Merge pull request #241 from viniciusjarina/fix2843
[mono.git] / mono / metadata / verify.c
index afe6a67aea923e86c8515977615d646402115b50..e4b48e7b26f1806df68d01a79c3e92a3a8070673 100644 (file)
@@ -6,6 +6,7 @@
  *
  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
+ * Copyright 2011 Rodrigo Kumpera
  */
 #include <config.h>
 
 #include <mono/metadata/security-core-clr.h>
 #include <mono/metadata/tokentype.h>
 #include <mono/metadata/mono-basic-block.h>
+#include <mono/metadata/attrdefs.h>
 #include <mono/utils/mono-counters.h>
+#include <mono/utils/monobitset.h>
 #include <string.h>
 #include <signal.h>
 #include <ctype.h>
 
-
 static MiniVerifierMode verifier_mode = MONO_VERIFIER_MODE_OFF;
 static gboolean verify_all = FALSE;
 
@@ -231,6 +233,12 @@ mono_class_is_valid_generic_instantiation (VerifyContext *ctx, MonoClass *klass)
 
 static gboolean
 mono_method_is_valid_generic_instantiation (VerifyContext *ctx, MonoMethod *method);
+
+static MonoGenericParam*
+verifier_get_generic_param_from_type (VerifyContext *ctx, MonoType *type);
+
+static gboolean
+verifier_class_is_assignable_from (MonoClass *target, MonoClass *candidate);
 //////////////////////////////////////////////////////////////////
 
 
@@ -305,12 +313,14 @@ static int allocated_memory;
 static int working_set;
 static int max_allocated_memory;
 static int max_working_set;
+static int total_allocated_memory;
 
 static void
 finish_collect_stats (void)
 {
        max_allocated_memory = MAX (max_allocated_memory, allocated_memory);
        max_working_set = MAX (max_working_set, working_set);
+       total_allocated_memory += allocated_memory;
        allocated_memory = working_set = 0;
 }
 
@@ -322,6 +332,7 @@ init_verifier_stats (void)
                inited = TRUE;
                mono_counters_register ("Maximum memory allocated during verification", MONO_COUNTER_METADATA | MONO_COUNTER_INT, &max_allocated_memory);
                mono_counters_register ("Maximum memory used during verification", MONO_COUNTER_METADATA | MONO_COUNTER_INT, &max_working_set);
+               mono_counters_register ("Total memory allocated for verification", MONO_COUNTER_METADATA | MONO_COUNTER_INT, &total_allocated_memory);
        }
 }
 
@@ -360,7 +371,7 @@ token_bounds_check (MonoImage *image, guint32 token)
 {
        if (image->dynamic)
                return mono_reflection_is_valid_dynamic_token ((MonoDynamicImage*)image, token);
-       return image->tables [mono_metadata_token_table (token)].rows >= mono_metadata_token_index (token);
+       return image->tables [mono_metadata_token_table (token)].rows >= mono_metadata_token_index (token) && mono_metadata_token_index (token) > 0;
 }
 
 static MonoType *
@@ -474,7 +485,7 @@ mono_class_has_default_constructor (MonoClass *klass)
  * this function checks for VAR and MVAR types that are invalid under the current verifier,
  */
 static gboolean
-mono_type_is_valid_type_in_context (MonoType *type, MonoGenericContext *context)
+mono_type_is_valid_type_in_context_full (MonoType *type, MonoGenericContext *context, gboolean check_gtd)
 {
        int i;
        MonoGenericInst *inst;
@@ -489,23 +500,47 @@ mono_type_is_valid_type_in_context (MonoType *type, MonoGenericContext *context)
                        return FALSE;
                break;
        case MONO_TYPE_SZARRAY:
-               return mono_type_is_valid_type_in_context (&type->data.klass->byval_arg, context);
+               return mono_type_is_valid_type_in_context_full (&type->data.klass->byval_arg, context, check_gtd);
        case MONO_TYPE_ARRAY:
-               return mono_type_is_valid_type_in_context (&type->data.array->eklass->byval_arg, context);
+               return mono_type_is_valid_type_in_context_full (&type->data.array->eklass->byval_arg, context, check_gtd);
        case MONO_TYPE_PTR:
-               return mono_type_is_valid_type_in_context (type->data.type, context);
+               return mono_type_is_valid_type_in_context_full (type->data.type, context, check_gtd);
        case MONO_TYPE_GENERICINST:
                inst = type->data.generic_class->context.class_inst;
                if (!inst->is_open)
                        break;
                for (i = 0; i < inst->type_argc; ++i)
-                       if (!mono_type_is_valid_type_in_context (inst->type_argv [i], context))
+                       if (!mono_type_is_valid_type_in_context_full (inst->type_argv [i], context, check_gtd))
                                return FALSE;
                break;
+       case MONO_TYPE_CLASS:
+       case MONO_TYPE_VALUETYPE: {
+               MonoClass *klass = type->data.klass;
+               /*
+                * It's possible to encode generic'sh types in such a way that they disguise themselves as class or valuetype.
+                * Fixing the type decoding is really tricky since under some cases this behavior is needed, for example, to
+                * have a 'class' type pointing to a 'genericinst' class.
+                *
+                * For the runtime these non canonical (weird) encodings work fine, the worst they can cause is some
+                * reflection oddities which are harmless  - to security at least.
+                */
+               if (klass->byval_arg.type != type->type)
+                       return mono_type_is_valid_type_in_context_full (&klass->byval_arg, context, check_gtd);
+
+               if (check_gtd && klass->generic_container)
+                       return FALSE;
+               break;
+       }
        }
        return TRUE;
 }
 
+static gboolean
+mono_type_is_valid_type_in_context (MonoType *type, MonoGenericContext *context)
+{
+       return mono_type_is_valid_type_in_context_full (type, context, FALSE);
+}
+
 /*This function returns NULL if the type is not instantiatable*/
 static MonoType*
 verifier_inflate_type (VerifyContext *ctx, MonoType *type, MonoGenericContext *context)
@@ -521,7 +556,9 @@ verifier_inflate_type (VerifyContext *ctx, MonoType *type, MonoGenericContext *c
        return result;
 }
 
-
+/*A side note here. We don't need to check if arguments are broken since this
+is only need to be done by the runtime before realizing the type.
+*/
 static gboolean
 is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *context, MonoGenericInst *ginst)
 {
@@ -535,15 +572,28 @@ is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *co
                MonoGenericParamInfo *param_info = mono_generic_container_get_param_info (gc, i);
                MonoClass *paramClass;
                MonoClass **constraints;
+               MonoType *param_type = ginst->type_argv [i];
 
-               if (!param_info->constraints && !(param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK))
+               /*it's not our job to validate type variables*/
+               if (mono_type_is_generic_argument (param_type))
                        continue;
-               if (mono_type_is_generic_argument (ginst->type_argv [i]))
-                       continue; //it's not our job to validate type variables
 
-               paramClass = mono_class_from_mono_type (ginst->type_argv [i]);
+               paramClass = mono_class_from_mono_type (param_type);
+
 
-               if (paramClass->exception_type != MONO_EXCEPTION_NONE)
+               /* A GTD can't be a generic argument.
+                *
+                * Due to how types are encoded we must check for the case of a genericinst MonoType and GTD MonoClass.
+                * This happens in cases such as: class Foo<T>  { void X() { new Bar<T> (); } }
+                *
+                * Open instantiations can have GTDs as this happens when one type is instantiated with others params
+                * and the former has an expansion into the later. For example:
+                * class B<K> {}
+                * class A<T>: B<K> {}
+                * The type A <K> has a parent B<K>, that is inflated into the GTD B<>.
+                * Since A<K> is open, thus not instantiatable, this is valid.
+                */
+               if (paramClass->generic_container && param_type->type != MONO_TYPE_GENERICINST && !ginst->is_open)
                        return FALSE;
 
                /*it's not safe to call mono_class_init from here*/
@@ -552,6 +602,9 @@ is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *co
                                return FALSE;
                }
 
+               if (!param_info->constraints && !(param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK))
+                       continue;
+
                if ((param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) && (!paramClass->valuetype || mono_class_is_nullable (paramClass)))
                        return FALSE;
 
@@ -576,6 +629,7 @@ is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *co
                        ctr = mono_class_from_mono_type (inflated);
                        mono_metadata_free_type (inflated);
 
+                       /*FIXME maybe we need the same this as verifier_class_is_assignable_from*/
                        if (!mono_class_is_assignable_from_slow (ctr, paramClass))
                                return FALSE;
                }
@@ -589,20 +643,47 @@ is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *co
  * This means that @candidate constraints are a super set of @target constaints
  */
 static gboolean
