X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=mono%2Fmetadata%2Fmetadata.c;h=b8f76940171b07b4a0c2abf43bda820ed8ea7718;hb=b8e5e458a9cb96685f8ad8f02fc012bcdf4a4cc4;hp=2ede4e850e1262228e4b8822e80d31c59f1919c1;hpb=5a50d5ab47f3fd8a8b0a2d773c89b6ce1edaa32c;p=mono.git diff --git a/mono/metadata/metadata.c b/mono/metadata/metadata.c index 2ede4e850e1..b8f76940171 100644 --- a/mono/metadata/metadata.c +++ b/mono/metadata/metadata.c @@ -19,7 +19,7 @@ #include "private.h" #include "class.h" -static void do_mono_metadata_parse_type (MonoType *type, MonoMetadata *m, const char *ptr, const char **rptr); +static void do_mono_metadata_parse_type (MonoType *type, MonoImage *m, const char *ptr, const char **rptr); /* * Encoding of the "description" argument: @@ -366,8 +366,20 @@ inverse of this mapping. #define idx_size(tableidx) (meta->tables [(tableidx)].rows < 65536 ? 2 : 4) /* Reference: Partition II - 23.2.6 */ +/* + * 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 (MonoMetadata *meta, int tableindex, guint32 *result_bitfield) +mono_metadata_compute_size (MonoImage *meta, int tableindex, guint32 *result_bitfield) { guint32 bitfield = 0; int size = 0, field_size; @@ -501,10 +513,10 @@ mono_metadata_compute_size (MonoMetadata *meta, int tableindex, guint32 *result_ 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); - /* Permission seems to be a blob heap pointer */ + 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); - /* Signature seems to be a blob heap pointer */ + 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); @@ -666,10 +678,10 @@ mono_metadata_compute_size (MonoMetadata *meta, int tableindex, guint32 *result_ * This is an internal function used by the image loader code. */ void -mono_metadata_compute_table_bases (MonoMetadata *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) @@ -691,8 +703,8 @@ mono_metadata_compute_table_bases (MonoMetadata *meta) * Returns a pointer to the @idx element in the metadata table * whose code is @table. */ -char * -mono_metadata_locate (MonoMetadata *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, ""); @@ -700,8 +712,16 @@ mono_metadata_locate (MonoMetadata *meta, int table, int idx) return meta->tables [table].base + (meta->tables [table].row_size * (idx - 1)); } -char * -mono_metadata_locate_token (MonoMetadata *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); } @@ -730,17 +750,24 @@ mono_metadata_get_table (MonoMetaTableEnum table) * Returns: an in-memory pointer to the @index in the string heap. */ const char * -mono_metadata_string_heap (MonoMetadata *meta, guint32 index) +mono_metadata_string_heap (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_strings.size, ""); - return meta->raw_metadata + meta->heap_strings.offset + index; + 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 (MonoMetadata *meta, guint32 index) +mono_metadata_user_string (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_us.size, ""); - return meta->raw_metadata + meta->heap_us.offset + index; + return meta->heap_us.data + index; } /** @@ -751,10 +778,26 @@ mono_metadata_user_string (MonoMetadata *meta, guint32 index) * Returns: an in-memory pointer to the @index in the Blob heap. */ const char * -mono_metadata_blob_heap (MonoMetadata *meta, guint32 index) +mono_metadata_blob_heap (MonoImage *meta, guint32 index) { g_return_val_if_fail (index < meta->heap_blob.size, ""); - return meta->raw_metadata + meta->heap_blob.offset + index; + return meta->heap_blob.data + index; +} + +/** + * 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) +{ + --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 const char * @@ -777,7 +820,7 @@ mono_metadata_decode_row (MonoTableInfo *t, int idx, guint32 *res, int res_size) { guint32 bitfield = t->size_bitfield; int i, count = mono_metadata_table_count (bitfield); - char *data = t->base + idx * t->row_size; + const char *data = t->base + idx * t->row_size; g_assert (res_size == count); @@ -814,7 +857,7 @@ mono_metadata_decode_row_col (MonoTableInfo *t, int idx, guint col) { guint32 bitfield = t->size_bitfield; int i; - register char *data = t->base + idx * t->row_size; + register const char *data = t->base + idx * t->row_size; register int n; g_assert (col < mono_metadata_table_count (bitfield)); @@ -883,7 +926,7 @@ mono_metadata_decode_blob_size (const char *xptr, const char **rptr) 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; @@ -906,8 +949,17 @@ mono_metadata_decode_value (const char *_ptr, const char **rptr) 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 (MonoMetadata *m, const char *ptr, const char **rptr) +mono_metadata_parse_typedef_or_ref (MonoImage *m, const char *ptr, const char **rptr) { guint32 token; token = mono_metadata_decode_value (ptr, &ptr); @@ -916,8 +968,19 @@ mono_metadata_parse_typedef_or_ref (MonoMetadata *m, const char *ptr, const char 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 (MonoMetadata *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 == MONO_TYPE_CMOD_OPT) || @@ -931,8 +994,19 @@ mono_metadata_parse_custom_mod (MonoMetadata *m, MonoCustomMod *dest, const char return FALSE; } +/* + * 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 (MonoMetadata *m, const char *ptr, const char **rptr) +mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr) { int i; MonoArrayType *array = g_new0 (MonoArrayType, 1); @@ -957,6 +1031,12 @@ mono_metadata_parse_array (MonoMetadata *m, const char *ptr, const char **rptr) return array; } +/* + * mono_metadata_free_array: + * @array: array description + * + * Frees the array description returned from mono_metadata_parse_array(). + */ void mono_metadata_free_array (MonoArrayType *array) { @@ -1024,15 +1104,15 @@ static GHashTable *type_cache = NULL; static guint mono_type_hash (gconstpointer data) { - MonoType *type = (MonoType *) 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) { - MonoType *a = (MonoType *) ka; - MonoType *b = (MonoType *) kb; + 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; @@ -1040,8 +1120,24 @@ mono_type_equal (gconstpointer ka, gconstpointer kb) 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 (MonoMetadata *m, MonoParseTypeMode mode, short opt_attrs, const char *ptr, const char **rptr) +mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs, const char *ptr, const char **rptr) { MonoType *type, *cached; @@ -1120,8 +1216,19 @@ mono_metadata_parse_type (MonoMetadata *m, MonoParseTypeMode mode, short opt_att } } +/* + * 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 (MonoMetadata *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; int i; @@ -1164,15 +1271,21 @@ mono_metadata_parse_method_signature (MonoMetadata *m, int def, const char *ptr, 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_type (method->ret); - for (i = 0; i < method->param_count; ++i) - mono_metadata_free_type (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); + g_free (sig); } /* @@ -1190,7 +1303,7 @@ mono_metadata_free_method_signature (MonoMethodSignature *method) * This extracts a Type as specified in Partition II (22.2.12) */ static void -do_mono_metadata_parse_type (MonoType *type, MonoMetadata *m, const char *ptr, const char **rptr) +do_mono_metadata_parse_type (MonoType *type, MonoImage *m, const char *ptr, const char **rptr) { type->type = mono_metadata_decode_value (ptr, &ptr); @@ -1239,28 +1352,12 @@ do_mono_metadata_parse_type (MonoType *type, MonoMetadata *m, const char *ptr, c *rptr = ptr; } -#if 0 -/** - * mono_metadata_parse_type: - * @m: metadata context to scan - * @ptr: pointer to encoded Type stream. - * @rptr: the new position in the stream after parsing the type +/* + * mono_metadata_free_type: + * @type: type to free * - * Returns: A MonoType structure that has the parsed information - * from the type stored at @ptr in the metadata table @m. + * Free the memory allocated for type @type. */ -MonoType * -mono_metadata_parse_type (MonoMetadata *m, const char *ptr, const char **rptr) -{ - /* should probably be allocated in a memchunk */ - MonoType *type = g_new0(MonoType, 1); - - do_mono_metadata_parse_type (type, m, ptr, rptr); - - return type; -} -#endif - void mono_metadata_free_type (MonoType *type) { @@ -1281,6 +1378,7 @@ mono_metadata_free_type (MonoType *type) g_free (type); } +#if 0 static void hex_dump (const char *buffer, int base, int count) { @@ -1301,6 +1399,7 @@ hex_dump (const char *buffer, int base, int count) } fflush (stdout); } +#endif /** * @mh: The Method header @@ -1385,11 +1484,21 @@ parse_section_data (MonoMethodHeader *mh, const unsigned 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 (MonoMetadata *m, const char *ptr) +mono_metadata_parse_mh (MonoImage *m, const char *ptr) { MonoMethodHeader *mh; - unsigned char flags = *(unsigned char *) ptr; + 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; @@ -1454,21 +1563,21 @@ mono_metadata_parse_mh (MonoMetadata *m, const char *ptr) if (local_var_sig_tok) { MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG]; - const char *ptr; + const char *locals_ptr; guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE]; int len=0, i, bsize; mono_metadata_decode_row (t, (local_var_sig_tok & 0xffffff)-1, cols, 1); - ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONE_SIGNATURE]); - bsize = mono_metadata_decode_blob_size (ptr, &ptr); - if (*ptr != 0x07) + 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++; - len = mono_metadata_decode_value (ptr, &ptr); + 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; for (i = 0; i < len; ++i) - mh->locals [i] = mono_metadata_parse_type (m, MONO_PARSE_LOCAL, 0, ptr, &ptr); + mh->locals [i] = mono_metadata_parse_type (m, MONO_PARSE_LOCAL, 0, locals_ptr, &locals_ptr); } else { mh = g_new0 (MonoMethodHeader, 1); } @@ -1481,6 +1590,12 @@ mono_metadata_parse_mh (MonoMetadata *m, const 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 (MonoMethodHeader *mh) { @@ -1495,19 +1610,30 @@ mono_metadata_free_mh (MonoMethodHeader *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 (MonoMetadata *m, short field_flags, const char *ptr, const char **rptr) +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 (MonoMetadata *m, const char *ptr, const char **rptr) +mono_metadata_parse_param (MonoImage *m, const char *ptr, const char **rptr) { return mono_metadata_parse_type (m, MONO_PARSE_PARAM, 0, ptr, rptr); } @@ -1595,7 +1721,7 @@ static int typedef_locator (const void *a, const void *b) { locator_t *loc = (locator_t *) a; - char *bb = (char *) b; + const char *bb = (const char *) b; int typedef_index = (bb - loc->t->base) / loc->t->row_size; guint32 col, col_next; @@ -1625,7 +1751,7 @@ static int table_locator (const void *a, const void *b) { locator_t *loc = (locator_t *) a; - char *bb = (char *) b; + const char *bb = (const char *) b; guint32 table_index = (bb - loc->t->base) / loc->t->row_size; guint32 col; @@ -1641,8 +1767,17 @@ table_locator (const void *a, const void *b) 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 (MonoMetadata *meta, guint32 index) +mono_metadata_typedef_from_field (MonoImage *meta, guint32 index) { MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF]; locator_t loc; @@ -1661,8 +1796,17 @@ mono_metadata_typedef_from_field (MonoMetadata *meta, guint32 index) 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 (MonoMetadata *meta, guint32 index) +mono_metadata_typedef_from_method (MonoImage *meta, guint32 index) { MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF]; locator_t loc; @@ -1681,8 +1825,16 @@ mono_metadata_typedef_from_method (MonoMetadata *meta, guint32 index) 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 (MonoMetadata *meta, guint32 index, guint *count) +mono_metadata_interfaces_from_typedef (MonoImage *meta, guint32 index, guint *count) { MonoTableInfo *tdef = &meta->tables [MONO_TABLE_INTERFACEIMPL]; locator_t loc; @@ -1727,11 +1879,16 @@ mono_metadata_interfaces_from_typedef (MonoMetadata *meta, guint32 index, guint } /* - * Return the typedef token of the type index is defined into. - * Return 0 if the index represents a toplevel type. + * 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 (MonoMetadata *meta, guint32 index) +mono_metadata_nested_in_typedef (MonoImage *meta, guint32 index) { MonoTableInfo *tdef = &meta->tables [MONO_TABLE_NESTEDCLASS]; locator_t loc; @@ -1750,6 +1907,81 @@ mono_metadata_nested_in_typedef (MonoMetadata *meta, guint32 index) 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 @@ -1826,8 +2058,15 @@ mono_type_size (MonoType *t, gint *align) case MONO_TYPE_VALUETYPE: { guint32 size; - size = mono_class_value_size (t->data.klass, align); - return 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: @@ -1843,6 +2082,104 @@ mono_type_size (MonoType *t, gint *align) 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) { @@ -1872,8 +2209,13 @@ mono_metadata_type_equal (MonoType *t1, MonoType *t2) 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; @@ -1882,6 +2224,15 @@ mono_metadata_type_equal (MonoType *t1, MonoType *t2) 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) { @@ -1902,9 +2253,21 @@ mono_metadata_signature_equal (MonoMethodSignature *sig1, MonoMethodSignature *s 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) { @@ -1933,7 +2296,7 @@ mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) * @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 address of the field data in the image that + * @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. @@ -1944,7 +2307,7 @@ mono_metadata_encode_value (guint32 value, char *buf, char **endbuf) * in the data. */ void -mono_metadata_field_info (MonoMetadata *meta, guint32 index, guint32 *offset, const char **rva, const char **marshal_info) +mono_metadata_field_info (MonoImage *meta, guint32 index, guint32 *offset, guint32 *rva, const char **marshal_info) { MonoTableInfo *tdef; locator_t loc; @@ -1972,9 +2335,9 @@ mono_metadata_field_info (MonoMetadata *meta, guint32 index, guint32 *offset, co /* * LAMESPEC: There is no signature, no nothing, just the raw data. */ - *rva = mono_cli_rva_map (meta->image_info, mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_RVA_RVA)); + *rva = mono_metadata_decode_row_col (tdef, loc.result, MONO_FIELD_RVA_RVA); } else { - *rva = NULL; + *rva = 0; } } @@ -1990,7 +2353,7 @@ mono_metadata_field_info (MonoMetadata *meta, guint32 index, guint32 *offset, co * Returns: the index into the Constsnts table or 0 if not found. */ guint32 -mono_metadata_get_constant_index (MonoMetadata *meta, guint32 token) +mono_metadata_get_constant_index (MonoImage *meta, guint32 token) { MonoTableInfo *tdef; locator_t loc; @@ -2021,3 +2384,207 @@ mono_metadata_get_constant_index (MonoMetadata *meta, guint32 token) } 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; +} +