2 * metadata.c: Routines for accessing the metadata
5 * Miguel de Icaza (miguel@ximian.com)
6 * Paolo Molaro (lupus@ximian.com)
8 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
9 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
18 #include "tabledefs.h"
19 #include "mono-endian.h"
21 #include "tokentype.h"
22 #include "metadata-internals.h"
23 #include "class-internals.h"
24 #include "verify-internals.h"
27 #include "debug-helpers.h"
28 #include "abi-details.h"
29 #include <mono/utils/mono-error-internals.h>
30 #include <mono/utils/bsearch.h>
32 /* Auxiliary structure used for caching inflated signatures */
34 MonoMethodSignature
*sig
;
35 MonoGenericContext context
;
36 } MonoInflatedMethodSignature
;
38 static gboolean
do_mono_metadata_parse_type (MonoType
*type
, MonoImage
*m
, MonoGenericContainer
*container
, gboolean transient
,
39 const char *ptr
, const char **rptr
);
41 static gboolean
do_mono_metadata_type_equal (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
);
42 static gboolean
mono_metadata_class_equal (MonoClass
*c1
, MonoClass
*c2
, gboolean signature_only
);
43 static gboolean
mono_metadata_fnptr_equal (MonoMethodSignature
*s1
, MonoMethodSignature
*s2
, gboolean signature_only
);
44 static gboolean
_mono_metadata_generic_class_equal (const MonoGenericClass
*g1
, const MonoGenericClass
*g2
,
45 gboolean signature_only
);
46 static void free_generic_inst (MonoGenericInst
*ginst
);
47 static void free_generic_class (MonoGenericClass
*ginst
);
48 static void free_inflated_method (MonoMethodInflated
*method
);
49 static void free_inflated_signature (MonoInflatedMethodSignature
*sig
);
50 static void mono_metadata_field_info_full (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
, MonoMarshalSpec
**marshal_spec
, gboolean alloc_from_image
);
51 static guint
mono_metadata_generic_param_hash (MonoGenericParam
*p
);
54 * This enumeration is used to describe the data types in the metadata
65 /* Index into Blob heap */
68 /* Index into String heap */
74 /* Pointer into a table */
77 /* HasConstant:Parent pointer (Param, Field or Property) */
80 /* HasCustomAttribute index. Indexes any table except CustomAttribute */
83 /* CustomAttributeType encoded index */
86 /* HasDeclSecurity index: TypeDef Method or Assembly */
89 /* Implementation coded index: File, Export AssemblyRef */
92 /* HasFieldMarshal coded index: Field or Param table */
95 /* MemberForwardedIndex: Field or Method */
98 /* TypeDefOrRef coded index: typedef, typeref, typespec */
101 /* MemberRefParent coded index: typeref, moduleref, method, memberref, typesepc, typedef */
104 /* MethodDefOrRef coded index: Method or Member Ref table */
107 /* HasSemantic coded index: Event or Property */
110 /* ResolutionScope coded index: Module, ModuleRef, AssemblytRef, TypeRef */
114 const static unsigned char TableSchemas
[] = {
115 #define ASSEMBLY_SCHEMA_OFFSET 0
116 MONO_MT_UINT32
, /* "HashId" }, */
117 MONO_MT_UINT16
, /* "Major" }, */
118 MONO_MT_UINT16
, /* "Minor" }, */
119 MONO_MT_UINT16
, /* "BuildNumber" }, */
120 MONO_MT_UINT16
, /* "RevisionNumber" }, */
121 MONO_MT_UINT32
, /* "Flags" }, */
122 MONO_MT_BLOB_IDX
, /* "PublicKey" }, */
123 MONO_MT_STRING_IDX
, /* "Name" }, */
124 MONO_MT_STRING_IDX
, /* "Culture" }, */
127 #define ASSEMBLYOS_SCHEMA_OFFSET ASSEMBLY_SCHEMA_OFFSET + 10
128 MONO_MT_UINT32
, /* "OSPlatformID" }, */
129 MONO_MT_UINT32
, /* "OSMajor" }, */
130 MONO_MT_UINT32
, /* "OSMinor" }, */
133 #define ASSEMBLYPROC_SCHEMA_OFFSET ASSEMBLYOS_SCHEMA_OFFSET + 4
134 MONO_MT_UINT32
, /* "Processor" }, */
137 #define ASSEMBLYREF_SCHEMA_OFFSET ASSEMBLYPROC_SCHEMA_OFFSET + 2
138 MONO_MT_UINT16
, /* "Major" }, */
139 MONO_MT_UINT16
, /* "Minor" }, */
140 MONO_MT_UINT16
, /* "Build" }, */
141 MONO_MT_UINT16
, /* "Revision" }, */
142 MONO_MT_UINT32
, /* "Flags" }, */
143 MONO_MT_BLOB_IDX
, /* "PublicKeyOrToken" }, */
144 MONO_MT_STRING_IDX
, /* "Name" }, */
145 MONO_MT_STRING_IDX
, /* "Culture" }, */
146 MONO_MT_BLOB_IDX
, /* "HashValue" }, */
149 #define ASSEMBLYREFOS_SCHEMA_OFFSET ASSEMBLYREF_SCHEMA_OFFSET + 10
150 MONO_MT_UINT32
, /* "OSPlatformID" }, */
151 MONO_MT_UINT32
, /* "OSMajorVersion" }, */
152 MONO_MT_UINT32
, /* "OSMinorVersion" }, */
153 MONO_MT_TABLE_IDX
, /* "AssemblyRef:AssemblyRef" }, */
156 #define ASSEMBLYREFPROC_SCHEMA_OFFSET ASSEMBLYREFOS_SCHEMA_OFFSET + 5
157 MONO_MT_UINT32
, /* "Processor" }, */
158 MONO_MT_TABLE_IDX
, /* "AssemblyRef:AssemblyRef" }, */
161 #define CLASS_LAYOUT_SCHEMA_OFFSET ASSEMBLYREFPROC_SCHEMA_OFFSET + 3
162 MONO_MT_UINT16
, /* "PackingSize" }, */
163 MONO_MT_UINT32
, /* "ClassSize" }, */
164 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
167 #define CONSTANT_SCHEMA_OFFSET CLASS_LAYOUT_SCHEMA_OFFSET + 4
168 MONO_MT_UINT8
, /* "Type" }, */
169 MONO_MT_UINT8
, /* "PaddingZero" }, */
170 MONO_MT_CONST_IDX
, /* "Parent" }, */
171 MONO_MT_BLOB_IDX
, /* "Value" }, */
174 #define CUSTOM_ATTR_SCHEMA_OFFSET CONSTANT_SCHEMA_OFFSET + 5
175 MONO_MT_HASCAT_IDX
, /* "Parent" }, */
176 MONO_MT_CAT_IDX
, /* "Type" }, */
177 MONO_MT_BLOB_IDX
, /* "Value" }, */
180 #define DECL_SEC_SCHEMA_OFFSET CUSTOM_ATTR_SCHEMA_OFFSET + 4
181 MONO_MT_UINT16
, /* "Action" }, */
182 MONO_MT_HASDEC_IDX
, /* "Parent" }, */
183 MONO_MT_BLOB_IDX
, /* "PermissionSet" }, */
186 #define EVENTMAP_SCHEMA_OFFSET DECL_SEC_SCHEMA_OFFSET + 4
187 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
188 MONO_MT_TABLE_IDX
, /* "EventList:Event" }, */
191 #define EVENT_SCHEMA_OFFSET EVENTMAP_SCHEMA_OFFSET + 3
192 MONO_MT_UINT16
, /* "EventFlags#EventAttribute" }, */
193 MONO_MT_STRING_IDX
, /* "Name" }, */
194 MONO_MT_TDOR_IDX
, /* "EventType" }, TypeDef or TypeRef or TypeSpec */
197 #define EVENT_POINTER_SCHEMA_OFFSET EVENT_SCHEMA_OFFSET + 4
198 MONO_MT_TABLE_IDX
, /* "Event" }, */
201 #define EXPORTED_TYPE_SCHEMA_OFFSET EVENT_POINTER_SCHEMA_OFFSET + 2
202 MONO_MT_UINT32
, /* "Flags" }, */
203 MONO_MT_TABLE_IDX
, /* "TypeDefId" }, */
204 MONO_MT_STRING_IDX
, /* "TypeName" }, */
205 MONO_MT_STRING_IDX
, /* "TypeNameSpace" }, */
206 MONO_MT_IMPL_IDX
, /* "Implementation" }, */
209 #define FIELD_SCHEMA_OFFSET EXPORTED_TYPE_SCHEMA_OFFSET + 6
210 MONO_MT_UINT16
, /* "Flags" }, */
211 MONO_MT_STRING_IDX
, /* "Name" }, */
212 MONO_MT_BLOB_IDX
, /* "Signature" }, */
215 #define FIELD_LAYOUT_SCHEMA_OFFSET FIELD_SCHEMA_OFFSET + 4
216 MONO_MT_UINT32
, /* "Offset" }, */
217 MONO_MT_TABLE_IDX
, /* "Field:Field" }, */
220 #define FIELD_MARSHAL_SCHEMA_OFFSET FIELD_LAYOUT_SCHEMA_OFFSET + 3
221 MONO_MT_HFM_IDX
, /* "Parent" }, */
222 MONO_MT_BLOB_IDX
, /* "NativeType" }, */
225 #define FIELD_RVA_SCHEMA_OFFSET FIELD_MARSHAL_SCHEMA_OFFSET + 3
226 MONO_MT_UINT32
, /* "RVA" }, */
227 MONO_MT_TABLE_IDX
, /* "Field:Field" }, */
230 #define FIELD_POINTER_SCHEMA_OFFSET FIELD_RVA_SCHEMA_OFFSET + 3
231 MONO_MT_TABLE_IDX
, /* "Field" }, */
234 #define FILE_SCHEMA_OFFSET FIELD_POINTER_SCHEMA_OFFSET + 2
235 MONO_MT_UINT32
, /* "Flags" }, */
236 MONO_MT_STRING_IDX
, /* "Name" }, */
237 MONO_MT_BLOB_IDX
, /* "Value" }, */
240 #define IMPLMAP_SCHEMA_OFFSET FILE_SCHEMA_OFFSET + 4
241 MONO_MT_UINT16
, /* "MappingFlag" }, */
242 MONO_MT_MF_IDX
, /* "MemberForwarded" }, */
243 MONO_MT_STRING_IDX
, /* "ImportName" }, */
244 MONO_MT_TABLE_IDX
, /* "ImportScope:ModuleRef" }, */
247 #define IFACEMAP_SCHEMA_OFFSET IMPLMAP_SCHEMA_OFFSET + 5
248 MONO_MT_TABLE_IDX
, /* "Class:TypeDef" }, */
249 MONO_MT_TDOR_IDX
, /* "Interface=TypeDefOrRef" }, */
252 #define MANIFEST_SCHEMA_OFFSET IFACEMAP_SCHEMA_OFFSET + 3
253 MONO_MT_UINT32
, /* "Offset" }, */
254 MONO_MT_UINT32
, /* "Flags" }, */
255 MONO_MT_STRING_IDX
, /* "Name" }, */
256 MONO_MT_IMPL_IDX
, /* "Implementation" }, */
259 #define MEMBERREF_SCHEMA_OFFSET MANIFEST_SCHEMA_OFFSET + 5
260 MONO_MT_MRP_IDX
, /* "Class" }, */
261 MONO_MT_STRING_IDX
, /* "Name" }, */
262 MONO_MT_BLOB_IDX
, /* "Signature" }, */
265 #define METHOD_SCHEMA_OFFSET MEMBERREF_SCHEMA_OFFSET + 4
266 MONO_MT_UINT32
, /* "RVA" }, */
267 MONO_MT_UINT16
, /* "ImplFlags#MethodImplAttributes" }, */
268 MONO_MT_UINT16
, /* "Flags#MethodAttribute" }, */
269 MONO_MT_STRING_IDX
, /* "Name" }, */
270 MONO_MT_BLOB_IDX
, /* "Signature" }, */
271 MONO_MT_TABLE_IDX
, /* "ParamList:Param" }, */
274 #define METHOD_IMPL_SCHEMA_OFFSET METHOD_SCHEMA_OFFSET + 7
275 MONO_MT_TABLE_IDX
, /* "Class:TypeDef" }, */
276 MONO_MT_MDOR_IDX
, /* "MethodBody" }, */
277 MONO_MT_MDOR_IDX
, /* "MethodDeclaration" }, */
280 #define METHOD_SEMA_SCHEMA_OFFSET METHOD_IMPL_SCHEMA_OFFSET + 4
281 MONO_MT_UINT16
, /* "MethodSemantic" }, */
282 MONO_MT_TABLE_IDX
, /* "Method:Method" }, */
283 MONO_MT_HS_IDX
, /* "Association" }, */
286 #define METHOD_POINTER_SCHEMA_OFFSET METHOD_SEMA_SCHEMA_OFFSET + 4
287 MONO_MT_TABLE_IDX
, /* "Method" }, */
290 #define MODULE_SCHEMA_OFFSET METHOD_POINTER_SCHEMA_OFFSET + 2
291 MONO_MT_UINT16
, /* "Generation" }, */
292 MONO_MT_STRING_IDX
, /* "Name" }, */
293 MONO_MT_GUID_IDX
, /* "MVID" }, */
294 MONO_MT_GUID_IDX
, /* "EncID" }, */
295 MONO_MT_GUID_IDX
, /* "EncBaseID" }, */
298 #define MODULEREF_SCHEMA_OFFSET MODULE_SCHEMA_OFFSET + 6
299 MONO_MT_STRING_IDX
, /* "Name" }, */
302 #define NESTED_CLASS_SCHEMA_OFFSET MODULEREF_SCHEMA_OFFSET + 2
303 MONO_MT_TABLE_IDX
, /* "NestedClass:TypeDef" }, */
304 MONO_MT_TABLE_IDX
, /* "EnclosingClass:TypeDef" }, */
307 #define PARAM_SCHEMA_OFFSET NESTED_CLASS_SCHEMA_OFFSET + 3
308 MONO_MT_UINT16
, /* "Flags" }, */
309 MONO_MT_UINT16
, /* "Sequence" }, */
310 MONO_MT_STRING_IDX
, /* "Name" }, */
313 #define PARAM_POINTER_SCHEMA_OFFSET PARAM_SCHEMA_OFFSET + 4
314 MONO_MT_TABLE_IDX
, /* "Param" }, */
317 #define PROPERTY_SCHEMA_OFFSET PARAM_POINTER_SCHEMA_OFFSET + 2
318 MONO_MT_UINT16
, /* "Flags" }, */
319 MONO_MT_STRING_IDX
, /* "Name" }, */
320 MONO_MT_BLOB_IDX
, /* "Type" }, */
323 #define PROPERTY_POINTER_SCHEMA_OFFSET PROPERTY_SCHEMA_OFFSET + 4
324 MONO_MT_TABLE_IDX
, /* "Property" }, */
327 #define PROPERTY_MAP_SCHEMA_OFFSET PROPERTY_POINTER_SCHEMA_OFFSET + 2
328 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
329 MONO_MT_TABLE_IDX
, /* "PropertyList:Property" }, */
332 #define STDALON_SIG_SCHEMA_OFFSET PROPERTY_MAP_SCHEMA_OFFSET + 3
333 MONO_MT_BLOB_IDX
, /* "Signature" }, */
336 #define TYPEDEF_SCHEMA_OFFSET STDALON_SIG_SCHEMA_OFFSET + 2
337 MONO_MT_UINT32
, /* "Flags" }, */
338 MONO_MT_STRING_IDX
, /* "Name" }, */
339 MONO_MT_STRING_IDX
, /* "Namespace" }, */
340 MONO_MT_TDOR_IDX
, /* "Extends" }, */
341 MONO_MT_TABLE_IDX
, /* "FieldList:Field" }, */
342 MONO_MT_TABLE_IDX
, /* "MethodList:Method" }, */
345 #define TYPEREF_SCHEMA_OFFSET TYPEDEF_SCHEMA_OFFSET + 7
346 MONO_MT_RS_IDX
, /* "ResolutionScope=ResolutionScope" }, */
347 MONO_MT_STRING_IDX
, /* "Name" }, */
348 MONO_MT_STRING_IDX
, /* "Namespace" }, */
351 #define TYPESPEC_SCHEMA_OFFSET TYPEREF_SCHEMA_OFFSET + 4
352 MONO_MT_BLOB_IDX
, /* "Signature" }, */
355 #define GENPARAM_SCHEMA_OFFSET TYPESPEC_SCHEMA_OFFSET + 2
356 MONO_MT_UINT16
, /* "Number" }, */
357 MONO_MT_UINT16
, /* "Flags" }, */
358 MONO_MT_TABLE_IDX
, /* "Owner" }, TypeDef or MethodDef */
359 MONO_MT_STRING_IDX
, /* "Name" }, */
362 #define METHOD_SPEC_SCHEMA_OFFSET GENPARAM_SCHEMA_OFFSET + 5
363 MONO_MT_MDOR_IDX
, /* "Method" }, */
364 MONO_MT_BLOB_IDX
, /* "Signature" }, */
367 #define GEN_CONSTRAINT_SCHEMA_OFFSET METHOD_SPEC_SCHEMA_OFFSET + 3
368 MONO_MT_TABLE_IDX
, /* "GenericParam" }, */
369 MONO_MT_TDOR_IDX
, /* "Constraint" }, */
372 #define NULL_SCHEMA_OFFSET GEN_CONSTRAINT_SCHEMA_OFFSET + 3
376 /* Must be the same order as MONO_TABLE_* */
377 const static unsigned char
378 table_description
[] = {
379 MODULE_SCHEMA_OFFSET
,
380 TYPEREF_SCHEMA_OFFSET
,
381 TYPEDEF_SCHEMA_OFFSET
,
382 FIELD_POINTER_SCHEMA_OFFSET
,
384 METHOD_POINTER_SCHEMA_OFFSET
,
385 METHOD_SCHEMA_OFFSET
,
386 PARAM_POINTER_SCHEMA_OFFSET
,
388 IFACEMAP_SCHEMA_OFFSET
,
389 MEMBERREF_SCHEMA_OFFSET
, /* 0xa */
390 CONSTANT_SCHEMA_OFFSET
,
391 CUSTOM_ATTR_SCHEMA_OFFSET
,
392 FIELD_MARSHAL_SCHEMA_OFFSET
,
393 DECL_SEC_SCHEMA_OFFSET
,
394 CLASS_LAYOUT_SCHEMA_OFFSET
,
395 FIELD_LAYOUT_SCHEMA_OFFSET
, /* 0x10 */
396 STDALON_SIG_SCHEMA_OFFSET
,
397 EVENTMAP_SCHEMA_OFFSET
,
398 EVENT_POINTER_SCHEMA_OFFSET
,
400 PROPERTY_MAP_SCHEMA_OFFSET
,
401 PROPERTY_POINTER_SCHEMA_OFFSET
,
402 PROPERTY_SCHEMA_OFFSET
,
403 METHOD_SEMA_SCHEMA_OFFSET
,
404 METHOD_IMPL_SCHEMA_OFFSET
,
405 MODULEREF_SCHEMA_OFFSET
, /* 0x1a */
406 TYPESPEC_SCHEMA_OFFSET
,
407 IMPLMAP_SCHEMA_OFFSET
,
408 FIELD_RVA_SCHEMA_OFFSET
,
411 ASSEMBLY_SCHEMA_OFFSET
, /* 0x20 */
412 ASSEMBLYPROC_SCHEMA_OFFSET
,
413 ASSEMBLYOS_SCHEMA_OFFSET
,
414 ASSEMBLYREF_SCHEMA_OFFSET
,
415 ASSEMBLYREFPROC_SCHEMA_OFFSET
,
416 ASSEMBLYREFOS_SCHEMA_OFFSET
,
418 EXPORTED_TYPE_SCHEMA_OFFSET
,
419 MANIFEST_SCHEMA_OFFSET
,
420 NESTED_CLASS_SCHEMA_OFFSET
,
421 GENPARAM_SCHEMA_OFFSET
, /* 0x2a */
422 METHOD_SPEC_SCHEMA_OFFSET
,
423 GEN_CONSTRAINT_SCHEMA_OFFSET
426 #ifdef HAVE_ARRAY_ELEM_INIT
427 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
428 #define MSGSTRFIELD1(line) str##line
429 static const struct msgstr_t
{
430 #define TABLEDEF(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
431 #include "mono/cil/tables.def"
434 #define TABLEDEF(a,b) b,
435 #include "mono/cil/tables.def"
438 static const gint16 tableidx
[] = {
439 #define TABLEDEF(a,b) [a] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
440 #include "mono/cil/tables.def"
445 #define TABLEDEF(a,b) b,
446 static const char* const
447 mono_tables_names
[] = {
448 #include "mono/cil/tables.def"
455 * mono_meta_table_name:
456 * @table: table index
458 * Returns the name of the given ECMA metadata logical format table
459 * as described in ECMA 335, Partition II, Section 22.
461 * Returns: the name for the @table index
464 mono_meta_table_name (int table
)
466 if ((table
< 0) || (table
> MONO_TABLE_LAST
))
469 #ifdef HAVE_ARRAY_ELEM_INIT
470 return (const char*)&tablestr
+ tableidx
[table
];
472 return mono_tables_names
[table
];
476 /* The guy who wrote the spec for this should not be allowed near a
479 If e is a coded token(see clause 23.1.7) that points into table ti out of n possible tables t0, .. tn-1,
480 then it is stored as e << (log n) & tag{ t0, .. tn-1}[ ti] using 2 bytes if the maximum number of
481 rows of tables t0, ..tn-1, is less than 2^16 - (log n), and using 4 bytes otherwise. The family of
482 finite maps tag{ t0, ..tn-1} is defined below. Note that to decode a physical row, you need the
483 inverse of this mapping.
486 #define rtsize(s,b) (((s) < (1 << (b)) ? 2 : 4))
487 #define idx_size(tableidx) (meta->tables [(tableidx)].rows < 65536 ? 2 : 4)
489 /* Reference: Partition II - 23.2.6 */
491 * mono_metadata_compute_size:
492 * @meta: metadata context
493 * @tableindex: metadata table number
494 * @result_bitfield: pointer to guint32 where to store additional info
496 * mono_metadata_compute_size() computes the lenght in bytes of a single
497 * row in a metadata table. The size of each column is encoded in the
498 * @result_bitfield return value along with the number of columns in the table.
499 * the resulting bitfield should be handed to the mono_metadata_table_size()
500 * and mono_metadata_table_count() macros.
501 * This is a Mono runtime internal only function.
504 mono_metadata_compute_size (MonoImage
*meta
, int tableindex
, guint32
*result_bitfield
)
506 guint32 bitfield
= 0;
507 int size
= 0, field_size
= 0;
510 const unsigned char *description
= TableSchemas
+ table_description
[tableindex
];
512 for (i
= 0; (code
= description
[i
]) != MONO_MT_END
; i
++){
515 field_size
= 4; break;
518 field_size
= 2; break;
521 field_size
= 1; break;
523 case MONO_MT_BLOB_IDX
:
524 field_size
= meta
->idx_blob_wide
? 4 : 2; break;
526 case MONO_MT_STRING_IDX
:
527 field_size
= meta
->idx_string_wide
? 4 : 2; break;
529 case MONO_MT_GUID_IDX
:
530 field_size
= meta
->idx_guid_wide
? 4 : 2; break;
532 case MONO_MT_TABLE_IDX
:
533 /* Uhm, a table index can point to other tables besides the current one
534 * so, it's not correct to use the rowcount of the current table to
535 * get the size for this column - lupus
537 switch (tableindex
) {
538 case MONO_TABLE_ASSEMBLYREFOS
:
540 field_size
= idx_size (MONO_TABLE_ASSEMBLYREF
); break;
541 case MONO_TABLE_ASSEMBLYREFPROCESSOR
:
543 field_size
= idx_size (MONO_TABLE_ASSEMBLYREF
); break;
544 case MONO_TABLE_CLASSLAYOUT
:
546 field_size
= idx_size (MONO_TABLE_TYPEDEF
); break;
547 case MONO_TABLE_EVENTMAP
:
548 g_assert (i
== 0 || i
== 1);
549 field_size
= i
? idx_size (MONO_TABLE_EVENT
):
550 idx_size(MONO_TABLE_TYPEDEF
);
552 case MONO_TABLE_EVENT_POINTER
:
554 field_size
= idx_size (MONO_TABLE_EVENT
); break;
555 case MONO_TABLE_EXPORTEDTYPE
:
557 /* the index is in another metadata file, so it must be 4 */
558 field_size
= 4; break;
559 case MONO_TABLE_FIELDLAYOUT
:
561 field_size
= idx_size (MONO_TABLE_FIELD
); break;
562 case MONO_TABLE_FIELDRVA
:
564 field_size
= idx_size (MONO_TABLE_FIELD
); break;
565 case MONO_TABLE_FIELD_POINTER
:
567 field_size
= idx_size (MONO_TABLE_FIELD
); break;
568 case MONO_TABLE_IMPLMAP
:
570 field_size
= idx_size (MONO_TABLE_MODULEREF
); break;
571 case MONO_TABLE_INTERFACEIMPL
:
573 field_size
= idx_size (MONO_TABLE_TYPEDEF
); break;
574 case MONO_TABLE_METHOD
:
576 field_size
= idx_size (MONO_TABLE_PARAM
); break;
577 case MONO_TABLE_METHODIMPL
:
579 field_size
= idx_size (MONO_TABLE_TYPEDEF
); break;
580 case MONO_TABLE_METHODSEMANTICS
:
582 field_size
= idx_size (MONO_TABLE_METHOD
); break;
583 case MONO_TABLE_METHOD_POINTER
:
585 field_size
= idx_size (MONO_TABLE_METHOD
); break;
586 case MONO_TABLE_NESTEDCLASS
:
587 g_assert (i
== 0 || i
== 1);
588 field_size
= idx_size (MONO_TABLE_TYPEDEF
); break;
589 case MONO_TABLE_PARAM_POINTER
:
591 field_size
= idx_size (MONO_TABLE_PARAM
); break;
592 case MONO_TABLE_PROPERTYMAP
:
593 g_assert (i
== 0 || i
== 1);
594 field_size
= i
? idx_size (MONO_TABLE_PROPERTY
):
595 idx_size(MONO_TABLE_TYPEDEF
);
597 case MONO_TABLE_PROPERTY_POINTER
:
599 field_size
= idx_size (MONO_TABLE_PROPERTY
); break;
600 case MONO_TABLE_TYPEDEF
:
601 g_assert (i
== 4 || i
== 5);
602 field_size
= i
== 4 ? idx_size (MONO_TABLE_FIELD
):
603 idx_size(MONO_TABLE_METHOD
);
605 case MONO_TABLE_GENERICPARAM
:
607 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
, meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
608 /*This is a coded token for 2 tables, so takes 1 bit */
609 field_size
= rtsize (n
, 16 - MONO_TYPEORMETHOD_BITS
);
611 case MONO_TABLE_GENERICPARAMCONSTRAINT
:
613 field_size
= idx_size (MONO_TABLE_GENERICPARAM
);
617 g_error ("Can't handle MONO_MT_TABLE_IDX for table %d element %d", tableindex
, i
);
622 * HasConstant: ParamDef, FieldDef, Property
624 case MONO_MT_CONST_IDX
:
625 n
= MAX (meta
->tables
[MONO_TABLE_PARAM
].rows
,
626 meta
->tables
[MONO_TABLE_FIELD
].rows
);
627 n
= MAX (n
, meta
->tables
[MONO_TABLE_PROPERTY
].rows
);
629 /* 2 bits to encode tag */
630 field_size
= rtsize (n
, 16-2);
634 * HasCustomAttribute: points to any table but
637 case MONO_MT_HASCAT_IDX
:
639 * We believe that since the signature and
640 * permission are indexing the Blob heap,
641 * we should consider the blob size first
643 /* I'm not a believer - lupus
644 if (meta->idx_blob_wide){
649 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
,
650 meta
->tables
[MONO_TABLE_FIELD
].rows
);
651 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
652 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
653 n
= MAX (n
, meta
->tables
[MONO_TABLE_PARAM
].rows
);
654 n
= MAX (n
, meta
->tables
[MONO_TABLE_INTERFACEIMPL
].rows
);
655 n
= MAX (n
, meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
656 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULE
].rows
);
657 n
= MAX (n
, meta
->tables
[MONO_TABLE_DECLSECURITY
].rows
);
658 n
= MAX (n
, meta
->tables
[MONO_TABLE_PROPERTY
].rows
);
659 n
= MAX (n
, meta
->tables
[MONO_TABLE_EVENT
].rows
);
660 n
= MAX (n
, meta
->tables
[MONO_TABLE_STANDALONESIG
].rows
);
661 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
662 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
663 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLY
].rows
);
664 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
665 n
= MAX (n
, meta
->tables
[MONO_TABLE_FILE
].rows
);
666 n
= MAX (n
, meta
->tables
[MONO_TABLE_EXPORTEDTYPE
].rows
);
667 n
= MAX (n
, meta
->tables
[MONO_TABLE_MANIFESTRESOURCE
].rows
);
669 /* 5 bits to encode */
670 field_size
= rtsize (n
, 16-5);
674 * CustomAttributeType: TypeDef, TypeRef, MethodDef,
675 * MemberRef and String.
677 case MONO_MT_CAT_IDX
:
678 /* String is a heap, if it is wide, we know the size */
680 if (meta->idx_string_wide){
685 n
= MAX (meta
->tables
[MONO_TABLE_TYPEREF
].rows
,
686 meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
687 n
= MAX (n
, meta
->tables
[MONO_TABLE_METHOD
].rows
);
688 n
= MAX (n
, meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
690 /* 3 bits to encode */
691 field_size
= rtsize (n
, 16-3);
695 * HasDeclSecurity: Typedef, MethodDef, Assembly
697 case MONO_MT_HASDEC_IDX
:
698 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
699 meta
->tables
[MONO_TABLE_METHOD
].rows
);
700 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLY
].rows
);
702 /* 2 bits to encode */
703 field_size
= rtsize (n
, 16-2);
707 * Implementation: File, AssemblyRef, ExportedType
709 case MONO_MT_IMPL_IDX
:
710 n
= MAX (meta
->tables
[MONO_TABLE_FILE
].rows
,
711 meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
712 n
= MAX (n
, meta
->tables
[MONO_TABLE_EXPORTEDTYPE
].rows
);
714 /* 2 bits to encode tag */
715 field_size
= rtsize (n
, 16-2);
719 * HasFieldMarshall: FieldDef, ParamDef
721 case MONO_MT_HFM_IDX
:
722 n
= MAX (meta
->tables
[MONO_TABLE_FIELD
].rows
,
723 meta
->tables
[MONO_TABLE_PARAM
].rows
);
725 /* 1 bit used to encode tag */
726 field_size
= rtsize (n
, 16-1);
730 * MemberForwarded: FieldDef, MethodDef
733 n
= MAX (meta
->tables
[MONO_TABLE_FIELD
].rows
,
734 meta
->tables
[MONO_TABLE_METHOD
].rows
);
736 /* 1 bit used to encode tag */
737 field_size
= rtsize (n
, 16-1);
741 * TypeDefOrRef: TypeDef, ParamDef, TypeSpec
743 * It is TypeDef, _TypeRef_, TypeSpec, instead.
745 case MONO_MT_TDOR_IDX
:
746 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
747 meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
748 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
750 /* 2 bits to encode */
751 field_size
= rtsize (n
, 16-2);
755 * MemberRefParent: TypeDef, TypeRef, MethodDef, ModuleRef, TypeSpec, MemberRef
757 case MONO_MT_MRP_IDX
:
758 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
759 meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
760 n
= MAX (n
, meta
->tables
[MONO_TABLE_METHOD
].rows
);
761 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
762 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
764 /* 3 bits to encode */
765 field_size
= rtsize (n
, 16 - 3);
769 * MethodDefOrRef: MethodDef, MemberRef
771 case MONO_MT_MDOR_IDX
:
772 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
,
773 meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
775 /* 1 bit used to encode tag */
776 field_size
= rtsize (n
, 16-1);
780 * HasSemantics: Property, Event
783 n
= MAX (meta
->tables
[MONO_TABLE_PROPERTY
].rows
,
784 meta
->tables
[MONO_TABLE_EVENT
].rows
);
786 /* 1 bit used to encode tag */
787 field_size
= rtsize (n
, 16-1);
791 * ResolutionScope: Module, ModuleRef, AssemblyRef, TypeRef
794 n
= MAX (meta
->tables
[MONO_TABLE_MODULE
].rows
,
795 meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
796 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
797 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
799 /* 2 bits used to encode tag (ECMA spec claims 3) */
800 field_size
= rtsize (n
, 16 - 2);
805 * encode field size as follows (we just need to
812 bitfield
|= (field_size
-1) << shift
;
815 /*g_print ("table %02x field %d size %d\n", tableindex, i, field_size);*/
818 *result_bitfield
= (i
<< 24) | bitfield
;
823 * mono_metadata_compute_table_bases:
824 * @meta: metadata context to compute table values
826 * Computes the table bases for the metadata structure.
827 * This is an internal function used by the image loader code.
830 mono_metadata_compute_table_bases (MonoImage
*meta
)
833 const char *base
= meta
->tables_base
;
835 for (i
= 0; i
< MONO_TABLE_NUM
; i
++) {
836 MonoTableInfo
*table
= &meta
->tables
[i
];
837 if (table
->rows
== 0)
840 table
->row_size
= mono_metadata_compute_size (meta
, i
, &table
->size_bitfield
);
842 base
+= table
->rows
* table
->row_size
;
847 * mono_metadata_locate:
848 * @meta: metadata context
849 * @table: table code.
850 * @idx: index of element to retrieve from @table.
852 * Returns: a pointer to the @idx element in the metadata table
853 * whose code is @table.
856 mono_metadata_locate (MonoImage
*meta
, int table
, int idx
)
858 /* idx == 0 refers always to NULL */
859 g_return_val_if_fail (idx
> 0 && idx
<= meta
->tables
[table
].rows
, ""); /*FIXME shouldn't we return NULL here?*/
861 return meta
->tables
[table
].base
+ (meta
->tables
[table
].row_size
* (idx
- 1));
865 * mono_metadata_locate_token:
866 * @meta: metadata context
867 * @token: metadata token
869 * Returns: a pointer to the data in the metadata represented by the
873 mono_metadata_locate_token (MonoImage
*meta
, guint32 token
)
875 return mono_metadata_locate (meta
, token
>> 24, token
& 0xffffff);
879 * mono_metadata_string_heap:
880 * @meta: metadata context
881 * @index: index into the string heap.
883 * Returns: an in-memory pointer to the @index in the string heap.
886 mono_metadata_string_heap (MonoImage
*meta
, guint32 index
)
888 g_assert (index
< meta
->heap_strings
.size
);
889 g_return_val_if_fail (index
< meta
->heap_strings
.size
, "");
890 return meta
->heap_strings
.data
+ index
;
894 * mono_metadata_user_string:
895 * @meta: metadata context
896 * @index: index into the user string heap.
898 * Returns: an in-memory pointer to the @index in the user string heap ("#US").
901 mono_metadata_user_string (MonoImage
*meta
, guint32 index
)
903 g_assert (index
< meta
->heap_us
.size
);
904 g_return_val_if_fail (index
< meta
->heap_us
.size
, "");
905 return meta
->heap_us
.data
+ index
;
909 * mono_metadata_blob_heap:
910 * @meta: metadata context
911 * @index: index into the blob.
913 * Returns: an in-memory pointer to the @index in the Blob heap.
916 mono_metadata_blob_heap (MonoImage
*meta
, guint32 index
)
918 g_assert (index
< meta
->heap_blob
.size
);
919 g_return_val_if_fail (index
< meta
->heap_blob
.size
, "");/*FIXME shouldn't we return NULL and check for index == 0?*/
920 return meta
->heap_blob
.data
+ index
;
924 * mono_metadata_guid_heap:
925 * @meta: metadata context
926 * @index: index into the guid heap.
928 * Returns: an in-memory pointer to the @index in the guid heap.
931 mono_metadata_guid_heap (MonoImage
*meta
, guint32 index
)
934 index
*= 16; /* adjust for guid size and 1-based index */
935 g_return_val_if_fail (index
< meta
->heap_guid
.size
, "");
936 return meta
->heap_guid
.data
+ index
;
939 static const unsigned char *
940 dword_align (const unsigned char *ptr
)
942 #if SIZEOF_VOID_P == 8
943 return (const unsigned char *) (((guint64
) (ptr
+ 3)) & ~3);
945 return (const unsigned char *) (((guint32
) (ptr
+ 3)) & ~3);
950 * mono_metadata_decode_row:
951 * @t: table to extract information from.
952 * @idx: index in table.
953 * @res: array of @res_size cols to store the results in
955 * This decompresses the metadata element @idx in table @t
956 * into the guint32 @res array that has res_size elements
959 mono_metadata_decode_row (const MonoTableInfo
*t
, int idx
, guint32
*res
, int res_size
)
961 guint32 bitfield
= t
->size_bitfield
;
962 int i
, count
= mono_metadata_table_count (bitfield
);
965 g_assert (idx
< t
->rows
);
967 data
= t
->base
+ idx
* t
->row_size
;
969 g_assert (res_size
== count
);
971 for (i
= 0; i
< count
; i
++) {
972 int n
= mono_metadata_table_size (bitfield
, i
);
976 res
[i
] = *data
; break;
978 res
[i
] = read16 (data
); break;
980 res
[i
] = read32 (data
); break;
982 g_assert_not_reached ();
989 * mono_metadata_decode_row_col:
990 * @t: table to extract information from.
991 * @idx: index for row in table.
992 * @col: column in the row.
994 * This function returns the value of column @col from the @idx
995 * row in the table @t.
998 mono_metadata_decode_row_col (const MonoTableInfo
*t
, int idx
, guint col
)
1000 guint32 bitfield
= t
->size_bitfield
;
1002 register const char *data
;
1005 g_assert (idx
< t
->rows
);
1006 g_assert (col
< mono_metadata_table_count (bitfield
));
1007 data
= t
->base
+ idx
* t
->row_size
;
1009 n
= mono_metadata_table_size (bitfield
, 0);
1010 for (i
= 0; i
< col
; ++i
) {
1012 n
= mono_metadata_table_size (bitfield
, i
+ 1);
1018 return read16 (data
);
1020 return read32 (data
);
1022 g_assert_not_reached ();
1028 * mono_metadata_decode_blob_size:
1029 * @ptr: pointer to a blob object
1030 * @rptr: the new position of the pointer
1032 * This decodes a compressed size as described by 23.1.4 (a blob or user string object)
1034 * Returns: the size of the blob object
1037 mono_metadata_decode_blob_size (const char *xptr
, const char **rptr
)
1039 const unsigned char *ptr
= (const unsigned char *)xptr
;
1042 if ((*ptr
& 0x80) == 0){
1043 size
= ptr
[0] & 0x7f;
1045 } else if ((*ptr
& 0x40) == 0){
1046 size
= ((ptr
[0] & 0x3f) << 8) + ptr
[1];
1049 size
= ((ptr
[0] & 0x1f) << 24) +
1061 * mono_metadata_decode_value:
1062 * @ptr: pointer to decode from
1063 * @rptr: the new position of the pointer
1065 * This routine decompresses 32-bit values as specified in the "Blob and
1066 * Signature" section (22.2)
1068 * Returns: the decoded value
1071 mono_metadata_decode_value (const char *_ptr
, const char **rptr
)
1073 const unsigned char *ptr
= (const unsigned char *) _ptr
;
1074 unsigned char b
= *ptr
;
1077 if ((b
& 0x80) == 0){
1080 } else if ((b
& 0x40) == 0){
1081 len
= ((b
& 0x3f) << 8 | ptr
[1]);
1084 len
= ((b
& 0x1f) << 24) |
1097 * mono_metadata_decode_signed_value:
1098 * @ptr: pointer to decode from
1099 * @rptr: the new position of the pointer
1101 * This routine decompresses 32-bit signed values
1102 * (not specified in the spec)
1104 * Returns: the decoded value
1107 mono_metadata_decode_signed_value (const char *ptr
, const char **rptr
)
1109 guint32 uval
= mono_metadata_decode_value (ptr
, rptr
);
1110 gint32 ival
= uval
>> 1;
1113 /* ival is a truncated 2's complement negative number. */
1115 /* 6 bits = 7 bits for compressed representation (top bit is '0') - 1 sign bit */
1118 /* 13 bits = 14 bits for compressed representation (top bits are '10') - 1 sign bit */
1119 return ival
- 0x2000;
1120 if (ival
< 0x10000000)
1121 /* 28 bits = 29 bits for compressed representation (top bits are '110') - 1 sign bit */
1122 return ival
- 0x10000000;
1123 g_assert (ival
< 0x20000000);
1124 g_warning ("compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival
, uval
);
1125 return ival
- 0x20000000;
1129 * Translates the given 1-based index into the Method, Field, Event, or Param tables
1130 * using the *Ptr tables in uncompressed metadata, if they are available.
1132 * FIXME: The caller is not forced to call this function, which is error-prone, since
1133 * forgetting to call it would only show up as a bug on uncompressed metadata.
1136 mono_metadata_translate_token_index (MonoImage
*image
, int table
, guint32 idx
)
1138 if (!image
->uncompressed_metadata
)
1142 case MONO_TABLE_METHOD
:
1143 if (image
->tables
[MONO_TABLE_METHOD_POINTER
].rows
)
1144 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_METHOD_POINTER
], idx
- 1, MONO_METHOD_POINTER_METHOD
);
1147 case MONO_TABLE_FIELD
:
1148 if (image
->tables
[MONO_TABLE_FIELD_POINTER
].rows
)
1149 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_FIELD_POINTER
], idx
- 1, MONO_FIELD_POINTER_FIELD
);
1152 case MONO_TABLE_EVENT
:
1153 if (image
->tables
[MONO_TABLE_EVENT_POINTER
].rows
)
1154 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_EVENT_POINTER
], idx
- 1, MONO_EVENT_POINTER_EVENT
);
1157 case MONO_TABLE_PROPERTY
:
1158 if (image
->tables
[MONO_TABLE_PROPERTY_POINTER
].rows
)
1159 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_PROPERTY_POINTER
], idx
- 1, MONO_PROPERTY_POINTER_PROPERTY
);
1162 case MONO_TABLE_PARAM
:
1163 if (image
->tables
[MONO_TABLE_PARAM_POINTER
].rows
)
1164 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_PARAM_POINTER
], idx
- 1, MONO_PARAM_POINTER_PARAM
);
1173 * mono_metadata_decode_table_row:
1175 * Same as mono_metadata_decode_row, but takes an IMAGE+TABLE ID pair, and takes
1176 * uncompressed metadata into account, so it should be used to access the
1177 * Method, Field, Param and Event tables when the access is made from metadata, i.e.
1178 * IDX is retrieved from a metadata table, like MONO_TYPEDEF_FIELD_LIST.
1181 mono_metadata_decode_table_row (MonoImage
*image
, int table
, int idx
, guint32
*res
, int res_size
)
1183 if (image
->uncompressed_metadata
)
1184 idx
= mono_metadata_translate_token_index (image
, table
, idx
+ 1) - 1;
1186 mono_metadata_decode_row (&image
->tables
[table
], idx
, res
, res_size
);
1190 * mono_metadata_decode_table_row_col:
1192 * Same as mono_metadata_decode_row_col, but takes an IMAGE+TABLE ID pair, and takes
1193 * uncompressed metadata into account, so it should be used to access the
1194 * Method, Field, Param and Event tables.
1196 guint32
mono_metadata_decode_table_row_col (MonoImage
*image
, int table
, int idx
, guint col
)
1198 if (image
->uncompressed_metadata
)
1199 idx
= mono_metadata_translate_token_index (image
, table
, idx
+ 1) - 1;
1201 return mono_metadata_decode_row_col (&image
->tables
[table
], idx
, col
);
1205 * mono_metadata_parse_typedef_or_ref:
1206 * @m: a metadata context.
1207 * @ptr: a pointer to an encoded TypedefOrRef in @m
1208 * @rptr: pointer updated to match the end of the decoded stream
1210 * Returns: a token valid in the @m metadata decoded from
1211 * the compressed representation.
1214 mono_metadata_parse_typedef_or_ref (MonoImage
*m
, const char *ptr
, const char **rptr
)
1217 token
= mono_metadata_decode_value (ptr
, &ptr
);
1220 return mono_metadata_token_from_dor (token
);
1224 * mono_metadata_parse_custom_mod:
1225 * @m: a metadata context.
1226 * @dest: storage where the info about the custom modifier is stored (may be NULL)
1227 * @ptr: a pointer to (possibly) the start of a custom modifier list
1228 * @rptr: pointer updated to match the end of the decoded stream
1230 * Checks if @ptr points to a type custom modifier compressed representation.
1232 * Returns: #TRUE if a custom modifier was found, #FALSE if not.
1235 mono_metadata_parse_custom_mod (MonoImage
*m
, MonoCustomMod
*dest
, const char *ptr
, const char **rptr
)
1237 MonoCustomMod local
;
1238 if ((*ptr
== MONO_TYPE_CMOD_OPT
) || (*ptr
== MONO_TYPE_CMOD_REQD
)) {
1241 dest
->required
= *ptr
== MONO_TYPE_CMOD_REQD
? 1 : 0;
1242 dest
->token
= mono_metadata_parse_typedef_or_ref (m
, ptr
+ 1, rptr
);
1249 * mono_metadata_parse_array_internal:
1250 * @m: a metadata context.
1251 * @transient: whenever to allocate data from the heap
1252 * @ptr: a pointer to an encoded array description.
1253 * @rptr: pointer updated to match the end of the decoded stream
1255 * Decodes the compressed array description found in the metadata @m at @ptr.
1257 * Returns: a #MonoArrayType structure describing the array type
1258 * and dimensions. Memory is allocated from the heap or from the image mempool, depending
1259 * on the value of @transient.
1261 * LOCKING: Acquires the loader lock
1263 static MonoArrayType
*
1264 mono_metadata_parse_array_internal (MonoImage
*m
, MonoGenericContainer
*container
,
1265 gboolean transient
, const char *ptr
, const char **rptr
)
1268 MonoArrayType
*array
;
1271 array
= transient
? g_malloc0 (sizeof (MonoArrayType
)) : mono_image_alloc0 (m
, sizeof (MonoArrayType
));
1272 etype
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
1275 array
->eklass
= mono_class_from_mono_type (etype
);
1276 array
->rank
= mono_metadata_decode_value (ptr
, &ptr
);
1278 array
->numsizes
= mono_metadata_decode_value (ptr
, &ptr
);
1279 if (array
->numsizes
)
1280 array
->sizes
= transient
? g_malloc0 (sizeof (int) * array
->numsizes
) : mono_image_alloc0 (m
, sizeof (int) * array
->numsizes
);
1281 for (i
= 0; i
< array
->numsizes
; ++i
)
1282 array
->sizes
[i
] = mono_metadata_decode_value (ptr
, &ptr
);
1284 array
->numlobounds
= mono_metadata_decode_value (ptr
, &ptr
);
1285 if (array
->numlobounds
)
1286 array
->lobounds
= transient
? g_malloc0 (sizeof (int) * array
->numlobounds
) : mono_image_alloc0 (m
, sizeof (int) * array
->numlobounds
);
1287 for (i
= 0; i
< array
->numlobounds
; ++i
)
1288 array
->lobounds
[i
] = mono_metadata_decode_signed_value (ptr
, &ptr
);
1296 mono_metadata_parse_array_full (MonoImage
*m
, MonoGenericContainer
*container
,
1297 const char *ptr
, const char **rptr
)
1299 return mono_metadata_parse_array_internal (m
, container
, FALSE
, ptr
, rptr
);
1303 mono_metadata_parse_array (MonoImage
*m
, const char *ptr
, const char **rptr
)
1305 return mono_metadata_parse_array_full (m
, NULL
, ptr
, rptr
);
1309 * mono_metadata_free_array:
1310 * @array: array description
1312 * Frees the array description returned from mono_metadata_parse_array().
1315 mono_metadata_free_array (MonoArrayType
*array
)
1317 g_free (array
->sizes
);
1318 g_free (array
->lobounds
);
1323 * need to add common field and param attributes combinations:
1326 * public static literal
1329 * private static literal
1331 static const MonoType
1333 /* data, attrs, type, nmods, byref, pinned */
1334 {{NULL
}, 0, MONO_TYPE_VOID
, 0, 0, 0},
1335 {{NULL
}, 0, MONO_TYPE_BOOLEAN
, 0, 0, 0},
1336 {{NULL
}, 0, MONO_TYPE_BOOLEAN
, 0, 1, 0},
1337 {{NULL
}, 0, MONO_TYPE_CHAR
, 0, 0, 0},
1338 {{NULL
}, 0, MONO_TYPE_CHAR
, 0, 1, 0},
1339 {{NULL
}, 0, MONO_TYPE_I1
, 0, 0, 0},
1340 {{NULL
}, 0, MONO_TYPE_I1
, 0, 1, 0},
1341 {{NULL
}, 0, MONO_TYPE_U1
, 0, 0, 0},
1342 {{NULL
}, 0, MONO_TYPE_U1
, 0, 1, 0},
1343 {{NULL
}, 0, MONO_TYPE_I2
, 0, 0, 0},
1344 {{NULL
}, 0, MONO_TYPE_I2
, 0, 1, 0},
1345 {{NULL
}, 0, MONO_TYPE_U2
, 0, 0, 0},
1346 {{NULL
}, 0, MONO_TYPE_U2
, 0, 1, 0},
1347 {{NULL
}, 0, MONO_TYPE_I4
, 0, 0, 0},
1348 {{NULL
}, 0, MONO_TYPE_I4
, 0, 1, 0},
1349 {{NULL
}, 0, MONO_TYPE_U4
, 0, 0, 0},
1350 {{NULL
}, 0, MONO_TYPE_U4
, 0, 1, 0},
1351 {{NULL
}, 0, MONO_TYPE_I8
, 0, 0, 0},
1352 {{NULL
}, 0, MONO_TYPE_I8
, 0, 1, 0},
1353 {{NULL
}, 0, MONO_TYPE_U8
, 0, 0, 0},
1354 {{NULL
}, 0, MONO_TYPE_U8
, 0, 1, 0},
1355 {{NULL
}, 0, MONO_TYPE_R4
, 0, 0, 0},
1356 {{NULL
}, 0, MONO_TYPE_R4
, 0, 1, 0},
1357 {{NULL
}, 0, MONO_TYPE_R8
, 0, 0, 0},
1358 {{NULL
}, 0, MONO_TYPE_R8
, 0, 1, 0},
1359 {{NULL
}, 0, MONO_TYPE_STRING
, 0, 0, 0},
1360 {{NULL
}, 0, MONO_TYPE_STRING
, 0, 1, 0},
1361 {{NULL
}, 0, MONO_TYPE_OBJECT
, 0, 0, 0},
1362 {{NULL
}, 0, MONO_TYPE_OBJECT
, 0, 1, 0},
1363 {{NULL
}, 0, MONO_TYPE_TYPEDBYREF
, 0, 0, 0},
1364 {{NULL
}, 0, MONO_TYPE_I
, 0, 0, 0},
1365 {{NULL
}, 0, MONO_TYPE_I
, 0, 1, 0},
1366 {{NULL
}, 0, MONO_TYPE_U
, 0, 0, 0},
1367 {{NULL
}, 0, MONO_TYPE_U
, 0, 1, 0},
1370 #define NBUILTIN_TYPES() (sizeof (builtin_types) / sizeof (builtin_types [0]))
1372 static GHashTable
*type_cache
= NULL
;
1373 static int next_generic_inst_id
= 0;
1375 /* Protected by image_sets_mutex */
1376 static MonoImageSet
*mscorlib_image_set
;
1377 /* Protected by image_sets_mutex */
1378 static GPtrArray
*image_sets
;
1379 static mono_mutex_t image_sets_mutex
;
1381 static guint
mono_generic_class_hash (gconstpointer data
);
1384 * MonoTypes with modifies are never cached, so we never check or use that field.
1387 mono_type_hash (gconstpointer data
)
1389 const MonoType
*type
= (const MonoType
*) data
;
1390 if (type
->type
== MONO_TYPE_GENERICINST
)
1391 return mono_generic_class_hash (type
->data
.generic_class
);
1393 return type
->type
| (type
->byref
<< 8) | (type
->attrs
<< 9);
1397 mono_type_equal (gconstpointer ka
, gconstpointer kb
)
1399 const MonoType
*a
= (const MonoType
*) ka
;
1400 const MonoType
*b
= (const MonoType
*) kb
;
1402 if (a
->type
!= b
->type
|| a
->byref
!= b
->byref
|| a
->attrs
!= b
->attrs
|| a
->pinned
!= b
->pinned
)
1404 /* need other checks */
1409 mono_metadata_generic_inst_hash (gconstpointer data
)
1411 const MonoGenericInst
*ginst
= (const MonoGenericInst
*) data
;
1415 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
1417 hash
+= mono_metadata_type_hash (ginst
->type_argv
[i
]);
1420 return hash
^ (ginst
->is_open
<< 8);
1424 mono_generic_inst_equal_full (const MonoGenericInst
*a
, const MonoGenericInst
*b
, gboolean signature_only
)
1428 #ifndef MONO_SMALL_CONFIG
1429 if (a
->id
&& b
->id
) {
1432 if (!signature_only
)
1437 if (a
->is_open
!= b
->is_open
|| a
->type_argc
!= b
->type_argc
)
1439 for (i
= 0; i
< a
->type_argc
; ++i
) {
1440 if (!do_mono_metadata_type_equal (a
->type_argv
[i
], b
->type_argv
[i
], signature_only
))
1447 mono_metadata_generic_inst_equal (gconstpointer ka
, gconstpointer kb
)
1449 const MonoGenericInst
*a
= (const MonoGenericInst
*) ka
;
1450 const MonoGenericInst
*b
= (const MonoGenericInst
*) kb
;
1452 return mono_generic_inst_equal_full (a
, b
, FALSE
);
1456 mono_generic_class_hash (gconstpointer data
)
1458 const MonoGenericClass
*gclass
= (const MonoGenericClass
*) data
;
1459 guint hash
= mono_metadata_type_hash (&gclass
->container_class
->byval_arg
);
1462 hash
+= gclass
->is_tb_open
;
1463 hash
+= mono_metadata_generic_context_hash (&gclass
->context
);
1469 mono_generic_class_equal (gconstpointer ka
, gconstpointer kb
)
1471 const MonoGenericClass
*a
= (const MonoGenericClass
*) ka
;
1472 const MonoGenericClass
*b
= (const MonoGenericClass
*) kb
;
1474 return _mono_metadata_generic_class_equal (a
, b
, FALSE
);
1478 * mono_metadata_init:
1480 * Initialize the global variables of this module.
1481 * This is a Mono runtime internal function.
1484 mono_metadata_init (void)
1488 type_cache
= g_hash_table_new (mono_type_hash
, mono_type_equal
);
1490 for (i
= 0; i
< NBUILTIN_TYPES (); ++i
)
1491 g_hash_table_insert (type_cache
, (gpointer
) &builtin_types
[i
], (gpointer
) &builtin_types
[i
]);
1493 mono_mutex_init_recursive (&image_sets_mutex
);
1497 * mono_metadata_cleanup:
1499 * Free all resources used by this module.
1500 * This is a Mono runtime internal function.
1503 mono_metadata_cleanup (void)
1505 g_hash_table_destroy (type_cache
);
1507 g_ptr_array_free (image_sets
, TRUE
);
1509 mono_mutex_destroy (&image_sets_mutex
);
1513 * mono_metadata_parse_type:
1514 * @m: metadata context
1515 * @mode: king of type that may be found at @ptr
1516 * @opt_attrs: optional attributes to store in the returned type
1517 * @ptr: pointer to the type representation
1518 * @rptr: pointer updated to match the end of the decoded stream
1519 * @transient: whenever to allocate the result from the heap or from a mempool
1521 * Decode a compressed type description found at @ptr in @m.
1522 * @mode can be one of MONO_PARSE_MOD_TYPE, MONO_PARSE_PARAM, MONO_PARSE_RET,
1523 * MONO_PARSE_FIELD, MONO_PARSE_LOCAL, MONO_PARSE_TYPE.
1524 * This function can be used to decode type descriptions in method signatures,
1525 * field signatures, locals signatures etc.
1527 * To parse a generic type, `generic_container' points to the current class'es
1528 * (the `generic_container' field in the MonoClass) or the current generic method's
1529 * (stored in image->property_hash) generic container.
1530 * When we encounter any MONO_TYPE_VAR or MONO_TYPE_MVAR's, they're looked up in
1531 * this MonoGenericContainer.
1533 * LOCKING: Acquires the loader lock.
1535 * Returns: a #MonoType structure representing the decoded type.
1538 mono_metadata_parse_type_internal (MonoImage
*m
, MonoGenericContainer
*container
, MonoParseTypeMode mode
,
1539 short opt_attrs
, gboolean transient
, const char *ptr
, const char **rptr
)
1541 MonoType
*type
, *cached
;
1543 gboolean byref
= FALSE
;
1544 gboolean pinned
= FALSE
;
1545 const char *tmp_ptr
;
1550 * According to the spec, custom modifiers should come before the byref
1551 * flag, but the IL produced by ilasm from the following signature:
1552 * object modopt(...) &
1553 * starts with a byref flag, followed by the modifiers. (bug #49802)
1554 * Also, this type seems to be different from 'object & modopt(...)'. Maybe
1555 * it would be better to treat byref as real type constructor instead of
1557 * Also, pinned should come before anything else, but some MSV++ produced
1558 * assemblies violate this (#bug 61990).
1561 /* Count the modifiers first */
1566 case MONO_TYPE_PINNED
:
1567 case MONO_TYPE_BYREF
:
1570 case MONO_TYPE_CMOD_REQD
:
1571 case MONO_TYPE_CMOD_OPT
:
1573 mono_metadata_parse_custom_mod (m
, NULL
, tmp_ptr
, &tmp_ptr
);
1583 size
= MONO_SIZEOF_TYPE
+ ((gint32
)count
) * sizeof (MonoCustomMod
);
1584 type
= transient
? g_malloc0 (size
) : mono_image_alloc0 (m
, size
);
1585 type
->num_mods
= count
;
1587 g_warning ("got more than 64 modifiers in type");
1590 memset (type
, 0, MONO_SIZEOF_TYPE
);
1593 /* Parse pinned, byref and custom modifiers */
1598 case MONO_TYPE_PINNED
:
1602 case MONO_TYPE_BYREF
:
1606 case MONO_TYPE_CMOD_REQD
:
1607 case MONO_TYPE_CMOD_OPT
:
1608 mono_metadata_parse_custom_mod (m
, &(type
->modifiers
[count
]), ptr
, &ptr
);
1616 type
->attrs
= opt_attrs
;
1617 type
->byref
= byref
;
1618 type
->pinned
= pinned
? 1 : 0;
1620 if (!do_mono_metadata_parse_type (type
, m
, container
, transient
, ptr
, &ptr
)) {
1627 if (!type
->num_mods
&& !transient
) {
1628 /* no need to free type here, because it is on the stack */
1629 if ((type
->type
== MONO_TYPE_CLASS
|| type
->type
== MONO_TYPE_VALUETYPE
) && !type
->pinned
&& !type
->attrs
) {
1630 MonoType
*ret
= type
->byref
? &type
->data
.klass
->this_arg
: &type
->data
.klass
->byval_arg
;
1632 /* Consider the case:
1634 class Foo<T> { class Bar {} }
1635 class Test : Foo<Test>.Bar {}
1637 When Foo<Test> is being expanded, 'Test' isn't yet initialized. It's actually in
1638 a really pristine state: it doesn't even know whether 'Test' is a reference or a value type.
1640 We ensure that the MonoClass is in a state that we can canonicalize to:
1642 klass->byval_arg.data.klass == klass
1643 klass->this_arg.data.klass == klass
1645 If we can't canonicalize 'type', it doesn't matter, since later users of 'type' will do it.
1647 LOCKING: even though we don't explicitly hold a lock, in the problematic case 'ret' is a field
1648 of a MonoClass which currently holds the loader lock. 'type' is local.
1650 if (ret
->data
.klass
== type
->data
.klass
) {
1654 /* No need to use locking since nobody is modifying the hash table */
1655 if ((cached
= g_hash_table_lookup (type_cache
, type
))) {
1660 /* printf ("%x %x %c %s\n", type->attrs, type->num_mods, type->pinned ? 'p' : ' ', mono_type_full_name (type)); */
1662 if (type
== &stype
) {
1663 type
= transient
? g_malloc (MONO_SIZEOF_TYPE
) : mono_image_alloc (m
, MONO_SIZEOF_TYPE
);
1664 memcpy (type
, &stype
, MONO_SIZEOF_TYPE
);
1670 mono_metadata_parse_type_full (MonoImage
*m
, MonoGenericContainer
*container
, MonoParseTypeMode mode
,
1671 short opt_attrs
, const char *ptr
, const char **rptr
)
1673 return mono_metadata_parse_type_internal (m
, container
, mode
, opt_attrs
, FALSE
, ptr
, rptr
);
1677 * LOCKING: Acquires the loader lock.
1680 mono_metadata_parse_type (MonoImage
*m
, MonoParseTypeMode mode
, short opt_attrs
,
1681 const char *ptr
, const char **rptr
)
1683 return mono_metadata_parse_type_full (m
, NULL
, mode
, opt_attrs
, ptr
, rptr
);
1687 mono_metadata_method_has_param_attrs (MonoImage
*m
, int def
)
1689 MonoTableInfo
*paramt
= &m
->tables
[MONO_TABLE_PARAM
];
1690 MonoTableInfo
*methodt
= &m
->tables
[MONO_TABLE_METHOD
];
1691 guint lastp
, i
, param_index
= mono_metadata_decode_row_col (methodt
, def
- 1, MONO_METHOD_PARAMLIST
);
1693 if (def
< methodt
->rows
)
1694 lastp
= mono_metadata_decode_row_col (methodt
, def
, MONO_METHOD_PARAMLIST
);
1696 lastp
= m
->tables
[MONO_TABLE_PARAM
].rows
+ 1;
1698 for (i
= param_index
; i
< lastp
; ++i
) {
1699 guint32 flags
= mono_metadata_decode_row_col (paramt
, i
- 1, MONO_PARAM_FLAGS
);
1708 * mono_metadata_get_param_attrs:
1710 * @m The image to loader parameter attributes from
1711 * @def method def token (one based)
1712 * @param_count number of params to decode including the return value
1714 * Return the parameter attributes for the method whose MethodDef index is DEF. The
1715 * returned memory needs to be freed by the caller. If all the param attributes are
1716 * 0, then NULL is returned.
1719 mono_metadata_get_param_attrs (MonoImage
*m
, int def
, int param_count
)
1721 MonoTableInfo
*paramt
= &m
->tables
[MONO_TABLE_PARAM
];
1722 MonoTableInfo
*methodt
= &m
->tables
[MONO_TABLE_METHOD
];
1723 guint32 cols
[MONO_PARAM_SIZE
];
1724 guint lastp
, i
, param_index
= mono_metadata_decode_row_col (methodt
, def
- 1, MONO_METHOD_PARAMLIST
);
1727 if (def
< methodt
->rows
)
1728 lastp
= mono_metadata_decode_row_col (methodt
, def
, MONO_METHOD_PARAMLIST
);
1730 lastp
= paramt
->rows
+ 1;
1732 for (i
= param_index
; i
< lastp
; ++i
) {
1733 mono_metadata_decode_row (paramt
, i
- 1, cols
, MONO_PARAM_SIZE
);
1734 if (cols
[MONO_PARAM_FLAGS
]) {
1736 pattrs
= g_new0 (int, param_count
);
1737 /* at runtime we just ignore this kind of malformed file:
1738 * the verifier can signal the error to the user
1740 if (cols
[MONO_PARAM_SEQUENCE
] >= param_count
)
1742 pattrs
[cols
[MONO_PARAM_SEQUENCE
]] = cols
[MONO_PARAM_FLAGS
];
1750 * mono_metadata_parse_signature_full:
1751 * @image: metadata context
1752 * @generic_container: generic container
1753 * @toke: metadata token
1755 * Decode a method signature stored in the STANDALONESIG table
1757 * LOCKING: Assumes the loader lock is held.
1759 * Returns: a MonoMethodSignature describing the signature.
1761 MonoMethodSignature
*
1762 mono_metadata_parse_signature_full (MonoImage
*image
, MonoGenericContainer
*generic_container
, guint32 token
)
1764 MonoTableInfo
*tables
= image
->tables
;
1765 guint32 idx
= mono_metadata_token_index (token
);
1769 if (image_is_dynamic (image
))
1770 return mono_lookup_dynamic_token (image
, token
, NULL
);
1772 g_assert (mono_metadata_token_table(token
) == MONO_TABLE_STANDALONESIG
);
1774 sig
= mono_metadata_decode_row_col (&tables
[MONO_TABLE_STANDALONESIG
], idx
- 1, 0);
1776 ptr
= mono_metadata_blob_heap (image
, sig
);
1777 mono_metadata_decode_blob_size (ptr
, &ptr
);
1779 return mono_metadata_parse_method_signature_full (image
, generic_container
, 0, ptr
, NULL
);
1783 * mono_metadata_parse_signature:
1784 * @image: metadata context
1785 * @toke: metadata token
1787 * Decode a method signature stored in the STANDALONESIG table
1789 * Returns: a MonoMethodSignature describing the signature.
1791 MonoMethodSignature
*
1792 mono_metadata_parse_signature (MonoImage
*image
, guint32 token
)
1794 return mono_metadata_parse_signature_full (image
, NULL
, token
);
1798 * mono_metadata_signature_alloc:
1799 * @image: metadata context
1800 * @nparmas: number of parameters in the signature
1802 * Allocate a MonoMethodSignature structure with the specified number of params.
1803 * The return type and the params types need to be filled later.
1804 * This is a Mono runtime internal function.
1806 * LOCKING: Assumes the loader lock is held.
1808 * Returns: the new MonoMethodSignature structure.
1810 MonoMethodSignature
*
1811 mono_metadata_signature_alloc (MonoImage
*m
, guint32 nparams
)
1813 MonoMethodSignature
*sig
;
1815 sig
= mono_image_alloc0 (m
, MONO_SIZEOF_METHOD_SIGNATURE
+ ((gint32
)nparams
) * sizeof (MonoType
*));
1816 sig
->param_count
= nparams
;
1817 sig
->sentinelpos
= -1;
1822 static MonoMethodSignature
*
1823 mono_metadata_signature_dup_internal (MonoImage
*image
, MonoMemPool
*mp
, MonoMethodSignature
*sig
)
1826 MonoMethodSignature
*ret
;
1827 sigsize
= MONO_SIZEOF_METHOD_SIGNATURE
+ sig
->param_count
* sizeof (MonoType
*);
1830 ret
= mono_image_alloc (image
, sigsize
);
1832 ret
= mono_mempool_alloc (mp
, sigsize
);
1834 ret
= g_malloc (sigsize
);
1836 memcpy (ret
, sig
, sigsize
);
1840 MonoMethodSignature
*
1841 mono_metadata_signature_dup_full (MonoImage
*image
, MonoMethodSignature
*sig
)
1843 return mono_metadata_signature_dup_internal (image
, NULL
, sig
);
1846 /*The mempool is accessed without synchronization*/
1847 MonoMethodSignature
*
1848 mono_metadata_signature_dup_mempool (MonoMemPool
*mp
, MonoMethodSignature
*sig
)
1850 return mono_metadata_signature_dup_internal (NULL
, mp
, sig
);
1854 * mono_metadata_signature_dup:
1855 * @sig: method signature
1857 * Duplicate an existing MonoMethodSignature so it can be modified.
1858 * This is a Mono runtime internal function.
1860 * Returns: the new MonoMethodSignature structure.
1862 MonoMethodSignature
*
1863 mono_metadata_signature_dup (MonoMethodSignature
*sig
)
1865 return mono_metadata_signature_dup_full (NULL
, sig
);
1869 * mono_metadata_signature_size:
1871 * Return the amount of memory allocated to SIG.
1874 mono_metadata_signature_size (MonoMethodSignature
*sig
)
1876 return MONO_SIZEOF_METHOD_SIGNATURE
+ sig
->param_count
* sizeof (MonoType
*);
1880 * mono_metadata_parse_method_signature:
1881 * @m: metadata context
1882 * @generic_container: generics container
1883 * @def: the MethodDef index or 0 for Ref signatures.
1884 * @ptr: pointer to the signature metadata representation
1885 * @rptr: pointer updated to match the end of the decoded stream
1887 * Decode a method signature stored at @ptr.
1888 * This is a Mono runtime internal function.
1890 * LOCKING: Assumes the loader lock is held.
1892 * Returns: a MonoMethodSignature describing the signature.
1894 MonoMethodSignature
*
1895 mono_metadata_parse_method_signature_full (MonoImage
*m
, MonoGenericContainer
*container
,
1896 int def
, const char *ptr
, const char **rptr
)
1898 MonoMethodSignature
*method
;
1899 int i
, *pattrs
= NULL
;
1900 guint32 hasthis
= 0, explicit_this
= 0, call_convention
, param_count
;
1901 guint32 gen_param_count
= 0;
1902 gboolean is_open
= FALSE
;
1905 gen_param_count
= 1;
1910 call_convention
= *ptr
& 0x0F;
1912 if (gen_param_count
)
1913 gen_param_count
= mono_metadata_decode_value (ptr
, &ptr
);
1914 param_count
= mono_metadata_decode_value (ptr
, &ptr
);
1917 pattrs
= mono_metadata_get_param_attrs (m
, def
, param_count
+ 1); /*Must be + 1 since signature's param count doesn't account for the return value */
1919 method
= mono_metadata_signature_alloc (m
, param_count
);
1920 method
->hasthis
= hasthis
;
1921 method
->explicit_this
= explicit_this
;
1922 method
->call_convention
= call_convention
;
1923 method
->generic_param_count
= gen_param_count
;
1925 if (call_convention
!= 0xa) {
1926 method
->ret
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_RET
, pattrs
? pattrs
[0] : 0, ptr
, &ptr
);
1928 mono_metadata_free_method_signature (method
);
1932 is_open
= mono_class_is_open_constructed_type (method
->ret
);
1935 for (i
= 0; i
< method
->param_count
; ++i
) {
1936 if (*ptr
== MONO_TYPE_SENTINEL
) {
1937 if (method
->call_convention
!= MONO_CALL_VARARG
|| def
) {
1938 g_warning ("found sentinel for methoddef or no vararg method 0x%08x on image %s", def
, m
->name
);
1942 if (method
->sentinelpos
>= 0) {
1943 g_warning ("found sentinel twice in the same signature for method 0x%08x on image %s", def
, m
->name
);
1947 method
->sentinelpos
= i
;
1950 method
->params
[i
] = mono_metadata_parse_type_full (m
, container
, MONO_PARSE_PARAM
, pattrs
? pattrs
[i
+1] : 0, ptr
, &ptr
);
1951 if (!method
->params
[i
]) {
1952 mono_metadata_free_method_signature (method
);
1957 is_open
= mono_class_is_open_constructed_type (method
->params
[i
]);
1960 /* The sentinel could be missing if the caller does not pass any additional arguments */
1961 if (!def
&& method
->call_convention
== MONO_CALL_VARARG
&& method
->sentinelpos
< 0)
1962 method
->sentinelpos
= method
->param_count
;
1964 method
->has_type_parameters
= is_open
;
1966 if (def
&& (method
->call_convention
== MONO_CALL_VARARG
))
1967 method
->sentinelpos
= method
->param_count
;
1974 * Add signature to a cache and increase ref count...
1981 * mono_metadata_parse_method_signature:
1982 * @m: metadata context
1983 * @def: the MethodDef index or 0 for Ref signatures.
1984 * @ptr: pointer to the signature metadata representation
1985 * @rptr: pointer updated to match the end of the decoded stream
1987 * Decode a method signature stored at @ptr.
1988 * This is a Mono runtime internal function.
1990 * LOCKING: Assumes the loader lock is held.
1992 * Returns: a MonoMethodSignature describing the signature.
1994 MonoMethodSignature
*
1995 mono_metadata_parse_method_signature (MonoImage
*m
, int def
, const char *ptr
, const char **rptr
)
1997 return mono_metadata_parse_method_signature_full (m
, NULL
, def
, ptr
, rptr
);
2001 * mono_metadata_free_method_signature:
2002 * @sig: signature to destroy
2004 * Free the memory allocated in the signature @sig.
2005 * This method needs to be robust and work also on partially-built
2006 * signatures, so it does extra checks.
2009 mono_metadata_free_method_signature (MonoMethodSignature
*sig
)
2011 /* Everything is allocated from mempools */
2015 mono_metadata_free_type (sig->ret);
2016 for (i = 0; i < sig->param_count; ++i) {
2017 if (sig->params [i])
2018 mono_metadata_free_type (sig->params [i]);
2024 mono_metadata_free_inflated_signature (MonoMethodSignature
*sig
)
2028 /* Allocated in inflate_generic_signature () */
2030 mono_metadata_free_type (sig
->ret
);
2031 for (i
= 0; i
< sig
->param_count
; ++i
) {
2032 if (sig
->params
[i
])
2033 mono_metadata_free_type (sig
->params
[i
]);
2039 inflated_method_equal (gconstpointer a
, gconstpointer b
)
2041 const MonoMethodInflated
*ma
= a
;
2042 const MonoMethodInflated
*mb
= b
;
2043 if (ma
->declaring
!= mb
->declaring
)
2045 if (ma
->method
.method
.is_mb_open
!= mb
->method
.method
.is_mb_open
)
2047 return mono_metadata_generic_context_equal (&ma
->context
, &mb
->context
);
2051 inflated_method_hash (gconstpointer a
)
2053 const MonoMethodInflated
*ma
= a
;
2054 return (mono_metadata_generic_context_hash (&ma
->context
) ^ mono_aligned_addr_hash (ma
->declaring
)) + ma
->method
.method
.is_mb_open
;
2058 inflated_signature_equal (gconstpointer a
, gconstpointer b
)
2060 const MonoInflatedMethodSignature
*sig1
= a
;
2061 const MonoInflatedMethodSignature
*sig2
= b
;
2063 /* sig->sig is assumed to be canonized */
2064 if (sig1
->sig
!= sig2
->sig
)
2066 /* The generic instances are canonized */
2067 return mono_metadata_generic_context_equal (&sig1
->context
, &sig2
->context
);
2071 inflated_signature_hash (gconstpointer a
)
2073 const MonoInflatedMethodSignature
*sig
= a
;
2075 /* sig->sig is assumed to be canonized */
2076 return mono_metadata_generic_context_hash (&sig
->context
) ^ mono_aligned_addr_hash (sig
->sig
);
2080 dump_ginst (MonoGenericInst *ginst)
2085 g_print ("Ginst: <");
2086 for (i = 0; i < ginst->type_argc; ++i) {
2089 name = mono_type_get_name (ginst->type_argv [i]);
2090 g_print ("%s", name);
2096 static gboolean
type_in_image (MonoType
*type
, MonoImage
*image
);
2099 signature_in_image (MonoMethodSignature
*sig
, MonoImage
*image
)
2101 gpointer iter
= NULL
;
2104 while ((p
= mono_signature_get_params (sig
, &iter
)) != NULL
)
2105 if (type_in_image (p
, image
))
2108 return type_in_image (mono_signature_get_return_type (sig
), image
);
2112 ginst_in_image (MonoGenericInst
*ginst
, MonoImage
*image
)
2116 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
2117 if (type_in_image (ginst
->type_argv
[i
], image
))
2125 gclass_in_image (MonoGenericClass
*gclass
, MonoImage
*image
)
2127 return gclass
->container_class
->image
== image
||
2128 ginst_in_image (gclass
->context
.class_inst
, image
);
2132 type_in_image (MonoType
*type
, MonoImage
*image
)
2135 switch (type
->type
) {
2136 case MONO_TYPE_GENERICINST
:
2137 return gclass_in_image (type
->data
.generic_class
, image
);
2139 type
= type
->data
.type
;
2141 case MONO_TYPE_SZARRAY
:
2142 type
= &type
->data
.klass
->byval_arg
;
2144 case MONO_TYPE_ARRAY
:
2145 type
= &type
->data
.array
->eklass
->byval_arg
;
2147 case MONO_TYPE_FNPTR
:
2148 return signature_in_image (type
->data
.method
, image
);
2149 case MONO_TYPE_VAR
: {
2150 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2152 g_assert (!container
->is_method
);
2154 * FIXME: The following check is here solely
2155 * for monodis, which uses the internal
2157 * mono_metadata_load_generic_params(). The
2158 * caller of that function needs to fill in
2159 * owner->klass or owner->method of the
2160 * returned struct, but monodis doesn't do
2161 * that. The image unloading depends on that,
2162 * however, so a crash results without this
2165 if (!container
->owner
.klass
)
2166 return container
->image
== image
;
2167 return container
->owner
.klass
->image
== image
;
2169 return type
->data
.generic_param
->image
== image
;
2172 case MONO_TYPE_MVAR
: {
2173 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2174 if (type
->data
.generic_param
->image
== image
)
2177 g_assert (container
->is_method
);
2178 if (!container
->owner
.method
)
2179 /* RefEmit created generic param whose method is not finished */
2180 return container
->image
== image
;
2181 return container
->owner
.method
->klass
->image
== image
;
2183 return type
->data
.generic_param
->image
== image
;
2187 /* At this point, we should've avoided all potential allocations in mono_class_from_mono_type () */
2188 return image
== mono_class_from_mono_type (type
)->image
;
2193 image_sets_lock (void)
2195 mono_mutex_lock (&image_sets_mutex
);
2199 image_sets_unlock (void)
2201 mono_mutex_unlock (&image_sets_mutex
);
2207 * Return a MonoImageSet representing the set of images in IMAGES.
2209 static MonoImageSet
*
2210 get_image_set (MonoImage
**images
, int nimages
)
2217 if (nimages
== 1 && images
[0] == mono_defaults
.corlib
&& mscorlib_image_set
)
2218 return mscorlib_image_set
;
2220 /* Happens with empty generic instances */
2222 return mscorlib_image_set
;
2227 image_sets
= g_ptr_array_new ();
2229 if (images
[0] == mono_defaults
.corlib
&& nimages
> 1)
2230 l
= images
[1]->image_sets
;
2232 l
= images
[0]->image_sets
;
2235 for (; l
; l
= l
->next
) {
2238 if (set
->nimages
== nimages
) {
2239 for (j
= 0; j
< nimages
; ++j
) {
2240 for (k
= 0; k
< nimages
; ++k
)
2241 if (set
->images
[k
] == images
[j
])
2255 set
= g_new0 (MonoImageSet
, 1);
2256 set
->nimages
= nimages
;
2257 set
->images
= g_new0 (MonoImage
*, nimages
);
2258 mono_mutex_init_recursive (&set
->lock
);
2259 for (i
= 0; i
< nimages
; ++i
)
2260 set
->images
[i
] = images
[i
];
2261 set
->gclass_cache
= g_hash_table_new_full (mono_generic_class_hash
, mono_generic_class_equal
, NULL
, (GDestroyNotify
)free_generic_class
);
2262 set
->ginst_cache
= g_hash_table_new_full (mono_metadata_generic_inst_hash
, mono_metadata_generic_inst_equal
, NULL
, (GDestroyNotify
)free_generic_inst
);
2263 set
->gmethod_cache
= g_hash_table_new_full (inflated_method_hash
, inflated_method_equal
, NULL
, (GDestroyNotify
)free_inflated_method
);
2264 set
->gsignature_cache
= g_hash_table_new_full (inflated_signature_hash
, inflated_signature_equal
, NULL
, (GDestroyNotify
)free_inflated_signature
);
2266 for (i
= 0; i
< nimages
; ++i
)
2267 set
->images
[i
]->image_sets
= g_slist_prepend (set
->images
[i
]->image_sets
, set
);
2269 g_ptr_array_add (image_sets
, set
);
2272 if (nimages
== 1 && images
[0] == mono_defaults
.corlib
) {
2273 mono_memory_barrier ();
2274 mscorlib_image_set
= set
;
2277 image_sets_unlock ();
2283 delete_image_set (MonoImageSet
*set
)
2287 g_hash_table_destroy (set
->gclass_cache
);
2288 g_hash_table_destroy (set
->ginst_cache
);
2289 g_hash_table_destroy (set
->gmethod_cache
);
2290 g_hash_table_destroy (set
->gsignature_cache
);
2294 for (i
= 0; i
< set
->nimages
; ++i
)
2295 set
->images
[i
]->image_sets
= g_slist_remove (set
->images
[i
]->image_sets
, set
);
2297 g_ptr_array_remove (image_sets
, set
);
2299 image_sets_unlock ();
2302 mono_mempool_destroy (set
->mempool
);
2303 g_free (set
->images
);
2304 mono_mutex_destroy (&set
->lock
);
2309 mono_image_set_lock (MonoImageSet
*set
)
2311 mono_mutex_lock (&set
->lock
);
2315 mono_image_set_unlock (MonoImageSet
*set
)
2317 mono_mutex_unlock (&set
->lock
);
2321 mono_image_set_alloc (MonoImageSet
*set
, guint size
)
2325 mono_image_set_lock (set
);
2327 set
->mempool
= mono_mempool_new_size (1024);
2328 res
= mono_mempool_alloc (set
->mempool
, size
);
2329 mono_image_set_unlock (set
);
2335 mono_image_set_alloc0 (MonoImageSet
*set
, guint size
)
2339 mono_image_set_lock (set
);
2341 set
->mempool
= mono_mempool_new_size (1024);
2342 res
= mono_mempool_alloc0 (set
->mempool
, size
);
2343 mono_image_set_unlock (set
);
2349 mono_image_set_strdup (MonoImageSet
*set
, const char *s
)
2353 mono_image_set_lock (set
);
2355 set
->mempool
= mono_mempool_new_size (1024);
2356 res
= mono_mempool_strdup (set
->mempool
, s
);
2357 mono_image_set_unlock (set
);
2363 * Structure used by the collect_..._images functions to store the image list.
2366 MonoImage
*image_buf
[64];
2368 int nimages
, images_len
;
2372 collect_data_init (CollectData
*data
)
2374 data
->images
= data
->image_buf
;
2375 data
->images_len
= 64;
2380 collect_data_free (CollectData
*data
)
2382 if (data
->images
!= data
->image_buf
)
2383 g_free (data
->images
);
2387 enlarge_data (CollectData
*data
)
2389 int new_len
= data
->images_len
< 16 ? 16 : data
->images_len
* 2;
2390 MonoImage
**d
= g_new (MonoImage
*, new_len
);
2393 g_assert_not_reached ();
2394 memcpy (d
, data
->images
, data
->images_len
);
2395 if (data
->images
!= data
->image_buf
)
2396 g_free (data
->images
);
2398 data
->images_len
= new_len
;
2402 add_image (MonoImage
*image
, CollectData
*data
)
2406 /* The arrays are small, so use a linear search instead of a hash table */
2407 for (i
= 0; i
< data
->nimages
; ++i
)
2408 if (data
->images
[i
] == image
)
2411 if (data
->nimages
== data
->images_len
)
2412 enlarge_data (data
);
2414 data
->images
[data
->nimages
++] = image
;
2418 collect_type_images (MonoType
*type
, CollectData
*data
);
2421 collect_ginst_images (MonoGenericInst
*ginst
, CollectData
*data
)
2425 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
2426 collect_type_images (ginst
->type_argv
[i
], data
);
2431 collect_gclass_images (MonoGenericClass
*gclass
, CollectData
*data
)
2433 add_image (gclass
->container_class
->image
, data
);
2434 if (gclass
->context
.class_inst
)
2435 collect_ginst_images (gclass
->context
.class_inst
, data
);
2439 collect_signature_images (MonoMethodSignature
*sig
, CollectData
*data
)
2441 gpointer iter
= NULL
;
2444 collect_type_images (mono_signature_get_return_type (sig
), data
);
2445 while ((p
= mono_signature_get_params (sig
, &iter
)) != NULL
)
2446 collect_type_images (p
, data
);
2450 collect_inflated_signature_images (MonoInflatedMethodSignature
*sig
, CollectData
*data
)
2452 collect_signature_images (sig
->sig
, data
);
2453 if (sig
->context
.class_inst
)
2454 collect_ginst_images (sig
->context
.class_inst
, data
);
2455 if (sig
->context
.method_inst
)
2456 collect_ginst_images (sig
->context
.method_inst
, data
);
2460 collect_method_images (MonoMethodInflated
*method
, CollectData
*data
)
2462 MonoMethod
*m
= method
->declaring
;
2464 add_image (method
->declaring
->klass
->image
, data
);
2465 if (method
->context
.class_inst
)
2466 collect_ginst_images (method
->context
.class_inst
, data
);
2467 if (method
->context
.method_inst
)
2468 collect_ginst_images (method
->context
.method_inst
, data
);
2470 * Dynamic assemblies have no references, so the images they depend on can be unloaded before them.
2472 if (image_is_dynamic (m
->klass
->image
))
2473 collect_signature_images (mono_method_signature (m
), data
);
2477 collect_type_images (MonoType
*type
, CollectData
*data
)
2480 switch (type
->type
) {
2481 case MONO_TYPE_GENERICINST
:
2482 collect_gclass_images (type
->data
.generic_class
, data
);
2485 type
= type
->data
.type
;
2487 case MONO_TYPE_SZARRAY
:
2488 type
= &type
->data
.klass
->byval_arg
;
2490 case MONO_TYPE_ARRAY
:
2491 type
= &type
->data
.array
->eklass
->byval_arg
;
2493 case MONO_TYPE_FNPTR
:
2494 //return signature_in_image (type->data.method, image);
2495 g_assert_not_reached ();
2496 case MONO_TYPE_VAR
: {
2497 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2499 g_assert (!container
->is_method
);
2501 * FIXME: The following check is here solely
2502 * for monodis, which uses the internal
2504 * mono_metadata_load_generic_params(). The
2505 * caller of that function needs to fill in
2506 * owner->klass or owner->method of the
2507 * returned struct, but monodis doesn't do
2508 * that. The image unloading depends on that,
2509 * however, so a crash results without this
2512 if (!container
->owner
.klass
)
2513 add_image (container
->image
, data
);
2515 add_image (container
->owner
.klass
->image
, data
);
2517 add_image (type
->data
.generic_param
->image
, data
);
2521 case MONO_TYPE_MVAR
: {
2522 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2523 if (type
->data
.generic_param
->image
)
2524 add_image (type
->data
.generic_param
->image
, data
);
2526 if (!container
->owner
.method
) {
2527 /* RefEmit created generic param whose method is not finished */
2528 add_image (container
->image
, data
);
2530 g_assert (container
->is_method
);
2531 add_image (container
->owner
.method
->klass
->image
, data
);
2534 add_image (type
->data
.generic_param
->image
, data
);
2538 case MONO_TYPE_CLASS
:
2539 case MONO_TYPE_VALUETYPE
:
2540 add_image (mono_class_from_mono_type (type
)->image
, data
);
2543 add_image (mono_defaults
.corlib
, data
);
2550 } CleanForImageUserData
;
2553 steal_gclass_in_image (gpointer key
, gpointer value
, gpointer data
)
2555 MonoGenericClass
*gclass
= key
;
2556 CleanForImageUserData
*user_data
= data
;
2558 g_assert (gclass_in_image (gclass
, user_data
->image
));
2560 user_data
->list
= g_slist_prepend (user_data
->list
, gclass
);
2565 steal_ginst_in_image (gpointer key
, gpointer value
, gpointer data
)
2567 MonoGenericInst
*ginst
= key
;
2568 CleanForImageUserData
*user_data
= data
;
2570 // This doesn't work during corlib compilation
2571 //g_assert (ginst_in_image (ginst, user_data->image));
2573 user_data
->list
= g_slist_prepend (user_data
->list
, ginst
);
2578 inflated_method_in_image (gpointer key
, gpointer value
, gpointer data
)
2580 MonoImage
*image
= data
;
2581 MonoMethodInflated
*method
= key
;
2584 // https://bugzilla.novell.com/show_bug.cgi?id=458168
2585 g_assert (method
->declaring
->klass
->image
== image
||
2586 (method
->context
.class_inst
&& ginst_in_image (method
->context
.class_inst
, image
)) ||
2587 (method
->context
.method_inst
&& ginst_in_image (method
->context
.method_inst
, image
)) || (((MonoMethod
*)method
)->signature
&& signature_in_image (mono_method_signature ((MonoMethod
*)method
), image
)));
2593 inflated_signature_in_image (gpointer key
, gpointer value
, gpointer data
)
2595 MonoImage
*image
= data
;
2596 MonoInflatedMethodSignature
*sig
= key
;
2598 return signature_in_image (sig
->sig
, image
) ||
2599 (sig
->context
.class_inst
&& ginst_in_image (sig
->context
.class_inst
, image
)) ||
2600 (sig
->context
.method_inst
&& ginst_in_image (sig
->context
.method_inst
, image
));
2604 check_gmethod (gpointer key
, gpointer value
, gpointer data
)
2606 MonoMethodInflated
*method
= key
;
2607 MonoImage
*image
= data
;
2609 if (method
->context
.class_inst
)
2610 g_assert (!ginst_in_image (method
->context
.class_inst
, image
));
2611 if (method
->context
.method_inst
)
2612 g_assert (!ginst_in_image (method
->context
.method_inst
, image
));
2613 if (((MonoMethod
*)method
)->signature
)
2614 g_assert (!signature_in_image (mono_method_signature ((MonoMethod
*)method
), image
));
2620 * Run a consistency check on the image set data structures.
2622 static G_GNUC_UNUSED
void
2623 check_image_sets (MonoImage
*image
)
2626 GSList
*l
= image
->image_sets
;
2631 for (i
= 0; i
< image_sets
->len
; ++i
) {
2632 MonoImageSet
*set
= g_ptr_array_index (image_sets
, i
);
2634 if (!g_slist_find (l
, set
)) {
2635 g_hash_table_foreach (set
->gmethod_cache
, check_gmethod
, image
);
2641 mono_metadata_clean_for_image (MonoImage
*image
)
2643 CleanForImageUserData ginst_data
, gclass_data
;
2644 GSList
*l
, *set_list
;
2646 //check_image_sets (image);
2649 * The data structures could reference each other so we delete them in two phases.
2650 * This is required because of the hashing functions in gclass/ginst_cache.
2652 ginst_data
.image
= gclass_data
.image
= image
;
2653 ginst_data
.list
= gclass_data
.list
= NULL
;
2655 /* Collect the items to delete */
2656 /* delete_image_set () modifies the lists so make a copy */
2657 for (l
= image
->image_sets
; l
; l
= l
->next
) {
2658 MonoImageSet
*set
= l
->data
;
2660 mono_image_set_lock (set
);
2661 g_hash_table_foreach_steal (set
->gclass_cache
, steal_gclass_in_image
, &gclass_data
);
2662 g_hash_table_foreach_steal (set
->ginst_cache
, steal_ginst_in_image
, &ginst_data
);
2663 g_hash_table_foreach_remove (set
->gmethod_cache
, inflated_method_in_image
, image
);
2664 g_hash_table_foreach_remove (set
->gsignature_cache
, inflated_signature_in_image
, image
);
2665 mono_image_set_unlock (set
);
2668 /* Delete the removed items */
2669 for (l
= ginst_data
.list
; l
; l
= l
->next
)
2670 free_generic_inst (l
->data
);
2671 for (l
= gclass_data
.list
; l
; l
= l
->next
)
2672 free_generic_class (l
->data
);
2673 g_slist_free (ginst_data
.list
);
2674 g_slist_free (gclass_data
.list
);
2675 /* delete_image_set () modifies the lists so make a copy */
2676 set_list
= g_slist_copy (image
->image_sets
);
2677 for (l
= set_list
; l
; l
= l
->next
) {
2678 MonoImageSet
*set
= l
->data
;
2680 delete_image_set (set
);
2682 g_slist_free (set_list
);
2686 free_inflated_method (MonoMethodInflated
*imethod
)
2689 MonoMethod
*method
= (MonoMethod
*)imethod
;
2691 mono_marshal_free_inflated_wrappers (method
);
2693 if (method
->signature
)
2694 mono_metadata_free_inflated_signature (method
->signature
);
2696 if (!((method
->flags
& METHOD_ATTRIBUTE_ABSTRACT
) || (method
->iflags
& METHOD_IMPL_ATTRIBUTE_RUNTIME
) || (method
->iflags
& METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL
) || (method
->flags
& METHOD_ATTRIBUTE_PINVOKE_IMPL
))) {
2697 MonoMethodHeader
*header
= imethod
->header
;
2700 /* Allocated in inflate_generic_header () */
2701 for (i
= 0; i
< header
->num_locals
; ++i
)
2702 mono_metadata_free_type (header
->locals
[i
]);
2703 g_free (header
->clauses
);
2712 free_generic_inst (MonoGenericInst
*ginst
)
2716 /* The ginst itself is allocated from the image set mempool */
2717 for (i
= 0; i
< ginst
->type_argc
; ++i
)
2718 mono_metadata_free_type (ginst
->type_argv
[i
]);
2722 free_generic_class (MonoGenericClass
*gclass
)
2724 /* The gclass itself is allocated from the image set mempool */
2725 if (gclass
->is_dynamic
)
2726 mono_reflection_free_dynamic_generic_class (gclass
);
2727 if (gclass
->cached_class
&& gclass
->cached_class
->interface_id
)
2728 mono_unload_interface_id (gclass
->cached_class
);
2732 free_inflated_signature (MonoInflatedMethodSignature
*sig
)
2734 mono_metadata_free_inflated_signature (sig
->sig
);
2739 mono_method_inflated_lookup (MonoMethodInflated
* method
, gboolean cache
)
2745 collect_data_init (&data
);
2747 collect_method_images (method
, &data
);
2749 set
= get_image_set (data
.images
, data
.nimages
);
2751 collect_data_free (&data
);
2753 mono_image_set_lock (set
);
2754 res
= g_hash_table_lookup (set
->gmethod_cache
, method
);
2755 if (!res
&& cache
) {
2756 g_hash_table_insert (set
->gmethod_cache
, method
, method
);
2760 mono_image_set_unlock (set
);
2765 * mono_metadata_get_inflated_signature:
2767 * Given an inflated signature and a generic context, return a canonical copy of the
2768 * signature. The returned signature might be equal to SIG or it might be a cached copy.
2770 MonoMethodSignature
*
2771 mono_metadata_get_inflated_signature (MonoMethodSignature
*sig
, MonoGenericContext
*context
)
2773 MonoInflatedMethodSignature helper
;
2774 MonoInflatedMethodSignature
*res
;
2779 helper
.context
.class_inst
= context
->class_inst
;
2780 helper
.context
.method_inst
= context
->method_inst
;
2782 collect_data_init (&data
);
2784 collect_inflated_signature_images (&helper
, &data
);
2786 set
= get_image_set (data
.images
, data
.nimages
);
2788 collect_data_free (&data
);
2790 mono_image_set_lock (set
);
2792 res
= g_hash_table_lookup (set
->gsignature_cache
, &helper
);
2794 res
= g_new0 (MonoInflatedMethodSignature
, 1);
2796 res
->context
.class_inst
= context
->class_inst
;
2797 res
->context
.method_inst
= context
->method_inst
;
2798 g_hash_table_insert (set
->gsignature_cache
, res
, res
);
2801 mono_image_set_unlock (set
);
2807 * mono_metadata_get_generic_inst:
2809 * Given a list of types, return a MonoGenericInst that represents that list.
2810 * The returned MonoGenericInst has its own copy of the list of types. The list
2811 * passed in the argument can be freed, modified or disposed of.
2815 mono_metadata_get_generic_inst (int type_argc
, MonoType
**type_argv
)
2817 MonoGenericInst
*ginst
;
2820 int size
= MONO_SIZEOF_GENERIC_INST
+ type_argc
* sizeof (MonoType
*);
2824 for (i
= 0; i
< type_argc
; ++i
)
2825 if (mono_class_is_open_constructed_type (type_argv
[i
]))
2827 is_open
= (i
< type_argc
);
2829 ginst
= g_alloca (size
);
2830 memset (ginst
, 0, sizeof (MonoGenericInst
));
2831 ginst
->is_open
= is_open
;
2832 ginst
->type_argc
= type_argc
;
2833 memcpy (ginst
->type_argv
, type_argv
, type_argc
* sizeof (MonoType
*));
2835 collect_data_init (&data
);
2837 collect_ginst_images (ginst
, &data
);
2839 set
= get_image_set (data
.images
, data
.nimages
);
2841 collect_data_free (&data
);
2843 mono_image_set_lock (set
);
2845 ginst
= g_hash_table_lookup (set
->ginst_cache
, ginst
);
2847 ginst
= mono_image_set_alloc0 (set
, size
);
2848 #ifndef MONO_SMALL_CONFIG
2849 ginst
->id
= ++next_generic_inst_id
;
2851 ginst
->is_open
= is_open
;
2852 ginst
->type_argc
= type_argc
;
2854 for (i
= 0; i
< type_argc
; ++i
)
2855 ginst
->type_argv
[i
] = mono_metadata_type_dup (NULL
, type_argv
[i
]);
2857 g_hash_table_insert (set
->ginst_cache
, ginst
, ginst
);
2860 mono_image_set_unlock (set
);
2865 mono_metadata_is_type_builder_generic_type_definition (MonoClass
*container_class
, MonoGenericInst
*inst
, gboolean is_dynamic
)
2867 MonoGenericContainer
*container
= container_class
->generic_container
;
2869 if (!is_dynamic
|| container_class
->wastypebuilder
|| container
->type_argc
!= inst
->type_argc
)
2871 return inst
== container
->context
.class_inst
;
2875 * mono_metadata_lookup_generic_class:
2877 * Returns a MonoGenericClass with the given properties.
2881 mono_metadata_lookup_generic_class (MonoClass
*container_class
, MonoGenericInst
*inst
, gboolean is_dynamic
)
2883 MonoGenericClass
*gclass
;
2884 MonoGenericClass helper
;
2885 gboolean is_tb_open
= mono_metadata_is_type_builder_generic_type_definition (container_class
, inst
, is_dynamic
);
2889 helper
.container_class
= container_class
;
2890 helper
.context
.class_inst
= inst
;
2891 helper
.context
.method_inst
= NULL
;
2892 helper
.is_dynamic
= is_dynamic
; /* We use this in a hash lookup, which does not attempt to downcast the pointer */
2893 helper
.is_tb_open
= is_tb_open
;
2894 helper
.cached_class
= NULL
;
2896 collect_data_init (&data
);
2898 collect_gclass_images (&helper
, &data
);
2900 set
= get_image_set (data
.images
, data
.nimages
);
2902 collect_data_free (&data
);
2904 mono_image_set_lock (set
);
2906 gclass
= g_hash_table_lookup (set
->gclass_cache
, &helper
);
2908 /* A tripwire just to keep us honest */
2909 g_assert (!helper
.cached_class
);
2912 mono_image_set_unlock (set
);
2917 MonoDynamicGenericClass
*dgclass
= mono_image_set_new0 (set
, MonoDynamicGenericClass
, 1);
2918 gclass
= &dgclass
->generic_class
;
2919 gclass
->is_dynamic
= 1;
2921 gclass
= mono_image_set_new0 (set
, MonoGenericClass
, 1);
2924 gclass
->is_tb_open
= is_tb_open
;
2925 gclass
->container_class
= container_class
;
2926 gclass
->context
.class_inst
= inst
;
2927 gclass
->context
.method_inst
= NULL
;
2928 gclass
->owner
= set
;
2929 if (inst
== container_class
->generic_container
->context
.class_inst
&& !is_tb_open
)
2930 gclass
->cached_class
= container_class
;
2932 g_hash_table_insert (set
->gclass_cache
, gclass
, gclass
);
2934 mono_image_set_unlock (set
);
2940 * mono_metadata_inflate_generic_inst:
2942 * Instantiate the generic instance @ginst with the context @context.
2943 * Check @error for success.
2947 mono_metadata_inflate_generic_inst (MonoGenericInst
*ginst
, MonoGenericContext
*context
, MonoError
*error
)
2949 MonoType
**type_argv
;
2950 MonoGenericInst
*nginst
= NULL
;
2953 mono_error_init (error
);
2955 if (!ginst
->is_open
)
2958 type_argv
= g_new0 (MonoType
*, ginst
->type_argc
);
2960 for (i
= 0; i
< ginst
->type_argc
; i
++) {
2961 type_argv
[i
] = mono_class_inflate_generic_type_checked (ginst
->type_argv
[i
], context
, error
);
2962 if (!mono_error_ok (error
))
2967 nginst
= mono_metadata_get_generic_inst (ginst
->type_argc
, type_argv
);
2970 for (i
= 0; i
< count
; i
++)
2971 mono_metadata_free_type (type_argv
[i
]);
2978 mono_metadata_parse_generic_inst (MonoImage
*m
, MonoGenericContainer
*container
,
2979 int count
, const char *ptr
, const char **rptr
)
2981 MonoType
**type_argv
;
2982 MonoGenericInst
*ginst
;
2985 type_argv
= g_new0 (MonoType
*, count
);
2987 for (i
= 0; i
< count
; i
++) {
2988 MonoType
*t
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
2999 ginst
= mono_metadata_get_generic_inst (count
, type_argv
);
3007 do_mono_metadata_parse_generic_class (MonoType
*type
, MonoImage
*m
, MonoGenericContainer
*container
,
3008 const char *ptr
, const char **rptr
)
3010 MonoGenericInst
*inst
;
3015 gtype
= mono_metadata_parse_type (m
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
3019 gklass
= mono_class_from_mono_type (gtype
);
3020 if (!gklass
->generic_container
)
3023 count
= mono_metadata_decode_value (ptr
, &ptr
);
3024 inst
= mono_metadata_parse_generic_inst (m
, container
, count
, ptr
, &ptr
);
3031 type
->data
.generic_class
= mono_metadata_lookup_generic_class (gklass
, inst
, FALSE
);
3037 * @gc: The generic container to normalize
3038 * @type: The kind of generic parameters the resulting generic-container should contain
3041 static MonoGenericContainer
*
3042 select_container (MonoGenericContainer
*gc
, MonoTypeEnum type
)
3044 gboolean is_var
= (type
== MONO_TYPE_VAR
);
3048 g_assert (is_var
|| type
== MONO_TYPE_MVAR
);
3051 if (gc
->is_method
|| gc
->parent
)
3053 * The current MonoGenericContainer is a generic method -> its `parent'
3054 * points to the containing class'es container.
3063 * mono_metadata_parse_generic_param:
3064 * @generic_container: Our MonoClass's or MonoMethod's MonoGenericContainer;
3065 * see mono_metadata_parse_type_full() for details.
3066 * Internal routine to parse a generic type parameter.
3067 * LOCKING: Acquires the loader lock
3069 static MonoGenericParam
*
3070 mono_metadata_parse_generic_param (MonoImage
*m
, MonoGenericContainer
*generic_container
,
3071 MonoTypeEnum type
, const char *ptr
, const char **rptr
)
3073 int index
= mono_metadata_decode_value (ptr
, &ptr
);
3077 generic_container
= select_container (generic_container
, type
);
3078 if (!generic_container
) {
3079 /* Create dummy MonoGenericParam */
3080 MonoGenericParam
*param
;
3082 param
= mono_image_alloc0 (m
, sizeof (MonoGenericParam
));
3089 if (index
>= generic_container
->type_argc
)
3092 return mono_generic_container_get_param (generic_container
, index
);
3096 * mono_metadata_get_shared_type:
3098 * Return a shared instance of TYPE, if available, NULL otherwise.
3099 * Shared MonoType instances help save memory. Their contents should not be modified
3100 * by the caller. They do not need to be freed as their lifetime is bound by either
3101 * the lifetime of the runtime (builtin types), or the lifetime of the MonoClass
3102 * instance they are embedded in. If they are freed, they should be freed using
3103 * mono_metadata_free_type () instead of g_free ().
3106 mono_metadata_get_shared_type (MonoType
*type
)
3110 /* No need to use locking since nobody is modifying the hash table */
3111 if ((cached
= g_hash_table_lookup (type_cache
, type
)))
3114 switch (type
->type
){
3115 case MONO_TYPE_CLASS
:
3116 case MONO_TYPE_VALUETYPE
:
3117 if (type
== &type
->data
.klass
->byval_arg
)
3119 if (type
== &type
->data
.klass
->this_arg
)
3128 compare_type_literals (int class_type
, int type_type
)
3130 /* byval_arg.type can be zero if we're decoding a type that references a class been loading.
3131 * See mcs/test/gtest-440. and #650936.
3132 * FIXME This better be moved to the metadata verifier as it can catch more cases.
3136 /* NET 1.1 assemblies might encode string and object in a denormalized way.
3139 if (type_type
== MONO_TYPE_CLASS
&& (class_type
== MONO_TYPE_STRING
|| class_type
== MONO_TYPE_OBJECT
))
3141 return class_type
== type_type
;
3145 * do_mono_metadata_parse_type:
3146 * @type: MonoType to be filled in with the return value
3148 * @generic_context: generics_context
3149 * @transient: whenever to allocate data from the heap
3150 * @ptr: pointer to the encoded type
3151 * @rptr: pointer where the end of the encoded type is saved
3153 * Internal routine used to "fill" the contents of @type from an
3154 * allocated pointer. This is done this way to avoid doing too
3155 * many mini-allocations (particularly for the MonoFieldType which
3156 * most of the time is just a MonoType, but sometimes might be augmented).
3158 * This routine is used by mono_metadata_parse_type and
3159 * mono_metadata_parse_field_type
3161 * This extracts a Type as specified in Partition II (22.2.12)
3163 * Returns: FALSE if the type could not be loaded
3166 do_mono_metadata_parse_type (MonoType
*type
, MonoImage
*m
, MonoGenericContainer
*container
,
3167 gboolean transient
, const char *ptr
, const char **rptr
)
3170 type
->type
= mono_metadata_decode_value (ptr
, &ptr
);
3172 switch (type
->type
){
3173 case MONO_TYPE_VOID
:
3174 case MONO_TYPE_BOOLEAN
:
3175 case MONO_TYPE_CHAR
:
3188 case MONO_TYPE_STRING
:
3189 case MONO_TYPE_OBJECT
:
3190 case MONO_TYPE_TYPEDBYREF
:
3192 case MONO_TYPE_VALUETYPE
:
3193 case MONO_TYPE_CLASS
: {
3197 token
= mono_metadata_parse_typedef_or_ref (m
, ptr
, &ptr
);
3198 class = mono_class_get_checked (m
, token
, &error
);
3199 type
->data
.klass
= class;
3201 mono_loader_set_error_from_mono_error (&error
);
3202 mono_error_cleanup (&error
); /*FIXME don't swallow the error message*/
3205 if (!compare_type_literals (class->byval_arg
.type
, type
->type
))
3209 case MONO_TYPE_SZARRAY
: {
3210 MonoType
*etype
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_MOD_TYPE
, 0, ptr
, &ptr
);
3213 type
->data
.klass
= mono_class_from_mono_type (etype
);
3214 if (!type
->data
.klass
)
3219 type
->data
.type
= mono_metadata_parse_type_internal (m
, container
, MONO_PARSE_MOD_TYPE
, 0, transient
, ptr
, &ptr
);
3220 if (!type
->data
.type
)
3223 case MONO_TYPE_FNPTR
:
3224 type
->data
.method
= mono_metadata_parse_method_signature_full (m
, container
, 0, ptr
, &ptr
);
3225 if (!type
->data
.method
)
3228 case MONO_TYPE_ARRAY
:
3229 type
->data
.array
= mono_metadata_parse_array_internal (m
, container
, transient
, ptr
, &ptr
);
3230 if (!type
->data
.array
)
3233 case MONO_TYPE_MVAR
:
3234 if (container
&& !container
->is_method
)
3237 type
->data
.generic_param
= mono_metadata_parse_generic_param (m
, container
, type
->type
, ptr
, &ptr
);
3238 if (!type
->data
.generic_param
)
3241 case MONO_TYPE_GENERICINST
:
3242 ok
= do_mono_metadata_parse_generic_class (type
, m
, container
, ptr
, &ptr
);
3245 g_warning ("type 0x%02x not handled in do_mono_metadata_parse_type on image %s", type
->type
, m
->name
);
3255 * mono_metadata_free_type:
3256 * @type: type to free
3258 * Free the memory allocated for type @type which is allocated on the heap.
3261 mono_metadata_free_type (MonoType
*type
)
3263 if (type
>= builtin_types
&& type
< builtin_types
+ NBUILTIN_TYPES ())
3266 switch (type
->type
){
3267 case MONO_TYPE_OBJECT
:
3268 case MONO_TYPE_STRING
:
3269 if (!type
->data
.klass
)
3272 case MONO_TYPE_CLASS
:
3273 case MONO_TYPE_VALUETYPE
:
3274 if (type
== &type
->data
.klass
->byval_arg
|| type
== &type
->data
.klass
->this_arg
)
3278 mono_metadata_free_type (type
->data
.type
);
3280 case MONO_TYPE_FNPTR
:
3281 mono_metadata_free_method_signature (type
->data
.method
);
3283 case MONO_TYPE_ARRAY
:
3284 mono_metadata_free_array (type
->data
.array
);
3293 hex_dump (const char *buffer
, int base
, int count
)
3295 int show_header
= 1;
3303 for (i
= 0; i
< count
; i
++){
3306 printf ("\n0x%08x: ", (unsigned char) base
+ i
);
3308 printf ("%02x ", (unsigned char) (buffer
[i
]));
3315 * @ptr: Points to the beginning of the Section Data (25.3)
3317 static MonoExceptionClause
*
3318 parse_section_data (MonoImage
*m
, int *num_clauses
, const unsigned char *ptr
)
3320 unsigned char sect_data_flags
;
3321 const unsigned char *sptr
;
3323 guint32 sect_data_len
;
3324 MonoExceptionClause
* clauses
= NULL
;
3327 /* align on 32-bit boundary */
3328 sptr
= ptr
= dword_align (ptr
);
3329 sect_data_flags
= *ptr
;
3332 is_fat
= sect_data_flags
& METHOD_HEADER_SECTION_FAT_FORMAT
;
3334 sect_data_len
= (ptr
[2] << 16) | (ptr
[1] << 8) | ptr
[0];
3337 sect_data_len
= ptr
[0];
3341 g_print ("flags: %02x, len: %d\n", sect_data_flags, sect_data_len);
3342 hex_dump (sptr, 0, sect_data_len+8);
3343 g_print ("\nheader: ");
3344 hex_dump (sptr-4, 0, 4);
3348 if (sect_data_flags
& METHOD_HEADER_SECTION_EHTABLE
) {
3349 const unsigned char *p
= dword_align (ptr
);
3351 *num_clauses
= is_fat
? sect_data_len
/ 24: sect_data_len
/ 12;
3352 /* we could just store a pointer if we don't need to byteswap */
3353 clauses
= g_malloc0 (sizeof (MonoExceptionClause
) * (*num_clauses
));
3354 for (i
= 0; i
< *num_clauses
; ++i
) {
3355 MonoExceptionClause
*ec
= &clauses
[i
];
3358 ec
->flags
= read32 (p
);
3359 ec
->try_offset
= read32 (p
+ 4);
3360 ec
->try_len
= read32 (p
+ 8);
3361 ec
->handler_offset
= read32 (p
+ 12);
3362 ec
->handler_len
= read32 (p
+ 16);
3363 tof_value
= read32 (p
+ 20);
3366 ec
->flags
= read16 (p
);
3367 ec
->try_offset
= read16 (p
+ 2);
3368 ec
->try_len
= *(p
+ 4);
3369 ec
->handler_offset
= read16 (p
+ 5);
3370 ec
->handler_len
= *(p
+ 7);
3371 tof_value
= read32 (p
+ 8);
3374 if (ec
->flags
== MONO_EXCEPTION_CLAUSE_FILTER
) {
3375 ec
->data
.filter_offset
= tof_value
;
3376 } else if (ec
->flags
== MONO_EXCEPTION_CLAUSE_NONE
) {
3377 ec
->data
.catch_class
= NULL
;
3380 ec
->data
.catch_class
= mono_class_get_checked (m
, tof_value
, &error
);
3381 if (!mono_error_ok (&error
)) {
3382 mono_error_cleanup (&error
); /* FIXME don't swallow the error */
3388 ec
->data
.catch_class
= NULL
;
3390 /* g_print ("try %d: %x %04x-%04x %04x\n", i, ec->flags, ec->try_offset, ec->try_offset+ec->try_len, ec->try_len); */
3394 if (sect_data_flags
& METHOD_HEADER_SECTION_MORE_SECTS
)
3395 ptr
+= sect_data_len
- 4; /* LAMESPEC: it seems the size includes the header */
3402 * mono_method_get_header_summary:
3403 * @method: The method to get the header.
3404 * @summary: Where to store the header
3407 * Returns: true if the header was properly decoded.
3410 mono_method_get_header_summary (MonoMethod
*method
, MonoMethodHeaderSummary
*summary
)
3416 unsigned char flags
, format
;
3419 /*Only the GMD has a pointer to the metadata.*/
3420 while (method
->is_inflated
)
3421 method
= ((MonoMethodInflated
*)method
)->declaring
;
3423 summary
->code_size
= 0;
3424 summary
->has_clauses
= FALSE
;
3426 /*FIXME extract this into a MACRO and share it with mono_method_get_header*/
3427 if ((method
->flags
& METHOD_ATTRIBUTE_ABSTRACT
) || (method
->iflags
& METHOD_IMPL_ATTRIBUTE_RUNTIME
) || (method
->iflags
& METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL
) || (method
->flags
& METHOD_ATTRIBUTE_PINVOKE_IMPL
))
3430 if (method
->wrapper_type
!= MONO_WRAPPER_NONE
|| method
->sre_method
) {
3431 MonoMethodHeader
*header
= ((MonoMethodWrapper
*)method
)->header
;
3434 summary
->code_size
= header
->code_size
;
3435 summary
->has_clauses
= header
->num_clauses
> 0;
3440 idx
= mono_metadata_token_index (method
->token
);
3441 img
= method
->klass
->image
;
3442 rva
= mono_metadata_decode_row_col (&img
->tables
[MONO_TABLE_METHOD
], idx
- 1, MONO_METHOD_RVA
);
3444 /*We must run the verifier since we'll be decoding it.*/
3445 if (!mono_verifier_verify_method_header (img
, rva
, NULL
))
3448 ptr
= mono_image_rva_map (img
, rva
);
3451 flags
= *(const unsigned char *)ptr
;
3452 format
= flags
& METHOD_HEADER_FORMAT_MASK
;
3455 case METHOD_HEADER_TINY_FORMAT
:
3457 summary
->code_size
= flags
>> 2;
3459 case METHOD_HEADER_FAT_FORMAT
:
3460 fat_flags
= read16 (ptr
);
3462 summary
->code_size
= read32 (ptr
);
3463 if (fat_flags
& METHOD_HEADER_MORE_SECTS
)
3464 summary
->has_clauses
= TRUE
;
3473 * mono_metadata_parse_mh_full:
3474 * @m: metadata context
3475 * @generic_context: generics context
3476 * @ptr: pointer to the method header.
3478 * Decode the method header at @ptr, including pointer to the IL code,
3479 * info about local variables and optional exception tables.
3480 * This is a Mono runtime internal function.
3482 * LOCKING: Acquires the loader lock.
3484 * Returns: a transient MonoMethodHeader allocated from the heap.
3487 mono_metadata_parse_mh_full (MonoImage
*m
, MonoGenericContainer
*container
, const char *ptr
)
3489 MonoMethodHeader
*mh
= NULL
;
3490 unsigned char flags
= *(const unsigned char *) ptr
;
3491 unsigned char format
= flags
& METHOD_HEADER_FORMAT_MASK
;
3493 guint32 local_var_sig_tok
, max_stack
, code_size
, init_locals
;
3494 const unsigned char *code
;
3495 MonoExceptionClause
* clauses
= NULL
;
3496 int hsize
, num_clauses
= 0;
3497 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_STANDALONESIG
];
3498 guint32 cols
[MONO_STAND_ALONE_SIGNATURE_SIZE
];
3500 g_return_val_if_fail (ptr
!= NULL
, NULL
);
3503 case METHOD_HEADER_TINY_FORMAT
:
3504 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
);
3507 mh
->is_transient
= TRUE
;
3508 local_var_sig_tok
= 0;
3509 mh
->code_size
= flags
>> 2;
3510 mh
->code
= (unsigned char*)ptr
;
3512 case METHOD_HEADER_FAT_FORMAT
:
3513 fat_flags
= read16 (ptr
);
3515 hsize
= (fat_flags
>> 12) & 0xf;
3516 max_stack
= read16 (ptr
);
3518 code_size
= read32 (ptr
);
3520 local_var_sig_tok
= read32 (ptr
);
3523 if (fat_flags
& METHOD_HEADER_INIT_LOCALS
)
3528 code
= (unsigned char*)ptr
;
3530 if (!(fat_flags
& METHOD_HEADER_MORE_SECTS
))
3534 * There are more sections
3536 ptr
= (char*)code
+ code_size
;
3542 if (local_var_sig_tok
) {
3543 int idx
= (local_var_sig_tok
& 0xffffff)-1;
3544 if (idx
>= t
->rows
|| idx
< 0)
3546 mono_metadata_decode_row (t
, idx
, cols
, 1);
3548 if (!mono_verifier_verify_standalone_signature (m
, cols
[MONO_STAND_ALONE_SIGNATURE
], NULL
))
3551 if (fat_flags
& METHOD_HEADER_MORE_SECTS
)
3552 clauses
= parse_section_data (m
, &num_clauses
, (const unsigned char*)ptr
);
3553 if (local_var_sig_tok
) {
3554 const char *locals_ptr
;
3555 int len
=0, i
, bsize
;
3557 locals_ptr
= mono_metadata_blob_heap (m
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
3558 bsize
= mono_metadata_decode_blob_size (locals_ptr
, &locals_ptr
);
3559 if (*locals_ptr
!= 0x07)
3560 g_warning ("wrong signature for locals blob");
3562 len
= mono_metadata_decode_value (locals_ptr
, &locals_ptr
);
3563 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
+ len
* sizeof (MonoType
*) + num_clauses
* sizeof (MonoExceptionClause
));
3564 mh
->num_locals
= len
;
3565 for (i
= 0; i
< len
; ++i
) {
3566 mh
->locals
[i
] = mono_metadata_parse_type_internal (m
, container
,
3567 MONO_PARSE_LOCAL
, 0, TRUE
, locals_ptr
, &locals_ptr
);
3568 if (!mh
->locals
[i
])
3572 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
+ num_clauses
* sizeof (MonoExceptionClause
));
3575 mh
->code_size
= code_size
;
3576 mh
->max_stack
= max_stack
;
3577 mh
->is_transient
= TRUE
;
3578 mh
->init_locals
= init_locals
;
3580 MonoExceptionClause
* clausesp
= (MonoExceptionClause
*)&mh
->locals
[mh
->num_locals
];
3581 memcpy (clausesp
, clauses
, num_clauses
* sizeof (MonoExceptionClause
));
3583 mh
->clauses
= clausesp
;
3584 mh
->num_clauses
= num_clauses
;
3595 * mono_metadata_parse_mh:
3596 * @generic_context: generics context
3597 * @ptr: pointer to the method header.
3599 * Decode the method header at @ptr, including pointer to the IL code,
3600 * info about local variables and optional exception tables.
3602 * Returns: a transient MonoMethodHeader allocated from the heap.
3605 mono_metadata_parse_mh (MonoImage
*m
, const char *ptr
)
3607 return mono_metadata_parse_mh_full (m
, NULL
, ptr
);
3611 * mono_metadata_free_mh:
3612 * @mh: a method header
3614 * Free the memory allocated for the method header.
3617 mono_metadata_free_mh (MonoMethodHeader
*mh
)
3621 /* If it is not transient it means it's part of a wrapper method,
3622 * or a SRE-generated method, so the lifetime in that case is
3623 * dictated by the method's own lifetime
3625 if (mh
->is_transient
) {
3626 for (i
= 0; i
< mh
->num_locals
; ++i
)
3627 mono_metadata_free_type (mh
->locals
[i
]);
3633 * mono_method_header_get_code:
3634 * @header: a MonoMethodHeader pointer
3635 * @code_size: memory location for returning the code size
3636 * @max_stack: memory location for returning the max stack
3638 * Method header accessor to retreive info about the IL code properties:
3639 * a pointer to the IL code itself, the size of the code and the max number
3640 * of stack slots used by the code.
3642 * Returns: pointer to the IL code represented by the method header.
3644 const unsigned char*
3645 mono_method_header_get_code (MonoMethodHeader
*header
, guint32
* code_size
, guint32
* max_stack
)
3648 *code_size
= header
->code_size
;
3650 *max_stack
= header
->max_stack
;
3651 return header
->code
;
3655 * mono_method_header_get_locals:
3656 * @header: a MonoMethodHeader pointer
3657 * @num_locals: memory location for returning the number of local variables
3658 * @init_locals: memory location for returning the init_locals flag
3660 * Method header accessor to retreive info about the local variables:
3661 * an array of local types, the number of locals and whether the locals
3662 * are supposed to be initialized to 0 on method entry
3664 * Returns: pointer to an array of types of the local variables
3667 mono_method_header_get_locals (MonoMethodHeader
*header
, guint32
* num_locals
, gboolean
*init_locals
)
3670 *num_locals
= header
->num_locals
;
3672 *init_locals
= header
->init_locals
;
3673 return header
->locals
;
3677 * mono_method_header_get_num_clauses:
3678 * @header: a MonoMethodHeader pointer
3680 * Method header accessor to retreive the number of exception clauses.
3682 * Returns: the number of exception clauses present
3685 mono_method_header_get_num_clauses (MonoMethodHeader
*header
)
3687 return header
->num_clauses
;
3691 * mono_method_header_get_clauses:
3692 * @header: a MonoMethodHeader pointer
3693 * @method: MonoMethod the header belongs to
3694 * @iter: pointer to a iterator
3695 * @clause: pointer to a MonoExceptionClause structure which will be filled with the info
3697 * Get the info about the exception clauses in the method. Set *iter to NULL to
3698 * initiate the iteration, then call the method repeatedly until it returns FALSE.
3699 * At each iteration, the structure pointed to by clause if filled with the
3700 * exception clause information.
3702 * Returns: TRUE if clause was filled with info, FALSE if there are no more exception
3706 mono_method_header_get_clauses (MonoMethodHeader
*header
, MonoMethod
*method
, gpointer
*iter
, MonoExceptionClause
*clause
)
3708 MonoExceptionClause
*sc
;
3709 /* later we'll be able to use this interface to parse the clause info on demand,
3710 * without allocating anything.
3712 if (!iter
|| !header
->num_clauses
)
3715 *iter
= sc
= header
->clauses
;
3721 if (sc
< header
->clauses
+ header
->num_clauses
) {
3730 * mono_metadata_parse_field_type:
3731 * @m: metadata context to extract information from
3732 * @ptr: pointer to the field signature
3733 * @rptr: pointer updated to match the end of the decoded stream
3735 * Parses the field signature, and returns the type information for it.
3737 * Returns: The MonoType that was extracted from @ptr.
3740 mono_metadata_parse_field_type (MonoImage
*m
, short field_flags
, const char *ptr
, const char **rptr
)
3742 return mono_metadata_parse_type (m
, MONO_PARSE_FIELD
, field_flags
, ptr
, rptr
);
3746 * mono_metadata_parse_param:
3747 * @m: metadata context to extract information from
3748 * @ptr: pointer to the param signature
3749 * @rptr: pointer updated to match the end of the decoded stream
3751 * Parses the param signature, and returns the type information for it.
3753 * Returns: The MonoType that was extracted from @ptr.
3756 mono_metadata_parse_param (MonoImage
*m
, const char *ptr
, const char **rptr
)
3758 return mono_metadata_parse_type (m
, MONO_PARSE_PARAM
, 0, ptr
, rptr
);
3762 * mono_metadata_token_from_dor:
3763 * @dor_token: A TypeDefOrRef coded index
3765 * dor_token is a TypeDefOrRef coded index: it contains either
3766 * a TypeDef, TypeRef or TypeSpec in the lower bits, and the upper
3767 * bits contain an index into the table.
3769 * Returns: an expanded token
3772 mono_metadata_token_from_dor (guint32 dor_index
)
3776 table
= dor_index
& 0x03;
3777 idx
= dor_index
>> 2;
3780 case 0: /* TypeDef */
3781 return MONO_TOKEN_TYPE_DEF
| idx
;
3782 case 1: /* TypeRef */
3783 return MONO_TOKEN_TYPE_REF
| idx
;
3784 case 2: /* TypeSpec */
3785 return MONO_TOKEN_TYPE_SPEC
| idx
;
3787 g_assert_not_reached ();
3794 * We use this to pass context information to the row locator
3797 int idx
; /* The index that we are trying to locate */
3798 int col_idx
; /* The index in the row where idx may be stored */
3799 MonoTableInfo
*t
; /* pointer to the table */
3804 * How the row locator works.
3809 * ___|___------> _______
3812 * A column in the rows of table A references an index in table B.
3813 * For example A may be the TYPEDEF table and B the METHODDEF table.
3815 * Given an index in table B we want to get the row in table A
3816 * where the column n references our index in B.
3818 * In the locator_t structure:
3820 * col_idx is the column number
3821 * index is the index in table B
3822 * result will be the index in table A
3825 * Table A Table B column (in table A)
3826 * TYPEDEF METHODDEF MONO_TYPEDEF_METHOD_LIST
3827 * TYPEDEF FIELD MONO_TYPEDEF_FIELD_LIST
3828 * PROPERTYMAP PROPERTY MONO_PROPERTY_MAP_PROPERTY_LIST
3829 * INTERFIMPL TYPEDEF MONO_INTERFACEIMPL_CLASS
3830 * METHODSEM PROPERTY ASSOCIATION (encoded index)
3832 * Note that we still don't support encoded indexes.
3836 typedef_locator (const void *a
, const void *b
)
3838 locator_t
*loc
= (locator_t
*) a
;
3839 const char *bb
= (const char *) b
;
3840 int typedef_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3841 guint32 col
, col_next
;
3843 col
= mono_metadata_decode_row_col (loc
->t
, typedef_index
, loc
->col_idx
);
3849 * Need to check that the next row is valid.
3851 if (typedef_index
+ 1 < loc
->t
->rows
) {
3852 col_next
= mono_metadata_decode_row_col (loc
->t
, typedef_index
+ 1, loc
->col_idx
);
3853 if (loc
->idx
>= col_next
)
3856 if (col
== col_next
)
3860 loc
->result
= typedef_index
;
3866 table_locator (const void *a
, const void *b
)
3868 locator_t
*loc
= (locator_t
*) a
;
3869 const char *bb
= (const char *) b
;
3870 guint32 table_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3873 col
= mono_metadata_decode_row_col (loc
->t
, table_index
, loc
->col_idx
);
3875 if (loc
->idx
== col
) {
3876 loc
->result
= table_index
;
3886 declsec_locator (const void *a
, const void *b
)
3888 locator_t
*loc
= (locator_t
*) a
;
3889 const char *bb
= (const char *) b
;
3890 guint32 table_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3893 col
= mono_metadata_decode_row_col (loc
->t
, table_index
, loc
->col_idx
);
3895 if (loc
->idx
== col
) {
3896 loc
->result
= table_index
;
3908 * Return the 1-based row index in TABLE, which must be one of the *Ptr tables,
3909 * which contains IDX.
3912 search_ptr_table (MonoImage
*image
, int table
, int idx
)
3914 MonoTableInfo
*ptrdef
= &image
->tables
[table
];
3917 /* Use a linear search to find our index in the table */
3918 for (i
= 0; i
< ptrdef
->rows
; i
++)
3919 /* All the Ptr tables have the same structure */
3920 if (mono_metadata_decode_row_col (ptrdef
, i
, 0) == idx
)
3923 if (i
< ptrdef
->rows
)
3930 * mono_metadata_typedef_from_field:
3931 * @meta: metadata context
3932 * @index: FieldDef token
3934 * Returns: the 1-based index into the TypeDef table of the type that
3935 * declared the field described by @index, or 0 if not found.
3938 mono_metadata_typedef_from_field (MonoImage
*meta
, guint32 index
)
3940 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_TYPEDEF
];
3946 loc
.idx
= mono_metadata_token_index (index
);
3947 loc
.col_idx
= MONO_TYPEDEF_FIELD_LIST
;
3950 if (meta
->uncompressed_metadata
)
3951 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_FIELD_POINTER
, loc
.idx
);
3953 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, typedef_locator
))
3956 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
3957 return loc
.result
+ 1;
3961 * mono_metadata_typedef_from_method:
3962 * @meta: metadata context
3963 * @index: MethodDef token
3965 * Returns: the 1-based index into the TypeDef table of the type that
3966 * declared the method described by @index. 0 if not found.
3969 mono_metadata_typedef_from_method (MonoImage
*meta
, guint32 index
)
3971 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_TYPEDEF
];
3977 loc
.idx
= mono_metadata_token_index (index
);
3978 loc
.col_idx
= MONO_TYPEDEF_METHOD_LIST
;
3981 if (meta
->uncompressed_metadata
)
3982 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_METHOD_POINTER
, loc
.idx
);
3984 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, typedef_locator
))
3987 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
3988 return loc
.result
+ 1;
3992 * mono_metadata_interfaces_from_typedef_full:
3993 * @meta: metadata context
3994 * @index: typedef token
3995 * @interfaces: Out parameter used to store the interface array
3996 * @count: Out parameter used to store the number of interfaces
3997 * @heap_alloc_result: if TRUE the result array will be g_malloc'd
3998 * @context: The generic context
4000 * The array of interfaces that the @index typedef token implements is returned in
4001 * @interfaces. The number of elements in the array is returned in @count.
4004 * Returns: TRUE on success, FALSE on failure.
4007 mono_metadata_interfaces_from_typedef_full (MonoImage
*meta
, guint32 index
, MonoClass
***interfaces
, guint
*count
, gboolean heap_alloc_result
, MonoGenericContext
*context
, MonoError
*error
)
4009 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_INTERFACEIMPL
];
4012 guint32 cols
[MONO_INTERFACEIMPL_SIZE
];
4018 mono_error_init (error
);
4023 loc
.idx
= mono_metadata_token_index (index
);
4024 loc
.col_idx
= MONO_INTERFACEIMPL_CLASS
;
4027 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4032 * We may end up in the middle of the rows...
4035 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_INTERFACEIMPL_CLASS
))
4041 while (pos
< tdef
->rows
) {
4042 mono_metadata_decode_row (tdef
, pos
, cols
, MONO_INTERFACEIMPL_SIZE
);
4043 if (cols
[MONO_INTERFACEIMPL_CLASS
] != loc
.idx
)
4048 if (heap_alloc_result
)
4049 result
= g_new0 (MonoClass
*, pos
- start
);
4051 result
= mono_image_alloc0 (meta
, sizeof (MonoClass
*) * (pos
- start
));
4054 while (pos
< tdef
->rows
) {
4057 mono_metadata_decode_row (tdef
, pos
, cols
, MONO_INTERFACEIMPL_SIZE
);
4058 if (cols
[MONO_INTERFACEIMPL_CLASS
] != loc
.idx
)
4060 iface
= mono_class_get_and_inflate_typespec_checked (
4061 meta
, mono_metadata_token_from_dor (cols
[MONO_INTERFACEIMPL_INTERFACE
]), context
, error
);
4064 result
[pos
- start
] = iface
;
4067 *count
= pos
- start
;
4068 *interfaces
= result
;
4073 * @meta: metadata context
4074 * @index: typedef token
4075 * @count: Out parameter used to store the number of interfaces
4077 * The array of interfaces that the @index typedef token implements is returned in
4078 * @interfaces. The number of elements in the array is returned in @count. The returned
4079 * array is g_malloc'd and the caller must free it.
4081 * LOCKING: Acquires the loader lock .
4083 * Returns: the interface array on success, NULL on failure.
4087 mono_metadata_interfaces_from_typedef (MonoImage
*meta
, guint32 index
, guint
*count
)
4090 MonoClass
**interfaces
= NULL
;
4093 rv
= mono_metadata_interfaces_from_typedef_full (meta
, index
, &interfaces
, count
, TRUE
, NULL
, &error
);
4094 g_assert (mono_error_ok (&error
)); /* FIXME dont swallow the error */
4102 * mono_metadata_nested_in_typedef:
4103 * @meta: metadata context
4104 * @index: typedef token
4106 * Returns: the 1-based index into the TypeDef table of the type
4107 * where the type described by @index is nested.
4108 * Returns 0 if @index describes a non-nested type.
4111 mono_metadata_nested_in_typedef (MonoImage
*meta
, guint32 index
)
4113 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_NESTEDCLASS
];
4119 loc
.idx
= mono_metadata_token_index (index
);
4120 loc
.col_idx
= MONO_NESTED_CLASS_NESTED
;
4123 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4126 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4127 return mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_NESTED_CLASS_ENCLOSING
) | MONO_TOKEN_TYPE_DEF
;
4131 * mono_metadata_nesting_typedef:
4132 * @meta: metadata context
4133 * @index: typedef token
4135 * Returns: the 1-based index into the TypeDef table of the first type
4136 * that is nested inside the type described by @index. The search starts at
4137 * @start_index. returns 0 if no such type is found.
4140 mono_metadata_nesting_typedef (MonoImage
*meta
, guint32 index
, guint32 start_index
)
4142 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_NESTEDCLASS
];
4144 guint32 class_index
= mono_metadata_token_index (index
);
4149 start
= start_index
;
4151 while (start
<= tdef
->rows
) {
4152 if (class_index
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_NESTED_CLASS_ENCLOSING
))
4158 if (start
> tdef
->rows
)
4165 * mono_metadata_packing_from_typedef:
4166 * @meta: metadata context
4167 * @index: token representing a type
4169 * Returns: the info stored in the ClassLAyout table for the given typedef token
4170 * into the @packing and @size pointers.
4171 * Returns 0 if the info is not found.
4174 mono_metadata_packing_from_typedef (MonoImage
*meta
, guint32 index
, guint32
*packing
, guint32
*size
)
4176 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_CLASSLAYOUT
];
4178 guint32 cols
[MONO_CLASS_LAYOUT_SIZE
];
4183 loc
.idx
= mono_metadata_token_index (index
);
4184 loc
.col_idx
= MONO_CLASS_LAYOUT_PARENT
;
4187 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4190 mono_metadata_decode_row (tdef
, loc
.result
, cols
, MONO_CLASS_LAYOUT_SIZE
);
4192 *packing
= cols
[MONO_CLASS_LAYOUT_PACKING_SIZE
];
4194 *size
= cols
[MONO_CLASS_LAYOUT_CLASS_SIZE
];
4196 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4197 return loc
.result
+ 1;
4201 * mono_metadata_custom_attrs_from_index:
4202 * @meta: metadata context
4203 * @index: token representing the parent
4205 * Returns: the 1-based index into the CustomAttribute table of the first
4206 * attribute which belongs to the metadata object described by @index.
4207 * Returns 0 if no such attribute is found.
4210 mono_metadata_custom_attrs_from_index (MonoImage
*meta
, guint32 index
)
4212 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_CUSTOMATTRIBUTE
];
4219 loc
.col_idx
= MONO_CUSTOM_ATTR_PARENT
;
4222 /* FIXME: Index translation */
4224 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4227 /* Find the first entry by searching backwards */
4228 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_CUSTOM_ATTR_PARENT
) == index
))
4231 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4232 return loc
.result
+ 1;
4236 * mono_metadata_declsec_from_index:
4237 * @meta: metadata context
4238 * @index: token representing the parent
4240 * Returns: the 0-based index into the DeclarativeSecurity table of the first
4241 * attribute which belongs to the metadata object described by @index.
4242 * Returns -1 if no such attribute is found.
4245 mono_metadata_declsec_from_index (MonoImage
*meta
, guint32 index
)
4247 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_DECLSECURITY
];
4254 loc
.col_idx
= MONO_DECL_SECURITY_PARENT
;
4257 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, declsec_locator
))
4260 /* Find the first entry by searching backwards */
4261 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_DECL_SECURITY_PARENT
) == index
))
4269 mono_backtrace (int limit
)
4274 backtrace (array
, limit
);
4275 names
= backtrace_symbols (array
, limit
);
4276 for (i
=0; i
< limit
; ++i
) {
4277 g_print ("\t%s\n", names
[i
]);
4283 static int i8_align
;
4286 * mono_type_set_alignment:
4288 * Set the alignment used by runtime to layout fields etc. of type TYPE to ALIGN.
4289 * This should only be used in AOT mode since the resulting layout will not match the
4293 mono_type_set_alignment (MonoTypeEnum type
, int align
)
4295 /* Support only a few types whose alignment is abi dependent */
4301 g_assert_not_reached ();
4308 * @t: the type to return the size of
4310 * Returns: the number of bytes required to hold an instance of this
4314 mono_type_size (MonoType
*t
, int *align
)
4321 *align
= MONO_ABI_ALIGNOF (gpointer
);
4322 return sizeof (gpointer
);
4326 case MONO_TYPE_VOID
:
4329 case MONO_TYPE_BOOLEAN
:
4330 *align
= MONO_ABI_ALIGNOF (gint8
);
4334 *align
= MONO_ABI_ALIGNOF (gint8
);
4336 case MONO_TYPE_CHAR
:
4339 *align
= MONO_ABI_ALIGNOF (gint16
);
4343 *align
= MONO_ABI_ALIGNOF (gint32
);
4346 *align
= MONO_ABI_ALIGNOF (float);
4350 *align
= MONO_ABI_ALIGNOF (gint64
);
4353 *align
= MONO_ABI_ALIGNOF (double);
4357 *align
= MONO_ABI_ALIGNOF (gpointer
);
4358 return sizeof (gpointer
);
4359 case MONO_TYPE_STRING
:
4360 *align
= MONO_ABI_ALIGNOF (gpointer
);
4361 return sizeof (gpointer
);
4362 case MONO_TYPE_OBJECT
:
4363 *align
= MONO_ABI_ALIGNOF (gpointer
);
4364 return sizeof (gpointer
);
4365 case MONO_TYPE_VALUETYPE
: {
4366 if (t
->data
.klass
->enumtype
)
4367 return mono_type_size (mono_class_enum_basetype (t
->data
.klass
), align
);
4369 return mono_class_value_size (t
->data
.klass
, (guint32
*)align
);
4371 case MONO_TYPE_CLASS
:
4372 case MONO_TYPE_SZARRAY
:
4374 case MONO_TYPE_FNPTR
:
4375 case MONO_TYPE_ARRAY
:
4376 *align
= MONO_ABI_ALIGNOF (gpointer
);
4377 return sizeof (gpointer
);
4378 case MONO_TYPE_TYPEDBYREF
:
4379 return mono_class_value_size (mono_defaults
.typed_reference_class
, (guint32
*)align
);
4380 case MONO_TYPE_GENERICINST
: {
4381 MonoGenericClass
*gclass
= t
->data
.generic_class
;
4382 MonoClass
*container_class
= gclass
->container_class
;
4384 // g_assert (!gclass->inst->is_open);
4386 if (container_class
->valuetype
) {
4387 if (container_class
->enumtype
)
4388 return mono_type_size (mono_class_enum_basetype (container_class
), align
);
4390 return mono_class_value_size (mono_class_from_mono_type (t
), (guint32
*)align
);
4392 *align
= MONO_ABI_ALIGNOF (gpointer
);
4393 return sizeof (gpointer
);
4397 case MONO_TYPE_MVAR
:
4398 /* FIXME: Martin, this is wrong. */
4399 *align
= MONO_ABI_ALIGNOF (gpointer
);
4400 return sizeof (gpointer
);
4402 g_error ("mono_type_size: type 0x%02x unknown", t
->type
);
4408 * mono_type_stack_size:
4409 * @t: the type to return the size it uses on the stack
4411 * Returns: the number of bytes required to hold an instance of this
4412 * type on the runtime stack
4415 mono_type_stack_size (MonoType
*t
, int *align
)
4417 return mono_type_stack_size_internal (t
, align
, FALSE
);
4421 mono_type_stack_size_internal (MonoType
*t
, int *align
, gboolean allow_open
)
4424 #if SIZEOF_VOID_P == SIZEOF_REGISTER
4425 int stack_slot_size
= sizeof (gpointer
);
4426 int stack_slot_align
= MONO_ABI_ALIGNOF (gpointer
);
4427 #elif SIZEOF_VOID_P < SIZEOF_REGISTER
4428 int stack_slot_size
= SIZEOF_REGISTER
;
4429 int stack_slot_align
= SIZEOF_REGISTER
;
4432 g_assert (t
!= NULL
);
4438 *align
= stack_slot_align
;
4439 return stack_slot_size
;
4443 case MONO_TYPE_BOOLEAN
:
4444 case MONO_TYPE_CHAR
:
4453 case MONO_TYPE_STRING
:
4454 case MONO_TYPE_OBJECT
:
4455 case MONO_TYPE_CLASS
:
4456 case MONO_TYPE_SZARRAY
:
4458 case MONO_TYPE_FNPTR
:
4459 case MONO_TYPE_ARRAY
:
4460 *align
= stack_slot_align
;
4461 return stack_slot_size
;
4463 case MONO_TYPE_MVAR
:
4464 g_assert (allow_open
);
4465 *align
= stack_slot_align
;
4466 return stack_slot_size
;
4467 case MONO_TYPE_TYPEDBYREF
:
4468 *align
= stack_slot_align
;
4469 return stack_slot_size
* 3;
4471 *align
= MONO_ABI_ALIGNOF (float);
4472 return sizeof (float);
4475 *align
= MONO_ABI_ALIGNOF (gint64
);
4476 return sizeof (gint64
);
4478 *align
= MONO_ABI_ALIGNOF (double);
4479 return sizeof (double);
4480 case MONO_TYPE_VALUETYPE
: {
4483 if (t
->data
.klass
->enumtype
)
4484 return mono_type_stack_size_internal (mono_class_enum_basetype (t
->data
.klass
), align
, allow_open
);
4486 size
= mono_class_value_size (t
->data
.klass
, (guint32
*)align
);
4488 *align
= *align
+ stack_slot_align
- 1;
4489 *align
&= ~(stack_slot_align
- 1);
4491 size
+= stack_slot_size
- 1;
4492 size
&= ~(stack_slot_size
- 1);
4497 case MONO_TYPE_GENERICINST
: {
4498 MonoGenericClass
*gclass
= t
->data
.generic_class
;
4499 MonoClass
*container_class
= gclass
->container_class
;
4502 g_assert (!gclass
->context
.class_inst
->is_open
);
4504 if (container_class
->valuetype
) {
4505 if (container_class
->enumtype
)
4506 return mono_type_stack_size_internal (mono_class_enum_basetype (container_class
), align
, allow_open
);
4508 guint32 size
= mono_class_value_size (mono_class_from_mono_type (t
), (guint32
*)align
);
4510 *align
= *align
+ stack_slot_align
- 1;
4511 *align
&= ~(stack_slot_align
- 1);
4513 size
+= stack_slot_size
- 1;
4514 size
&= ~(stack_slot_size
- 1);
4519 *align
= stack_slot_align
;
4520 return stack_slot_size
;
4524 g_error ("type 0x%02x unknown", t
->type
);
4530 mono_type_generic_inst_is_valuetype (MonoType
*type
)
4532 g_assert (type
->type
== MONO_TYPE_GENERICINST
);
4533 return type
->data
.generic_class
->container_class
->valuetype
;
4537 mono_metadata_generic_class_is_valuetype (MonoGenericClass
*gclass
)
4539 return gclass
->container_class
->valuetype
;
4543 _mono_metadata_generic_class_equal (const MonoGenericClass
*g1
, const MonoGenericClass
*g2
, gboolean signature_only
)
4545 MonoGenericInst
*i1
= g1
->context
.class_inst
;
4546 MonoGenericInst
*i2
= g2
->context
.class_inst
;
4548 if (g1
->is_dynamic
!= g2
->is_dynamic
)
4550 if (!mono_metadata_class_equal (g1
->container_class
, g2
->container_class
, signature_only
))
4552 if (!mono_generic_inst_equal_full (i1
, i2
, signature_only
))
4554 return g1
->is_tb_open
== g2
->is_tb_open
;
4558 _mono_metadata_generic_class_container_equal (const MonoGenericClass
*g1
, MonoClass
*c2
, gboolean signature_only
)
4560 MonoGenericInst
*i1
= g1
->context
.class_inst
;
4561 MonoGenericInst
*i2
= c2
->generic_container
->context
.class_inst
;
4563 if (!mono_metadata_class_equal (g1
->container_class
, c2
, signature_only
))
4565 if (!mono_generic_inst_equal_full (i1
, i2
, signature_only
))
4567 return !g1
->is_tb_open
;
4571 mono_metadata_generic_context_hash (const MonoGenericContext
*context
)
4573 /* FIXME: check if this seed is good enough */
4574 guint hash
= 0xc01dfee7;
4575 if (context
->class_inst
)
4576 hash
= ((hash
<< 5) - hash
) ^ mono_metadata_generic_inst_hash (context
->class_inst
);
4577 if (context
->method_inst
)
4578 hash
= ((hash
<< 5) - hash
) ^ mono_metadata_generic_inst_hash (context
->method_inst
);
4583 mono_metadata_generic_context_equal (const MonoGenericContext
*g1
, const MonoGenericContext
*g2
)
4585 return g1
->class_inst
== g2
->class_inst
&& g1
->method_inst
== g2
->method_inst
;
4589 * mono_metadata_str_hash:
4591 * This should be used instead of g_str_hash for computing hash codes visible
4592 * outside this module, since g_str_hash () is not guaranteed to be stable
4593 * (its not the same in eglib for example).
4596 mono_metadata_str_hash (gconstpointer v1
)
4598 /* Same as g_str_hash () in glib */
4599 char *p
= (char *) v1
;
4604 hash
= (hash
<< 5) - hash
+ *p
;
4611 * mono_metadata_type_hash:
4614 * Computes an hash value for @t1 to be used in GHashTable.
4615 * The returned hash is guaranteed to be the same across executions.
4618 mono_metadata_type_hash (MonoType
*t1
)
4620 guint hash
= t1
->type
;
4622 hash
|= t1
->byref
<< 6; /* do not collide with t1->type values */
4624 case MONO_TYPE_VALUETYPE
:
4625 case MONO_TYPE_CLASS
:
4626 case MONO_TYPE_SZARRAY
: {
4627 MonoClass
*class = t1
->data
.klass
;
4629 * Dynamic classes must not be hashed on their type since it can change
4630 * during runtime. For example, if we hash a reference type that is
4631 * later made into a valuetype.
4633 * This is specially problematic with generic instances since they are
4634 * inserted in a bunch of hash tables before been finished.
4636 if (image_is_dynamic (class->image
))
4637 return (t1
->byref
<< 6) | mono_metadata_str_hash (class->name
);
4638 return ((hash
<< 5) - hash
) ^ mono_metadata_str_hash (class->name
);
4641 return ((hash
<< 5) - hash
) ^ mono_metadata_type_hash (t1
->data
.type
);
4642 case MONO_TYPE_ARRAY
:
4643 return ((hash
<< 5) - hash
) ^ mono_metadata_type_hash (&t1
->data
.array
->eklass
->byval_arg
);
4644 case MONO_TYPE_GENERICINST
:
4645 return ((hash
<< 5) - hash
) ^ mono_generic_class_hash (t1
->data
.generic_class
);
4647 case MONO_TYPE_MVAR
:
4648 return ((hash
<< 5) - hash
) ^ mono_metadata_generic_param_hash (t1
->data
.generic_param
);
4654 mono_metadata_generic_param_hash (MonoGenericParam
*p
)
4657 MonoGenericParamInfo
*info
;
4659 hash
= (mono_generic_param_num (p
) << 2) | p
->serial
;
4660 info
= mono_generic_param_info (p
);
4661 /* Can't hash on the owner klass/method, since those might not be set when this is called */
4663 hash
= ((hash
<< 5) - hash
) ^ info
->token
;
4668 mono_metadata_generic_param_equal (MonoGenericParam
*p1
, MonoGenericParam
*p2
, gboolean signature_only
)
4672 if (mono_generic_param_num (p1
) != mono_generic_param_num (p2
))
4674 if (p1
->serial
!= p2
->serial
)
4678 * We have to compare the image as well because if we didn't,
4679 * the generic_inst_cache lookup wouldn't care about the image
4680 * of generic params, so what could happen is that a generic
4681 * inst with params from image A is put into the cache, then
4682 * image B gets that generic inst from the cache, image A is
4683 * unloaded, so the inst is deleted, but image B still retains
4686 * The AOT runtime doesn't set the image when it's decoding
4687 * types, so we only compare it when the owner is NULL.
4689 if (mono_generic_param_owner (p1
) == mono_generic_param_owner (p2
) &&
4690 (mono_generic_param_owner (p1
) || p1
->image
== p2
->image
))
4694 * If `signature_only' is true, we're comparing two (method) signatures.
4695 * In this case, the owner of two type parameters doesn't need to match.
4698 return signature_only
;
4702 mono_metadata_class_equal (MonoClass
*c1
, MonoClass
*c2
, gboolean signature_only
)
4706 if (c1
->generic_class
&& c2
->generic_class
)
4707 return _mono_metadata_generic_class_equal (c1
->generic_class
, c2
->generic_class
, signature_only
);
4708 if (c1
->generic_class
&& c2
->generic_container
)
4709 return _mono_metadata_generic_class_container_equal (c1
->generic_class
, c2
, signature_only
);
4710 if (c1
->generic_container
&& c2
->generic_class
)
4711 return _mono_metadata_generic_class_container_equal (c2
->generic_class
, c1
, signature_only
);
4712 if ((c1
->byval_arg
.type
== MONO_TYPE_VAR
) && (c2
->byval_arg
.type
== MONO_TYPE_VAR
))
4713 return mono_metadata_generic_param_equal (
4714 c1
->byval_arg
.data
.generic_param
, c2
->byval_arg
.data
.generic_param
, signature_only
);
4715 if ((c1
->byval_arg
.type
== MONO_TYPE_MVAR
) && (c2
->byval_arg
.type
== MONO_TYPE_MVAR
))
4716 return mono_metadata_generic_param_equal (
4717 c1
->byval_arg
.data
.generic_param
, c2
->byval_arg
.data
.generic_param
, signature_only
);
4718 if (signature_only
&&
4719 (c1
->byval_arg
.type
== MONO_TYPE_SZARRAY
) && (c2
->byval_arg
.type
== MONO_TYPE_SZARRAY
))
4720 return mono_metadata_class_equal (c1
->byval_arg
.data
.klass
, c2
->byval_arg
.data
.klass
, signature_only
);
4721 if (signature_only
&&
4722 (c1
->byval_arg
.type
== MONO_TYPE_ARRAY
) && (c2
->byval_arg
.type
== MONO_TYPE_ARRAY
))
4723 return do_mono_metadata_type_equal (&c1
->byval_arg
, &c2
->byval_arg
, signature_only
);
4728 mono_metadata_fnptr_equal (MonoMethodSignature
*s1
, MonoMethodSignature
*s2
, gboolean signature_only
)
4730 gpointer iter1
= 0, iter2
= 0;
4734 if (s1
->call_convention
!= s2
->call_convention
)
4736 if (s1
->sentinelpos
!= s2
->sentinelpos
)
4738 if (s1
->hasthis
!= s2
->hasthis
)
4740 if (s1
->explicit_this
!= s2
->explicit_this
)
4742 if (! do_mono_metadata_type_equal (s1
->ret
, s2
->ret
, signature_only
))
4744 if (s1
->param_count
!= s2
->param_count
)
4748 MonoType
*t1
= mono_signature_get_params (s1
, &iter1
);
4749 MonoType
*t2
= mono_signature_get_params (s2
, &iter2
);
4751 if (t1
== NULL
|| t2
== NULL
)
4753 if (! do_mono_metadata_type_equal (t1
, t2
, signature_only
))
4759 * mono_metadata_type_equal:
4763 * Determine if @t1 and @t2 represent the same type.
4764 * Returns: #TRUE if @t1 and @t2 are equal.
4767 do_mono_metadata_type_equal (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
)
4769 if (t1
->type
!= t2
->type
|| t1
->byref
!= t2
->byref
)
4773 case MONO_TYPE_VOID
:
4774 case MONO_TYPE_BOOLEAN
:
4775 case MONO_TYPE_CHAR
:
4786 case MONO_TYPE_STRING
:
4789 case MONO_TYPE_OBJECT
:
4790 case MONO_TYPE_TYPEDBYREF
:
4792 case MONO_TYPE_VALUETYPE
:
4793 case MONO_TYPE_CLASS
:
4794 case MONO_TYPE_SZARRAY
:
4795 return mono_metadata_class_equal (t1
->data
.klass
, t2
->data
.klass
, signature_only
);
4797 return do_mono_metadata_type_equal (t1
->data
.type
, t2
->data
.type
, signature_only
);
4798 case MONO_TYPE_ARRAY
:
4799 if (t1
->data
.array
->rank
!= t2
->data
.array
->rank
)
4801 return mono_metadata_class_equal (t1
->data
.array
->eklass
, t2
->data
.array
->eklass
, signature_only
);
4802 case MONO_TYPE_GENERICINST
:
4803 return _mono_metadata_generic_class_equal (
4804 t1
->data
.generic_class
, t2
->data
.generic_class
, signature_only
);
4806 return mono_metadata_generic_param_equal (
4807 t1
->data
.generic_param
, t2
->data
.generic_param
, signature_only
);
4808 case MONO_TYPE_MVAR
:
4809 return mono_metadata_generic_param_equal (
4810 t1
->data
.generic_param
, t2
->data
.generic_param
, signature_only
);
4811 case MONO_TYPE_FNPTR
:
4812 return mono_metadata_fnptr_equal (t1
->data
.method
, t2
->data
.method
, signature_only
);
4814 g_error ("implement type compare for %0x!", t1
->type
);
4822 mono_metadata_type_equal (MonoType
*t1
, MonoType
*t2
)
4824 return do_mono_metadata_type_equal (t1
, t2
, FALSE
);
4828 * mono_metadata_type_equal_full:
4831 * @signature_only: if signature only comparison should be made
4833 * Determine if @t1 and @t2 are signature compatible if @signature_only is #TRUE, otherwise
4834 * behaves the same way as mono_metadata_type_equal.
4835 * The function mono_metadata_type_equal(a, b) is just a shortcut for mono_metadata_type_equal_full(a, b, FALSE).
4836 * Returns: #TRUE if @t1 and @t2 are equal taking @signature_only into account.
4839 mono_metadata_type_equal_full (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
)
4841 return do_mono_metadata_type_equal (t1
, t2
, signature_only
);
4845 * mono_metadata_signature_equal:
4846 * @sig1: a signature
4847 * @sig2: another signature
4849 * Determine if @sig1 and @sig2 represent the same signature, with the
4850 * same number of arguments and the same types.
4851 * Returns: #TRUE if @sig1 and @sig2 are equal.
4854 mono_metadata_signature_equal (MonoMethodSignature
*sig1
, MonoMethodSignature
*sig2
)
4858 if (sig1
->hasthis
!= sig2
->hasthis
|| sig1
->param_count
!= sig2
->param_count
)
4861 if (sig1
->generic_param_count
!= sig2
->generic_param_count
)
4865 * We're just comparing the signatures of two methods here:
4867 * If we have two generic methods `void Foo<U> (U u)' and `void Bar<V> (V v)',
4868 * U and V are equal here.
4870 * That's what the `signature_only' argument of do_mono_metadata_type_equal() is for.
4873 for (i
= 0; i
< sig1
->param_count
; i
++) {
4874 MonoType
*p1
= sig1
->params
[i
];
4875 MonoType
*p2
= sig2
->params
[i
];
4877 /* if (p1->attrs != p2->attrs)
4880 if (!do_mono_metadata_type_equal (p1
, p2
, TRUE
))
4884 if (!do_mono_metadata_type_equal (sig1
->ret
, sig2
->ret
, TRUE
))
4890 * mono_metadata_type_dup:
4891 * @image: image to alloc memory from
4892 * @original: type to duplicate
4894 * Returns: copy of type allocated from the image's mempool (or from the heap, if @image is null).
4897 mono_metadata_type_dup (MonoImage
*image
, const MonoType
*o
)
4900 int sizeof_o
= MONO_SIZEOF_TYPE
;
4902 sizeof_o
+= o
->num_mods
* sizeof (MonoCustomMod
);
4904 r
= image
? mono_image_alloc0 (image
, sizeof_o
) : g_malloc (sizeof_o
);
4906 memcpy (r
, o
, sizeof_o
);
4908 if (o
->type
== MONO_TYPE_PTR
) {
4909 r
->data
.type
= mono_metadata_type_dup (image
, o
->data
.type
);
4910 } else if (o
->type
== MONO_TYPE_ARRAY
) {
4911 r
->data
.array
= mono_dup_array_type (image
, o
->data
.array
);
4912 } else if (o
->type
== MONO_TYPE_FNPTR
) {
4913 /*FIXME the dup'ed signature is leaked mono_metadata_free_type*/
4914 r
->data
.method
= mono_metadata_signature_deep_dup (image
, o
->data
.method
);
4920 mono_signature_hash (MonoMethodSignature
*sig
)
4922 guint i
, res
= sig
->ret
->type
;
4924 for (i
= 0; i
< sig
->param_count
; i
++)
4925 res
= (res
<< 5) - res
+ mono_type_hash (sig
->params
[i
]);
4931 * mono_metadata_encode_value:
4932 * @value: value to encode
4933 * @buf: buffer where to write the compressed representation
4934 * @endbuf: pointer updated to point at the end of the encoded output
4936 * Encodes the value @value in the compressed representation used
4937 * in metadata and stores the result in @buf. @buf needs to be big
4938 * enough to hold the data (4 bytes).
4941 mono_metadata_encode_value (guint32 value
, char *buf
, char **endbuf
)
4947 else if (value
< 0x4000) {
4948 p
[0] = 0x80 | (value
>> 8);
4949 p
[1] = value
& 0xff;
4952 p
[0] = (value
>> 24) | 0xc0;
4953 p
[1] = (value
>> 16) & 0xff;
4954 p
[2] = (value
>> 8) & 0xff;
4955 p
[3] = value
& 0xff;
4963 * mono_metadata_field_info:
4964 * @meta: the Image the field is defined in
4965 * @index: the index in the field table representing the field
4966 * @offset: a pointer to an integer where to store the offset that
4967 * may have been specified for the field in a FieldLayout table
4968 * @rva: a pointer to the RVA of the field data in the image that
4969 * may have been defined in a FieldRVA table
4970 * @marshal_spec: a pointer to the marshal spec that may have been
4971 * defined for the field in a FieldMarshal table.
4973 * Gather info for field @index that may have been defined in the FieldLayout,
4974 * FieldRVA and FieldMarshal tables.
4975 * Either of offset, rva and marshal_spec can be NULL if you're not interested
4979 mono_metadata_field_info (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
4980 MonoMarshalSpec
**marshal_spec
)
4982 mono_metadata_field_info_full (meta
, index
, offset
, rva
, marshal_spec
, FALSE
);
4986 mono_metadata_field_info_with_mempool (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
4987 MonoMarshalSpec
**marshal_spec
)
4989 mono_metadata_field_info_full (meta
, index
, offset
, rva
, marshal_spec
, TRUE
);
4993 mono_metadata_field_info_full (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
4994 MonoMarshalSpec
**marshal_spec
, gboolean alloc_from_image
)
4996 MonoTableInfo
*tdef
;
4999 loc
.idx
= index
+ 1;
5000 if (meta
->uncompressed_metadata
)
5001 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_FIELD_POINTER
, loc
.idx
);
5004 tdef
= &meta
->tables
[MONO_TABLE_FIELDLAYOUT
];
5006 loc
.col_idx
= MONO_FIELD_LAYOUT_FIELD
;
5009 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5010 *offset
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_LAYOUT_OFFSET
);
5012 *offset
= (guint32
)-1;
5016 tdef
= &meta
->tables
[MONO_TABLE_FIELDRVA
];
5018 loc
.col_idx
= MONO_FIELD_RVA_FIELD
;
5021 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5023 * LAMESPEC: There is no signature, no nothing, just the raw data.
5025 *rva
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_RVA_RVA
);
5033 if ((p
= mono_metadata_get_marshal_info (meta
, index
, TRUE
))) {
5034 *marshal_spec
= mono_metadata_parse_marshal_spec_full (alloc_from_image
? meta
: NULL
, meta
, p
);
5041 * mono_metadata_get_constant_index:
5042 * @meta: the Image the field is defined in
5043 * @index: the token that may have a row defined in the constants table
5044 * @hint: possible position for the row
5046 * @token must be a FieldDef, ParamDef or PropertyDef token.
5048 * Returns: the index into the Constants table or 0 if not found.
5051 mono_metadata_get_constant_index (MonoImage
*meta
, guint32 token
, guint32 hint
)
5053 MonoTableInfo
*tdef
;
5055 guint32 index
= mono_metadata_token_index (token
);
5057 tdef
= &meta
->tables
[MONO_TABLE_CONSTANT
];
5058 index
<<= MONO_HASCONSTANT_BITS
;
5059 switch (mono_metadata_token_table (token
)) {
5060 case MONO_TABLE_FIELD
:
5061 index
|= MONO_HASCONSTANT_FIEDDEF
;
5063 case MONO_TABLE_PARAM
:
5064 index
|= MONO_HASCONSTANT_PARAM
;
5066 case MONO_TABLE_PROPERTY
:
5067 index
|= MONO_HASCONSTANT_PROPERTY
;
5070 g_warning ("Not a valid token for the constant table: 0x%08x", token
);
5074 loc
.col_idx
= MONO_CONSTANT_PARENT
;
5077 /* FIXME: Index translation */
5079 if ((hint
> 0) && (hint
< tdef
->rows
) && (mono_metadata_decode_row_col (tdef
, hint
- 1, MONO_CONSTANT_PARENT
) == index
))
5082 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5083 return loc
.result
+ 1;
5089 * mono_metadata_events_from_typedef:
5090 * @meta: metadata context
5091 * @index: 0-based index (in the TypeDef table) describing a type
5093 * Returns: the 0-based index in the Event table for the events in the
5094 * type. The last event that belongs to the type (plus 1) is stored
5095 * in the @end_idx pointer.
5098 mono_metadata_events_from_typedef (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5102 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_EVENTMAP
];
5110 loc
.col_idx
= MONO_EVENT_MAP_PARENT
;
5111 loc
.idx
= index
+ 1;
5113 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5116 start
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_EVENT_MAP_EVENTLIST
);
5117 if (loc
.result
+ 1 < tdef
->rows
) {
5118 end
= mono_metadata_decode_row_col (tdef
, loc
.result
+ 1, MONO_EVENT_MAP_EVENTLIST
) - 1;
5120 end
= meta
->tables
[MONO_TABLE_EVENT
].rows
;
5128 * mono_metadata_methods_from_event:
5129 * @meta: metadata context
5130 * @index: 0-based index (in the Event table) describing a event
5132 * Returns: the 0-based index in the MethodDef table for the methods in the
5133 * event. The last method that belongs to the event (plus 1) is stored
5134 * in the @end_idx pointer.
5137 mono_metadata_methods_from_event (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5141 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
5142 MonoTableInfo
*msemt
= &meta
->tables
[MONO_TABLE_METHODSEMANTICS
];
5148 if (meta
->uncompressed_metadata
)
5149 index
= search_ptr_table (meta
, MONO_TABLE_EVENT_POINTER
, index
+ 1) - 1;
5152 loc
.col_idx
= MONO_METHOD_SEMA_ASSOCIATION
;
5153 loc
.idx
= ((index
+ 1) << MONO_HAS_SEMANTICS_BITS
) | MONO_HAS_SEMANTICS_EVENT
; /* Method association coded index */
5155 if (!mono_binary_search (&loc
, msemt
->base
, msemt
->rows
, msemt
->row_size
, table_locator
))
5160 * We may end up in the middle of the rows...
5163 if (loc
.idx
== mono_metadata_decode_row_col (msemt
, start
- 1, MONO_METHOD_SEMA_ASSOCIATION
))
5169 while (end
< msemt
->rows
) {
5170 mono_metadata_decode_row (msemt
, end
, cols
, MONO_METHOD_SEMA_SIZE
);
5171 if (cols
[MONO_METHOD_SEMA_ASSOCIATION
] != loc
.idx
)
5180 * mono_metadata_properties_from_typedef:
5181 * @meta: metadata context
5182 * @index: 0-based index (in the TypeDef table) describing a type
5184 * Returns: the 0-based index in the Property table for the properties in the
5185 * type. The last property that belongs to the type (plus 1) is stored
5186 * in the @end_idx pointer.
5189 mono_metadata_properties_from_typedef (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5193 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_PROPERTYMAP
];
5201 loc
.col_idx
= MONO_PROPERTY_MAP_PARENT
;
5202 loc
.idx
= index
+ 1;
5204 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5207 start
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_PROPERTY_MAP_PROPERTY_LIST
);
5208 if (loc
.result
+ 1 < tdef
->rows
) {
5209 end
= mono_metadata_decode_row_col (tdef
, loc
.result
+ 1, MONO_PROPERTY_MAP_PROPERTY_LIST
) - 1;
5211 end
= meta
->tables
[MONO_TABLE_PROPERTY
].rows
;
5219 * mono_metadata_methods_from_property:
5220 * @meta: metadata context
5221 * @index: 0-based index (in the PropertyDef table) describing a property
5223 * Returns: the 0-based index in the MethodDef table for the methods in the
5224 * property. The last method that belongs to the property (plus 1) is stored
5225 * in the @end_idx pointer.
5228 mono_metadata_methods_from_property (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5232 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
5233 MonoTableInfo
*msemt
= &meta
->tables
[MONO_TABLE_METHODSEMANTICS
];
5239 if (meta
->uncompressed_metadata
)
5240 index
= search_ptr_table (meta
, MONO_TABLE_PROPERTY_POINTER
, index
+ 1) - 1;
5243 loc
.col_idx
= MONO_METHOD_SEMA_ASSOCIATION
;
5244 loc
.idx
= ((index
+ 1) << MONO_HAS_SEMANTICS_BITS
) | MONO_HAS_SEMANTICS_PROPERTY
; /* Method association coded index */
5246 if (!mono_binary_search (&loc
, msemt
->base
, msemt
->rows
, msemt
->row_size
, table_locator
))
5251 * We may end up in the middle of the rows...
5254 if (loc
.idx
== mono_metadata_decode_row_col (msemt
, start
- 1, MONO_METHOD_SEMA_ASSOCIATION
))
5260 while (end
< msemt
->rows
) {
5261 mono_metadata_decode_row (msemt
, end
, cols
, MONO_METHOD_SEMA_SIZE
);
5262 if (cols
[MONO_METHOD_SEMA_ASSOCIATION
] != loc
.idx
)
5271 mono_metadata_implmap_from_method (MonoImage
*meta
, guint32 method_idx
)
5274 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_IMPLMAP
];
5279 /* No index translation seems to be needed */
5282 loc
.col_idx
= MONO_IMPLMAP_MEMBER
;
5283 loc
.idx
= ((method_idx
+ 1) << MONO_MEMBERFORWD_BITS
) | MONO_MEMBERFORWD_METHODDEF
;
5285 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5288 return loc
.result
+ 1;
5292 * @image: context where the image is created
5293 * @type_spec: typespec token
5294 * @deprecated use mono_type_create_from_typespec_checked that has proper error handling
5296 * Creates a MonoType representing the TypeSpec indexed by the @type_spec
5300 mono_type_create_from_typespec (MonoImage
*image
, guint32 type_spec
)
5303 MonoType
*type
= mono_type_create_from_typespec_checked (image
, type_spec
, &error
);
5305 g_error ("Could not create typespec %x due to %s", type_spec
, mono_error_get_message (&error
));
5310 mono_type_create_from_typespec_checked (MonoImage
*image
, guint32 type_spec
, MonoError
*error
)
5313 guint32 idx
= mono_metadata_token_index (type_spec
);
5315 guint32 cols
[MONO_TYPESPEC_SIZE
];
5318 MonoType
*type
, *type2
;
5320 mono_error_init (error
);
5322 mono_image_lock (image
);
5323 type
= g_hash_table_lookup (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
));
5324 mono_image_unlock (image
);
5328 t
= &image
->tables
[MONO_TABLE_TYPESPEC
];
5330 mono_metadata_decode_row (t
, idx
-1, cols
, MONO_TYPESPEC_SIZE
);
5331 ptr
= mono_metadata_blob_heap (image
, cols
[MONO_TYPESPEC_SIGNATURE
]);
5333 if (!mono_verifier_verify_typespec_signature (image
, cols
[MONO_TYPESPEC_SIGNATURE
], type_spec
, NULL
)) {
5334 mono_error_set_bad_image (error
, image
, "Could not verify type spec %08x.", type_spec
);
5338 len
= mono_metadata_decode_value (ptr
, &ptr
);
5340 type
= mono_metadata_parse_type_internal (image
, NULL
, MONO_PARSE_TYPE
, 0, TRUE
, ptr
, &ptr
);
5342 if (mono_loader_get_last_error ())
5343 mono_error_set_from_loader_error (error
);
5345 mono_error_set_bad_image (error
, image
, "Could not parse type spec %08x.", type_spec
);
5349 type2
= mono_metadata_type_dup (image
, type
);
5350 mono_metadata_free_type (type
);
5352 mono_image_lock (image
);
5353 type
= g_hash_table_lookup (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
));
5354 /* We might leak some data in the image mempool if found */
5356 g_hash_table_insert (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
), type2
);
5359 mono_image_unlock (image
);
5366 mono_image_strndup (MonoImage
*image
, const char *data
, guint len
)
5370 return g_strndup (data
, len
);
5371 res
= mono_image_alloc (image
, len
+ 1);
5372 memcpy (res
, data
, len
);
5378 mono_metadata_parse_marshal_spec (MonoImage
*image
, const char *ptr
)
5380 return mono_metadata_parse_marshal_spec_full (NULL
, image
, ptr
);
5384 * If IMAGE is non-null, memory will be allocated from its mempool, otherwise it will be allocated using malloc.
5385 * PARENT_IMAGE is the image containing the marshal spec.
5388 mono_metadata_parse_marshal_spec_full (MonoImage
*image
, MonoImage
*parent_image
, const char *ptr
)
5390 MonoMarshalSpec
*res
;
5392 const char *start
= ptr
;
5394 /* fixme: this is incomplete, but I cant find more infos in the specs */
5397 res
= mono_image_alloc0 (image
, sizeof (MonoMarshalSpec
));
5399 res
= g_new0 (MonoMarshalSpec
, 1);
5401 len
= mono_metadata_decode_value (ptr
, &ptr
);
5402 res
->native
= *ptr
++;
5404 if (res
->native
== MONO_NATIVE_LPARRAY
) {
5405 res
->data
.array_data
.param_num
= -1;
5406 res
->data
.array_data
.num_elem
= -1;
5407 res
->data
.array_data
.elem_mult
= -1;
5409 if (ptr
- start
<= len
)
5410 res
->data
.array_data
.elem_type
= *ptr
++;
5411 if (ptr
- start
<= len
)
5412 res
->data
.array_data
.param_num
= mono_metadata_decode_value (ptr
, &ptr
);
5413 if (ptr
- start
<= len
)
5414 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5415 if (ptr
- start
<= len
) {
5417 * LAMESPEC: Older spec versions say this parameter comes before
5418 * num_elem. Never spec versions don't talk about elem_mult at
5419 * all, but csc still emits it, and it is used to distinguish
5420 * between param_num being 0, and param_num being omitted.
5421 * So if (param_num == 0) && (num_elem > 0), then
5422 * elem_mult == 0 -> the array size is num_elem
5423 * elem_mult == 1 -> the array size is @param_num + num_elem
5425 res
->data
.array_data
.elem_mult
= mono_metadata_decode_value (ptr
, &ptr
);
5429 if (res
->native
== MONO_NATIVE_BYVALTSTR
) {
5430 if (ptr
- start
<= len
)
5431 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5434 if (res
->native
== MONO_NATIVE_BYVALARRAY
) {
5435 if (ptr
- start
<= len
)
5436 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5439 if (res
->native
== MONO_NATIVE_CUSTOM
) {
5440 /* skip unused type guid */
5441 len
= mono_metadata_decode_value (ptr
, &ptr
);
5443 /* skip unused native type name */
5444 len
= mono_metadata_decode_value (ptr
, &ptr
);
5446 /* read custom marshaler type name */
5447 len
= mono_metadata_decode_value (ptr
, &ptr
);
5448 res
->data
.custom_data
.custom_name
= mono_image_strndup (image
, ptr
, len
);
5450 /* read cookie string */
5451 len
= mono_metadata_decode_value (ptr
, &ptr
);
5452 res
->data
.custom_data
.cookie
= mono_image_strndup (image
, ptr
, len
);
5453 res
->data
.custom_data
.image
= parent_image
;
5456 if (res
->native
== MONO_NATIVE_SAFEARRAY
) {
5457 res
->data
.safearray_data
.elem_type
= 0;
5458 res
->data
.safearray_data
.num_elem
= 0;
5459 if (ptr
- start
<= len
)
5460 res
->data
.safearray_data
.elem_type
= *ptr
++;
5461 if (ptr
- start
<= len
)
5462 res
->data
.safearray_data
.num_elem
= *ptr
++;
5468 mono_metadata_free_marshal_spec (MonoMarshalSpec
*spec
)
5470 if (spec
->native
== MONO_NATIVE_CUSTOM
) {
5471 g_free (spec
->data
.custom_data
.custom_name
);
5472 g_free (spec
->data
.custom_data
.cookie
);
5478 * mono_type_to_unmanaged:
5480 * Returns: A MonoMarshalNative enumeration value (MONO_NATIVE_) value
5481 * describing the underlying native reprensetation of the type.
5483 * In addition the value pointed by
5484 * "conv" will contain the kind of marshalling required for this
5485 * particular type one of the MONO_MARSHAL_CONV_ enumeration values.
5488 mono_type_to_unmanaged (MonoType
*type
, MonoMarshalSpec
*mspec
, gboolean as_field
,
5489 gboolean unicode
, MonoMarshalConv
*conv
)
5491 MonoMarshalConv dummy_conv
;
5497 *conv
= MONO_MARSHAL_CONV_NONE
;
5500 return MONO_NATIVE_UINT
;
5504 case MONO_TYPE_BOOLEAN
:
5506 switch (mspec
->native
) {
5507 case MONO_NATIVE_VARIANTBOOL
:
5508 *conv
= MONO_MARSHAL_CONV_BOOL_VARIANTBOOL
;
5509 return MONO_NATIVE_VARIANTBOOL
;
5510 case MONO_NATIVE_BOOLEAN
:
5511 *conv
= MONO_MARSHAL_CONV_BOOL_I4
;
5512 return MONO_NATIVE_BOOLEAN
;
5513 case MONO_NATIVE_I1
:
5514 case MONO_NATIVE_U1
:
5515 return mspec
->native
;
5517 g_error ("cant marshal bool to native type %02x", mspec
->native
);
5520 *conv
= MONO_MARSHAL_CONV_BOOL_I4
;
5521 return MONO_NATIVE_BOOLEAN
;
5522 case MONO_TYPE_CHAR
:
5524 switch (mspec
->native
) {
5525 case MONO_NATIVE_U2
:
5526 case MONO_NATIVE_U1
:
5527 return mspec
->native
;
5529 g_error ("cant marshal char to native type %02x", mspec
->native
);
5532 return unicode
? MONO_NATIVE_U2
: MONO_NATIVE_U1
;
5533 case MONO_TYPE_I1
: return MONO_NATIVE_I1
;
5534 case MONO_TYPE_U1
: return MONO_NATIVE_U1
;
5535 case MONO_TYPE_I2
: return MONO_NATIVE_I2
;
5536 case MONO_TYPE_U2
: return MONO_NATIVE_U2
;
5537 case MONO_TYPE_I4
: return MONO_NATIVE_I4
;
5538 case MONO_TYPE_U4
: return MONO_NATIVE_U4
;
5539 case MONO_TYPE_I8
: return MONO_NATIVE_I8
;
5540 case MONO_TYPE_U8
: return MONO_NATIVE_U8
;
5541 case MONO_TYPE_R4
: return MONO_NATIVE_R4
;
5542 case MONO_TYPE_R8
: return MONO_NATIVE_R8
;
5543 case MONO_TYPE_STRING
:
5545 switch (mspec
->native
) {
5546 case MONO_NATIVE_BSTR
:
5547 *conv
= MONO_MARSHAL_CONV_STR_BSTR
;
5548 return MONO_NATIVE_BSTR
;
5549 case MONO_NATIVE_LPSTR
:
5550 *conv
= MONO_MARSHAL_CONV_STR_LPSTR
;
5551 return MONO_NATIVE_LPSTR
;
5552 case MONO_NATIVE_LPWSTR
:
5553 *conv
= MONO_MARSHAL_CONV_STR_LPWSTR
;
5554 return MONO_NATIVE_LPWSTR
;
5555 case MONO_NATIVE_LPTSTR
:
5556 *conv
= MONO_MARSHAL_CONV_STR_LPTSTR
;
5557 return MONO_NATIVE_LPTSTR
;
5558 case MONO_NATIVE_ANSIBSTR
:
5559 *conv
= MONO_MARSHAL_CONV_STR_ANSIBSTR
;
5560 return MONO_NATIVE_ANSIBSTR
;
5561 case MONO_NATIVE_TBSTR
:
5562 *conv
= MONO_MARSHAL_CONV_STR_TBSTR
;
5563 return MONO_NATIVE_TBSTR
;
5564 case MONO_NATIVE_BYVALTSTR
:
5566 *conv
= MONO_MARSHAL_CONV_STR_BYVALWSTR
;
5568 *conv
= MONO_MARSHAL_CONV_STR_BYVALSTR
;
5569 return MONO_NATIVE_BYVALTSTR
;
5571 g_error ("Can not marshal string to native type '%02x': Invalid managed/unmanaged type combination (String fields must be paired with LPStr, LPWStr, BStr or ByValTStr).", mspec
->native
);
5575 *conv
= MONO_MARSHAL_CONV_STR_LPWSTR
;
5576 return MONO_NATIVE_LPWSTR
;
5579 *conv
= MONO_MARSHAL_CONV_STR_LPSTR
;
5580 return MONO_NATIVE_LPSTR
;
5582 case MONO_TYPE_PTR
: return MONO_NATIVE_UINT
;
5583 case MONO_TYPE_VALUETYPE
: /*FIXME*/
5584 if (type
->data
.klass
->enumtype
) {
5585 t
= mono_class_enum_basetype (type
->data
.klass
)->type
;
5588 if (type
->data
.klass
== mono_defaults
.handleref_class
){
5589 *conv
= MONO_MARSHAL_CONV_HANDLEREF
;
5590 return MONO_NATIVE_INT
;
5592 return MONO_NATIVE_STRUCT
;
5593 case MONO_TYPE_SZARRAY
:
5594 case MONO_TYPE_ARRAY
:
5596 switch (mspec
->native
) {
5597 case MONO_NATIVE_BYVALARRAY
:
5598 if ((type
->data
.klass
->element_class
== mono_defaults
.char_class
) && !unicode
)
5599 *conv
= MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY
;
5601 *conv
= MONO_MARSHAL_CONV_ARRAY_BYVALARRAY
;
5602 return MONO_NATIVE_BYVALARRAY
;
5603 case MONO_NATIVE_SAFEARRAY
:
5604 *conv
= MONO_MARSHAL_CONV_ARRAY_SAVEARRAY
;
5605 return MONO_NATIVE_SAFEARRAY
;
5606 case MONO_NATIVE_LPARRAY
:
5607 *conv
= MONO_MARSHAL_CONV_ARRAY_LPARRAY
;
5608 return MONO_NATIVE_LPARRAY
;
5610 g_error ("cant marshal array as native type %02x", mspec
->native
);
5614 *conv
= MONO_MARSHAL_CONV_ARRAY_LPARRAY
;
5615 return MONO_NATIVE_LPARRAY
;
5616 case MONO_TYPE_I
: return MONO_NATIVE_INT
;
5617 case MONO_TYPE_U
: return MONO_NATIVE_UINT
;
5618 case MONO_TYPE_CLASS
:
5619 case MONO_TYPE_OBJECT
: {
5620 /* FIXME : we need to handle ArrayList and StringBuilder here, probably */
5622 switch (mspec
->native
) {
5623 case MONO_NATIVE_STRUCT
:
5624 return MONO_NATIVE_STRUCT
;
5625 case MONO_NATIVE_CUSTOM
:
5626 return MONO_NATIVE_CUSTOM
;
5627 case MONO_NATIVE_INTERFACE
:
5628 *conv
= MONO_MARSHAL_CONV_OBJECT_INTERFACE
;
5629 return MONO_NATIVE_INTERFACE
;
5630 case MONO_NATIVE_IDISPATCH
:
5631 *conv
= MONO_MARSHAL_CONV_OBJECT_IDISPATCH
;
5632 return MONO_NATIVE_IDISPATCH
;
5633 case MONO_NATIVE_IUNKNOWN
:
5634 *conv
= MONO_MARSHAL_CONV_OBJECT_IUNKNOWN
;
5635 return MONO_NATIVE_IUNKNOWN
;
5636 case MONO_NATIVE_FUNC
:
5637 if (t
== MONO_TYPE_CLASS
&& (type
->data
.klass
== mono_defaults
.multicastdelegate_class
||
5638 type
->data
.klass
== mono_defaults
.delegate_class
||
5639 type
->data
.klass
->parent
== mono_defaults
.multicastdelegate_class
)) {
5640 *conv
= MONO_MARSHAL_CONV_DEL_FTN
;
5641 return MONO_NATIVE_FUNC
;
5645 g_error ("cant marshal object as native type %02x", mspec
->native
);
5648 if (t
== MONO_TYPE_CLASS
&& (type
->data
.klass
== mono_defaults
.multicastdelegate_class
||
5649 type
->data
.klass
== mono_defaults
.delegate_class
||
5650 type
->data
.klass
->parent
== mono_defaults
.multicastdelegate_class
)) {
5651 *conv
= MONO_MARSHAL_CONV_DEL_FTN
;
5652 return MONO_NATIVE_FUNC
;
5654 if (mono_defaults
.safehandle_class
&& type
->data
.klass
== mono_defaults
.safehandle_class
){
5655 *conv
= MONO_MARSHAL_CONV_SAFEHANDLE
;
5656 return MONO_NATIVE_INT
;
5658 *conv
= MONO_MARSHAL_CONV_OBJECT_STRUCT
;
5659 return MONO_NATIVE_STRUCT
;
5661 case MONO_TYPE_FNPTR
: return MONO_NATIVE_FUNC
;
5662 case MONO_TYPE_GENERICINST
:
5663 type
= &type
->data
.generic_class
->container_class
->byval_arg
;
5666 case MONO_TYPE_TYPEDBYREF
:
5668 g_error ("type 0x%02x not handled in marshal", t
);
5670 return MONO_NATIVE_MAX
;
5674 mono_metadata_get_marshal_info (MonoImage
*meta
, guint32 idx
, gboolean is_field
)
5677 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_FIELDMARSHAL
];
5683 loc
.col_idx
= MONO_FIELD_MARSHAL_PARENT
;
5684 loc
.idx
= ((idx
+ 1) << MONO_HAS_FIELD_MARSHAL_BITS
) | (is_field
? MONO_HAS_FIELD_MARSHAL_FIELDSREF
: MONO_HAS_FIELD_MARSHAL_PARAMDEF
);
5686 /* FIXME: Index translation */
5688 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5691 return mono_metadata_blob_heap (meta
, mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_MARSHAL_NATIVE_TYPE
));
5695 method_from_method_def_or_ref (MonoImage
*m
, guint32 tok
, MonoGenericContext
*context
)
5698 MonoMethod
*result
= NULL
;
5699 guint32 idx
= tok
>> MONO_METHODDEFORREF_BITS
;
5701 switch (tok
& MONO_METHODDEFORREF_MASK
) {
5702 case MONO_METHODDEFORREF_METHODDEF
:
5703 result
= mono_get_method_checked (m
, MONO_TOKEN_METHOD_DEF
| idx
, NULL
, context
, &error
);
5705 case MONO_METHODDEFORREF_METHODREF
:
5706 result
= mono_get_method_checked (m
, MONO_TOKEN_MEMBER_REF
| idx
, NULL
, context
, &error
);
5709 g_assert_not_reached ();
5712 if (!mono_error_ok (&error
)) {
5713 mono_loader_set_error_from_mono_error (&error
);
5714 mono_error_cleanup (&error
);
5720 * mono_class_get_overrides_full:
5722 * Return the method overrides belonging to class @type_token in @overrides, and
5723 * the number of overrides in @num_overrides.
5725 * Returns: TRUE on success, FALSE on failure.
5728 mono_class_get_overrides_full (MonoImage
*image
, guint32 type_token
, MonoMethod
***overrides
, gint32
*num_overrides
,
5729 MonoGenericContext
*generic_context
)
5733 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_METHODIMPL
];
5736 guint32 cols
[MONO_METHODIMPL_SIZE
];
5737 MonoMethod
**result
;
5748 loc
.col_idx
= MONO_METHODIMPL_CLASS
;
5749 loc
.idx
= mono_metadata_token_index (type_token
);
5751 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5757 * We may end up in the middle of the rows...
5760 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_METHODIMPL_CLASS
))
5765 while (end
< tdef
->rows
) {
5766 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, end
, MONO_METHODIMPL_CLASS
))
5772 result
= g_new (MonoMethod
*, num
* 2);
5773 for (i
= 0; i
< num
; ++i
) {
5776 if (!mono_verifier_verify_methodimpl_row (image
, start
+ i
, &error
)) {
5777 mono_error_cleanup (&error
);
5782 mono_metadata_decode_row (tdef
, start
+ i
, cols
, MONO_METHODIMPL_SIZE
);
5783 method
= method_from_method_def_or_ref (
5784 image
, cols
[MONO_METHODIMPL_DECLARATION
], generic_context
);
5787 result
[i
* 2] = method
;
5788 method
= method_from_method_def_or_ref (
5789 image
, cols
[MONO_METHODIMPL_BODY
], generic_context
);
5792 result
[i
* 2 + 1] = method
;
5795 *overrides
= result
;
5797 *num_overrides
= num
;
5802 * mono_guid_to_string:
5804 * Converts a 16 byte Microsoft GUID to the standard string representation.
5807 mono_guid_to_string (const guint8
*guid
)
5809 return g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
5810 guid
[3], guid
[2], guid
[1], guid
[0],
5814 guid
[10], guid
[11], guid
[12], guid
[13], guid
[14], guid
[15]);
5818 get_constraints (MonoImage
*image
, int owner
, MonoClass
***constraints
, MonoGenericContainer
*container
, MonoError
*error
)
5820 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAMCONSTRAINT
];
5821 guint32 cols
[MONO_GENPARCONSTRAINT_SIZE
];
5822 guint32 i
, token
, found
;
5823 MonoClass
*klass
, **res
;
5824 GSList
*cons
= NULL
, *tmp
;
5825 MonoGenericContext
*context
= &container
->context
;
5827 mono_error_init (error
);
5829 *constraints
= NULL
;
5831 for (i
= 0; i
< tdef
->rows
; ++i
) {
5832 mono_metadata_decode_row (tdef
, i
, cols
, MONO_GENPARCONSTRAINT_SIZE
);
5833 if (cols
[MONO_GENPARCONSTRAINT_GENERICPAR
] == owner
) {
5834 token
= mono_metadata_token_from_dor (cols
[MONO_GENPARCONSTRAINT_CONSTRAINT
]);
5835 klass
= mono_class_get_and_inflate_typespec_checked (image
, token
, context
, error
);
5837 g_slist_free (cons
);
5840 cons
= g_slist_append (cons
, klass
);
5843 /* contiguous list finished */
5850 res
= mono_image_alloc0 (image
, sizeof (MonoClass
*) * (found
+ 1));
5851 for (i
= 0, tmp
= cons
; i
< found
; ++i
, tmp
= tmp
->next
) {
5852 res
[i
] = tmp
->data
;
5854 g_slist_free (cons
);
5860 * mono_metadata_get_generic_param_row:
5863 * @token: TypeOrMethodDef token, owner for GenericParam
5864 * @owner: coded token, set on return
5866 * Returns: 1-based row-id in the GenericParam table whose
5867 * owner is @token. 0 if not found.
5870 mono_metadata_get_generic_param_row (MonoImage
*image
, guint32 token
, guint32
*owner
)
5872 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAM
];
5879 if (mono_metadata_token_table (token
) == MONO_TABLE_TYPEDEF
)
5880 *owner
= MONO_TYPEORMETHOD_TYPE
;
5881 else if (mono_metadata_token_table (token
) == MONO_TABLE_METHOD
)
5882 *owner
= MONO_TYPEORMETHOD_METHOD
;
5884 g_error ("wrong token %x to get_generic_param_row", token
);
5887 *owner
|= mono_metadata_token_index (token
) << MONO_TYPEORMETHOD_BITS
;
5890 loc
.col_idx
= MONO_GENERICPARAM_OWNER
;
5893 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5896 /* Find the first entry by searching backwards */
5897 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_GENERICPARAM_OWNER
) == loc
.idx
))
5900 return loc
.result
+ 1;
5904 mono_metadata_has_generic_params (MonoImage
*image
, guint32 token
)
5907 return mono_metadata_get_generic_param_row (image
, token
, &owner
);
5911 * Memory is allocated from IMAGE's mempool.
5914 mono_metadata_load_generic_param_constraints_checked (MonoImage
*image
, guint32 token
,
5915 MonoGenericContainer
*container
, MonoError
*error
)
5918 guint32 start_row
, i
, owner
;
5919 mono_error_init (error
);
5921 if (! (start_row
= mono_metadata_get_generic_param_row (image
, token
, &owner
)))
5923 for (i
= 0; i
< container
->type_argc
; i
++) {
5924 if (!get_constraints (image
, start_row
+ i
, &mono_generic_container_get_param_info (container
, i
)->constraints
, container
, error
)) {
5925 g_assert (!mono_loader_get_last_error ());
5933 * mono_metadata_load_generic_params:
5935 * Load the type parameters from the type or method definition @token.
5937 * Use this method after parsing a type or method definition to figure out whether it's a generic
5938 * type / method. When parsing a method definition, @parent_container points to the generic container
5939 * of the current class, if any.
5941 * Note: This method does not load the constraints: for typedefs, this has to be done after fully
5942 * creating the type.
5944 * Returns: NULL if @token is not a generic type or method definition or the new generic container.
5946 * LOCKING: Acquires the loader lock
5949 MonoGenericContainer
*
5950 mono_metadata_load_generic_params (MonoImage
*image
, guint32 token
, MonoGenericContainer
*parent_container
)
5952 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAM
];
5953 guint32 cols
[MONO_GENERICPARAM_SIZE
];
5954 guint32 i
, owner
= 0, n
;
5955 MonoGenericContainer
*container
;
5956 MonoGenericParamFull
*params
;
5957 MonoGenericContext
*context
;
5959 if (!(i
= mono_metadata_get_generic_param_row (image
, token
, &owner
)))
5961 mono_metadata_decode_row (tdef
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
5964 container
= mono_image_alloc0 (image
, sizeof (MonoGenericContainer
));
5965 container
->image
= image
;
5968 params
= g_realloc (params
, sizeof (MonoGenericParamFull
) * n
);
5969 memset (¶ms
[n
- 1], 0, sizeof (MonoGenericParamFull
));
5970 params
[n
- 1].param
.owner
= container
;
5971 params
[n
- 1].param
.num
= cols
[MONO_GENERICPARAM_NUMBER
];
5972 params
[n
- 1].info
.token
= i
| MONO_TOKEN_GENERIC_PARAM
;
5973 params
[n
- 1].info
.flags
= cols
[MONO_GENERICPARAM_FLAGS
];
5974 params
[n
- 1].info
.name
= mono_metadata_string_heap (image
, cols
[MONO_GENERICPARAM_NAME
]);
5975 if (params
[n
- 1].param
.num
!= n
- 1)
5976 g_warning ("GenericParam table unsorted or hole in generic param sequence: token %d", i
);
5977 if (++i
> tdef
->rows
)
5979 mono_metadata_decode_row (tdef
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
5980 } while (cols
[MONO_GENERICPARAM_OWNER
] == owner
);
5982 container
->type_argc
= n
;
5983 container
->type_params
= mono_image_alloc0 (image
, sizeof (MonoGenericParamFull
) * n
);
5984 memcpy (container
->type_params
, params
, sizeof (MonoGenericParamFull
) * n
);
5986 container
->parent
= parent_container
;
5988 if (mono_metadata_token_table (token
) == MONO_TABLE_METHOD
)
5989 container
->is_method
= 1;
5991 g_assert (container
->parent
== NULL
|| container
->is_method
);
5993 context
= &container
->context
;
5994 if (container
->is_method
) {
5995 context
->class_inst
= container
->parent
? container
->parent
->context
.class_inst
: NULL
;
5996 context
->method_inst
= mono_get_shared_generic_inst (container
);
5998 context
->class_inst
= mono_get_shared_generic_inst (container
);
6005 mono_get_shared_generic_inst (MonoGenericContainer
*container
)
6007 MonoType
**type_argv
;
6009 MonoGenericInst
*nginst
;
6012 type_argv
= g_new0 (MonoType
*, container
->type_argc
);
6013 helper
= g_new0 (MonoType
, container
->type_argc
);
6015 for (i
= 0; i
< container
->type_argc
; i
++) {
6016 MonoType
*t
= &helper
[i
];
6018 t
->type
= container
->is_method
? MONO_TYPE_MVAR
: MONO_TYPE_VAR
;
6019 t
->data
.generic_param
= mono_generic_container_get_param (container
, i
);
6024 nginst
= mono_metadata_get_generic_inst (container
->type_argc
, type_argv
);
6033 * mono_type_is_byref:
6034 * @type: the MonoType operated on
6036 * Returns: #TRUE if @type represents a type passed by reference,
6040 mono_type_is_byref (MonoType
*type
)
6046 * mono_type_get_type:
6047 * @type: the MonoType operated on
6049 * Returns: the IL type value for @type. This is one of the MonoTypeEnum
6050 * enum members like MONO_TYPE_I4 or MONO_TYPE_STRING.
6053 mono_type_get_type (MonoType
*type
)
6059 * mono_type_get_signature:
6060 * @type: the MonoType operated on
6062 * It is only valid to call this function if @type is a MONO_TYPE_FNPTR.
6064 * Returns: the MonoMethodSignature pointer that describes the signature
6065 * of the function pointer @type represents.
6067 MonoMethodSignature
*
6068 mono_type_get_signature (MonoType
*type
)
6070 g_assert (type
->type
== MONO_TYPE_FNPTR
);
6071 return type
->data
.method
;
6075 * mono_type_get_class:
6076 * @type: the MonoType operated on
6078 * It is only valid to call this function if @type is a MONO_TYPE_CLASS or a
6079 * MONO_TYPE_VALUETYPE. For more general functionality, use mono_class_from_mono_type (),
6082 * Returns: the MonoClass pointer that describes the class that @type represents.
6085 mono_type_get_class (MonoType
*type
)
6087 /* FIXME: review the runtime users before adding the assert here */
6088 return type
->data
.klass
;
6092 * mono_type_get_array_type:
6093 * @type: the MonoType operated on
6095 * It is only valid to call this function if @type is a MONO_TYPE_ARRAY.
6097 * Returns: a MonoArrayType struct describing the array type that @type
6098 * represents. The info includes details such as rank, array element type
6099 * and the sizes and bounds of multidimensional arrays.
6102 mono_type_get_array_type (MonoType
*type
)
6104 return type
->data
.array
;
6108 * mono_type_get_ptr_type:
6109 * @type: the MonoType operated on
6111 * It is only valid to call this function if @type is a MONO_TYPE_PTR.
6114 * Returns: the MonoType pointer that describes the type that @type
6115 * represents a pointer to.
6118 mono_type_get_ptr_type (MonoType
*type
)
6120 g_assert (type
->type
== MONO_TYPE_PTR
);
6121 return type
->data
.type
;
6125 mono_type_get_modifiers (MonoType
*type
, gboolean
*is_required
, gpointer
*iter
)
6127 /* FIXME: implement */
6132 * mono_type_is_struct:
6133 * @type: the MonoType operated on
6135 * Returns: #TRUE is @type is a struct, that is a ValueType but not en enum
6136 * or a basic type like System.Int32. #FALSE otherwise.
6139 mono_type_is_struct (MonoType
*type
)
6141 return (!type
->byref
&& ((type
->type
== MONO_TYPE_VALUETYPE
&&
6142 !type
->data
.klass
->enumtype
) || (type
->type
== MONO_TYPE_TYPEDBYREF
) ||
6143 ((type
->type
== MONO_TYPE_GENERICINST
) &&
6144 mono_metadata_generic_class_is_valuetype (type
->data
.generic_class
) &&
6145 !type
->data
.generic_class
->container_class
->enumtype
)));
6149 * mono_type_is_void:
6150 * @type: the MonoType operated on
6152 * Returns: #TRUE is @type is System.Void. #FALSE otherwise.
6155 mono_type_is_void (MonoType
*type
)
6157 return (type
&& (type
->type
== MONO_TYPE_VOID
) && !type
->byref
);
6161 * mono_type_is_pointer:
6162 * @type: the MonoType operated on
6164 * Returns: #TRUE is @type is a managed or unmanaged pointer type. #FALSE otherwise.
6167 mono_type_is_pointer (MonoType
*type
)
6169 return (type
&& ((type
->byref
|| (type
->type
== MONO_TYPE_I
) || type
->type
== MONO_TYPE_STRING
)
6170 || (type
->type
== MONO_TYPE_SZARRAY
) || (type
->type
== MONO_TYPE_CLASS
) ||
6171 (type
->type
== MONO_TYPE_U
) || (type
->type
== MONO_TYPE_OBJECT
) ||
6172 (type
->type
== MONO_TYPE_ARRAY
) || (type
->type
== MONO_TYPE_PTR
) ||
6173 (type
->type
== MONO_TYPE_FNPTR
)));
6177 * mono_type_is_reference:
6178 * @type: the MonoType operated on
6180 * Returns: #TRUE is @type represents an object reference . #FALSE otherwise.
6183 mono_type_is_reference (MonoType
*type
)
6185 return (type
&& (((type
->type
== MONO_TYPE_STRING
) ||
6186 (type
->type
== MONO_TYPE_SZARRAY
) || (type
->type
== MONO_TYPE_CLASS
) ||
6187 (type
->type
== MONO_TYPE_OBJECT
) || (type
->type
== MONO_TYPE_ARRAY
)) ||
6188 ((type
->type
== MONO_TYPE_GENERICINST
) &&
6189 !mono_metadata_generic_class_is_valuetype (type
->data
.generic_class
))));
6193 * mono_signature_get_return_type:
6194 * @sig: the method signature inspected
6196 * Returns: the return type of the method signature @sig
6199 mono_signature_get_return_type (MonoMethodSignature
*sig
)
6205 * mono_signature_get_params:
6206 * @sig: the method signature inspected
6207 * #iter: pointer to an iterator
6209 * Iterates over the parameters for the method signature @sig.
6210 * A void* pointer must be initualized to #NULL to start the iteration
6211 * and it's address is passed to this function repeteadly until it returns
6214 * Returns: the next parameter type of the method signature @sig,
6215 * #NULL when finished.
6218 mono_signature_get_params (MonoMethodSignature
*sig
, gpointer
*iter
)
6224 /* start from the first */
6225 if (sig
->param_count
) {
6226 *iter
= &sig
->params
[0];
6227 return sig
->params
[0];
6235 if (type
< &sig
->params
[sig
->param_count
]) {
6243 * mono_signature_get_param_count:
6244 * @sig: the method signature inspected
6246 * Returns: the number of parameters in the method signature @sig.
6249 mono_signature_get_param_count (MonoMethodSignature
*sig
)
6251 return sig
->param_count
;
6255 * mono_signature_get_call_conv:
6256 * @sig: the method signature inspected
6258 * Returns: the call convention of the method signature @sig.
6261 mono_signature_get_call_conv (MonoMethodSignature
*sig
)
6263 return sig
->call_convention
;
6267 * mono_signature_vararg_start:
6268 * @sig: the method signature inspected
6270 * Returns: the number of the first vararg parameter in the
6271 * method signature @sig. -1 if this is not a vararg signature.
6274 mono_signature_vararg_start (MonoMethodSignature
*sig
)
6276 return sig
->sentinelpos
;
6280 * mono_signature_is_instance:
6281 * @sig: the method signature inspected
6283 * Returns: #TRUE if this the method signature @sig has an implicit
6284 * first instance argument. #FALSE otherwise.
6287 mono_signature_is_instance (MonoMethodSignature
*sig
)
6289 return sig
->hasthis
;
6293 * mono_signature_param_is_out
6294 * @sig: the method signature inspected
6295 * @param_num: the 0-based index of the inspected parameter
6297 * Returns: #TRUE if the parameter is an out parameter, #FALSE
6301 mono_signature_param_is_out (MonoMethodSignature
*sig
, int param_num
)
6303 g_assert (param_num
>= 0 && param_num
< sig
->param_count
);
6304 return (sig
->params
[param_num
]->attrs
& PARAM_ATTRIBUTE_OUT
) != 0;
6308 * mono_signature_explicit_this:
6309 * @sig: the method signature inspected
6311 * Returns: #TRUE if this the method signature @sig has an explicit
6312 * instance argument. #FALSE otherwise.
6315 mono_signature_explicit_this (MonoMethodSignature
*sig
)
6317 return sig
->explicit_this
;
6320 /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */
6322 mono_aligned_addr_hash (gconstpointer ptr
)
6324 return GPOINTER_TO_UINT (ptr
) >> 3;
6328 * If @field belongs to an inflated generic class, return the corresponding field of the
6329 * generic type definition class.
6332 mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField
*field
)
6337 if (!field
->parent
->generic_class
)
6340 gtd
= field
->parent
->generic_class
->container_class
;
6341 offset
= field
- field
->parent
->fields
;
6342 return gtd
->fields
+ offset
;
6346 * If @event belongs to an inflated generic class, return the corresponding event of the
6347 * generic type definition class.
6350 mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent
*event
)
6355 if (!event
->parent
->generic_class
)
6358 gtd
= event
->parent
->generic_class
->container_class
;
6359 offset
= event
- event
->parent
->ext
->events
;
6360 return gtd
->ext
->events
+ offset
;
6364 * If @property belongs to an inflated generic class, return the corresponding property of the
6365 * generic type definition class.
6368 mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty
*property
)
6373 if (!property
->parent
->generic_class
)
6376 gtd
= property
->parent
->generic_class
->container_class
;
6377 offset
= property
- property
->parent
->ext
->properties
;
6378 return gtd
->ext
->properties
+ offset
;