-mono_generic_param_is_constraint_compatible (VerifyContext *ctx, MonoGenericParam *target, MonoGenericParam *candidate, MonoGenericContext *context)
+mono_generic_param_is_constraint_compatible (VerifyContext *ctx, MonoGenericParam *target, MonoGenericParam *candidate, MonoClass *candidate_param_class, MonoGenericContext *context)
 {
        MonoGenericParamInfo *tinfo = mono_generic_param_info (target);
        MonoGenericParamInfo *cinfo = mono_generic_param_info (candidate);
+       MonoClass **candidate_class;
+       gboolean class_constraint_satisfied = FALSE;
+       gboolean valuetype_constraint_satisfied = FALSE;
 
        int tmask = tinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK;
        int cmask = cinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK;
-       if ((tmask & cmask) != tmask)
+
+       if (cinfo->constraints) {
+               for (candidate_class = cinfo->constraints; *candidate_class; ++candidate_class) {
+                       MonoClass *cc;
+                       MonoType *inflated = verifier_inflate_type (ctx, &(*candidate_class)->byval_arg, ctx->generic_context);
+                       if (!inflated)
+                               return FALSE;
+                       cc = mono_class_from_mono_type (inflated);
+                       mono_metadata_free_type (inflated);
+
+                       if (mono_type_is_reference (&cc->byval_arg) && !MONO_CLASS_IS_INTERFACE (cc))
+                               class_constraint_satisfied = TRUE;
+                       else if (!mono_type_is_reference (&cc->byval_arg) && !MONO_CLASS_IS_INTERFACE (cc))
+                               valuetype_constraint_satisfied = TRUE;
+               }
+       }
+       class_constraint_satisfied |= (cmask & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) != 0;
+       valuetype_constraint_satisfied |= (cmask & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) != 0;
+
+       if ((tmask & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) && !class_constraint_satisfied)
                return FALSE;
+       if ((tmask & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) && !valuetype_constraint_satisfied)
+               return FALSE;
+       if ((tmask & GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT) && !((cmask & GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT) ||
+               valuetype_constraint_satisfied)) {
+               return FALSE;
+       }
+
 
        if (tinfo->constraints) {
-               MonoClass **target_class, **candidate_class;
-               if (!cinfo->constraints)
-                       return FALSE;
+               MonoClass **target_class;
                for (target_class = tinfo->constraints; *target_class; ++target_class) {
                        MonoClass *tc;
                        MonoType *inflated = verifier_inflate_type (ctx, &(*target_class)->byval_arg, context);
@@ -611,6 +692,16 @@ mono_generic_param_is_constraint_compatible (VerifyContext *ctx, MonoGenericPara
                        tc = mono_class_from_mono_type (inflated);
                        mono_metadata_free_type (inflated);
 
+                       /*
+                        * A constraint from @target might inflate into @candidate itself and in that case we don't need
+                        * check it's constraints since it satisfy the constraint by itself.
+                        */
+                       if (mono_metadata_type_equal (&tc->byval_arg, &candidate_param_class->byval_arg))
+                               continue;
+
+                       if (!cinfo->constraints)
+                               return FALSE;
+
                        for (candidate_class = cinfo->constraints; *candidate_class; ++candidate_class) {
                                MonoClass *cc;
                                inflated = verifier_inflate_type (ctx, &(*candidate_class)->byval_arg, ctx->generic_context);
@@ -619,8 +710,25 @@ mono_generic_param_is_constraint_compatible (VerifyContext *ctx, MonoGenericPara
                                cc = mono_class_from_mono_type (inflated);
                                mono_metadata_free_type (inflated);
 
-                               if (mono_class_is_assignable_from (tc, cc))
+                               if (verifier_class_is_assignable_from (tc, cc))
                                        break;
+
+                               /*
+                                * This happens when we have the following:
+                                *
+                                * Bar<K> where K : IFace
+                                * Foo<T, U> where T : U where U : IFace
+                                *      ...
+                                *      Bar<T> <- T here satisfy K constraint transitively through to U's constraint
+                                *
+                                */
+                               if (mono_type_is_generic_argument (&cc->byval_arg)) {
+                                       MonoGenericParam *other_candidate = verifier_get_generic_param_from_type (ctx, &cc->byval_arg);
+
+                                       if (mono_generic_param_is_constraint_compatible (ctx, target, other_candidate, cc, context)) {
+                                               break;
+                                       }
+                               }
                        }
                        if (!*candidate_class)
                                return FALSE;
@@ -650,7 +758,7 @@ verifier_get_generic_param_from_type (VerifyContext *ctx, MonoType *type)
                gc = mono_method_get_generic_container (gmd);
        }
        if (!gc)
-               return FALSE;
+               return NULL;
        return mono_generic_container_get_param (gc, num);
 }
 
@@ -668,12 +776,13 @@ is_valid_type_in_context (VerifyContext *ctx, MonoType *type)
 }
 
 static gboolean
-is_valid_generic_instantiation_in_context (VerifyContext *ctx, MonoGenericInst *ginst)
+is_valid_generic_instantiation_in_context (VerifyContext *ctx, MonoGenericInst *ginst, gboolean check_gtd)
 {
        int i;
        for (i = 0; i < ginst->type_argc; ++i) {
                MonoType *type = ginst->type_argv [i];
-               if (!is_valid_type_in_context (ctx, type))
+                       
+               if (!mono_type_is_valid_type_in_context_full (type, ctx->generic_context, TRUE))
                        return FALSE;
        }
        return TRUE;
@@ -687,6 +796,7 @@ generic_arguments_respect_constraints (VerifyContext *ctx, MonoGenericContainer
                MonoType *type = ginst->type_argv [i];
                MonoGenericParam *target = mono_generic_container_get_param (gc, i);
                MonoGenericParam *candidate;
+               MonoClass *candidate_class;
 
                if (!mono_type_is_generic_argument (type))
                        continue;
@@ -695,8 +805,9 @@ generic_arguments_respect_constraints (VerifyContext *ctx, MonoGenericContainer
                        return FALSE;
 
                candidate = verifier_get_generic_param_from_type (ctx, type);
+               candidate_class = mono_class_from_mono_type (type);
 
-               if (!mono_generic_param_is_constraint_compatible (ctx, target, candidate, context))
+               if (!mono_generic_param_is_constraint_compatible (ctx, target, candidate, candidate_class, context))
                        return FALSE;
        }
        return TRUE;
@@ -728,7 +839,7 @@ mono_method_is_valid_generic_instantiation (VerifyContext *ctx, MonoMethod *meth
        MonoGenericContainer *gc = mono_method_get_generic_container (gmethod->declaring);
        if (!gc) /*non-generic inflated method - it's part of a generic type  */
                return TRUE;
-       if (ctx && !is_valid_generic_instantiation_in_context (ctx, ginst))
+       if (ctx && !is_valid_generic_instantiation_in_context (ctx, ginst, TRUE))
                return FALSE;
        return is_valid_generic_instantiation (gc, &gmethod->context, ginst);
 
@@ -740,7 +851,7 @@ mono_class_is_valid_generic_instantiation (VerifyContext *ctx, MonoClass *klass)
        MonoGenericClass *gklass = klass->generic_class;
        MonoGenericInst *ginst = gklass->context.class_inst;
        MonoGenericContainer *gc = gklass->container_class->generic_container;
-       if (ctx && !is_valid_generic_instantiation_in_context (ctx, ginst))
+       if (ctx && !is_valid_generic_instantiation_in_context (ctx, ginst, TRUE))
                return FALSE;
        return is_valid_generic_instantiation (gc, &gklass->context, ginst);
 }
@@ -774,6 +885,7 @@ mono_type_is_valid_in_context (VerifyContext *ctx, MonoType *type)
                        ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid generic instantiation of type %s.%s at 0x%04x", klass->name_space, klass->name, ctx->ip_offset), MONO_EXCEPTION_TYPE_LOAD);
                else
                        ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Could not load type %s.%s at 0x%04x", klass->name_space, klass->name, ctx->ip_offset), MONO_EXCEPTION_TYPE_LOAD);
+               mono_loader_clear_error ();
                return FALSE;
        }
 
@@ -825,20 +937,34 @@ verifier_load_field (VerifyContext *ctx, int token, MonoClass **out_klass, const
        MonoClassField *field;
        MonoClass *klass = NULL;
 
-       if (!IS_FIELD_DEF_OR_REF (token) || !token_bounds_check (ctx->image, token)) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid field token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return NULL;
+       if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
+               field = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+               klass = field ? field->parent : NULL;
+       } else {
+               if (!IS_FIELD_DEF_OR_REF (token) || !token_bounds_check (ctx->image, token)) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid field token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return NULL;
+               }
+
+               field = mono_field_from_token (ctx->image, token, &klass, ctx->generic_context);
        }
 
-       field = mono_field_from_token (ctx->image, token, &klass, ctx->generic_context);
-       if (!field || !field->parent || !klass) {
+       if (!field || !field->parent || !klass || mono_loader_get_last_error ()) {
                ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Cannot load field from token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+               mono_loader_clear_error ();
                return NULL;
        }
 
        if (!mono_type_is_valid_in_context (ctx, &klass->byval_arg))
                return NULL;
 
+       if (mono_field_get_flags (field) & FIELD_ATTRIBUTE_LITERAL) {
+               char *type_name = mono_type_get_full_name (field->parent);
+               ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Cannot reference literal field %s::%s at 0x%04x", type_name, field->name, ctx->ip_offset));
+               g_free (type_name);
+               return NULL;
+       }
+
        *out_klass = klass;
        return field;
 }
@@ -846,16 +972,21 @@ verifier_load_field (VerifyContext *ctx, int token, MonoClass **out_klass, const
 static MonoMethod*
 verifier_load_method (VerifyContext *ctx, int token, const char *opcode) {
        MonoMethod* method;
-       
-       if (!IS_METHOD_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid method token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return NULL;
-       }
 
-       method = mono_get_method_full (ctx->image, token, NULL, ctx->generic_context);
+       if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
+               method = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+       } else {
+               if (!IS_METHOD_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid method token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return NULL;
+               }
+
+               method = mono_get_method_full (ctx->image, token, NULL, ctx->generic_context);
+       }
 
-       if (!method) {
+       if (!method || mono_loader_get_last_error ()) {
                ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Cannot load method from token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+               mono_loader_clear_error ();
                return NULL;
        }
        
@@ -869,15 +1000,20 @@ static MonoType*
 verifier_load_type (VerifyContext *ctx, int token, const char *opcode) {
        MonoType* type;
        
-       if (!IS_TYPE_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid type token 0x%08x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return NULL;
+       if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
+               MonoClass *class = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+               type = class ? &class->byval_arg : NULL;
+       } else {
+               if (!IS_TYPE_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid type token 0x%08x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return NULL;
+               }
+               type = mono_type_get_full (ctx->image, token, ctx->generic_context);
        }
 
-       type = mono_type_get_full (ctx->image, token, ctx->generic_context);
-
-       if (!type) {
+       if (!type || mono_loader_get_last_error ()) {
                ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Cannot load type from token 0x%08x for %s at 0x%04x", token, opcode, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+               mono_loader_clear_error ();
                return NULL;
        }
 
@@ -983,18 +1119,30 @@ stack_slot_stack_type_full_name (ILStackDesc *value)
 {
        GString *str = g_string_new ("");
        char *result;
+       gboolean has_pred = FALSE, first = TRUE;
 
        if ((value->stype & TYPE_MASK) != value->stype) {
-               gboolean first = TRUE;
                g_string_append(str, "[");
                APPEND_WITH_PREDICATE (stack_slot_is_this_pointer, "this");
                APPEND_WITH_PREDICATE (stack_slot_is_boxed_value, "boxed");
                APPEND_WITH_PREDICATE (stack_slot_is_null_literal, "null");
                APPEND_WITH_PREDICATE (stack_slot_is_managed_mutability_pointer, "cmmp");
                APPEND_WITH_PREDICATE (stack_slot_is_managed_pointer, "mp");
-               g_string_append(str, "] ");
+               has_pred = TRUE;
        }
 
+       if (mono_type_is_generic_argument (value->type) && !stack_slot_is_boxed_value (value)) {
+               if (!has_pred)
+                       g_string_append(str, "[");
+               if (!first)
+                       g_string_append (str, ", ");
+               g_string_append (str, "unboxed");
+               has_pred = TRUE;
+       }
+
+       if (has_pred)
+               g_string_append(str, "] ");
+
        g_string_append (str, stack_slot_get_name (value));
        result = str->str;
        g_string_free (str, FALSE);
@@ -1043,625 +1191,6 @@ mono_free_verify_list (GSList *list)
                (list) = g_slist_prepend ((list), vinfo);       \
        } while (0)
 
-static const char
-valid_cultures[][9] = {
-       "ar-SA", "ar-IQ", "ar-EG", "ar-LY",
-       "ar-DZ", "ar-MA", "ar-TN", "ar-OM",
-       "ar-YE", "ar-SY", "ar-JO", "ar-LB",
-       "ar-KW", "ar-AE", "ar-BH", "ar-QA",
-       "bg-BG", "ca-ES", "zh-TW", "zh-CN",
-       "zh-HK", "zh-SG", "zh-MO", "cs-CZ",
-       "da-DK", "de-DE", "de-CH", "de-AT",
-       "de-LU", "de-LI", "el-GR", "en-US",
-       "en-GB", "en-AU", "en-CA", "en-NZ",
-       "en-IE", "en-ZA", "en-JM", "en-CB",
-       "en-BZ", "en-TT", "en-ZW", "en-PH",
-       "es-ES-Ts", "es-MX", "es-ES-Is", "es-GT",
-       "es-CR", "es-PA", "es-DO", "es-VE",
-       "es-CO", "es-PE", "es-AR", "es-EC",
-       "es-CL", "es-UY", "es-PY", "es-BO",
-       "es-SV", "es-HN", "es-NI", "es-PR",
-       "Fi-FI", "fr-FR", "fr-BE", "fr-CA",
-       "Fr-CH", "fr-LU", "fr-MC", "he-IL",
-       "hu-HU", "is-IS", "it-IT", "it-CH",
-       "Ja-JP", "ko-KR", "nl-NL", "nl-BE",
-       "nb-NO", "nn-NO", "pl-PL", "pt-BR",
-       "pt-PT", "ro-RO", "ru-RU", "hr-HR",
-       "Lt-sr-SP", "Cy-sr-SP", "sk-SK", "sq-AL",
-       "sv-SE", "sv-FI", "th-TH", "tr-TR",
-       "ur-PK", "id-ID", "uk-UA", "be-BY",
-       "sl-SI", "et-EE", "lv-LV", "lt-LT",
-       "fa-IR", "vi-VN", "hy-AM", "Lt-az-AZ",
-       "Cy-az-AZ",
-       "eu-ES", "mk-MK", "af-ZA",
-       "ka-GE", "fo-FO", "hi-IN", "ms-MY",
-       "ms-BN", "kk-KZ", "ky-KZ", "sw-KE",
-       "Lt-uz-UZ", "Cy-uz-UZ", "tt-TA", "pa-IN",
-       "gu-IN", "ta-IN", "te-IN", "kn-IN",
-       "mr-IN", "sa-IN", "mn-MN", "gl-ES",
-       "kok-IN", "syr-SY", "div-MV"
-};
-
-static int
-is_valid_culture (const char *cname)
-{
-       int i;
-       int found;
-
-       found = *cname == 0;
-       for (i = 0; i < G_N_ELEMENTS (valid_cultures); ++i) {
-               if (g_ascii_strcasecmp (valid_cultures [i], cname)) {
-                       found = 1;
-                       break;
-               }
-       }
-       return found;
-}
-
-static int
-is_valid_assembly_flags (guint32 flags) {
-       /* Metadata: 22.1.2 */
-       flags &= ~(0x8000 | 0x4000); /* ignore reserved bits 0x0030? */
-       return ((flags == 1) || (flags == 0));
-}
-
-static int
-is_valid_blob (MonoImage *image, guint32 blob_index, int notnull)
-{
-       guint32 size;
-       const char *p, *blob_end;
-
-       if (blob_index >= image->heap_blob.size)
-               return 0;
-       p = mono_metadata_blob_heap (image, blob_index);
-       size = mono_metadata_decode_blob_size (p, &blob_end);
-       if (blob_index + size + (blob_end-p) > image->heap_blob.size)
-               return 0;
-       if (notnull && !size)
-               return 0;
-       return 1;
-}
-
-static const char*
-is_valid_string (MonoImage *image, guint32 str_index, int notnull)
-{
-       const char *p, *blob_end, *res;
-
-       if (str_index >= image->heap_strings.size)
-               return NULL;
-       res = p = mono_metadata_string_heap (image, str_index);
-       blob_end = mono_metadata_string_heap (image, image->heap_strings.size - 1);
-       if (notnull && !*p)
-               return 0;
-       /* 
-        * FIXME: should check it's a valid utf8 string, too.
-        */
-       while (p <= blob_end) {
-               if (!*p)
-                       return res;
-               ++p;
-       }
-       return *p? NULL: res;
-}
-
-static int
-is_valid_cls_ident (const char *p)
-{
-       /*
-        * FIXME: we need the full unicode glib support for this.
-        * Check: http://www.unicode.org/unicode/reports/tr15/Identifier.java
-        * We do the lame thing for now.
-        */
-       if (!isalpha (*p))
-               return 0;
-       ++p;
-       while (*p) {
-               if (!isalnum (*p) && *p != '_')
-                       return 0;
-               ++p;
-       }
-       return 1;
-}
-
-static int
-is_valid_filename (const char *p)
-{
-       if (!*p)
-               return 0;
-       return strpbrk (p, "\\//:")? 0: 1;
-}
-
-static GSList*
-verify_assembly_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLY];
-       guint32 cols [MONO_ASSEMBLY_SIZE];
-       const char *p;
-
-       if (level & MONO_VERIFY_ERROR) {
-               if (t->rows > 1)
-                       ADD_ERROR (list, g_strdup ("Assembly table may only have 0 or 1 rows"));
-               mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
-
-               switch (cols [MONO_ASSEMBLY_HASH_ALG]) {
-               case ASSEMBLY_HASH_NONE:
-               case ASSEMBLY_HASH_MD5:
-               case ASSEMBLY_HASH_SHA1:
-                       break;
-               default:
-                       ADD_ERROR (list, g_strdup_printf ("Hash algorithm 0x%x unknown", cols [MONO_ASSEMBLY_HASH_ALG]));
-               }
-
-               if (!is_valid_assembly_flags (cols [MONO_ASSEMBLY_FLAGS]))
-                       ADD_ERROR (list, g_strdup_printf ("Invalid flags in assembly: 0x%x", cols [MONO_ASSEMBLY_FLAGS]));
-
-               if (!is_valid_blob (image, cols [MONO_ASSEMBLY_PUBLIC_KEY], FALSE))
-                       ADD_ERROR (list, g_strdup ("Assembly public key is an invalid index"));
-
-               if (!(p = is_valid_string (image, cols [MONO_ASSEMBLY_NAME], TRUE))) {
-                       ADD_ERROR (list, g_strdup ("Assembly name is invalid"));
-               } else {
-                       if (strpbrk (p, ":\\/."))
-                               ADD_ERROR (list, g_strdup_printf ("Assembly name `%s' contains invalid chars", p));
-               }
-
-               if (!(p = is_valid_string (image, cols [MONO_ASSEMBLY_CULTURE], FALSE))) {
-                       ADD_ERROR (list, g_strdup ("Assembly culture is an invalid index"));
-               } else {
-                       if (!is_valid_culture (p))
-                               ADD_ERROR (list, g_strdup_printf ("Assembly culture `%s' is invalid", p));
-               }
-       }
-       return list;
-}
-
-static GSList*
-verify_assemblyref_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLYREF];
-       guint32 cols [MONO_ASSEMBLYREF_SIZE];
-       const char *p;
-       int i;
-
-       if (level & MONO_VERIFY_ERROR) {
-               for (i = 0; i < t->rows; ++i) {
-                       mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
-                       if (!is_valid_assembly_flags (cols [MONO_ASSEMBLYREF_FLAGS]))
-                               ADD_ERROR (list, g_strdup_printf ("Invalid flags in assemblyref row %d: 0x%x", i + 1, cols [MONO_ASSEMBLY_FLAGS]));
-
-                       if (!is_valid_blob (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY], FALSE))
-                               ADD_ERROR (list, g_strdup_printf ("AssemblyRef public key in row %d is an invalid index", i + 1));
-
-                       if (!(p = is_valid_string (image, cols [MONO_ASSEMBLYREF_CULTURE], FALSE))) {
-                               ADD_ERROR (list, g_strdup_printf ("AssemblyRef culture in row %d is invalid", i + 1));
-                       } else {
-                               if (!is_valid_culture (p))
-                                       ADD_ERROR (list, g_strdup_printf ("AssemblyRef culture `%s' in row %d is invalid", p, i + 1));
-                       }
-
-                       if (cols [MONO_ASSEMBLYREF_HASH_VALUE] && !is_valid_blob (image, cols [MONO_ASSEMBLYREF_HASH_VALUE], TRUE))
-                               ADD_ERROR (list, g_strdup_printf ("AssemblyRef hash value in row %d is invalid or not null and empty", i + 1));
-               }
-       }
-       if (level & MONO_VERIFY_WARNING) {
-               /* check for duplicated rows */
-               for (i = 0; i < t->rows; ++i) {
-               }
-       }
-       return list;
-}
-
-static GSList*
-verify_class_layout_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_CLASSLAYOUT];
-       MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
-       guint32 cols [MONO_CLASS_LAYOUT_SIZE];
-       guint32 value, i;
-
-       if (level & MONO_VERIFY_ERROR) {
-               for (i = 0; i < t->rows; ++i) {
-                       mono_metadata_decode_row (t, i, cols, MONO_CLASS_LAYOUT_SIZE);
-
-                       if (cols [MONO_CLASS_LAYOUT_PARENT] > tdef->rows || !cols [MONO_CLASS_LAYOUT_PARENT]) {
-                               ADD_ERROR (list, g_strdup_printf ("Parent in class layout is invalid in row %d", i + 1));
-                       } else {
-                               value = mono_metadata_decode_row_col (tdef, cols [MONO_CLASS_LAYOUT_PARENT] - 1, MONO_TYPEDEF_FLAGS);
-                               if (value & TYPE_ATTRIBUTE_INTERFACE)
-                                       ADD_ERROR (list, g_strdup_printf ("Parent in class layout row %d is an interface", i + 1));
-                               if (value & TYPE_ATTRIBUTE_AUTO_LAYOUT)
-                                       ADD_ERROR (list, g_strdup_printf ("Parent in class layout row %d is AutoLayout", i + 1));
-                               if (value & TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT) {
-                                       switch (cols [MONO_CLASS_LAYOUT_PACKING_SIZE]) {
-                                       case 0: case 1: case 2: case 4: case 8: case 16:
-                                       case 32: case 64: case 128: break;
-                                       default:
-                                               ADD_ERROR (list, g_strdup_printf ("Packing size %d in class layout row %d is invalid", cols [MONO_CLASS_LAYOUT_PACKING_SIZE], i + 1));
-                                       }
-                               } else if (value & TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
-                                       /*
-                                        * FIXME: LAMESPEC: it claims it must be 0 (it's 1, instead).
-                                       if (cols [MONO_CLASS_LAYOUT_PACKING_SIZE])
-                                               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));
-                                       */
-                               }
-                               /*
-                                * FIXME: we need to check that if class size != 0, 
-                                * it needs to be greater than the class calculated size.
-                                * If parent is a valuetype it also needs to be smaller than
-                                * 1 MByte (0x100000 bytes).
-                                * To do both these checks we need to load the referenced 
-                                * assemblies, though (the spec claims we didn't have to, bah).
-                                */
-                               /* 
-                                * We need to check that the parent types have the same layout 
-                                * type as well.
-                                */
-                       }
-               }
-       }
-
-       return list;
-}
-
-static GSList*
-verify_constant_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_CONSTANT];
-       guint32 cols [MONO_CONSTANT_SIZE];
-       guint32 value, i;
-       GHashTable *dups = g_hash_table_new (NULL, NULL);
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_CONSTANT_SIZE);
-
-               if (level & MONO_VERIFY_ERROR)
-                       if (g_hash_table_lookup (dups, GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT])))
-                               ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is duplicated in Constant row %d", cols [MONO_CONSTANT_PARENT], i + 1));
-               g_hash_table_insert (dups, GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT]),
-                               GUINT_TO_POINTER (cols [MONO_CONSTANT_PARENT]));
-
-               switch (cols [MONO_CONSTANT_TYPE]) {
-               case MONO_TYPE_U1: /* LAMESPEC: it says I1...*/
-               case MONO_TYPE_U2:
-               case MONO_TYPE_U4:
-               case MONO_TYPE_U8:
-                       if (level & MONO_VERIFY_CLS)
-                               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));
-               case MONO_TYPE_BOOLEAN:
-               case MONO_TYPE_CHAR:
-               case MONO_TYPE_I1:
-               case MONO_TYPE_I2:
-               case MONO_TYPE_I4:
-               case MONO_TYPE_I8:
-               case MONO_TYPE_R4:
-               case MONO_TYPE_R8:
-               case MONO_TYPE_STRING:
-               case MONO_TYPE_CLASS:
-                       break;
-               default:
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Type 0x%x is invalid in Constant row %d", cols [MONO_CONSTANT_TYPE], i + 1));
-               }
-               if (level & MONO_VERIFY_ERROR) {
-                       value = cols [MONO_CONSTANT_PARENT] >> MONO_HASCONSTANT_BITS;
-                       switch (cols [MONO_CONSTANT_PARENT] & MONO_HASCONSTANT_MASK) {
-                       case MONO_HASCONSTANT_FIEDDEF:
-                               if (value > image->tables [MONO_TABLE_FIELD].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Parent (field) is invalid in Constant row %d", i + 1));
-                               break;
-                       case MONO_HASCONSTANT_PARAM:
-                               if (value > image->tables [MONO_TABLE_PARAM].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Parent (param) is invalid in Constant row %d", i + 1));
-                               break;
-                       case MONO_HASCONSTANT_PROPERTY:
-                               if (value > image->tables [MONO_TABLE_PROPERTY].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Parent (property) is invalid in Constant row %d", i + 1));
-                               break;
-                       default:
-                               ADD_ERROR (list, g_strdup_printf ("Parent is invalid in Constant row %d", i + 1));
-                               break;
-                       }
-               }
-               if (level & MONO_VERIFY_CLS) {
-                       /* 
-                        * FIXME: verify types is consistent with the enum type
-                        * is parent is an enum.
-                        */
-               }
-       }
-       g_hash_table_destroy (dups);
-       return list;
-}
-
-static GSList*
-verify_event_map_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_EVENTMAP];
-       guint32 cols [MONO_EVENT_MAP_SIZE];
-       guint32 i, last_event;
-       GHashTable *dups = g_hash_table_new (NULL, NULL);
-
-       last_event = 0;
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_EVENT_MAP_SIZE);
-               if (level & MONO_VERIFY_ERROR)
-                       if (g_hash_table_lookup (dups, GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT])))
-                               ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is duplicated in Event Map row %d", cols [MONO_EVENT_MAP_PARENT], i + 1));
-               g_hash_table_insert (dups, GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT]),
-                               GUINT_TO_POINTER (cols [MONO_EVENT_MAP_PARENT]));
-               if (level & MONO_VERIFY_ERROR) {
-                       if (cols [MONO_EVENT_MAP_PARENT] > image->tables [MONO_TABLE_TYPEDEF].rows)
-                               ADD_ERROR (list, g_strdup_printf ("Parent 0x%08x is invalid in Event Map row %d", cols [MONO_EVENT_MAP_PARENT], i + 1));
-                       if (cols [MONO_EVENT_MAP_EVENTLIST] > image->tables [MONO_TABLE_EVENT].rows)
-                               ADD_ERROR (list, g_strdup_printf ("EventList 0x%08x is invalid in Event Map row %d", cols [MONO_EVENT_MAP_EVENTLIST], i + 1));
-
-                       if (cols [MONO_EVENT_MAP_EVENTLIST] <= last_event)
-                               ADD_ERROR (list, g_strdup_printf ("EventList overlap in Event Map row %d", i + 1));
-                       last_event = cols [MONO_EVENT_MAP_EVENTLIST];
-               }
-       }
-
-       g_hash_table_destroy (dups);
-       return list;
-}
-
-static GSList*
-verify_event_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_EVENT];
-       guint32 cols [MONO_EVENT_SIZE];
-       const char *p;
-       guint32 value, i;
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_EVENT_SIZE);
-
-               if (cols [MONO_EVENT_FLAGS] & ~(EVENT_SPECIALNAME|EVENT_RTSPECIALNAME)) {
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Flags 0x%04x invalid in Event row %d", cols [MONO_EVENT_FLAGS], i + 1));
-               }
-               if (!(p = is_valid_string (image, cols [MONO_EVENT_NAME], TRUE))) {
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid name in Event row %d", i + 1));
-               } else {
-                       if (level & MONO_VERIFY_CLS) {
-                               if (!is_valid_cls_ident (p))
-                                       ADD_WARN (list, MONO_VERIFY_CLS, g_strdup_printf ("Invalid CLS name '%s` in Event row %d", p, i + 1));
-                       }
-               }
-
-               if (level & MONO_VERIFY_ERROR && cols [MONO_EVENT_TYPE]) {
-                       value = cols [MONO_EVENT_TYPE] >> MONO_TYPEDEFORREF_BITS;
-                       switch (cols [MONO_EVENT_TYPE] & MONO_TYPEDEFORREF_MASK) {
-                       case MONO_TYPEDEFORREF_TYPEDEF:
-                               if (!value || value > image->tables [MONO_TABLE_TYPEDEF].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
-                               break;
-                       case MONO_TYPEDEFORREF_TYPEREF:
-                               if (!value || value > image->tables [MONO_TABLE_TYPEREF].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
-                               break;
-                       case MONO_TYPEDEFORREF_TYPESPEC:
-                               if (!value || value > image->tables [MONO_TABLE_TYPESPEC].rows)
-                                       ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
-                               break;
-                       default:
-                               ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
-                       }
-               }
-               /*
-                * FIXME: check that there is 1 add and remove row in methodsemantics
-                * and 0 or 1 raise and 0 or more other (maybe it's better to check for 
-                * these while checking methodsemantics).
-                * check for duplicated names for the same type [ERROR]
-                * check for CLS duplicate names for the same type [CLS]
-                */
-       }
-       return list;
-}
-
-static GSList*
-verify_field_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_FIELD];
-       guint32 cols [MONO_FIELD_SIZE];
-       const char *p;
-       guint32 i, flags;
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_FIELD_SIZE);
-               /*
-                * Check this field has only one owner and that the owner is not 
-                * an interface (done in verify_typedef_table() )
-                */
-               flags = cols [MONO_FIELD_FLAGS];
-               switch (flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) {
-               case FIELD_ATTRIBUTE_COMPILER_CONTROLLED:
-               case FIELD_ATTRIBUTE_PRIVATE:
-               case FIELD_ATTRIBUTE_FAM_AND_ASSEM:
-               case FIELD_ATTRIBUTE_ASSEMBLY:
-               case FIELD_ATTRIBUTE_FAMILY:
-               case FIELD_ATTRIBUTE_FAM_OR_ASSEM:
-               case FIELD_ATTRIBUTE_PUBLIC:
-                       break;
-               default:
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid access mask in Field row %d", i + 1));
-                       break;
-               }
-               if (level & MONO_VERIFY_ERROR) {
-                       if ((flags & FIELD_ATTRIBUTE_LITERAL) && (flags & FIELD_ATTRIBUTE_INIT_ONLY))
-                               ADD_ERROR (list, g_strdup_printf ("Literal and InitOnly cannot be both set in Field row %d", i + 1));
-                       if ((flags & FIELD_ATTRIBUTE_LITERAL) && !(flags & FIELD_ATTRIBUTE_STATIC))
-                               ADD_ERROR (list, g_strdup_printf ("Literal needs also Static set in Field row %d", i + 1));
-                       if ((flags & FIELD_ATTRIBUTE_RT_SPECIAL_NAME) && !(flags & FIELD_ATTRIBUTE_SPECIAL_NAME))
-                               ADD_ERROR (list, g_strdup_printf ("RTSpecialName needs also SpecialName set in Field row %d", i + 1));
-                       /*
-                        * FIXME: check there is only one owner in the respective table.
-                        * if (flags & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL)
-                        * if (flags & FIELD_ATTRIBUTE_HAS_DEFAULT)
-                        * if (flags & FIELD_ATTRIBUTE_HAS_FIELD_RVA)
-                        */
-               }
-               if (!(p = is_valid_string (image, cols [MONO_FIELD_NAME], TRUE))) {
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid name in Field row %d", i + 1));
-               } else {
-                       if (level & MONO_VERIFY_CLS) {
-                               if (!is_valid_cls_ident (p))
-                                       ADD_WARN (list, MONO_VERIFY_CLS, g_strdup_printf ("Invalid CLS name '%s` in Field row %d", p, i + 1));
-                       }
-               }
-               /*
-                * check signature.
-                * if owner is module needs to be static, access mask needs to be compilercontrolled,
-                * public or private (not allowed in cls mode).
-                * if owner is an enum ...
-                */
-
-
-       }
-       return list;
-}
-
-static GSList*
-verify_file_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_FILE];
-       guint32 cols [MONO_FILE_SIZE];
-       const char *p;
-       guint32 i;
-       GHashTable *dups = g_hash_table_new (g_str_hash, g_str_equal);
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_FILE_SIZE);
-               if (level & MONO_VERIFY_ERROR) {
-                       if (cols [MONO_FILE_FLAGS] != FILE_CONTAINS_METADATA && cols [MONO_FILE_FLAGS] != FILE_CONTAINS_NO_METADATA)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid flags in File row %d", i + 1));
-                       if (!is_valid_blob (image, cols [MONO_FILE_HASH_VALUE], TRUE))
-                               ADD_ERROR (list, g_strdup_printf ("File hash value in row %d is invalid or not null and empty", i + 1));
-               }
-               if (!(p = is_valid_string (image, cols [MONO_FILE_NAME], TRUE))) {
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid name in File row %d", i + 1));
-               } else {
-                       if (level & MONO_VERIFY_ERROR) {
-                               if (!is_valid_filename (p))
-                                       ADD_ERROR (list, g_strdup_printf ("Invalid name '%s` in File row %d", p, i + 1));
-                               else if (g_hash_table_lookup (dups, p)) {
-                                       ADD_ERROR (list, g_strdup_printf ("Duplicate name '%s` in File row %d", p, i + 1));
-                               }
-                               g_hash_table_insert (dups, (gpointer)p, (gpointer)p);
-                       }
-               }
-               /*
-                * FIXME: I don't understand what this means:
-                * If this module contains a row in the Assembly table (that is, if this module "holds the manifest") 
-                * then there shall not be any row in the File table for this module - i.e., no self-reference  [ERROR]
-                */
-
-       }
-       if (level & MONO_VERIFY_WARNING) {
-               if (!t->rows && image->tables [MONO_TABLE_EXPORTEDTYPE].rows)
-                       ADD_WARN (list, MONO_VERIFY_WARNING, g_strdup ("ExportedType table should be empty if File table is empty"));
-       }
-       g_hash_table_destroy (dups);
-       return list;
-}
-
-static GSList*
-verify_moduleref_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_MODULEREF];
-       MonoTableInfo *tfile = &image->tables [MONO_TABLE_FILE];
-       guint32 cols [MONO_MODULEREF_SIZE];
-       const char *p, *pf;
-       guint32 found, i, j, value;
-       GHashTable *dups = g_hash_table_new (g_str_hash, g_str_equal);
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_MODULEREF_SIZE);
-               if (!(p = is_valid_string (image, cols [MONO_MODULEREF_NAME], TRUE))) {
-                       if (level & MONO_VERIFY_ERROR)
-                               ADD_ERROR (list, g_strdup_printf ("Invalid name in ModuleRef row %d", i + 1));
-               } else {
-                       if (level & MONO_VERIFY_ERROR) {
-                               if (!is_valid_filename (p))
-                                       ADD_ERROR (list, g_strdup_printf ("Invalid name '%s` in ModuleRef row %d", p, i + 1));
-                               else if (g_hash_table_lookup (dups, p)) {
-                                       ADD_WARN (list, MONO_VERIFY_WARNING, g_strdup_printf ("Duplicate name '%s` in ModuleRef row %d", p, i + 1));
-                                       g_hash_table_insert (dups, (gpointer)p, (gpointer)p);
-                                       found = 0;
-                                       for (j = 0; j < tfile->rows; ++j) {
-                                               value = mono_metadata_decode_row_col (tfile, j, MONO_FILE_NAME);
-                                               if ((pf = is_valid_string (image, value, TRUE)))
-                                                       if (strcmp (p, pf) == 0) {
-                                                               found = 1;
-                                                               break;
-                                                       }
-                                       }
-                                       if (!found)
-                                               ADD_ERROR (list, g_strdup_printf ("Name '%s` in ModuleRef row %d doesn't have a match in File table", p, i + 1));
-                               }
-                       }
-               }
-       }
-       g_hash_table_destroy (dups);
-       return list;
-}
-
-static GSList*
-verify_standalonesig_table (MonoImage *image, GSList *list, int level)
-{
-       MonoTableInfo *t = &image->tables [MONO_TABLE_STANDALONESIG];
-       guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
-       const char *p;
-       guint32 i;
-
-       for (i = 0; i < t->rows; ++i) {
-               mono_metadata_decode_row (t, i, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
-               if (level & MONO_VERIFY_ERROR) {
-                       if (!is_valid_blob (image, cols [MONO_STAND_ALONE_SIGNATURE], TRUE)) {
-                               ADD_ERROR (list, g_strdup_printf ("Signature is invalid in StandAloneSig row %d", i + 1));
-                       } else {
-                               p = mono_metadata_blob_heap (image, cols [MONO_STAND_ALONE_SIGNATURE]);
-                               /* FIXME: check it's a valid locals or method sig.*/
-                       }
-               }
-       }
-       return list;
-}
-
-GSList*
-mono_image_verify_tables (MonoImage *image, int level)
-{
-       GSList *error_list = NULL;
-
-       error_list = verify_assembly_table (image, error_list, level);
-       /* 
-        * AssemblyOS, AssemblyProcessor, AssemblyRefOs and
-        * AssemblyRefProcessor should be ignored, 
-        * though we may want to emit a warning, since it should not 
-        * be present in a PE file.
-        */
-       error_list = verify_assemblyref_table (image, error_list, level);
-       error_list = verify_class_layout_table (image, error_list, level);
-       error_list = verify_constant_table (image, error_list, level);
-       /*
-        * cutom attribute, declsecurity 
-        */
-       error_list = verify_event_map_table (image, error_list, level);
-       error_list = verify_event_table (image, error_list, level);
-       error_list = verify_field_table (image, error_list, level);
-       error_list = verify_file_table (image, error_list, level);
-       error_list = verify_moduleref_table (image, error_list, level);
-       error_list = verify_standalonesig_table (image, error_list, level);
-
-       return g_slist_reverse (error_list);
-}
-
 #define ADD_INVALID(list,msg)  \
        do {    \
                MonoVerifyInfoExtended *vinfo = g_new (MonoVerifyInfoExtended, 1);      \
@@ -1730,7 +1259,7 @@ in_any_exception_block (MonoMethodHeader *header, guint offset)
  * Verify if it's valid to perform a branch from @offset to @target.
  * This should be used with br and brtrue/false.
  * It returns 0 if valid, 1 for unverifiable and 2 for invalid.
- * The major diferent from other similiar functions is that branching into a
+ * The major difference from other similiar functions is that branching into a
  * finally/fault block is invalid instead of just unverifiable.  
  */
 static int
@@ -1764,7 +1293,7 @@ is_valid_branch_instruction (MonoMethodHeader *header, guint offset, guint targe
  * This should be used with binary comparison branching instruction, like beq, bge and similars.
  * It returns 0 if valid, 1 for unverifiable and 2 for invalid.
  * 
- * The major diferences from other similar functions are that most errors lead to invalid
+ * The major differences from other similar functions are that most errors lead to invalid
  * code and only branching out of finally, filter or fault clauses is unverifiable. 
  */
 static int
@@ -2095,6 +1624,14 @@ stack_pop_safe (VerifyContext *ctx)
        return ctx->eval.stack + --ctx->eval.size;
 }
 
+/*Positive number distance from stack top. [0] is stack top, [1] is the one below*/
+static ILStackDesc*
+stack_peek (VerifyContext *ctx, int distance)
+{
+       g_assert (ctx->eval.size - distance > 0);
+       return ctx->eval.stack + (ctx->eval.size - 1 - distance);
+}
+
 static ILStackDesc *
 stack_push_stack_val (VerifyContext *ctx, ILStackDesc *value)
 {
@@ -2346,7 +1883,7 @@ is_array_type_compatible (MonoType *target, MonoType *candidate)
        if (left->rank != right->rank)
                return FALSE;
 
-       return mono_class_is_assignable_from (left->eklass, right->eklass);
+       return verifier_class_is_assignable_from (left->eklass, right->eklass);
 }
 
 static int
@@ -2383,21 +1920,12 @@ handle_enum:
        case MONO_TYPE_VAR:
        case MONO_TYPE_MVAR:
 
-       case MONO_TYPE_CLASS:
-       case MONO_TYPE_STRING:
-       case MONO_TYPE_OBJECT:
-       case MONO_TYPE_SZARRAY:
-       case MONO_TYPE_ARRAY:
-               return TYPE_COMPLEX | mask;
-
-       case MONO_TYPE_GENERICINST:
-               if (mono_type_is_enum_type (type)) {
-                       type = mono_type_get_underlying_type_any (type);
-                       type_kind = type->type;
-                       goto handle_enum;
-               } else {
-                       return TYPE_COMPLEX | mask;
-               }
+       case MONO_TYPE_CLASS:
+       case MONO_TYPE_STRING:
+       case MONO_TYPE_OBJECT:
+       case MONO_TYPE_SZARRAY:
+       case MONO_TYPE_ARRAY:
+               return TYPE_COMPLEX | mask;
 
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
@@ -2407,9 +1935,12 @@ handle_enum:
        case MONO_TYPE_R8:
                return TYPE_R8 | mask;
 
+       case MONO_TYPE_GENERICINST:
        case MONO_TYPE_VALUETYPE:
                if (mono_type_is_enum_type (type)) {
                        type = mono_type_get_underlying_type_any (type);
+                       if (!type)
+                               return FALSE;
                        type_kind = type->type;
                        goto handle_enum;
                } else {
@@ -2469,16 +2000,6 @@ handle_enum:
                stack->stype = TYPE_COMPLEX | mask;
                break;
                
-       case MONO_TYPE_GENERICINST:
-               if (mono_type_is_enum_type (type)) {
-                       type = mono_type_get_underlying_type_any (type);
-                       type_kind = type->type;
-                       goto handle_enum;
-               } else {
-                       stack->stype = TYPE_COMPLEX | mask;
-                       break;
-               }
-
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
                stack->stype = TYPE_I8 | mask;
@@ -2487,9 +2008,15 @@ handle_enum:
        case MONO_TYPE_R8:
                stack->stype = TYPE_R8 | mask;
                break;
+       case MONO_TYPE_GENERICINST:
        case MONO_TYPE_VALUETYPE:
                if (mono_type_is_enum_type (type)) {
-                       type = mono_type_get_underlying_type_any (type);
+                       MonoType *utype = mono_type_get_underlying_type_any (type);
+                       if (!utype) {
+                               ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Could not resolve underlying type of %x at %d", type->type, ctx->ip_offset));
+                               return FALSE;
+                       }
+                       type = utype;
                        type_kind = type->type;
                        goto handle_enum;
                } else {
@@ -2539,6 +2066,113 @@ init_stack_with_value_at_exception_boundary (VerifyContext *ctx, ILCodeDesc *cod
                code->stack->stype |= BOXED_MASK;
 }
 
+static MonoClass*
+get_ienumerable_class (void)
+{
+       static MonoClass* generic_ienumerable_class = NULL;
+
+       if (generic_ienumerable_class == NULL)
+               generic_ienumerable_class = mono_class_from_name (mono_defaults.corlib,
+                       "System.Collections.Generic", "IEnumerable`1");
+               return generic_ienumerable_class;
+}
+
+static MonoClass*
+get_icollection_class (void)
+{
+       static MonoClass* generic_icollection_class = NULL;
+
+       if (generic_icollection_class == NULL)
+               generic_icollection_class = mono_class_from_name (mono_defaults.corlib,
+                       "System.Collections.Generic", "ICollection`1");
+               return generic_icollection_class;
+}
+
+static MonoClass*
+inflate_class_one_arg (MonoClass *gtype, MonoClass *arg0)
+{
+       MonoType *args [1];
+       args [0] = &arg0->byval_arg;
+
+       return mono_class_bind_generic_parameters (gtype, 1, args, FALSE);
+}
+
+static gboolean
+verifier_inflate_and_check_compat (MonoClass *target, MonoClass *gtd, MonoClass *arg)
+{
+       MonoClass *tmp;
+       if (!(tmp = inflate_class_one_arg (gtd, arg)))
+               return FALSE;
+       if (mono_class_is_variant_compatible (target, tmp, TRUE))
+               return TRUE;
+       return FALSE;
+}
+
+static gboolean
+verifier_class_is_assignable_from (MonoClass *target, MonoClass *candidate)
+{
+       MonoClass *iface_gtd;
+
+       if (target == candidate)
+               return TRUE;
+
+       if (mono_class_has_variant_generic_params (target)) {
+               if (MONO_CLASS_IS_INTERFACE (target)) {
+                       if (candidate->rank == 1) {
+                               if (verifier_inflate_and_check_compat (target, mono_defaults.generic_ilist_class, candidate->element_class))
+                                       return TRUE;
+                               if (verifier_inflate_and_check_compat (target, get_icollection_class (), candidate->element_class))
+                                       return TRUE;
+                               if (verifier_inflate_and_check_compat (target, get_ienumerable_class (), candidate->element_class))
+                                       return TRUE;
+                       } else {
+                               MonoError error;
+                               int i;
+                               while (candidate && candidate != mono_defaults.object_class) {
+                                       mono_class_setup_interfaces (candidate, &error);
+                                       if (!mono_error_ok (&error)) {
+                                               mono_error_cleanup (&error);
+                                               return FALSE;
+                                       }
+
+                                       /*klass is a generic variant interface, We need to extract from oklass a list of ifaces which are viable candidates.*/
+                                       for (i = 0; i < candidate->interface_offsets_count; ++i) {
+                                               MonoClass *iface = candidate->interfaces_packed [i];
+                                               if (mono_class_is_variant_compatible (target, iface, TRUE))
+                                                       return TRUE;
+                                       }
+
+                                       for (i = 0; i < candidate->interface_count; ++i) {
+                                               MonoClass *iface = candidate->interfaces [i];
+                                               if (mono_class_is_variant_compatible (target, iface, TRUE))
+                                                       return TRUE;
+                                       }
+                                       candidate = candidate->parent;
+                               }
+                       }
+               } else if (target->delegate) {
+                       if (mono_class_is_variant_compatible (target, candidate, TRUE))
+                               return TRUE;
+               }
+               return FALSE;
+       }
+
+       if (mono_class_is_assignable_from (target, candidate))
+               return TRUE;
+
+       if (!MONO_CLASS_IS_INTERFACE (target) || !target->generic_class || candidate->rank != 1)
+               return FALSE;
+
+       iface_gtd = target->generic_class->container_class;
+       if (iface_gtd != mono_defaults.generic_ilist_class && iface_gtd != get_icollection_class () && iface_gtd != get_ienumerable_class ())
+               return FALSE;
+
+       target = mono_class_from_mono_type (target->generic_class->context.class_inst->type_argv [0]);
+       candidate = candidate->element_class;
+
+       return TRUE;
+}
+
 /*Verify if type 'candidate' can be stored in type 'target'.
  * 
  * If strict, check for the underlying type and not the verification stack types
@@ -2628,8 +2262,17 @@ handle_enum:
                MonoClass *candidate_klass;
                if (mono_type_is_enum_type (target)) {
                        target = mono_type_get_underlying_type_any (target);
+                       if (!target)
+                               return FALSE;
                        goto handle_enum;
                }
+               /*
+                * VAR / MVAR compatibility must be checked by verify_stack_type_compatibility
+                * to take boxing status into account.
+                */
+               if (mono_type_is_generic_argument (original_candidate))
+                       return FALSE;
+
                target_klass = mono_class_from_mono_type (target);
                candidate_klass = mono_class_from_mono_type (candidate);
                if (mono_class_is_nullable (target_klass)) {
@@ -2637,8 +2280,7 @@ handle_enum:
                                return FALSE;
                        return target_klass == candidate_klass;
                }
-               
-               return mono_class_is_assignable_from (target_klass, candidate_klass);
+               return verifier_class_is_assignable_from (target_klass, candidate_klass);
        }
 
        case MONO_TYPE_STRING:
@@ -2651,10 +2293,14 @@ handle_enum:
                 */
                if (mono_type_is_generic_argument (original_candidate))
                        return FALSE;
+
+               if (candidate->type == MONO_TYPE_VALUETYPE)
+                       return FALSE;
+
                /* If candidate is an enum it should return true for System.Enum and supertypes.
                 * That's why here we use the original type and not the underlying type.
                 */ 
-               return mono_class_is_assignable_from (target->data.klass, mono_class_from_mono_type (original_candidate));
+               return verifier_class_is_assignable_from (target->data.klass, mono_class_from_mono_type (original_candidate));
 
        case MONO_TYPE_OBJECT:
                return MONO_TYPE_IS_REFERENCE (candidate);
@@ -2665,9 +2311,10 @@ handle_enum:
                if (candidate->type != MONO_TYPE_SZARRAY)
                        return FALSE;
 
-               left = mono_class_from_mono_type (target)->element_class;
-               right = mono_class_from_mono_type (candidate)->element_class;
-               return mono_class_is_assignable_from (left, right);
+               left = mono_class_from_mono_type (target);
+               right = mono_class_from_mono_type (candidate);
+
+               return verifier_class_is_assignable_from (left, right);
        }
 
        case MONO_TYPE_ARRAY:
@@ -2679,13 +2326,20 @@ handle_enum:
                return candidate->type == MONO_TYPE_TYPEDBYREF;
 
        case MONO_TYPE_VALUETYPE: {
-               MonoClass *target_klass  = mono_class_from_mono_type (target);
-               MonoClass *candidate_klass = mono_class_from_mono_type (candidate);
+               MonoClass *target_klass;
+               MonoClass *candidate_klass;
 
+               if (candidate->type == MONO_TYPE_CLASS)
+                       return FALSE;
+
+               target_klass = mono_class_from_mono_type (target);
+               candidate_klass = mono_class_from_mono_type (candidate);
                if (target_klass == candidate_klass)
                        return TRUE;
                if (mono_type_is_enum_type (target)) {
                        target = mono_type_get_underlying_type_any (target);
+                       if (!target)
+                               return FALSE;
                        goto handle_enum;
                }
                return FALSE;
@@ -2741,6 +2395,30 @@ get_generic_param (VerifyContext *ctx, MonoType *param)
        return ctx->generic_context->method_inst->type_argv [param_num]->data.generic_param;
        
 }
+
+static gboolean
+recursive_boxed_constraint_type_check (VerifyContext *ctx, MonoType *type, MonoClass *constraint_class, int recursion_level)
+{
+       MonoType *constraint_type = &constraint_class->byval_arg;
+       if (recursion_level <= 0)
+               return FALSE;
+
+       if (verify_type_compatibility_full (ctx, type, mono_type_get_type_byval (constraint_type), FALSE))
+               return TRUE;
+
+       if (mono_type_is_generic_argument (constraint_type)) {
+               MonoGenericParam *param = get_generic_param (ctx, constraint_type);
+               MonoClass **class;
+               if (!param)
+                       return FALSE;
+               for (class = mono_generic_param_info (param)->constraints; class && *class; ++class) {
+                       if (recursive_boxed_constraint_type_check (ctx, type, *class, recursion_level - 1))
+                               return TRUE;
+               }
+       }
+       return FALSE;
+}
+
 /*
  * is_compatible_boxed_valuetype:
  * 
@@ -2763,8 +2441,12 @@ is_compatible_boxed_valuetype (VerifyContext *ctx, MonoType *type, MonoType *can
        if (mono_type_is_generic_argument (candidate)) {
                MonoGenericParam *param = get_generic_param (ctx, candidate);
                MonoClass **class;
+               if (!param)
+                       return FALSE;
+
                for (class = mono_generic_param_info (param)->constraints; class && *class; ++class) {
-                       if (verify_type_compatibility_full (ctx, type, mono_type_get_type_byval (& (*class)->byval_arg), FALSE))
+                       /*256 should be enough since there can't be more than 255 generic arguments.*/
+                       if (recursive_boxed_constraint_type_check (ctx, type, *class, 256))
                                return TRUE;
                }
        }
