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
);
53 * This enumeration is used to describe the data types in the metadata
64 /* Index into Blob heap */
67 /* Index into String heap */
73 /* Pointer into a table */
76 /* HasConstant:Parent pointer (Param, Field or Property) */
79 /* HasCustomAttribute index. Indexes any table except CustomAttribute */
82 /* CustomAttributeType encoded index */
85 /* HasDeclSecurity index: TypeDef Method or Assembly */
88 /* Implementation coded index: File, Export AssemblyRef */
91 /* HasFieldMarshal coded index: Field or Param table */
94 /* MemberForwardedIndex: Field or Method */
97 /* TypeDefOrRef coded index: typedef, typeref, typespec */
100 /* MemberRefParent coded index: typeref, moduleref, method, memberref, typesepc, typedef */
103 /* MethodDefOrRef coded index: Method or Member Ref table */
106 /* HasSemantic coded index: Event or Property */
109 /* ResolutionScope coded index: Module, ModuleRef, AssemblytRef, TypeRef */
113 const static unsigned char TableSchemas
[] = {
114 #define ASSEMBLY_SCHEMA_OFFSET 0
115 MONO_MT_UINT32
, /* "HashId" }, */
116 MONO_MT_UINT16
, /* "Major" }, */
117 MONO_MT_UINT16
, /* "Minor" }, */
118 MONO_MT_UINT16
, /* "BuildNumber" }, */
119 MONO_MT_UINT16
, /* "RevisionNumber" }, */
120 MONO_MT_UINT32
, /* "Flags" }, */
121 MONO_MT_BLOB_IDX
, /* "PublicKey" }, */
122 MONO_MT_STRING_IDX
, /* "Name" }, */
123 MONO_MT_STRING_IDX
, /* "Culture" }, */
126 #define ASSEMBLYOS_SCHEMA_OFFSET ASSEMBLY_SCHEMA_OFFSET + 10
127 MONO_MT_UINT32
, /* "OSPlatformID" }, */
128 MONO_MT_UINT32
, /* "OSMajor" }, */
129 MONO_MT_UINT32
, /* "OSMinor" }, */
132 #define ASSEMBLYPROC_SCHEMA_OFFSET ASSEMBLYOS_SCHEMA_OFFSET + 4
133 MONO_MT_UINT32
, /* "Processor" }, */
136 #define ASSEMBLYREF_SCHEMA_OFFSET ASSEMBLYPROC_SCHEMA_OFFSET + 2
137 MONO_MT_UINT16
, /* "Major" }, */
138 MONO_MT_UINT16
, /* "Minor" }, */
139 MONO_MT_UINT16
, /* "Build" }, */
140 MONO_MT_UINT16
, /* "Revision" }, */
141 MONO_MT_UINT32
, /* "Flags" }, */
142 MONO_MT_BLOB_IDX
, /* "PublicKeyOrToken" }, */
143 MONO_MT_STRING_IDX
, /* "Name" }, */
144 MONO_MT_STRING_IDX
, /* "Culture" }, */
145 MONO_MT_BLOB_IDX
, /* "HashValue" }, */
148 #define ASSEMBLYREFOS_SCHEMA_OFFSET ASSEMBLYREF_SCHEMA_OFFSET + 10
149 MONO_MT_UINT32
, /* "OSPlatformID" }, */
150 MONO_MT_UINT32
, /* "OSMajorVersion" }, */
151 MONO_MT_UINT32
, /* "OSMinorVersion" }, */
152 MONO_MT_TABLE_IDX
, /* "AssemblyRef:AssemblyRef" }, */
155 #define ASSEMBLYREFPROC_SCHEMA_OFFSET ASSEMBLYREFOS_SCHEMA_OFFSET + 5
156 MONO_MT_UINT32
, /* "Processor" }, */
157 MONO_MT_TABLE_IDX
, /* "AssemblyRef:AssemblyRef" }, */
160 #define CLASS_LAYOUT_SCHEMA_OFFSET ASSEMBLYREFPROC_SCHEMA_OFFSET + 3
161 MONO_MT_UINT16
, /* "PackingSize" }, */
162 MONO_MT_UINT32
, /* "ClassSize" }, */
163 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
166 #define CONSTANT_SCHEMA_OFFSET CLASS_LAYOUT_SCHEMA_OFFSET + 4
167 MONO_MT_UINT8
, /* "Type" }, */
168 MONO_MT_UINT8
, /* "PaddingZero" }, */
169 MONO_MT_CONST_IDX
, /* "Parent" }, */
170 MONO_MT_BLOB_IDX
, /* "Value" }, */
173 #define CUSTOM_ATTR_SCHEMA_OFFSET CONSTANT_SCHEMA_OFFSET + 5
174 MONO_MT_HASCAT_IDX
, /* "Parent" }, */
175 MONO_MT_CAT_IDX
, /* "Type" }, */
176 MONO_MT_BLOB_IDX
, /* "Value" }, */
179 #define DECL_SEC_SCHEMA_OFFSET CUSTOM_ATTR_SCHEMA_OFFSET + 4
180 MONO_MT_UINT16
, /* "Action" }, */
181 MONO_MT_HASDEC_IDX
, /* "Parent" }, */
182 MONO_MT_BLOB_IDX
, /* "PermissionSet" }, */
185 #define EVENTMAP_SCHEMA_OFFSET DECL_SEC_SCHEMA_OFFSET + 4
186 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
187 MONO_MT_TABLE_IDX
, /* "EventList:Event" }, */
190 #define EVENT_SCHEMA_OFFSET EVENTMAP_SCHEMA_OFFSET + 3
191 MONO_MT_UINT16
, /* "EventFlags#EventAttribute" }, */
192 MONO_MT_STRING_IDX
, /* "Name" }, */
193 MONO_MT_TDOR_IDX
, /* "EventType" }, TypeDef or TypeRef or TypeSpec */
196 #define EVENT_POINTER_SCHEMA_OFFSET EVENT_SCHEMA_OFFSET + 4
197 MONO_MT_TABLE_IDX
, /* "Event" }, */
200 #define EXPORTED_TYPE_SCHEMA_OFFSET EVENT_POINTER_SCHEMA_OFFSET + 2
201 MONO_MT_UINT32
, /* "Flags" }, */
202 MONO_MT_TABLE_IDX
, /* "TypeDefId" }, */
203 MONO_MT_STRING_IDX
, /* "TypeName" }, */
204 MONO_MT_STRING_IDX
, /* "TypeNameSpace" }, */
205 MONO_MT_IMPL_IDX
, /* "Implementation" }, */
208 #define FIELD_SCHEMA_OFFSET EXPORTED_TYPE_SCHEMA_OFFSET + 6
209 MONO_MT_UINT16
, /* "Flags" }, */
210 MONO_MT_STRING_IDX
, /* "Name" }, */
211 MONO_MT_BLOB_IDX
, /* "Signature" }, */
214 #define FIELD_LAYOUT_SCHEMA_OFFSET FIELD_SCHEMA_OFFSET + 4
215 MONO_MT_UINT32
, /* "Offset" }, */
216 MONO_MT_TABLE_IDX
, /* "Field:Field" }, */
219 #define FIELD_MARSHAL_SCHEMA_OFFSET FIELD_LAYOUT_SCHEMA_OFFSET + 3
220 MONO_MT_HFM_IDX
, /* "Parent" }, */
221 MONO_MT_BLOB_IDX
, /* "NativeType" }, */
224 #define FIELD_RVA_SCHEMA_OFFSET FIELD_MARSHAL_SCHEMA_OFFSET + 3
225 MONO_MT_UINT32
, /* "RVA" }, */
226 MONO_MT_TABLE_IDX
, /* "Field:Field" }, */
229 #define FIELD_POINTER_SCHEMA_OFFSET FIELD_RVA_SCHEMA_OFFSET + 3
230 MONO_MT_TABLE_IDX
, /* "Field" }, */
233 #define FILE_SCHEMA_OFFSET FIELD_POINTER_SCHEMA_OFFSET + 2
234 MONO_MT_UINT32
, /* "Flags" }, */
235 MONO_MT_STRING_IDX
, /* "Name" }, */
236 MONO_MT_BLOB_IDX
, /* "Value" }, */
239 #define IMPLMAP_SCHEMA_OFFSET FILE_SCHEMA_OFFSET + 4
240 MONO_MT_UINT16
, /* "MappingFlag" }, */
241 MONO_MT_MF_IDX
, /* "MemberForwarded" }, */
242 MONO_MT_STRING_IDX
, /* "ImportName" }, */
243 MONO_MT_TABLE_IDX
, /* "ImportScope:ModuleRef" }, */
246 #define IFACEMAP_SCHEMA_OFFSET IMPLMAP_SCHEMA_OFFSET + 5
247 MONO_MT_TABLE_IDX
, /* "Class:TypeDef" }, */
248 MONO_MT_TDOR_IDX
, /* "Interface=TypeDefOrRef" }, */
251 #define MANIFEST_SCHEMA_OFFSET IFACEMAP_SCHEMA_OFFSET + 3
252 MONO_MT_UINT32
, /* "Offset" }, */
253 MONO_MT_UINT32
, /* "Flags" }, */
254 MONO_MT_STRING_IDX
, /* "Name" }, */
255 MONO_MT_IMPL_IDX
, /* "Implementation" }, */
258 #define MEMBERREF_SCHEMA_OFFSET MANIFEST_SCHEMA_OFFSET + 5
259 MONO_MT_MRP_IDX
, /* "Class" }, */
260 MONO_MT_STRING_IDX
, /* "Name" }, */
261 MONO_MT_BLOB_IDX
, /* "Signature" }, */
264 #define METHOD_SCHEMA_OFFSET MEMBERREF_SCHEMA_OFFSET + 4
265 MONO_MT_UINT32
, /* "RVA" }, */
266 MONO_MT_UINT16
, /* "ImplFlags#MethodImplAttributes" }, */
267 MONO_MT_UINT16
, /* "Flags#MethodAttribute" }, */
268 MONO_MT_STRING_IDX
, /* "Name" }, */
269 MONO_MT_BLOB_IDX
, /* "Signature" }, */
270 MONO_MT_TABLE_IDX
, /* "ParamList:Param" }, */
273 #define METHOD_IMPL_SCHEMA_OFFSET METHOD_SCHEMA_OFFSET + 7
274 MONO_MT_TABLE_IDX
, /* "Class:TypeDef" }, */
275 MONO_MT_MDOR_IDX
, /* "MethodBody" }, */
276 MONO_MT_MDOR_IDX
, /* "MethodDeclaration" }, */
279 #define METHOD_SEMA_SCHEMA_OFFSET METHOD_IMPL_SCHEMA_OFFSET + 4
280 MONO_MT_UINT16
, /* "MethodSemantic" }, */
281 MONO_MT_TABLE_IDX
, /* "Method:Method" }, */
282 MONO_MT_HS_IDX
, /* "Association" }, */
285 #define METHOD_POINTER_SCHEMA_OFFSET METHOD_SEMA_SCHEMA_OFFSET + 4
286 MONO_MT_TABLE_IDX
, /* "Method" }, */
289 #define MODULE_SCHEMA_OFFSET METHOD_POINTER_SCHEMA_OFFSET + 2
290 MONO_MT_UINT16
, /* "Generation" }, */
291 MONO_MT_STRING_IDX
, /* "Name" }, */
292 MONO_MT_GUID_IDX
, /* "MVID" }, */
293 MONO_MT_GUID_IDX
, /* "EncID" }, */
294 MONO_MT_GUID_IDX
, /* "EncBaseID" }, */
297 #define MODULEREF_SCHEMA_OFFSET MODULE_SCHEMA_OFFSET + 6
298 MONO_MT_STRING_IDX
, /* "Name" }, */
301 #define NESTED_CLASS_SCHEMA_OFFSET MODULEREF_SCHEMA_OFFSET + 2
302 MONO_MT_TABLE_IDX
, /* "NestedClass:TypeDef" }, */
303 MONO_MT_TABLE_IDX
, /* "EnclosingClass:TypeDef" }, */
306 #define PARAM_SCHEMA_OFFSET NESTED_CLASS_SCHEMA_OFFSET + 3
307 MONO_MT_UINT16
, /* "Flags" }, */
308 MONO_MT_UINT16
, /* "Sequence" }, */
309 MONO_MT_STRING_IDX
, /* "Name" }, */
312 #define PARAM_POINTER_SCHEMA_OFFSET PARAM_SCHEMA_OFFSET + 4
313 MONO_MT_TABLE_IDX
, /* "Param" }, */
316 #define PROPERTY_SCHEMA_OFFSET PARAM_POINTER_SCHEMA_OFFSET + 2
317 MONO_MT_UINT16
, /* "Flags" }, */
318 MONO_MT_STRING_IDX
, /* "Name" }, */
319 MONO_MT_BLOB_IDX
, /* "Type" }, */
322 #define PROPERTY_POINTER_SCHEMA_OFFSET PROPERTY_SCHEMA_OFFSET + 4
323 MONO_MT_TABLE_IDX
, /* "Property" }, */
326 #define PROPERTY_MAP_SCHEMA_OFFSET PROPERTY_POINTER_SCHEMA_OFFSET + 2
327 MONO_MT_TABLE_IDX
, /* "Parent:TypeDef" }, */
328 MONO_MT_TABLE_IDX
, /* "PropertyList:Property" }, */
331 #define STDALON_SIG_SCHEMA_OFFSET PROPERTY_MAP_SCHEMA_OFFSET + 3
332 MONO_MT_BLOB_IDX
, /* "Signature" }, */
335 #define TYPEDEF_SCHEMA_OFFSET STDALON_SIG_SCHEMA_OFFSET + 2
336 MONO_MT_UINT32
, /* "Flags" }, */
337 MONO_MT_STRING_IDX
, /* "Name" }, */
338 MONO_MT_STRING_IDX
, /* "Namespace" }, */
339 MONO_MT_TDOR_IDX
, /* "Extends" }, */
340 MONO_MT_TABLE_IDX
, /* "FieldList:Field" }, */
341 MONO_MT_TABLE_IDX
, /* "MethodList:Method" }, */
344 #define TYPEREF_SCHEMA_OFFSET TYPEDEF_SCHEMA_OFFSET + 7
345 MONO_MT_RS_IDX
, /* "ResolutionScope=ResolutionScope" }, */
346 MONO_MT_STRING_IDX
, /* "Name" }, */
347 MONO_MT_STRING_IDX
, /* "Namespace" }, */
350 #define TYPESPEC_SCHEMA_OFFSET TYPEREF_SCHEMA_OFFSET + 4
351 MONO_MT_BLOB_IDX
, /* "Signature" }, */
354 #define GENPARAM_SCHEMA_OFFSET TYPESPEC_SCHEMA_OFFSET + 2
355 MONO_MT_UINT16
, /* "Number" }, */
356 MONO_MT_UINT16
, /* "Flags" }, */
357 MONO_MT_TABLE_IDX
, /* "Owner" }, TypeDef or MethodDef */
358 MONO_MT_STRING_IDX
, /* "Name" }, */
361 #define METHOD_SPEC_SCHEMA_OFFSET GENPARAM_SCHEMA_OFFSET + 5
362 MONO_MT_MDOR_IDX
, /* "Method" }, */
363 MONO_MT_BLOB_IDX
, /* "Signature" }, */
366 #define GEN_CONSTRAINT_SCHEMA_OFFSET METHOD_SPEC_SCHEMA_OFFSET + 3
367 MONO_MT_TABLE_IDX
, /* "GenericParam" }, */
368 MONO_MT_TDOR_IDX
, /* "Constraint" }, */
371 #define DOCUMENT_SCHEMA_OFFSET GEN_CONSTRAINT_SCHEMA_OFFSET + 3
372 MONO_MT_BLOB_IDX
, /* Name */
373 MONO_MT_GUID_IDX
, /* HashAlgorithm */
374 MONO_MT_BLOB_IDX
, /* Hash */
375 MONO_MT_GUID_IDX
, /* Language */
378 #define METHODBODY_SCHEMA_OFFSET DOCUMENT_SCHEMA_OFFSET + 5
379 MONO_MT_BLOB_IDX
, /* SequencePoints */
382 #define LOCALSCOPE_SCHEMA_OFFSET METHODBODY_SCHEMA_OFFSET + 2
383 MONO_MT_TABLE_IDX
, /* Method */
384 MONO_MT_TABLE_IDX
, /* ImportScope */
385 MONO_MT_TABLE_IDX
, /* VariableList */
386 MONO_MT_TABLE_IDX
, /* ConstantList */
387 MONO_MT_UINT32
, /* StartOffset */
388 MONO_MT_UINT32
, /* Length */
391 #define LOCALVARIABLE_SCHEMA_OFFSET LOCALSCOPE_SCHEMA_OFFSET + 7
392 MONO_MT_UINT16
, /* Attributes */
393 MONO_MT_UINT16
, /* Index */
394 MONO_MT_STRING_IDX
, /* Name */
397 #define NULL_SCHEMA_OFFSET LOCALVARIABLE_SCHEMA_OFFSET + 4
401 /* Must be the same order as MONO_TABLE_* */
402 const static unsigned char
403 table_description
[] = {
404 MODULE_SCHEMA_OFFSET
,
405 TYPEREF_SCHEMA_OFFSET
,
406 TYPEDEF_SCHEMA_OFFSET
,
407 FIELD_POINTER_SCHEMA_OFFSET
,
409 METHOD_POINTER_SCHEMA_OFFSET
,
410 METHOD_SCHEMA_OFFSET
,
411 PARAM_POINTER_SCHEMA_OFFSET
,
413 IFACEMAP_SCHEMA_OFFSET
,
414 MEMBERREF_SCHEMA_OFFSET
, /* 0xa */
415 CONSTANT_SCHEMA_OFFSET
,
416 CUSTOM_ATTR_SCHEMA_OFFSET
,
417 FIELD_MARSHAL_SCHEMA_OFFSET
,
418 DECL_SEC_SCHEMA_OFFSET
,
419 CLASS_LAYOUT_SCHEMA_OFFSET
,
420 FIELD_LAYOUT_SCHEMA_OFFSET
, /* 0x10 */
421 STDALON_SIG_SCHEMA_OFFSET
,
422 EVENTMAP_SCHEMA_OFFSET
,
423 EVENT_POINTER_SCHEMA_OFFSET
,
425 PROPERTY_MAP_SCHEMA_OFFSET
,
426 PROPERTY_POINTER_SCHEMA_OFFSET
,
427 PROPERTY_SCHEMA_OFFSET
,
428 METHOD_SEMA_SCHEMA_OFFSET
,
429 METHOD_IMPL_SCHEMA_OFFSET
,
430 MODULEREF_SCHEMA_OFFSET
, /* 0x1a */
431 TYPESPEC_SCHEMA_OFFSET
,
432 IMPLMAP_SCHEMA_OFFSET
,
433 FIELD_RVA_SCHEMA_OFFSET
,
436 ASSEMBLY_SCHEMA_OFFSET
, /* 0x20 */
437 ASSEMBLYPROC_SCHEMA_OFFSET
,
438 ASSEMBLYOS_SCHEMA_OFFSET
,
439 ASSEMBLYREF_SCHEMA_OFFSET
,
440 ASSEMBLYREFPROC_SCHEMA_OFFSET
,
441 ASSEMBLYREFOS_SCHEMA_OFFSET
,
443 EXPORTED_TYPE_SCHEMA_OFFSET
,
444 MANIFEST_SCHEMA_OFFSET
,
445 NESTED_CLASS_SCHEMA_OFFSET
,
446 GENPARAM_SCHEMA_OFFSET
, /* 0x2a */
447 METHOD_SPEC_SCHEMA_OFFSET
,
448 GEN_CONSTRAINT_SCHEMA_OFFSET
,
452 DOCUMENT_SCHEMA_OFFSET
, /* 0x30 */
453 METHODBODY_SCHEMA_OFFSET
,
454 LOCALSCOPE_SCHEMA_OFFSET
,
455 LOCALVARIABLE_SCHEMA_OFFSET
458 #ifdef HAVE_ARRAY_ELEM_INIT
459 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
460 #define MSGSTRFIELD1(line) str##line
461 static const struct msgstr_t
{
462 #define TABLEDEF(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
463 #include "mono/cil/tables.def"
466 #define TABLEDEF(a,b) b,
467 #include "mono/cil/tables.def"
470 static const gint16 tableidx
[] = {
471 #define TABLEDEF(a,b) [a] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
472 #include "mono/cil/tables.def"
477 #define TABLEDEF(a,b) b,
478 static const char* const
479 mono_tables_names
[] = {
480 #include "mono/cil/tables.def"
487 * mono_meta_table_name:
488 * @table: table index
490 * Returns the name of the given ECMA metadata logical format table
491 * as described in ECMA 335, Partition II, Section 22.
493 * Returns: the name for the @table index
496 mono_meta_table_name (int table
)
498 if ((table
< 0) || (table
> MONO_TABLE_LAST
))
501 #ifdef HAVE_ARRAY_ELEM_INIT
502 return (const char*)&tablestr
+ tableidx
[table
];
504 return mono_tables_names
[table
];
508 /* The guy who wrote the spec for this should not be allowed near a
511 If e is a coded token(see clause 23.1.7) that points into table ti out of n possible tables t0, .. tn-1,
512 then it is stored as e << (log n) & tag{ t0, .. tn-1}[ ti] using 2 bytes if the maximum number of
513 rows of tables t0, ..tn-1, is less than 2^16 - (log n), and using 4 bytes otherwise. The family of
514 finite maps tag{ t0, ..tn-1} is defined below. Note that to decode a physical row, you need the
515 inverse of this mapping.
518 #define rtsize(meta,s,b) (((s) < (1 << (b)) ? 2 : 4))
519 #define idx_size(meta,tableidx) ((meta)->tables [(tableidx)].rows < 65536 ? 2 : 4)
521 /* Reference: Partition II - 23.2.6 */
523 * mono_metadata_compute_size:
524 * @meta: metadata context
525 * @tableindex: metadata table number
526 * @result_bitfield: pointer to guint32 where to store additional info
528 * mono_metadata_compute_size() computes the lenght in bytes of a single
529 * row in a metadata table. The size of each column is encoded in the
530 * @result_bitfield return value along with the number of columns in the table.
531 * the resulting bitfield should be handed to the mono_metadata_table_size()
532 * and mono_metadata_table_count() macros.
533 * This is a Mono runtime internal only function.
536 mono_metadata_compute_size (MonoImage
*meta
, int tableindex
, guint32
*result_bitfield
)
538 guint32 bitfield
= 0;
539 int size
= 0, field_size
= 0;
542 const unsigned char *description
= TableSchemas
+ table_description
[tableindex
];
544 for (i
= 0; (code
= description
[i
]) != MONO_MT_END
; i
++){
547 field_size
= 4; break;
550 field_size
= 2; break;
553 field_size
= 1; break;
555 case MONO_MT_BLOB_IDX
:
556 field_size
= meta
->idx_blob_wide
? 4 : 2; break;
558 case MONO_MT_STRING_IDX
:
559 field_size
= meta
->idx_string_wide
? 4 : 2; break;
561 case MONO_MT_GUID_IDX
:
562 field_size
= meta
->idx_guid_wide
? 4 : 2; break;
564 case MONO_MT_TABLE_IDX
:
565 /* Uhm, a table index can point to other tables besides the current one
566 * so, it's not correct to use the rowcount of the current table to
567 * get the size for this column - lupus
569 switch (tableindex
) {
570 case MONO_TABLE_ASSEMBLYREFOS
:
572 field_size
= idx_size (meta
, MONO_TABLE_ASSEMBLYREF
); break;
573 case MONO_TABLE_ASSEMBLYREFPROCESSOR
:
575 field_size
= idx_size (meta
, MONO_TABLE_ASSEMBLYREF
); break;
576 case MONO_TABLE_CLASSLAYOUT
:
578 field_size
= idx_size (meta
, MONO_TABLE_TYPEDEF
); break;
579 case MONO_TABLE_EVENTMAP
:
580 g_assert (i
== 0 || i
== 1);
581 field_size
= i
? idx_size (meta
, MONO_TABLE_EVENT
):
582 idx_size (meta
, MONO_TABLE_TYPEDEF
);
584 case MONO_TABLE_EVENT_POINTER
:
586 field_size
= idx_size (meta
, MONO_TABLE_EVENT
); break;
587 case MONO_TABLE_EXPORTEDTYPE
:
589 /* the index is in another metadata file, so it must be 4 */
590 field_size
= 4; break;
591 case MONO_TABLE_FIELDLAYOUT
:
593 field_size
= idx_size (meta
, MONO_TABLE_FIELD
); break;
594 case MONO_TABLE_FIELDRVA
:
596 field_size
= idx_size (meta
, MONO_TABLE_FIELD
); break;
597 case MONO_TABLE_FIELD_POINTER
:
599 field_size
= idx_size (meta
, MONO_TABLE_FIELD
); break;
600 case MONO_TABLE_IMPLMAP
:
602 field_size
= idx_size (meta
, MONO_TABLE_MODULEREF
); break;
603 case MONO_TABLE_INTERFACEIMPL
:
605 field_size
= idx_size (meta
, MONO_TABLE_TYPEDEF
); break;
606 case MONO_TABLE_METHOD
:
608 field_size
= idx_size (meta
, MONO_TABLE_PARAM
); break;
609 case MONO_TABLE_METHODIMPL
:
611 field_size
= idx_size (meta
, MONO_TABLE_TYPEDEF
); break;
612 case MONO_TABLE_METHODSEMANTICS
:
614 field_size
= idx_size (meta
, MONO_TABLE_METHOD
); break;
615 case MONO_TABLE_METHOD_POINTER
:
617 field_size
= idx_size (meta
, MONO_TABLE_METHOD
); break;
618 case MONO_TABLE_NESTEDCLASS
:
619 g_assert (i
== 0 || i
== 1);
620 field_size
= idx_size (meta
, MONO_TABLE_TYPEDEF
); break;
621 case MONO_TABLE_PARAM_POINTER
:
623 field_size
= idx_size (meta
, MONO_TABLE_PARAM
); break;
624 case MONO_TABLE_PROPERTYMAP
:
625 g_assert (i
== 0 || i
== 1);
626 field_size
= i
? idx_size (meta
, MONO_TABLE_PROPERTY
):
627 idx_size (meta
, MONO_TABLE_TYPEDEF
);
629 case MONO_TABLE_PROPERTY_POINTER
:
631 field_size
= idx_size (meta
, MONO_TABLE_PROPERTY
); break;
632 case MONO_TABLE_TYPEDEF
:
633 g_assert (i
== 4 || i
== 5);
634 field_size
= i
== 4 ? idx_size (meta
, MONO_TABLE_FIELD
):
635 idx_size (meta
, MONO_TABLE_METHOD
);
637 case MONO_TABLE_GENERICPARAM
:
639 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
, meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
640 /*This is a coded token for 2 tables, so takes 1 bit */
641 field_size
= rtsize (meta
, n
, 16 - MONO_TYPEORMETHOD_BITS
);
643 case MONO_TABLE_GENERICPARAMCONSTRAINT
:
645 field_size
= idx_size (meta
, MONO_TABLE_GENERICPARAM
);
647 case MONO_TABLE_LOCALSCOPE
:
650 // FIXME: This table is in another file
651 field_size
= idx_size (meta
, MONO_TABLE_METHOD
);
654 field_size
= idx_size (meta
, MONO_TABLE_IMPORTSCOPE
);
657 field_size
= idx_size (meta
, MONO_TABLE_LOCALVARIABLE
);
660 field_size
= idx_size (meta
, MONO_TABLE_LOCALCONSTANT
);
663 g_assert_not_reached ();
668 g_error ("Can't handle MONO_MT_TABLE_IDX for table %d element %d", tableindex
, i
);
673 * HasConstant: ParamDef, FieldDef, Property
675 case MONO_MT_CONST_IDX
:
676 n
= MAX (meta
->tables
[MONO_TABLE_PARAM
].rows
,
677 meta
->tables
[MONO_TABLE_FIELD
].rows
);
678 n
= MAX (n
, meta
->tables
[MONO_TABLE_PROPERTY
].rows
);
680 /* 2 bits to encode tag */
681 field_size
= rtsize (meta
, n
, 16-2);
685 * HasCustomAttribute: points to any table but
688 case MONO_MT_HASCAT_IDX
:
690 * We believe that since the signature and
691 * permission are indexing the Blob heap,
692 * we should consider the blob size first
694 /* I'm not a believer - lupus
695 if (meta->idx_blob_wide){
700 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
,
701 meta
->tables
[MONO_TABLE_FIELD
].rows
);
702 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
703 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
704 n
= MAX (n
, meta
->tables
[MONO_TABLE_PARAM
].rows
);
705 n
= MAX (n
, meta
->tables
[MONO_TABLE_INTERFACEIMPL
].rows
);
706 n
= MAX (n
, meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
707 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULE
].rows
);
708 n
= MAX (n
, meta
->tables
[MONO_TABLE_DECLSECURITY
].rows
);
709 n
= MAX (n
, meta
->tables
[MONO_TABLE_PROPERTY
].rows
);
710 n
= MAX (n
, meta
->tables
[MONO_TABLE_EVENT
].rows
);
711 n
= MAX (n
, meta
->tables
[MONO_TABLE_STANDALONESIG
].rows
);
712 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
713 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
714 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLY
].rows
);
715 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
716 n
= MAX (n
, meta
->tables
[MONO_TABLE_FILE
].rows
);
717 n
= MAX (n
, meta
->tables
[MONO_TABLE_EXPORTEDTYPE
].rows
);
718 n
= MAX (n
, meta
->tables
[MONO_TABLE_MANIFESTRESOURCE
].rows
);
720 /* 5 bits to encode */
721 field_size
= rtsize (meta
, n
, 16-5);
725 * CustomAttributeType: TypeDef, TypeRef, MethodDef,
726 * MemberRef and String.
728 case MONO_MT_CAT_IDX
:
729 /* String is a heap, if it is wide, we know the size */
731 if (meta->idx_string_wide){
736 n
= MAX (meta
->tables
[MONO_TABLE_TYPEREF
].rows
,
737 meta
->tables
[MONO_TABLE_TYPEDEF
].rows
);
738 n
= MAX (n
, meta
->tables
[MONO_TABLE_METHOD
].rows
);
739 n
= MAX (n
, meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
741 /* 3 bits to encode */
742 field_size
= rtsize (meta
, n
, 16-3);
746 * HasDeclSecurity: Typedef, MethodDef, Assembly
748 case MONO_MT_HASDEC_IDX
:
749 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
750 meta
->tables
[MONO_TABLE_METHOD
].rows
);
751 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLY
].rows
);
753 /* 2 bits to encode */
754 field_size
= rtsize (meta
, n
, 16-2);
758 * Implementation: File, AssemblyRef, ExportedType
760 case MONO_MT_IMPL_IDX
:
761 n
= MAX (meta
->tables
[MONO_TABLE_FILE
].rows
,
762 meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
763 n
= MAX (n
, meta
->tables
[MONO_TABLE_EXPORTEDTYPE
].rows
);
765 /* 2 bits to encode tag */
766 field_size
= rtsize (meta
, n
, 16-2);
770 * HasFieldMarshall: FieldDef, ParamDef
772 case MONO_MT_HFM_IDX
:
773 n
= MAX (meta
->tables
[MONO_TABLE_FIELD
].rows
,
774 meta
->tables
[MONO_TABLE_PARAM
].rows
);
776 /* 1 bit used to encode tag */
777 field_size
= rtsize (meta
, n
, 16-1);
781 * MemberForwarded: FieldDef, MethodDef
784 n
= MAX (meta
->tables
[MONO_TABLE_FIELD
].rows
,
785 meta
->tables
[MONO_TABLE_METHOD
].rows
);
787 /* 1 bit used to encode tag */
788 field_size
= rtsize (meta
, n
, 16-1);
792 * TypeDefOrRef: TypeDef, ParamDef, TypeSpec
794 * It is TypeDef, _TypeRef_, TypeSpec, instead.
796 case MONO_MT_TDOR_IDX
:
797 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
798 meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
799 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
801 /* 2 bits to encode */
802 field_size
= rtsize (meta
, n
, 16-2);
806 * MemberRefParent: TypeDef, TypeRef, MethodDef, ModuleRef, TypeSpec, MemberRef
808 case MONO_MT_MRP_IDX
:
809 n
= MAX (meta
->tables
[MONO_TABLE_TYPEDEF
].rows
,
810 meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
811 n
= MAX (n
, meta
->tables
[MONO_TABLE_METHOD
].rows
);
812 n
= MAX (n
, meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
813 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPESPEC
].rows
);
815 /* 3 bits to encode */
816 field_size
= rtsize (meta
, n
, 16 - 3);
820 * MethodDefOrRef: MethodDef, MemberRef
822 case MONO_MT_MDOR_IDX
:
823 n
= MAX (meta
->tables
[MONO_TABLE_METHOD
].rows
,
824 meta
->tables
[MONO_TABLE_MEMBERREF
].rows
);
826 /* 1 bit used to encode tag */
827 field_size
= rtsize (meta
, n
, 16-1);
831 * HasSemantics: Property, Event
834 n
= MAX (meta
->tables
[MONO_TABLE_PROPERTY
].rows
,
835 meta
->tables
[MONO_TABLE_EVENT
].rows
);
837 /* 1 bit used to encode tag */
838 field_size
= rtsize (meta
, n
, 16-1);
842 * ResolutionScope: Module, ModuleRef, AssemblyRef, TypeRef
845 n
= MAX (meta
->tables
[MONO_TABLE_MODULE
].rows
,
846 meta
->tables
[MONO_TABLE_MODULEREF
].rows
);
847 n
= MAX (n
, meta
->tables
[MONO_TABLE_ASSEMBLYREF
].rows
);
848 n
= MAX (n
, meta
->tables
[MONO_TABLE_TYPEREF
].rows
);
850 /* 2 bits used to encode tag (ECMA spec claims 3) */
851 field_size
= rtsize (meta
, n
, 16 - 2);
856 * encode field size as follows (we just need to
863 bitfield
|= (field_size
-1) << shift
;
866 /*g_print ("table %02x field %d size %d\n", tableindex, i, field_size);*/
869 *result_bitfield
= (i
<< 24) | bitfield
;
874 * mono_metadata_compute_table_bases:
875 * @meta: metadata context to compute table values
877 * Computes the table bases for the metadata structure.
878 * This is an internal function used by the image loader code.
881 mono_metadata_compute_table_bases (MonoImage
*meta
)
884 const char *base
= meta
->tables_base
;
886 for (i
= 0; i
< MONO_TABLE_NUM
; i
++) {
887 MonoTableInfo
*table
= &meta
->tables
[i
];
888 if (table
->rows
== 0)
891 table
->row_size
= mono_metadata_compute_size (meta
, i
, &table
->size_bitfield
);
893 base
+= table
->rows
* table
->row_size
;
898 * mono_metadata_locate:
899 * @meta: metadata context
900 * @table: table code.
901 * @idx: index of element to retrieve from @table.
903 * Returns: a pointer to the @idx element in the metadata table
904 * whose code is @table.
907 mono_metadata_locate (MonoImage
*meta
, int table
, int idx
)
909 /* idx == 0 refers always to NULL */
910 g_return_val_if_fail (idx
> 0 && idx
<= meta
->tables
[table
].rows
, ""); /*FIXME shouldn't we return NULL here?*/
912 return meta
->tables
[table
].base
+ (meta
->tables
[table
].row_size
* (idx
- 1));
916 * mono_metadata_locate_token:
917 * @meta: metadata context
918 * @token: metadata token
920 * Returns: a pointer to the data in the metadata represented by the
924 mono_metadata_locate_token (MonoImage
*meta
, guint32 token
)
926 return mono_metadata_locate (meta
, token
>> 24, token
& 0xffffff);
930 * mono_metadata_string_heap:
931 * @meta: metadata context
932 * @index: index into the string heap.
934 * Returns: an in-memory pointer to the @index in the string heap.
937 mono_metadata_string_heap (MonoImage
*meta
, guint32 index
)
939 g_assert (index
< meta
->heap_strings
.size
);
940 g_return_val_if_fail (index
< meta
->heap_strings
.size
, "");
941 return meta
->heap_strings
.data
+ index
;
945 * mono_metadata_user_string:
946 * @meta: metadata context
947 * @index: index into the user string heap.
949 * Returns: an in-memory pointer to the @index in the user string heap ("#US").
952 mono_metadata_user_string (MonoImage
*meta
, guint32 index
)
954 g_assert (index
< meta
->heap_us
.size
);
955 g_return_val_if_fail (index
< meta
->heap_us
.size
, "");
956 return meta
->heap_us
.data
+ index
;
960 * mono_metadata_blob_heap:
961 * @meta: metadata context
962 * @index: index into the blob.
964 * Returns: an in-memory pointer to the @index in the Blob heap.
967 mono_metadata_blob_heap (MonoImage
*meta
, guint32 index
)
969 g_assert (index
< meta
->heap_blob
.size
);
970 g_return_val_if_fail (index
< meta
->heap_blob
.size
, "");/*FIXME shouldn't we return NULL and check for index == 0?*/
971 return meta
->heap_blob
.data
+ index
;
975 * mono_metadata_guid_heap:
976 * @meta: metadata context
977 * @index: index into the guid heap.
979 * Returns: an in-memory pointer to the @index in the guid heap.
982 mono_metadata_guid_heap (MonoImage
*meta
, guint32 index
)
985 index
*= 16; /* adjust for guid size and 1-based index */
986 g_return_val_if_fail (index
< meta
->heap_guid
.size
, "");
987 return meta
->heap_guid
.data
+ index
;
990 static const unsigned char *
991 dword_align (const unsigned char *ptr
)
993 #if SIZEOF_VOID_P == 8
994 return (const unsigned char *) (((guint64
) (ptr
+ 3)) & ~3);
996 return (const unsigned char *) (((guint32
) (ptr
+ 3)) & ~3);
1001 * mono_metadata_decode_row:
1002 * @t: table to extract information from.
1003 * @idx: index in table.
1004 * @res: array of @res_size cols to store the results in
1006 * This decompresses the metadata element @idx in table @t
1007 * into the guint32 @res array that has res_size elements
1010 mono_metadata_decode_row (const MonoTableInfo
*t
, int idx
, guint32
*res
, int res_size
)
1012 guint32 bitfield
= t
->size_bitfield
;
1013 int i
, count
= mono_metadata_table_count (bitfield
);
1016 g_assert (idx
< t
->rows
);
1017 g_assert (idx
>= 0);
1018 data
= t
->base
+ idx
* t
->row_size
;
1020 g_assert (res_size
== count
);
1022 for (i
= 0; i
< count
; i
++) {
1023 int n
= mono_metadata_table_size (bitfield
, i
);
1027 res
[i
] = *data
; break;
1029 res
[i
] = read16 (data
); break;
1031 res
[i
] = read32 (data
); break;
1033 g_assert_not_reached ();
1040 * mono_metadata_decode_row_col:
1041 * @t: table to extract information from.
1042 * @idx: index for row in table.
1043 * @col: column in the row.
1045 * This function returns the value of column @col from the @idx
1046 * row in the table @t.
1049 mono_metadata_decode_row_col (const MonoTableInfo
*t
, int idx
, guint col
)
1051 guint32 bitfield
= t
->size_bitfield
;
1053 register const char *data
;
1056 g_assert (idx
< t
->rows
);
1057 g_assert (col
< mono_metadata_table_count (bitfield
));
1058 data
= t
->base
+ idx
* t
->row_size
;
1060 n
= mono_metadata_table_size (bitfield
, 0);
1061 for (i
= 0; i
< col
; ++i
) {
1063 n
= mono_metadata_table_size (bitfield
, i
+ 1);
1069 return read16 (data
);
1071 return read32 (data
);
1073 g_assert_not_reached ();
1079 * mono_metadata_decode_blob_size:
1080 * @ptr: pointer to a blob object
1081 * @rptr: the new position of the pointer
1083 * This decodes a compressed size as described by 23.1.4 (a blob or user string object)
1085 * Returns: the size of the blob object
1088 mono_metadata_decode_blob_size (const char *xptr
, const char **rptr
)
1090 const unsigned char *ptr
= (const unsigned char *)xptr
;
1093 if ((*ptr
& 0x80) == 0){
1094 size
= ptr
[0] & 0x7f;
1096 } else if ((*ptr
& 0x40) == 0){
1097 size
= ((ptr
[0] & 0x3f) << 8) + ptr
[1];
1100 size
= ((ptr
[0] & 0x1f) << 24) +
1112 * mono_metadata_decode_value:
1113 * @ptr: pointer to decode from
1114 * @rptr: the new position of the pointer
1116 * This routine decompresses 32-bit values as specified in the "Blob and
1117 * Signature" section (22.2)
1119 * Returns: the decoded value
1122 mono_metadata_decode_value (const char *_ptr
, const char **rptr
)
1124 const unsigned char *ptr
= (const unsigned char *) _ptr
;
1125 unsigned char b
= *ptr
;
1128 if ((b
& 0x80) == 0){
1131 } else if ((b
& 0x40) == 0){
1132 len
= ((b
& 0x3f) << 8 | ptr
[1]);
1135 len
= ((b
& 0x1f) << 24) |
1148 * mono_metadata_decode_signed_value:
1149 * @ptr: pointer to decode from
1150 * @rptr: the new position of the pointer
1152 * This routine decompresses 32-bit signed values
1153 * (not specified in the spec)
1155 * Returns: the decoded value
1158 mono_metadata_decode_signed_value (const char *ptr
, const char **rptr
)
1160 guint32 uval
= mono_metadata_decode_value (ptr
, rptr
);
1161 gint32 ival
= uval
>> 1;
1164 /* ival is a truncated 2's complement negative number. */
1166 /* 6 bits = 7 bits for compressed representation (top bit is '0') - 1 sign bit */
1169 /* 13 bits = 14 bits for compressed representation (top bits are '10') - 1 sign bit */
1170 return ival
- 0x2000;
1171 if (ival
< 0x10000000)
1172 /* 28 bits = 29 bits for compressed representation (top bits are '110') - 1 sign bit */
1173 return ival
- 0x10000000;
1174 g_assert (ival
< 0x20000000);
1175 g_warning ("compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival
, uval
);
1176 return ival
- 0x20000000;
1180 * Translates the given 1-based index into the Method, Field, Event, or Param tables
1181 * using the *Ptr tables in uncompressed metadata, if they are available.
1183 * FIXME: The caller is not forced to call this function, which is error-prone, since
1184 * forgetting to call it would only show up as a bug on uncompressed metadata.
1187 mono_metadata_translate_token_index (MonoImage
*image
, int table
, guint32 idx
)
1189 if (!image
->uncompressed_metadata
)
1193 case MONO_TABLE_METHOD
:
1194 if (image
->tables
[MONO_TABLE_METHOD_POINTER
].rows
)
1195 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_METHOD_POINTER
], idx
- 1, MONO_METHOD_POINTER_METHOD
);
1198 case MONO_TABLE_FIELD
:
1199 if (image
->tables
[MONO_TABLE_FIELD_POINTER
].rows
)
1200 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_FIELD_POINTER
], idx
- 1, MONO_FIELD_POINTER_FIELD
);
1203 case MONO_TABLE_EVENT
:
1204 if (image
->tables
[MONO_TABLE_EVENT_POINTER
].rows
)
1205 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_EVENT_POINTER
], idx
- 1, MONO_EVENT_POINTER_EVENT
);
1208 case MONO_TABLE_PROPERTY
:
1209 if (image
->tables
[MONO_TABLE_PROPERTY_POINTER
].rows
)
1210 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_PROPERTY_POINTER
], idx
- 1, MONO_PROPERTY_POINTER_PROPERTY
);
1213 case MONO_TABLE_PARAM
:
1214 if (image
->tables
[MONO_TABLE_PARAM_POINTER
].rows
)
1215 return mono_metadata_decode_row_col (&image
->tables
[MONO_TABLE_PARAM_POINTER
], idx
- 1, MONO_PARAM_POINTER_PARAM
);
1224 * mono_metadata_decode_table_row:
1226 * Same as mono_metadata_decode_row, but takes an IMAGE+TABLE ID pair, and takes
1227 * uncompressed metadata into account, so it should be used to access the
1228 * Method, Field, Param and Event tables when the access is made from metadata, i.e.
1229 * IDX is retrieved from a metadata table, like MONO_TYPEDEF_FIELD_LIST.
1232 mono_metadata_decode_table_row (MonoImage
*image
, int table
, int idx
, guint32
*res
, int res_size
)
1234 if (image
->uncompressed_metadata
)
1235 idx
= mono_metadata_translate_token_index (image
, table
, idx
+ 1) - 1;
1237 mono_metadata_decode_row (&image
->tables
[table
], idx
, res
, res_size
);
1241 * mono_metadata_decode_table_row_col:
1243 * Same as mono_metadata_decode_row_col, but takes an IMAGE+TABLE ID pair, and takes
1244 * uncompressed metadata into account, so it should be used to access the
1245 * Method, Field, Param and Event tables.
1247 guint32
mono_metadata_decode_table_row_col (MonoImage
*image
, int table
, int idx
, guint col
)
1249 if (image
->uncompressed_metadata
)
1250 idx
= mono_metadata_translate_token_index (image
, table
, idx
+ 1) - 1;
1252 return mono_metadata_decode_row_col (&image
->tables
[table
], idx
, col
);
1256 * mono_metadata_parse_typedef_or_ref:
1257 * @m: a metadata context.
1258 * @ptr: a pointer to an encoded TypedefOrRef in @m
1259 * @rptr: pointer updated to match the end of the decoded stream
1261 * Returns: a token valid in the @m metadata decoded from
1262 * the compressed representation.
1265 mono_metadata_parse_typedef_or_ref (MonoImage
*m
, const char *ptr
, const char **rptr
)
1268 token
= mono_metadata_decode_value (ptr
, &ptr
);
1271 return mono_metadata_token_from_dor (token
);
1275 * mono_metadata_parse_custom_mod:
1276 * @m: a metadata context.
1277 * @dest: storage where the info about the custom modifier is stored (may be NULL)
1278 * @ptr: a pointer to (possibly) the start of a custom modifier list
1279 * @rptr: pointer updated to match the end of the decoded stream
1281 * Checks if @ptr points to a type custom modifier compressed representation.
1283 * Returns: #TRUE if a custom modifier was found, #FALSE if not.
1286 mono_metadata_parse_custom_mod (MonoImage
*m
, MonoCustomMod
*dest
, const char *ptr
, const char **rptr
)
1288 MonoCustomMod local
;
1289 if ((*ptr
== MONO_TYPE_CMOD_OPT
) || (*ptr
== MONO_TYPE_CMOD_REQD
)) {
1292 dest
->required
= *ptr
== MONO_TYPE_CMOD_REQD
? 1 : 0;
1293 dest
->token
= mono_metadata_parse_typedef_or_ref (m
, ptr
+ 1, rptr
);
1300 * mono_metadata_parse_array_internal:
1301 * @m: a metadata context.
1302 * @transient: whenever to allocate data from the heap
1303 * @ptr: a pointer to an encoded array description.
1304 * @rptr: pointer updated to match the end of the decoded stream
1306 * Decodes the compressed array description found in the metadata @m at @ptr.
1308 * Returns: a #MonoArrayType structure describing the array type
1309 * and dimensions. Memory is allocated from the heap or from the image mempool, depending
1310 * on the value of @transient.
1312 * LOCKING: Acquires the loader lock
1314 static MonoArrayType
*
1315 mono_metadata_parse_array_internal (MonoImage
*m
, MonoGenericContainer
*container
,
1316 gboolean transient
, const char *ptr
, const char **rptr
)
1319 MonoArrayType
*array
;
1322 array
= transient
? g_malloc0 (sizeof (MonoArrayType
)) : mono_image_alloc0 (m
, sizeof (MonoArrayType
));
1323 etype
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
1326 array
->eklass
= mono_class_from_mono_type (etype
);
1327 array
->rank
= mono_metadata_decode_value (ptr
, &ptr
);
1329 array
->numsizes
= mono_metadata_decode_value (ptr
, &ptr
);
1330 if (array
->numsizes
)
1331 array
->sizes
= transient
? g_malloc0 (sizeof (int) * array
->numsizes
) : mono_image_alloc0 (m
, sizeof (int) * array
->numsizes
);
1332 for (i
= 0; i
< array
->numsizes
; ++i
)
1333 array
->sizes
[i
] = mono_metadata_decode_value (ptr
, &ptr
);
1335 array
->numlobounds
= mono_metadata_decode_value (ptr
, &ptr
);
1336 if (array
->numlobounds
)
1337 array
->lobounds
= transient
? g_malloc0 (sizeof (int) * array
->numlobounds
) : mono_image_alloc0 (m
, sizeof (int) * array
->numlobounds
);
1338 for (i
= 0; i
< array
->numlobounds
; ++i
)
1339 array
->lobounds
[i
] = mono_metadata_decode_signed_value (ptr
, &ptr
);
1347 mono_metadata_parse_array_full (MonoImage
*m
, MonoGenericContainer
*container
,
1348 const char *ptr
, const char **rptr
)
1350 return mono_metadata_parse_array_internal (m
, container
, FALSE
, ptr
, rptr
);
1354 mono_metadata_parse_array (MonoImage
*m
, const char *ptr
, const char **rptr
)
1356 return mono_metadata_parse_array_full (m
, NULL
, ptr
, rptr
);
1360 * mono_metadata_free_array:
1361 * @array: array description
1363 * Frees the array description returned from mono_metadata_parse_array().
1366 mono_metadata_free_array (MonoArrayType
*array
)
1368 g_free (array
->sizes
);
1369 g_free (array
->lobounds
);
1374 * need to add common field and param attributes combinations:
1377 * public static literal
1380 * private static literal
1382 static const MonoType
1384 /* data, attrs, type, nmods, byref, pinned */
1385 {{NULL
}, 0, MONO_TYPE_VOID
, 0, 0, 0},
1386 {{NULL
}, 0, MONO_TYPE_BOOLEAN
, 0, 0, 0},
1387 {{NULL
}, 0, MONO_TYPE_BOOLEAN
, 0, 1, 0},
1388 {{NULL
}, 0, MONO_TYPE_CHAR
, 0, 0, 0},
1389 {{NULL
}, 0, MONO_TYPE_CHAR
, 0, 1, 0},
1390 {{NULL
}, 0, MONO_TYPE_I1
, 0, 0, 0},
1391 {{NULL
}, 0, MONO_TYPE_I1
, 0, 1, 0},
1392 {{NULL
}, 0, MONO_TYPE_U1
, 0, 0, 0},
1393 {{NULL
}, 0, MONO_TYPE_U1
, 0, 1, 0},
1394 {{NULL
}, 0, MONO_TYPE_I2
, 0, 0, 0},
1395 {{NULL
}, 0, MONO_TYPE_I2
, 0, 1, 0},
1396 {{NULL
}, 0, MONO_TYPE_U2
, 0, 0, 0},
1397 {{NULL
}, 0, MONO_TYPE_U2
, 0, 1, 0},
1398 {{NULL
}, 0, MONO_TYPE_I4
, 0, 0, 0},
1399 {{NULL
}, 0, MONO_TYPE_I4
, 0, 1, 0},
1400 {{NULL
}, 0, MONO_TYPE_U4
, 0, 0, 0},
1401 {{NULL
}, 0, MONO_TYPE_U4
, 0, 1, 0},
1402 {{NULL
}, 0, MONO_TYPE_I8
, 0, 0, 0},
1403 {{NULL
}, 0, MONO_TYPE_I8
, 0, 1, 0},
1404 {{NULL
}, 0, MONO_TYPE_U8
, 0, 0, 0},
1405 {{NULL
}, 0, MONO_TYPE_U8
, 0, 1, 0},
1406 {{NULL
}, 0, MONO_TYPE_R4
, 0, 0, 0},
1407 {{NULL
}, 0, MONO_TYPE_R4
, 0, 1, 0},
1408 {{NULL
}, 0, MONO_TYPE_R8
, 0, 0, 0},
1409 {{NULL
}, 0, MONO_TYPE_R8
, 0, 1, 0},
1410 {{NULL
}, 0, MONO_TYPE_STRING
, 0, 0, 0},
1411 {{NULL
}, 0, MONO_TYPE_STRING
, 0, 1, 0},
1412 {{NULL
}, 0, MONO_TYPE_OBJECT
, 0, 0, 0},
1413 {{NULL
}, 0, MONO_TYPE_OBJECT
, 0, 1, 0},
1414 {{NULL
}, 0, MONO_TYPE_TYPEDBYREF
, 0, 0, 0},
1415 {{NULL
}, 0, MONO_TYPE_I
, 0, 0, 0},
1416 {{NULL
}, 0, MONO_TYPE_I
, 0, 1, 0},
1417 {{NULL
}, 0, MONO_TYPE_U
, 0, 0, 0},
1418 {{NULL
}, 0, MONO_TYPE_U
, 0, 1, 0},
1421 #define NBUILTIN_TYPES() (sizeof (builtin_types) / sizeof (builtin_types [0]))
1423 static GHashTable
*type_cache
= NULL
;
1424 static int next_generic_inst_id
= 0;
1426 /* Protected by image_sets_mutex */
1427 static MonoImageSet
*mscorlib_image_set
;
1428 /* Protected by image_sets_mutex */
1429 static GPtrArray
*image_sets
;
1430 static mono_mutex_t image_sets_mutex
;
1432 static guint
mono_generic_class_hash (gconstpointer data
);
1435 * MonoTypes with modifies are never cached, so we never check or use that field.
1438 mono_type_hash (gconstpointer data
)
1440 const MonoType
*type
= (const MonoType
*) data
;
1441 if (type
->type
== MONO_TYPE_GENERICINST
)
1442 return mono_generic_class_hash (type
->data
.generic_class
);
1444 return type
->type
| (type
->byref
<< 8) | (type
->attrs
<< 9);
1448 mono_type_equal (gconstpointer ka
, gconstpointer kb
)
1450 const MonoType
*a
= (const MonoType
*) ka
;
1451 const MonoType
*b
= (const MonoType
*) kb
;
1453 if (a
->type
!= b
->type
|| a
->byref
!= b
->byref
|| a
->attrs
!= b
->attrs
|| a
->pinned
!= b
->pinned
)
1455 /* need other checks */
1460 mono_metadata_generic_inst_hash (gconstpointer data
)
1462 const MonoGenericInst
*ginst
= (const MonoGenericInst
*) data
;
1466 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
1468 hash
+= mono_metadata_type_hash (ginst
->type_argv
[i
]);
1471 return hash
^ (ginst
->is_open
<< 8);
1475 mono_generic_inst_equal_full (const MonoGenericInst
*a
, const MonoGenericInst
*b
, gboolean signature_only
)
1479 #ifndef MONO_SMALL_CONFIG
1480 if (a
->id
&& b
->id
) {
1483 if (!signature_only
)
1488 if (a
->is_open
!= b
->is_open
|| a
->type_argc
!= b
->type_argc
)
1490 for (i
= 0; i
< a
->type_argc
; ++i
) {
1491 if (!do_mono_metadata_type_equal (a
->type_argv
[i
], b
->type_argv
[i
], signature_only
))
1498 mono_metadata_generic_inst_equal (gconstpointer ka
, gconstpointer kb
)
1500 const MonoGenericInst
*a
= (const MonoGenericInst
*) ka
;
1501 const MonoGenericInst
*b
= (const MonoGenericInst
*) kb
;
1503 return mono_generic_inst_equal_full (a
, b
, FALSE
);
1507 mono_generic_class_hash (gconstpointer data
)
1509 const MonoGenericClass
*gclass
= (const MonoGenericClass
*) data
;
1510 guint hash
= mono_metadata_type_hash (&gclass
->container_class
->byval_arg
);
1513 hash
+= gclass
->is_tb_open
;
1514 hash
+= mono_metadata_generic_context_hash (&gclass
->context
);
1520 mono_generic_class_equal (gconstpointer ka
, gconstpointer kb
)
1522 const MonoGenericClass
*a
= (const MonoGenericClass
*) ka
;
1523 const MonoGenericClass
*b
= (const MonoGenericClass
*) kb
;
1525 return _mono_metadata_generic_class_equal (a
, b
, FALSE
);
1529 * mono_metadata_init:
1531 * Initialize the global variables of this module.
1532 * This is a Mono runtime internal function.
1535 mono_metadata_init (void)
1539 type_cache
= g_hash_table_new (mono_type_hash
, mono_type_equal
);
1541 for (i
= 0; i
< NBUILTIN_TYPES (); ++i
)
1542 g_hash_table_insert (type_cache
, (gpointer
) &builtin_types
[i
], (gpointer
) &builtin_types
[i
]);
1544 mono_mutex_init_recursive (&image_sets_mutex
);
1548 * mono_metadata_cleanup:
1550 * Free all resources used by this module.
1551 * This is a Mono runtime internal function.
1554 mono_metadata_cleanup (void)
1556 g_hash_table_destroy (type_cache
);
1558 g_ptr_array_free (image_sets
, TRUE
);
1560 mono_mutex_destroy (&image_sets_mutex
);
1564 * mono_metadata_parse_type:
1565 * @m: metadata context
1566 * @mode: king of type that may be found at @ptr
1567 * @opt_attrs: optional attributes to store in the returned type
1568 * @ptr: pointer to the type representation
1569 * @rptr: pointer updated to match the end of the decoded stream
1570 * @transient: whenever to allocate the result from the heap or from a mempool
1572 * Decode a compressed type description found at @ptr in @m.
1573 * @mode can be one of MONO_PARSE_MOD_TYPE, MONO_PARSE_PARAM, MONO_PARSE_RET,
1574 * MONO_PARSE_FIELD, MONO_PARSE_LOCAL, MONO_PARSE_TYPE.
1575 * This function can be used to decode type descriptions in method signatures,
1576 * field signatures, locals signatures etc.
1578 * To parse a generic type, `generic_container' points to the current class'es
1579 * (the `generic_container' field in the MonoClass) or the current generic method's
1580 * (stored in image->property_hash) generic container.
1581 * When we encounter any MONO_TYPE_VAR or MONO_TYPE_MVAR's, they're looked up in
1582 * this MonoGenericContainer.
1584 * LOCKING: Acquires the loader lock.
1586 * Returns: a #MonoType structure representing the decoded type.
1589 mono_metadata_parse_type_internal (MonoImage
*m
, MonoGenericContainer
*container
, MonoParseTypeMode mode
,
1590 short opt_attrs
, gboolean transient
, const char *ptr
, const char **rptr
)
1592 MonoType
*type
, *cached
;
1594 gboolean byref
= FALSE
;
1595 gboolean pinned
= FALSE
;
1596 const char *tmp_ptr
;
1601 * According to the spec, custom modifiers should come before the byref
1602 * flag, but the IL produced by ilasm from the following signature:
1603 * object modopt(...) &
1604 * starts with a byref flag, followed by the modifiers. (bug #49802)
1605 * Also, this type seems to be different from 'object & modopt(...)'. Maybe
1606 * it would be better to treat byref as real type constructor instead of
1608 * Also, pinned should come before anything else, but some MSV++ produced
1609 * assemblies violate this (#bug 61990).
1612 /* Count the modifiers first */
1617 case MONO_TYPE_PINNED
:
1618 case MONO_TYPE_BYREF
:
1621 case MONO_TYPE_CMOD_REQD
:
1622 case MONO_TYPE_CMOD_OPT
:
1624 mono_metadata_parse_custom_mod (m
, NULL
, tmp_ptr
, &tmp_ptr
);
1634 size
= MONO_SIZEOF_TYPE
+ ((gint32
)count
) * sizeof (MonoCustomMod
);
1635 type
= transient
? g_malloc0 (size
) : mono_image_alloc0 (m
, size
);
1636 type
->num_mods
= count
;
1638 g_warning ("got more than 64 modifiers in type");
1641 memset (type
, 0, MONO_SIZEOF_TYPE
);
1644 /* Parse pinned, byref and custom modifiers */
1649 case MONO_TYPE_PINNED
:
1653 case MONO_TYPE_BYREF
:
1657 case MONO_TYPE_CMOD_REQD
:
1658 case MONO_TYPE_CMOD_OPT
:
1659 mono_metadata_parse_custom_mod (m
, &(type
->modifiers
[count
]), ptr
, &ptr
);
1667 type
->attrs
= opt_attrs
;
1668 type
->byref
= byref
;
1669 type
->pinned
= pinned
? 1 : 0;
1671 if (!do_mono_metadata_parse_type (type
, m
, container
, transient
, ptr
, &ptr
)) {
1678 if (!type
->num_mods
&& !transient
) {
1679 /* no need to free type here, because it is on the stack */
1680 if ((type
->type
== MONO_TYPE_CLASS
|| type
->type
== MONO_TYPE_VALUETYPE
) && !type
->pinned
&& !type
->attrs
) {
1681 MonoType
*ret
= type
->byref
? &type
->data
.klass
->this_arg
: &type
->data
.klass
->byval_arg
;
1683 /* Consider the case:
1685 class Foo<T> { class Bar {} }
1686 class Test : Foo<Test>.Bar {}
1688 When Foo<Test> is being expanded, 'Test' isn't yet initialized. It's actually in
1689 a really pristine state: it doesn't even know whether 'Test' is a reference or a value type.
1691 We ensure that the MonoClass is in a state that we can canonicalize to:
1693 klass->byval_arg.data.klass == klass
1694 klass->this_arg.data.klass == klass
1696 If we can't canonicalize 'type', it doesn't matter, since later users of 'type' will do it.
1698 LOCKING: even though we don't explicitly hold a lock, in the problematic case 'ret' is a field
1699 of a MonoClass which currently holds the loader lock. 'type' is local.
1701 if (ret
->data
.klass
== type
->data
.klass
) {
1705 /* No need to use locking since nobody is modifying the hash table */
1706 if ((cached
= g_hash_table_lookup (type_cache
, type
))) {
1711 /* printf ("%x %x %c %s\n", type->attrs, type->num_mods, type->pinned ? 'p' : ' ', mono_type_full_name (type)); */
1713 if (type
== &stype
) {
1714 type
= transient
? g_malloc (MONO_SIZEOF_TYPE
) : mono_image_alloc (m
, MONO_SIZEOF_TYPE
);
1715 memcpy (type
, &stype
, MONO_SIZEOF_TYPE
);
1721 mono_metadata_parse_type_full (MonoImage
*m
, MonoGenericContainer
*container
, MonoParseTypeMode mode
,
1722 short opt_attrs
, const char *ptr
, const char **rptr
)
1724 return mono_metadata_parse_type_internal (m
, container
, mode
, opt_attrs
, FALSE
, ptr
, rptr
);
1728 * LOCKING: Acquires the loader lock.
1731 mono_metadata_parse_type (MonoImage
*m
, MonoParseTypeMode mode
, short opt_attrs
,
1732 const char *ptr
, const char **rptr
)
1734 return mono_metadata_parse_type_full (m
, NULL
, mode
, opt_attrs
, ptr
, rptr
);
1738 mono_metadata_method_has_param_attrs (MonoImage
*m
, int def
)
1740 MonoTableInfo
*paramt
= &m
->tables
[MONO_TABLE_PARAM
];
1741 MonoTableInfo
*methodt
= &m
->tables
[MONO_TABLE_METHOD
];
1742 guint lastp
, i
, param_index
= mono_metadata_decode_row_col (methodt
, def
- 1, MONO_METHOD_PARAMLIST
);
1744 if (def
< methodt
->rows
)
1745 lastp
= mono_metadata_decode_row_col (methodt
, def
, MONO_METHOD_PARAMLIST
);
1747 lastp
= m
->tables
[MONO_TABLE_PARAM
].rows
+ 1;
1749 for (i
= param_index
; i
< lastp
; ++i
) {
1750 guint32 flags
= mono_metadata_decode_row_col (paramt
, i
- 1, MONO_PARAM_FLAGS
);
1759 * mono_metadata_get_param_attrs:
1761 * @m The image to loader parameter attributes from
1762 * @def method def token (one based)
1763 * @param_count number of params to decode including the return value
1765 * Return the parameter attributes for the method whose MethodDef index is DEF. The
1766 * returned memory needs to be freed by the caller. If all the param attributes are
1767 * 0, then NULL is returned.
1770 mono_metadata_get_param_attrs (MonoImage
*m
, int def
, int param_count
)
1772 MonoTableInfo
*paramt
= &m
->tables
[MONO_TABLE_PARAM
];
1773 MonoTableInfo
*methodt
= &m
->tables
[MONO_TABLE_METHOD
];
1774 guint32 cols
[MONO_PARAM_SIZE
];
1775 guint lastp
, i
, param_index
= mono_metadata_decode_row_col (methodt
, def
- 1, MONO_METHOD_PARAMLIST
);
1778 if (def
< methodt
->rows
)
1779 lastp
= mono_metadata_decode_row_col (methodt
, def
, MONO_METHOD_PARAMLIST
);
1781 lastp
= paramt
->rows
+ 1;
1783 for (i
= param_index
; i
< lastp
; ++i
) {
1784 mono_metadata_decode_row (paramt
, i
- 1, cols
, MONO_PARAM_SIZE
);
1785 if (cols
[MONO_PARAM_FLAGS
]) {
1787 pattrs
= g_new0 (int, param_count
);
1788 /* at runtime we just ignore this kind of malformed file:
1789 * the verifier can signal the error to the user
1791 if (cols
[MONO_PARAM_SEQUENCE
] >= param_count
)
1793 pattrs
[cols
[MONO_PARAM_SEQUENCE
]] = cols
[MONO_PARAM_FLAGS
];
1802 * mono_metadata_parse_signature:
1803 * @image: metadata context
1804 * @toke: metadata token
1806 * Decode a method signature stored in the STANDALONESIG table
1808 * Returns: a MonoMethodSignature describing the signature.
1810 MonoMethodSignature
*
1811 mono_metadata_parse_signature (MonoImage
*image
, guint32 token
)
1814 MonoMethodSignature
*ret
;
1815 MonoTableInfo
*tables
= image
->tables
;
1816 guint32 idx
= mono_metadata_token_index (token
);
1820 if (image_is_dynamic (image
))
1821 return mono_lookup_dynamic_token (image
, token
, NULL
);
1823 g_assert (mono_metadata_token_table(token
) == MONO_TABLE_STANDALONESIG
);
1825 sig
= mono_metadata_decode_row_col (&tables
[MONO_TABLE_STANDALONESIG
], idx
- 1, 0);
1827 ptr
= mono_metadata_blob_heap (image
, sig
);
1828 mono_metadata_decode_blob_size (ptr
, &ptr
);
1830 ret
= mono_metadata_parse_method_signature_full (image
, NULL
, 0, ptr
, NULL
, &error
);
1831 mono_error_cleanup (&error
); /*FIXME don't swallow the error message*/
1836 * mono_metadata_signature_alloc:
1837 * @image: metadata context
1838 * @nparmas: number of parameters in the signature
1840 * Allocate a MonoMethodSignature structure with the specified number of params.
1841 * The return type and the params types need to be filled later.
1842 * This is a Mono runtime internal function.
1844 * LOCKING: Assumes the loader lock is held.
1846 * Returns: the new MonoMethodSignature structure.
1848 MonoMethodSignature
*
1849 mono_metadata_signature_alloc (MonoImage
*m
, guint32 nparams
)
1851 MonoMethodSignature
*sig
;
1853 sig
= mono_image_alloc0 (m
, MONO_SIZEOF_METHOD_SIGNATURE
+ ((gint32
)nparams
) * sizeof (MonoType
*));
1854 sig
->param_count
= nparams
;
1855 sig
->sentinelpos
= -1;
1860 static MonoMethodSignature
*
1861 mono_metadata_signature_dup_internal (MonoImage
*image
, MonoMemPool
*mp
, MonoMethodSignature
*sig
)
1864 MonoMethodSignature
*ret
;
1865 sigsize
= MONO_SIZEOF_METHOD_SIGNATURE
+ sig
->param_count
* sizeof (MonoType
*);
1868 ret
= mono_image_alloc (image
, sigsize
);
1870 ret
= mono_mempool_alloc (mp
, sigsize
);
1872 ret
= g_malloc (sigsize
);
1874 memcpy (ret
, sig
, sigsize
);
1878 MonoMethodSignature
*
1879 mono_metadata_signature_dup_full (MonoImage
*image
, MonoMethodSignature
*sig
)
1881 return mono_metadata_signature_dup_internal (image
, NULL
, sig
);
1884 /*The mempool is accessed without synchronization*/
1885 MonoMethodSignature
*
1886 mono_metadata_signature_dup_mempool (MonoMemPool
*mp
, MonoMethodSignature
*sig
)
1888 return mono_metadata_signature_dup_internal (NULL
, mp
, sig
);
1892 * mono_metadata_signature_dup:
1893 * @sig: method signature
1895 * Duplicate an existing MonoMethodSignature so it can be modified.
1896 * This is a Mono runtime internal function.
1898 * Returns: the new MonoMethodSignature structure.
1900 MonoMethodSignature
*
1901 mono_metadata_signature_dup (MonoMethodSignature
*sig
)
1903 return mono_metadata_signature_dup_full (NULL
, sig
);
1907 * mono_metadata_signature_size:
1909 * Return the amount of memory allocated to SIG.
1912 mono_metadata_signature_size (MonoMethodSignature
*sig
)
1914 return MONO_SIZEOF_METHOD_SIGNATURE
+ sig
->param_count
* sizeof (MonoType
*);
1918 * mono_metadata_parse_method_signature:
1919 * @m: metadata context
1920 * @generic_container: generics container
1921 * @def: the MethodDef index or 0 for Ref signatures.
1922 * @ptr: pointer to the signature metadata representation
1923 * @rptr: pointer updated to match the end of the decoded stream
1925 * Decode a method signature stored at @ptr.
1926 * This is a Mono runtime internal function.
1928 * LOCKING: Assumes the loader lock is held.
1930 * Returns: a MonoMethodSignature describing the signature.
1932 MonoMethodSignature
*
1933 mono_metadata_parse_method_signature_full (MonoImage
*m
, MonoGenericContainer
*container
,
1934 int def
, const char *ptr
, const char **rptr
, MonoError
*error
)
1936 MonoMethodSignature
*method
;
1937 int i
, *pattrs
= NULL
;
1938 guint32 hasthis
= 0, explicit_this
= 0, call_convention
, param_count
;
1939 guint32 gen_param_count
= 0;
1940 gboolean is_open
= FALSE
;
1942 mono_error_init (error
);
1945 gen_param_count
= 1;
1950 call_convention
= *ptr
& 0x0F;
1952 if (gen_param_count
)
1953 gen_param_count
= mono_metadata_decode_value (ptr
, &ptr
);
1954 param_count
= mono_metadata_decode_value (ptr
, &ptr
);
1957 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 */
1959 method
= mono_metadata_signature_alloc (m
, param_count
);
1960 method
->hasthis
= hasthis
;
1961 method
->explicit_this
= explicit_this
;
1962 method
->call_convention
= call_convention
;
1963 method
->generic_param_count
= gen_param_count
;
1965 if (call_convention
!= 0xa) {
1966 method
->ret
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_RET
, pattrs
? pattrs
[0] : 0, ptr
, &ptr
);
1968 mono_metadata_free_method_signature (method
);
1970 if (mono_loader_get_last_error ())
1971 mono_error_set_from_loader_error (error
);
1973 mono_error_set_bad_image (error
, m
, "Could not parse return type signature");
1976 is_open
= mono_class_is_open_constructed_type (method
->ret
);
1979 for (i
= 0; i
< method
->param_count
; ++i
) {
1980 if (*ptr
== MONO_TYPE_SENTINEL
) {
1981 if (method
->call_convention
!= MONO_CALL_VARARG
|| def
) {
1982 mono_loader_assert_no_error ();
1983 mono_error_set_bad_image (error
, m
, "Found sentinel for methoddef or no vararg");
1987 if (method
->sentinelpos
>= 0) {
1988 mono_loader_assert_no_error ();
1989 mono_error_set_bad_image (error
, m
, "Found sentinel twice in the same signature.");
1993 method
->sentinelpos
= i
;
1996 method
->params
[i
] = mono_metadata_parse_type_full (m
, container
, MONO_PARSE_PARAM
, pattrs
? pattrs
[i
+1] : 0, ptr
, &ptr
);
1997 if (!method
->params
[i
]) {
1998 if (mono_loader_get_last_error ())
1999 mono_error_set_from_loader_error (error
);
2001 mono_error_set_bad_image (error
, m
, "Could not parse type argument %d on method signature", i
);
2002 mono_metadata_free_method_signature (method
);
2007 is_open
= mono_class_is_open_constructed_type (method
->params
[i
]);
2010 /* The sentinel could be missing if the caller does not pass any additional arguments */
2011 if (!def
&& method
->call_convention
== MONO_CALL_VARARG
&& method
->sentinelpos
< 0)
2012 method
->sentinelpos
= method
->param_count
;
2014 method
->has_type_parameters
= is_open
;
2016 if (def
&& (method
->call_convention
== MONO_CALL_VARARG
))
2017 method
->sentinelpos
= method
->param_count
;
2024 * Add signature to a cache and increase ref count...
2027 mono_loader_assert_no_error ();
2032 * mono_metadata_parse_method_signature:
2033 * @m: metadata context
2034 * @def: the MethodDef index or 0 for Ref signatures.
2035 * @ptr: pointer to the signature metadata representation
2036 * @rptr: pointer updated to match the end of the decoded stream
2038 * Decode a method signature stored at @ptr.
2039 * This is a Mono runtime internal function.
2041 * LOCKING: Assumes the loader lock is held.
2043 * Returns: a MonoMethodSignature describing the signature.
2045 MonoMethodSignature
*
2046 mono_metadata_parse_method_signature (MonoImage
*m
, int def
, const char *ptr
, const char **rptr
)
2049 MonoMethodSignature
*ret
;
2050 ret
= mono_metadata_parse_method_signature_full (m
, NULL
, def
, ptr
, rptr
, &error
);
2052 mono_loader_set_error_from_mono_error (&error
);
2053 mono_error_cleanup (&error
); /*FIXME don't swallow the error message*/
2059 * mono_metadata_free_method_signature:
2060 * @sig: signature to destroy
2062 * Free the memory allocated in the signature @sig.
2063 * This method needs to be robust and work also on partially-built
2064 * signatures, so it does extra checks.
2067 mono_metadata_free_method_signature (MonoMethodSignature
*sig
)
2069 /* Everything is allocated from mempools */
2073 mono_metadata_free_type (sig->ret);
2074 for (i = 0; i < sig->param_count; ++i) {
2075 if (sig->params [i])
2076 mono_metadata_free_type (sig->params [i]);
2082 mono_metadata_free_inflated_signature (MonoMethodSignature
*sig
)
2086 /* Allocated in inflate_generic_signature () */
2088 mono_metadata_free_type (sig
->ret
);
2089 for (i
= 0; i
< sig
->param_count
; ++i
) {
2090 if (sig
->params
[i
])
2091 mono_metadata_free_type (sig
->params
[i
]);
2097 inflated_method_equal (gconstpointer a
, gconstpointer b
)
2099 const MonoMethodInflated
*ma
= a
;
2100 const MonoMethodInflated
*mb
= b
;
2101 if (ma
->declaring
!= mb
->declaring
)
2103 if (ma
->method
.method
.is_mb_open
!= mb
->method
.method
.is_mb_open
)
2105 return mono_metadata_generic_context_equal (&ma
->context
, &mb
->context
);
2109 inflated_method_hash (gconstpointer a
)
2111 const MonoMethodInflated
*ma
= a
;
2112 return (mono_metadata_generic_context_hash (&ma
->context
) ^ mono_aligned_addr_hash (ma
->declaring
)) + ma
->method
.method
.is_mb_open
;
2116 inflated_signature_equal (gconstpointer a
, gconstpointer b
)
2118 const MonoInflatedMethodSignature
*sig1
= a
;
2119 const MonoInflatedMethodSignature
*sig2
= b
;
2121 /* sig->sig is assumed to be canonized */
2122 if (sig1
->sig
!= sig2
->sig
)
2124 /* The generic instances are canonized */
2125 return mono_metadata_generic_context_equal (&sig1
->context
, &sig2
->context
);
2129 inflated_signature_hash (gconstpointer a
)
2131 const MonoInflatedMethodSignature
*sig
= a
;
2133 /* sig->sig is assumed to be canonized */
2134 return mono_metadata_generic_context_hash (&sig
->context
) ^ mono_aligned_addr_hash (sig
->sig
);
2138 dump_ginst (MonoGenericInst *ginst)
2143 g_print ("Ginst: <");
2144 for (i = 0; i < ginst->type_argc; ++i) {
2147 name = mono_type_get_name (ginst->type_argv [i]);
2148 g_print ("%s", name);
2154 static gboolean
type_in_image (MonoType
*type
, MonoImage
*image
);
2157 signature_in_image (MonoMethodSignature
*sig
, MonoImage
*image
)
2159 gpointer iter
= NULL
;
2162 while ((p
= mono_signature_get_params (sig
, &iter
)) != NULL
)
2163 if (type_in_image (p
, image
))
2166 return type_in_image (mono_signature_get_return_type (sig
), image
);
2170 ginst_in_image (MonoGenericInst
*ginst
, MonoImage
*image
)
2174 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
2175 if (type_in_image (ginst
->type_argv
[i
], image
))
2183 gclass_in_image (MonoGenericClass
*gclass
, MonoImage
*image
)
2185 return gclass
->container_class
->image
== image
||
2186 ginst_in_image (gclass
->context
.class_inst
, image
);
2190 type_in_image (MonoType
*type
, MonoImage
*image
)
2193 switch (type
->type
) {
2194 case MONO_TYPE_GENERICINST
:
2195 return gclass_in_image (type
->data
.generic_class
, image
);
2197 type
= type
->data
.type
;
2199 case MONO_TYPE_SZARRAY
:
2200 type
= &type
->data
.klass
->byval_arg
;
2202 case MONO_TYPE_ARRAY
:
2203 type
= &type
->data
.array
->eklass
->byval_arg
;
2205 case MONO_TYPE_FNPTR
:
2206 return signature_in_image (type
->data
.method
, image
);
2207 case MONO_TYPE_VAR
: {
2208 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2210 g_assert (!container
->is_method
);
2212 * FIXME: The following check is here solely
2213 * for monodis, which uses the internal
2215 * mono_metadata_load_generic_params(). The
2216 * caller of that function needs to fill in
2217 * owner->klass or owner->method of the
2218 * returned struct, but monodis doesn't do
2219 * that. The image unloading depends on that,
2220 * however, so a crash results without this
2223 if (!container
->owner
.klass
)
2224 return container
->image
== image
;
2225 return container
->owner
.klass
->image
== image
;
2227 return type
->data
.generic_param
->image
== image
;
2230 case MONO_TYPE_MVAR
: {
2231 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2232 if (type
->data
.generic_param
->image
== image
)
2235 g_assert (container
->is_method
);
2236 if (!container
->owner
.method
)
2237 /* RefEmit created generic param whose method is not finished */
2238 return container
->image
== image
;
2239 return container
->owner
.method
->klass
->image
== image
;
2241 return type
->data
.generic_param
->image
== image
;
2245 /* At this point, we should've avoided all potential allocations in mono_class_from_mono_type () */
2246 return image
== mono_class_from_mono_type (type
)->image
;
2251 image_sets_lock (void)
2253 mono_mutex_lock (&image_sets_mutex
);
2257 image_sets_unlock (void)
2259 mono_mutex_unlock (&image_sets_mutex
);
2265 * Return a MonoImageSet representing the set of images in IMAGES.
2267 static MonoImageSet
*
2268 get_image_set (MonoImage
**images
, int nimages
)
2275 if (nimages
== 1 && images
[0] == mono_defaults
.corlib
&& mscorlib_image_set
)
2276 return mscorlib_image_set
;
2278 /* Happens with empty generic instances */
2280 return mscorlib_image_set
;
2285 image_sets
= g_ptr_array_new ();
2287 if (images
[0] == mono_defaults
.corlib
&& nimages
> 1)
2288 l
= images
[1]->image_sets
;
2290 l
= images
[0]->image_sets
;
2293 for (; l
; l
= l
->next
) {
2296 if (set
->nimages
== nimages
) {
2297 for (j
= 0; j
< nimages
; ++j
) {
2298 for (k
= 0; k
< nimages
; ++k
)
2299 if (set
->images
[k
] == images
[j
])
2313 set
= g_new0 (MonoImageSet
, 1);
2314 set
->nimages
= nimages
;
2315 set
->images
= g_new0 (MonoImage
*, nimages
);
2316 mono_mutex_init_recursive (&set
->lock
);
2317 for (i
= 0; i
< nimages
; ++i
)
2318 set
->images
[i
] = images
[i
];
2319 set
->gclass_cache
= g_hash_table_new_full (mono_generic_class_hash
, mono_generic_class_equal
, NULL
, (GDestroyNotify
)free_generic_class
);
2320 set
->ginst_cache
= g_hash_table_new_full (mono_metadata_generic_inst_hash
, mono_metadata_generic_inst_equal
, NULL
, (GDestroyNotify
)free_generic_inst
);
2321 set
->gmethod_cache
= g_hash_table_new_full (inflated_method_hash
, inflated_method_equal
, NULL
, (GDestroyNotify
)free_inflated_method
);
2322 set
->gsignature_cache
= g_hash_table_new_full (inflated_signature_hash
, inflated_signature_equal
, NULL
, (GDestroyNotify
)free_inflated_signature
);
2324 for (i
= 0; i
< nimages
; ++i
)
2325 set
->images
[i
]->image_sets
= g_slist_prepend (set
->images
[i
]->image_sets
, set
);
2327 g_ptr_array_add (image_sets
, set
);
2330 if (nimages
== 1 && images
[0] == mono_defaults
.corlib
) {
2331 mono_memory_barrier ();
2332 mscorlib_image_set
= set
;
2335 image_sets_unlock ();
2341 delete_image_set (MonoImageSet
*set
)
2345 g_hash_table_destroy (set
->gclass_cache
);
2346 g_hash_table_destroy (set
->ginst_cache
);
2347 g_hash_table_destroy (set
->gmethod_cache
);
2348 g_hash_table_destroy (set
->gsignature_cache
);
2352 for (i
= 0; i
< set
->nimages
; ++i
)
2353 set
->images
[i
]->image_sets
= g_slist_remove (set
->images
[i
]->image_sets
, set
);
2355 g_ptr_array_remove (image_sets
, set
);
2357 image_sets_unlock ();
2360 mono_mempool_destroy (set
->mempool
);
2361 g_free (set
->images
);
2362 mono_mutex_destroy (&set
->lock
);
2367 mono_image_set_lock (MonoImageSet
*set
)
2369 mono_mutex_lock (&set
->lock
);
2373 mono_image_set_unlock (MonoImageSet
*set
)
2375 mono_mutex_unlock (&set
->lock
);
2379 mono_image_set_alloc (MonoImageSet
*set
, guint size
)
2383 mono_image_set_lock (set
);
2385 set
->mempool
= mono_mempool_new_size (1024);
2386 res
= mono_mempool_alloc (set
->mempool
, size
);
2387 mono_image_set_unlock (set
);
2393 mono_image_set_alloc0 (MonoImageSet
*set
, guint size
)
2397 mono_image_set_lock (set
);
2399 set
->mempool
= mono_mempool_new_size (1024);
2400 res
= mono_mempool_alloc0 (set
->mempool
, size
);
2401 mono_image_set_unlock (set
);
2407 mono_image_set_strdup (MonoImageSet
*set
, const char *s
)
2411 mono_image_set_lock (set
);
2413 set
->mempool
= mono_mempool_new_size (1024);
2414 res
= mono_mempool_strdup (set
->mempool
, s
);
2415 mono_image_set_unlock (set
);
2421 * Structure used by the collect_..._images functions to store the image list.
2424 MonoImage
*image_buf
[64];
2426 int nimages
, images_len
;
2430 collect_data_init (CollectData
*data
)
2432 data
->images
= data
->image_buf
;
2433 data
->images_len
= 64;
2438 collect_data_free (CollectData
*data
)
2440 if (data
->images
!= data
->image_buf
)
2441 g_free (data
->images
);
2445 enlarge_data (CollectData
*data
)
2447 int new_len
= data
->images_len
< 16 ? 16 : data
->images_len
* 2;
2448 MonoImage
**d
= g_new (MonoImage
*, new_len
);
2451 g_assert_not_reached ();
2452 memcpy (d
, data
->images
, data
->images_len
);
2453 if (data
->images
!= data
->image_buf
)
2454 g_free (data
->images
);
2456 data
->images_len
= new_len
;
2460 add_image (MonoImage
*image
, CollectData
*data
)
2464 /* The arrays are small, so use a linear search instead of a hash table */
2465 for (i
= 0; i
< data
->nimages
; ++i
)
2466 if (data
->images
[i
] == image
)
2469 if (data
->nimages
== data
->images_len
)
2470 enlarge_data (data
);
2472 data
->images
[data
->nimages
++] = image
;
2476 collect_type_images (MonoType
*type
, CollectData
*data
);
2479 collect_ginst_images (MonoGenericInst
*ginst
, CollectData
*data
)
2483 for (i
= 0; i
< ginst
->type_argc
; ++i
) {
2484 collect_type_images (ginst
->type_argv
[i
], data
);
2489 collect_gclass_images (MonoGenericClass
*gclass
, CollectData
*data
)
2491 add_image (gclass
->container_class
->image
, data
);
2492 if (gclass
->context
.class_inst
)
2493 collect_ginst_images (gclass
->context
.class_inst
, data
);
2497 collect_signature_images (MonoMethodSignature
*sig
, CollectData
*data
)
2499 gpointer iter
= NULL
;
2502 collect_type_images (mono_signature_get_return_type (sig
), data
);
2503 while ((p
= mono_signature_get_params (sig
, &iter
)) != NULL
)
2504 collect_type_images (p
, data
);
2508 collect_inflated_signature_images (MonoInflatedMethodSignature
*sig
, CollectData
*data
)
2510 collect_signature_images (sig
->sig
, data
);
2511 if (sig
->context
.class_inst
)
2512 collect_ginst_images (sig
->context
.class_inst
, data
);
2513 if (sig
->context
.method_inst
)
2514 collect_ginst_images (sig
->context
.method_inst
, data
);
2518 collect_method_images (MonoMethodInflated
*method
, CollectData
*data
)
2520 MonoMethod
*m
= method
->declaring
;
2522 add_image (method
->declaring
->klass
->image
, data
);
2523 if (method
->context
.class_inst
)
2524 collect_ginst_images (method
->context
.class_inst
, data
);
2525 if (method
->context
.method_inst
)
2526 collect_ginst_images (method
->context
.method_inst
, data
);
2528 * Dynamic assemblies have no references, so the images they depend on can be unloaded before them.
2530 if (image_is_dynamic (m
->klass
->image
))
2531 collect_signature_images (mono_method_signature (m
), data
);
2535 collect_type_images (MonoType
*type
, CollectData
*data
)
2538 switch (type
->type
) {
2539 case MONO_TYPE_GENERICINST
:
2540 collect_gclass_images (type
->data
.generic_class
, data
);
2543 type
= type
->data
.type
;
2545 case MONO_TYPE_SZARRAY
:
2546 type
= &type
->data
.klass
->byval_arg
;
2548 case MONO_TYPE_ARRAY
:
2549 type
= &type
->data
.array
->eklass
->byval_arg
;
2551 case MONO_TYPE_FNPTR
:
2552 //return signature_in_image (type->data.method, image);
2553 g_assert_not_reached ();
2554 case MONO_TYPE_VAR
: {
2555 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2557 g_assert (!container
->is_method
);
2559 * FIXME: The following check is here solely
2560 * for monodis, which uses the internal
2562 * mono_metadata_load_generic_params(). The
2563 * caller of that function needs to fill in
2564 * owner->klass or owner->method of the
2565 * returned struct, but monodis doesn't do
2566 * that. The image unloading depends on that,
2567 * however, so a crash results without this
2570 if (!container
->owner
.klass
)
2571 add_image (container
->image
, data
);
2573 add_image (container
->owner
.klass
->image
, data
);
2575 add_image (type
->data
.generic_param
->image
, data
);
2579 case MONO_TYPE_MVAR
: {
2580 MonoGenericContainer
*container
= mono_type_get_generic_param_owner (type
);
2581 if (type
->data
.generic_param
->image
)
2582 add_image (type
->data
.generic_param
->image
, data
);
2584 if (!container
->owner
.method
) {
2585 /* RefEmit created generic param whose method is not finished */
2586 add_image (container
->image
, data
);
2588 g_assert (container
->is_method
);
2589 add_image (container
->owner
.method
->klass
->image
, data
);
2592 add_image (type
->data
.generic_param
->image
, data
);
2596 case MONO_TYPE_CLASS
:
2597 case MONO_TYPE_VALUETYPE
:
2598 add_image (mono_class_from_mono_type (type
)->image
, data
);
2601 add_image (mono_defaults
.corlib
, data
);
2608 } CleanForImageUserData
;
2611 steal_gclass_in_image (gpointer key
, gpointer value
, gpointer data
)
2613 MonoGenericClass
*gclass
= key
;
2614 CleanForImageUserData
*user_data
= data
;
2616 g_assert (gclass_in_image (gclass
, user_data
->image
));
2618 user_data
->list
= g_slist_prepend (user_data
->list
, gclass
);
2623 steal_ginst_in_image (gpointer key
, gpointer value
, gpointer data
)
2625 MonoGenericInst
*ginst
= key
;
2626 CleanForImageUserData
*user_data
= data
;
2628 // This doesn't work during corlib compilation
2629 //g_assert (ginst_in_image (ginst, user_data->image));
2631 user_data
->list
= g_slist_prepend (user_data
->list
, ginst
);
2636 inflated_method_in_image (gpointer key
, gpointer value
, gpointer data
)
2638 MonoImage
*image
= data
;
2639 MonoMethodInflated
*method
= key
;
2642 // https://bugzilla.novell.com/show_bug.cgi?id=458168
2643 g_assert (method
->declaring
->klass
->image
== image
||
2644 (method
->context
.class_inst
&& ginst_in_image (method
->context
.class_inst
, image
)) ||
2645 (method
->context
.method_inst
&& ginst_in_image (method
->context
.method_inst
, image
)) || (((MonoMethod
*)method
)->signature
&& signature_in_image (mono_method_signature ((MonoMethod
*)method
), image
)));
2651 inflated_signature_in_image (gpointer key
, gpointer value
, gpointer data
)
2653 MonoImage
*image
= data
;
2654 MonoInflatedMethodSignature
*sig
= key
;
2656 return signature_in_image (sig
->sig
, image
) ||
2657 (sig
->context
.class_inst
&& ginst_in_image (sig
->context
.class_inst
, image
)) ||
2658 (sig
->context
.method_inst
&& ginst_in_image (sig
->context
.method_inst
, image
));
2662 check_gmethod (gpointer key
, gpointer value
, gpointer data
)
2664 MonoMethodInflated
*method
= key
;
2665 MonoImage
*image
= data
;
2667 if (method
->context
.class_inst
)
2668 g_assert (!ginst_in_image (method
->context
.class_inst
, image
));
2669 if (method
->context
.method_inst
)
2670 g_assert (!ginst_in_image (method
->context
.method_inst
, image
));
2671 if (((MonoMethod
*)method
)->signature
)
2672 g_assert (!signature_in_image (mono_method_signature ((MonoMethod
*)method
), image
));
2678 * Run a consistency check on the image set data structures.
2680 static G_GNUC_UNUSED
void
2681 check_image_sets (MonoImage
*image
)
2684 GSList
*l
= image
->image_sets
;
2689 for (i
= 0; i
< image_sets
->len
; ++i
) {
2690 MonoImageSet
*set
= g_ptr_array_index (image_sets
, i
);
2692 if (!g_slist_find (l
, set
)) {
2693 g_hash_table_foreach (set
->gmethod_cache
, check_gmethod
, image
);
2699 mono_metadata_clean_for_image (MonoImage
*image
)
2701 CleanForImageUserData ginst_data
, gclass_data
;
2702 GSList
*l
, *set_list
;
2704 //check_image_sets (image);
2707 * The data structures could reference each other so we delete them in two phases.
2708 * This is required because of the hashing functions in gclass/ginst_cache.
2710 ginst_data
.image
= gclass_data
.image
= image
;
2711 ginst_data
.list
= gclass_data
.list
= NULL
;
2713 /* Collect the items to delete */
2714 /* delete_image_set () modifies the lists so make a copy */
2715 for (l
= image
->image_sets
; l
; l
= l
->next
) {
2716 MonoImageSet
*set
= l
->data
;
2718 mono_image_set_lock (set
);
2719 g_hash_table_foreach_steal (set
->gclass_cache
, steal_gclass_in_image
, &gclass_data
);
2720 g_hash_table_foreach_steal (set
->ginst_cache
, steal_ginst_in_image
, &ginst_data
);
2721 g_hash_table_foreach_remove (set
->gmethod_cache
, inflated_method_in_image
, image
);
2722 g_hash_table_foreach_remove (set
->gsignature_cache
, inflated_signature_in_image
, image
);
2723 mono_image_set_unlock (set
);
2726 /* Delete the removed items */
2727 for (l
= ginst_data
.list
; l
; l
= l
->next
)
2728 free_generic_inst (l
->data
);
2729 for (l
= gclass_data
.list
; l
; l
= l
->next
)
2730 free_generic_class (l
->data
);
2731 g_slist_free (ginst_data
.list
);
2732 g_slist_free (gclass_data
.list
);
2733 /* delete_image_set () modifies the lists so make a copy */
2734 set_list
= g_slist_copy (image
->image_sets
);
2735 for (l
= set_list
; l
; l
= l
->next
) {
2736 MonoImageSet
*set
= l
->data
;
2738 delete_image_set (set
);
2740 g_slist_free (set_list
);
2744 free_inflated_method (MonoMethodInflated
*imethod
)
2747 MonoMethod
*method
= (MonoMethod
*)imethod
;
2749 mono_marshal_free_inflated_wrappers (method
);
2751 if (method
->signature
)
2752 mono_metadata_free_inflated_signature (method
->signature
);
2754 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
))) {
2755 MonoMethodHeader
*header
= imethod
->header
;
2758 /* Allocated in inflate_generic_header () */
2759 for (i
= 0; i
< header
->num_locals
; ++i
)
2760 mono_metadata_free_type (header
->locals
[i
]);
2761 g_free (header
->clauses
);
2770 free_generic_inst (MonoGenericInst
*ginst
)
2774 /* The ginst itself is allocated from the image set mempool */
2775 for (i
= 0; i
< ginst
->type_argc
; ++i
)
2776 mono_metadata_free_type (ginst
->type_argv
[i
]);
2780 free_generic_class (MonoGenericClass
*gclass
)
2782 /* The gclass itself is allocated from the image set mempool */
2783 if (gclass
->is_dynamic
)
2784 mono_reflection_free_dynamic_generic_class (gclass
);
2785 if (gclass
->cached_class
&& gclass
->cached_class
->interface_id
)
2786 mono_unload_interface_id (gclass
->cached_class
);
2790 free_inflated_signature (MonoInflatedMethodSignature
*sig
)
2792 mono_metadata_free_inflated_signature (sig
->sig
);
2797 mono_method_inflated_lookup (MonoMethodInflated
* method
, gboolean cache
)
2803 collect_data_init (&data
);
2805 collect_method_images (method
, &data
);
2807 set
= get_image_set (data
.images
, data
.nimages
);
2809 collect_data_free (&data
);
2811 mono_image_set_lock (set
);
2812 res
= g_hash_table_lookup (set
->gmethod_cache
, method
);
2813 if (!res
&& cache
) {
2814 g_hash_table_insert (set
->gmethod_cache
, method
, method
);
2818 mono_image_set_unlock (set
);
2823 * mono_metadata_get_inflated_signature:
2825 * Given an inflated signature and a generic context, return a canonical copy of the
2826 * signature. The returned signature might be equal to SIG or it might be a cached copy.
2828 MonoMethodSignature
*
2829 mono_metadata_get_inflated_signature (MonoMethodSignature
*sig
, MonoGenericContext
*context
)
2831 MonoInflatedMethodSignature helper
;
2832 MonoInflatedMethodSignature
*res
;
2837 helper
.context
.class_inst
= context
->class_inst
;
2838 helper
.context
.method_inst
= context
->method_inst
;
2840 collect_data_init (&data
);
2842 collect_inflated_signature_images (&helper
, &data
);
2844 set
= get_image_set (data
.images
, data
.nimages
);
2846 collect_data_free (&data
);
2848 mono_image_set_lock (set
);
2850 res
= g_hash_table_lookup (set
->gsignature_cache
, &helper
);
2852 res
= g_new0 (MonoInflatedMethodSignature
, 1);
2854 res
->context
.class_inst
= context
->class_inst
;
2855 res
->context
.method_inst
= context
->method_inst
;
2856 g_hash_table_insert (set
->gsignature_cache
, res
, res
);
2859 mono_image_set_unlock (set
);
2865 * mono_metadata_get_generic_inst:
2867 * Given a list of types, return a MonoGenericInst that represents that list.
2868 * The returned MonoGenericInst has its own copy of the list of types. The list
2869 * passed in the argument can be freed, modified or disposed of.
2873 mono_metadata_get_generic_inst (int type_argc
, MonoType
**type_argv
)
2875 MonoGenericInst
*ginst
;
2878 int size
= MONO_SIZEOF_GENERIC_INST
+ type_argc
* sizeof (MonoType
*);
2882 for (i
= 0; i
< type_argc
; ++i
)
2883 if (mono_class_is_open_constructed_type (type_argv
[i
]))
2885 is_open
= (i
< type_argc
);
2887 ginst
= g_alloca (size
);
2888 memset (ginst
, 0, sizeof (MonoGenericInst
));
2889 ginst
->is_open
= is_open
;
2890 ginst
->type_argc
= type_argc
;
2891 memcpy (ginst
->type_argv
, type_argv
, type_argc
* sizeof (MonoType
*));
2893 collect_data_init (&data
);
2895 collect_ginst_images (ginst
, &data
);
2897 set
= get_image_set (data
.images
, data
.nimages
);
2899 collect_data_free (&data
);
2901 mono_image_set_lock (set
);
2903 ginst
= g_hash_table_lookup (set
->ginst_cache
, ginst
);
2905 ginst
= mono_image_set_alloc0 (set
, size
);
2906 #ifndef MONO_SMALL_CONFIG
2907 ginst
->id
= ++next_generic_inst_id
;
2909 ginst
->is_open
= is_open
;
2910 ginst
->type_argc
= type_argc
;
2912 for (i
= 0; i
< type_argc
; ++i
)
2913 ginst
->type_argv
[i
] = mono_metadata_type_dup (NULL
, type_argv
[i
]);
2915 g_hash_table_insert (set
->ginst_cache
, ginst
, ginst
);
2918 mono_image_set_unlock (set
);
2923 mono_metadata_is_type_builder_generic_type_definition (MonoClass
*container_class
, MonoGenericInst
*inst
, gboolean is_dynamic
)
2925 MonoGenericContainer
*container
= container_class
->generic_container
;
2927 if (!is_dynamic
|| container_class
->wastypebuilder
|| container
->type_argc
!= inst
->type_argc
)
2929 return inst
== container
->context
.class_inst
;
2933 * mono_metadata_lookup_generic_class:
2935 * Returns a MonoGenericClass with the given properties.
2939 mono_metadata_lookup_generic_class (MonoClass
*container_class
, MonoGenericInst
*inst
, gboolean is_dynamic
)
2941 MonoGenericClass
*gclass
;
2942 MonoGenericClass helper
;
2943 gboolean is_tb_open
= mono_metadata_is_type_builder_generic_type_definition (container_class
, inst
, is_dynamic
);
2947 helper
.container_class
= container_class
;
2948 helper
.context
.class_inst
= inst
;
2949 helper
.context
.method_inst
= NULL
;
2950 helper
.is_dynamic
= is_dynamic
; /* We use this in a hash lookup, which does not attempt to downcast the pointer */
2951 helper
.is_tb_open
= is_tb_open
;
2952 helper
.cached_class
= NULL
;
2954 collect_data_init (&data
);
2956 collect_gclass_images (&helper
, &data
);
2958 set
= get_image_set (data
.images
, data
.nimages
);
2960 collect_data_free (&data
);
2962 mono_image_set_lock (set
);
2964 gclass
= g_hash_table_lookup (set
->gclass_cache
, &helper
);
2966 /* A tripwire just to keep us honest */
2967 g_assert (!helper
.cached_class
);
2970 mono_image_set_unlock (set
);
2975 MonoDynamicGenericClass
*dgclass
= mono_image_set_new0 (set
, MonoDynamicGenericClass
, 1);
2976 gclass
= &dgclass
->generic_class
;
2977 gclass
->is_dynamic
= 1;
2979 gclass
= mono_image_set_new0 (set
, MonoGenericClass
, 1);
2982 gclass
->is_tb_open
= is_tb_open
;
2983 gclass
->container_class
= container_class
;
2984 gclass
->context
.class_inst
= inst
;
2985 gclass
->context
.method_inst
= NULL
;
2986 gclass
->owner
= set
;
2987 if (inst
== container_class
->generic_container
->context
.class_inst
&& !is_tb_open
)
2988 gclass
->cached_class
= container_class
;
2990 g_hash_table_insert (set
->gclass_cache
, gclass
, gclass
);
2992 mono_image_set_unlock (set
);
2998 * mono_metadata_inflate_generic_inst:
3000 * Instantiate the generic instance @ginst with the context @context.
3001 * Check @error for success.
3005 mono_metadata_inflate_generic_inst (MonoGenericInst
*ginst
, MonoGenericContext
*context
, MonoError
*error
)
3007 MonoType
**type_argv
;
3008 MonoGenericInst
*nginst
= NULL
;
3011 mono_error_init (error
);
3013 if (!ginst
->is_open
)
3016 type_argv
= g_new0 (MonoType
*, ginst
->type_argc
);
3018 for (i
= 0; i
< ginst
->type_argc
; i
++) {
3019 type_argv
[i
] = mono_class_inflate_generic_type_checked (ginst
->type_argv
[i
], context
, error
);
3020 if (!mono_error_ok (error
))
3025 nginst
= mono_metadata_get_generic_inst (ginst
->type_argc
, type_argv
);
3028 for (i
= 0; i
< count
; i
++)
3029 mono_metadata_free_type (type_argv
[i
]);
3036 mono_metadata_parse_generic_inst (MonoImage
*m
, MonoGenericContainer
*container
,
3037 int count
, const char *ptr
, const char **rptr
)
3039 MonoType
**type_argv
;
3040 MonoGenericInst
*ginst
;
3043 type_argv
= g_new0 (MonoType
*, count
);
3045 for (i
= 0; i
< count
; i
++) {
3046 MonoType
*t
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
3057 ginst
= mono_metadata_get_generic_inst (count
, type_argv
);
3065 do_mono_metadata_parse_generic_class (MonoType
*type
, MonoImage
*m
, MonoGenericContainer
*container
,
3066 const char *ptr
, const char **rptr
)
3068 MonoGenericInst
*inst
;
3073 gtype
= mono_metadata_parse_type (m
, MONO_PARSE_TYPE
, 0, ptr
, &ptr
);
3077 gklass
= mono_class_from_mono_type (gtype
);
3078 if (!gklass
->generic_container
)
3081 count
= mono_metadata_decode_value (ptr
, &ptr
);
3082 inst
= mono_metadata_parse_generic_inst (m
, container
, count
, ptr
, &ptr
);
3089 type
->data
.generic_class
= mono_metadata_lookup_generic_class (gklass
, inst
, FALSE
);
3095 * @gc: The generic container to normalize
3096 * @type: The kind of generic parameters the resulting generic-container should contain
3099 static MonoGenericContainer
*
3100 select_container (MonoGenericContainer
*gc
, MonoTypeEnum type
)
3102 gboolean is_var
= (type
== MONO_TYPE_VAR
);
3106 g_assert (is_var
|| type
== MONO_TYPE_MVAR
);
3109 if (gc
->is_method
|| gc
->parent
)
3111 * The current MonoGenericContainer is a generic method -> its `parent'
3112 * points to the containing class'es container.
3121 * mono_metadata_parse_generic_param:
3122 * @generic_container: Our MonoClass's or MonoMethod's MonoGenericContainer;
3123 * see mono_metadata_parse_type_full() for details.
3124 * Internal routine to parse a generic type parameter.
3125 * LOCKING: Acquires the loader lock
3127 static MonoGenericParam
*
3128 mono_metadata_parse_generic_param (MonoImage
*m
, MonoGenericContainer
*generic_container
,
3129 MonoTypeEnum type
, const char *ptr
, const char **rptr
)
3131 int index
= mono_metadata_decode_value (ptr
, &ptr
);
3135 generic_container
= select_container (generic_container
, type
);
3136 if (!generic_container
) {
3137 /* Create dummy MonoGenericParam */
3138 MonoGenericParam
*param
;
3140 param
= mono_image_alloc0 (m
, sizeof (MonoGenericParam
));
3147 if (index
>= generic_container
->type_argc
)
3150 return mono_generic_container_get_param (generic_container
, index
);
3154 * mono_metadata_get_shared_type:
3156 * Return a shared instance of TYPE, if available, NULL otherwise.
3157 * Shared MonoType instances help save memory. Their contents should not be modified
3158 * by the caller. They do not need to be freed as their lifetime is bound by either
3159 * the lifetime of the runtime (builtin types), or the lifetime of the MonoClass
3160 * instance they are embedded in. If they are freed, they should be freed using
3161 * mono_metadata_free_type () instead of g_free ().
3164 mono_metadata_get_shared_type (MonoType
*type
)
3168 /* No need to use locking since nobody is modifying the hash table */
3169 if ((cached
= g_hash_table_lookup (type_cache
, type
)))
3172 switch (type
->type
){
3173 case MONO_TYPE_CLASS
:
3174 case MONO_TYPE_VALUETYPE
:
3175 if (type
== &type
->data
.klass
->byval_arg
)
3177 if (type
== &type
->data
.klass
->this_arg
)
3188 compare_type_literals (int class_type
, int type_type
)
3190 /* byval_arg.type can be zero if we're decoding a type that references a class been loading.
3191 * See mcs/test/gtest-440. and #650936.
3192 * FIXME This better be moved to the metadata verifier as it can catch more cases.
3196 /* NET 1.1 assemblies might encode string and object in a denormalized way.
3199 if (class_type
== type_type
)
3202 if (type_type
== MONO_TYPE_CLASS
)
3203 return class_type
== MONO_TYPE_STRING
|| class_type
== MONO_TYPE_OBJECT
;
3205 g_assert (type_type
== MONO_TYPE_VALUETYPE
);
3206 switch (class_type
) {
3207 case MONO_TYPE_BOOLEAN
:
3208 case MONO_TYPE_CHAR
:
3221 case MONO_TYPE_CLASS
:
3229 * do_mono_metadata_parse_type:
3230 * @type: MonoType to be filled in with the return value
3232 * @generic_context: generics_context
3233 * @transient: whenever to allocate data from the heap
3234 * @ptr: pointer to the encoded type
3235 * @rptr: pointer where the end of the encoded type is saved
3237 * Internal routine used to "fill" the contents of @type from an
3238 * allocated pointer. This is done this way to avoid doing too
3239 * many mini-allocations (particularly for the MonoFieldType which
3240 * most of the time is just a MonoType, but sometimes might be augmented).
3242 * This routine is used by mono_metadata_parse_type and
3243 * mono_metadata_parse_field_type
3245 * This extracts a Type as specified in Partition II (22.2.12)
3247 * Returns: FALSE if the type could not be loaded
3250 do_mono_metadata_parse_type (MonoType
*type
, MonoImage
*m
, MonoGenericContainer
*container
,
3251 gboolean transient
, const char *ptr
, const char **rptr
)
3254 type
->type
= mono_metadata_decode_value (ptr
, &ptr
);
3256 switch (type
->type
){
3257 case MONO_TYPE_VOID
:
3258 case MONO_TYPE_BOOLEAN
:
3259 case MONO_TYPE_CHAR
:
3272 case MONO_TYPE_STRING
:
3273 case MONO_TYPE_OBJECT
:
3274 case MONO_TYPE_TYPEDBYREF
:
3276 case MONO_TYPE_VALUETYPE
:
3277 case MONO_TYPE_CLASS
: {
3281 token
= mono_metadata_parse_typedef_or_ref (m
, ptr
, &ptr
);
3282 class = mono_class_get_checked (m
, token
, &error
);
3283 type
->data
.klass
= class;
3285 mono_loader_set_error_from_mono_error (&error
);
3286 mono_error_cleanup (&error
); /*FIXME don't swallow the error message*/
3289 if (!compare_type_literals (class->byval_arg
.type
, type
->type
))
3293 case MONO_TYPE_SZARRAY
: {
3294 MonoType
*etype
= mono_metadata_parse_type_full (m
, container
, MONO_PARSE_MOD_TYPE
, 0, ptr
, &ptr
);
3297 type
->data
.klass
= mono_class_from_mono_type (etype
);
3298 if (!type
->data
.klass
)
3303 type
->data
.type
= mono_metadata_parse_type_internal (m
, container
, MONO_PARSE_MOD_TYPE
, 0, transient
, ptr
, &ptr
);
3304 if (!type
->data
.type
)
3307 case MONO_TYPE_FNPTR
: {
3309 type
->data
.method
= mono_metadata_parse_method_signature_full (m
, container
, 0, ptr
, &ptr
, &error
);
3310 if (!type
->data
.method
) {
3311 mono_loader_set_error_from_mono_error (&error
);
3312 mono_error_cleanup (&error
); /*FIXME don't swallow the error message*/
3317 case MONO_TYPE_ARRAY
:
3318 type
->data
.array
= mono_metadata_parse_array_internal (m
, container
, transient
, ptr
, &ptr
);
3319 if (!type
->data
.array
)
3322 case MONO_TYPE_MVAR
:
3323 if (container
&& !container
->is_method
)
3326 type
->data
.generic_param
= mono_metadata_parse_generic_param (m
, container
, type
->type
, ptr
, &ptr
);
3327 if (!type
->data
.generic_param
)
3330 case MONO_TYPE_GENERICINST
:
3331 ok
= do_mono_metadata_parse_generic_class (type
, m
, container
, ptr
, &ptr
);
3334 g_warning ("type 0x%02x not handled in do_mono_metadata_parse_type on image %s", type
->type
, m
->name
);
3344 * mono_metadata_free_type:
3345 * @type: type to free
3347 * Free the memory allocated for type @type which is allocated on the heap.
3350 mono_metadata_free_type (MonoType
*type
)
3352 if (type
>= builtin_types
&& type
< builtin_types
+ NBUILTIN_TYPES ())
3355 switch (type
->type
){
3356 case MONO_TYPE_OBJECT
:
3357 case MONO_TYPE_STRING
:
3358 if (!type
->data
.klass
)
3361 case MONO_TYPE_CLASS
:
3362 case MONO_TYPE_VALUETYPE
:
3363 if (type
== &type
->data
.klass
->byval_arg
|| type
== &type
->data
.klass
->this_arg
)
3367 mono_metadata_free_type (type
->data
.type
);
3369 case MONO_TYPE_FNPTR
:
3370 mono_metadata_free_method_signature (type
->data
.method
);
3372 case MONO_TYPE_ARRAY
:
3373 mono_metadata_free_array (type
->data
.array
);
3384 hex_dump (const char *buffer
, int base
, int count
)
3386 int show_header
= 1;
3394 for (i
= 0; i
< count
; i
++){
3397 printf ("\n0x%08x: ", (unsigned char) base
+ i
);
3399 printf ("%02x ", (unsigned char) (buffer
[i
]));
3406 * @ptr: Points to the beginning of the Section Data (25.3)
3408 static MonoExceptionClause
*
3409 parse_section_data (MonoImage
*m
, int *num_clauses
, const unsigned char *ptr
)
3411 unsigned char sect_data_flags
;
3413 guint32 sect_data_len
;
3414 MonoExceptionClause
* clauses
= NULL
;
3417 /* align on 32-bit boundary */
3418 ptr
= dword_align (ptr
);
3419 sect_data_flags
= *ptr
;
3422 is_fat
= sect_data_flags
& METHOD_HEADER_SECTION_FAT_FORMAT
;
3424 sect_data_len
= (ptr
[2] << 16) | (ptr
[1] << 8) | ptr
[0];
3427 sect_data_len
= ptr
[0];
3431 if (sect_data_flags
& METHOD_HEADER_SECTION_EHTABLE
) {
3432 const unsigned char *p
= dword_align (ptr
);
3434 *num_clauses
= is_fat
? sect_data_len
/ 24: sect_data_len
/ 12;
3435 /* we could just store a pointer if we don't need to byteswap */
3436 clauses
= g_malloc0 (sizeof (MonoExceptionClause
) * (*num_clauses
));
3437 for (i
= 0; i
< *num_clauses
; ++i
) {
3438 MonoExceptionClause
*ec
= &clauses
[i
];
3441 ec
->flags
= read32 (p
);
3442 ec
->try_offset
= read32 (p
+ 4);
3443 ec
->try_len
= read32 (p
+ 8);
3444 ec
->handler_offset
= read32 (p
+ 12);
3445 ec
->handler_len
= read32 (p
+ 16);
3446 tof_value
= read32 (p
+ 20);
3449 ec
->flags
= read16 (p
);
3450 ec
->try_offset
= read16 (p
+ 2);
3451 ec
->try_len
= *(p
+ 4);
3452 ec
->handler_offset
= read16 (p
+ 5);
3453 ec
->handler_len
= *(p
+ 7);
3454 tof_value
= read32 (p
+ 8);
3457 if (ec
->flags
== MONO_EXCEPTION_CLAUSE_FILTER
) {
3458 ec
->data
.filter_offset
= tof_value
;
3459 } else if (ec
->flags
== MONO_EXCEPTION_CLAUSE_NONE
) {
3460 ec
->data
.catch_class
= NULL
;
3463 ec
->data
.catch_class
= mono_class_get_checked (m
, tof_value
, &error
);
3464 if (!mono_error_ok (&error
)) {
3465 mono_error_cleanup (&error
); /* FIXME don't swallow the error */
3471 ec
->data
.catch_class
= NULL
;
3473 /* g_print ("try %d: %x %04x-%04x %04x\n", i, ec->flags, ec->try_offset, ec->try_offset+ec->try_len, ec->try_len); */
3477 if (sect_data_flags
& METHOD_HEADER_SECTION_MORE_SECTS
)
3478 ptr
+= sect_data_len
- 4; /* LAMESPEC: it seems the size includes the header */
3485 * mono_method_get_header_summary:
3486 * @method: The method to get the header.
3487 * @summary: Where to store the header
3490 * Returns: true if the header was properly decoded.
3493 mono_method_get_header_summary (MonoMethod
*method
, MonoMethodHeaderSummary
*summary
)
3499 unsigned char flags
, format
;
3502 /*Only the GMD has a pointer to the metadata.*/
3503 while (method
->is_inflated
)
3504 method
= ((MonoMethodInflated
*)method
)->declaring
;
3506 summary
->code_size
= 0;
3507 summary
->has_clauses
= FALSE
;
3509 /*FIXME extract this into a MACRO and share it with mono_method_get_header*/
3510 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
))
3513 if (method
->wrapper_type
!= MONO_WRAPPER_NONE
|| method
->sre_method
) {
3514 MonoMethodHeader
*header
= ((MonoMethodWrapper
*)method
)->header
;
3517 summary
->code_size
= header
->code_size
;
3518 summary
->has_clauses
= header
->num_clauses
> 0;
3523 idx
= mono_metadata_token_index (method
->token
);
3524 img
= method
->klass
->image
;
3525 rva
= mono_metadata_decode_row_col (&img
->tables
[MONO_TABLE_METHOD
], idx
- 1, MONO_METHOD_RVA
);
3527 /*We must run the verifier since we'll be decoding it.*/
3528 if (!mono_verifier_verify_method_header (img
, rva
, NULL
))
3531 ptr
= mono_image_rva_map (img
, rva
);
3534 flags
= *(const unsigned char *)ptr
;
3535 format
= flags
& METHOD_HEADER_FORMAT_MASK
;
3538 case METHOD_HEADER_TINY_FORMAT
:
3540 summary
->code_size
= flags
>> 2;
3542 case METHOD_HEADER_FAT_FORMAT
:
3543 fat_flags
= read16 (ptr
);
3545 summary
->code_size
= read32 (ptr
);
3546 if (fat_flags
& METHOD_HEADER_MORE_SECTS
)
3547 summary
->has_clauses
= TRUE
;
3556 * mono_metadata_parse_mh_full:
3557 * @m: metadata context
3558 * @generic_context: generics context
3559 * @ptr: pointer to the method header.
3561 * Decode the method header at @ptr, including pointer to the IL code,
3562 * info about local variables and optional exception tables.
3563 * This is a Mono runtime internal function.
3565 * LOCKING: Acquires the loader lock.
3567 * Returns: a transient MonoMethodHeader allocated from the heap.
3570 mono_metadata_parse_mh_full (MonoImage
*m
, MonoGenericContainer
*container
, const char *ptr
)
3572 MonoMethodHeader
*mh
= NULL
;
3573 unsigned char flags
= *(const unsigned char *) ptr
;
3574 unsigned char format
= flags
& METHOD_HEADER_FORMAT_MASK
;
3576 guint32 local_var_sig_tok
, max_stack
, code_size
, init_locals
;
3577 const unsigned char *code
;
3578 MonoExceptionClause
* clauses
= NULL
;
3579 int num_clauses
= 0;
3580 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_STANDALONESIG
];
3581 guint32 cols
[MONO_STAND_ALONE_SIGNATURE_SIZE
];
3583 g_return_val_if_fail (ptr
!= NULL
, NULL
);
3586 case METHOD_HEADER_TINY_FORMAT
:
3587 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
);
3590 mh
->is_transient
= TRUE
;
3591 local_var_sig_tok
= 0;
3592 mh
->code_size
= flags
>> 2;
3593 mh
->code
= (unsigned char*)ptr
;
3595 case METHOD_HEADER_FAT_FORMAT
:
3596 fat_flags
= read16 (ptr
);
3598 max_stack
= read16 (ptr
);
3600 code_size
= read32 (ptr
);
3602 local_var_sig_tok
= read32 (ptr
);
3605 if (fat_flags
& METHOD_HEADER_INIT_LOCALS
)
3610 code
= (unsigned char*)ptr
;
3612 if (!(fat_flags
& METHOD_HEADER_MORE_SECTS
))
3616 * There are more sections
3618 ptr
= (char*)code
+ code_size
;
3624 if (local_var_sig_tok
) {
3625 int idx
= (local_var_sig_tok
& 0xffffff)-1;
3626 if (idx
>= t
->rows
|| idx
< 0)
3628 mono_metadata_decode_row (t
, idx
, cols
, 1);
3630 if (!mono_verifier_verify_standalone_signature (m
, cols
[MONO_STAND_ALONE_SIGNATURE
], NULL
))
3633 if (fat_flags
& METHOD_HEADER_MORE_SECTS
)
3634 clauses
= parse_section_data (m
, &num_clauses
, (const unsigned char*)ptr
);
3635 if (local_var_sig_tok
) {
3636 const char *locals_ptr
;
3639 locals_ptr
= mono_metadata_blob_heap (m
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
3640 mono_metadata_decode_blob_size (locals_ptr
, &locals_ptr
);
3641 if (*locals_ptr
!= 0x07)
3642 g_warning ("wrong signature for locals blob");
3644 len
= mono_metadata_decode_value (locals_ptr
, &locals_ptr
);
3645 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
+ len
* sizeof (MonoType
*) + num_clauses
* sizeof (MonoExceptionClause
));
3646 mh
->num_locals
= len
;
3647 for (i
= 0; i
< len
; ++i
) {
3648 mh
->locals
[i
] = mono_metadata_parse_type_internal (m
, container
,
3649 MONO_PARSE_LOCAL
, 0, TRUE
, locals_ptr
, &locals_ptr
);
3650 if (!mh
->locals
[i
])
3654 mh
= g_malloc0 (MONO_SIZEOF_METHOD_HEADER
+ num_clauses
* sizeof (MonoExceptionClause
));
3657 mh
->code_size
= code_size
;
3658 mh
->max_stack
= max_stack
;
3659 mh
->is_transient
= TRUE
;
3660 mh
->init_locals
= init_locals
;
3662 MonoExceptionClause
* clausesp
= (MonoExceptionClause
*)&mh
->locals
[mh
->num_locals
];
3663 memcpy (clausesp
, clauses
, num_clauses
* sizeof (MonoExceptionClause
));
3665 mh
->clauses
= clausesp
;
3666 mh
->num_clauses
= num_clauses
;
3677 * mono_metadata_parse_mh:
3678 * @generic_context: generics context
3679 * @ptr: pointer to the method header.
3681 * Decode the method header at @ptr, including pointer to the IL code,
3682 * info about local variables and optional exception tables.
3684 * Returns: a transient MonoMethodHeader allocated from the heap.
3687 mono_metadata_parse_mh (MonoImage
*m
, const char *ptr
)
3689 return mono_metadata_parse_mh_full (m
, NULL
, ptr
);
3693 * mono_metadata_free_mh:
3694 * @mh: a method header
3696 * Free the memory allocated for the method header.
3699 mono_metadata_free_mh (MonoMethodHeader
*mh
)
3703 /* If it is not transient it means it's part of a wrapper method,
3704 * or a SRE-generated method, so the lifetime in that case is
3705 * dictated by the method's own lifetime
3707 if (mh
->is_transient
) {
3708 for (i
= 0; i
< mh
->num_locals
; ++i
)
3709 mono_metadata_free_type (mh
->locals
[i
]);
3715 * mono_method_header_get_code:
3716 * @header: a MonoMethodHeader pointer
3717 * @code_size: memory location for returning the code size
3718 * @max_stack: memory location for returning the max stack
3720 * Method header accessor to retreive info about the IL code properties:
3721 * a pointer to the IL code itself, the size of the code and the max number
3722 * of stack slots used by the code.
3724 * Returns: pointer to the IL code represented by the method header.
3726 const unsigned char*
3727 mono_method_header_get_code (MonoMethodHeader
*header
, guint32
* code_size
, guint32
* max_stack
)
3730 *code_size
= header
->code_size
;
3732 *max_stack
= header
->max_stack
;
3733 return header
->code
;
3737 * mono_method_header_get_locals:
3738 * @header: a MonoMethodHeader pointer
3739 * @num_locals: memory location for returning the number of local variables
3740 * @init_locals: memory location for returning the init_locals flag
3742 * Method header accessor to retreive info about the local variables:
3743 * an array of local types, the number of locals and whether the locals
3744 * are supposed to be initialized to 0 on method entry
3746 * Returns: pointer to an array of types of the local variables
3749 mono_method_header_get_locals (MonoMethodHeader
*header
, guint32
* num_locals
, gboolean
*init_locals
)
3752 *num_locals
= header
->num_locals
;
3754 *init_locals
= header
->init_locals
;
3755 return header
->locals
;
3759 * mono_method_header_get_num_clauses:
3760 * @header: a MonoMethodHeader pointer
3762 * Method header accessor to retreive the number of exception clauses.
3764 * Returns: the number of exception clauses present
3767 mono_method_header_get_num_clauses (MonoMethodHeader
*header
)
3769 return header
->num_clauses
;
3773 * mono_method_header_get_clauses:
3774 * @header: a MonoMethodHeader pointer
3775 * @method: MonoMethod the header belongs to
3776 * @iter: pointer to a iterator
3777 * @clause: pointer to a MonoExceptionClause structure which will be filled with the info
3779 * Get the info about the exception clauses in the method. Set *iter to NULL to
3780 * initiate the iteration, then call the method repeatedly until it returns FALSE.
3781 * At each iteration, the structure pointed to by clause if filled with the
3782 * exception clause information.
3784 * Returns: TRUE if clause was filled with info, FALSE if there are no more exception
3788 mono_method_header_get_clauses (MonoMethodHeader
*header
, MonoMethod
*method
, gpointer
*iter
, MonoExceptionClause
*clause
)
3790 MonoExceptionClause
*sc
;
3791 /* later we'll be able to use this interface to parse the clause info on demand,
3792 * without allocating anything.
3794 if (!iter
|| !header
->num_clauses
)
3797 *iter
= sc
= header
->clauses
;
3803 if (sc
< header
->clauses
+ header
->num_clauses
) {
3812 * mono_metadata_parse_field_type:
3813 * @m: metadata context to extract information from
3814 * @ptr: pointer to the field signature
3815 * @rptr: pointer updated to match the end of the decoded stream
3817 * Parses the field signature, and returns the type information for it.
3819 * Returns: The MonoType that was extracted from @ptr.
3822 mono_metadata_parse_field_type (MonoImage
*m
, short field_flags
, const char *ptr
, const char **rptr
)
3824 return mono_metadata_parse_type (m
, MONO_PARSE_FIELD
, field_flags
, ptr
, rptr
);
3828 * mono_metadata_parse_param:
3829 * @m: metadata context to extract information from
3830 * @ptr: pointer to the param signature
3831 * @rptr: pointer updated to match the end of the decoded stream
3833 * Parses the param signature, and returns the type information for it.
3835 * Returns: The MonoType that was extracted from @ptr.
3838 mono_metadata_parse_param (MonoImage
*m
, const char *ptr
, const char **rptr
)
3840 return mono_metadata_parse_type (m
, MONO_PARSE_PARAM
, 0, ptr
, rptr
);
3844 * mono_metadata_token_from_dor:
3845 * @dor_token: A TypeDefOrRef coded index
3847 * dor_token is a TypeDefOrRef coded index: it contains either
3848 * a TypeDef, TypeRef or TypeSpec in the lower bits, and the upper
3849 * bits contain an index into the table.
3851 * Returns: an expanded token
3854 mono_metadata_token_from_dor (guint32 dor_index
)
3858 table
= dor_index
& 0x03;
3859 idx
= dor_index
>> 2;
3862 case 0: /* TypeDef */
3863 return MONO_TOKEN_TYPE_DEF
| idx
;
3864 case 1: /* TypeRef */
3865 return MONO_TOKEN_TYPE_REF
| idx
;
3866 case 2: /* TypeSpec */
3867 return MONO_TOKEN_TYPE_SPEC
| idx
;
3869 g_assert_not_reached ();
3876 * We use this to pass context information to the row locator
3879 int idx
; /* The index that we are trying to locate */
3880 int col_idx
; /* The index in the row where idx may be stored */
3881 MonoTableInfo
*t
; /* pointer to the table */
3886 * How the row locator works.
3891 * ___|___------> _______
3894 * A column in the rows of table A references an index in table B.
3895 * For example A may be the TYPEDEF table and B the METHODDEF table.
3897 * Given an index in table B we want to get the row in table A
3898 * where the column n references our index in B.
3900 * In the locator_t structure:
3902 * col_idx is the column number
3903 * index is the index in table B
3904 * result will be the index in table A
3907 * Table A Table B column (in table A)
3908 * TYPEDEF METHODDEF MONO_TYPEDEF_METHOD_LIST
3909 * TYPEDEF FIELD MONO_TYPEDEF_FIELD_LIST
3910 * PROPERTYMAP PROPERTY MONO_PROPERTY_MAP_PROPERTY_LIST
3911 * INTERFIMPL TYPEDEF MONO_INTERFACEIMPL_CLASS
3912 * METHODSEM PROPERTY ASSOCIATION (encoded index)
3914 * Note that we still don't support encoded indexes.
3918 typedef_locator (const void *a
, const void *b
)
3920 locator_t
*loc
= (locator_t
*) a
;
3921 const char *bb
= (const char *) b
;
3922 int typedef_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3923 guint32 col
, col_next
;
3925 col
= mono_metadata_decode_row_col (loc
->t
, typedef_index
, loc
->col_idx
);
3931 * Need to check that the next row is valid.
3933 if (typedef_index
+ 1 < loc
->t
->rows
) {
3934 col_next
= mono_metadata_decode_row_col (loc
->t
, typedef_index
+ 1, loc
->col_idx
);
3935 if (loc
->idx
>= col_next
)
3938 if (col
== col_next
)
3942 loc
->result
= typedef_index
;
3948 table_locator (const void *a
, const void *b
)
3950 locator_t
*loc
= (locator_t
*) a
;
3951 const char *bb
= (const char *) b
;
3952 guint32 table_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3955 col
= mono_metadata_decode_row_col (loc
->t
, table_index
, loc
->col_idx
);
3957 if (loc
->idx
== col
) {
3958 loc
->result
= table_index
;
3968 declsec_locator (const void *a
, const void *b
)
3970 locator_t
*loc
= (locator_t
*) a
;
3971 const char *bb
= (const char *) b
;
3972 guint32 table_index
= (bb
- loc
->t
->base
) / loc
->t
->row_size
;
3975 col
= mono_metadata_decode_row_col (loc
->t
, table_index
, loc
->col_idx
);
3977 if (loc
->idx
== col
) {
3978 loc
->result
= table_index
;
3990 * Return the 1-based row index in TABLE, which must be one of the *Ptr tables,
3991 * which contains IDX.
3994 search_ptr_table (MonoImage
*image
, int table
, int idx
)
3996 MonoTableInfo
*ptrdef
= &image
->tables
[table
];
3999 /* Use a linear search to find our index in the table */
4000 for (i
= 0; i
< ptrdef
->rows
; i
++)
4001 /* All the Ptr tables have the same structure */
4002 if (mono_metadata_decode_row_col (ptrdef
, i
, 0) == idx
)
4005 if (i
< ptrdef
->rows
)
4012 * mono_metadata_typedef_from_field:
4013 * @meta: metadata context
4014 * @index: FieldDef token
4016 * Returns: the 1-based index into the TypeDef table of the type that
4017 * declared the field described by @index, or 0 if not found.
4020 mono_metadata_typedef_from_field (MonoImage
*meta
, guint32 index
)
4022 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_TYPEDEF
];
4028 loc
.idx
= mono_metadata_token_index (index
);
4029 loc
.col_idx
= MONO_TYPEDEF_FIELD_LIST
;
4032 if (meta
->uncompressed_metadata
)
4033 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_FIELD_POINTER
, loc
.idx
);
4035 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, typedef_locator
))
4038 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4039 return loc
.result
+ 1;
4043 * mono_metadata_typedef_from_method:
4044 * @meta: metadata context
4045 * @index: MethodDef token
4047 * Returns: the 1-based index into the TypeDef table of the type that
4048 * declared the method described by @index. 0 if not found.
4051 mono_metadata_typedef_from_method (MonoImage
*meta
, guint32 index
)
4053 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_TYPEDEF
];
4059 loc
.idx
= mono_metadata_token_index (index
);
4060 loc
.col_idx
= MONO_TYPEDEF_METHOD_LIST
;
4063 if (meta
->uncompressed_metadata
)
4064 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_METHOD_POINTER
, loc
.idx
);
4066 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, typedef_locator
))
4069 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4070 return loc
.result
+ 1;
4074 * mono_metadata_interfaces_from_typedef_full:
4075 * @meta: metadata context
4076 * @index: typedef token
4077 * @interfaces: Out parameter used to store the interface array
4078 * @count: Out parameter used to store the number of interfaces
4079 * @heap_alloc_result: if TRUE the result array will be g_malloc'd
4080 * @context: The generic context
4082 * The array of interfaces that the @index typedef token implements is returned in
4083 * @interfaces. The number of elements in the array is returned in @count.
4086 * Returns: TRUE on success, FALSE on failure.
4089 mono_metadata_interfaces_from_typedef_full (MonoImage
*meta
, guint32 index
, MonoClass
***interfaces
, guint
*count
, gboolean heap_alloc_result
, MonoGenericContext
*context
, MonoError
*error
)
4091 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_INTERFACEIMPL
];
4094 guint32 cols
[MONO_INTERFACEIMPL_SIZE
];
4100 mono_error_init (error
);
4105 loc
.idx
= mono_metadata_token_index (index
);
4106 loc
.col_idx
= MONO_INTERFACEIMPL_CLASS
;
4109 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4114 * We may end up in the middle of the rows...
4117 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_INTERFACEIMPL_CLASS
))
4123 while (pos
< tdef
->rows
) {
4124 mono_metadata_decode_row (tdef
, pos
, cols
, MONO_INTERFACEIMPL_SIZE
);
4125 if (cols
[MONO_INTERFACEIMPL_CLASS
] != loc
.idx
)
4130 if (heap_alloc_result
)
4131 result
= g_new0 (MonoClass
*, pos
- start
);
4133 result
= mono_image_alloc0 (meta
, sizeof (MonoClass
*) * (pos
- start
));
4136 while (pos
< tdef
->rows
) {
4139 mono_metadata_decode_row (tdef
, pos
, cols
, MONO_INTERFACEIMPL_SIZE
);
4140 if (cols
[MONO_INTERFACEIMPL_CLASS
] != loc
.idx
)
4142 iface
= mono_class_get_and_inflate_typespec_checked (
4143 meta
, mono_metadata_token_from_dor (cols
[MONO_INTERFACEIMPL_INTERFACE
]), context
, error
);
4146 result
[pos
- start
] = iface
;
4149 *count
= pos
- start
;
4150 *interfaces
= result
;
4155 * @meta: metadata context
4156 * @index: typedef token
4157 * @count: Out parameter used to store the number of interfaces
4159 * The array of interfaces that the @index typedef token implements is returned in
4160 * @interfaces. The number of elements in the array is returned in @count. The returned
4161 * array is g_malloc'd and the caller must free it.
4163 * LOCKING: Acquires the loader lock .
4165 * Returns: the interface array on success, NULL on failure.
4169 mono_metadata_interfaces_from_typedef (MonoImage
*meta
, guint32 index
, guint
*count
)
4172 MonoClass
**interfaces
= NULL
;
4175 rv
= mono_metadata_interfaces_from_typedef_full (meta
, index
, &interfaces
, count
, TRUE
, NULL
, &error
);
4176 g_assert (mono_error_ok (&error
)); /* FIXME dont swallow the error */
4184 * mono_metadata_nested_in_typedef:
4185 * @meta: metadata context
4186 * @index: typedef token
4188 * Returns: the 1-based index into the TypeDef table of the type
4189 * where the type described by @index is nested.
4190 * Returns 0 if @index describes a non-nested type.
4193 mono_metadata_nested_in_typedef (MonoImage
*meta
, guint32 index
)
4195 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_NESTEDCLASS
];
4201 loc
.idx
= mono_metadata_token_index (index
);
4202 loc
.col_idx
= MONO_NESTED_CLASS_NESTED
;
4205 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4208 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4209 return mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_NESTED_CLASS_ENCLOSING
) | MONO_TOKEN_TYPE_DEF
;
4213 * mono_metadata_nesting_typedef:
4214 * @meta: metadata context
4215 * @index: typedef token
4217 * Returns: the 1-based index into the TypeDef table of the first type
4218 * that is nested inside the type described by @index. The search starts at
4219 * @start_index. returns 0 if no such type is found.
4222 mono_metadata_nesting_typedef (MonoImage
*meta
, guint32 index
, guint32 start_index
)
4224 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_NESTEDCLASS
];
4226 guint32 class_index
= mono_metadata_token_index (index
);
4231 start
= start_index
;
4233 while (start
<= tdef
->rows
) {
4234 if (class_index
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_NESTED_CLASS_ENCLOSING
))
4240 if (start
> tdef
->rows
)
4247 * mono_metadata_packing_from_typedef:
4248 * @meta: metadata context
4249 * @index: token representing a type
4251 * Returns: the info stored in the ClassLAyout table for the given typedef token
4252 * into the @packing and @size pointers.
4253 * Returns 0 if the info is not found.
4256 mono_metadata_packing_from_typedef (MonoImage
*meta
, guint32 index
, guint32
*packing
, guint32
*size
)
4258 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_CLASSLAYOUT
];
4260 guint32 cols
[MONO_CLASS_LAYOUT_SIZE
];
4265 loc
.idx
= mono_metadata_token_index (index
);
4266 loc
.col_idx
= MONO_CLASS_LAYOUT_PARENT
;
4269 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4272 mono_metadata_decode_row (tdef
, loc
.result
, cols
, MONO_CLASS_LAYOUT_SIZE
);
4274 *packing
= cols
[MONO_CLASS_LAYOUT_PACKING_SIZE
];
4276 *size
= cols
[MONO_CLASS_LAYOUT_CLASS_SIZE
];
4278 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4279 return loc
.result
+ 1;
4283 * mono_metadata_custom_attrs_from_index:
4284 * @meta: metadata context
4285 * @index: token representing the parent
4287 * Returns: the 1-based index into the CustomAttribute table of the first
4288 * attribute which belongs to the metadata object described by @index.
4289 * Returns 0 if no such attribute is found.
4292 mono_metadata_custom_attrs_from_index (MonoImage
*meta
, guint32 index
)
4294 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_CUSTOMATTRIBUTE
];
4301 loc
.col_idx
= MONO_CUSTOM_ATTR_PARENT
;
4304 /* FIXME: Index translation */
4306 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4309 /* Find the first entry by searching backwards */
4310 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_CUSTOM_ATTR_PARENT
) == index
))
4313 /* loc_result is 0..1, needs to be mapped to table index (that is +1) */
4314 return loc
.result
+ 1;
4318 * mono_metadata_declsec_from_index:
4319 * @meta: metadata context
4320 * @index: token representing the parent
4322 * Returns: the 0-based index into the DeclarativeSecurity table of the first
4323 * attribute which belongs to the metadata object described by @index.
4324 * Returns -1 if no such attribute is found.
4327 mono_metadata_declsec_from_index (MonoImage
*meta
, guint32 index
)
4329 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_DECLSECURITY
];
4336 loc
.col_idx
= MONO_DECL_SECURITY_PARENT
;
4339 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, declsec_locator
))
4342 /* Find the first entry by searching backwards */
4343 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_DECL_SECURITY_PARENT
) == index
))
4350 * mono_metadata_localscope_from_methoddef:
4351 * @meta: metadata context
4352 * @index: methoddef index
4354 * Returns: the 1-based index into the LocalScope table of the first
4355 * scope which belongs to the method described by @index.
4356 * Returns 0 if no such row is found.
4359 mono_metadata_localscope_from_methoddef (MonoImage
*meta
, guint32 index
)
4361 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_LOCALSCOPE
];
4368 loc
.col_idx
= MONO_LOCALSCOPE_METHOD
;
4371 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
4374 /* Find the first entry by searching backwards */
4375 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_LOCALSCOPE_METHOD
) == index
))
4378 return loc
.result
+ 1;
4383 mono_backtrace (int limit
)
4388 backtrace (array
, limit
);
4389 names
= backtrace_symbols (array
, limit
);
4390 for (i
=0; i
< limit
; ++i
) {
4391 g_print ("\t%s\n", names
[i
]);
4397 static int i8_align
;
4400 * mono_type_set_alignment:
4402 * Set the alignment used by runtime to layout fields etc. of type TYPE to ALIGN.
4403 * This should only be used in AOT mode since the resulting layout will not match the
4407 mono_type_set_alignment (MonoTypeEnum type
, int align
)
4409 /* Support only a few types whose alignment is abi dependent */
4415 g_assert_not_reached ();
4422 * @t: the type to return the size of
4424 * Returns: the number of bytes required to hold an instance of this
4428 mono_type_size (MonoType
*t
, int *align
)
4430 MonoTypeEnum simple_type
;
4437 *align
= MONO_ABI_ALIGNOF (gpointer
);
4438 return sizeof (gpointer
);
4441 simple_type
= t
->type
;
4443 switch (simple_type
) {
4444 case MONO_TYPE_VOID
:
4447 case MONO_TYPE_BOOLEAN
:
4448 *align
= MONO_ABI_ALIGNOF (gint8
);
4452 *align
= MONO_ABI_ALIGNOF (gint8
);
4454 case MONO_TYPE_CHAR
:
4457 *align
= MONO_ABI_ALIGNOF (gint16
);
4461 *align
= MONO_ABI_ALIGNOF (gint32
);
4464 *align
= MONO_ABI_ALIGNOF (float);
4468 *align
= MONO_ABI_ALIGNOF (gint64
);
4471 *align
= MONO_ABI_ALIGNOF (double);
4475 *align
= MONO_ABI_ALIGNOF (gpointer
);
4476 return sizeof (gpointer
);
4477 case MONO_TYPE_STRING
:
4478 *align
= MONO_ABI_ALIGNOF (gpointer
);
4479 return sizeof (gpointer
);
4480 case MONO_TYPE_OBJECT
:
4481 *align
= MONO_ABI_ALIGNOF (gpointer
);
4482 return sizeof (gpointer
);
4483 case MONO_TYPE_VALUETYPE
: {
4484 if (t
->data
.klass
->enumtype
)
4485 return mono_type_size (mono_class_enum_basetype (t
->data
.klass
), align
);
4487 return mono_class_value_size (t
->data
.klass
, (guint32
*)align
);
4489 case MONO_TYPE_CLASS
:
4490 case MONO_TYPE_SZARRAY
:
4492 case MONO_TYPE_FNPTR
:
4493 case MONO_TYPE_ARRAY
:
4494 *align
= MONO_ABI_ALIGNOF (gpointer
);
4495 return sizeof (gpointer
);
4496 case MONO_TYPE_TYPEDBYREF
:
4497 return mono_class_value_size (mono_defaults
.typed_reference_class
, (guint32
*)align
);
4498 case MONO_TYPE_GENERICINST
: {
4499 MonoGenericClass
*gclass
= t
->data
.generic_class
;
4500 MonoClass
*container_class
= gclass
->container_class
;
4502 // g_assert (!gclass->inst->is_open);
4504 if (container_class
->valuetype
) {
4505 if (container_class
->enumtype
)
4506 return mono_type_size (mono_class_enum_basetype (container_class
), align
);
4508 return mono_class_value_size (mono_class_from_mono_type (t
), (guint32
*)align
);
4510 *align
= MONO_ABI_ALIGNOF (gpointer
);
4511 return sizeof (gpointer
);
4515 case MONO_TYPE_MVAR
:
4516 if (!t
->data
.generic_param
->gshared_constraint
|| t
->data
.generic_param
->gshared_constraint
->type
== MONO_TYPE_VALUETYPE
) {
4517 *align
= MONO_ABI_ALIGNOF (gpointer
);
4518 return sizeof (gpointer
);
4520 /* The gparam can only match types given by gshared_constraint */
4521 return mono_type_size (t
->data
.generic_param
->gshared_constraint
, align
);
4525 g_error ("mono_type_size: type 0x%02x unknown", t
->type
);
4531 * mono_type_stack_size:
4532 * @t: the type to return the size it uses on the stack
4534 * Returns: the number of bytes required to hold an instance of this
4535 * type on the runtime stack
4538 mono_type_stack_size (MonoType
*t
, int *align
)
4540 return mono_type_stack_size_internal (t
, align
, FALSE
);
4544 mono_type_stack_size_internal (MonoType
*t
, int *align
, gboolean allow_open
)
4547 MonoTypeEnum simple_type
;
4548 #if SIZEOF_VOID_P == SIZEOF_REGISTER
4549 int stack_slot_size
= sizeof (gpointer
);
4550 int stack_slot_align
= MONO_ABI_ALIGNOF (gpointer
);
4551 #elif SIZEOF_VOID_P < SIZEOF_REGISTER
4552 int stack_slot_size
= SIZEOF_REGISTER
;
4553 int stack_slot_align
= SIZEOF_REGISTER
;
4556 g_assert (t
!= NULL
);
4562 *align
= stack_slot_align
;
4563 return stack_slot_size
;
4566 simple_type
= t
->type
;
4567 switch (simple_type
) {
4568 case MONO_TYPE_BOOLEAN
:
4569 case MONO_TYPE_CHAR
:
4578 case MONO_TYPE_STRING
:
4579 case MONO_TYPE_OBJECT
:
4580 case MONO_TYPE_CLASS
:
4581 case MONO_TYPE_SZARRAY
:
4583 case MONO_TYPE_FNPTR
:
4584 case MONO_TYPE_ARRAY
:
4585 *align
= stack_slot_align
;
4586 return stack_slot_size
;
4588 case MONO_TYPE_MVAR
:
4589 g_assert (allow_open
);
4590 if (!t
->data
.generic_param
->gshared_constraint
|| t
->data
.generic_param
->gshared_constraint
->type
== MONO_TYPE_VALUETYPE
) {
4591 *align
= stack_slot_align
;
4592 return stack_slot_size
;
4594 /* The gparam can only match types given by gshared_constraint */
4595 return mono_type_stack_size_internal (t
->data
.generic_param
->gshared_constraint
, align
, allow_open
);
4597 case MONO_TYPE_TYPEDBYREF
:
4598 *align
= stack_slot_align
;
4599 return stack_slot_size
* 3;
4601 *align
= MONO_ABI_ALIGNOF (float);
4602 return sizeof (float);
4605 *align
= MONO_ABI_ALIGNOF (gint64
);
4606 return sizeof (gint64
);
4608 *align
= MONO_ABI_ALIGNOF (double);
4609 return sizeof (double);
4610 case MONO_TYPE_VALUETYPE
: {
4613 if (t
->data
.klass
->enumtype
)
4614 return mono_type_stack_size_internal (mono_class_enum_basetype (t
->data
.klass
), align
, allow_open
);
4616 size
= mono_class_value_size (t
->data
.klass
, (guint32
*)align
);
4618 *align
= *align
+ stack_slot_align
- 1;
4619 *align
&= ~(stack_slot_align
- 1);
4621 size
+= stack_slot_size
- 1;
4622 size
&= ~(stack_slot_size
- 1);
4627 case MONO_TYPE_GENERICINST
: {
4628 MonoGenericClass
*gclass
= t
->data
.generic_class
;
4629 MonoClass
*container_class
= gclass
->container_class
;
4632 g_assert (!gclass
->context
.class_inst
->is_open
);
4634 if (container_class
->valuetype
) {
4635 if (container_class
->enumtype
)
4636 return mono_type_stack_size_internal (mono_class_enum_basetype (container_class
), align
, allow_open
);
4638 guint32 size
= mono_class_value_size (mono_class_from_mono_type (t
), (guint32
*)align
);
4640 *align
= *align
+ stack_slot_align
- 1;
4641 *align
&= ~(stack_slot_align
- 1);
4643 size
+= stack_slot_size
- 1;
4644 size
&= ~(stack_slot_size
- 1);
4649 *align
= stack_slot_align
;
4650 return stack_slot_size
;
4654 g_error ("type 0x%02x unknown", t
->type
);
4660 mono_type_generic_inst_is_valuetype (MonoType
*type
)
4662 g_assert (type
->type
== MONO_TYPE_GENERICINST
);
4663 return type
->data
.generic_class
->container_class
->valuetype
;
4667 mono_metadata_generic_class_is_valuetype (MonoGenericClass
*gclass
)
4669 return gclass
->container_class
->valuetype
;
4673 _mono_metadata_generic_class_equal (const MonoGenericClass
*g1
, const MonoGenericClass
*g2
, gboolean signature_only
)
4675 MonoGenericInst
*i1
= g1
->context
.class_inst
;
4676 MonoGenericInst
*i2
= g2
->context
.class_inst
;
4678 if (g1
->is_dynamic
!= g2
->is_dynamic
)
4680 if (!mono_metadata_class_equal (g1
->container_class
, g2
->container_class
, signature_only
))
4682 if (!mono_generic_inst_equal_full (i1
, i2
, signature_only
))
4684 return g1
->is_tb_open
== g2
->is_tb_open
;
4688 _mono_metadata_generic_class_container_equal (const MonoGenericClass
*g1
, MonoClass
*c2
, gboolean signature_only
)
4690 MonoGenericInst
*i1
= g1
->context
.class_inst
;
4691 MonoGenericInst
*i2
= c2
->generic_container
->context
.class_inst
;
4693 if (!mono_metadata_class_equal (g1
->container_class
, c2
, signature_only
))
4695 if (!mono_generic_inst_equal_full (i1
, i2
, signature_only
))
4697 return !g1
->is_tb_open
;
4701 mono_metadata_generic_context_hash (const MonoGenericContext
*context
)
4703 /* FIXME: check if this seed is good enough */
4704 guint hash
= 0xc01dfee7;
4705 if (context
->class_inst
)
4706 hash
= ((hash
<< 5) - hash
) ^ mono_metadata_generic_inst_hash (context
->class_inst
);
4707 if (context
->method_inst
)
4708 hash
= ((hash
<< 5) - hash
) ^ mono_metadata_generic_inst_hash (context
->method_inst
);
4713 mono_metadata_generic_context_equal (const MonoGenericContext
*g1
, const MonoGenericContext
*g2
)
4715 return g1
->class_inst
== g2
->class_inst
&& g1
->method_inst
== g2
->method_inst
;
4719 * mono_metadata_str_hash:
4721 * This should be used instead of g_str_hash for computing hash codes visible
4722 * outside this module, since g_str_hash () is not guaranteed to be stable
4723 * (its not the same in eglib for example).
4726 mono_metadata_str_hash (gconstpointer v1
)
4728 /* Same as g_str_hash () in glib */
4729 char *p
= (char *) v1
;
4734 hash
= (hash
<< 5) - hash
+ *p
;
4741 * mono_metadata_type_hash:
4744 * Computes an hash value for @t1 to be used in GHashTable.
4745 * The returned hash is guaranteed to be the same across executions.
4748 mono_metadata_type_hash (MonoType
*t1
)
4750 guint hash
= t1
->type
;
4752 hash
|= t1
->byref
<< 6; /* do not collide with t1->type values */
4754 case MONO_TYPE_VALUETYPE
:
4755 case MONO_TYPE_CLASS
:
4756 case MONO_TYPE_SZARRAY
: {
4757 MonoClass
*class = t1
->data
.klass
;
4759 * Dynamic classes must not be hashed on their type since it can change
4760 * during runtime. For example, if we hash a reference type that is
4761 * later made into a valuetype.
4763 * This is specially problematic with generic instances since they are
4764 * inserted in a bunch of hash tables before been finished.
4766 if (image_is_dynamic (class->image
))
4767 return (t1
->byref
<< 6) | mono_metadata_str_hash (class->name
);
4768 return ((hash
<< 5) - hash
) ^ mono_metadata_str_hash (class->name
);
4771 return ((hash
<< 5) - hash
) ^ mono_metadata_type_hash (t1
->data
.type
);
4772 case MONO_TYPE_ARRAY
:
4773 return ((hash
<< 5) - hash
) ^ mono_metadata_type_hash (&t1
->data
.array
->eklass
->byval_arg
);
4774 case MONO_TYPE_GENERICINST
:
4775 return ((hash
<< 5) - hash
) ^ mono_generic_class_hash (t1
->data
.generic_class
);
4777 case MONO_TYPE_MVAR
:
4778 return ((hash
<< 5) - hash
) ^ mono_metadata_generic_param_hash (t1
->data
.generic_param
);
4785 mono_metadata_generic_param_hash (MonoGenericParam
*p
)
4788 MonoGenericParamInfo
*info
;
4790 hash
= (mono_generic_param_num (p
) << 2);
4791 if (p
->gshared_constraint
)
4792 hash
= ((hash
<< 5) - hash
) ^ mono_metadata_type_hash (p
->gshared_constraint
);
4793 info
= mono_generic_param_info (p
);
4794 /* Can't hash on the owner klass/method, since those might not be set when this is called */
4796 hash
= ((hash
<< 5) - hash
) ^ info
->token
;
4801 mono_metadata_generic_param_equal_internal (MonoGenericParam
*p1
, MonoGenericParam
*p2
, gboolean signature_only
)
4805 if (mono_generic_param_num (p1
) != mono_generic_param_num (p2
))
4807 if (p1
->gshared_constraint
&& p2
->gshared_constraint
) {
4808 if (!mono_metadata_type_equal (p1
->gshared_constraint
, p2
->gshared_constraint
))
4811 if (p1
->gshared_constraint
!= p2
->gshared_constraint
)
4816 * We have to compare the image as well because if we didn't,
4817 * the generic_inst_cache lookup wouldn't care about the image
4818 * of generic params, so what could happen is that a generic
4819 * inst with params from image A is put into the cache, then
4820 * image B gets that generic inst from the cache, image A is
4821 * unloaded, so the inst is deleted, but image B still retains
4824 * The AOT runtime doesn't set the image when it's decoding
4825 * types, so we only compare it when the owner is NULL.
4827 if (mono_generic_param_owner (p1
) == mono_generic_param_owner (p2
) &&
4828 (mono_generic_param_owner (p1
) || p1
->image
== p2
->image
))
4832 * If `signature_only' is true, we're comparing two (method) signatures.
4833 * In this case, the owner of two type parameters doesn't need to match.
4836 return signature_only
;
4840 mono_metadata_generic_param_equal (MonoGenericParam
*p1
, MonoGenericParam
*p2
)
4842 return mono_metadata_generic_param_equal_internal (p1
, p2
, TRUE
);
4846 mono_metadata_class_equal (MonoClass
*c1
, MonoClass
*c2
, gboolean signature_only
)
4850 if (c1
->generic_class
&& c2
->generic_class
)
4851 return _mono_metadata_generic_class_equal (c1
->generic_class
, c2
->generic_class
, signature_only
);
4852 if (c1
->generic_class
&& c2
->generic_container
)
4853 return _mono_metadata_generic_class_container_equal (c1
->generic_class
, c2
, signature_only
);
4854 if (c1
->generic_container
&& c2
->generic_class
)
4855 return _mono_metadata_generic_class_container_equal (c2
->generic_class
, c1
, signature_only
);
4856 if ((c1
->byval_arg
.type
== MONO_TYPE_VAR
) && (c2
->byval_arg
.type
== MONO_TYPE_VAR
))
4857 return mono_metadata_generic_param_equal_internal (
4858 c1
->byval_arg
.data
.generic_param
, c2
->byval_arg
.data
.generic_param
, signature_only
);
4859 if ((c1
->byval_arg
.type
== MONO_TYPE_MVAR
) && (c2
->byval_arg
.type
== MONO_TYPE_MVAR
))
4860 return mono_metadata_generic_param_equal_internal (
4861 c1
->byval_arg
.data
.generic_param
, c2
->byval_arg
.data
.generic_param
, signature_only
);
4862 if (signature_only
&&
4863 (c1
->byval_arg
.type
== MONO_TYPE_SZARRAY
) && (c2
->byval_arg
.type
== MONO_TYPE_SZARRAY
))
4864 return mono_metadata_class_equal (c1
->byval_arg
.data
.klass
, c2
->byval_arg
.data
.klass
, signature_only
);
4865 if (signature_only
&&
4866 (c1
->byval_arg
.type
== MONO_TYPE_ARRAY
) && (c2
->byval_arg
.type
== MONO_TYPE_ARRAY
))
4867 return do_mono_metadata_type_equal (&c1
->byval_arg
, &c2
->byval_arg
, signature_only
);
4872 mono_metadata_fnptr_equal (MonoMethodSignature
*s1
, MonoMethodSignature
*s2
, gboolean signature_only
)
4874 gpointer iter1
= 0, iter2
= 0;
4878 if (s1
->call_convention
!= s2
->call_convention
)
4880 if (s1
->sentinelpos
!= s2
->sentinelpos
)
4882 if (s1
->hasthis
!= s2
->hasthis
)
4884 if (s1
->explicit_this
!= s2
->explicit_this
)
4886 if (! do_mono_metadata_type_equal (s1
->ret
, s2
->ret
, signature_only
))
4888 if (s1
->param_count
!= s2
->param_count
)
4892 MonoType
*t1
= mono_signature_get_params (s1
, &iter1
);
4893 MonoType
*t2
= mono_signature_get_params (s2
, &iter2
);
4895 if (t1
== NULL
|| t2
== NULL
)
4897 if (! do_mono_metadata_type_equal (t1
, t2
, signature_only
))
4903 * mono_metadata_type_equal:
4907 * Determine if @t1 and @t2 represent the same type.
4908 * Returns: #TRUE if @t1 and @t2 are equal.
4911 do_mono_metadata_type_equal (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
)
4913 if (t1
->type
!= t2
->type
|| t1
->byref
!= t2
->byref
)
4917 case MONO_TYPE_VOID
:
4918 case MONO_TYPE_BOOLEAN
:
4919 case MONO_TYPE_CHAR
:
4930 case MONO_TYPE_STRING
:
4933 case MONO_TYPE_OBJECT
:
4934 case MONO_TYPE_TYPEDBYREF
:
4936 case MONO_TYPE_VALUETYPE
:
4937 case MONO_TYPE_CLASS
:
4938 case MONO_TYPE_SZARRAY
:
4939 return mono_metadata_class_equal (t1
->data
.klass
, t2
->data
.klass
, signature_only
);
4941 return do_mono_metadata_type_equal (t1
->data
.type
, t2
->data
.type
, signature_only
);
4942 case MONO_TYPE_ARRAY
:
4943 if (t1
->data
.array
->rank
!= t2
->data
.array
->rank
)
4945 return mono_metadata_class_equal (t1
->data
.array
->eklass
, t2
->data
.array
->eklass
, signature_only
);
4946 case MONO_TYPE_GENERICINST
:
4947 return _mono_metadata_generic_class_equal (
4948 t1
->data
.generic_class
, t2
->data
.generic_class
, signature_only
);
4950 return mono_metadata_generic_param_equal_internal (
4951 t1
->data
.generic_param
, t2
->data
.generic_param
, signature_only
);
4952 case MONO_TYPE_MVAR
:
4953 return mono_metadata_generic_param_equal_internal (
4954 t1
->data
.generic_param
, t2
->data
.generic_param
, signature_only
);
4955 case MONO_TYPE_FNPTR
:
4956 return mono_metadata_fnptr_equal (t1
->data
.method
, t2
->data
.method
, signature_only
);
4958 g_error ("implement type compare for %0x!", t1
->type
);
4966 mono_metadata_type_equal (MonoType
*t1
, MonoType
*t2
)
4968 return do_mono_metadata_type_equal (t1
, t2
, FALSE
);
4972 * mono_metadata_type_equal_full:
4975 * @signature_only: if signature only comparison should be made
4977 * Determine if @t1 and @t2 are signature compatible if @signature_only is #TRUE, otherwise
4978 * behaves the same way as mono_metadata_type_equal.
4979 * The function mono_metadata_type_equal(a, b) is just a shortcut for mono_metadata_type_equal_full(a, b, FALSE).
4980 * Returns: #TRUE if @t1 and @t2 are equal taking @signature_only into account.
4983 mono_metadata_type_equal_full (MonoType
*t1
, MonoType
*t2
, gboolean signature_only
)
4985 return do_mono_metadata_type_equal (t1
, t2
, signature_only
);
4989 * mono_metadata_signature_equal:
4990 * @sig1: a signature
4991 * @sig2: another signature
4993 * Determine if @sig1 and @sig2 represent the same signature, with the
4994 * same number of arguments and the same types.
4995 * Returns: #TRUE if @sig1 and @sig2 are equal.
4998 mono_metadata_signature_equal (MonoMethodSignature
*sig1
, MonoMethodSignature
*sig2
)
5002 if (sig1
->hasthis
!= sig2
->hasthis
|| sig1
->param_count
!= sig2
->param_count
)
5005 if (sig1
->generic_param_count
!= sig2
->generic_param_count
)
5009 * We're just comparing the signatures of two methods here:
5011 * If we have two generic methods `void Foo<U> (U u)' and `void Bar<V> (V v)',
5012 * U and V are equal here.
5014 * That's what the `signature_only' argument of do_mono_metadata_type_equal() is for.
5017 for (i
= 0; i
< sig1
->param_count
; i
++) {
5018 MonoType
*p1
= sig1
->params
[i
];
5019 MonoType
*p2
= sig2
->params
[i
];
5021 /* if (p1->attrs != p2->attrs)
5024 if (!do_mono_metadata_type_equal (p1
, p2
, TRUE
))
5028 if (!do_mono_metadata_type_equal (sig1
->ret
, sig2
->ret
, TRUE
))
5034 * mono_metadata_type_dup:
5035 * @image: image to alloc memory from
5036 * @original: type to duplicate
5038 * Returns: copy of type allocated from the image's mempool (or from the heap, if @image is null).
5041 mono_metadata_type_dup (MonoImage
*image
, const MonoType
*o
)
5044 int sizeof_o
= MONO_SIZEOF_TYPE
;
5046 sizeof_o
+= o
->num_mods
* sizeof (MonoCustomMod
);
5048 r
= image
? mono_image_alloc0 (image
, sizeof_o
) : g_malloc (sizeof_o
);
5050 memcpy (r
, o
, sizeof_o
);
5052 if (o
->type
== MONO_TYPE_PTR
) {
5053 r
->data
.type
= mono_metadata_type_dup (image
, o
->data
.type
);
5054 } else if (o
->type
== MONO_TYPE_ARRAY
) {
5055 r
->data
.array
= mono_dup_array_type (image
, o
->data
.array
);
5056 } else if (o
->type
== MONO_TYPE_FNPTR
) {
5057 /*FIXME the dup'ed signature is leaked mono_metadata_free_type*/
5058 r
->data
.method
= mono_metadata_signature_deep_dup (image
, o
->data
.method
);
5064 mono_signature_hash (MonoMethodSignature
*sig
)
5066 guint i
, res
= sig
->ret
->type
;
5068 for (i
= 0; i
< sig
->param_count
; i
++)
5069 res
= (res
<< 5) - res
+ mono_type_hash (sig
->params
[i
]);
5075 * mono_metadata_encode_value:
5076 * @value: value to encode
5077 * @buf: buffer where to write the compressed representation
5078 * @endbuf: pointer updated to point at the end of the encoded output
5080 * Encodes the value @value in the compressed representation used
5081 * in metadata and stores the result in @buf. @buf needs to be big
5082 * enough to hold the data (4 bytes).
5085 mono_metadata_encode_value (guint32 value
, char *buf
, char **endbuf
)
5091 else if (value
< 0x4000) {
5092 p
[0] = 0x80 | (value
>> 8);
5093 p
[1] = value
& 0xff;
5096 p
[0] = (value
>> 24) | 0xc0;
5097 p
[1] = (value
>> 16) & 0xff;
5098 p
[2] = (value
>> 8) & 0xff;
5099 p
[3] = value
& 0xff;
5107 * mono_metadata_field_info:
5108 * @meta: the Image the field is defined in
5109 * @index: the index in the field table representing the field
5110 * @offset: a pointer to an integer where to store the offset that
5111 * may have been specified for the field in a FieldLayout table
5112 * @rva: a pointer to the RVA of the field data in the image that
5113 * may have been defined in a FieldRVA table
5114 * @marshal_spec: a pointer to the marshal spec that may have been
5115 * defined for the field in a FieldMarshal table.
5117 * Gather info for field @index that may have been defined in the FieldLayout,
5118 * FieldRVA and FieldMarshal tables.
5119 * Either of offset, rva and marshal_spec can be NULL if you're not interested
5123 mono_metadata_field_info (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
5124 MonoMarshalSpec
**marshal_spec
)
5126 mono_metadata_field_info_full (meta
, index
, offset
, rva
, marshal_spec
, FALSE
);
5130 mono_metadata_field_info_with_mempool (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
5131 MonoMarshalSpec
**marshal_spec
)
5133 mono_metadata_field_info_full (meta
, index
, offset
, rva
, marshal_spec
, TRUE
);
5137 mono_metadata_field_info_full (MonoImage
*meta
, guint32 index
, guint32
*offset
, guint32
*rva
,
5138 MonoMarshalSpec
**marshal_spec
, gboolean alloc_from_image
)
5140 MonoTableInfo
*tdef
;
5143 loc
.idx
= index
+ 1;
5144 if (meta
->uncompressed_metadata
)
5145 loc
.idx
= search_ptr_table (meta
, MONO_TABLE_FIELD_POINTER
, loc
.idx
);
5148 tdef
= &meta
->tables
[MONO_TABLE_FIELDLAYOUT
];
5150 loc
.col_idx
= MONO_FIELD_LAYOUT_FIELD
;
5153 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5154 *offset
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_LAYOUT_OFFSET
);
5156 *offset
= (guint32
)-1;
5160 tdef
= &meta
->tables
[MONO_TABLE_FIELDRVA
];
5162 loc
.col_idx
= MONO_FIELD_RVA_FIELD
;
5165 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5167 * LAMESPEC: There is no signature, no nothing, just the raw data.
5169 *rva
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_RVA_RVA
);
5177 if ((p
= mono_metadata_get_marshal_info (meta
, index
, TRUE
))) {
5178 *marshal_spec
= mono_metadata_parse_marshal_spec_full (alloc_from_image
? meta
: NULL
, meta
, p
);
5185 * mono_metadata_get_constant_index:
5186 * @meta: the Image the field is defined in
5187 * @index: the token that may have a row defined in the constants table
5188 * @hint: possible position for the row
5190 * @token must be a FieldDef, ParamDef or PropertyDef token.
5192 * Returns: the index into the Constants table or 0 if not found.
5195 mono_metadata_get_constant_index (MonoImage
*meta
, guint32 token
, guint32 hint
)
5197 MonoTableInfo
*tdef
;
5199 guint32 index
= mono_metadata_token_index (token
);
5201 tdef
= &meta
->tables
[MONO_TABLE_CONSTANT
];
5202 index
<<= MONO_HASCONSTANT_BITS
;
5203 switch (mono_metadata_token_table (token
)) {
5204 case MONO_TABLE_FIELD
:
5205 index
|= MONO_HASCONSTANT_FIEDDEF
;
5207 case MONO_TABLE_PARAM
:
5208 index
|= MONO_HASCONSTANT_PARAM
;
5210 case MONO_TABLE_PROPERTY
:
5211 index
|= MONO_HASCONSTANT_PROPERTY
;
5214 g_warning ("Not a valid token for the constant table: 0x%08x", token
);
5218 loc
.col_idx
= MONO_CONSTANT_PARENT
;
5221 /* FIXME: Index translation */
5223 if ((hint
> 0) && (hint
< tdef
->rows
) && (mono_metadata_decode_row_col (tdef
, hint
- 1, MONO_CONSTANT_PARENT
) == index
))
5226 if (tdef
->base
&& mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
)) {
5227 return loc
.result
+ 1;
5233 * mono_metadata_events_from_typedef:
5234 * @meta: metadata context
5235 * @index: 0-based index (in the TypeDef table) describing a type
5237 * Returns: the 0-based index in the Event table for the events in the
5238 * type. The last event that belongs to the type (plus 1) is stored
5239 * in the @end_idx pointer.
5242 mono_metadata_events_from_typedef (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5246 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_EVENTMAP
];
5254 loc
.col_idx
= MONO_EVENT_MAP_PARENT
;
5255 loc
.idx
= index
+ 1;
5257 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5260 start
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_EVENT_MAP_EVENTLIST
);
5261 if (loc
.result
+ 1 < tdef
->rows
) {
5262 end
= mono_metadata_decode_row_col (tdef
, loc
.result
+ 1, MONO_EVENT_MAP_EVENTLIST
) - 1;
5264 end
= meta
->tables
[MONO_TABLE_EVENT
].rows
;
5272 * mono_metadata_methods_from_event:
5273 * @meta: metadata context
5274 * @index: 0-based index (in the Event table) describing a event
5276 * Returns: the 0-based index in the MethodDef table for the methods in the
5277 * event. The last method that belongs to the event (plus 1) is stored
5278 * in the @end_idx pointer.
5281 mono_metadata_methods_from_event (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5285 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
5286 MonoTableInfo
*msemt
= &meta
->tables
[MONO_TABLE_METHODSEMANTICS
];
5292 if (meta
->uncompressed_metadata
)
5293 index
= search_ptr_table (meta
, MONO_TABLE_EVENT_POINTER
, index
+ 1) - 1;
5296 loc
.col_idx
= MONO_METHOD_SEMA_ASSOCIATION
;
5297 loc
.idx
= ((index
+ 1) << MONO_HAS_SEMANTICS_BITS
) | MONO_HAS_SEMANTICS_EVENT
; /* Method association coded index */
5299 if (!mono_binary_search (&loc
, msemt
->base
, msemt
->rows
, msemt
->row_size
, table_locator
))
5304 * We may end up in the middle of the rows...
5307 if (loc
.idx
== mono_metadata_decode_row_col (msemt
, start
- 1, MONO_METHOD_SEMA_ASSOCIATION
))
5313 while (end
< msemt
->rows
) {
5314 mono_metadata_decode_row (msemt
, end
, cols
, MONO_METHOD_SEMA_SIZE
);
5315 if (cols
[MONO_METHOD_SEMA_ASSOCIATION
] != loc
.idx
)
5324 * mono_metadata_properties_from_typedef:
5325 * @meta: metadata context
5326 * @index: 0-based index (in the TypeDef table) describing a type
5328 * Returns: the 0-based index in the Property table for the properties in the
5329 * type. The last property that belongs to the type (plus 1) is stored
5330 * in the @end_idx pointer.
5333 mono_metadata_properties_from_typedef (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5337 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_PROPERTYMAP
];
5345 loc
.col_idx
= MONO_PROPERTY_MAP_PARENT
;
5346 loc
.idx
= index
+ 1;
5348 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5351 start
= mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_PROPERTY_MAP_PROPERTY_LIST
);
5352 if (loc
.result
+ 1 < tdef
->rows
) {
5353 end
= mono_metadata_decode_row_col (tdef
, loc
.result
+ 1, MONO_PROPERTY_MAP_PROPERTY_LIST
) - 1;
5355 end
= meta
->tables
[MONO_TABLE_PROPERTY
].rows
;
5363 * mono_metadata_methods_from_property:
5364 * @meta: metadata context
5365 * @index: 0-based index (in the PropertyDef table) describing a property
5367 * Returns: the 0-based index in the MethodDef table for the methods in the
5368 * property. The last method that belongs to the property (plus 1) is stored
5369 * in the @end_idx pointer.
5372 mono_metadata_methods_from_property (MonoImage
*meta
, guint32 index
, guint
*end_idx
)
5376 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
5377 MonoTableInfo
*msemt
= &meta
->tables
[MONO_TABLE_METHODSEMANTICS
];
5383 if (meta
->uncompressed_metadata
)
5384 index
= search_ptr_table (meta
, MONO_TABLE_PROPERTY_POINTER
, index
+ 1) - 1;
5387 loc
.col_idx
= MONO_METHOD_SEMA_ASSOCIATION
;
5388 loc
.idx
= ((index
+ 1) << MONO_HAS_SEMANTICS_BITS
) | MONO_HAS_SEMANTICS_PROPERTY
; /* Method association coded index */
5390 if (!mono_binary_search (&loc
, msemt
->base
, msemt
->rows
, msemt
->row_size
, table_locator
))
5395 * We may end up in the middle of the rows...
5398 if (loc
.idx
== mono_metadata_decode_row_col (msemt
, start
- 1, MONO_METHOD_SEMA_ASSOCIATION
))
5404 while (end
< msemt
->rows
) {
5405 mono_metadata_decode_row (msemt
, end
, cols
, MONO_METHOD_SEMA_SIZE
);
5406 if (cols
[MONO_METHOD_SEMA_ASSOCIATION
] != loc
.idx
)
5415 mono_metadata_implmap_from_method (MonoImage
*meta
, guint32 method_idx
)
5418 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_IMPLMAP
];
5423 /* No index translation seems to be needed */
5426 loc
.col_idx
= MONO_IMPLMAP_MEMBER
;
5427 loc
.idx
= ((method_idx
+ 1) << MONO_MEMBERFORWD_BITS
) | MONO_MEMBERFORWD_METHODDEF
;
5429 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5432 return loc
.result
+ 1;
5436 * @image: context where the image is created
5437 * @type_spec: typespec token
5438 * @deprecated use mono_type_create_from_typespec_checked that has proper error handling
5440 * Creates a MonoType representing the TypeSpec indexed by the @type_spec
5444 mono_type_create_from_typespec (MonoImage
*image
, guint32 type_spec
)
5447 MonoType
*type
= mono_type_create_from_typespec_checked (image
, type_spec
, &error
);
5449 g_error ("Could not create typespec %x due to %s", type_spec
, mono_error_get_message (&error
));
5454 mono_type_create_from_typespec_checked (MonoImage
*image
, guint32 type_spec
, MonoError
*error
)
5457 guint32 idx
= mono_metadata_token_index (type_spec
);
5459 guint32 cols
[MONO_TYPESPEC_SIZE
];
5461 MonoType
*type
, *type2
;
5463 mono_error_init (error
);
5465 mono_image_lock (image
);
5466 type
= g_hash_table_lookup (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
));
5467 mono_image_unlock (image
);
5471 t
= &image
->tables
[MONO_TABLE_TYPESPEC
];
5473 mono_metadata_decode_row (t
, idx
-1, cols
, MONO_TYPESPEC_SIZE
);
5474 ptr
= mono_metadata_blob_heap (image
, cols
[MONO_TYPESPEC_SIGNATURE
]);
5476 if (!mono_verifier_verify_typespec_signature (image
, cols
[MONO_TYPESPEC_SIGNATURE
], type_spec
, NULL
)) {
5477 mono_error_set_bad_image (error
, image
, "Could not verify type spec %08x.", type_spec
);
5481 mono_metadata_decode_value (ptr
, &ptr
);
5483 type
= mono_metadata_parse_type_internal (image
, NULL
, MONO_PARSE_TYPE
, 0, TRUE
, ptr
, &ptr
);
5485 if (mono_loader_get_last_error ())
5486 mono_error_set_from_loader_error (error
);
5488 mono_error_set_bad_image (error
, image
, "Could not parse type spec %08x.", type_spec
);
5492 type2
= mono_metadata_type_dup (image
, type
);
5493 mono_metadata_free_type (type
);
5495 mono_image_lock (image
);
5496 type
= g_hash_table_lookup (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
));
5497 /* We might leak some data in the image mempool if found */
5499 g_hash_table_insert (image
->typespec_cache
, GUINT_TO_POINTER (type_spec
), type2
);
5502 mono_image_unlock (image
);
5509 mono_image_strndup (MonoImage
*image
, const char *data
, guint len
)
5513 return g_strndup (data
, len
);
5514 res
= mono_image_alloc (image
, len
+ 1);
5515 memcpy (res
, data
, len
);
5521 mono_metadata_parse_marshal_spec (MonoImage
*image
, const char *ptr
)
5523 return mono_metadata_parse_marshal_spec_full (NULL
, image
, ptr
);
5527 * If IMAGE is non-null, memory will be allocated from its mempool, otherwise it will be allocated using malloc.
5528 * PARENT_IMAGE is the image containing the marshal spec.
5531 mono_metadata_parse_marshal_spec_full (MonoImage
*image
, MonoImage
*parent_image
, const char *ptr
)
5533 MonoMarshalSpec
*res
;
5535 const char *start
= ptr
;
5537 /* fixme: this is incomplete, but I cant find more infos in the specs */
5540 res
= mono_image_alloc0 (image
, sizeof (MonoMarshalSpec
));
5542 res
= g_new0 (MonoMarshalSpec
, 1);
5544 len
= mono_metadata_decode_value (ptr
, &ptr
);
5545 res
->native
= *ptr
++;
5547 if (res
->native
== MONO_NATIVE_LPARRAY
) {
5548 res
->data
.array_data
.param_num
= -1;
5549 res
->data
.array_data
.num_elem
= -1;
5550 res
->data
.array_data
.elem_mult
= -1;
5552 if (ptr
- start
<= len
)
5553 res
->data
.array_data
.elem_type
= *ptr
++;
5554 if (ptr
- start
<= len
)
5555 res
->data
.array_data
.param_num
= mono_metadata_decode_value (ptr
, &ptr
);
5556 if (ptr
- start
<= len
)
5557 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5558 if (ptr
- start
<= len
) {
5560 * LAMESPEC: Older spec versions say this parameter comes before
5561 * num_elem. Never spec versions don't talk about elem_mult at
5562 * all, but csc still emits it, and it is used to distinguish
5563 * between param_num being 0, and param_num being omitted.
5564 * So if (param_num == 0) && (num_elem > 0), then
5565 * elem_mult == 0 -> the array size is num_elem
5566 * elem_mult == 1 -> the array size is @param_num + num_elem
5568 res
->data
.array_data
.elem_mult
= mono_metadata_decode_value (ptr
, &ptr
);
5572 if (res
->native
== MONO_NATIVE_BYVALTSTR
) {
5573 if (ptr
- start
<= len
)
5574 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5577 if (res
->native
== MONO_NATIVE_BYVALARRAY
) {
5578 if (ptr
- start
<= len
)
5579 res
->data
.array_data
.num_elem
= mono_metadata_decode_value (ptr
, &ptr
);
5582 if (res
->native
== MONO_NATIVE_CUSTOM
) {
5583 /* skip unused type guid */
5584 len
= mono_metadata_decode_value (ptr
, &ptr
);
5586 /* skip unused native type name */
5587 len
= mono_metadata_decode_value (ptr
, &ptr
);
5589 /* read custom marshaler type name */
5590 len
= mono_metadata_decode_value (ptr
, &ptr
);
5591 res
->data
.custom_data
.custom_name
= mono_image_strndup (image
, ptr
, len
);
5593 /* read cookie string */
5594 len
= mono_metadata_decode_value (ptr
, &ptr
);
5595 res
->data
.custom_data
.cookie
= mono_image_strndup (image
, ptr
, len
);
5596 res
->data
.custom_data
.image
= parent_image
;
5599 if (res
->native
== MONO_NATIVE_SAFEARRAY
) {
5600 res
->data
.safearray_data
.elem_type
= 0;
5601 res
->data
.safearray_data
.num_elem
= 0;
5602 if (ptr
- start
<= len
)
5603 res
->data
.safearray_data
.elem_type
= *ptr
++;
5604 if (ptr
- start
<= len
)
5605 res
->data
.safearray_data
.num_elem
= *ptr
++;
5611 mono_metadata_free_marshal_spec (MonoMarshalSpec
*spec
)
5613 if (spec
->native
== MONO_NATIVE_CUSTOM
) {
5614 g_free (spec
->data
.custom_data
.custom_name
);
5615 g_free (spec
->data
.custom_data
.cookie
);
5621 * mono_type_to_unmanaged:
5623 * Returns: A MonoMarshalNative enumeration value (MONO_NATIVE_) value
5624 * describing the underlying native reprensetation of the type.
5626 * In addition the value pointed by
5627 * "conv" will contain the kind of marshalling required for this
5628 * particular type one of the MONO_MARSHAL_CONV_ enumeration values.
5631 mono_type_to_unmanaged (MonoType
*type
, MonoMarshalSpec
*mspec
, gboolean as_field
,
5632 gboolean unicode
, MonoMarshalConv
*conv
)
5634 MonoMarshalConv dummy_conv
;
5640 *conv
= MONO_MARSHAL_CONV_NONE
;
5643 return MONO_NATIVE_UINT
;
5647 case MONO_TYPE_BOOLEAN
:
5649 switch (mspec
->native
) {
5650 case MONO_NATIVE_VARIANTBOOL
:
5651 *conv
= MONO_MARSHAL_CONV_BOOL_VARIANTBOOL
;
5652 return MONO_NATIVE_VARIANTBOOL
;
5653 case MONO_NATIVE_BOOLEAN
:
5654 *conv
= MONO_MARSHAL_CONV_BOOL_I4
;
5655 return MONO_NATIVE_BOOLEAN
;
5656 case MONO_NATIVE_I1
:
5657 case MONO_NATIVE_U1
:
5658 return mspec
->native
;
5660 g_error ("cant marshal bool to native type %02x", mspec
->native
);
5663 *conv
= MONO_MARSHAL_CONV_BOOL_I4
;
5664 return MONO_NATIVE_BOOLEAN
;
5665 case MONO_TYPE_CHAR
:
5667 switch (mspec
->native
) {
5668 case MONO_NATIVE_U2
:
5669 case MONO_NATIVE_U1
:
5670 return mspec
->native
;
5672 g_error ("cant marshal char to native type %02x", mspec
->native
);
5675 return unicode
? MONO_NATIVE_U2
: MONO_NATIVE_U1
;
5676 case MONO_TYPE_I1
: return MONO_NATIVE_I1
;
5677 case MONO_TYPE_U1
: return MONO_NATIVE_U1
;
5678 case MONO_TYPE_I2
: return MONO_NATIVE_I2
;
5679 case MONO_TYPE_U2
: return MONO_NATIVE_U2
;
5680 case MONO_TYPE_I4
: return MONO_NATIVE_I4
;
5681 case MONO_TYPE_U4
: return MONO_NATIVE_U4
;
5682 case MONO_TYPE_I8
: return MONO_NATIVE_I8
;
5683 case MONO_TYPE_U8
: return MONO_NATIVE_U8
;
5684 case MONO_TYPE_R4
: return MONO_NATIVE_R4
;
5685 case MONO_TYPE_R8
: return MONO_NATIVE_R8
;
5686 case MONO_TYPE_STRING
:
5688 switch (mspec
->native
) {
5689 case MONO_NATIVE_BSTR
:
5690 *conv
= MONO_MARSHAL_CONV_STR_BSTR
;
5691 return MONO_NATIVE_BSTR
;
5692 case MONO_NATIVE_LPSTR
:
5693 *conv
= MONO_MARSHAL_CONV_STR_LPSTR
;
5694 return MONO_NATIVE_LPSTR
;
5695 case MONO_NATIVE_LPWSTR
:
5696 *conv
= MONO_MARSHAL_CONV_STR_LPWSTR
;
5697 return MONO_NATIVE_LPWSTR
;
5698 case MONO_NATIVE_LPTSTR
:
5699 *conv
= MONO_MARSHAL_CONV_STR_LPTSTR
;
5700 return MONO_NATIVE_LPTSTR
;
5701 case MONO_NATIVE_ANSIBSTR
:
5702 *conv
= MONO_MARSHAL_CONV_STR_ANSIBSTR
;
5703 return MONO_NATIVE_ANSIBSTR
;
5704 case MONO_NATIVE_TBSTR
:
5705 *conv
= MONO_MARSHAL_CONV_STR_TBSTR
;
5706 return MONO_NATIVE_TBSTR
;
5707 case MONO_NATIVE_BYVALTSTR
:
5709 *conv
= MONO_MARSHAL_CONV_STR_BYVALWSTR
;
5711 *conv
= MONO_MARSHAL_CONV_STR_BYVALSTR
;
5712 return MONO_NATIVE_BYVALTSTR
;
5714 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
);
5718 *conv
= MONO_MARSHAL_CONV_STR_LPWSTR
;
5719 return MONO_NATIVE_LPWSTR
;
5722 *conv
= MONO_MARSHAL_CONV_STR_LPSTR
;
5723 return MONO_NATIVE_LPSTR
;
5725 case MONO_TYPE_PTR
: return MONO_NATIVE_UINT
;
5726 case MONO_TYPE_VALUETYPE
: /*FIXME*/
5727 if (type
->data
.klass
->enumtype
) {
5728 t
= mono_class_enum_basetype (type
->data
.klass
)->type
;
5731 if (type
->data
.klass
== mono_defaults
.handleref_class
){
5732 *conv
= MONO_MARSHAL_CONV_HANDLEREF
;
5733 return MONO_NATIVE_INT
;
5735 return MONO_NATIVE_STRUCT
;
5736 case MONO_TYPE_SZARRAY
:
5737 case MONO_TYPE_ARRAY
:
5739 switch (mspec
->native
) {
5740 case MONO_NATIVE_BYVALARRAY
:
5741 if ((type
->data
.klass
->element_class
== mono_defaults
.char_class
) && !unicode
)
5742 *conv
= MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY
;
5744 *conv
= MONO_MARSHAL_CONV_ARRAY_BYVALARRAY
;
5745 return MONO_NATIVE_BYVALARRAY
;
5746 case MONO_NATIVE_SAFEARRAY
:
5747 *conv
= MONO_MARSHAL_CONV_ARRAY_SAVEARRAY
;
5748 return MONO_NATIVE_SAFEARRAY
;
5749 case MONO_NATIVE_LPARRAY
:
5750 *conv
= MONO_MARSHAL_CONV_ARRAY_LPARRAY
;
5751 return MONO_NATIVE_LPARRAY
;
5753 g_error ("cant marshal array as native type %02x", mspec
->native
);
5757 *conv
= MONO_MARSHAL_CONV_ARRAY_LPARRAY
;
5758 return MONO_NATIVE_LPARRAY
;
5759 case MONO_TYPE_I
: return MONO_NATIVE_INT
;
5760 case MONO_TYPE_U
: return MONO_NATIVE_UINT
;
5761 case MONO_TYPE_CLASS
:
5762 case MONO_TYPE_OBJECT
: {
5763 /* FIXME : we need to handle ArrayList and StringBuilder here, probably */
5765 switch (mspec
->native
) {
5766 case MONO_NATIVE_STRUCT
:
5767 return MONO_NATIVE_STRUCT
;
5768 case MONO_NATIVE_CUSTOM
:
5769 return MONO_NATIVE_CUSTOM
;
5770 case MONO_NATIVE_INTERFACE
:
5771 *conv
= MONO_MARSHAL_CONV_OBJECT_INTERFACE
;
5772 return MONO_NATIVE_INTERFACE
;
5773 case MONO_NATIVE_IDISPATCH
:
5774 *conv
= MONO_MARSHAL_CONV_OBJECT_IDISPATCH
;
5775 return MONO_NATIVE_IDISPATCH
;
5776 case MONO_NATIVE_IUNKNOWN
:
5777 *conv
= MONO_MARSHAL_CONV_OBJECT_IUNKNOWN
;
5778 return MONO_NATIVE_IUNKNOWN
;
5779 case MONO_NATIVE_FUNC
:
5780 if (t
== MONO_TYPE_CLASS
&& (type
->data
.klass
== mono_defaults
.multicastdelegate_class
||
5781 type
->data
.klass
== mono_defaults
.delegate_class
||
5782 type
->data
.klass
->parent
== mono_defaults
.multicastdelegate_class
)) {
5783 *conv
= MONO_MARSHAL_CONV_DEL_FTN
;
5784 return MONO_NATIVE_FUNC
;
5788 g_error ("cant marshal object as native type %02x", mspec
->native
);
5791 if (t
== MONO_TYPE_CLASS
&& (type
->data
.klass
== mono_defaults
.multicastdelegate_class
||
5792 type
->data
.klass
== mono_defaults
.delegate_class
||
5793 type
->data
.klass
->parent
== mono_defaults
.multicastdelegate_class
)) {
5794 *conv
= MONO_MARSHAL_CONV_DEL_FTN
;
5795 return MONO_NATIVE_FUNC
;
5797 if (mono_defaults
.safehandle_class
&& type
->data
.klass
== mono_defaults
.safehandle_class
){
5798 *conv
= MONO_MARSHAL_CONV_SAFEHANDLE
;
5799 return MONO_NATIVE_INT
;
5801 *conv
= MONO_MARSHAL_CONV_OBJECT_STRUCT
;
5802 return MONO_NATIVE_STRUCT
;
5804 case MONO_TYPE_FNPTR
: return MONO_NATIVE_FUNC
;
5805 case MONO_TYPE_GENERICINST
:
5806 type
= &type
->data
.generic_class
->container_class
->byval_arg
;
5809 case MONO_TYPE_TYPEDBYREF
:
5811 g_error ("type 0x%02x not handled in marshal", t
);
5813 return MONO_NATIVE_MAX
;
5817 mono_metadata_get_marshal_info (MonoImage
*meta
, guint32 idx
, gboolean is_field
)
5820 MonoTableInfo
*tdef
= &meta
->tables
[MONO_TABLE_FIELDMARSHAL
];
5826 loc
.col_idx
= MONO_FIELD_MARSHAL_PARENT
;
5827 loc
.idx
= ((idx
+ 1) << MONO_HAS_FIELD_MARSHAL_BITS
) | (is_field
? MONO_HAS_FIELD_MARSHAL_FIELDSREF
: MONO_HAS_FIELD_MARSHAL_PARAMDEF
);
5829 /* FIXME: Index translation */
5831 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5834 return mono_metadata_blob_heap (meta
, mono_metadata_decode_row_col (tdef
, loc
.result
, MONO_FIELD_MARSHAL_NATIVE_TYPE
));
5838 method_from_method_def_or_ref (MonoImage
*m
, guint32 tok
, MonoGenericContext
*context
, MonoError
*error
)
5840 MonoMethod
*result
= NULL
;
5841 guint32 idx
= tok
>> MONO_METHODDEFORREF_BITS
;
5843 mono_error_init (error
);
5845 switch (tok
& MONO_METHODDEFORREF_MASK
) {
5846 case MONO_METHODDEFORREF_METHODDEF
:
5847 result
= mono_get_method_checked (m
, MONO_TOKEN_METHOD_DEF
| idx
, NULL
, context
, error
);
5849 case MONO_METHODDEFORREF_METHODREF
:
5850 result
= mono_get_method_checked (m
, MONO_TOKEN_MEMBER_REF
| idx
, NULL
, context
, error
);
5853 mono_error_set_bad_image (error
, m
, "Invalid MethodDefOfRef token %x", tok
);
5860 * mono_class_get_overrides_full:
5862 * Return the method overrides belonging to class @type_token in @overrides, and
5863 * the number of overrides in @num_overrides.
5865 * Returns: TRUE on success, FALSE on failure.
5868 mono_class_get_overrides_full (MonoImage
*image
, guint32 type_token
, MonoMethod
***overrides
, gint32
*num_overrides
,
5869 MonoGenericContext
*generic_context
)
5873 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_METHODIMPL
];
5876 guint32 cols
[MONO_METHODIMPL_SIZE
];
5877 MonoMethod
**result
;
5888 loc
.col_idx
= MONO_METHODIMPL_CLASS
;
5889 loc
.idx
= mono_metadata_token_index (type_token
);
5891 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
5897 * We may end up in the middle of the rows...
5900 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, start
- 1, MONO_METHODIMPL_CLASS
))
5905 while (end
< tdef
->rows
) {
5906 if (loc
.idx
== mono_metadata_decode_row_col (tdef
, end
, MONO_METHODIMPL_CLASS
))
5912 result
= g_new (MonoMethod
*, num
* 2);
5913 for (i
= 0; i
< num
; ++i
) {
5916 if (!mono_verifier_verify_methodimpl_row (image
, start
+ i
, &error
)) {
5917 mono_error_cleanup (&error
); /* FIXME don't swallow the error */
5922 mono_metadata_decode_row (tdef
, start
+ i
, cols
, MONO_METHODIMPL_SIZE
);
5923 method
= method_from_method_def_or_ref (
5924 image
, cols
[MONO_METHODIMPL_DECLARATION
], generic_context
, &error
);
5925 if (method
== NULL
) {
5926 mono_error_cleanup (&error
); /* FIXME don't swallow the error */
5929 result
[i
* 2] = method
;
5930 method
= method_from_method_def_or_ref (
5931 image
, cols
[MONO_METHODIMPL_BODY
], generic_context
, &error
);
5932 if (method
== NULL
) {
5933 mono_error_cleanup (&error
); /* FIXME don't swallow the error */
5936 result
[i
* 2 + 1] = method
;
5939 *overrides
= result
;
5941 *num_overrides
= num
;
5946 * mono_guid_to_string:
5948 * Converts a 16 byte Microsoft GUID to the standard string representation.
5951 mono_guid_to_string (const guint8
*guid
)
5953 return g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
5954 guid
[3], guid
[2], guid
[1], guid
[0],
5958 guid
[10], guid
[11], guid
[12], guid
[13], guid
[14], guid
[15]);
5962 get_constraints (MonoImage
*image
, int owner
, MonoClass
***constraints
, MonoGenericContainer
*container
, MonoError
*error
)
5964 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAMCONSTRAINT
];
5965 guint32 cols
[MONO_GENPARCONSTRAINT_SIZE
];
5966 guint32 i
, token
, found
;
5967 MonoClass
*klass
, **res
;
5968 GSList
*cons
= NULL
, *tmp
;
5969 MonoGenericContext
*context
= &container
->context
;
5971 mono_error_init (error
);
5973 *constraints
= NULL
;
5975 for (i
= 0; i
< tdef
->rows
; ++i
) {
5976 mono_metadata_decode_row (tdef
, i
, cols
, MONO_GENPARCONSTRAINT_SIZE
);
5977 if (cols
[MONO_GENPARCONSTRAINT_GENERICPAR
] == owner
) {
5978 token
= mono_metadata_token_from_dor (cols
[MONO_GENPARCONSTRAINT_CONSTRAINT
]);
5979 klass
= mono_class_get_and_inflate_typespec_checked (image
, token
, context
, error
);
5981 g_slist_free (cons
);
5984 cons
= g_slist_append (cons
, klass
);
5987 /* contiguous list finished */
5994 res
= mono_image_alloc0 (image
, sizeof (MonoClass
*) * (found
+ 1));
5995 for (i
= 0, tmp
= cons
; i
< found
; ++i
, tmp
= tmp
->next
) {
5996 res
[i
] = tmp
->data
;
5998 g_slist_free (cons
);
6004 * mono_metadata_get_generic_param_row:
6007 * @token: TypeOrMethodDef token, owner for GenericParam
6008 * @owner: coded token, set on return
6010 * Returns: 1-based row-id in the GenericParam table whose
6011 * owner is @token. 0 if not found.
6014 mono_metadata_get_generic_param_row (MonoImage
*image
, guint32 token
, guint32
*owner
)
6016 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAM
];
6023 if (mono_metadata_token_table (token
) == MONO_TABLE_TYPEDEF
)
6024 *owner
= MONO_TYPEORMETHOD_TYPE
;
6025 else if (mono_metadata_token_table (token
) == MONO_TABLE_METHOD
)
6026 *owner
= MONO_TYPEORMETHOD_METHOD
;
6028 g_error ("wrong token %x to get_generic_param_row", token
);
6031 *owner
|= mono_metadata_token_index (token
) << MONO_TYPEORMETHOD_BITS
;
6034 loc
.col_idx
= MONO_GENERICPARAM_OWNER
;
6037 if (!mono_binary_search (&loc
, tdef
->base
, tdef
->rows
, tdef
->row_size
, table_locator
))
6040 /* Find the first entry by searching backwards */
6041 while ((loc
.result
> 0) && (mono_metadata_decode_row_col (tdef
, loc
.result
- 1, MONO_GENERICPARAM_OWNER
) == loc
.idx
))
6044 return loc
.result
+ 1;
6048 mono_metadata_has_generic_params (MonoImage
*image
, guint32 token
)
6051 return mono_metadata_get_generic_param_row (image
, token
, &owner
);
6055 * Memory is allocated from IMAGE's mempool.
6058 mono_metadata_load_generic_param_constraints_checked (MonoImage
*image
, guint32 token
,
6059 MonoGenericContainer
*container
, MonoError
*error
)
6062 guint32 start_row
, i
, owner
;
6063 mono_error_init (error
);
6065 if (! (start_row
= mono_metadata_get_generic_param_row (image
, token
, &owner
)))
6067 for (i
= 0; i
< container
->type_argc
; i
++) {
6068 if (!get_constraints (image
, start_row
+ i
, &mono_generic_container_get_param_info (container
, i
)->constraints
, container
, error
)) {
6069 mono_loader_assert_no_error ();
6077 * mono_metadata_load_generic_params:
6079 * Load the type parameters from the type or method definition @token.
6081 * Use this method after parsing a type or method definition to figure out whether it's a generic
6082 * type / method. When parsing a method definition, @parent_container points to the generic container
6083 * of the current class, if any.
6085 * Note: This method does not load the constraints: for typedefs, this has to be done after fully
6086 * creating the type.
6088 * Returns: NULL if @token is not a generic type or method definition or the new generic container.
6090 * LOCKING: Acquires the loader lock
6093 MonoGenericContainer
*
6094 mono_metadata_load_generic_params (MonoImage
*image
, guint32 token
, MonoGenericContainer
*parent_container
)
6096 MonoTableInfo
*tdef
= &image
->tables
[MONO_TABLE_GENERICPARAM
];
6097 guint32 cols
[MONO_GENERICPARAM_SIZE
];
6098 guint32 i
, owner
= 0, n
;
6099 MonoGenericContainer
*container
;
6100 MonoGenericParamFull
*params
;
6101 MonoGenericContext
*context
;
6103 if (!(i
= mono_metadata_get_generic_param_row (image
, token
, &owner
)))
6105 mono_metadata_decode_row (tdef
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
6108 container
= mono_image_alloc0 (image
, sizeof (MonoGenericContainer
));
6109 container
->image
= image
;
6112 params
= g_realloc (params
, sizeof (MonoGenericParamFull
) * n
);
6113 memset (¶ms
[n
- 1], 0, sizeof (MonoGenericParamFull
));
6114 params
[n
- 1].param
.owner
= container
;
6115 params
[n
- 1].param
.num
= cols
[MONO_GENERICPARAM_NUMBER
];
6116 params
[n
- 1].info
.token
= i
| MONO_TOKEN_GENERIC_PARAM
;
6117 params
[n
- 1].info
.flags
= cols
[MONO_GENERICPARAM_FLAGS
];
6118 params
[n
- 1].info
.name
= mono_metadata_string_heap (image
, cols
[MONO_GENERICPARAM_NAME
]);
6119 if (params
[n
- 1].param
.num
!= n
- 1)
6120 g_warning ("GenericParam table unsorted or hole in generic param sequence: token %d", i
);
6121 if (++i
> tdef
->rows
)
6123 mono_metadata_decode_row (tdef
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
6124 } while (cols
[MONO_GENERICPARAM_OWNER
] == owner
);
6126 container
->type_argc
= n
;
6127 container
->type_params
= mono_image_alloc0 (image
, sizeof (MonoGenericParamFull
) * n
);
6128 memcpy (container
->type_params
, params
, sizeof (MonoGenericParamFull
) * n
);
6130 container
->parent
= parent_container
;
6132 if (mono_metadata_token_table (token
) == MONO_TABLE_METHOD
)
6133 container
->is_method
= 1;
6135 g_assert (container
->parent
== NULL
|| container
->is_method
);
6137 context
= &container
->context
;
6138 if (container
->is_method
) {
6139 context
->class_inst
= container
->parent
? container
->parent
->context
.class_inst
: NULL
;
6140 context
->method_inst
= mono_get_shared_generic_inst (container
);
6142 context
->class_inst
= mono_get_shared_generic_inst (container
);
6149 mono_get_shared_generic_inst (MonoGenericContainer
*container
)
6151 MonoType
**type_argv
;
6153 MonoGenericInst
*nginst
;
6156 type_argv
= g_new0 (MonoType
*, container
->type_argc
);
6157 helper
= g_new0 (MonoType
, container
->type_argc
);
6159 for (i
= 0; i
< container
->type_argc
; i
++) {
6160 MonoType
*t
= &helper
[i
];
6162 t
->type
= container
->is_method
? MONO_TYPE_MVAR
: MONO_TYPE_VAR
;
6163 t
->data
.generic_param
= mono_generic_container_get_param (container
, i
);
6168 nginst
= mono_metadata_get_generic_inst (container
->type_argc
, type_argv
);
6177 * mono_type_is_byref:
6178 * @type: the MonoType operated on
6180 * Returns: #TRUE if @type represents a type passed by reference,
6184 mono_type_is_byref (MonoType
*type
)
6190 * mono_type_get_type:
6191 * @type: the MonoType operated on
6193 * Returns: the IL type value for @type. This is one of the MonoTypeEnum
6194 * enum members like MONO_TYPE_I4 or MONO_TYPE_STRING.
6197 mono_type_get_type (MonoType
*type
)
6203 * mono_type_get_signature:
6204 * @type: the MonoType operated on
6206 * It is only valid to call this function if @type is a MONO_TYPE_FNPTR.
6208 * Returns: the MonoMethodSignature pointer that describes the signature
6209 * of the function pointer @type represents.
6211 MonoMethodSignature
*
6212 mono_type_get_signature (MonoType
*type
)
6214 g_assert (type
->type
== MONO_TYPE_FNPTR
);
6215 return type
->data
.method
;
6219 * mono_type_get_class:
6220 * @type: the MonoType operated on
6222 * It is only valid to call this function if @type is a MONO_TYPE_CLASS or a
6223 * MONO_TYPE_VALUETYPE. For more general functionality, use mono_class_from_mono_type (),
6226 * Returns: the MonoClass pointer that describes the class that @type represents.
6229 mono_type_get_class (MonoType
*type
)
6231 /* FIXME: review the runtime users before adding the assert here */
6232 return type
->data
.klass
;
6236 * mono_type_get_array_type:
6237 * @type: the MonoType operated on
6239 * It is only valid to call this function if @type is a MONO_TYPE_ARRAY.
6241 * Returns: a MonoArrayType struct describing the array type that @type
6242 * represents. The info includes details such as rank, array element type
6243 * and the sizes and bounds of multidimensional arrays.
6246 mono_type_get_array_type (MonoType
*type
)
6248 return type
->data
.array
;
6252 * mono_type_get_ptr_type:
6253 * @type: the MonoType operated on
6255 * It is only valid to call this function if @type is a MONO_TYPE_PTR.
6258 * Returns: the MonoType pointer that describes the type that @type
6259 * represents a pointer to.
6262 mono_type_get_ptr_type (MonoType
*type
)
6264 g_assert (type
->type
== MONO_TYPE_PTR
);
6265 return type
->data
.type
;
6269 mono_type_get_modifiers (MonoType
*type
, gboolean
*is_required
, gpointer
*iter
)
6271 /* FIXME: implement */
6276 * mono_type_is_struct:
6277 * @type: the MonoType operated on
6279 * Returns: #TRUE is @type is a struct, that is a ValueType but not en enum
6280 * or a basic type like System.Int32. #FALSE otherwise.
6283 mono_type_is_struct (MonoType
*type
)
6285 return (!type
->byref
&& ((type
->type
== MONO_TYPE_VALUETYPE
&&
6286 !type
->data
.klass
->enumtype
) || (type
->type
== MONO_TYPE_TYPEDBYREF
) ||
6287 ((type
->type
== MONO_TYPE_GENERICINST
) &&
6288 mono_metadata_generic_class_is_valuetype (type
->data
.generic_class
) &&
6289 !type
->data
.generic_class
->container_class
->enumtype
)));
6293 * mono_type_is_void:
6294 * @type: the MonoType operated on
6296 * Returns: #TRUE is @type is System.Void. #FALSE otherwise.
6299 mono_type_is_void (MonoType
*type
)
6301 return (type
&& (type
->type
== MONO_TYPE_VOID
) && !type
->byref
);
6305 * mono_type_is_pointer:
6306 * @type: the MonoType operated on
6308 * Returns: #TRUE is @type is a managed or unmanaged pointer type. #FALSE otherwise.
6311 mono_type_is_pointer (MonoType
*type
)
6313 return (type
&& ((type
->byref
|| (type
->type
== MONO_TYPE_I
) || type
->type
== MONO_TYPE_STRING
)
6314 || (type
->type
== MONO_TYPE_SZARRAY
) || (type
->type
== MONO_TYPE_CLASS
) ||
6315 (type
->type
== MONO_TYPE_U
) || (type
->type
== MONO_TYPE_OBJECT
) ||
6316 (type
->type
== MONO_TYPE_ARRAY
) || (type
->type
== MONO_TYPE_PTR
) ||
6317 (type
->type
== MONO_TYPE_FNPTR
)));
6321 * mono_type_is_reference:
6322 * @type: the MonoType operated on
6324 * Returns: #TRUE is @type represents an object reference . #FALSE otherwise.
6327 mono_type_is_reference (MonoType
*type
)
6329 return (type
&& (((type
->type
== MONO_TYPE_STRING
) ||
6330 (type
->type
== MONO_TYPE_SZARRAY
) || (type
->type
== MONO_TYPE_CLASS
) ||
6331 (type
->type
== MONO_TYPE_OBJECT
) || (type
->type
== MONO_TYPE_ARRAY
)) ||
6332 ((type
->type
== MONO_TYPE_GENERICINST
) &&
6333 !mono_metadata_generic_class_is_valuetype (type
->data
.generic_class
))));
6337 * mono_signature_get_return_type:
6338 * @sig: the method signature inspected
6340 * Returns: the return type of the method signature @sig
6343 mono_signature_get_return_type (MonoMethodSignature
*sig
)
6349 * mono_signature_get_params:
6350 * @sig: the method signature inspected
6351 * #iter: pointer to an iterator
6353 * Iterates over the parameters for the method signature @sig.
6354 * A void* pointer must be initualized to #NULL to start the iteration
6355 * and it's address is passed to this function repeteadly until it returns
6358 * Returns: the next parameter type of the method signature @sig,
6359 * #NULL when finished.
6362 mono_signature_get_params (MonoMethodSignature
*sig
, gpointer
*iter
)
6368 /* start from the first */
6369 if (sig
->param_count
) {
6370 *iter
= &sig
->params
[0];
6371 return sig
->params
[0];
6379 if (type
< &sig
->params
[sig
->param_count
]) {
6387 * mono_signature_get_param_count:
6388 * @sig: the method signature inspected
6390 * Returns: the number of parameters in the method signature @sig.
6393 mono_signature_get_param_count (MonoMethodSignature
*sig
)
6395 return sig
->param_count
;
6399 * mono_signature_get_call_conv:
6400 * @sig: the method signature inspected
6402 * Returns: the call convention of the method signature @sig.
6405 mono_signature_get_call_conv (MonoMethodSignature
*sig
)
6407 return sig
->call_convention
;
6411 * mono_signature_vararg_start:
6412 * @sig: the method signature inspected
6414 * Returns: the number of the first vararg parameter in the
6415 * method signature @sig. -1 if this is not a vararg signature.
6418 mono_signature_vararg_start (MonoMethodSignature
*sig
)
6420 return sig
->sentinelpos
;
6424 * mono_signature_is_instance:
6425 * @sig: the method signature inspected
6427 * Returns: #TRUE if this the method signature @sig has an implicit
6428 * first instance argument. #FALSE otherwise.
6431 mono_signature_is_instance (MonoMethodSignature
*sig
)
6433 return sig
->hasthis
;
6437 * mono_signature_param_is_out
6438 * @sig: the method signature inspected
6439 * @param_num: the 0-based index of the inspected parameter
6441 * Returns: #TRUE if the parameter is an out parameter, #FALSE
6445 mono_signature_param_is_out (MonoMethodSignature
*sig
, int param_num
)
6447 g_assert (param_num
>= 0 && param_num
< sig
->param_count
);
6448 return (sig
->params
[param_num
]->attrs
& PARAM_ATTRIBUTE_OUT
) != 0;
6452 * mono_signature_explicit_this:
6453 * @sig: the method signature inspected
6455 * Returns: #TRUE if this the method signature @sig has an explicit
6456 * instance argument. #FALSE otherwise.
6459 mono_signature_explicit_this (MonoMethodSignature
*sig
)
6461 return sig
->explicit_this
;
6464 /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */
6466 mono_aligned_addr_hash (gconstpointer ptr
)
6468 return GPOINTER_TO_UINT (ptr
) >> 3;
6472 * If @field belongs to an inflated generic class, return the corresponding field of the
6473 * generic type definition class.
6476 mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField
*field
)
6481 if (!field
->parent
->generic_class
)
6484 gtd
= field
->parent
->generic_class
->container_class
;
6485 offset
= field
- field
->parent
->fields
;
6486 return gtd
->fields
+ offset
;
6490 * If @event belongs to an inflated generic class, return the corresponding event of the
6491 * generic type definition class.
6494 mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent
*event
)
6499 if (!event
->parent
->generic_class
)
6502 gtd
= event
->parent
->generic_class
->container_class
;
6503 offset
= event
- event
->parent
->ext
->events
;
6504 return gtd
->ext
->events
+ offset
;
6508 * If @property belongs to an inflated generic class, return the corresponding property of the
6509 * generic type definition class.
6512 mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty
*property
)
6517 if (!property
->parent
->generic_class
)
6520 gtd
= property
->parent
->generic_class
->container_class
;
6521 offset
= property
- property
->parent
->ext
->properties
;
6522 return gtd
->ext
->properties
+ offset
;