X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fmetadata.c;h=b8f76940171b07b4a0c2abf43bda820ed8ea7718;hb=b8e5e458a9cb96685f8ad8f02fc012bcdf4a4cc4;hp=496e24112c7ef754b802603f85437d30c7332454;hpb=1b0c8991e2292a91c4db1687151938c0ef85e57a;p=mono.git diff --git a/mono/metadata/metadata.c b/mono/metadata/metadata.c index 496e24112c7..b8f76940171 100644 --- a/mono/metadata/metadata.c +++ b/mono/metadata/metadata.c @@ -9,11 +9,17 @@ #include #include +#include #include #include "metadata.h" -#include "methodheader.h" -#include "endian.h" +#include "tabledefs.h" +#include "mono-endian.h" #include "cil-coff.h" +#include "tokentype.h" +#include "private.h" +#include "class.h" + +static void do_mono_metadata_parse_type (MonoType *type, MonoImage *m, const char *ptr, const char **rptr); /* * Encoding of the "description" argument: @@ -360,13 +366,26 @@ inverse of this mapping. #define idx_size(tableidx) (meta->tables [(tableidx)].rows < 65536 ? 2 : 4) /* Reference: Partition II - 23.2.6 */ -static int -compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *result_bitfield) +/* + * mono_metadata_compute_size: + * @meta: metadata context + * @tableindex: metadata table number + * @result_bitfield: pointer to guint32 where to store additional info + * + * mono_metadata_compute_size() computes the lenght in bytes of a single + * row in a metadata table. The size of each column is encoded in the + * @result_bitfield return value along with the number of columns in the table. + * the resulting bitfield should be handed to the mono_metadata_table_size() + * and mono_metadata_table_count() macros. + */ +int +mono_metadata_compute_size (MonoImage *meta, int tableindex, guint32 *result_bitfield) { guint32 bitfield = 0; int size = 0, field_size; int i, n, code; int shift = 0; + MonoMetaTable *table = tables [tableindex].table; for (i = 0; (code = table [i].code) != MONO_MT_END; i++){ switch (code){ @@ -394,61 +413,61 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * get the size for this column - lupus */ switch (tableindex) { - case META_TABLE_ASSEMBLYREFOS: + case MONO_TABLE_ASSEMBLYREFOS: g_assert (i == 3); - field_size = idx_size (META_TABLE_ASSEMBLYREF); break; - case META_TABLE_ASSEMBLYPROCESSOR: + field_size = idx_size (MONO_TABLE_ASSEMBLYREF); break; + case MONO_TABLE_ASSEMBLYPROCESSOR: g_assert (i == 1); - field_size = idx_size (META_TABLE_ASSEMBLYREF); break; - case META_TABLE_CLASSLAYOUT: + field_size = idx_size (MONO_TABLE_ASSEMBLYREF); break; + case MONO_TABLE_CLASSLAYOUT: g_assert (i == 2); - field_size = idx_size (META_TABLE_TYPEDEF); break; - case META_TABLE_EVENTMAP: + field_size = idx_size (MONO_TABLE_TYPEDEF); break; + case MONO_TABLE_EVENTMAP: g_assert (i == 0 || i == 1); - field_size = i ? idx_size (META_TABLE_EVENT): - idx_size(META_TABLE_TYPEDEF); + field_size = i ? idx_size (MONO_TABLE_EVENT): + idx_size(MONO_TABLE_TYPEDEF); break; - case META_TABLE_EVENT: + case MONO_TABLE_EVENT: g_assert (i == 2); - field_size = MAX (idx_size (META_TABLE_TYPEDEF), idx_size(META_TABLE_TYPEREF)); - field_size = MAX (field_size, idx_size(META_TABLE_TYPESPEC)); + field_size = MAX (idx_size (MONO_TABLE_TYPEDEF), idx_size(MONO_TABLE_TYPEREF)); + field_size = MAX (field_size, idx_size(MONO_TABLE_TYPESPEC)); break; - case META_TABLE_EXPORTEDTYPE: + case MONO_TABLE_EXPORTEDTYPE: g_assert (i == 1); - field_size = idx_size (META_TABLE_TYPEDEF); break; - case META_TABLE_FIELDLAYOUT: + field_size = idx_size (MONO_TABLE_TYPEDEF); break; + case MONO_TABLE_FIELDLAYOUT: g_assert (i == 1); - field_size = idx_size (META_TABLE_FIELD); break; - case META_TABLE_FIELDRVA: + field_size = idx_size (MONO_TABLE_FIELD); break; + case MONO_TABLE_FIELDRVA: g_assert (i == 1); - field_size = idx_size (META_TABLE_FIELD); break; - case META_TABLE_IMPLMAP: + field_size = idx_size (MONO_TABLE_FIELD); break; + case MONO_TABLE_IMPLMAP: g_assert (i == 3); - field_size = idx_size (META_TABLE_MODULEREF); break; - case META_TABLE_INTERFACEIMPL: + field_size = idx_size (MONO_TABLE_MODULEREF); break; + case MONO_TABLE_INTERFACEIMPL: g_assert (i == 0); - field_size = idx_size (META_TABLE_TYPEDEF); break; - case META_TABLE_METHOD: + field_size = idx_size (MONO_TABLE_TYPEDEF); break; + case MONO_TABLE_METHOD: g_assert (i == 5); - field_size = idx_size (META_TABLE_PARAM); break; - case META_TABLE_METHODIMPL: + field_size = idx_size (MONO_TABLE_PARAM); break; + case MONO_TABLE_METHODIMPL: g_assert (i == 0); - field_size = idx_size (META_TABLE_TYPEDEF); break; - case META_TABLE_METHODSEMANTICS: + field_size = idx_size (MONO_TABLE_TYPEDEF); break; + case MONO_TABLE_METHODSEMANTICS: g_assert (i == 1); - field_size = idx_size (META_TABLE_METHOD); break; - case META_TABLE_NESTEDCLASS: + field_size = idx_size (MONO_TABLE_METHOD); break; + case MONO_TABLE_NESTEDCLASS: g_assert (i == 0 || i == 1); - field_size = idx_size (META_TABLE_TYPEDEF); break; - case META_TABLE_PROPERTYMAP: + field_size = idx_size (MONO_TABLE_TYPEDEF); break; + case MONO_TABLE_PROPERTYMAP: g_assert (i == 0 || i == 1); - field_size = i ? idx_size (META_TABLE_PROPERTY): - idx_size(META_TABLE_TYPEDEF); + field_size = i ? idx_size (MONO_TABLE_PROPERTY): + idx_size(MONO_TABLE_TYPEDEF); break; - case META_TABLE_TYPEDEF: + case MONO_TABLE_TYPEDEF: g_assert (i == 4 || i == 5); - field_size = i == 4 ? idx_size (META_TABLE_FIELD): - idx_size(META_TABLE_METHOD); + field_size = i == 4 ? idx_size (MONO_TABLE_FIELD): + idx_size(MONO_TABLE_METHOD); break; default: g_assert_not_reached (); @@ -462,9 +481,9 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * HasConstant: ParamDef, FieldDef, Property */ case MONO_MT_CONST_IDX: - n = MAX (meta->tables [META_TABLE_PARAM].rows, - meta->tables [META_TABLE_FIELD].rows); - n = MAX (n, meta->tables [META_TABLE_PROPERTY].rows); + n = MAX (meta->tables [MONO_TABLE_PARAM].rows, + meta->tables [MONO_TABLE_FIELD].rows); + n = MAX (n, meta->tables [MONO_TABLE_PROPERTY].rows); /* 2 bits to encode tag */ field_size = rtsize (n, 16-2); @@ -486,25 +505,25 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r break; }*/ - n = MAX (meta->tables [META_TABLE_METHOD].rows, - meta->tables [META_TABLE_FIELD].rows); - n = MAX (n, meta->tables [META_TABLE_TYPEREF].rows); - n = MAX (n, meta->tables [META_TABLE_TYPEDEF].rows); - n = MAX (n, meta->tables [META_TABLE_PARAM].rows); - n = MAX (n, meta->tables [META_TABLE_INTERFACEIMPL].rows); - n = MAX (n, meta->tables [META_TABLE_MEMBERREF].rows); - n = MAX (n, meta->tables [META_TABLE_MODULE].rows); - /* Permission seems to be a blob heap pointer */ - n = MAX (n, meta->tables [META_TABLE_PROPERTY].rows); - n = MAX (n, meta->tables [META_TABLE_EVENT].rows); - /* Signature seems to be a blob heap pointer */ - n = MAX (n, meta->tables [META_TABLE_MODULEREF].rows); - n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows); - n = MAX (n, meta->tables [META_TABLE_ASSEMBLY].rows); - n = MAX (n, meta->tables [META_TABLE_ASSEMBLYREF].rows); - n = MAX (n, meta->tables [META_TABLE_FILE].rows); - n = MAX (n, meta->tables [META_TABLE_EXPORTEDTYPE].rows); - n = MAX (n, meta->tables [META_TABLE_MANIFESTRESOURCE].rows); + n = MAX (meta->tables [MONO_TABLE_METHOD].rows, + meta->tables [MONO_TABLE_FIELD].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPEDEF].rows); + n = MAX (n, meta->tables [MONO_TABLE_PARAM].rows); + n = MAX (n, meta->tables [MONO_TABLE_INTERFACEIMPL].rows); + n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_MODULE].rows); + n = MAX (n, meta->tables [MONO_TABLE_DECLSECURITY].rows); + n = MAX (n, meta->tables [MONO_TABLE_PROPERTY].rows); + n = MAX (n, meta->tables [MONO_TABLE_EVENT].rows); + n = MAX (n, meta->tables [MONO_TABLE_STANDALONESIG].rows); + n = MAX (n, meta->tables [MONO_TABLE_MODULEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows); + n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLY].rows); + n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLYREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_FILE].rows); + n = MAX (n, meta->tables [MONO_TABLE_EXPORTEDTYPE].rows); + n = MAX (n, meta->tables [MONO_TABLE_MANIFESTRESOURCE].rows); /* 5 bits to encode */ field_size = rtsize (n, 16-5); @@ -522,10 +541,10 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r break; }*/ - n = MAX (meta->tables [META_TABLE_TYPEREF].rows, - meta->tables [META_TABLE_TYPEDEF].rows); - n = MAX (n, meta->tables [META_TABLE_METHOD].rows); - n = MAX (n, meta->tables [META_TABLE_MEMBERREF].rows); + n = MAX (meta->tables [MONO_TABLE_TYPEREF].rows, + meta->tables [MONO_TABLE_TYPEDEF].rows); + n = MAX (n, meta->tables [MONO_TABLE_METHOD].rows); + n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows); /* 3 bits to encode */ field_size = rtsize (n, 16-3); @@ -535,9 +554,9 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * HasDeclSecurity: Typedef, MethodDef, Assembly */ case MONO_MT_HASDEC_IDX: - n = MAX (meta->tables [META_TABLE_TYPEDEF].rows, - meta->tables [META_TABLE_METHOD].rows); - n = MAX (n, meta->tables [META_TABLE_ASSEMBLY].rows); + n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows, + meta->tables [MONO_TABLE_METHOD].rows); + n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLY].rows); /* 2 bits to encode */ field_size = rtsize (n, 16-2); @@ -547,9 +566,9 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * Implementation: File, AssemblyRef, ExportedType */ case MONO_MT_IMPL_IDX: - n = MAX (meta->tables [META_TABLE_FILE].rows, - meta->tables [META_TABLE_ASSEMBLYREF].rows); - n = MAX (n, meta->tables [META_TABLE_EXPORTEDTYPE].rows); + n = MAX (meta->tables [MONO_TABLE_FILE].rows, + meta->tables [MONO_TABLE_ASSEMBLYREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_EXPORTEDTYPE].rows); /* 2 bits to encode tag */ field_size = rtsize (n, 16-2); @@ -559,8 +578,8 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * HasFieldMarshall: FieldDef, ParamDef */ case MONO_MT_HFM_IDX: - n = MAX (meta->tables [META_TABLE_FIELD].rows, - meta->tables [META_TABLE_PARAM].rows); + n = MAX (meta->tables [MONO_TABLE_FIELD].rows, + meta->tables [MONO_TABLE_PARAM].rows); /* 1 bit used to encode tag */ field_size = rtsize (n, 16-1); @@ -570,8 +589,8 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * MemberForwarded: FieldDef, MethodDef */ case MONO_MT_MF_IDX: - n = MAX (meta->tables [META_TABLE_FIELD].rows, - meta->tables [META_TABLE_METHOD].rows); + n = MAX (meta->tables [MONO_TABLE_FIELD].rows, + meta->tables [MONO_TABLE_METHOD].rows); /* 1 bit used to encode tag */ field_size = rtsize (n, 16-1); @@ -579,25 +598,28 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r /* * TypeDefOrRef: TypeDef, ParamDef, TypeSpec + * LAMESPEC + * It is TypeDef, _TypeRef_, TypeSpec, instead. */ case MONO_MT_TDOR_IDX: - n = MAX (meta->tables [META_TABLE_TYPEDEF].rows, - meta->tables [META_TABLE_PARAM].rows); - n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows); + n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows, + meta->tables [MONO_TABLE_TYPEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows); /* 2 bits to encode */ field_size = rtsize (n, 16-2); break; /* - * MemberRefParent: TypeDef, TypeRef, ModuleDef, ModuleRef, TypeSpec + * MemberRefParent: TypeDef, TypeRef, MethodDef, ModuleRef, TypeSpec, MemberRef */ case MONO_MT_MRP_IDX: - n = MAX (meta->tables [META_TABLE_TYPEDEF].rows, - meta->tables [META_TABLE_TYPEREF].rows); - n = MAX (n, meta->tables [META_TABLE_MODULE].rows); - n = MAX (n, meta->tables [META_TABLE_MODULEREF].rows); - n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows); + n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows, + meta->tables [MONO_TABLE_TYPEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_METHOD].rows); + n = MAX (n, meta->tables [MONO_TABLE_MODULEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows); + n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows); /* 3 bits to encode */ field_size = rtsize (n, 16 - 3); @@ -609,8 +631,8 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * MethodDefOrRef: MethodDef, MemberRef */ case MONO_MT_HS_IDX: - n = MAX (meta->tables [META_TABLE_METHOD].rows, - meta->tables [META_TABLE_MEMBERREF].rows); + n = MAX (meta->tables [MONO_TABLE_METHOD].rows, + meta->tables [MONO_TABLE_MEMBERREF].rows); /* 1 bit used to encode tag */ field_size = rtsize (n, 16-1); @@ -620,10 +642,10 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * ResolutionScope: Module, ModuleRef, AssemblyRef, TypeRef */ case MONO_MT_RS_IDX: - n = MAX (meta->tables [META_TABLE_MODULE].rows, - meta->tables [META_TABLE_MODULEREF].rows); - n = MAX (n, meta->tables [META_TABLE_ASSEMBLYREF].rows); - n = MAX (n, meta->tables [META_TABLE_TYPEREF].rows); + n = MAX (meta->tables [MONO_TABLE_MODULE].rows, + meta->tables [MONO_TABLE_MODULEREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLYREF].rows); + n = MAX (n, meta->tables [MONO_TABLE_TYPEREF].rows); /* 2 bits used to encode tag (ECMA spec claims 3) */ field_size = rtsize (n, 16 - 2); @@ -656,18 +678,17 @@ compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *r * This is an internal function used by the image loader code. */ void -mono_metadata_compute_table_bases (metadata_t *meta) +mono_metadata_compute_table_bases (MonoImage *meta) { int i; - char *base = meta->tables_base; + const char *base = meta->tables_base; for (i = 0; i < 64; i++){ if (meta->tables [i].rows == 0) continue; - meta->tables [i].row_size = compute_size ( - meta, tables [i].table, i, - &meta->tables [i].size_bitfield); + meta->tables [i].row_size = mono_metadata_compute_size ( + meta, i, &meta->tables [i].size_bitfield); meta->tables [i].base = base; base += meta->tables [i].rows * meta->tables [i].row_size; } @@ -682,8 +703,8 @@ mono_metadata_compute_table_bases (metadata_t *meta) * Returns a pointer to the @idx element in the metadata table * whose code is @table. */ -char * -mono_metadata_locate (metadata_t *meta, int table, int idx) +const char * +mono_metadata_locate (MonoImage *meta, int table, int idx) { /* idx == 0 refers always to NULL */ g_return_val_if_fail (idx > 0 && idx <= meta->tables [table].rows, ""); @@ -691,8 +712,16 @@ mono_metadata_locate (metadata_t *meta, int table, int idx) return meta->tables [table].base + (meta->tables [table].row_size * (idx - 1)); } -char * -mono_metadata_locate_token (metadata_t *meta, guint32 token) +/** + * mono_metadata_locate_token: + * @meta: metadata context + * @token: metadata token + * + * Returns a pointer to the data in the metadata represented by the + * token #token. + */ +const char * +mono_metadata_locate_token (MonoImage *meta, guint32 token) { return mono_metadata_locate (meta, token >> 24, token & 0xffffff); } @@ -704,11 +733,11 @@ mono_metadata_locate_token (metadata_t *meta, guint32 token) * Returns the MonoMetaTable structure for table @table */ MonoMetaTable * -mono_metadata_get_table (MetaTableEnum table) +mono_metadata_get_table (MonoMetaTableEnum table) { int x = (int) table; - g_return_val_if_fail ((x > 0) && (x <= META_TABLE_LAST), NULL); + g_return_val_if_fail ((x > 0) && (x <= MONO_TABLE_LAST), NULL); return tables [table].table; } @@ -721,17 +750,24 @@ mono_metadata_get_table (MetaTableEnum table) * Returns: an in-memory pointer to the @index in the string heap. */ const char * -mono_metadata_string_heap (metadata_t *meta, guint32 index) +mono_metadata_string_heap (MonoImage *meta, guint32 index) { - g_return_val_if_fail (index < meta->heap_strings.sh_size, ""); - return meta->raw_metadata + meta->heap_strings.sh_offset + index; + g_return_val_if_fail (index < meta->heap_strings.size, ""); + return meta->heap_strings.data + index; } +/** + * mono_metadata_user_string: + * @meta: metadata context + * @index: index into the user string heap. + * + * Returns: an in-memory pointer to the @index in the user string heap ("#US"). + */ const char * -mono_metadata_user_string (metadata_t *meta, guint32 index) +mono_metadata_user_string (MonoImage *meta, guint32 index) { - g_return_val_if_fail (index < meta->heap_us.sh_size, ""); - return meta->raw_metadata + meta->heap_us.sh_offset + index; + g_return_val_if_fail (index < meta->heap_us.size, ""); + return meta->heap_us.data + index; } /** @@ -742,46 +778,32 @@ mono_metadata_user_string (metadata_t *meta, guint32 index) * Returns: an in-memory pointer to the @index in the Blob heap. */ const char * -mono_metadata_blob_heap (metadata_t *meta, guint32 index) +mono_metadata_blob_heap (MonoImage *meta, guint32 index) { - g_return_val_if_fail (index < meta->heap_blob.sh_size, ""); - return meta->raw_metadata + meta->heap_blob.sh_offset + index; + g_return_val_if_fail (index < meta->heap_blob.size, ""); + return meta->heap_blob.data + index; } -static const char * -dword_align (const char *ptr) +/** + * mono_metadata_guid_heap: + * @meta: metadata context + * @index: index into the guid heap. + * + * Returns: an in-memory pointer to the @index in the guid heap. + */ +const char * +mono_metadata_guid_heap (MonoImage *meta, guint32 index) { - return (const char *) (((guint32) (ptr + 3)) & ~3); + --index; + index *= 16; /* adjust for guid size and 1-based index */ + g_return_val_if_fail (index < meta->heap_guid.size, ""); + return meta->heap_guid.data + index; } -static MonoMetaExceptionHandler * -parse_exception_handler (const char *ptr, gboolean is_fat) +static const char * +dword_align (const char *ptr) { - MonoMetaExceptionHandler *eh = g_new0 (MonoMetaExceptionHandler, 1); - int size; - - eh->kind = (MonoMetaExceptionEnum) *ptr; - ptr++; - if (is_fat) - size = (ptr [0] << 16) | (ptr [1] << 8) | ptr [2]; - else - size = (unsigned char) ptr [0]; - - /* - * It must be aligned - */ - ptr += 4; - g_assert ((((guint32) ptr) & 3) == 0); - - if (is_fat){ - printf ("Records: %d (%d)\n", size / 12, size); - - } else { - printf ("Records: %d (%d)\n", size / 12, size); - - } - - return eh; + return (const char *) (((guint32) (ptr + 3)) & ~3); } /** @@ -794,16 +816,16 @@ parse_exception_handler (const char *ptr, gboolean is_fat) * into the guint32 @res array that has res_size elements */ void -mono_metadata_decode_row (metadata_tableinfo_t *t, int idx, guint32 *res, int res_size) +mono_metadata_decode_row (MonoTableInfo *t, int idx, guint32 *res, int res_size) { guint32 bitfield = t->size_bitfield; - int i, count = meta_table_count (bitfield); - char *data = t->base + idx * t->row_size; + int i, count = mono_metadata_table_count (bitfield); + const char *data = t->base + idx * t->row_size; g_assert (res_size == count); for (i = 0; i < count; i++){ - int n = meta_table_size (bitfield, i); + int n = mono_metadata_table_size (bitfield, i); switch (n){ case 1: @@ -821,131 +843,202 @@ mono_metadata_decode_row (metadata_tableinfo_t *t, int idx, guint32 *res, int re } } +/** + * mono_metadata_decode_row_col: + * @t: table to extract information from. + * @idx: index for row in table. + * @col: column in the row. + * + * This function returns the value of column @col from the @idx + * row in the table @t. + */ +guint32 +mono_metadata_decode_row_col (MonoTableInfo *t, int idx, guint col) +{ + guint32 bitfield = t->size_bitfield; + int i; + register const char *data = t->base + idx * t->row_size; + register int n; + + g_assert (col < mono_metadata_table_count (bitfield)); + + n = mono_metadata_table_size (bitfield, 0); + for (i = 0; i < col; ++i) { + data += n; + n = mono_metadata_table_size (bitfield, i + 1); + } + switch (n){ + case 1: + return *data; + case 2: + return read16 (data); + case 4: + return read32 (data); + default: + g_assert_not_reached (); + } + return 0; +} /** * mono_metadata_decode_blob_size: * @ptr: pointer to a blob object - * @size: where we return the size of the object + * @rptr: the new position of the pointer * - * This decodes a compressed size as described by 23.1.4 + * This decodes a compressed size as described by 23.1.4 (a blob or user string object) * - * Returns: the position to start decoding a blob or user string object - * from. + * Returns: the size of the blob object */ -const char * -mono_metadata_decode_blob_size (const char *xptr, int *size) +guint32 +mono_metadata_decode_blob_size (const char *xptr, const char **rptr) { - const unsigned char *ptr = xptr; + const unsigned char *ptr = (const unsigned char *)xptr; + guint32 size; if ((*ptr & 0x80) == 0){ - *size = ptr [0] & 0x7f; + size = ptr [0] & 0x7f; ptr++; } else if ((*ptr & 0x40) == 0){ - *size = ((ptr [0] & 0x3f) << 8) + ptr [1]; + size = ((ptr [0] & 0x3f) << 8) + ptr [1]; ptr += 2; } else { - *size = ((ptr [0] & 0x1f) << 24) + + size = ((ptr [0] & 0x1f) << 24) + (ptr [1] << 16) + (ptr [2] << 8) + ptr [3]; ptr += 4; } - - return (char *) ptr; + if (rptr) + *rptr = ptr; + return size; } /** * mono_metadata_decode_value: * @ptr: pointer to decode from - * @len: result value is stored here. + * @rptr: the new position of the pointer * * This routine decompresses 32-bit values as specified in the "Blob and * Signature" section (22.2) * - * Returns: updated pointer location + * Returns: the decoded value */ -const char * -mono_metadata_decode_value (const char *_ptr, guint32 *len) +guint32 +mono_metadata_decode_value (const char *_ptr, const char **rptr) { - const unsigned char *ptr = (unsigned char *) _ptr; + const unsigned char *ptr = (const unsigned char *) _ptr; unsigned char b = *ptr; + guint32 len; if ((b & 0x80) == 0){ - *len = b; - return ptr+1; + len = b; + ++ptr; } else if ((b & 0x40) == 0){ - *len = ((b & 0x3f) << 8 | ptr [1]); - return ptr + 2; + len = ((b & 0x3f) << 8 | ptr [1]); + ptr += 2; + } else { + len = ((b & 0x1f) << 24) | + (ptr [1] << 16) | + (ptr [2] << 8) | + ptr [3]; + ptr += 4; } - *len = ((b & 0x1f) << 24) | - (ptr [1] << 16) | - (ptr [2] << 8) | - ptr [3]; + if (rptr) + *rptr = ptr; - return ptr + 4; + return len; } +/* + * mono_metadata_parse_typedef_or_ref: + * @m: a metadata context. + * @ptr: a pointer to an encoded TypedefOrRef in @m + * @rptr: pointer updated to match the end of the decoded stream + * + * Returns: a token valid in the @m metadata decoded from + * the compressed representation. + */ guint32 -mono_metadata_parse_typedef_or_ref (metadata_t *m, const char *ptr, const char **rptr) +mono_metadata_parse_typedef_or_ref (MonoImage *m, const char *ptr, const char **rptr) { guint32 token; - guint table; - ptr = mono_metadata_decode_value (ptr, &token); - - switch (table & 0x03) { - case 0: table = META_TABLE_TYPEDEF; break; - case 1: table = META_TABLE_TYPEREF; break; - case 2: table = META_TABLE_TYPESPEC; break; - default: g_error ("Unhandled encoding for typedef-or-ref coded index"); - } + token = mono_metadata_decode_value (ptr, &ptr); if (rptr) *rptr = ptr; - return (token >> 2) | table << 24; + return mono_metadata_token_from_dor (token); } +/* + * mono_metadata_parse_custom_mod: + * @m: a metadata context. + * @dest: storage where the info about the custom modifier is stored (may be NULL) + * @ptr: a pointer to (possibly) the start of a custom modifier list + * @rptr: pointer updated to match the end of the decoded stream + * + * Checks if @ptr points to a type custom modifier compressed representation. + * + * Returns: #TRUE if a custom modifier was found, #FALSE if not. + */ int -mono_metadata_parse_custom_mod (metadata_t *m, MonoCustomMod *dest, const char *ptr, const char **rptr) +mono_metadata_parse_custom_mod (MonoImage *m, MonoCustomMod *dest, const char *ptr, const char **rptr) { MonoCustomMod local; - if ((*ptr == ELEMENT_TYPE_CMOD_OPT) || - (*ptr == ELEMENT_TYPE_CMOD_REQD)) { + if ((*ptr == MONO_TYPE_CMOD_OPT) || + (*ptr == MONO_TYPE_CMOD_REQD)) { if (!dest) dest = &local; - dest->mod = *ptr++; - dest->token = mono_metadata_parse_typedef_or_ref (m, ptr, &ptr); + dest->required = *ptr == MONO_TYPE_CMOD_REQD ? 1 : 0; + dest->token = mono_metadata_parse_typedef_or_ref (m, ptr + 1, &ptr); return TRUE; } return FALSE; } -MonoArray * -mono_metadata_parse_array (metadata_t *m, const char *ptr, const char **rptr) +/* + * mono_metadata_parse_array: + * @m: a metadata context. + * @ptr: a pointer to an encoded array description. + * @rptr: pointer updated to match the end of the decoded stream + * + * Decodes the compressed array description found in the metadata @m at @ptr. + * + * Returns: a #MonoArrayType structure describing the array type + * and dimensions. + */ +MonoArrayType * +mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr) { int i; - MonoArray *array = g_new0(MonoArray, 1); + MonoArrayType *array = g_new0 (MonoArrayType, 1); - array->type = mono_metadata_parse_type (m, ptr, &ptr); - ptr = mono_metadata_decode_value (ptr, &array->rank); + array->type = mono_metadata_parse_type (m, MONO_PARSE_TYPE, 0, ptr, &ptr); + array->rank = mono_metadata_decode_value (ptr, &ptr); - ptr = mono_metadata_decode_value (ptr, &array->numsizes); + array->numsizes = mono_metadata_decode_value (ptr, &ptr); if (array->numsizes) - array->sizes = g_new0(int, array->numsizes); + array->sizes = g_new0 (int, array->numsizes); for (i = 0; i < array->numsizes; ++i) - ptr = mono_metadata_decode_value (ptr, &(array->sizes[i])); + array->sizes [i] = mono_metadata_decode_value (ptr, &ptr); - ptr = mono_metadata_decode_value (ptr, &array->numlobounds); + array->numlobounds = mono_metadata_decode_value (ptr, &ptr); if (array->numlobounds) - array->lobounds = g_new0(int, array->numlobounds); + array->lobounds = g_new0 (int, array->numlobounds); for (i = 0; i < array->numlobounds; ++i) - ptr = mono_metadata_decode_value (ptr, &(array->lobounds[i])); + array->lobounds [i] = mono_metadata_decode_value (ptr, &ptr); if (rptr) *rptr = ptr; return array; } +/* + * mono_metadata_free_array: + * @array: array description + * + * Frees the array description returned from mono_metadata_parse_array(). + */ void -mono_metadata_free_array (MonoArray *array) +mono_metadata_free_array (MonoArrayType *array) { mono_metadata_free_type (array->type); g_free (array->sizes); @@ -953,170 +1046,302 @@ mono_metadata_free_array (MonoArray *array) g_free (array); } -MonoParam * -mono_metadata_parse_param (metadata_t *m, int rettype, const char *ptr, const char **rptr) +/* + * need to add common field and param attributes combinations: + * [out] param + * public static + * public static literal + * private + * private static + * private static literal + */ +static MonoType +builtin_types[] = { + /* data, attrs, type, nmods, byref, pinned */ + {{NULL}, 0, MONO_TYPE_VOID, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_BOOLEAN, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_BOOLEAN, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_CHAR, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_CHAR, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_I1, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I1, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_U1, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_U1, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_I2, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I2, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_U2, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_U2, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_I4, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I4, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_U4, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_U4, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_I8, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I8, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_U8, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_U8, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_R4, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_R4, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_R8, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_R8, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_STRING, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_STRING, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_TYPEDBYREF, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_I, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_U, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_U, 0, 1, 0}, + {{NULL}, 0, MONO_TYPE_OBJECT, 0, 0, 0}, + {{NULL}, 0, MONO_TYPE_OBJECT, 0, 1, 0} +}; + +#define NBUILTIN_TYPES() (sizeof (builtin_types) / sizeof (builtin_types [0])) + +static GHashTable *type_cache = NULL; + +/* + * MonoTypes with modifies are never cached, so we never check or use that field. + */ +static guint +mono_type_hash (gconstpointer data) +{ + const MonoType *type = (const MonoType *) data; + return type->type | (type->byref << 8) | (type->attrs << 9); +} + +static gint +mono_type_equal (gconstpointer ka, gconstpointer kb) { - const char *tmp_ptr = ptr; - MonoParam *param; - int count = 0; - int byref = 0; - - /* count the modifiers */ - while (mono_metadata_parse_custom_mod (m, NULL, tmp_ptr, &tmp_ptr)) - count++; - param = g_malloc0(sizeof(MonoParam)+(count-1)*sizeof(MonoCustomMod)); - param->num_modifiers = count; - /* save them this time */ - count = 0; - while (mono_metadata_parse_custom_mod (m, &(param->modifiers[count]), ptr, &ptr)) - count++; - switch (*ptr) { - case ELEMENT_TYPE_TYPEDBYREF: - param->typedbyref = 1; - ptr++; - break; - case ELEMENT_TYPE_VOID: - if (!rettype) - g_error ("void not allowed in param"); - ptr++; + const MonoType *a = (const MonoType *) ka; + const MonoType *b = (const MonoType *) kb; + + if (a->type != b->type || a->byref != b->byref || a->attrs != b->attrs || a->pinned != b->pinned) + return 0; + /* need other checks */ + return 1; +} + +/* + * mono_metadata_parse_type: + * @m: metadata context + * @mode: king of type that may be found at @ptr + * @opt_attrs: optional attributes to store in the returned type + * @ptr: pointer to the type representation + * @rptr: pointer updated to match the end of the decoded stream + * + * Decode a compressed type description found at @ptr in @m. + * @mode can be one of MONO_PARSE_MOD_TYPE, MONO_PARSE_PARAM, MONO_PARSE_RET, + * MONO_PARSE_FIELD, MONO_PARSE_LOCAL, MONO_PARSE_TYPE. + * This function can be used to decode type descriptions in method signatures, + * field signatures, locals signatures etc. + * + * Returns: a #MonoType structure representing the decoded type. + */ +MonoType* +mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs, const char *ptr, const char **rptr) +{ + MonoType *type, *cached; + + if (!type_cache) { + int i; + type_cache = g_hash_table_new (mono_type_hash, mono_type_equal); + + for (i = 0; i < NBUILTIN_TYPES (); ++i) + g_hash_table_insert (type_cache, &builtin_types [i], &builtin_types [i]); + } + + switch (mode) { + case MONO_PARSE_MOD_TYPE: + case MONO_PARSE_PARAM: + case MONO_PARSE_RET: + case MONO_PARSE_FIELD: { + /* count the modifiers */ + const char *tmp_ptr = ptr; + int count = 0; + while (mono_metadata_parse_custom_mod (m, NULL, tmp_ptr, &tmp_ptr)) + count++; + if (count) { + type = g_malloc0 (sizeof (MonoType) + (count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod)); + type->num_mods = count; + if (count > 64) + g_warning ("got more than 64 modifiers in type"); + /* save them this time */ + count = 0; + while (mono_metadata_parse_custom_mod (m, &(type->modifiers [count]), ptr, &ptr)) + count++; + break; + } /* fall through */ + } + case MONO_PARSE_LOCAL: + case MONO_PARSE_TYPE: + /* + * Later we can avoid doing this allocation. + */ + type = g_new0 (MonoType, 1); break; - case ELEMENT_TYPE_BYREF: - byref = 1; + default: + g_assert_not_reached (); + } + + type->attrs = opt_attrs; + if (mode == MONO_PARSE_LOCAL) { + /* + * check for pinned flag + */ + if (*ptr == MONO_TYPE_PINNED) { + type->pinned = 1; + ++ptr; + } + } + + switch (*ptr) { + case MONO_TYPE_BYREF: + if (mode == MONO_PARSE_FIELD) + g_warning ("A field type cannot be byref"); + type->byref = 1; ptr++; /* follow through */ default: - param->type = mono_metadata_parse_type (m, ptr, &ptr); - param->type->byref = byref; + /*if (*ptr == MONO_TYPE_VOID && mode != MONO_PARSE_RET) + g_error ("void not allowed in param");*/ + do_mono_metadata_parse_type (type, m, ptr, &ptr); break; } if (rptr) *rptr = ptr; - return param; -} - -void -mono_metadata_free_param (MonoParam *param) -{ - if (param->type) - mono_metadata_free_type (param->type); - g_free (param); + if (mode != MONO_PARSE_PARAM && !type->num_mods && (cached = g_hash_table_lookup (type_cache, type))) { + mono_metadata_free_type (type); + return cached; + } else { + return type; + } } +/* + * mono_metadata_parse_method_signature: + * @m: metadata context + * @def: use #TRUE when parsing MethodDef, #FALSE with MethodRef signatures. + * @ptr: pointer to the signature metadata representation + * @rptr: pointer updated to match the end of the decoded stream + * + * Decode a method signature stored at @ptr. + * + * Returns: a MonoMethodSignature describing the signature. + */ MonoMethodSignature * -mono_metadata_parse_method_signature (metadata_t *m, int def, const char *ptr, const char **rptr) +mono_metadata_parse_method_signature (MonoImage *m, int def, const char *ptr, const char **rptr) { - MonoMethodSignature *method = g_new0(MonoMethodSignature, 1); + MonoMethodSignature *method; int i; + guint32 hasthis = 0, explicit_this = 0, call_convention, param_count; if (*ptr & 0x20) - method->hasthis = 1; + hasthis = 1; if (*ptr & 0x40) - method->explicit_this = 1; - method->call_convention = *ptr & 0x0F; + explicit_this = 1; + call_convention = *ptr & 0x0F; ptr++; - ptr = mono_metadata_decode_value (ptr, &method->param_count); - method->ret = mono_metadata_parse_param (m, 1, ptr, &ptr); - - method->params = g_new0(MonoParam*, method->param_count); - method->sentinelpos = -1; - for (i = 0; i < method->param_count; ++i) { - if (*ptr == ELEMENT_TYPE_SENTINEL) { - if (method->call_convention != MONO_CALL_VARARG || def) - g_error ("found sentinel for methoddef or no vararg method"); - method->sentinelpos = i; - ptr++; + param_count = mono_metadata_decode_value (ptr, &ptr); + + method = g_malloc0 (sizeof (MonoMethodSignature) + (param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*)); + method->param_count = param_count; + method->hasthis = hasthis; + method->explicit_this = explicit_this; + method->call_convention = call_convention; + method->ret = mono_metadata_parse_type (m, MONO_PARSE_RET, 0, ptr, &ptr); + + if (method->param_count) { + method->sentinelpos = -1; + + for (i = 0; i < method->param_count; ++i) { + if (*ptr == MONO_TYPE_SENTINEL) { + if (method->call_convention != MONO_CALL_VARARG || def) + g_error ("found sentinel for methoddef or no vararg method"); + method->sentinelpos = i; + ptr++; + } + method->params [i] = mono_metadata_parse_type (m, MONO_PARSE_PARAM, 0, ptr, &ptr); } - method->params[i] = mono_metadata_parse_param (m, 0, ptr, &ptr); } - + if (rptr) *rptr = ptr; + /* + * Add signature to a cache and increase ref count... + */ return method; } +/* + * mono_metadata_free_method_signature: + * @sig: signature to destroy + * + * Free the memory allocated in the signature @sig. + */ void -mono_metadata_free_method_signature (MonoMethodSignature *method) +mono_metadata_free_method_signature (MonoMethodSignature *sig) { int i; - mono_metadata_free_param (method->ret); - for (i = 0; i < method->param_count; ++i) - mono_metadata_free_param (method->params[i]); + mono_metadata_free_type (sig->ret); + for (i = 0; i < sig->param_count; ++i) + mono_metadata_free_type (sig->params [i]); - g_free (method->params); - g_free (method); + g_free (sig); } -/* II 22.2.12 */ -MonoType * -mono_metadata_parse_type (metadata_t *m, const char *ptr, const char **rptr) +/* + * do_mono_metadata_parse_type: + * @type: MonoType to be filled in with the return value + * @ + * Internal routine used to "fill" the contents of @type from an + * allocated pointer. This is done this way to avoid doing too + * many mini-allocations (particularly for the MonoFieldType which + * most of the time is just a MonoType, but sometimes might be augmented). + * + * This routine is used by mono_metadata_parse_type and + * mono_metadata_parse_field_type + * + * This extracts a Type as specified in Partition II (22.2.12) + */ +static void +do_mono_metadata_parse_type (MonoType *type, MonoImage *m, const char *ptr, const char **rptr) { - /* should probably be allocated in a memchunk */ - MonoType *type = g_new0(MonoType, 1); - int val; - - ptr = mono_metadata_decode_value (ptr, &val); - type->type = val; + type->type = mono_metadata_decode_value (ptr, &ptr); switch (type->type){ - case ELEMENT_TYPE_BOOLEAN: - case ELEMENT_TYPE_CHAR: - case ELEMENT_TYPE_I1: - case ELEMENT_TYPE_U1: - case ELEMENT_TYPE_I2: - case ELEMENT_TYPE_U2: - case ELEMENT_TYPE_I4: - case ELEMENT_TYPE_U4: - case ELEMENT_TYPE_I8: - case ELEMENT_TYPE_U8: - case ELEMENT_TYPE_R4: - case ELEMENT_TYPE_R8: - case ELEMENT_TYPE_I: - case ELEMENT_TYPE_U: - case ELEMENT_TYPE_STRING: - case ELEMENT_TYPE_OBJECT: + case MONO_TYPE_VOID: + case MONO_TYPE_BOOLEAN: + case MONO_TYPE_CHAR: + case MONO_TYPE_I1: + case MONO_TYPE_U1: + case MONO_TYPE_I2: + case MONO_TYPE_U2: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + case MONO_TYPE_I8: + case MONO_TYPE_U8: + case MONO_TYPE_R4: + case MONO_TYPE_R8: + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_STRING: + case MONO_TYPE_OBJECT: + case MONO_TYPE_TYPEDBYREF: break; - case ELEMENT_TYPE_VALUETYPE: - case ELEMENT_TYPE_CLASS: - type->data.token = mono_metadata_parse_typedef_or_ref (m, ptr, &ptr); + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_CLASS: { + guint32 token; + token = mono_metadata_parse_typedef_or_ref (m, ptr, &ptr); + type->data.klass = mono_class_get (m, token); break; - case ELEMENT_TYPE_SZARRAY: - case ELEMENT_TYPE_PTR: - if (mono_metadata_parse_custom_mod (m, NULL, ptr, NULL)) { - const char *tmp_ptr = ptr; - MonoModifiedType *mtype; - int count = 0; - - type->custom_mod = 1; - /* count the modifiers */ - while (mono_metadata_parse_custom_mod (m, NULL, tmp_ptr, &tmp_ptr)) - count++; - type->data.mtype = mtype = g_malloc0(sizeof(MonoModifiedType)+(count-1)*sizeof(MonoCustomMod)); - mtype->num_modifiers = count; - count = 0; - /* save them this time */ - while (mono_metadata_parse_custom_mod (m, &(mtype->modifiers[count]), ptr, &ptr)) - count++; - /* FIXME: mono_metadata_decode_value ... */ - if (*ptr == ELEMENT_TYPE_VOID) { - mtype->type = NULL; - ptr++; - } else { - mtype->type = mono_metadata_parse_type (m, ptr, &ptr); - } - } else { - /* FIXME: mono_metadata_decode_value ... */ - if (*ptr == ELEMENT_TYPE_VOID) { - type->data.type = NULL; - ptr++; - } else { - type->data.type = mono_metadata_parse_type (m, ptr, &ptr); - } - } + } + case MONO_TYPE_SZARRAY: + case MONO_TYPE_PTR: + type->data.type = mono_metadata_parse_type (m, MONO_PARSE_MOD_TYPE, 0, ptr, &ptr); break; - case ELEMENT_TYPE_FNPTR: + case MONO_TYPE_FNPTR: type->data.method = mono_metadata_parse_method_signature (m, 0, ptr, &ptr); break; - case ELEMENT_TYPE_ARRAY: + case MONO_TYPE_ARRAY: type->data.array = mono_metadata_parse_array (m, ptr, &ptr); break; default: @@ -1125,113 +1350,202 @@ mono_metadata_parse_type (metadata_t *m, const char *ptr, const char **rptr) if (rptr) *rptr = ptr; - return type; } +/* + * mono_metadata_free_type: + * @type: type to free + * + * Free the memory allocated for type @type. + */ void mono_metadata_free_type (MonoType *type) { + if (type >= builtin_types && type < builtin_types + NBUILTIN_TYPES ()) + return; switch (type->type){ - case ELEMENT_TYPE_SZARRAY: - case ELEMENT_TYPE_PTR: - if (!type->custom_mod) - mono_metadata_free_type (type->data.type); - else { - mono_metadata_free_type (type->data.mtype->type); - g_free (type->data.mtype); - } + case MONO_TYPE_SZARRAY: + case MONO_TYPE_PTR: + mono_metadata_free_type (type->data.type); break; - case ELEMENT_TYPE_FNPTR: + case MONO_TYPE_FNPTR: mono_metadata_free_method_signature (type->data.method); break; - case ELEMENT_TYPE_ARRAY: + case MONO_TYPE_ARRAY: mono_metadata_free_array (type->data.array); break; } g_free (type); } +#if 0 +static void +hex_dump (const char *buffer, int base, int count) +{ + int show_header = 1; + int i; + + if (count < 0){ + count = -count; + show_header = 0; + } + + for (i = 0; i < count; i++){ + if (show_header) + if ((i % 16) == 0) + printf ("\n0x%08x: ", (unsigned char) base + i); + + printf ("%02x ", (unsigned char) (buffer [i])); + } + fflush (stdout); +} +#endif + /** * @mh: The Method header * @ptr: Points to the beginning of the Section Data (25.3) */ static void -parse_section_data (MonoMetaMethodHeader *mh, const char *ptr) +parse_section_data (MonoMethodHeader *mh, const unsigned char *ptr) { -#if 0 - while ((*ptr) & METHOD_HEADER_SECTION_MORE_SECTS){ + unsigned char sect_data_flags; + const unsigned char *sptr; + int is_fat; + guint32 sect_data_len; + + while (1) { /* align on 32-bit boundary */ /* FIXME: not 64-bit clean code */ - ptr = dword_align (ptr); - + sptr = ptr = dword_align (ptr); sect_data_flags = *ptr; ptr++; - if (sect_data_flags & METHOD_HEADER_SECTION_MORE_SECTS){ - g_error ("Can not deal with more sections"); + is_fat = sect_data_flags & METHOD_HEADER_SECTION_FAT_FORMAT; + if (is_fat) { + sect_data_len = (ptr [2] << 16) | (ptr [1] << 8) | ptr [0]; + ptr += 3; + } else { + sect_data_len = ptr [0]; + ++ptr; } + /* + g_print ("flags: %02x, len: %d\n", sect_data_flags, sect_data_len); + hex_dump (sptr, 0, sect_data_len+8); + g_print ("\nheader: "); + hex_dump (sptr-4, 0, 4); + g_print ("\n"); + */ - if (sect_data_flags & METHOD_HEADER_SECTION_FAT_FORMAT){ - sect_data_len = + if (sect_data_flags & METHOD_HEADER_SECTION_EHTABLE) { + const unsigned char *p = dword_align (ptr); + int i; + mh->num_clauses = is_fat ? sect_data_len / 24: sect_data_len / 12; + /* we could just store a pointer if we don't need to byteswap */ + mh->clauses = g_new0 (MonoExceptionClause, mh->num_clauses); + for (i = 0; i < mh->num_clauses; ++i) { + MonoExceptionClause *ec = &mh->clauses [i]; + + if (is_fat) { + /* we could memcpy and byteswap */ + ec->flags = read32 (p); + p += 4; + ec->try_offset = read32 (p); + p += 4; + ec->try_len = read32 (p); + p += 4; + ec->handler_offset = read32 (p); + p += 4; + ec->handler_len = read32 (p); + p += 4; + ec->token_or_filter = read32 (p); + p += 4; } else { - sect_data_len = ptr [0]; - ptr++; + ec->flags = read16 (p); + p += 2; + ec->try_offset = read16 (p); + p += 2; + ec->try_len = *p; + ++p; + ec->handler_offset = read16 (p); + p += 2; + ec->handler_len = *p; + ++p; + ec->token_or_filter = read32 (p); + p += 4; } - - if (!(sect_data_flags & METHOD_HEADER_SECTION_EHTABLE)) - return mh; - - ptr = dword_align (ptr); + /* g_print ("try %d: %x %04x-%04x %04x\n", i, ec->flags, ec->try_offset, ec->try_offset+ec->try_len, ec->try_len); */ + } + + } + if (sect_data_flags & METHOD_HEADER_SECTION_MORE_SECTS) + ptr += sect_data_len - 4; /* LAMESPEC: it seems the size includes the header */ + else + return; } -#endif } -MonoMetaMethodHeader * -mono_metadata_parse_mh (metadata_t *m, const char *ptr) +/* + * mono_metadata_parse_mh: + * @m: metadata context + * @ptr: pointer to the method header. + * + * Decode the method header at @ptr, including pointer to the IL code, + * info about local variables and optional exception tables. + * + * Returns: a MonoMethodHeader. + */ +MonoMethodHeader * +mono_metadata_parse_mh (MonoImage *m, const char *ptr) { - MonoMetaMethodHeader *mh; - unsigned char flags = *(unsigned char *) ptr; + MonoMethodHeader *mh; + unsigned char flags = *(const unsigned char *) ptr; unsigned char format = flags & METHOD_HEADER_FORMAT_MASK; guint16 fat_flags; + guint32 local_var_sig_tok, max_stack, code_size, init_locals; + const unsigned char *code; int hsize; g_return_val_if_fail (ptr != NULL, NULL); - mh = g_new0 (MonoMetaMethodHeader, 1); switch (format){ case METHOD_HEADER_TINY_FORMAT: + mh = g_new0 (MonoMethodHeader, 1); ptr++; mh->max_stack = 8; - mh->local_var_sig_tok = 0; + local_var_sig_tok = 0; mh->code_size = flags >> 2; mh->code = ptr; - break; - + return mh; case METHOD_HEADER_TINY_FORMAT1: + mh = g_new0 (MonoMethodHeader, 1); ptr++; mh->max_stack = 8; - mh->local_var_sig_tok = 0; - mh->code_size = flags >> 3; + local_var_sig_tok = 0; + + /* + * The spec claims 3 bits, but the Beta2 is + * incorrect + */ + mh->code_size = flags >> 2; mh->code = ptr; - break; - + return mh; case METHOD_HEADER_FAT_FORMAT: fat_flags = read16 (ptr); ptr += 2; hsize = (fat_flags >> 12) & 0xf; - mh->max_stack = *(guint16 *) ptr; + max_stack = read16 (ptr); ptr += 2; - mh->code_size = *(guint32 *) ptr; + code_size = read32 (ptr); ptr += 4; - mh->local_var_sig_tok = *(guint32 *) ptr; + local_var_sig_tok = read32 (ptr); ptr += 4; if (fat_flags & METHOD_HEADER_INIT_LOCALS) - mh->init_locals = 1; + init_locals = 1; else - mh->init_locals = 0; + init_locals = 0; - mh->code = ptr; + code = ptr; if (!(fat_flags & METHOD_HEADER_MORE_SECTS)) break; @@ -1239,55 +1553,1038 @@ mono_metadata_parse_mh (metadata_t *m, const char *ptr) /* * There are more sections */ - ptr = mh->code + mh->code_size; + ptr = code + code_size; - parse_section_data (mh, ptr); break; default: - g_free (mh); return NULL; } - if (mh->local_var_sig_tok) { - metadata_tableinfo_t *t = &m->tables [META_TABLE_STANDALONESIG]; - const char *ptr; - guint32 cols[1]; + if (local_var_sig_tok) { + MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG]; + const char *locals_ptr; + guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE]; int len=0, i, bsize; - mono_metadata_decode_row (t, (mh->local_var_sig_tok & 0xffffff)-1, cols, 1); - ptr = mono_metadata_blob_heap (m, cols [0]); - ptr = mono_metadata_decode_blob_size (ptr, &bsize); - if (*ptr != 0x07) + mono_metadata_decode_row (t, (local_var_sig_tok & 0xffffff)-1, cols, 1); + locals_ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONE_SIGNATURE]); + bsize = mono_metadata_decode_blob_size (locals_ptr, &locals_ptr); + if (*locals_ptr != 0x07) g_warning ("wrong signature for locals blob"); - ptr++; - ptr = mono_metadata_decode_value (ptr, &len); + locals_ptr++; + len = mono_metadata_decode_value (locals_ptr, &locals_ptr); + mh = g_malloc0 (sizeof (MonoMethodHeader) + (len - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*)); mh->num_locals = len; - mh->locals = g_new (MonoType*, len); - for (i = 0; i < len; ++i) { - int val; - const char *p = ptr; - ptr = mono_metadata_decode_blob_size (ptr, &val); - /* FIXME: store pinned/byref values */ - if (val == ELEMENT_TYPE_PINNED) { - p = ptr; - ptr = mono_metadata_decode_blob_size (ptr, &val); - } - if (val == ELEMENT_TYPE_BYREF) { - p = ptr; - } - mh->locals [i] = mono_metadata_parse_type (m, p, &ptr); - } + for (i = 0; i < len; ++i) + mh->locals [i] = mono_metadata_parse_type (m, MONO_PARSE_LOCAL, 0, locals_ptr, &locals_ptr); + } else { + mh = g_new0 (MonoMethodHeader, 1); } + mh->code = code; + mh->code_size = code_size; + mh->max_stack = max_stack; + mh->init_locals = init_locals; + if (fat_flags & METHOD_HEADER_MORE_SECTS) + parse_section_data (mh, (const unsigned char*)ptr); return mh; } +/* + * mono_metadata_free_mh: + * @mh: a method header + * + * Free the memory allocated for the method header. + */ void -mono_metadata_free_mh (MonoMetaMethodHeader *mh) +mono_metadata_free_mh (MonoMethodHeader *mh) { int i; for (i = 0; i < mh->num_locals; ++i) mono_metadata_free_type (mh->locals[i]); - g_free (mh->locals); + g_free (mh->clauses); g_free (mh); } + +/** + * mono_metadata_parse_field_type: + * @m: metadata context to extract information from + * @ptr: pointer to the field signature + * @rptr: pointer updated to match the end of the decoded stream + * + * Parses the field signature, and returns the type information for it. + * + * Returns: The MonoType that was extracted from @ptr. + */ +MonoType * +mono_metadata_parse_field_type (MonoImage *m, short field_flags, const char *ptr, const char **rptr) +{ + return mono_metadata_parse_type (m, MONO_PARSE_FIELD, field_flags, ptr, rptr); +} + +/** + * mono_metadata_parse_param: + * @m: metadata context to extract information from + * @ptr: pointer to the param signature + * @rptr: pointer updated to match the end of the decoded stream + * + * Parses the param signature, and returns the type information for it. + * + * Returns: The MonoType that was extracted from @ptr. + */ +MonoType * +mono_metadata_parse_param (MonoImage *m, const char *ptr, const char **rptr) +{ + return mono_metadata_parse_type (m, MONO_PARSE_PARAM, 0, ptr, rptr); +} + +/* + * mono_metadata_token_from_dor: + * @dor_token: A TypeDefOrRef coded index + * + * dor_token is a TypeDefOrRef coded index: it contains either + * a TypeDef, TypeRef or TypeSpec in the lower bits, and the upper + * bits contain an index into the table. + * + * Returns: an expanded token + */ +guint32 +mono_metadata_token_from_dor (guint32 dor_index) +{ + guint32 table, idx; + + table = dor_index & 0x03; + idx = dor_index >> 2; + + switch (table){ + case 0: /* TypeDef */ + return MONO_TOKEN_TYPE_DEF | idx; + + case 1: /* TypeRef */ + return MONO_TOKEN_TYPE_REF | idx; + + case 2: /* TypeSpec */ + return MONO_TOKEN_TYPE_SPEC | idx; + + default: + g_assert_not_reached (); + } + + return 0; +} + +/* + * We use this to pass context information to the row locator + */ +typedef struct { + int idx; /* The index that we are trying to locate */ + int col_idx; /* The index in the row where idx may be stored */ + MonoTableInfo *t; /* pointer to the table */ + guint32 result; +} locator_t; + +#define CSIZE(x) (sizeof (x) / 4) + +/* + * How the row locator works. + * + * Table A + * ___|___ + * ___|___ Table B + * ___|___------> _______ + * ___|___ _______ + * + * A column in the rows of table A references an index in table B. + * For example A may be the TYPEDEF table and B the METHODDEF table. + * + * Given an index in table B we want to get the row in table A + * where the column n references our index in B. + * + * In the locator_t structure: + * t is table A + * col_idx is the column number + * index is the index in table B + * result will be the index in table A + * + * Examples: + * Table A Table B column (in table A) + * TYPEDEF METHODDEF MONO_TYPEDEF_METHOD_LIST + * TYPEDEF FIELD MONO_TYPEDEF_FIELD_LIST + * PROPERTYMAP PROPERTY MONO_PROPERTY_MAP_PROPERTY_LIST + * INTERFIMPL TYPEDEF MONO_INTERFACEIMPL_CLASS + * METHODSEM PROPERTY ASSOCIATION (encoded index) + * + * Note that we still don't support encoded indexes. + * + */ +static int +typedef_locator (const void *a, const void *b) +{ + locator_t *loc = (locator_t *) a; + const char *bb = (const char *) b; + int typedef_index = (bb - loc->t->base) / loc->t->row_size; + guint32 col, col_next; + + col = mono_metadata_decode_row_col (loc->t, typedef_index, loc->col_idx); + + if (loc->idx < col) + return -1; + + /* + * Need to check that the next row is valid. + */ + if (typedef_index + 1 < loc->t->rows) { + col_next = mono_metadata_decode_row_col (loc->t, typedef_index + 1, loc->col_idx); + if (loc->idx >= col_next) + return 1; + + if (col == col_next) + return 1; + } + + loc->result = typedef_index; + + return 0; +} + +static int +table_locator (const void *a, const void *b) +{ + locator_t *loc = (locator_t *) a; + const char *bb = (const char *) b; + guint32 table_index = (bb - loc->t->base) / loc->t->row_size; + guint32 col; + + col = mono_metadata_decode_row_col (loc->t, table_index, loc->col_idx); + + if (loc->idx == col) { + loc->result = table_index; + return 0; + } + if (loc->idx < col) + return -1; + else + return 1; +} + +/* + * mono_metadata_typedef_from_field: + * @meta: metadata context + * @index: FieldDef token + * + * Returns the 1-based index into the TypeDef table of the type that + * declared the field described by @index. + * Returns 0 if not found. + */ +guint32 +mono_metadata_typedef_from_field (MonoImage *meta, guint32 index) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF]; + locator_t loc; + + if (!tdef->base) + return 0; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_TYPEDEF_FIELD_LIST; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, typedef_locator)) + g_assert_not_reached (); + + /* loc_result is 0..1, needs to be mapped to table index (that is +1) */ + return loc.result + 1; +} + +/* + * mono_metadata_typedef_from_method: + * @meta: metadata context + * @index: MethodDef token + * + * Returns the 1-based index into the TypeDef table of the type that + * declared the method described by @index. + * Returns 0 if not found. + */ +guint32 +mono_metadata_typedef_from_method (MonoImage *meta, guint32 index) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF]; + locator_t loc; + + if (!tdef->base) + return 0; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_TYPEDEF_METHOD_LIST; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, typedef_locator)) + g_assert_not_reached (); + + /* loc_result is 0..1, needs to be mapped to table index (that is +1) */ + return loc.result + 1; +} + +/* + * mono_metadata_interfaces_from_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns and array of interfaces that the @index typedef token implements. + * The number of elemnts in the array is returned in @count. + */ +MonoClass** +mono_metadata_interfaces_from_typedef (MonoImage *meta, guint32 index, guint *count) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_INTERFACEIMPL]; + locator_t loc; + guint32 start, i; + guint32 cols [MONO_INTERFACEIMPL_SIZE]; + MonoClass **result; + + *count = 0; + + if (!tdef->base) + return NULL; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_INTERFACEIMPL_CLASS; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return NULL; + + start = loc.result; + /* + * We may end up in the middle of the rows... + */ + while (start > 0) { + if (loc.idx == mono_metadata_decode_row_col (tdef, start - 1, MONO_INTERFACEIMPL_CLASS)) + start--; + else + break; + } + result = NULL; + i = 0; + while (start < tdef->rows) { + mono_metadata_decode_row (tdef, start, cols, MONO_INTERFACEIMPL_SIZE); + if (cols [MONO_INTERFACEIMPL_CLASS] != loc.idx) + break; + result = g_renew (MonoClass*, result, i + 1); + result [i] = mono_class_get (meta, mono_metadata_token_from_dor (cols [MONO_INTERFACEIMPL_INTERFACE])); + *count = ++i; + ++start; + } + return result; +} + +/* + * mono_metadata_nested_in_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns: the 1-based index into the TypeDef table of the type + * where the type described by @index is nested. + * Retruns 0 if @index describes a non-nested type. + */ +guint32 +mono_metadata_nested_in_typedef (MonoImage *meta, guint32 index) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_NESTEDCLASS]; + locator_t loc; + + if (!tdef->base) + return 0; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_NESTED_CLASS_NESTED; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + /* loc_result is 0..1, needs to be mapped to table index (that is +1) */ + return mono_metadata_decode_row_col (tdef, loc.result, MONO_NESTED_CLASS_ENCLOSING) | MONO_TOKEN_TYPE_DEF; +} + +/* + * mono_metadata_nesting_typedef: + * @meta: metadata context + * @index: typedef token + * + * Returns: the 1-based index into the TypeDef table of the first type + * that is nested inside the type described by @index. + * Retruns 0 if @index doesn't have nested types. + */ +guint32 +mono_metadata_nesting_typedef (MonoImage *meta, guint32 index) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_NESTEDCLASS]; + locator_t loc; + guint32 start; + + if (!tdef->base) + return 0; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_NESTED_CLASS_ENCLOSING; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + start = loc.result; + + while (start > 0) { + if (loc.idx == mono_metadata_decode_row_col (tdef, start - 1, MONO_NESTED_CLASS_ENCLOSING)) + start--; + else + break; + } + + /* loc_result is 0..1, needs to be mapped to table index (that is +1) */ + return start + 1; +} + +/* + * mono_metadata_packing_from_typedef: + * @meta: metadata context + * @index: token representing a type + * + * Returns the info stored in the ClassLAyout table for the given typedef token + * into the @packing and @size pointers. + * Returns 0 if the info is not found. + */ +guint32 +mono_metadata_packing_from_typedef (MonoImage *meta, guint32 index, guint32 *packing, guint32 *size) +{ + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_CLASSLAYOUT]; + locator_t loc; + guint32 cols [MONO_CLASS_LAYOUT_SIZE]; + + if (!tdef->base) + return 0; + + loc.idx = mono_metadata_token_index (index); + loc.col_idx = MONO_CLASS_LAYOUT_PARENT; + loc.t = tdef; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + mono_metadata_decode_row (tdef, loc.result, cols, MONO_CLASS_LAYOUT_SIZE); + if (packing) + *packing = cols [MONO_CLASS_LAYOUT_PACKING_SIZE]; + if (size) + *size = cols [MONO_CLASS_LAYOUT_CLASS_SIZE]; + + /* loc_result is 0..1, needs to be mapped to table index (that is +1) */ + return loc.result + 1; +} + +#ifndef __GNUC__ +#define __alignof__(a) sizeof(a) +#endif + +/* + * mono_type_size: + * @t: the type to return the size of + * + * Returns: the number of bytes required to hold an instance of this + * type in memory + */ +int +mono_type_size (MonoType *t, gint *align) +{ + if (!t) { + *align = 1; + return 0; + } + if (t->byref) { + *align = __alignof__(gpointer); + return sizeof (gpointer); + } + + switch (t->type){ + case MONO_TYPE_VOID: + *align = 1; + return 0; + case MONO_TYPE_BOOLEAN: + *align = __alignof__(char); + return sizeof (char); + + case MONO_TYPE_CHAR: + *align = __alignof__(short); + return sizeof (short); + + case MONO_TYPE_I1: + case MONO_TYPE_U1: + *align = __alignof__(char); + return 1; + + case MONO_TYPE_I2: + case MONO_TYPE_U2: + *align = __alignof__(gint16); + return 2; + + case MONO_TYPE_I4: + case MONO_TYPE_U4: + *align = __alignof__(gint32); + return 4; + case MONO_TYPE_R4: + *align = __alignof__(float); + return 4; + + case MONO_TYPE_I8: + case MONO_TYPE_U8: + *align = __alignof__(gint64); + case MONO_TYPE_R8: + *align = __alignof__(double); + return 8; + + case MONO_TYPE_I: + case MONO_TYPE_U: + *align = __alignof__(gpointer); + return sizeof (gpointer); + + case MONO_TYPE_STRING: + *align = __alignof__(gpointer); + return sizeof (gpointer); + + case MONO_TYPE_OBJECT: + *align = __alignof__(gpointer); + return sizeof (gpointer); + + case MONO_TYPE_VALUETYPE: { + guint32 size; + + if (!t->data.klass->size_inited) + mono_class_init (t->data.klass); + + if (t->data.klass->enumtype) { + return mono_type_size (t->data.klass->enum_basetype, align); + } else { + size = mono_class_value_size (t->data.klass, align); + return size; + } + } + case MONO_TYPE_CLASS: + case MONO_TYPE_SZARRAY: + case MONO_TYPE_PTR: + case MONO_TYPE_FNPTR: + case MONO_TYPE_ARRAY: + case MONO_TYPE_TYPEDBYREF: /* we may want to use a struct {MonoType* type, void *data } instead ...*/ + *align = __alignof__(gpointer); + return sizeof (gpointer); + default: + g_error ("type 0x%02x unknown", t->type); + } + return 0; +} + +/* + * mono_type_stack_size: + * @t: the type to return the size it uses on the stack + * + * Returns: the number of bytes required to hold an instance of this + * type on the runtime stack + */ +int +mono_type_stack_size (MonoType *t, gint *align) +{ + g_assert (t != NULL); + + if (t->byref) { + *align = __alignof__(gpointer); + return sizeof (gpointer); + } + + switch (t->type){ + case MONO_TYPE_BOOLEAN: + case MONO_TYPE_CHAR: + case MONO_TYPE_I1: + case MONO_TYPE_U1: + case MONO_TYPE_I2: + case MONO_TYPE_U2: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_STRING: + case MONO_TYPE_OBJECT: + case MONO_TYPE_CLASS: + case MONO_TYPE_SZARRAY: + case MONO_TYPE_PTR: + case MONO_TYPE_FNPTR: + case MONO_TYPE_ARRAY: + case MONO_TYPE_TYPEDBYREF: + *align = __alignof__(gpointer); + return sizeof (gpointer); + case MONO_TYPE_R4: + *align = __alignof__(float); + return 4; + + case MONO_TYPE_I8: + case MONO_TYPE_U8: + *align = __alignof__(gint64); + case MONO_TYPE_R8: + *align = __alignof__(double); + return 8; + + case MONO_TYPE_VALUETYPE: { + guint32 size; + + if (t->data.klass->enumtype) + return mono_type_stack_size (t->data.klass->enum_basetype, align); + else { + size = mono_class_value_size (t->data.klass, align); + *align = __alignof__(gpointer); + return size; + } + } + default: + g_error ("type 0x%02x unknown", t->type); + } + return 0; +} + +/* + * mono_metadata_type_hash: + * @t1: a type + * + * Computes an hash value for @t1 to be used in GHashTable. + */ +guint +mono_metadata_type_hash (MonoType *t1) +{ + guint hash = t1->type; + + hash |= t1->byref << 6; /* do not collide with t1->type values */ + switch (t1->type) { + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_CLASS: + /* check if the distribution is good enough */ + return hash << 7 | g_str_hash (t1->data.klass->name); + case MONO_TYPE_PTR: + case MONO_TYPE_SZARRAY: + return hash << 7 | mono_metadata_type_hash (t1->data.type); + } + return hash; +} + +/* + * mono_metadata_type_equal: + * @t1: a type + * @t2: another type + * + * Determine if @t1 and @t2 represent the same type. + * Returns: #TRUE if @t1 and @t2 are equal. + */ +gboolean +mono_metadata_type_equal (MonoType *t1, MonoType *t2) +{ + if (t1->type != t2->type || + t1->byref != t2->byref) + return FALSE; + + switch (t1->type) { + case MONO_TYPE_VOID: + case MONO_TYPE_BOOLEAN: + case MONO_TYPE_CHAR: + case MONO_TYPE_I1: + case MONO_TYPE_U1: + case MONO_TYPE_I2: + case MONO_TYPE_U2: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + case MONO_TYPE_I8: + case MONO_TYPE_U8: + case MONO_TYPE_R4: + case MONO_TYPE_R8: + case MONO_TYPE_STRING: + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_OBJECT: + return TRUE; + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_CLASS: + return t1->data.klass == t2->data.klass; + case MONO_TYPE_PTR: + case MONO_TYPE_SZARRAY: + return mono_metadata_type_equal (t1->data.type, t2->data.type); + case MONO_TYPE_ARRAY: + if (t1->data.array->rank != t2->data.array->rank) + return FALSE; + return mono_metadata_type_equal (t1->data.array->type, t2->data.array->type); + default: + g_error ("implement type compare for %0x!", t1->type); + return FALSE; + } + + return FALSE; +} + +/* + * mono_metadata_signature_equal: + * @sig1: a signature + * @sig2: another signature + * + * Determine if @sig1 and @sig2 represent the same signature, with the + * same number of arguments and the same types. + * Returns: #TRUE if @sig1 and @sig2 are equal. + */ +gboolean +mono_metadata_signature_equal (MonoMethodSignature *sig1, MonoMethodSignature *sig2) +{ + int i; + + if (sig1->hasthis != sig2->hasthis || + sig1->param_count != sig2->param_count) + return FALSE; + + for (i = 0; i < sig1->param_count; i++) { + MonoType *p1 = sig1->params[i]; + MonoType *p2 = sig2->params[i]; + + if (p1->attrs != p2->attrs) + return FALSE; + + if (!mono_metadata_type_equal (p1, p2)) + return FALSE; + } + + if (!mono_metadata_type_equal (sig1->ret, sig2->ret)) + return FALSE; + return TRUE; +} + +/* + * mono_metadata_encode_value: + * @value: value to encode + * @buf: buffer where to write the compressed representation + * @endbuf: pointer updated to point at the end of the encoded output + * + * Encodes the value @value in the compressed representation used + * in metadata and stores the result in @buf. @buf needs to be big + * enough to hold the data (4 bytes). + */ +void +mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) +{ + char *p = buf; + + if (value <= 127) + *p++ = value; + else if (value <= 16384) { + p [0] = 0x80 | (value >> 8); + p [1] = value & 0xff; + p += 2; + } else { + p [0] = (value >> 24) | 0xc0; + p [1] = (value >> 16) & 0xff; + p [2] = (value >> 8) & 0xff; + p [3] = value & 0xff; + p += 4; + } + if (endbuf) + *endbuf = p; +} + +/* + * mono_metadata_field_info: + * @meta: the Image the field is defined in + * @index: the index in the field table representing the field + * @offset: a pointer to an integer where to store the offset that + * may have been specified for the field in a FieldLayout table + * @rva: a pointer to the RVA of the field data in the image that + * may have been defined in a FieldRVA table + * @marshal_info: a pointer to the marshal signature that may have been + * defined for the field in a FieldMarshal table. + * + * Gather info for field @index that may have been defined in the FieldLayout, + * FieldRVA and FieldMarshal tables. + * Either of offset, rva and marshal_info can be NULL if you're not interested + * in the data. + */ +void +mono_metadata_field_info (MonoImage *meta, guint32 index, guint32 *offset, guint32 *rva, const char **marshal_info) +{ + MonoTableInfo *tdef; + locator_t loc; + + loc.idx = index + 1; + if (offset) { + tdef = &meta->tables [MONO_TABLE_FIELDLAYOUT]; + + loc.col_idx = MONO_FIELD_LAYOUT_FIELD; + loc.t = tdef; + + if (tdef->base && bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) { + *offset = mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_LAYOUT_OFFSET); + } else { + *offset = (guint32)-1; + } + } + if (rva) { + tdef = &meta->tables [MONO_TABLE_FIELDRVA]; + + loc.col_idx = MONO_FIELD_RVA_FIELD; + loc.t = tdef; + + if (tdef->base && bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) { + /* + * LAMESPEC: There is no signature, no nothing, just the raw data. + */ + *rva = mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_RVA_RVA); + } else { + *rva = 0; + } + } + +} + +/* + * mono_metadata_get_constant_index: + * @meta: the Image the field is defined in + * @index: the token that may have a row defined in the constants table + * + * @token must be a FieldDef, ParamDef or PropertyDef token. + * + * Returns: the index into the Constsnts table or 0 if not found. + */ +guint32 +mono_metadata_get_constant_index (MonoImage *meta, guint32 token) +{ + MonoTableInfo *tdef; + locator_t loc; + guint32 index = mono_metadata_token_index (token); + + tdef = &meta->tables [MONO_TABLE_CONSTANT]; + index <<= HASCONSTANT_BITS; + switch (mono_metadata_token_table (token)) { + case MONO_TABLE_FIELD: + index |= HASCONSTANT_FIEDDEF; + break; + case MONO_TABLE_PARAM: + index |= HASCONSTANT_PARAM; + break; + case MONO_TABLE_PROPERTY: + index |= HASCONSTANT_PROPERTY; + break; + default: + g_warning ("Not a valid token for the constant table: 0x%08x", token); + return 0; + } + loc.idx = index; + loc.col_idx = MONO_CONSTANT_PARENT; + loc.t = tdef; + + if (tdef->base && bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) { + return loc.result + 1; + } + return 0; +} + +/* + * mono_metadata_events_from_typedef: + * @meta: metadata context + * @index: 0-based index (in the TypeDef table) describing a type + * + * Returns: the 0-based index in the Event table for the events in the + * type. The last event that belongs to the type (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_events_from_typedef (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint32 start, end; + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_EVENTMAP]; + + *end_idx = 0; + + if (!tdef->base) + return 0; + + loc.t = tdef; + loc.col_idx = MONO_EVENT_MAP_PARENT; + loc.idx = index + 1; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + start = mono_metadata_decode_row_col (tdef, loc.result, MONO_EVENT_MAP_EVENTLIST); + if (loc.result + 1 < tdef->rows) { + end = mono_metadata_decode_row_col (tdef, loc.result + 1, MONO_EVENT_MAP_EVENTLIST) - 1; + } else { + end = meta->tables [MONO_TABLE_EVENT].rows; + } + + *end_idx = end; + return start - 1; +} + +/* + * mono_metadata_methods_from_event: + * @meta: metadata context + * @index: 0-based index (in the Event table) describing a event + * + * Returns: the 0-based index in the MethodDef table for the methods in the + * event. The last method that belongs to the event (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_methods_from_event (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint start, end; + guint32 cols [MONO_METHOD_SEMA_SIZE]; + MonoTableInfo *msemt = &meta->tables [MONO_TABLE_METHODSEMANTICS]; + + *end_idx = 0; + if (!msemt->base) + return 0; + + loc.t = msemt; + loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION; + loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT; /* Method association coded index */ + + if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator)) + return 0; + + start = loc.result; + /* + * We may end up in the middle of the rows... + */ + while (start > 0) { + if (loc.idx == mono_metadata_decode_row_col (msemt, start - 1, MONO_METHOD_SEMA_ASSOCIATION)) + start--; + else + break; + } + end = start + 1; + while (end < msemt->rows) { + mono_metadata_decode_row (msemt, end, cols, MONO_METHOD_SEMA_SIZE); + if (cols [MONO_METHOD_SEMA_ASSOCIATION] != loc.idx) + break; + ++end; + } + *end_idx = end; + return start; +} + +/* + * mono_metadata_properties_from_typedef: + * @meta: metadata context + * @index: 0-based index (in the TypeDef table) describing a type + * + * Returns: the 0-based index in the Property table for the properties in the + * type. The last property that belongs to the type (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_properties_from_typedef (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint32 start, end; + MonoTableInfo *tdef = &meta->tables [MONO_TABLE_PROPERTYMAP]; + + *end_idx = 0; + + if (!tdef->base) + return 0; + + loc.t = tdef; + loc.col_idx = MONO_PROPERTY_MAP_PARENT; + loc.idx = index + 1; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return 0; + + start = mono_metadata_decode_row_col (tdef, loc.result, MONO_PROPERTY_MAP_PROPERTY_LIST); + if (loc.result + 1 < tdef->rows) { + end = mono_metadata_decode_row_col (tdef, loc.result + 1, MONO_PROPERTY_MAP_PROPERTY_LIST) - 1; + } else { + end = meta->tables [MONO_TABLE_PROPERTY].rows; + } + + *end_idx = end; + return start - 1; +} + +/* + * mono_metadata_methods_from_property: + * @meta: metadata context + * @index: 0-based index (in the PropertyDef table) describing a property + * + * Returns: the 0-based index in the MethodDef table for the methods in the + * property. The last method that belongs to the property (plus 1) is stored + * in the @end_idx pointer. + */ +guint32 +mono_metadata_methods_from_property (MonoImage *meta, guint32 index, guint *end_idx) +{ + locator_t loc; + guint start, end; + guint32 cols [MONO_METHOD_SEMA_SIZE]; + MonoTableInfo *msemt = &meta->tables [MONO_TABLE_METHODSEMANTICS]; + + *end_idx = 0; + if (!msemt->base) + return 0; + + loc.t = msemt; + loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION; + loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_PROPERTY; /* Method association coded index */ + + if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator)) + return 0; + + start = loc.result; + /* + * We may end up in the middle of the rows... + */ + while (start > 0) { + if (loc.idx == mono_metadata_decode_row_col (msemt, start - 1, MONO_METHOD_SEMA_ASSOCIATION)) + start--; + else + break; + } + end = start + 1; + while (end < msemt->rows) { + mono_metadata_decode_row (msemt, end, cols, MONO_METHOD_SEMA_SIZE); + if (cols [MONO_METHOD_SEMA_ASSOCIATION] != loc.idx) + break; + ++end; + } + *end_idx = end; + return start; +} + +/** + * @image: context where the image is created + * @type_spec: typespec token + * + * Creates a MonoType representing the TypeSpec indexed by the @type_spec + * token. + */ +MonoType * +mono_type_create_from_typespec (MonoImage *image, guint32 type_spec) +{ + guint32 idx = mono_metadata_token_index (type_spec); + MonoTableInfo *t; + guint32 cols [MONO_TYPESPEC_SIZE]; + const char *ptr; + guint32 len; + MonoType *type; + + t = &image->tables [MONO_TABLE_TYPESPEC]; + + mono_metadata_decode_row (t, idx-1, cols, MONO_TYPESPEC_SIZE); + ptr = mono_metadata_blob_heap (image, cols [MONO_TYPESPEC_SIGNATURE]); + len = mono_metadata_decode_value (ptr, &ptr); + type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr); + + return type; +} +