@@ -2775,7 +2457,7 @@ is_compatible_boxed_valuetype (VerifyContext *ctx, MonoType *type, MonoType *can
        if (!strict)
                return TRUE;
 
-       return MONO_TYPE_IS_REFERENCE (type) && mono_class_is_assignable_from (mono_class_from_mono_type (type), mono_class_from_mono_type (candidate));
+       return MONO_TYPE_IS_REFERENCE (type) && verifier_class_is_assignable_from (mono_class_from_mono_type (type), mono_class_from_mono_type (candidate));
 }
 
 static int
@@ -2833,6 +2515,8 @@ mono_delegate_type_equal (MonoType *target, MonoType *candidate)
                return candidate->type == target->type;
 
        case MONO_TYPE_PTR:
+               if (candidate->type != MONO_TYPE_PTR)
+                       return FALSE;
                return mono_delegate_type_equal (target->data.type, candidate->data.type);
 
        case MONO_TYPE_FNPTR:
@@ -2846,18 +2530,18 @@ mono_delegate_type_equal (MonoType *target, MonoType *candidate)
                target_klass = mono_class_from_mono_type (target);
                candidate_klass = mono_class_from_mono_type (candidate);
                /*FIXME handle nullables and enum*/
-               return mono_class_is_assignable_from (target_klass, candidate_klass);
+               return verifier_class_is_assignable_from (target_klass, candidate_klass);
        }
        case MONO_TYPE_OBJECT:
                return MONO_TYPE_IS_REFERENCE (candidate);
 
        case MONO_TYPE_CLASS:
