mono/metadata/verify.c

   1
   2 #include <mono/metadata/object.h>
   3 #include <mono/metadata/verify.h>
   4 #include <mono/metadata/opcodes.h>
   5 #include <mono/metadata/tabledefs.h>
   6 #include <mono/metadata/reflection.h>
   7 #include <mono/metadata/debug-helpers.h>
   8 #include <mono/metadata/mono-endian.h>
   9 #include <string.h>
  10 #include <signal.h>
  11 #include <ctype.h>
  12
  13 /*
  14  * Pull the list of opcodes
  15  */
  16 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
  17         a = i,
  18
  19 enum {
  20 #include "mono/cil/opcode.def"
  21         LAST = 0xff
  22 };
  23 #undef OPDEF
  24
  25 void
  26 mono_free_verify_list (GSList *list)
  27 {
  28         MonoVerifyInfo* info;
  29         GSList *tmp;
  30
  31         for (tmp = list; tmp; tmp = tmp->next) {
  32                 info = tmp->data;
  33                 g_free (info->message);
  34                 g_free (info);
  35         }
  36         g_slist_free (list);
  37 }
  38
  39 #define ADD_ERROR(list,msg)     \
  40         do {    \
  41                 MonoVerifyInfo *vinfo = g_new (MonoVerifyInfo, 1);      \
  42                 vinfo->status = MONO_VERIFY_ERROR;      \
  43                 vinfo->message = (msg); \
  44                 (list) = g_slist_prepend ((list), vinfo);       \
  45         } while (0)
  46
  47 #define ADD_WARN(list,code,msg) \
  48         do {    \
  49                 MonoVerifyInfo *vinfo = g_new (MonoVerifyInfo, 1);      \
  50                 vinfo->status = (code); \
  51                 vinfo->message = (msg); \
  52                 (list) = g_slist_prepend ((list), vinfo);       \
  53         } while (0)
  54
  55 static const char* const
  56 valid_cultures[] = {
  57         "ar-SA", "ar-IQ", "ar-EG", "ar-LY",
  58         "ar-DZ", "ar-MA", "ar-TN", "ar-OM",
  59         "ar-YE", "ar-SY", "ar-JO", "ar-LB",
  60         "ar-KW", "ar-AE", "ar-BH", "ar-QA",
  61         "bg-BG", "ca-ES", "zh-TW", "zh-CN",
  62         "zh-HK", "zh-SG", "zh-MO", "cs-CZ",
  63         "da-DK", "de-DE", "de-CH", "de-AT",
  64         "de-LU", "de-LI", "el-GR", "en-US",
  65         "en-GB", "en-AU", "en-CA", "en-NZ",
  66         "en-IE", "en-ZA", "en-JM", "en-CB",
  67         "en-BZ", "en-TT", "en-ZW", "en-PH",
  68         "es-ES-Ts", "es-MX", "es-ES-Is", "es-GT",
  69         "es-CR", "es-PA", "es-DO", "es-VE",
  70         "es-CO", "es-PE", "es-AR", "es-EC",
  71         "es-CL", "es-UY", "es-PY", "es-BO",
  72         "es-SV", "es-HN", "es-NI", "es-PR",
  73         "Fi-FI", "fr-FR", "fr-BE", "fr-CA",
  74         "Fr-CH", "fr-LU", "fr-MC", "he-IL",
  75         "hu-HU", "is-IS", "it-IT", "it-CH",
  76         "Ja-JP", "ko-KR", "nl-NL", "nl-BE",
  77         "nb-NO", "nn-NO", "pl-PL", "pt-BR",
  78         "pt-PT", "ro-RO", "ru-RU", "hr-HR",
  79         "Lt-sr-SP", "Cy-sr-SP", "sk-SK", "sq-AL",
  80         "sv-SE", "sv-FI", "th-TH", "tr-TR",
  81         "ur-PK", "id-ID", "uk-UA", "be-BY",
  82         "sl-SI", "et-EE", "lv-LV", "lt-LT",
  83         "fa-IR", "vi-VN", "hy-AM", "Lt-az-AZ",
  84         "Cy-az-AZ",
  85         "eu-ES", "mk-MK", "af-ZA",
  86         "ka-GE", "fo-FO", "hi-IN", "ms-MY",
  87         "ms-BN", "kk-KZ", "ky-KZ", "sw-KE",
  88         "Lt-uz-UZ", "Cy-uz-UZ", "tt-TA", "pa-IN",
  89         "gu-IN", "ta-IN", "te-IN", "kn-IN",
  90         "mr-IN", "sa-IN", "mn-MN", "gl-ES",
  91         "kok-IN", "syr-SY", "div-MV",
  92         NULL
  93 };
  94
  95 static int
  96 is_valid_culture (const char *cname)
  97 {
  98         int i;
  99         int found;
 100
 101         found = *cname == 0;
 102         for (i = 0; !found && valid_cultures [i]; ++i) {
 103                 if (g_strcasecmp (valid_cultures [i], cname))
 104                         found = 1;
 105         }
 106         return found;
 107 }
 108
 109 static int
 110 is_valid_assembly_flags (guint32 flags) {
 111         /* Metadata: 22.1.2 */
 112         flags &= ~(0x8000 | 0x4000); /* ignore reserved bits 0x0030? */
 113         return ((flags == 1) || (flags == 0));
 114 }
 115
 116 static int
 117 is_valid_blob (MonoImage *image, guint32 blob_index, int notnull)
 118 {
 119         guint32 size;
 120         const char *p, *blob_end;
 121
 122         if (blob_index >= image->heap_blob.size)
 123                 return 0;
 124         p = mono_metadata_blob_heap (image, blob_index);
 125         size = mono_metadata_decode_blob_size (p, &blob_end);
 126         if (blob_index + size + (blob_end-p) > image->heap_blob.size)
 127                 return 0;
 128         if (notnull && !size)
 129                 return 0;
 130         return 1;
 131 }
 132
 133 static const char*
 134 is_valid_string (MonoImage *image, guint32 str_index, int notnull)
 135 {
 136         const char *p, *blob_end, *res;
 137
 138         if (str_index >= image->heap_strings.size)
 139                 return NULL;
 140         res = p = mono_metadata_string_heap (image, str_index);
 141         blob_end = mono_metadata_string_heap (image, image->heap_strings.size - 1);
 142         if (notnull && !*p)
 143                 return 0;
 144         /*
 145          * FIXME: should check it's a valid utf8 string, too.
 146          */
 147         while (p <= blob_end) {
 148                 if (!*p)
 149                         return res;
 150                 ++p;
 151         }
 152         return *p? NULL: res;
 153 }
 154
 155 static int
 156 is_valid_cls_ident (const char *p)
 157 {
 158         /*
 159          * FIXME: we need the full unicode glib support for this.
 160          * Check: http://www.unicode.org/unicode/reports/tr15/Identifier.java
 161          * We do the lame thing for now.
 162          */
 163         if (!isalpha (*p))
 164                 return 0;
 165         ++p;
 166         while (*p) {
 167                 if (!isalnum (*p) && *p != '_')
 168                         return 0;
 169                 ++p;
 170         }
 171         return 1;
 172 }
 173
 174 static int
 175 is_valid_filename (const char *p)
 176 {
 177         if (!*p)
 178                 return 0;
 179         return strpbrk (p, "\\//:")? 0: 1;
 180 }
 181
 182 static GSList*
 183 verify_assembly_table (MonoImage *image, GSList *list, int level)
 184 {
 185         MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLY];
 186         guint32 cols [MONO_ASSEMBLY_SIZE];
 187         const char *p;
 188
 189         if (level & MONO_VERIFY_ERROR) {
 190                 if (t->rows > 1)
 191                         ADD_ERROR (list, g_strdup ("Assembly table may only have 0 or 1 rows"));
 192                 mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
 193
 194                 switch (cols [MONO_ASSEMBLY_HASH_ALG]) {
 195                 case ASSEMBLY_HASH_NONE:
 196                 case ASSEMBLY_HASH_MD5:
 197                 case ASSEMBLY_HASH_SHA1:
 198                         break;
 199                 default:
 200                         ADD_ERROR (list, g_strdup_printf ("Hash algorithm 0x%x unknown", cols [MONO_ASSEMBLY_HASH_ALG]));
 201                 }
 202
 203                 if (!is_valid_assembly_flags (cols [MONO_ASSEMBLY_FLAGS]))
 204                         ADD_ERROR (list, g_strdup_printf ("Invalid flags in assembly: 0x%x", cols [MONO_ASSEMBLY_FLAGS]));
 205
 206                 if (!is_valid_blob (image, cols [MONO_ASSEMBLY_PUBLIC_KEY], FALSE))
 207                         ADD_ERROR (list, g_strdup ("Assembly public key is an invalid index"));
 208
 209                 if (!(p = is_valid_string (image, cols [MONO_ASSEMBLY_NAME], TRUE))) {
 210                         ADD_ERROR (list, g_strdup ("Assembly name is invalid"));
 211                 } else {
 212                         if (strpbrk (p, ":\\/."))
 213                                 ADD_ERROR (list, g_strdup_printf ("Assembly name `%s' contains invalid chars", p));
 214                 }
 215
 216                 if (!(p = is_valid_string (image, cols [MONO_ASSEMBLY_CULTURE], FALSE))) {
 217                         ADD_ERROR (list, g_strdup ("Assembly culture is an invalid index"));
 218                 } else {
 219                         if (!is_valid_culture (p))
 220                                 ADD_ERROR (list, g_strdup_printf ("Assembly culture `%s' is invalid", p));
 221                 }
 222         }
 223         return list;
 224 }
 225
 226 static GSList*
 227 verify_assemblyref_table (MonoImage *image, GSList *list, int level)
 228 {
 229         MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLYREF];
 230         guint32 cols [MONO_ASSEMBLYREF_SIZE];
 231         const char *p;
 232         int i;
 233
 234         if (level & MONO_VERIFY_ERROR) {
 235                 for (i = 0; i < t->rows; ++i) {
 236                         mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
 237                         if (!is_valid_assembly_flags (cols [MONO_ASSEMBLYREF_FLAGS]))
 238                                 ADD_ERROR (list, g_strdup_printf ("Invalid flags in assemblyref row %d: 0x%x", i + 1, cols [MONO_ASSEMBLY_FLAGS]));
 239
 240                         if (!is_valid_blob (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY], FALSE))
 241                                 ADD_ERROR (list, g_strdup_printf ("AssemblyRef public key in row %d is an invalid index", i + 1));
 242
 243                         if (!(p = is_valid_string (image, cols [MONO_ASSEMBLYREF_CULTURE], FALSE))) {
 244                                 ADD_ERROR (list, g_strdup_printf ("AssemblyRef culture in row %d is invalid", i + 1));
 245                         } else {
 246                                 if (!is_valid_culture (p))
 247                                         ADD_ERROR (list, g_strdup_printf ("AssemblyRef culture `%s' in row %d is invalid", p, i + 1));
 248                         }
 249
 250                         if (cols [MONO_ASSEMBLYREF_HASH_VALUE] && !is_valid_blob (image, cols [MONO_ASSEMBLYREF_HASH_VALUE], TRUE))
 251                                 ADD_ERROR (list, g_strdup_printf ("AssemblyRef hash value in row %d is invalid or not null and empty", i + 1));
 252                 }
 253         }
 254         if (level & MONO_VERIFY_WARNING) {
 255                 /* check for duplicated rows */
 256                 for (i = 0; i < t->rows; ++i) {
 257                 }
 258         }
 259         return list;
 260 }
 261
 262 static GSList*
 263 verify_class_layout_table (MonoImage *image, GSList *list, int level)
 264 {
 265         MonoTableInfo *t = &image->tables [MONO_TABLE_CLASSLAYOUT];
 266         MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
 267         guint32 cols [MONO_CLASS_LAYOUT_SIZE];
 268         guint32 value, i;
 269
 270         if (level & MONO_VERIFY_ERROR) {
 271                 for (i = 0; i < t->rows; ++i) {
 272                         mono_metadata_decode_row (t, i, cols, MONO_CLASS_LAYOUT_SIZE);
 273
 274                         if (cols [MONO_CLASS_LAYOUT_PARENT] > tdef->rows || !cols [MONO_CLASS_LAYOUT_PARENT]) {
 275                                 ADD_ERROR (list, g_strdup_printf ("Parent in class layout is invalid in row %d", i + 1));
 276                         } else {
 277                                 value = mono_metadata_decode_row_col (tdef, cols [MONO_CLASS_LAYOUT_PARENT] - 1, MONO_TYPEDEF_FLAGS);
 278                                 if (value & TYPE_ATTRIBUTE_INTERFACE)
 279                                         ADD_ERROR (list, g_strdup_printf ("Parent in class layout row %d is an interface", i + 1));
 280                                 if (value & TYPE_ATTRIBUTE_AUTO_LAYOUT)
 281                                         ADD_ERROR (list, g_strdup_printf ("Parent in class layout row %d is AutoLayout", i + 1));
 282                                 if (value & TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT) {
 283                                         switch (cols [MONO_CLASS_LAYOUT_PACKING_SIZE]) {
 284                                         case 0: case 1: case 2: case 4: case 8: case 16:
 285                                         case 32: case 64: case 128: break;
 286                                         default:
 287                                                 ADD_ERROR (list, g_strdup_printf ("Packing size %d in class layout row %d is invalid", cols [MONO_CLASS_LAYOUT_PACKING_SIZE], i + 1));
 288                                         }
 289                                 } else if (value & TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
 290                                         /*
 291                                          * FIXME: LAMESPEC: it claims it must be 0 (it's 1, instead).
 292                                         if (cols [MONO_CLASS_LAYOUT_PACKING_SIZE])
 293                                                 ADD_ERROR (list, g_strdup_printf ("Packing size %d in class layout row %d is invalid with explicit layout", cols [MONO_CLASS_LAYOUT_PACKING_SIZE], i + 1));
 294                                         */
 295                                 }
 296                                 /*
 297                                  * FIXME: we need to check that if class size != 0,
 298                                  * it needs to be greater than the class calculated size.
 299                                  * If parent is a valuetype it also needs to be smaller than
 300                                  * 1 MByte (0x100000 bytes).
 301                                  * To do both these checks we need to load the referenced
 302                                  * assemblies, though (the spec claims we didn't have to, bah).
 303                                  */
 304                                 /*
 305                                  * We need to check that the parent types have the samme layout
 306                                  * type as well.
 307                                  */
 308                         }
 309                 }
 310         }
 311
 312         return list;
 313 }
 314
 315 static GSList*
 316 verify_constant_table (MonoImage *image, GSList *list, int level)
 317 {
 318         MonoTableInfo *t = &image->tables [MONO_TABLE_CONSTANT];
 319         guint32 cols [MONO_CONSTANT_SIZE];
 320         guint32 value, i;
 321         GHashTable *dups = g_hash_table_new (g_direct_hash, g_direct_equal);
 322
 323         for (i = 0; i < t->rows; ++i) {
 324                 mono_metadata_decode_row (t, i, cols, MONO_CONSTANT_SIZE);
 325
 326                 if (level & MONO_VERIFY_ERROR)
 327                         if (g_hash_table_lookup (dups, GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT])))
 328                                 ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is duplicated in Constant row %d", cols [MONO_CONSTANT_PARENT], i + 1));
 329                 g_hash_table_insert (dups, GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT]),
 330                                 GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT]));
 331
 332                 switch (cols [MONO_CONSTANT_TYPE]) {
 333                 case MONO_TYPE_U1: /* LAMESPEC: it says I1...*/
 334                 case MONO_TYPE_U2:
 335                 case MONO_TYPE_U4:
 336                 case MONO_TYPE_U8:
 337                         if (level & MONO_VERIFY_CLS)
 338                                 ADD_WARN (list, MONO_VERIFY_CLS, g_strdup_printf ("Type 0x%x not CLS compliant in Constant row %d", cols [MONO_CONSTANT_TYPE], i + 1));
 339                 case MONO_TYPE_BOOLEAN:
 340                 case MONO_TYPE_CHAR:
 341                 case MONO_TYPE_I1:
 342                 case MONO_TYPE_I2:
 343                 case MONO_TYPE_I4:
 344                 case MONO_TYPE_I8:
 345                 case MONO_TYPE_R4:
 346                 case MONO_TYPE_R8:
 347                 case MONO_TYPE_STRING:
 348                 case MONO_TYPE_CLASS:
 349                         break;
 350                 default:
 351                         if (level & MONO_VERIFY_ERROR)
 352                                 ADD_ERROR (list, g_strdup_printf ("Type 0x%x is invalid in Constant row %d", cols [MONO_CONSTANT_TYPE], i + 1));
 353                 }
 354                 if (level & MONO_VERIFY_ERROR) {
 355                         value = cols [MONO_CONSTANT_PARENT] >> HASCONSTANT_BITS;
 356                         switch (cols [MONO_CONSTANT_PARENT] & HASCONSTANT_MASK) {
 357                         case HASCONSTANT_FIEDDEF:
 358                                 if (value > image->tables [MONO_TABLE_FIELD].rows)
 359                                         ADD_ERROR (list, g_strdup_printf ("Parent (field) is invalid in Constant row %d", i + 1));
 360                                 break;
 361                         case HASCONSTANT_PARAM:
 362                                 if (value > image->tables [MONO_TABLE_PARAM].rows)
 363                                         ADD_ERROR (list, g_strdup_printf ("Parent (param) is invalid in Constant row %d", i + 1));
 364                                 break;
 365                         case HASCONSTANT_PROPERTY:
 366                                 if (value > image->tables [MONO_TABLE_PROPERTY].rows)
 367                                         ADD_ERROR (list, g_strdup_printf ("Parent (property) is invalid in Constant row %d", i + 1));
 368                                 break;
 369                         default:
 370                                 ADD_ERROR (list, g_strdup_printf ("Parent is invalid in Constant row %d", i + 1));
 371                                 break;
 372                         }
 373                 }
 374                 if (level & MONO_VERIFY_CLS) {
 375                         /*
 376                          * FIXME: verify types is consistent with the enum type
 377                          * is parent is an enum.
 378                          */
 379                 }
 380         }
 381         g_hash_table_destroy (dups);
 382         return list;
 383 }
 384
 385 static GSList*
 386 verify_event_map_table (MonoImage *image, GSList *list, int level)
 387 {
 388         MonoTableInfo *t = &image->tables [MONO_TABLE_EVENTMAP];
 389         guint32 cols [MONO_EVENT_MAP_SIZE];
 390         guint32 i, last_event;
 391         GHashTable *dups = g_hash_table_new (g_direct_hash, g_direct_equal);
 392
 393         last_event = 0;
 394
 395         for (i = 0; i < t->rows; ++i) {
 396                 mono_metadata_decode_row (t, i, cols, MONO_EVENT_MAP_SIZE);
 397                 if (level & MONO_VERIFY_ERROR)
 398                         if (g_hash_table_lookup (dups, GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT])))
 399                                 ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is duplicated in Event Map row %d", cols [MONO_EVENT_MAP_PARENT], i + 1));
 400                 g_hash_table_insert (dups, GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT]),
 401                                 GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT]));
 402                 if (level & MONO_VERIFY_ERROR) {
 403                         if (cols [MONO_EVENT_MAP_PARENT] > image->tables [MONO_TABLE_TYPEDEF].rows)
 404                                 ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is invalid in Event Map row %d", cols [MONO_EVENT_MAP_PARENT], i + 1));
 405                         if (cols [MONO_EVENT_MAP_EVENTLIST] > image->tables [MONO_TABLE_EVENT].rows)
 406                                 ADD_ERROR (list, g_strdup_printf ("EventList 0x%08x is invalid in Event Map row %d", cols [MONO_EVENT_MAP_EVENTLIST], i + 1));
 407
 408                         if (cols [MONO_EVENT_MAP_EVENTLIST] <= last_event)
 409                                 ADD_ERROR (list, g_strdup_printf ("EventList overlap in Event Map row %d", i + 1));
 410                         last_event = cols [MONO_EVENT_MAP_EVENTLIST];
 411                 }
 412         }
 413
 414         g_hash_table_destroy (dups);
 415         return list;
 416 }
 417
 418 static GSList*
 419 verify_event_table (MonoImage *image, GSList *list, int level)
 420 {
 421         MonoTableInfo *t = &image->tables [MONO_TABLE_EVENT];
 422         guint32 cols [MONO_EVENT_SIZE];
 423         const char *p;
 424         guint32 value, i;
 425
 426         for (i = 0; i < t->rows; ++i) {
 427                 mono_metadata_decode_row (t, i, cols, MONO_EVENT_SIZE);
 428
 429                 if (cols [MONO_EVENT_FLAGS] & ~(EVENT_SPECIALNAME|EVENT_RTSPECIALNAME)) {
 430                         if (level & MONO_VERIFY_ERROR)
 431                                 ADD_ERROR (list, g_strdup_printf ("Flags 0x%04x invalid in Event row %d", cols [MONO_EVENT_FLAGS], i + 1));
 432                 }
 433                 if (!(p = is_valid_string (image, cols [MONO_EVENT_NAME], TRUE))) {
 434                         if (level & MONO_VERIFY_ERROR)
 435                                 ADD_ERROR (list, g_strdup_printf ("Invalid name in Event row %d", i + 1));
 436                 } else {
 437                         if (level & MONO_VERIFY_CLS) {
 438                                 if (!is_valid_cls_ident (p))
 439                                         ADD_WARN (list, MONO_VERIFY_CLS, g_strdup_printf ("Invalid CLS name '%s` in Event row %d", p, i + 1));
 440                         }
 441                 }
 442
 443                 if (level & MONO_VERIFY_ERROR && cols [MONO_EVENT_TYPE]) {
 444                         value = cols [MONO_EVENT_TYPE] >> TYPEDEFORREF_BITS;
 445                         switch (cols [MONO_EVENT_TYPE] & TYPEDEFORREF_MASK) {
 446                         case TYPEDEFORREF_TYPEDEF:
 447                                 if (!value || value > image->tables [MONO_TABLE_TYPEDEF].rows)
 448                                         ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
 449                                 break;
 450                         case TYPEDEFORREF_TYPEREF:
 451                                 if (!value || value > image->tables [MONO_TABLE_TYPEREF].rows)
 452                                         ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
 453                                 break;
 454                         case TYPEDEFORREF_TYPESPEC:
 455                                 if (!value || value > image->tables [MONO_TABLE_TYPESPEC].rows)
 456                                         ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
 457                                 break;
 458                         default:
 459                                 ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
 460                         }
 461                 }
 462                 /*
 463                  * FIXME: check that there is 1 add and remove row in methodsemantics
 464                  * and 0 or 1 raise and 0 or more other (maybe it's better to check for
 465                  * these while checking methodsemantics).
 466                  * check for duplicated names for the same type [ERROR]
 467                  * check for CLS duplicate names for the same type [CLS]
 468                  */
 469         }
 470         return list;
 471 }
 472
 473 static GSList*
 474 verify_field_table (MonoImage *image, GSList *list, int level)
 475 {
 476         MonoTableInfo *t = &image->tables [MONO_TABLE_FIELD];
 477         guint32 cols [MONO_FIELD_SIZE];
 478         const char *p;
 479         guint32 i, flags;
 480
 481         for (i = 0; i < t->rows; ++i) {
 482                 mono_metadata_decode_row (t, i, cols, MONO_FIELD_SIZE);
 483                 /*
 484                  * Check this field has only one owner and that the owner is not
 485                  * an interface (done in verify_typedef_table() )
 486                  */
 487                 flags = cols [MONO_FIELD_FLAGS];
 488                 switch (flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) {
 489                 case FIELD_ATTRIBUTE_COMPILER_CONTROLLED:
 490                 case FIELD_ATTRIBUTE_PRIVATE:
 491                 case FIELD_ATTRIBUTE_FAM_AND_ASSEM:
 492                 case FIELD_ATTRIBUTE_ASSEMBLY:
 493                 case FIELD_ATTRIBUTE_FAMILY:
 494                 case FIELD_ATTRIBUTE_FAM_OR_ASSEM:
 495                 case FIELD_ATTRIBUTE_PUBLIC:
 496                         break;
 497                 default:
 498                         if (level & MONO_VERIFY_ERROR)
 499                                 ADD_ERROR (list, g_strdup_printf ("Invalid access mask in Field row %d", i + 1));
 500                         break;
 501                 }
 502                 if (level & MONO_VERIFY_ERROR) {
 503                         if ((flags & FIELD_ATTRIBUTE_LITERAL) && (flags & FIELD_ATTRIBUTE_INIT_ONLY))
 504                                 ADD_ERROR (list, g_strdup_printf ("Literal and InitOnly cannot be both set in Field row %d", i + 1));
 505                         if ((flags & FIELD_ATTRIBUTE_LITERAL) && !(flags & FIELD_ATTRIBUTE_STATIC))
 506                                 ADD_ERROR (list, g_strdup_printf ("Literal needs also Static set in Field row %d", i + 1));
 507                         if ((flags & FIELD_ATTRIBUTE_RT_SPECIAL_NAME) && !(flags & FIELD_ATTRIBUTE_SPECIAL_NAME))
 508                                 ADD_ERROR (list, g_strdup_printf ("RTSpecialName needs also SpecialName set in Field row %d", i + 1));
 509                         /*
 510                          * FIXME: check there is only ono owner in the respective table.
 511                          * if (flags & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL)
 512                          * if (flags & FIELD_ATTRIBUTE_HAS_DEFAULT)
 513                          * if (flags & FIELD_ATTRIBUTE_HAS_FIELD_RVA)
 514                          */
 515                 }
 516                 if (!(p = is_valid_string (image, cols [MONO_FIELD_NAME], TRUE))) {
 517                         if (level & MONO_VERIFY_ERROR)
 518                                 ADD_ERROR (list, g_strdup_printf ("Invalid name in Field row %d", i + 1));
 519                 } else {
 520                         if (level & MONO_VERIFY_CLS) {
 521                                 if (!is_valid_cls_ident (p))
 522                                         ADD_WARN (list, MONO_VERIFY_CLS, g_strdup_printf ("Invalid CLS name '%s` in Field row %d", p, i + 1));
 523                         }
 524                 }
 525                 /*
 526                  * check signature.
 527                  * if owner is module needs to be static, access mask needs to be compilercontrolled,
 528                  * public or private (not allowed in cls mode).
 529                  * if owner is an enum ...
 530                  */
 531
 532
 533         }
 534         return list;
 535 }
 536
 537 static GSList*
 538 verify_file_table (MonoImage *image, GSList *list, int level)
 539 {
 540         MonoTableInfo *t = &image->tables [MONO_TABLE_FILE];
 541         guint32 cols [MONO_FILE_SIZE];
 542         const char *p;
 543         guint32 i;
 544         GHashTable *dups = g_hash_table_new (g_str_hash, g_str_equal);
 545
 546         for (i = 0; i < t->rows; ++i) {
 547                 mono_metadata_decode_row (t, i, cols, MONO_FILE_SIZE);
 548                 if (level & MONO_VERIFY_ERROR) {
 549                         if (cols [MONO_FILE_FLAGS] != FILE_CONTAINS_METADATA && cols [MONO_FILE_FLAGS] != FILE_CONTAINS_NO_METADATA)
 550                                 ADD_ERROR (list, g_strdup_printf ("Invalid flags in File row %d", i + 1));
 551                         if (!is_valid_blob (image, cols [MONO_FILE_HASH_VALUE], TRUE))
 552                                 ADD_ERROR (list, g_strdup_printf ("File hash value in row %d is invalid or not null and empty", i + 1));
 553                 }
 554                 if (!(p = is_valid_string (image, cols [MONO_FILE_NAME], TRUE))) {
 555                         if (level & MONO_VERIFY_ERROR)
 556                                 ADD_ERROR (list, g_strdup_printf ("Invalid name in File row %d", i + 1));
 557                 } else {
 558                         if (level & MONO_VERIFY_ERROR) {
 559                                 if (!is_valid_filename (p))
 560                                         ADD_ERROR (list, g_strdup_printf ("Invalid name '%s` in File row %d", p, i + 1));
 561                                 else if (g_hash_table_lookup (dups, p)) {
 562                                         ADD_ERROR (list, g_strdup_printf ("Duplicate name '%s` in File row %d", p, i + 1));
 563                                 }
 564                                 g_hash_table_insert (dups, (gpointer)p, (gpointer)p);
 565                         }
 566                 }
 567                 /*
 568                  * FIXME: I don't understand what this means:
 569                  * If this module contains a row in the Assembly table (that is, if this module "holds the manifest")
 570                  * then there shall not be any row in the File table for this module - i.e., no self-reference  [ERROR]
 571                  */
 572
 573         }
 574         if (level & MONO_VERIFY_WARNING) {
 575                 if (!t->rows && image->tables [MONO_TABLE_EXPORTEDTYPE].rows)
 576                         ADD_WARN (list, MONO_VERIFY_WARNING, g_strdup ("ExportedType table should be empty if File table is empty"));
 577         }
 578         g_hash_table_destroy (dups);
 579         return list;
 580 }
 581
 582 static GSList*
 583 verify_moduleref_table (MonoImage *image, GSList *list, int level)
 584 {
 585         MonoTableInfo *t = &image->tables [MONO_TABLE_MODULEREF];
 586         MonoTableInfo *tfile = &image->tables [MONO_TABLE_FILE];
 587         guint32 cols [MONO_MODULEREF_SIZE];
 588         const char *p, *pf;
 589         guint32 found, i, j, value;
 590         GHashTable *dups = g_hash_table_new (g_str_hash, g_str_equal);
 591
 592         for (i = 0; i < t->rows; ++i) {
 593                 mono_metadata_decode_row (t, i, cols, MONO_MODULEREF_SIZE);
 594                 if (!(p = is_valid_string (image, cols [MONO_MODULEREF_NAME], TRUE))) {
 595                         if (level & MONO_VERIFY_ERROR)
 596                                 ADD_ERROR (list, g_strdup_printf ("Invalid name in ModuleRef row %d", i + 1));
 597                 } else {
 598                         if (level & MONO_VERIFY_ERROR) {
 599                                 if (!is_valid_filename (p))
 600                                         ADD_ERROR (list, g_strdup_printf ("Invalid name '%s` in ModuleRef row %d", p, i + 1));
 601                                 else if (g_hash_table_lookup (dups, p)) {
 602                                         ADD_WARN (list, MONO_VERIFY_WARNING, g_strdup_printf ("Duplicate name '%s` in ModuleRef row %d", p, i + 1));
 603                                         g_hash_table_insert (dups, (gpointer)p, (gpointer)p);
 604                                         found = 0;
 605                                         for (j = 0; j < tfile->rows; ++j) {
 606                                                 value = mono_metadata_decode_row_col (tfile, j, MONO_FILE_NAME);
 607                                                 if ((pf = is_valid_string (image, value, TRUE)))
 608                                                         if (strcmp (p, pf) == 0) {
 609                                                                 found = 1;
 610                                                                 break;
 611                                                         }
 612                                         }
 613                                         if (!found)
 614                                                 ADD_ERROR (list, g_strdup_printf ("Name '%s` in ModuleRef row %d doesn't have a match in File table", p, i + 1));
 615                                 }
 616                         }
 617                 }
 618         }
 619         g_hash_table_destroy (dups);
 620         return list;
 621 }
 622
 623 static GSList*
 624 verify_standalonesig_table (MonoImage *image, GSList *list, int level)
 625 {
 626         MonoTableInfo *t = &image->tables [MONO_TABLE_STANDALONESIG];
 627         guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
 628         const char *p;
 629         guint32 i;
 630
 631         for (i = 0; i < t->rows; ++i) {
 632                 mono_metadata_decode_row (t, i, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
 633                 if (level & MONO_VERIFY_ERROR) {
 634                         if (!is_valid_blob (image, cols [MONO_STAND_ALONE_SIGNATURE], TRUE)) {
 635                                 ADD_ERROR (list, g_strdup_printf ("Signature is invalid in StandAloneSig row %d", i + 1));
 636                         } else {
 637                                 p = mono_metadata_blob_heap (image, cols [MONO_STAND_ALONE_SIGNATURE]);
 638                                 /* FIXME: check it's a valid locals or method sig.*/
 639                         }
 640                 }
 641         }
 642         return list;
 643 }
 644
 645 GSList*
 646 mono_image_verify_tables (MonoImage *image, int level)
 647 {
 648         GSList *error_list = NULL;
 649
 650         error_list = verify_assembly_table (image, error_list, level);
 651         /*
 652          * AssemblyOS, AssemblyProcessor, AssemblyRefOs and
 653          * AssemblyRefProcessor should be ignored,
 654          * though we may want to emit a warning, since it should not
 655          * be present in a PE file.
 656          */
 657         error_list = verify_assemblyref_table (image, error_list, level);
 658         error_list = verify_class_layout_table (image, error_list, level);
 659         error_list = verify_constant_table (image, error_list, level);
 660         /*
 661          * cutom attribute, declsecurity
 662          */
 663         error_list = verify_event_map_table (image, error_list, level);
 664         error_list = verify_event_table (image, error_list, level);
 665         error_list = verify_field_table (image, error_list, level);
 666         error_list = verify_file_table (image, error_list, level);
 667         error_list = verify_moduleref_table (image, error_list, level);
 668         error_list = verify_standalonesig_table (image, error_list, level);
 669
 670         return g_slist_reverse (error_list);
 671 }
 672
 673 enum {
 674         TYPE_INVALID = 0, /* leave at 0. */
 675         TYPE_INT32 = 1,
 676         TYPE_INT64 = 2,
 677         TYPE_NINT  = 3,
 678         TYPE_FLOAT = 4,
 679         TYPE_MANP = 5,
 680         TYPE_OBJREF = 6,
 681         TYPE_MAX = 7
 682 };
 683
 684 const static unsigned char
 685 valid_binops [TYPE_MAX] [TYPE_MAX] = {
 686         {TYPE_INVALID},
 687         {TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_NINT,    TYPE_INVALID, TYPE_MANP},
 688         {TYPE_INVALID, TYPE_INVALID, TYPE_INT64,   TYPE_INVALID},
 689         {TYPE_INVALID, TYPE_NINT,    TYPE_INVALID, TYPE_NINT,    TYPE_INVALID, TYPE_MANP},
 690         {TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_FLOAT},
 691         {TYPE_INVALID, TYPE_MANP,    TYPE_INVALID, TYPE_MANP,    TYPE_INVALID, TYPE_NINT},
 692         {TYPE_INVALID}
 693                        /* int32 */   /* int64 */   /* native */  /* float */   /* managed p */ /* objref */
 694 };
 695
 696 const static unsigned char
 697 valid_unnops [TYPE_MAX] = {
 698         TYPE_INVALID, TYPE_INT32,    TYPE_INT64,   TYPE_NINT,    TYPE_FLOAT,   TYPE_INVALID
 699                        /* int32 */   /* int64 */   /* native */  /* float */   /* managed p */ /* objref */
 700 };
 701
 702 /* note: the resulting type is always a boolean */
 703 const static unsigned char
 704 valid_bincomp [TYPE_MAX] [TYPE_MAX] = {
 705         {TYPE_INVALID},
 706         {TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_INT32,   TYPE_INVALID},
 707         {TYPE_INVALID, TYPE_INVALID, TYPE_INT32,   TYPE_INVALID},
 708         {TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_INT32},
 709         {TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INT32},
 710         {TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_INT32},
 711         {TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INVALID, TYPE_INT32}
 712                        /* int32 */   /* int64 */   /* native */  /* float */   /* managed p */ /* objref */
 713 };
 714
 715 const static unsigned char
 716 valid_intops [TYPE_MAX] [TYPE_MAX] = {
 717         {TYPE_INVALID},
 718         {TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_NINT},
 719         {TYPE_INVALID, TYPE_INVALID, TYPE_INT64},
 720         {TYPE_INVALID, TYPE_NINT,    TYPE_INVALID, TYPE_NINT},
 721         {TYPE_INVALID}
 722 };
 723
 724 const static unsigned char
 725 valid_shiftops [TYPE_MAX] [TYPE_MAX] = {
 726         {TYPE_INVALID},
 727         {TYPE_INVALID, TYPE_INT32,   TYPE_INVALID, TYPE_INT32},
 728         {TYPE_INVALID, TYPE_INT64,   TYPE_INVALID, TYPE_INT64},
 729         {TYPE_INVALID, TYPE_NINT,    TYPE_INVALID, TYPE_NINT},
 730         {TYPE_INVALID}
 731 };
 732
 733 #define ADD_INVALID(list,msg)   \
 734         do {    \
 735                 MonoVerifyInfo *vinfo = g_new (MonoVerifyInfo, 1);      \
 736                 vinfo->status = MONO_VERIFY_ERROR;      \
 737                 vinfo->message = (msg); \
 738                 (list) = g_slist_prepend ((list), vinfo);       \
 739                 /*G_BREAKPOINT ();*/    \
 740                 goto invalid_cil;       \
 741         } while (0)
 742
 743 #define CHECK_STACK_UNDERFLOW(num)      \
 744         do {    \
 745                 if (cur_stack < (num))  \
 746                         ADD_INVALID (list, g_strdup_printf ("Stack underflow at 0x%04x (%d items instead of %d)", ip_offset, cur_stack, (num)));        \
 747         } while (0)
 748
 749 #define CHECK_STACK_OVERFLOW()  \
 750         do {    \
 751                 if (cur_stack >= max_stack)     \
 752                         ADD_INVALID (list, g_strdup_printf ("Maxstack exceeded at 0x%04x", ip_offset)); \
 753         } while (0)
 754
 755 enum {
 756         PREFIX_UNALIGNED = 1,
 757         PREFIX_VOLATILE  = 2,
 758         PREFIX_TAIL      = 4,
 759         PREFIX_ADDR_MASK = 3,
 760         PREFIX_FUNC_MASK = 4
 761 };
 762
 763 enum {
 764         CODE_SEEN = 1
 765 };
 766
 767 typedef struct {
 768         MonoClass *klass;
 769         int type;
 770 } ILStackDesc;
 771
 772 typedef struct {
 773         ILStackDesc *stack;
 774         guint16 stack_count;
 775         guint16 flags;
 776 } ILCodeDesc;
 777
 778 static int
 779 in_any_block (MonoMethodHeader *header, guint offset)
 780 {
 781         int i;
 782         MonoExceptionClause *clause;
 783
 784         for (i = 0; i < header->num_clauses; ++i) {
 785                 clause = &header->clauses [i];
 786                 if (MONO_OFFSET_IN_CLAUSE (clause, offset))
 787                         return 1;
 788                 if (MONO_OFFSET_IN_HANDLER (clause, offset))
 789                         return 1;
 790                 /* need to check filter ... */
 791         }
 792         return 0;
 793 }
 794
 795 static int
 796 in_same_block (MonoMethodHeader *header, guint offset, guint target)
 797 {
 798         int i;
 799         MonoExceptionClause *clause;
 800
 801         for (i = 0; i < header->num_clauses; ++i) {
 802                 clause = &header->clauses [i];
 803                 if (MONO_OFFSET_IN_CLAUSE (clause, offset) && !MONO_OFFSET_IN_CLAUSE (clause, target))
 804                         return 0;
 805                 if (MONO_OFFSET_IN_HANDLER (clause, offset) && !MONO_OFFSET_IN_HANDLER (clause, target))
 806                         return 0;
 807                 /* need to check filter ... */
 808         }
 809         return 1;
 810 }
 811
 812 /*
 813  * A leave can't escape a finally block
 814  */
 815 static int
 816 is_correct_leave (MonoMethodHeader *header, guint offset, guint target)
 817 {
 818         int i;
 819         MonoExceptionClause *clause;
 820
 821         for (i = 0; i < header->num_clauses; ++i) {
 822                 clause = &header->clauses [i];
 823                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY && MONO_OFFSET_IN_HANDLER (clause, offset) && !MONO_OFFSET_IN_HANDLER (clause, target))
 824                         return 0;
 825                 /* need to check filter ... */
 826         }
 827         return 1;
 828 }
 829
 830 static int
 831 can_merge_stack (ILCodeDesc *a, ILCodeDesc *b)
 832 {
 833         if (!b->flags & CODE_SEEN) {
 834                 b->flags |= CODE_SEEN;
 835                 b->stack_count = a->stack_count;
 836                 /* merge types */
 837                 return 1;
 838         }
 839         if (a->stack_count != b->stack_count)
 840                 return 0;
 841         /* merge types */
 842         return 1;
 843 }
 844
 845 /*
 846  * FIXME: need to distinguish between valid and verifiable.
 847  * Need to keep track of types on the stack.
 848  * Verify types for opcodes.
 849  */
 850 GSList*
 851 mono_method_verify (MonoMethod *method, int level)
 852 {
 853         MonoMethodHeader *header;
 854         MonoMethodSignature *signature, *csig;
 855         MonoMethod *cmethod;
 856         MonoImage *image;
 857         register const unsigned char *ip;
 858         register const unsigned char *end;
 859         const unsigned char *target; /* branch target */
 860         int max_args, max_stack, cur_stack, i, n, need_merge, start;
 861         guint32 token, ip_offset;
 862         char *local_state = NULL;
 863         GSList *list = NULL;
 864         guint prefix = 0;
 865         ILCodeDesc *code;
 866
 867         if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 868                         (method->flags & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT))) {
 869                 return NULL;
 870         }
 871         signature = method->signature;
 872         header = ((MonoMethodNormal *)method)->header;
 873         ip = header->code;
 874         end = ip + header->code_size;
 875         max_args = method->signature->param_count + method->signature->hasthis;
 876         max_stack = header->max_stack;
 877         need_merge = cur_stack = 0;
 878         start = 1;
 879         image = method->klass->image;
 880         code = g_new0 (ILCodeDesc, header->code_size);
 881
 882         if (header->num_locals) {
 883                 local_state = g_new (char, header->num_locals);
 884                 memset (local_state, header->init_locals, header->num_locals);
 885         }
 886         /*g_print ("Method %s.%s::%s\n", method->klass->name_space, method->klass->name, method->name);*/
 887
 888         for (i = 0; i < header->num_clauses; ++i) {
 889                 MonoExceptionClause *clause = &header->clauses [i];
 890                 /* catch blocks have the exception on the stack. */
 891                 if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) {
 892                         code [clause->handler_offset].stack_count = 1;
 893                         code [clause->handler_offset].flags |= CODE_SEEN;
 894                 }
 895         }
 896
 897         while (ip < end) {
 898                 ip_offset = ip - header->code;
 899                 if (start || !(code [ip_offset].flags & CODE_SEEN)) {
 900                         if (start) {
 901                                 /* g_print ("setting stack of IL_%04x to %d\n", ip_offset, 0); */
 902                                 cur_stack = code [ip_offset].stack_count;
 903                         } else {
 904                                 code [ip_offset].stack_count = cur_stack;
 905                         }
 906                         code [ip_offset].flags |= CODE_SEEN;
 907                 } else {
 908                         /* stack merge */
 909                         if (code [ip_offset].stack_count != cur_stack)
 910                                 ADD_INVALID (list, g_strdup_printf ("Cannot merge stack states at 0x%04x", ip_offset));
 911                 }
 912                 start = 0;
 913                 if (need_merge) {
 914                         if (!can_merge_stack (&code [ip_offset], &code [target - header->code]))
 915                                 ADD_INVALID (list, g_strdup_printf ("Cannot merge stack states at 0x%04x", ip_offset));
 916                         need_merge = 0;
 917                 }
 918 #if 0
 919                 {
 920                         char *discode;
 921                         discode = mono_disasm_code_one (NULL, method, ip);
 922                         discode [strlen (discode) - 1] = 0; /* no \n */
 923                         g_print ("%-29s (%d)\n", discode, cur_stack);
 924                         g_free (discode);
 925                 }
 926 #endif
 927
 928                 switch (*ip) {
 929                 case CEE_NOP:
 930                 case CEE_BREAK:
 931                         ++ip;
 932                         break;
 933                 case CEE_LDARG_0:
 934                 case CEE_LDARG_1:
 935                 case CEE_LDARG_2:
 936                 case CEE_LDARG_3:
 937                         if (*ip - CEE_LDARG_0 >= max_args)
 938                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have argument %d at 0x%04x", *ip - CEE_LDARG_0, ip_offset));
 939                         CHECK_STACK_OVERFLOW ();
 940                         ++cur_stack;
 941                         ++ip;
 942                         break;
 943                 case CEE_LDLOC_0:
 944                 case CEE_LDLOC_1:
 945                 case CEE_LDLOC_2:
 946                 case CEE_LDLOC_3:
 947                         if (*ip - CEE_LDLOC_0 >= header->num_locals)
 948                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", *ip - CEE_LDLOC_0, ip_offset));
 949                         if (0 && !local_state [*ip - CEE_LDLOC_0])
 950                                 ADD_INVALID (list, g_strdup_printf ("Local var %d is initialized at 0x%04x", *ip - CEE_LDLOC_0, ip_offset));
 951                         CHECK_STACK_OVERFLOW ();
 952                         ++cur_stack;
 953                         ++ip;
 954                         break;
 955                 case CEE_STLOC_0:
 956                 case CEE_STLOC_1:
 957                 case CEE_STLOC_2:
 958                 case CEE_STLOC_3:
 959                         if (*ip - CEE_STLOC_0 >= header->num_locals)
 960                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", *ip - CEE_STLOC_0, ip_offset));
 961                         local_state [*ip - CEE_STLOC_0] = 1;
 962                         CHECK_STACK_UNDERFLOW (1);
 963                         --cur_stack;
 964                         ++ip;
 965                         break;
 966                 case CEE_LDARG_S:
 967                 case CEE_LDARGA_S:
 968                         if (ip [1] >= max_args)
 969                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have argument %d at 0x%04x", ip [1], ip_offset));
 970                         CHECK_STACK_OVERFLOW ();
 971                         ++cur_stack;
 972                         ip += 2;
 973                         break;
 974                 case CEE_STARG_S:
 975                         if (ip [1] >= max_args)
 976                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have argument %d at 0x%04x", ip [1], ip_offset));
 977                         CHECK_STACK_UNDERFLOW (1);
 978                         --cur_stack;
 979                         ip += 2;
 980                         break;
 981                 case CEE_LDLOC_S:
 982                 case CEE_LDLOCA_S:
 983                         if (ip [1] >= header->num_locals)
 984                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", ip [1], ip_offset));
 985                         /* no need to check if the var is initialized if the address is taken */
 986                         if (0 && *ip == CEE_LDLOC_S && !local_state [ip [1]])
 987                                 ADD_INVALID (list, g_strdup_printf ("Local var %d is initialized at 0x%04x", ip [1], ip_offset));
 988                         CHECK_STACK_OVERFLOW ();
 989                         ++cur_stack;
 990                         ip += 2;
 991                         break;
 992                 case CEE_STLOC_S:
 993                         if (ip [1] >= header->num_locals)
 994                                 ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", ip [1], ip_offset));
 995                         local_state [ip [1]] = 1;
 996                         CHECK_STACK_UNDERFLOW (1);
 997                         --cur_stack;
 998                         ip += 2;
 999                         break;
1000                 case CEE_LDNULL:
1001                         CHECK_STACK_OVERFLOW ();
1002                         ++cur_stack;
1003                         ++ip;
1004                         break;
1005                 case CEE_LDC_I4_M1:
1006                 case CEE_LDC_I4_0:
1007                 case CEE_LDC_I4_1:
1008                 case CEE_LDC_I4_2:
1009                 case CEE_LDC_I4_3:
1010                 case CEE_LDC_I4_4:
1011                 case CEE_LDC_I4_5:
1012                 case CEE_LDC_I4_6:
1013                 case CEE_LDC_I4_7:
1014                 case CEE_LDC_I4_8:
1015                         CHECK_STACK_OVERFLOW ();
1016                         ++cur_stack;
1017                         ++ip;
1018                         break;
1019                 case CEE_LDC_I4_S:
1020                         CHECK_STACK_OVERFLOW ();
1021                         ++cur_stack;
1022                         ip += 2;
1023                         break;
1024                 case CEE_LDC_I4:
1025                         CHECK_STACK_OVERFLOW ();
1026                         ++cur_stack;
1027                         ip += 5;
1028                         break;
1029                 case CEE_LDC_I8:
1030                         CHECK_STACK_OVERFLOW ();
1031                         ++cur_stack;
1032                         ip += 9;
1033                         break;
1034                 case CEE_LDC_R4:
1035                         CHECK_STACK_OVERFLOW ();
1036                         ++cur_stack;
1037                         ip += 5;
1038                         break;
1039                 case CEE_LDC_R8:
1040                         CHECK_STACK_OVERFLOW ();
1041                         ++cur_stack;
1042                         ip += 9;
1043                         break;
1044                 case CEE_UNUSED99: ++ip; break; /* warn/error instead? */
1045                 case CEE_DUP:
1046                         CHECK_STACK_UNDERFLOW (1);
1047                         CHECK_STACK_OVERFLOW ();
1048                         ++cur_stack;
1049                         ++ip;
1050                         break;
1051                 case CEE_POP:
1052                         CHECK_STACK_UNDERFLOW (1);
1053                         --cur_stack;
1054                         ++ip;
1055                         break;
1056                 case CEE_JMP:
1057                         if (cur_stack)
1058                                 ADD_INVALID (list, g_strdup_printf ("Eval stack must be empty in jmp at 0x%04x", ip_offset));
1059                         token = read32 (ip + 1);
1060                         if (in_any_block (header, ip_offset))
1061                                 ADD_INVALID (list, g_strdup_printf ("jmp cannot escape exception blocks at 0x%04x", ip_offset));
1062                         /*
1063                          * FIXME: check signature, retval, arguments etc.
1064                          */
1065                         ip += 5;
1066                         break;
1067                 case CEE_CALL:
1068                 case CEE_CALLVIRT:
1069                         token = read32 (ip + 1);
1070                         /*
1071                          * FIXME: we could just load the signature ...
1072                          */
1073                         cmethod = mono_get_method (image, token, NULL);
1074                         if (!cmethod)
1075                                 ADD_INVALID (list, g_strdup_printf ("Method 0x%08x not found at 0x%04x", token, ip_offset));
1076                         csig = cmethod->signature;
1077                         CHECK_STACK_UNDERFLOW (csig->param_count + csig->hasthis);
1078                         cur_stack -= csig->param_count + csig->hasthis;
1079                         if (csig->ret->type != MONO_TYPE_VOID) {
1080                                 CHECK_STACK_OVERFLOW ();
1081                                 ++cur_stack;
1082                         }
1083                         ip += 5;
1084                         break;
1085                 case CEE_CALLI:
1086                         token = read32 (ip + 1);
1087                         /*
1088                          * FIXME: check signature, retval, arguments etc.
1089                          */
1090                         ip += 5;
1091                         break;
1092                 case CEE_RET:
1093                         if (signature->ret->type != MONO_TYPE_VOID) {
1094                                 CHECK_STACK_UNDERFLOW (1);
1095                                 --cur_stack;
1096                         }
1097                         if (cur_stack)
1098                                 ADD_INVALID (list, g_strdup_printf ("Stack not empty (%d) after ret at 0x%04x", cur_stack, ip_offset));
1099                         cur_stack = 0;
1100                         if (in_any_block (header, ip_offset))
1101                                 ADD_INVALID (list, g_strdup_printf ("ret cannot escape exception blocks at 0x%04x", ip_offset));
1102                         ++ip;
1103                         break;
1104                 case CEE_BR_S:
1105                         target = ip + (signed char)ip [1] + 2;
1106                         if (target >= end || target < header->code)
1107                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1108                         if (!in_same_block (header, ip_offset, target - header->code))
1109                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1110                         ip += 2;
1111                         start = 1;
1112                         break;
1113                 case CEE_BRFALSE_S:
1114                 case CEE_BRTRUE_S:
1115                         target = ip + (signed char)ip [1] + 2;
1116                         if (target >= end || target < header->code)
1117                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1118                         if (!in_same_block (header, ip_offset, target - header->code))
1119                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1120                         CHECK_STACK_UNDERFLOW (1);
1121                         --cur_stack;
1122                         ip += 2;
1123                         need_merge = 1;
1124                         break;
1125                 case CEE_BEQ_S:
1126                 case CEE_BGE_S:
1127                 case CEE_BGT_S:
1128                 case CEE_BLE_S:
1129                 case CEE_BLT_S:
1130                 case CEE_BNE_UN_S:
1131                 case CEE_BGE_UN_S:
1132                 case CEE_BGT_UN_S:
1133                 case CEE_BLE_UN_S:
1134                 case CEE_BLT_UN_S:
1135                         target = ip + (signed char)ip [1] + 2;
1136                         if (target >= end || target < header->code)
1137                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1138                         if (!in_same_block (header, ip_offset, target - header->code))
1139                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1140                         CHECK_STACK_UNDERFLOW (2);
1141                         cur_stack -= 2;
1142                         ip += 2;
1143                         need_merge = 1;
1144                         break;
1145                 case CEE_BR:
1146                         target = ip + (gint32)read32 (ip + 1) + 5;
1147                         if (target >= end || target < header->code)
1148                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1149                         if (!in_same_block (header, ip_offset, target - header->code))
1150                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1151                         ip += 5;
1152                         start = 1;
1153                         break;
1154                 case CEE_BRFALSE:
1155                 case CEE_BRTRUE:
1156                         target = ip + (gint32)read32 (ip + 1) + 5;
1157                         if (target >= end || target < header->code)
1158                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1159                         if (!in_same_block (header, ip_offset, target - header->code))
1160                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1161                         CHECK_STACK_UNDERFLOW (1);
1162                         --cur_stack;
1163                         ip += 5;
1164                         need_merge = 1;
1165                         break;
1166                 case CEE_BEQ:
1167                 case CEE_BGE:
1168                 case CEE_BGT:
1169                 case CEE_BLE:
1170                 case CEE_BLT:
1171                 case CEE_BNE_UN:
1172                 case CEE_BGE_UN:
1173                 case CEE_BGT_UN:
1174                 case CEE_BLE_UN:
1175                 case CEE_BLT_UN:
1176                         target = ip + (gint32)read32 (ip + 1) + 5;
1177                         if (target >= end || target < header->code)
1178                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1179                         if (!in_same_block (header, ip_offset, target - header->code))
1180                                 ADD_INVALID (list, g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", ip_offset));
1181                         CHECK_STACK_UNDERFLOW (2);
1182                         cur_stack -= 2;
1183                         ip += 5;
1184                         need_merge = 1;
1185                         break;
1186                 case CEE_SWITCH:
1187                         n = read32 (ip + 1);
1188                         target = ip + sizeof (guint32) * n;
1189                         /* FIXME: check that ip is in range (and within the same exception block) */
1190                         for (i = 0; i < n; ++i)
1191                                 if (target + (gint32) read32 (ip + 5 + i * sizeof (gint32)) >= end || target + (gint32) read32 (ip + 5 + i * sizeof (gint32)) < header->code)
1192                                         ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1193                         CHECK_STACK_UNDERFLOW (1);
1194                         --cur_stack;
1195                         ip += 5 + sizeof (guint32) * n;
1196                         break;
1197                 case CEE_LDIND_I1:
1198                 case CEE_LDIND_U1:
1199                 case CEE_LDIND_I2:
1200                 case CEE_LDIND_U2:
1201                 case CEE_LDIND_I4:
1202                 case CEE_LDIND_U4:
1203                 case CEE_LDIND_I8:
1204                 case CEE_LDIND_I:
1205                 case CEE_LDIND_R4:
1206                 case CEE_LDIND_R8:
1207                 case CEE_LDIND_REF:
1208                         CHECK_STACK_UNDERFLOW (1);
1209                         ++ip;
1210                         break;
1211                 case CEE_STIND_REF:
1212                 case CEE_STIND_I1:
1213                 case CEE_STIND_I2:
1214                 case CEE_STIND_I4:
1215                 case CEE_STIND_I8:
1216                 case CEE_STIND_R4:
1217                 case CEE_STIND_R8:
1218                         CHECK_STACK_UNDERFLOW (2);
1219                         cur_stack -= 2;
1220                         ++ip;
1221                         break;
1222                 case CEE_ADD:
1223                 case CEE_SUB:
1224                 case CEE_MUL:
1225                 case CEE_DIV:
1226                 case CEE_DIV_UN:
1227                 case CEE_REM:
1228                 case CEE_REM_UN:
1229                 case CEE_AND:
1230                 case CEE_OR:
1231                 case CEE_XOR:
1232                 case CEE_SHL:
1233                 case CEE_SHR:
1234                 case CEE_SHR_UN:
1235                         CHECK_STACK_UNDERFLOW (2);
1236                         --cur_stack;
1237                         ++ip;
1238                         break;
1239                 case CEE_NEG:
1240                 case CEE_NOT:
1241                 case CEE_CONV_I1:
1242                 case CEE_CONV_I2:
1243                 case CEE_CONV_I4:
1244                 case CEE_CONV_I8:
1245                 case CEE_CONV_R4:
1246                 case CEE_CONV_R8:
1247                 case CEE_CONV_U4:
1248                 case CEE_CONV_U8:
1249                         CHECK_STACK_UNDERFLOW (1);
1250                         ++ip;
1251                         break;
1252                 case CEE_CPOBJ:
1253                         token = read32 (ip + 1);
1254                         CHECK_STACK_UNDERFLOW (2);
1255                         cur_stack -= 2;
1256                         ip += 5;
1257                         break;
1258                 case CEE_LDOBJ:
1259                         token = read32 (ip + 1);
1260                         CHECK_STACK_UNDERFLOW (1);
1261                         ip += 5;
1262                         break;
1263                 case CEE_LDSTR:
1264                         token = read32 (ip + 1);
1265                         CHECK_STACK_OVERFLOW ();
1266                         ++cur_stack;
1267                         ip += 5;
1268                         break;
1269                 case CEE_NEWOBJ:
1270                         token = read32 (ip + 1);
1271                         /*
1272                          * FIXME: we could just load the signature ...
1273                          */
1274                         cmethod = mono_get_method (image, token, NULL);
1275                         if (!cmethod)
1276                                 ADD_INVALID (list, g_strdup_printf ("Constructor 0x%08x not found at 0x%04x", token, ip_offset));
1277                         csig = cmethod->signature;
1278                         CHECK_STACK_UNDERFLOW (csig->param_count);
1279                         cur_stack -= csig->param_count;
1280                         CHECK_STACK_OVERFLOW ();
1281                         ++cur_stack;
1282                         ip += 5;
1283                         break;
1284                 case CEE_CASTCLASS:
1285                 case CEE_ISINST:
1286                         token = read32 (ip + 1);
1287                         CHECK_STACK_UNDERFLOW (1);
1288                         ip += 5;
1289                         break;
1290                 case CEE_CONV_R_UN:
1291                         CHECK_STACK_UNDERFLOW (1);
1292                         ++ip;
1293                         break;
1294                 case CEE_UNUSED58:
1295                 case CEE_UNUSED1:
1296                         ++ip; /* warn, error ? */
1297                         break;
1298                 case CEE_UNBOX:
1299                         token = read32 (ip + 1);
1300                         CHECK_STACK_UNDERFLOW (1);
1301                         ip += 5;
1302                         break;
1303                 case CEE_THROW:
1304                         CHECK_STACK_UNDERFLOW (1);
1305                         --cur_stack;
1306                         ++ip;
1307                         start = 1;
1308                         break;
1309                 case CEE_LDFLD:
1310                         CHECK_STACK_UNDERFLOW (1);
1311                         token = read32 (ip + 1);
1312                         ip += 5;
1313                         break;
1314                 case CEE_LDFLDA:
1315                         CHECK_STACK_UNDERFLOW (1);
1316                         token = read32 (ip + 1);
1317                         ip += 5;
1318                         break;
1319                 case CEE_STFLD:
1320                         CHECK_STACK_UNDERFLOW (2);
1321                         cur_stack -= 2;
1322                         token = read32 (ip + 1);
1323                         ip += 5;
1324                         break;
1325                 case CEE_LDSFLD:
1326                         CHECK_STACK_OVERFLOW ();
1327                         token = read32 (ip + 1);
1328                         ++cur_stack;
1329                         ip += 5;
1330                         break;
1331                 case CEE_LDSFLDA:
1332                         CHECK_STACK_OVERFLOW ();
1333                         token = read32 (ip + 1);
1334                         ++cur_stack;
1335                         ip += 5;
1336                         break;
1337                 case CEE_STSFLD:
1338                         CHECK_STACK_UNDERFLOW (1);
1339                         --cur_stack;
1340                         token = read32 (ip + 1);
1341                         ip += 5;
1342                         break;
1343                 case CEE_STOBJ:
1344                         CHECK_STACK_UNDERFLOW (2);
1345                         cur_stack -= 2;
1346                         token = read32 (ip + 1);
1347                         ip += 5;
1348                         break;
1349                 case CEE_CONV_OVF_I1_UN:
1350                 case CEE_CONV_OVF_I2_UN:
1351                 case CEE_CONV_OVF_I4_UN:
1352                 case CEE_CONV_OVF_I8_UN:
1353                 case CEE_CONV_OVF_U1_UN:
1354                 case CEE_CONV_OVF_U2_UN:
1355                 case CEE_CONV_OVF_U4_UN:
1356                 case CEE_CONV_OVF_U8_UN:
1357                 case CEE_CONV_OVF_I_UN:
1358                 case CEE_CONV_OVF_U_UN:
1359                         CHECK_STACK_UNDERFLOW (1);
1360                         ++ip;
1361                         break;
1362                 case CEE_BOX:
1363                         CHECK_STACK_UNDERFLOW (1);
1364                         token = read32 (ip + 1);
1365                         ip += 5;
1366                         break;
1367                 case CEE_NEWARR:
1368                         CHECK_STACK_UNDERFLOW (1);
1369                         token = read32 (ip + 1);
1370                         ip += 5;
1371                         break;
1372                 case CEE_LDLEN:
1373                         CHECK_STACK_UNDERFLOW (1);
1374                         ++ip;
1375                         break;
1376                 case CEE_LDELEMA:
1377                         CHECK_STACK_UNDERFLOW (2);
1378                         --cur_stack;
1379                         token = read32 (ip + 1);
1380                         ip += 5;
1381                         break;
1382                 case CEE_LDELEM_I1:
1383                 case CEE_LDELEM_U1:
1384                 case CEE_LDELEM_I2:
1385                 case CEE_LDELEM_U2:
1386                 case CEE_LDELEM_I4:
1387                 case CEE_LDELEM_U4:
1388                 case CEE_LDELEM_I8:
1389                 case CEE_LDELEM_I:
1390                 case CEE_LDELEM_R4:
1391                 case CEE_LDELEM_R8:
1392                 case CEE_LDELEM_REF:
1393                         CHECK_STACK_UNDERFLOW (2);
1394                         --cur_stack;
1395                         ++ip;
1396                         break;
1397                 case CEE_STELEM_I:
1398                 case CEE_STELEM_I1:
1399                 case CEE_STELEM_I2:
1400                 case CEE_STELEM_I4:
1401                 case CEE_STELEM_I8:
1402                 case CEE_STELEM_R4:
1403                 case CEE_STELEM_R8:
1404                 case CEE_STELEM_REF:
1405                         CHECK_STACK_UNDERFLOW (3);
1406                         cur_stack -= 3;
1407                         ++ip;
1408                         break;
1409                 case CEE_UNUSED2:
1410                 case CEE_UNUSED3:
1411                 case CEE_UNUSED4:
1412                 case CEE_UNUSED5:
1413                 case CEE_UNUSED6:
1414                 case CEE_UNUSED7:
1415                 case CEE_UNUSED8:
1416                 case CEE_UNUSED9:
1417                 case CEE_UNUSED10:
1418                 case CEE_UNUSED11:
1419                 case CEE_UNUSED12:
1420                 case CEE_UNUSED13:
1421                 case CEE_UNUSED14:
1422                 case CEE_UNUSED15:
1423                 case CEE_UNUSED16:
1424                 case CEE_UNUSED17:
1425                         ++ip; /* warn, error ? */
1426                         break;
1427                 case CEE_CONV_OVF_I1:
1428                 case CEE_CONV_OVF_U1:
1429                 case CEE_CONV_OVF_I2:
1430                 case CEE_CONV_OVF_U2:
1431                 case CEE_CONV_OVF_I4:
1432                 case CEE_CONV_OVF_U4:
1433                 case CEE_CONV_OVF_I8:
1434                 case CEE_CONV_OVF_U8:
1435                         CHECK_STACK_UNDERFLOW (1);
1436                         ++ip;
1437                         break;
1438                 case CEE_UNUSED50:
1439                 case CEE_UNUSED18:
1440                 case CEE_UNUSED19:
1441                 case CEE_UNUSED20:
1442                 case CEE_UNUSED21:
1443                 case CEE_UNUSED22:
1444                 case CEE_UNUSED23:
1445                         ++ip; /* warn, error ? */
1446                         break;
1447                 case CEE_REFANYVAL:
1448                         CHECK_STACK_UNDERFLOW (1);
1449                         ++ip;
1450                         break;
1451                 case CEE_CKFINITE:
1452                         CHECK_STACK_UNDERFLOW (1);
1453                         ++ip;
1454                         break;
1455                 case CEE_UNUSED24:
1456                 case CEE_UNUSED25:
1457                         ++ip; /* warn, error ? */
1458                         break;
1459                 case CEE_MKREFANY:
1460                         CHECK_STACK_UNDERFLOW (1);
1461                         token = read32 (ip + 1);
1462                         ip += 5;
1463                         break;
1464                 case CEE_UNUSED59:
1465                 case CEE_UNUSED60:
1466                 case CEE_UNUSED61:
1467                 case CEE_UNUSED62:
1468                 case CEE_UNUSED63:
1469                 case CEE_UNUSED64:
1470                 case CEE_UNUSED65:
1471                 case CEE_UNUSED66:
1472                 case CEE_UNUSED67:
1473                         ++ip; /* warn, error ? */
1474                         break;
1475                 case CEE_LDTOKEN:
1476                         CHECK_STACK_OVERFLOW ();
1477                         token = read32 (ip + 1);
1478                         ++cur_stack;
1479                         ip += 5;
1480                         break;
1481                 case CEE_CONV_U2:
1482                 case CEE_CONV_U1:
1483                 case CEE_CONV_I:
1484                 case CEE_CONV_OVF_I:
1485                 case CEE_CONV_OVF_U:
1486                         CHECK_STACK_UNDERFLOW (1);
1487                         ++ip;
1488                         break;
1489                 case CEE_ADD_OVF:
1490                 case CEE_ADD_OVF_UN:
1491                 case CEE_MUL_OVF:
1492                 case CEE_MUL_OVF_UN:
1493                 case CEE_SUB_OVF:
1494                 case CEE_SUB_OVF_UN:
1495                         CHECK_STACK_UNDERFLOW (2);
1496                         --cur_stack;
1497                         ++ip;
1498                         break;
1499                 case CEE_ENDFINALLY:
1500                         ++ip;
1501                         start = 1;
1502                         break;
1503                 case CEE_LEAVE:
1504                         target = ip + (gint32)read32(ip + 1) + 5;
1505                         if (target >= end || target < header->code)
1506                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1507                         if (!is_correct_leave (header, ip_offset, target - header->code))
1508                                 ADD_INVALID (list, g_strdup_printf ("Leave not allowed in finally block at 0x%04x", ip_offset));
1509                         ip += 5;
1510                         start = 1;
1511                         break;
1512                 case CEE_LEAVE_S:
1513                         target = ip + (signed char)ip [1] + 2;
1514                         if (target >= end || target < header->code)
1515                                 ADD_INVALID (list, g_strdup_printf ("Branch target out of code at 0x%04x", ip_offset));
1516                         if (!is_correct_leave (header, ip_offset, target - header->code))
1517                                 ADD_INVALID (list, g_strdup_printf ("Leave not allowed in finally block at 0x%04x", ip_offset));
1518                         ip += 2;
1519                         start = 1;
1520                         break;
1521                 case CEE_STIND_I:
1522                         CHECK_STACK_UNDERFLOW (2);
1523                         cur_stack -= 2;
1524                         ++ip;
1525                         break;
1526                 case CEE_CONV_U:
1527                         CHECK_STACK_UNDERFLOW (1);
1528                         ++ip;
1529                         break;
1530                 case CEE_UNUSED26:
1531                 case CEE_UNUSED27:
1532                 case CEE_UNUSED28:
1533                 case CEE_UNUSED29:
1534                 case CEE_UNUSED30:
1535                 case CEE_UNUSED31:
1536                 case CEE_UNUSED32:
1537                 case CEE_UNUSED33:
1538                 case CEE_UNUSED34:
1539                 case CEE_UNUSED35:
1540                 case CEE_UNUSED36:
1541                 case CEE_UNUSED37:
1542                 case CEE_UNUSED38:
1543                 case CEE_UNUSED39:
1544                 case CEE_UNUSED40:
1545                 case CEE_UNUSED41:
1546                 case CEE_UNUSED42:
1547                 case CEE_UNUSED43:
1548                 case CEE_UNUSED44:
1549                 case CEE_UNUSED45:
1550                 case CEE_UNUSED46:
1551                 case CEE_UNUSED47:
1552                 case CEE_UNUSED48:
1553                         ++ip;
1554                         break;
1555                 case CEE_PREFIX7:
1556                 case CEE_PREFIX6:
1557                 case CEE_PREFIX5:
1558                 case CEE_PREFIX4:
1559                 case CEE_PREFIX3:
1560                 case CEE_PREFIX2:
1561                 case CEE_PREFIXREF:
1562                         ++ip;
1563                         break;
1564                 case CEE_PREFIX1:
1565                         ++ip;
1566                         switch (*ip) {
1567                         case CEE_ARGLIST:
1568                                 CHECK_STACK_OVERFLOW ();
1569                                 ++ip;
1570                                 break;
1571                         case CEE_CEQ:
1572                         case CEE_CGT:
1573                         case CEE_CGT_UN:
1574                         case CEE_CLT:
1575                         case CEE_CLT_UN:
1576                                 CHECK_STACK_UNDERFLOW (2);
1577                                 --cur_stack;
1578                                 ++ip;
1579                                 break;
1580                         case CEE_LDFTN:
1581                                 CHECK_STACK_OVERFLOW ();
1582                                 token = read32 (ip + 1);
1583                                 ip += 5;
1584                                 cur_stack++;
1585                                 break;
1586                         case CEE_LDVIRTFTN:
1587                                 CHECK_STACK_UNDERFLOW (1);
1588                                 token = read32 (ip + 1);
1589                                 ip += 5;
1590                                 cur_stack++;
1591                                 break;
1592                         case CEE_UNUSED56:
1593                                 ++ip;
1594                                 break;
1595                         case CEE_LDARG:
1596                         case CEE_LDARGA:
1597                                 if (read16 (ip + 1) >= max_args)
1598                                         ADD_INVALID (list, g_strdup_printf ("Method doesn't have argument %d at 0x%04x", read16 (ip + 1), ip_offset));
1599                                 CHECK_STACK_OVERFLOW ();
1600                                 ++cur_stack;
1601                                 ip += 3;
1602                                 break;
1603                         case CEE_STARG:
1604                                 if (read16 (ip + 1) >= max_args)
1605                                         ADD_INVALID (list, g_strdup_printf ("Method doesn't have argument %d at 0x%04x", read16(ip + 1), ip_offset));
1606                                 CHECK_STACK_UNDERFLOW (1);
1607                                 --cur_stack;
1608                                 ip += 3;
1609                                 break;
1610                         case CEE_LDLOC:
1611                         case CEE_LDLOCA:
1612                                 if (read16 (ip + 1) >= header->num_locals)
1613                                         ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", read16 (ip + 1), ip_offset));
1614                                 /* no need to check if the var is initialized if the address is taken */
1615                                 if (0 && *ip == CEE_LDLOC && !local_state [read16 (ip + 1)])
1616                                         ADD_INVALID (list, g_strdup_printf ("Local var %d is initialized at 0x%04x", read16 (ip + 1), ip_offset));
1617                                 CHECK_STACK_OVERFLOW ();
1618                                 ++cur_stack;
1619                                 ip += 3;
1620                                 break;
1621                         case CEE_STLOC:
1622                                 if (read16 (ip + 1) >= header->num_locals)
1623                                         ADD_INVALID (list, g_strdup_printf ("Method doesn't have local var %d at 0x%04x", read16 (ip + 1), ip_offset));
1624                                 local_state [read16 (ip + 1)] = 1;
1625                                 CHECK_STACK_UNDERFLOW (1);
1626                                 --cur_stack;
1627                                 ip += 3;
1628                                 break;
1629                         case CEE_LOCALLOC:
1630                                 if (cur_stack != 1)
1631                                         ADD_INVALID (list, g_strdup_printf ("Stack must have only size item in localloc at 0x%04x", ip_offset));
1632                                 ++ip;
1633                                 break;
1634                         case CEE_UNUSED57:
1635                                 ++ip;
1636                                 break;
1637                         case CEE_ENDFILTER:
1638                                 if (cur_stack != 1)
1639                                         ADD_INVALID (list, g_strdup_printf ("Stack must have only filter result in endfilter at 0x%04x", ip_offset));
1640                                 ++ip;
1641                                 break;
1642                         case CEE_UNALIGNED_:
1643                                 prefix |= PREFIX_UNALIGNED;
1644                                 ++ip;
1645                                 break;
1646                         case CEE_VOLATILE_:
1647                                 prefix |= PREFIX_VOLATILE;
1648                                 ++ip;
1649                                 break;
1650                         case CEE_TAIL_:
1651                                 prefix |= PREFIX_TAIL;
1652                                 ++ip;
1653                                 if (ip < end && (*ip != CEE_CALL && *ip != CEE_CALLI && *ip != CEE_CALLVIRT))
1654                                         ADD_INVALID (list, g_strdup_printf ("tail prefix must be used only with call opcodes at 0x%04x", ip_offset));
1655                                 break;
1656                         case CEE_INITOBJ:
1657                                 CHECK_STACK_UNDERFLOW (1);
1658                                 token = read32 (ip + 1);
1659                                 ip += 5;
1660                                 --cur_stack;
1661                                 break;
1662                         case CEE_UNUSED68:
1663                                 ++ip;
1664                                 break;
1665                         case CEE_CPBLK:
1666                                 CHECK_STACK_UNDERFLOW (3);
1667                                 ip++;
1668                                 break;
1669                         case CEE_INITBLK:
1670                                 CHECK_STACK_UNDERFLOW (3);
1671                                 ip++;
1672                                 break;
1673                         case CEE_UNUSED69:
1674                                 ++ip;
1675                                 break;
1676                         case CEE_RETHROW:
1677                                 ++ip;
1678                                 break;
1679                         case CEE_UNUSED:
1680                                 ++ip;
1681                                 break;
1682                         case CEE_SIZEOF:
1683                                 CHECK_STACK_OVERFLOW ();
1684                                 token = read32 (ip + 1);
1685                                 ip += 5;
1686                                 cur_stack++;
1687                                 break;
1688                         case CEE_REFANYTYPE:
1689                                 CHECK_STACK_UNDERFLOW (1);
1690                                 ++ip;
1691                                 break;
1692                         case CEE_UNUSED52:
1693                         case CEE_UNUSED53:
1694                         case CEE_UNUSED54:
1695                         case CEE_UNUSED55:
1696                         case CEE_UNUSED70:
1697                                 ++ip;
1698                                 break;
1699                         }
1700                 }
1701         }
1702         /*
1703          * FIXME: if ip != end we overflowed: mark as error.
1704          */
1705 invalid_cil:
1706
1707         g_free (local_state);
1708         g_free (code);
1709         return list;
1710 }
1711
1712 typedef struct {
1713         const char *name;
1714         guint64 offset;
1715 } FieldDesc;
1716
1717 typedef struct {
1718         const char *name;
1719         const FieldDesc *fields;
1720 } ClassDesc;
1721
1722 static const FieldDesc
1723 typebuilder_fields[] = {
1724         {"tname", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, name)},
1725         {"nspace", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, nspace)},
1726         {"parent", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, parent)},
1727         {"interfaces", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, interfaces)},
1728         {"methods", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, methods)},
1729         {"properties", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, properties)},
1730         {"fields", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, fields)},
1731         {"attrs", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, attrs)},
1732         {"table_idx", G_STRUCT_OFFSET (MonoReflectionTypeBuilder, table_idx)},
1733         {NULL, 0}
1734 };
1735
1736 static const FieldDesc
1737 modulebuilder_fields[] = {
1738         {"types", G_STRUCT_OFFSET (MonoReflectionModuleBuilder, types)},
1739         {"cattrs", G_STRUCT_OFFSET (MonoReflectionModuleBuilder, cattrs)},
1740         {"guid", G_STRUCT_OFFSET (MonoReflectionModuleBuilder, guid)},
1741         {"table_idx", G_STRUCT_OFFSET (MonoReflectionModuleBuilder, table_idx)},
1742         {NULL, 0}
1743 };
1744
1745 static const FieldDesc
1746 assemblybuilder_fields[] = {
1747         {"entry_point", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, entry_point)},
1748         {"modules", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, modules)},
1749         {"name", G_STRUCT_OFFSET (MonoReflectionAssemblyBuilder, name)},
1750         {NULL, 0}
1751 };
1752
1753 static const FieldDesc
1754 ctorbuilder_fields[] = {
1755         {"ilgen", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, ilgen)},
1756         {"parameters", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, parameters)},
1757         {"attrs", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, attrs)},
1758         {"iattrs", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, iattrs)},
1759         {"table_idx", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, table_idx)},
1760         {"call_conv", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, call_conv)},
1761         {"type", G_STRUCT_OFFSET (MonoReflectionCtorBuilder, type)},
1762         {NULL, 0}
1763 };
1764
1765 static const FieldDesc
1766 methodbuilder_fields[] = {
1767         {"mhandle", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, mhandle)},
1768         {"rtype", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, rtype)},
1769         {"parameters", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, parameters)},
1770         {"attrs", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, attrs)},
1771         {"iattrs", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, iattrs)},
1772         {"name", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, name)},
1773         {"table_idx", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, table_idx)},
1774         {"code", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, code)},
1775         {"ilgen", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, ilgen)},
1776         {"type", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, type)},
1777         {"pinfo", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, pinfo)},
1778         {"pi_dll", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, dll)},
1779         {"pi_entry", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, dllentry)},
1780         {"ncharset", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, charset)},
1781         {"native_cc", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, native_cc)},
1782         {"call_conv", G_STRUCT_OFFSET (MonoReflectionMethodBuilder, call_conv)},
1783         {NULL, 0}
1784 };
1785
1786 static const FieldDesc
1787 fieldbuilder_fields[] = {
1788         {"attrs", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, attrs)},
1789         {"type", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, type)},
1790         {"name", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, name)},
1791         {"def_value", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, def_value)},
1792         {"offset", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, offset)},
1793         {"table_idx", G_STRUCT_OFFSET (MonoReflectionFieldBuilder, table_idx)},
1794         {NULL, 0}
1795 };
1796
1797 static const FieldDesc
1798 propertybuilder_fields[] = {
1799         {"attrs", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, attrs)},
1800         {"name", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, name)},
1801         {"type", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, type)},
1802         {"parameters", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, parameters)},
1803         {"def_value", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, def_value)},
1804         {"set_method", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, set_method)},
1805         {"get_method", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, get_method)},
1806         {"table_idx", G_STRUCT_OFFSET (MonoReflectionPropertyBuilder, table_idx)},
1807         {NULL, 0}
1808 };
1809
1810 static const FieldDesc
1811 ilgenerator_fields[] = {
1812         {"code", G_STRUCT_OFFSET (MonoReflectionILGen, code)},
1813         {"mbuilder", G_STRUCT_OFFSET (MonoReflectionILGen, mbuilder)},
1814         {"code_len", G_STRUCT_OFFSET (MonoReflectionILGen, code_len)},
1815         {"max_stack", G_STRUCT_OFFSET (MonoReflectionILGen, max_stack)},
1816         {"cur_stack", G_STRUCT_OFFSET (MonoReflectionILGen, cur_stack)},
1817         {"locals", G_STRUCT_OFFSET (MonoReflectionILGen, locals)},
1818         {"ex_handlers", G_STRUCT_OFFSET (MonoReflectionILGen, ex_handlers)},
1819         {NULL, 0}
1820 };
1821
1822 static const FieldDesc
1823 ilexinfo_fields[] = {
1824         {"handlers", G_STRUCT_OFFSET (MonoILExceptionInfo, handlers)},
1825         {"start", G_STRUCT_OFFSET (MonoILExceptionInfo, start)},
1826         {"len", G_STRUCT_OFFSET (MonoILExceptionInfo, len)},
1827         {"end", G_STRUCT_OFFSET (MonoILExceptionInfo, label)},
1828         {NULL, 0}
1829 };
1830
1831 static const FieldDesc
1832 ilexblock_fields[] = {
1833         {"extype", G_STRUCT_OFFSET (MonoILExceptionBlock, extype)},
1834         {"type", G_STRUCT_OFFSET (MonoILExceptionBlock, type)},
1835         {"start", G_STRUCT_OFFSET (MonoILExceptionBlock, start)},
1836         {"len", G_STRUCT_OFFSET (MonoILExceptionBlock, len)},
1837         {"filter_offset", G_STRUCT_OFFSET (MonoILExceptionBlock, filter_offset)},
1838         {NULL, 0}
1839 };
1840
1841 static const ClassDesc
1842 emit_classes_to_check [] = {
1843         {"TypeBuilder", typebuilder_fields},
1844         {"ModuleBuilder", modulebuilder_fields},
1845         {"AssemblyBuilder", assemblybuilder_fields},
1846         {"ConstructorBuilder", ctorbuilder_fields},
1847         {"MethodBuilder", methodbuilder_fields},
1848         {"FieldBuilder", fieldbuilder_fields},
1849         {"PropertyBuilder", propertybuilder_fields},
1850         {"ILGenerator", ilgenerator_fields},
1851         {"ILExceptionBlock", ilexblock_fields},
1852         {"ILExceptionInfo", ilexinfo_fields},
1853         {NULL, NULL}
1854 };
1855
1856 static const FieldDesc
1857 monoevent_fields[] = {
1858         {"klass", G_STRUCT_OFFSET (MonoReflectionEvent, klass)},
1859         {"handle", G_STRUCT_OFFSET (MonoReflectionEvent, event)},
1860         {NULL, 0}
1861 };
1862
1863 static const FieldDesc
1864 monoproperty_fields[] = {
1865         {"klass", G_STRUCT_OFFSET (MonoReflectionProperty, klass)},
1866         {"prop", G_STRUCT_OFFSET (MonoReflectionProperty, property)},
1867         {NULL, 0}
1868 };
1869
1870 static const FieldDesc
1871 monofield_fields[] = {
1872         {"klass", G_STRUCT_OFFSET (MonoReflectionField, klass)},
1873         {"fhandle", G_STRUCT_OFFSET (MonoReflectionField, field)},
1874         {NULL, 0}
1875 };
1876
1877 static const FieldDesc
1878 monomethodinfo_fields[] = {
1879         {"parent", G_STRUCT_OFFSET (MonoMethodInfo, parent)},
1880         {"ret", G_STRUCT_OFFSET (MonoMethodInfo, ret)},
1881         {"attrs", G_STRUCT_OFFSET (MonoMethodInfo, attrs)},
1882         {"iattrs", G_STRUCT_OFFSET (MonoMethodInfo, implattrs)},
1883         {NULL, 0}
1884 };
1885
1886 static const FieldDesc
1887 monopropertyinfo_fields[] = {
1888         {"parent", G_STRUCT_OFFSET (MonoPropertyInfo, parent)},
1889         {"name", G_STRUCT_OFFSET (MonoPropertyInfo, name)},
1890         {"get_method", G_STRUCT_OFFSET (MonoPropertyInfo, get)},
1891         {"set_method", G_STRUCT_OFFSET (MonoPropertyInfo, set)},
1892         {"attrs", G_STRUCT_OFFSET (MonoPropertyInfo, attrs)},
1893         {NULL, 0}
1894 };
1895
1896 static const FieldDesc
1897 monofieldinfo_fields[] = {
1898         {"parent", G_STRUCT_OFFSET (MonoFieldInfo, parent)},
1899         {"type", G_STRUCT_OFFSET (MonoFieldInfo, type)},
1900         {"name", G_STRUCT_OFFSET (MonoFieldInfo, name)},
1901         {"attrs", G_STRUCT_OFFSET (MonoFieldInfo, attrs)},
1902         {NULL, 0}
1903 };
1904
1905 static const FieldDesc
1906 monomethod_fields[] = {
1907         {"mhandle", G_STRUCT_OFFSET (MonoReflectionMethod, method)},
1908         {NULL, 0}
1909 };
1910
1911 static const FieldDesc
1912 monocmethod_fields[] = {
1913         {"mhandle", G_STRUCT_OFFSET (MonoReflectionMethod, method)},
1914         {NULL, 0}
1915 };
1916
1917 static const FieldDesc
1918 pinfo_fields[] = {
1919         {"ClassImpl", G_STRUCT_OFFSET (MonoReflectionParameter, ClassImpl)},
1920         {"DefaultValueImpl", G_STRUCT_OFFSET (MonoReflectionParameter, DefaultValueImpl)},
1921         {"MemberImpl", G_STRUCT_OFFSET (MonoReflectionParameter, MemberImpl)},
1922         {"NameImpl", G_STRUCT_OFFSET (MonoReflectionParameter, NameImpl)},
1923         {"PositionImpl", G_STRUCT_OFFSET (MonoReflectionParameter, PositionImpl)},
1924         {"AttrsImpl", G_STRUCT_OFFSET (MonoReflectionParameter, AttrsImpl)},
1925         {NULL, 0}
1926 };
1927
1928 static const ClassDesc
1929 reflection_classes_to_check [] = {
1930         {"MonoEvent", monoevent_fields},
1931         {"MonoProperty", monoproperty_fields},
1932         {"MonoField", monofield_fields},
1933         {"MonoMethodInfo", monomethodinfo_fields},
1934         {"MonoPropertyInfo", monopropertyinfo_fields},
1935         {"MonoFieldInfo", monofieldinfo_fields},
1936         {"MonoMethod", monomethod_fields},
1937         {"MonoCMethod", monocmethod_fields},
1938         {"ParameterInfo", pinfo_fields},
1939         {NULL, NULL}
1940 };
1941
1942 static FieldDesc
1943 enuminfo_fields[] = {
1944         {"utype", G_STRUCT_OFFSET (MonoEnumInfo, utype)},
1945         {"values", G_STRUCT_OFFSET (MonoEnumInfo, values)},
1946         {"names", G_STRUCT_OFFSET (MonoEnumInfo, names)},
1947         {NULL, 0}
1948 };
1949
1950 static FieldDesc
1951 delegate_fields[] = {
1952         {"target_type", G_STRUCT_OFFSET (MonoDelegate, target_type)},
1953         {"m_target", G_STRUCT_OFFSET (MonoDelegate, target)},
1954         {"method_name", G_STRUCT_OFFSET (MonoDelegate, method_name)},
1955         {"method_ptr", G_STRUCT_OFFSET (MonoDelegate, method_ptr)},
1956         {"delegate_trampoline", G_STRUCT_OFFSET (MonoDelegate, delegate_trampoline)},
1957         {"method_info", G_STRUCT_OFFSET (MonoDelegate, method_info)},
1958         {NULL, 0}
1959 };
1960
1961 static FieldDesc
1962 multicast_delegate_fields[] = {
1963         {"prev", G_STRUCT_OFFSET (MonoMulticastDelegate, prev)},
1964         {NULL, 0}
1965 };
1966
1967 static FieldDesc
1968 async_result_fields[] = {
1969         {"async_state", G_STRUCT_OFFSET (MonoAsyncResult, async_state)},
1970         {"handle", G_STRUCT_OFFSET (MonoAsyncResult, handle)},
1971         {"async_delegate", G_STRUCT_OFFSET (MonoAsyncResult, async_delegate)},
1972         {"data", G_STRUCT_OFFSET (MonoAsyncResult, data)},
1973         {"sync_completed", G_STRUCT_OFFSET (MonoAsyncResult, sync_completed)},
1974         {"completed", G_STRUCT_OFFSET (MonoAsyncResult, completed)},
1975         {"endinvoke_called", G_STRUCT_OFFSET (MonoAsyncResult, endinvoke_called)},
1976         {NULL, 0}
1977 };
1978
1979 static FieldDesc
1980 exception_fields[] = {
1981         {"trace_ips", G_STRUCT_OFFSET (MonoException, trace_ips)},
1982         {"inner_exception", G_STRUCT_OFFSET (MonoException, inner_ex)},
1983         {"message", G_STRUCT_OFFSET (MonoException, message)},
1984         {"help_link", G_STRUCT_OFFSET (MonoException, help_link)},
1985         {"class_name", G_STRUCT_OFFSET (MonoException, class_name)},
1986         {"stack_trace", G_STRUCT_OFFSET (MonoException, stack_trace)},
1987         {"remote_stack_trace", G_STRUCT_OFFSET (MonoException, remote_stack_trace)},
1988         {"remote_stack_index", G_STRUCT_OFFSET (MonoException, remote_stack_index)},
1989         {"hresult", G_STRUCT_OFFSET (MonoException, hresult)},
1990         {"source", G_STRUCT_OFFSET (MonoException, source)},
1991         {NULL, 0}
1992 };
1993
1994 static const ClassDesc
1995 system_classes_to_check [] = {
1996         {"Exception", exception_fields},
1997         {"MonoEnumInfo", enuminfo_fields},
1998         {"Delegate", delegate_fields},
1999         {"MulticastDelegate", multicast_delegate_fields},
2000         {NULL, NULL}
2001 };
2002
2003 static FieldDesc
2004 stack_frame_fields [] = {
2005         {"ilOffset", G_STRUCT_OFFSET (MonoStackFrame, il_offset)},
2006         {"nativeOffset", G_STRUCT_OFFSET (MonoStackFrame, native_offset)},
2007         {"methodBase", G_STRUCT_OFFSET (MonoStackFrame, method)},
2008         {"fileName", G_STRUCT_OFFSET (MonoStackFrame, filename)},
2009         {"lineNumber", G_STRUCT_OFFSET (MonoStackFrame, line)},
2010         {"columnNumber", G_STRUCT_OFFSET (MonoStackFrame, column)},
2011         {NULL, 0}
2012 };
2013
2014 static const ClassDesc
2015 system_diagnostics_classes_to_check [] = {
2016         {"StackFrame", stack_frame_fields},
2017         {NULL, NULL}
2018 };
2019
2020 static FieldDesc
2021 mono_method_message_fields[] = {
2022         {"method", G_STRUCT_OFFSET (MonoMethodMessage, method)},
2023         {"args", G_STRUCT_OFFSET (MonoMethodMessage, args)},
2024         {"names", G_STRUCT_OFFSET (MonoMethodMessage, names)},
2025         {"arg_types", G_STRUCT_OFFSET (MonoMethodMessage, arg_types)},
2026         {"ctx", G_STRUCT_OFFSET (MonoMethodMessage, ctx)},
2027         {"rval", G_STRUCT_OFFSET (MonoMethodMessage, rval)},
2028         {"exc", G_STRUCT_OFFSET (MonoMethodMessage, exc)},
2029         {NULL, 0}
2030 };
2031
2032 static const ClassDesc
2033 messaging_classes_to_check [] = {
2034         {"AsyncResult", async_result_fields},
2035         {"MonoMethodMessage", mono_method_message_fields},
2036         {NULL, NULL}
2037 };
2038
2039 static FieldDesc
2040 transparent_proxy_fields[] = {
2041         {"_rp", G_STRUCT_OFFSET (MonoTransparentProxy, rp)},
2042         {"_class", G_STRUCT_OFFSET (MonoTransparentProxy, klass)},
2043         {NULL, 0}
2044 };
2045
2046 static FieldDesc
2047 real_proxy_fields[] = {
2048         {"class_to_proxy", G_STRUCT_OFFSET (MonoRealProxy, class_to_proxy)},
2049         {NULL, 0}
2050 };
2051
2052 static const ClassDesc
2053 proxy_classes_to_check [] = {
2054         {"TransparentProxy", transparent_proxy_fields},
2055         {"RealProxy", real_proxy_fields},
2056         {NULL, NULL}
2057 };
2058
2059 static FieldDesc
2060 wait_handle_fields[] = {
2061         {"os_handle", G_STRUCT_OFFSET (MonoWaitHandle, handle)},
2062         {"disposed", G_STRUCT_OFFSET (MonoWaitHandle, disposed)},
2063         {NULL, 0}
2064 };
2065
2066 static const ClassDesc
2067 threading_classes_to_check [] = {
2068         {"WaitHandle", wait_handle_fields},
2069         {NULL, NULL}
2070 };
2071
2072 typedef struct {
2073         const char *name;
2074         const ClassDesc *types;
2075 } NameSpaceDesc;
2076
2077 static const NameSpaceDesc
2078 namespaces_to_check[] = {
2079         {"System.Runtime.Remoting.Proxies", proxy_classes_to_check},
2080         {"System.Runtime.Remoting.Messaging", messaging_classes_to_check},
2081         {"System.Reflection.Emit", emit_classes_to_check},
2082         {"System.Reflection", reflection_classes_to_check},
2083         {"System.Threading", threading_classes_to_check},
2084         {"System.Diagnostics", system_diagnostics_classes_to_check},
2085         {"System", system_classes_to_check},
2086         {NULL, NULL}
2087 };
2088
2089 static char*
2090 check_corlib (MonoImage *corlib)
2091 {
2092         MonoClass *klass;
2093         MonoClassField *field;
2094         const FieldDesc *fdesc;
2095         const ClassDesc *cdesc;
2096         const NameSpaceDesc *ndesc;
2097         gint struct_offset;
2098
2099         for (ndesc = namespaces_to_check; ndesc->name; ++ndesc) {
2100                 for (cdesc = ndesc->types; cdesc->name; ++cdesc) {
2101                         klass = mono_class_from_name (corlib, ndesc->name, cdesc->name);
2102                         if (!klass)
2103                                 return g_strdup_printf ("Cannot find class %s", cdesc->name);
2104                         mono_class_init (klass);
2105                         /*
2106                          * FIXME: we should also check the size of valuetypes, or
2107                          * we're going to have trouble when we access them in arrays.
2108                          */
2109                         if (klass->valuetype)
2110                                 struct_offset = 8;
2111                         else
2112                                 struct_offset = 0;
2113                         for (fdesc = cdesc->fields; fdesc->name; ++fdesc) {
2114                                 field = mono_class_get_field_from_name (klass, fdesc->name);
2115                                 if (!field || (field->offset != (fdesc->offset + struct_offset)))
2116                                         return g_strdup_printf ("field `%s' mismatch in class %s (%ld != %ld)", fdesc->name, cdesc->name, (long) fdesc->offset, (long) (field?field->offset:-1));
2117                         }
2118                 }
2119         }
2120         return NULL;
2121 }
2122
2123 char*
2124 mono_verify_corlib () {
2125         return check_corlib (mono_defaults.corlib);
2126 }
2127