From cfd0ebeef7cc4f49e09058b2f03b9746c284bbd1 Mon Sep 17 00:00:00 2001 From: Paolo Molaro Date: Mon, 20 Aug 2001 13:46:59 +0000 Subject: [PATCH] Mon Aug 20 19:33:34 CEST 2001 Paolo Molaro * util.c: add a space when decoding multiple flags. * dump.c, dump.h, main.c: decode the property map and methodsemantics tables. Disassemble property information to .property IL directives. * get.c: allow passing a NULL as method in dis_stringify_method () if a methoddef_row is given. Mon Aug 20 19:39:00 CEST 2001 Paolo Molaro * blob.h: fix MONO_TYPE_TYPEDBYREF value. * cil-coff.h: split MonoMSDOSHeader and add size info. * image.c: add some consistency checks. * metadata.c: fix row size computation: one programmer error and one LAMESPEC. Handle MONO_TYPE_TYPEDBYREF. add explanation for the locator routine. Fix decoding of size in method header. svn path=/trunk/mono/; revision=511 --- mono/dis/ChangeLog | 10 +++ mono/dis/dis-cil.c | 4 +- mono/dis/dump.c | 55 +++++++++++++- mono/dis/dump.h | 2 + mono/dis/get.c | 17 ++++- mono/dis/main.c | 151 +++++++++++++++++++++++++++++++++++++++ mono/dis/util.c | 5 +- mono/metadata/ChangeLog | 10 +++ mono/metadata/blob.h | 2 +- mono/metadata/cil-coff.h | 10 ++- mono/metadata/image.c | 19 ++++- mono/metadata/metadata.c | 53 +++++++++++--- 12 files changed, 320 insertions(+), 18 deletions(-) diff --git a/mono/dis/ChangeLog b/mono/dis/ChangeLog index 8ec4f384cdc..336009718dc 100644 --- a/mono/dis/ChangeLog +++ b/mono/dis/ChangeLog @@ -1,3 +1,13 @@ + +Mon Aug 20 19:33:34 CEST 2001 Paolo Molaro + + * util.c: add a space when decoding multiple flags. + * dump.c, dump.h, main.c: decode the property map and + methodsemantics tables. Disassemble property information + to .property IL directives. + * get.c: allow passing a NULL as method in dis_stringify_method () + if a methoddef_row is given. + 2001-08-20 Dietmar Maurer * get.c (dis_stringify_type): support pinned values diff --git a/mono/dis/dis-cil.c b/mono/dis/dis-cil.c index 6c221e61132..54669a98b5b 100644 --- a/mono/dis/dis-cil.c +++ b/mono/dis/dis-cil.c @@ -77,7 +77,7 @@ get_encoded_user_string (const char *ptr) return res; } -#define CODE_INDENT g_assert (indent_level < 127); \ +#define CODE_INDENT g_assert (indent_level < 512); \ indent[indent_level*2] = ' '; \ indent[indent_level*2+1] = ' '; \ ++indent_level; \ @@ -94,7 +94,7 @@ dissasemble_cil (MonoMetadata *m, MonoMethodHeader *mh) const unsigned char *end = start + size; const unsigned char *ptr = start; opcode_t *entry; - char indent[256]; + char indent[1024]; int i, indent_level = 0; char *clause_names[] = {"catch", "filter", "finally", "fault"}; diff --git a/mono/dis/dump.c b/mono/dis/dump.c index 36395bf4f90..db914cd1791 100644 --- a/mono/dis/dump.c +++ b/mono/dis/dump.c @@ -268,6 +268,25 @@ dump_table_constant (MonoMetadata *m) } +void +dump_table_property_map (MonoMetadata *m) +{ + MonoTableInfo *t = &m->tables [MONO_TABLE_PROPERTYMAP]; + int i; + char *s; + + fprintf (output, "Property Map Table (1..%d)\n", t->rows); + + for (i = 0; i < t->rows; i++){ + guint32 cols [MONO_PROPERTY_MAP_SIZE]; + + mono_metadata_decode_row (t, i, cols, MONO_PROPERTY_MAP_SIZE); + s = get_typedef (m, cols [MONO_PROPERTY_MAP_PARENT]); + fprintf (output, "%d: %s %d\n", i + 1, s, cols [MONO_PROPERTY_MAP_PROPERTY_LIST]); + g_free (s); + } +} + void dump_table_property (MonoMetadata *m) { @@ -276,7 +295,7 @@ dump_table_property (MonoMetadata *m) const char *ptr; char flags[128]; - fprintf (output, "Property Table (0..%d)\n", t->rows); + fprintf (output, "Property Table (1..%d)\n", t->rows); for (i = 0; i < t->rows; i++){ guint32 cols [MONO_PROPERTY_SIZE]; @@ -303,7 +322,7 @@ dump_table_property (MonoMetadata *m) pcount = mono_metadata_decode_value (ptr, &ptr); ptr = get_type (m, ptr, &type); fprintf (output, "%d: %s %s (", - i, type, mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME])); + i + 1, type, mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME])); g_free (type); for (j = 0; j < pcount; j++){ @@ -418,3 +437,35 @@ dump_table_method (MonoMetadata *m) } +static map_t semantics_map [] = { + {1, "setter"}, + {2, "getter"}, + {4, "other"}, + {8, "add-on"}, + {0x10, "remove-on"}, + {0x20, "fire"}, + {0, NULL}, +}; + +void +dump_table_methodsem (MonoMetadata *m) +{ + MonoTableInfo *t = &m->tables [MONO_TABLE_METHODSEMANTICS]; + int i, is_property, index; + const char *semantics; + + fprintf (output, "Method Semantics Table (1..%d)\n", t->rows); + for (i = 1; i <= t->rows; i++){ + guint32 cols [MONO_METHOD_SEMA_SIZE]; + + mono_metadata_decode_row (t, i - 1, cols, MONO_METHOD_SEMA_SIZE); + semantics = flags (cols [MONO_METHOD_SEMA_SEMANTICS], semantics_map); + is_property = cols [MONO_METHOD_SEMA_ASSOCIATION] & 1; + index = cols [MONO_METHOD_SEMA_ASSOCIATION] >> 1; + fprintf (output, "%d: %s method: %d %s %d\n", i, semantics, + cols [MONO_METHOD_SEMA_METHOD] - 1, + is_property? "property" : "event", + index); + } +} + diff --git a/mono/dis/dump.h b/mono/dis/dump.h index 795bc330cb0..e52aa3a0324 100644 --- a/mono/dis/dump.h +++ b/mono/dis/dump.h @@ -5,10 +5,12 @@ void dump_table_assemblyref (MonoMetadata *m); void dump_table_class_layout (MonoMetadata *m); void dump_table_constant (MonoMetadata *m); void dump_table_property (MonoMetadata *m); +void dump_table_property_map (MonoMetadata *m); void dump_table_event (MonoMetadata *m); void dump_table_file (MonoMetadata *m); void dump_table_moduleref (MonoMetadata *m); void dump_table_method (MonoMetadata *m); +void dump_table_methodsem (MonoMetadata *m); void dump_table_field (MonoMetadata *m); void dump_table_memberref (MonoMetadata *m); void dump_table_param (MonoMetadata *m); diff --git a/mono/dis/get.c b/mono/dis/get.c index ce5cb694a08..a6b8acfc8eb 100644 --- a/mono/dis/get.c +++ b/mono/dis/get.c @@ -455,16 +455,26 @@ dis_stringify_method_signature (MonoMetadata *m, MonoMethodSignature *method, in guint32 pcols [MONO_PARAM_SIZE]; guint32 param_index = 0; const char *name = ""; - char *retval = dis_stringify_param (m, method->ret); + int free_method = 0; + char *retval; GString *result = g_string_new (""); int i; + g_assert (method || methoddef_row); + if (methoddef_row) { mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD], methoddef_row -1, cols, MONO_METHOD_SIZE); name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]); param_index = cols [MONO_METHOD_PARAMLIST]; + if (!method) { + const char *sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]); + mono_metadata_decode_blob_size (sig, &sig); + method = mono_metadata_parse_method_signature (m, 1, sig, &sig); + free_method = 1; + } } + retval = dis_stringify_param (m, method->ret); if (method->hasthis) g_string_append (result, "instance "); g_string_append (result, map (method->call_convention, call_conv_type_map)); @@ -487,8 +497,11 @@ dis_stringify_method_signature (MonoMetadata *m, MonoMethodSignature *method, in } g_string_append (result, ") "); + if (free_method) + mono_metadata_free_method_signature (method); retval = result->str; g_string_free (result, FALSE); + return retval; } @@ -1127,6 +1140,8 @@ get_token (MonoMetadata *m, guint32 token) return get_typedef (m, idx); case MONO_TOKEN_TYPE_REF: return get_typeref (m, idx); + case MONO_TOKEN_TYPE_SPEC: + return get_typespec (m, idx); default: g_error ("Do not know how to decode tokens of type 0x%08x", token); } diff --git a/mono/dis/main.c b/mono/dis/main.c index 09903c3a748..88d296285f0 100644 --- a/mono/dis/main.c +++ b/mono/dis/main.c @@ -16,6 +16,7 @@ #include #include #include +#include #include "meta.h" #include "util.h" #include "dump.h" @@ -474,6 +475,152 @@ dis_method_list (MonoMetadata *m, MonoCLIImageInfo *ii, guint32 start, guint32 e } } +typedef struct { + MonoTableInfo *t; + guint32 col_idx; + guint32 idx; + guint32 result; +} plocator_t; + +static int +table_locator (const void *a, const void *b) +{ + plocator_t *loc = (plocator_t *) a; + char *bb = (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; +} + +static void +dis_property_methods (MonoMetadata *m, guint32 prop) +{ + plocator_t loc; + guint start; + guint32 cols [MONO_METHOD_SEMA_SIZE]; + MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS]; + char *sig; + char *type[] = {NULL, ".set", ".get", NULL, ".other"}; + + loc.t = msemt; + loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION; + loc.idx = (prop << 1) | 1; /* Method association coded index */ + + if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator)) + return; + + 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; + } + while (start < msemt->rows) { + mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE); + if (cols [MONO_METHOD_SEMA_ASSOCIATION] != loc.idx) + break; + sig = dis_stringify_method_signature (m, NULL, cols [MONO_METHOD_SEMA_METHOD]); + fprintf (output, "\t\t%s %s\n", type [cols [MONO_METHOD_SEMA_SEMANTICS]], sig); + g_free (sig); + ++start; + } +} + +static char* +dis_property_signature (MonoMetadata *m, guint32 prop_idx) +{ + MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY]; + const char *ptr; + guint32 pcount, i; + guint32 cols [MONO_PROPERTY_SIZE]; + MonoType *type; + MonoParam *param; + char *blurb; + const char *name; + int prop_flags; + GString *res = g_string_new (""); + + mono_metadata_decode_row (propt, prop_idx, cols, MONO_PROPERTY_SIZE); + name = mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME]); + prop_flags = cols [MONO_PROPERTY_FLAGS]; + ptr = mono_metadata_blob_heap (m, cols [MONO_PROPERTY_TYPE]); + mono_metadata_decode_blob_size (ptr, &ptr); + /* ECMA claims 0x08 ... */ + if (*ptr != 0x28 && *ptr != 0x08) + g_warning("incorrect signature in propert blob: 0x%x", *ptr); + ptr++; + pcount = mono_metadata_decode_value (ptr, &ptr); + type = mono_metadata_parse_type (m, ptr, &ptr); + blurb = dis_stringify_type (m, type); + if (prop_flags & 0x0200) + g_string_append (res, "special "); + if (prop_flags & 0x0400) + g_string_append (res, "runtime "); + if (prop_flags & 0x1000) + g_string_append (res, "hasdefault "); + g_string_sprintfa (res, "%s %s (", blurb, name); + g_free (blurb); + mono_metadata_free_type (type); + for (i = 0; i < pcount; i++) { + if (i) + g_string_append (res, ", "); + param = mono_metadata_parse_param (m, 0, ptr, &ptr); + blurb = dis_stringify_param (m, param); + g_string_append (res, blurb); + mono_metadata_free_param (param); + g_free (blurb); + } + g_string_append_c (res, ')'); + blurb = res->str; + g_string_free (res, FALSE); + return blurb; + +} + +static void +dis_property_list (MonoMetadata *m, guint32 typedef_row) +{ + plocator_t loc; + guint32 start, end, i; + MonoTableInfo *tdef = &m->tables [MONO_TABLE_PROPERTYMAP]; + + loc.t = tdef; + loc.col_idx = MONO_PROPERTY_MAP_PARENT; + loc.idx = typedef_row + 1; + + if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator)) + return; + + 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 = m->tables [MONO_TABLE_PROPERTY].rows; + } + + for (i = start - 1; i < end; ++i) { + char *sig = dis_property_signature (m, i); + fprintf (output, "\t.property %s\n\t{\n", sig); + dis_property_methods (m, i + 1); + fprintf (output, "\t}\n"); + g_free (sig); + } +} + /** * dis_type: * @m: metadata context @@ -533,6 +680,8 @@ dis_type (MonoMetadata *m, MonoCLIImageInfo *ii, int n) if (cols [MONO_TYPEDEF_METHOD_LIST] < m->tables [MONO_TABLE_METHOD].rows) dis_method_list (m, ii, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last); + dis_property_list (m, n); + fprintf (output, " }\n}\n\n"); } @@ -567,10 +716,12 @@ struct { { "--classlayout", MONO_TABLE_CLASSLAYOUT, dump_table_class_layout }, { "--constant", MONO_TABLE_CONSTANT, dump_table_constant }, { "--property", MONO_TABLE_PROPERTY, dump_table_property }, + { "--propertymap", MONO_TABLE_PROPERTYMAP, dump_table_property_map }, { "--event", MONO_TABLE_EVENT, dump_table_event }, { "--file", MONO_TABLE_FILE, dump_table_file }, { "--moduleref", MONO_TABLE_MODULEREF, dump_table_moduleref }, { "--method", MONO_TABLE_METHOD, dump_table_method }, + { "--methodsem", MONO_TABLE_METHODSEMANTICS, dump_table_methodsem }, { NULL, -1 } }; diff --git a/mono/dis/util.c b/mono/dis/util.c index 2debbbf1eff..004bbd683bc 100644 --- a/mono/dis/util.c +++ b/mono/dis/util.c @@ -47,8 +47,11 @@ flags (guint32 code, map_t *table) buffer [0] = 0; for (i = 0; table [i].str != NULL; i++) - if (table [i].code & code) + if (table [i].code & code) { + if (buffer [0]) + strcat (buffer, " "); strcat (buffer, table [i].str); + } return buffer; } diff --git a/mono/metadata/ChangeLog b/mono/metadata/ChangeLog index 0a25c2ceccd..2402adaff90 100644 --- a/mono/metadata/ChangeLog +++ b/mono/metadata/ChangeLog @@ -1,3 +1,13 @@ +Mon Aug 20 19:39:00 CEST 2001 Paolo Molaro + + * blob.h: fix MONO_TYPE_TYPEDBYREF value. + * cil-coff.h: split MonoMSDOSHeader and add size info. + * image.c: add some consistency checks. + * metadata.c: fix row size computation: one programmer + error and one LAMESPEC. Handle MONO_TYPE_TYPEDBYREF. + add explanation for the locator routine. + Fix decoding of size in method header. + 2001-08-20 Miguel de Icaza * assembly.c (g_concat_dir_and_file): Use _S for string concat. diff --git a/mono/metadata/blob.h b/mono/metadata/blob.h index 9bf4a278368..e5cb42b3616 100644 --- a/mono/metadata/blob.h +++ b/mono/metadata/blob.h @@ -33,7 +33,7 @@ typedef enum { MONO_TYPE_VALUETYPE = 0x11, /* arg: token */ MONO_TYPE_CLASS = 0x12, /* arg: token */ MONO_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */ - MONO_TYPE_TYPEDBYREF = 0x15, + MONO_TYPE_TYPEDBYREF = 0x16, MONO_TYPE_I = 0x18, MONO_TYPE_U = 0x19, MONO_TYPE_FNPTR = 0x1b, /* arg: full method signature */ diff --git a/mono/metadata/cil-coff.h b/mono/metadata/cil-coff.h index 58600c3e2cf..1393c801306 100644 --- a/mono/metadata/cil-coff.h +++ b/mono/metadata/cil-coff.h @@ -27,10 +27,14 @@ #define METHOD_HEADER_SECTION_FAT_FORMAT 0x40 #define METHOD_HEADER_SECTION_MORE_SECTS 0x80 +/* 128 bytes */ typedef struct { - char msdos_header [128]; + char msdos_header [60]; + guint32 pe_offset; + char msdos_header2 [64]; } MonoMSDOSHeader; +/* 20 bytes */ typedef struct { guint16 coff_machine; guint16 coff_sections; @@ -44,6 +48,7 @@ typedef struct { #define COFF_ATTRIBUTE_EXECUTABLE_IMAGE 0x0002 #define COFF_ATTRIBUTE_LIBRARY_IMAGE 0x2000 +/* 28 bytes */ typedef struct { guint16 pe_magic; guchar pe_major; @@ -56,6 +61,7 @@ typedef struct { guint32 pe_rva_data_base; } MonoPEHeader; +/* 68 bytes */ typedef struct { guint32 pe_image_base; /* must be 0x400000 */ guint32 pe_section_align; /* must be 8192 */ @@ -85,6 +91,7 @@ typedef struct { guint32 size; } MonoPEDirEntry; +/* 128 bytes */ typedef struct { MonoPEDirEntry pe_export_table; MonoPEDirEntry pe_import_table; @@ -104,6 +111,7 @@ typedef struct { MonoPEDirEntry pe_reserved; } MonoPEDatadir; +/* 248 bytes */ typedef struct { char pesig [4]; MonoCOFFHeader coff; diff --git a/mono/metadata/image.c b/mono/metadata/image.c index c61b3880a1f..eb0bf8866b4 100644 --- a/mono/metadata/image.c +++ b/mono/metadata/image.c @@ -148,6 +148,8 @@ load_section_tables (MonoImage *image, MonoCLIImageInfo *iinfo) t->st_lineno_ptr = le32_to_cpu (t->st_lineno_ptr); t->st_reloc_count = le16_to_cpu (t->st_reloc_count); t->st_line_count = le16_to_cpu (t->st_line_count); + + /* consistency checks here */ } for (i = 0; i < top; i++) @@ -341,12 +343,27 @@ do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status) if (fread (&msdos, sizeof (msdos), 1, image->f) != 1) goto invalid_image; - if (!(msdos.msdos_header [0] == 0x4d && msdos.msdos_header [1] == 0x5a)) + if (!(msdos.msdos_header [0] == 'M' && msdos.msdos_header [1] == 'Z')) goto invalid_image; + if (msdos.pe_offset != sizeof (msdos)) + fseek (image->f, msdos.pe_offset, SEEK_SET); + if ((n = fread (header, sizeof (MonoDotNetHeader), 1, image->f)) != 1) goto invalid_image; + if (header->coff.coff_machine != 0x14c) /* FIXME: ENOENDIAN */ + goto invalid_image; + + if (header->coff.coff_opt_header_size != (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4)) + goto invalid_image; + + if (header->pe.pe_magic != 0x10B) /* FIXME: ENOENDIAN */ + goto invalid_image; + + if (header->pe.pe_major != 6 || header->pe.pe_minor != 0) + goto invalid_image; + /* * FIXME: byte swap all addresses here for header. */ diff --git a/mono/metadata/metadata.c b/mono/metadata/metadata.c index 5178286937f..12da3d8d94a 100644 --- a/mono/metadata/metadata.c +++ b/mono/metadata/metadata.c @@ -582,10 +582,12 @@ compute_size (MonoMetadata *meta, MonoMetaTable *table, int tableindex, guint32 /* * TypeDefOrRef: TypeDef, ParamDef, TypeSpec + * LAMESPEC + * It is TypeDef, _TypeRef_, TypeSpec, instead. */ case MONO_MT_TDOR_IDX: n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows, - meta->tables [MONO_TABLE_PARAM].rows); + meta->tables [MONO_TABLE_TYPEREF].rows); n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows); /* 2 bits to encode */ @@ -593,14 +595,15 @@ compute_size (MonoMetadata *meta, MonoMetaTable *table, int tableindex, guint32 break; /* - * MemberRefParent: TypeDef, TypeRef, ModuleDef, ModuleRef, TypeSpec + * MemberRefParent: TypeDef, TypeRef, MethodDef, ModuleRef, TypeSpec, MemberRef */ case MONO_MT_MRP_IDX: n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows, meta->tables [MONO_TABLE_TYPEREF].rows); - n = MAX (n, meta->tables [MONO_TABLE_MODULE].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); @@ -1109,6 +1112,7 @@ do_mono_metadata_parse_type (MonoType *type, MonoMetadata *m, const char *ptr, c case MONO_TYPE_U: case MONO_TYPE_STRING: case MONO_TYPE_OBJECT: + case MONO_TYPE_TYPEDBYREF: break; case MONO_TYPE_VALUETYPE: case MONO_TYPE_CLASS: @@ -1237,7 +1241,7 @@ parse_section_data (MonoMethodHeader *mh, const unsigned char *ptr) is_fat = sect_data_flags & METHOD_HEADER_SECTION_FAT_FORMAT; if (is_fat) { - sect_data_len = (ptr [0] << 16) | (ptr [1] << 8) | ptr [2]; + sect_data_len = (ptr [2] << 16) | (ptr [1] << 8) | ptr [0]; ptr += 3; } else { sect_data_len = ptr [0]; @@ -1476,18 +1480,48 @@ mono_metadata_token_from_dor (guint32 dor_index) } /* - * We use this to pass context information to the typedef locator + * 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 is stored */ - MonoMetadata *m; /* the metadata context */ - MonoTableInfo *t; /* pointer to the typedef table */ + 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 + * METHODSEM PROPERTY ASSOCIATION (encoded index) + * + * Note that we still don't support encoded indexes. + * + */ static int typedef_locator (const void *a, const void *b) { @@ -1637,6 +1671,7 @@ mono_type_size (MonoType *t, gint *align) 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: -- 2.25.1