-               return mono_class_is_assignable_from(target->data.klass, mono_class_from_mono_type (candidate));
+               return verifier_class_is_assignable_from(target->data.klass, mono_class_from_mono_type (candidate));
 
        case MONO_TYPE_SZARRAY:
                if (candidate->type != MONO_TYPE_SZARRAY)
                        return FALSE;
-               return mono_class_is_assignable_from (mono_class_from_mono_type (target)->element_class, mono_class_from_mono_type (candidate)->element_class);
+               return verifier_class_is_assignable_from (mono_class_from_mono_type (target)->element_class, mono_class_from_mono_type (candidate)->element_class);
 
        case MONO_TYPE_ARRAY:
                if (candidate->type != MONO_TYPE_ARRAY)
@@ -2936,6 +2620,12 @@ mono_delegate_signature_equal (MonoMethodSignature *delegate_sig, MonoMethodSign
        return TRUE;
 }
 
+gboolean
+mono_verifier_is_signature_compatible (MonoMethodSignature *target, MonoMethodSignature *candidate)
+{
+       return mono_delegate_signature_equal (target, candidate, FALSE);
+}
+
 /* 
  * verify_ldftn_delegate:
  * 
@@ -3141,19 +2831,23 @@ store_local (VerifyContext *ctx, guint32 arg)
        }
 
        /*TODO verify definite assigment */             
-       if (check_underflow (ctx, 1)) {
-               value = stack_pop(ctx);
-               if (!verify_stack_type_compatibility (ctx, ctx->locals [arg], value)) {
-                       char *expected = mono_type_full_name (ctx->locals [arg]);
-                       char *found = stack_slot_full_name (value);
-                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible type '%s' on stack cannot be stored to local %d with type '%s' at 0x%04x",
-                                       found,
-                                       arg,
-                                       expected,
-                                       ctx->ip_offset));
-                       g_free (expected);
-                       g_free (found); 
-               }
+       if (!check_underflow (ctx, 1))
+               return;
+
+       value = stack_pop (ctx);
+       if (ctx->locals [arg]->byref && stack_slot_is_managed_mutability_pointer (value))
+               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use a readonly managed reference when storing on a local variable at 0x%04x", ctx->ip_offset));
+                       
+       if (!verify_stack_type_compatibility (ctx, ctx->locals [arg], value)) {
+               char *expected = mono_type_full_name (ctx->locals [arg]);
+               char *found = stack_slot_full_name (value);
+               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible type '%s' on stack cannot be stored to local %d with type '%s' at 0x%04x",
+                               found,
+                               arg,
+                               expected,
+                               ctx->ip_offset));
+               g_free (expected);
+               g_free (found); 
        }
 }
 
@@ -3376,7 +3070,11 @@ do_ret (VerifyContext *ctx)
                top = stack_pop(ctx);
 
                if (!verify_stack_type_compatibility (ctx, ctx->signature->ret, top)) {
-                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible return value on stack with method signature ret at 0x%04x", ctx->ip_offset));
+                       char *ret_type = mono_type_full_name (ctx->signature->ret);
+                       char *stack_type = stack_slot_full_name (top);
+                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible return value on stack with method signature, expected '%s' but got '%s' at 0x%04x", ret_type, stack_type, ctx->ip_offset));
+                       g_free (stack_type);
+                       g_free (ret_type);
                        return;
                }
 
@@ -3422,7 +3120,7 @@ do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
                if (method->flags & METHOD_ATTRIBUTE_ABSTRACT) 
                        CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use call with an abstract method at 0x%04x", ctx->ip_offset));
                
-               if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !(method->flags & METHOD_ATTRIBUTE_FINAL)) {
+               if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !(method->flags & METHOD_ATTRIBUTE_FINAL) && !(method->klass->flags & TYPE_ATTRIBUTE_SEALED)) {
                        virt_check_this = TRUE;
                        ctx->code [ctx->ip_offset].flags |= IL_CODE_CALL_NONFINAL_VIRTUAL;
                }
@@ -3470,7 +3168,7 @@ do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
                        if (!mono_method_is_constructor (ctx->method))
                                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot call a constructor outside one at 0x%04x", ctx->ip_offset));
                        if (method->klass != ctx->method->klass->parent && method->klass != ctx->method->klass)
-                               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot call a constructor to a type diferent that this or super at 0x%04x", ctx->ip_offset));
+                               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot call a constructor of a type different from this or super at 0x%04x", ctx->ip_offset));
 
                        ctx->super_ctor_called = TRUE;
                        value = stack_pop_safe (ctx);
@@ -3487,7 +3185,7 @@ do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
                copy.stype &= ~POINTER_MASK;
 
                if (virt_check_this && !stack_slot_is_this_pointer (value) && !(method->klass->valuetype || stack_slot_is_boxed_value (value)))
-                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use the call opcode with a non-final virtual method on an object diferent thant the this pointer at 0x%04x", ctx->ip_offset));
+                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use the call opcode with a non-final virtual method on an object different than the 'this' pointer at 0x%04x", ctx->ip_offset));
 
                if (constrained && virtual) {
                        if (!stack_slot_is_managed_pointer (value))
@@ -3508,8 +3206,16 @@ do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
                        if (method->klass->valuetype && (stack_slot_is_boxed_value (value) || !stack_slot_is_managed_pointer (value)))
                                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use a boxed or literal valuetype to call a valuetype method at 0x%04x", ctx->ip_offset));
                }
-               if (!verify_stack_type_compatibility (ctx, type, &copy))
-                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible this argument on stack with method signature at 0x%04x", ctx->ip_offset));
+               if (!verify_stack_type_compatibility (ctx, type, &copy)) {
+                       char *expected = mono_type_full_name (type);
+                       char *effective = stack_slot_full_name (&copy);
+                       char *method_name = mono_method_full_name (method, TRUE);
+                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible this argument on stack with method signature expected '%s' but got '%s' for a call to '%s' at 0x%04x",
+                                       expected, effective, method_name, ctx->ip_offset));
+                       g_free (method_name);
+                       g_free (effective);
+                       g_free (expected);
+               }
 
                if (!IS_SKIP_VISIBILITY (ctx) && !mono_method_can_access_method_full (ctx->method, method, mono_class_from_mono_type (value->type))) {
                        char *name = mono_method_full_name (method, TRUE);
@@ -3524,6 +3230,9 @@ do_invoke_method (VerifyContext *ctx, int method_token, gboolean virtual)
        }
 
        if (sig->ret->type != MONO_TYPE_VOID) {
+               if (!mono_type_is_valid_in_context (ctx, sig->ret))
+                       return;
+
                if (check_overflow (ctx)) {
                        value = stack_push (ctx);
                        set_stack_value (ctx, value, sig->ret, FALSE);
@@ -3599,8 +3308,14 @@ do_store_static_field (VerifyContext *ctx, int token) {
        if (!IS_SKIP_VISIBILITY (ctx) && !mono_method_can_access_field_full (ctx->method, field, NULL))
                CODE_NOT_VERIFIABLE2 (ctx, g_strdup_printf ("Type at stack is not accessible at 0x%04x", ctx->ip_offset), MONO_EXCEPTION_FIELD_ACCESS);
 
-       if (!verify_stack_type_compatibility (ctx, field->type, value))
-               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible type %s in static field store at 0x%04x", stack_slot_get_name (value), ctx->ip_offset));       
+       if (!verify_stack_type_compatibility (ctx, field->type, value)) {
+               char *stack_name = stack_slot_full_name (value);
+               char *field_name = mono_type_full_name (field->type);
+               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Incompatible type in static field store expected '%s' but found '%s' at 0x%04x",
+                               field_name, stack_name, ctx->ip_offset));
+               g_free (field_name);
+               g_free (stack_name);
+       }
 }
 
 static gboolean
@@ -3640,8 +3355,13 @@ check_is_valid_type_for_field_ops (VerifyContext *ctx, int token, ILStackDesc *o
                if (field->parent->valuetype && stack_slot_is_boxed_value (obj))
                        CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Type at stack is a boxed valuetype and is not compatible to reference the field at 0x%04x", ctx->ip_offset));
 
-               if (!stack_slot_is_null_literal (obj) && !verify_stack_type_compatibility_full (ctx, &field->parent->byval_arg, obj, TRUE, FALSE))
-                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Type at stack is not compatible to reference the field at 0x%04x", ctx->ip_offset));
+               if (!stack_slot_is_null_literal (obj) && !verify_stack_type_compatibility_full (ctx, &field->parent->byval_arg, obj, TRUE, FALSE)) {
+                       char *found = stack_slot_full_name (obj);
+                       char *expected = mono_type_full_name (&field->parent->byval_arg);
+                       CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Expected type '%s' but found '%s' referencing the 'this' argument at 0x%04x", expected, found, ctx->ip_offset));
+                       g_free (found);
+                       g_free (expected);
+               }
 
                if (!IS_SKIP_VISIBILITY (ctx) && !mono_method_can_access_field_full (ctx->method, field, mono_class_from_mono_type (obj->type)))
                        CODE_NOT_VERIFIABLE2 (ctx, g_strdup_printf ("Type at stack is not accessible at 0x%04x", ctx->ip_offset), MONO_EXCEPTION_FIELD_ACCESS);
@@ -3845,7 +3565,34 @@ do_load_token (VerifyContext *ctx, int token)
        MonoClass *handle_class;
        if (!check_overflow (ctx))
                return;
-       handle = mono_ldtoken (ctx->image, token, &handle_class, ctx->generic_context);
+
+       if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
+               handle = mono_method_get_wrapper_data (ctx->method, token);
+               handle_class = mono_method_get_wrapper_data (ctx->method, token + 1);
+               if (handle_class == mono_defaults.typehandle_class)
+                       handle = &((MonoClass*)handle)->byval_arg;
+       } else {
+               switch (token & 0xff000000) {
+               case MONO_TOKEN_TYPE_DEF:
+               case MONO_TOKEN_TYPE_REF:
+               case MONO_TOKEN_TYPE_SPEC:
+               case MONO_TOKEN_FIELD_DEF:
+               case MONO_TOKEN_METHOD_DEF:
+               case MONO_TOKEN_METHOD_SPEC:
+               case MONO_TOKEN_MEMBER_REF:
+                       if (!token_bounds_check (ctx->image, token)) {
+                               ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Table index out of range 0x%x for token %x for ldtoken at 0x%04x", mono_metadata_token_index (token), token, ctx->ip_offset));
+                               return;
+                       }
+                       break;
+               default:
+                       ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Invalid table 0x%x for token 0x%x for ldtoken at 0x%04x", mono_metadata_token_table (token), token, ctx->ip_offset));
+                       return;
+               }
+
+               handle = mono_ldtoken (ctx->image, token, &handle_class, ctx->generic_context);
+       }
+
        if (!handle) {
                ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Invalid token 0x%x for ldtoken at 0x%04x", token, ctx->ip_offset));
                return;
@@ -3918,8 +3665,13 @@ do_stobj (VerifyContext *ctx, int token)
        if (stack_slot_is_boxed_value (src) && !MONO_TYPE_IS_REFERENCE (src->type) && !MONO_TYPE_IS_REFERENCE (type))
                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use stobj with a boxed source value that is not a reference type at 0x%04x", ctx->ip_offset));
 
-       if (!verify_stack_type_compatibility (ctx, type, src))
-               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Token and source types of stobj don't match at 0x%04x", ctx->ip_offset));
+       if (!verify_stack_type_compatibility (ctx, type, src)) {
+               char *type_name = mono_type_full_name (type);
+               char *src_name = stack_slot_full_name (src);
+               CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Token '%s' and source '%s' of stobj don't match ' at 0x%04x", type_name, src_name, ctx->ip_offset));
+               g_free (type_name);
+               g_free (src_name);
+       }
 
        if (!verify_type_compatibility (ctx, mono_type_get_type_byval (dest->type), type))
                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Destination and token types of stobj don't match at 0x%04x", ctx->ip_offset));
@@ -4010,7 +3762,7 @@ do_newobj (VerifyContext *ctx, int token)
        if (method->klass->flags & (TYPE_ATTRIBUTE_ABSTRACT | TYPE_ATTRIBUTE_INTERFACE))
                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Trying to instantiate an abstract or interface type at 0x%04x", ctx->ip_offset));
 
-       if (!mono_method_can_access_method_full (ctx->method, method, NULL)) {
+       if (!IS_SKIP_VISIBILITY (ctx) && !mono_method_can_access_method_full (ctx->method, method, NULL)) {
                char *from = mono_method_full_name (ctx->method, TRUE);
                char *to = mono_method_full_name (method, TRUE);
                CODE_NOT_VERIFIABLE2 (ctx, g_strdup_printf ("Constructor %s not visible from %s at 0x%04x", to, from, ctx->ip_offset), MONO_EXCEPTION_METHOD_ACCESS);
@@ -4025,6 +3777,11 @@ do_newobj (VerifyContext *ctx, int token)
                return;
        }
 
+       if (!sig->hasthis) {
+               ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Invalid constructor signature missing hasthis at 0x%04x", ctx->ip_offset));
+               return;
+       }
+
        if (!check_underflow (ctx, sig->param_count))
                return;
 
@@ -4071,7 +3828,7 @@ do_cast (VerifyContext *ctx, int token, const char *opcode) {
        if (!check_underflow (ctx, 1))
                return;
 
-       if (!(type = verifier_load_type (ctx, token, opcode)))
+       if (!(type = get_boxable_mono_type (ctx, token, opcode)))
                return;
 
        if (type->byref) {
@@ -4470,6 +4227,7 @@ do_leave (VerifyContext *ctx, int delta)
        if (!is_correct_leave (ctx->header, ctx->ip_offset, target))
                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Leave not allowed in finally block at 0x%04x", ctx->ip_offset));
        ctx->eval.size = 0;
+       ctx->target = target;
 }
 
 /* 
@@ -4544,13 +4302,21 @@ do_load_function_ptr (VerifyContext *ctx, guint32 token, gboolean virtual)
        if (!virtual && !check_overflow (ctx))
                return;
 
-       if (!IS_METHOD_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid token %x for ldftn  at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return;
-       }
+       if (ctx->method->wrapper_type != MONO_WRAPPER_NONE) {
+               method = mono_method_get_wrapper_data (ctx->method, (guint32)token);
+               if (!method) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid token %x for ldftn  at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return;
+               }
+       } else {
+               if (!IS_METHOD_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid token %x for ldftn  at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return;
+               }
 
-       if (!(method = verifier_load_method (ctx, token, virtual ? "ldvirtfrn" : "ldftn")))
-               return;
+               if (!(method = verifier_load_method (ctx, token, virtual ? "ldvirtfrn" : "ldftn")))
+                       return;
+       }
 
        if (mono_method_is_constructor (method))
                CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Cannot use ldftn with a constructor at 0x%04x", ctx->ip_offset));
@@ -4568,7 +4334,7 @@ do_load_function_ptr (VerifyContext *ctx, guint32 token, gboolean virtual)
                        CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Unexpected object for ldvirtftn at 0x%04x", ctx->ip_offset));
        }
        
-       if (!mono_method_can_access_method_full (ctx->method, method, NULL))
+       if (!IS_SKIP_VISIBILITY (ctx) && !mono_method_can_access_method_full (ctx->method, method, NULL))
                CODE_NOT_VERIFIABLE2 (ctx, g_strdup_printf ("Loaded method is not visible for ldftn/ldvirtftn at 0x%04x", ctx->ip_offset), MONO_EXCEPTION_METHOD_ACCESS);
 
        top = stack_push_val(ctx, TYPE_PTR, mono_type_create_fnptr_from_mono_method (ctx, method));
@@ -4579,11 +4345,6 @@ static void
 do_sizeof (VerifyContext *ctx, int token)
 {
        MonoType *type;
-
-       if (!IS_TYPE_DEF_OR_REF_OR_SPEC (token) || !token_bounds_check (ctx->image, token)) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid type token %x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return;
-       }
        
        if (!(type = verifier_load_type (ctx, token, "sizeof")))
                return;
@@ -4629,16 +4390,18 @@ static void
 do_ldstr (VerifyContext *ctx, guint32 token)
 {
        GSList *error = NULL;
-       if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid string token %x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return;
-       }
+       if (ctx->method->wrapper_type == MONO_WRAPPER_NONE && !ctx->image->dynamic) {
+               if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid string token %x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return;
+               }
 
-       if (!ctx->image->dynamic && !mono_verifier_verify_string_signature (ctx->image, mono_metadata_token_index (token), &error)) {
-               if (error)
-                       ctx->list = g_slist_concat (ctx->list, error);
-               ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid string index %x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
-               return;
+               if (!mono_verifier_verify_string_signature (ctx->image, mono_metadata_token_index (token), &error)) {
+                       if (error)
+                               ctx->list = g_slist_concat (ctx->list, error);
+                       ADD_VERIFY_ERROR2 (ctx, g_strdup_printf ("Invalid string index %x at 0x%04x", token, ctx->ip_offset), MONO_EXCEPTION_BAD_IMAGE);
+                       return;
+               }
        }
 
        if (check_overflow (ctx))
@@ -4795,7 +4558,10 @@ merge_stacks (VerifyContext *ctx, ILCodeDesc *from, ILCodeDesc *to, gboolean sta
                        && !mono_class_from_mono_type (new_type)->valuetype
                        && !stack_slot_is_managed_pointer (old_slot)
                        && !stack_slot_is_managed_pointer (new_slot)) {
-                       
+
+                       mono_class_setup_supertypes (old_class);
+                       mono_class_setup_supertypes (new_class);
+
                        for (j = MIN (old_class->idepth, new_class->idepth) - 1; j > 0; --j) {
                                if (mono_metadata_type_equal (&old_class->supertypes [j]->byval_arg, &new_class->supertypes [j]->byval_arg)) {
                                        match_class = old_class->supertypes [j];
@@ -4997,6 +4763,12 @@ mono_method_verify (MonoMethod *method, int level)
                finish_collect_stats ();
                return ctx.list;
        }
+       if (!method->is_generic && !method->klass->is_generic && ctx.signature->has_type_parameters) {
+               ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Method and signature don't match in terms of genericity"));
+               finish_collect_stats ();
+               return ctx.list;
+       }
+
        ctx.header = mono_method_get_header (method);
        if (!ctx.header) {
                ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Could not decode method header"));
@@ -5162,10 +4934,11 @@ mono_method_verify (MonoMethod *method, int level)
        g_assert (bb);
 
        while (ip < end && ctx.valid) {
+               int op_size;
                ip_offset = ip - code_start;
                {
                        const unsigned char *ip_copy = ip;
-                       int size, op;
+                       int op;
 
                        if (ip_offset > bb->end) {
                                ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Branch or EH block at [0x%04x] targets middle instruction at 0x%04x", bb->end, ip_offset));
@@ -5175,29 +4948,22 @@ mono_method_verify (MonoMethod *method, int level)
                        if (ip_offset == bb->end)
                                bb = bb->next;
        
-                       size = mono_opcode_value_and_size (&ip_copy, end, &op);
-                       if (size == -1) {
+                       op_size = mono_opcode_value_and_size (&ip_copy, end, &op);
+                       if (op_size == -1) {
                                ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Invalid instruction %x at 0x%04x", *ip, ip_offset));
                                goto cleanup;
                        }
 
-                       if (ADD_IS_GREATER_OR_OVF (ip_offset, size, bb->end)) {
+                       if (ADD_IS_GREATER_OR_OVF (ip_offset, op_size, bb->end)) {
                                ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Branch or EH block targets middle of instruction at 0x%04x", ip_offset));
                                goto cleanup;
                        }
 
                        /*Last Instruction*/
-                       if (ip_offset + size == bb->end && mono_opcode_is_prefix (op)) {
+                       if (ip_offset + op_size == bb->end && mono_opcode_is_prefix (op)) {
                                ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Branch or EH block targets between prefix '%s' and instruction at 0x%04x", mono_opcode_name (op), ip_offset));
                                goto cleanup;
                        }
-
-                       if (bb->dead) {
-                               /*FIXME remove this once we move all bad branch checking code to use BB only*/
-                               ctx.code [ip_offset].flags |= IL_CODE_FLAG_SEEN;
-                               ip += size;
-                               continue;
-                       }
                }
 
                ctx.ip_offset = ip_offset = ip - code_start;
@@ -5239,6 +5005,14 @@ mono_method_verify (MonoMethod *method, int level)
                        }
                }
 
+               /*This must be done after fallthru detection otherwise it won't happen.*/
+               if (bb->dead) {
+                       /*FIXME remove this once we move all bad branch checking code to use BB only*/
+                       ctx.code [ip_offset].flags |= IL_CODE_FLAG_SEEN;
+                       ip += op_size;
+                       continue;
+               }
+
                if (!ctx.valid)
                        break;
 
@@ -5490,14 +5264,13 @@ mono_method_verify (MonoMethod *method, int level)
                        break; 
 
                case CEE_DUP: {
-                       ILStackDesc * top;
+                       ILStackDesc *top;
                        if (!check_underflow (&ctx, 1))
                                break;
                        if (!check_overflow (&ctx))
                                break;
-                       top = stack_pop_safe (&ctx);
-                       copy_stack_value (stack_push (&ctx), top); 
-                       copy_stack_value (stack_push (&ctx), top);
+                       top = stack_push (&ctx);
+                       copy_stack_value (top, stack_peek (&ctx, 1));
                        ++ip;
                        break;
                }
@@ -5577,7 +5350,6 @@ mono_method_verify (MonoMethod *method, int level)
                        code_bounds_check (sizeof (guint32) * entries);
                        
                        do_switch (&ctx, entries, ip);
-                       start = 1;
                        ip += sizeof (guint32) * entries;
                        break;
                }
@@ -5872,6 +5644,7 @@ mono_method_verify (MonoMethod *method, int level)
                        do_leave (&ctx, read32 (ip + 1) + 5);
                        ip += 5;
                        start = 1;
+                       need_merge = 1;
                        break;
 
                case CEE_LEAVE_S:
@@ -5879,6 +5652,7 @@ mono_method_verify (MonoMethod *method, int level)
                        do_leave (&ctx, (signed char)ip [1] + 2);
                        ip += 2;
                        start = 1;
+                       need_merge = 1;
                        break;
 
                case CEE_PREFIX1:
@@ -5912,7 +5686,8 @@ mono_method_verify (MonoMethod *method, int level)
 
 
                        case CEE_ARGLIST:
-                               check_overflow (&ctx);
+                               if (!check_overflow (&ctx))
+                                       break;
                                if (ctx.signature->call_convention != MONO_CALL_VARARG)
                                        ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Cannot use arglist on method without VARGARG calling convention at 0x%04x", ctx.ip_offset));
                                set_stack_value (&ctx, stack_push (&ctx), &mono_defaults.argumenthandle_class->byval_arg, FALSE);
@@ -6154,7 +5929,7 @@ mono_verify_corlib ()
 gboolean
 mono_verifier_is_enabled_for_method (MonoMethod *method)
 {
-       return mono_verifier_is_enabled_for_class (method->klass) && method->wrapper_type == MONO_WRAPPER_NONE;
+       return mono_verifier_is_enabled_for_class (method->klass) && (method->wrapper_type == MONO_WRAPPER_NONE || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD);
 }
 
 /*
@@ -6164,7 +5939,7 @@ mono_verifier_is_enabled_for_method (MonoMethod *method)
 gboolean
 mono_verifier_is_enabled_for_class (MonoClass *klass)
 {
-       return verify_all || (verifier_mode > MONO_VERIFIER_MODE_OFF && !klass->image->assembly->in_gac && klass->image != mono_defaults.corlib);
+       return verify_all || (verifier_mode > MONO_VERIFIER_MODE_OFF && !(klass->image->assembly && klass->image->assembly->in_gac) && klass->image != mono_defaults.corlib);
 }
 
 gboolean
@@ -6173,10 +5948,14 @@ mono_verifier_is_enabled_for_image (MonoImage *image)
        return verify_all || verifier_mode > MONO_VERIFIER_MODE_OFF;
 }
 
+/*
+ * Dynamic methods are not considered full trust since if the user is trusted and need to
+ * generate unsafe code, make the method skip verification - this is a known good way to do it.
+ */
 gboolean
 mono_verifier_is_method_full_trust (MonoMethod *method)
 {
-       return mono_verifier_is_class_full_trust (method->klass);
+       return mono_verifier_is_class_full_trust (method->klass) && !method->dynamic;
 }
 
 /*
@@ -6192,7 +5971,7 @@ mono_verifier_is_class_full_trust (MonoClass *klass)
 {
        /* under CoreCLR code is trusted if it is part of the "platform" otherwise all code inside the GAC is trusted */
        gboolean trusted_location = (mono_security_get_mode () != MONO_SECURITY_MODE_CORE_CLR) ? 
-               klass->image->assembly->in_gac : mono_security_core_clr_is_platform_image (klass->image);
+               (klass->image->assembly && klass->image->assembly->in_gac) : mono_security_core_clr_is_platform_image (klass->image);
 
        if (verify_all && verifier_mode == MONO_VERIFIER_MODE_OFF)
                return trusted_location || klass->image == mono_defaults.corlib;
@@ -6200,11 +5979,11 @@ mono_verifier_is_class_full_trust (MonoClass *klass)
 }
 
 GSList*
-mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility)
+mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility, gboolean is_fulltrust)
 {
        return mono_method_verify (method, 
                        (verifier_mode != MONO_VERIFIER_MODE_STRICT ? MONO_VERIFY_NON_STRICT: 0)
-                       | (!mono_verifier_is_method_full_trust (method) ? MONO_VERIFY_FAIL_FAST : 0)
+                       | (!is_fulltrust && !mono_verifier_is_method_full_trust (method) ? MONO_VERIFY_FAIL_FAST : 0)
                        | (skip_visibility ? MONO_VERIFY_SKIP_VISIBILITY : 0));
 }
 
@@ -6350,6 +6129,73 @@ verify_valuetype_layout (MonoClass *class)
        return res;
 }
 
+static gboolean
+recursive_mark_constraint_args (MonoBitSet *used_args, MonoGenericContainer *gc, MonoType *type)
+{
+       int idx;
+       MonoClass **constraints;
+       MonoGenericParamInfo *param_info;
+
+       g_assert (mono_type_is_generic_argument (type));
+
+       idx = mono_type_get_generic_param_num (type);
+       if (mono_bitset_test_fast (used_args, idx))
+               return FALSE;
+
+       mono_bitset_set_fast (used_args, idx);
+       param_info = mono_generic_container_get_param_info (gc, idx);
+
+       if (!param_info->constraints)
+               return TRUE;
+
+       for (constraints = param_info->constraints; *constraints; ++constraints) {
+               MonoClass *ctr = *constraints;
+               MonoType *constraint_type = &ctr->byval_arg;
+
+               if (mono_type_is_generic_argument (constraint_type) && !recursive_mark_constraint_args (used_args, gc, constraint_type))
+                       return FALSE;
+       }
+       return TRUE;
+}
+
+static gboolean
+verify_generic_parameters (MonoClass *class)
+{
+       int i;
+       MonoGenericContainer *gc = class->generic_container;
+       MonoBitSet *used_args = mono_bitset_new (gc->type_argc, 0);
+
+       for (i = 0; i < gc->type_argc; ++i) {
+               MonoGenericParamInfo *param_info = mono_generic_container_get_param_info (gc, i);
+               MonoClass **constraints;
+
+               if (!param_info->constraints)
+                       continue;
+
+               mono_bitset_clear_all (used_args);
+               mono_bitset_set_fast (used_args, i);
+
+               for (constraints = param_info->constraints; *constraints; ++constraints) {
+                       MonoClass *ctr = *constraints;
+                       MonoType *constraint_type = &ctr->byval_arg;
+
+                       if (!mono_type_is_valid_type_in_context (constraint_type, &gc->context))
+                               goto fail;
+
+                       if (mono_type_is_generic_argument (constraint_type) && !recursive_mark_constraint_args (used_args, gc, constraint_type))
+                               goto fail;
+                       if (ctr->generic_class && !mono_class_is_valid_generic_instantiation (NULL, ctr))
+                               goto fail;
+               }
+       }
+       mono_bitset_free (used_args);
+       return TRUE;
+
+fail:
+       mono_bitset_free (used_args);
+       return FALSE;
+}
+
 /*
  * Check if the class is verifiable.
  * 
@@ -6368,10 +6214,23 @@ mono_verifier_verify_class (MonoClass *class)
                !MONO_CLASS_IS_INTERFACE (class) &&
                (!class->image->dynamic && class->type_token != 0x2000001)) /*<Module> is the first type in the assembly*/
                return FALSE;
-       if (class->parent && MONO_CLASS_IS_INTERFACE (class->parent))
-               return FALSE;
+       if (class->parent) {
+               if (MONO_CLASS_IS_INTERFACE (class->parent))
+                       return FALSE;
+               if (!class->generic_class && class->parent->generic_container)
+                       return FALSE;
+               if (class->parent->generic_class && !class->generic_class) {
+                       MonoGenericContext *context = mono_class_get_context (class);
+                       if (class->generic_container)
+                               context = &class->generic_container->context;
+                       if (!mono_type_is_valid_type_in_context (&class->parent->byval_arg, context))
+                               return FALSE;
+               }
+       }
        if (class->generic_container && (class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT)
                return FALSE;
+       if (class->generic_container && !verify_generic_parameters (class))
+               return FALSE;
        if (!verify_class_for_overlapping_reference_fields (class))
                return FALSE;
        if (class->generic_class && !mono_class_is_valid_generic_instantiation (NULL, class))
@@ -6384,6 +6243,21 @@ mono_verifier_verify_class (MonoClass *class)
                return FALSE;
        return TRUE;
 }
+
+gboolean
+mono_verifier_class_is_valid_generic_instantiation (MonoClass *class)
+{
+       return mono_class_is_valid_generic_instantiation (NULL, class);
+}
+
+gboolean
+mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method)
+{
+       if (!method->is_inflated)
+               return TRUE;
+       return mono_method_is_valid_generic_instantiation (NULL, method);
+}
+
 #else
 
 gboolean
@@ -6394,7 +6268,7 @@ mono_verifier_verify_class (MonoClass *class)
 }
 
 GSList*
-mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility)
+mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility, gboolean is_fulltrust)
 {
        /* The verifier was disabled at compile time */
        return NULL;
@@ -6449,10 +6323,18 @@ mono_free_verify_list (GSList *list)
        /* will always be null if verifier is disabled */
 }
 
-GSList*
-mono_image_verify_tables (MonoImage *image, int level)
+gboolean
+mono_verifier_class_is_valid_generic_instantiation (MonoClass *class)
 {
-       /* The verifier was disabled at compile time */
-       return NULL;
-}      
+       return TRUE;
+}
+
+gboolean
+mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method)
+{
+       return TRUE;
+}
+
+
+
 #endif