projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[runtime] Don't set flag to skip future initialization on half-baked classes
[mono.git] / mono / dis / get.c
diff --git a/mono/dis/get.c b/mono/dis/get.c
old mode 100644 (file)
new mode 100755 (executable)
index d167c84..a78324d
--- a/mono/dis/get.c
+++ b/mono/dis/get.c
@@ -5,6 +5,7 @@
  *   Miguel de Icaza (miguel@ximian.com)
  *
  * (C) 2001 Ximian, Inc.
+ * Copyright 2012 Xamarin Inc
  */
 #include <config.h>
 #include <stdio.h>
@@ -188,12 +189,11 @@ get_typespec (MonoImage *m, guint32 idx, gboolean is_def, MonoGenericContainer *
        const char *ptr;
        char *s, *result;
        GString *res = g_string_new ("");
-       int len;
        MonoMethodSignature *sig;
 
        mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPESPEC], idx-1, cols, MONO_TYPESPEC_SIZE);
        ptr = mono_metadata_blob_heap (m, cols [MONO_TYPESPEC_SIGNATURE]);
-       len = mono_metadata_decode_value (ptr, &ptr);
+       /* len = */ mono_metadata_decode_value (ptr, &ptr);
 
        switch (*ptr++){
        case MONO_TYPE_PTR:
@@ -214,14 +214,16 @@ get_typespec (MonoImage *m, guint32 idx, gboolean is_def, MonoGenericContainer *
                g_string_append (res, "*");
                break;
 
-       case MONO_TYPE_FNPTR:
-               sig = mono_metadata_parse_method_signature_full (m, container, 0, ptr, &ptr);
+       case MONO_TYPE_FNPTR: {
+               MonoError error;
+               sig = mono_metadata_parse_method_signature_full (m, container, 0, ptr, &ptr, &error);
+               g_assert (mono_error_ok (&error)); /*FIXME don't swallow the error message*/
                s = dis_stringify_function_ptr (m, sig);
                g_string_append (res, "method ");
                g_string_append (res, s);
                g_free (s);
                break;
-
+       }
        case MONO_TYPE_ARRAY:
                ptr = get_type (m, ptr, &s, is_def, container);
                g_string_append (res, s);
@@ -888,14 +890,18 @@ dis_stringify_method_signature_full (MonoImage *m, MonoMethodSignature *method,
                method_name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]);
                param_index = cols [MONO_METHOD_PARAMLIST];
                if (!method) {
+                       MonoError error;
                        const char *sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
 
                        container = mono_metadata_load_generic_params (m, MONO_TOKEN_METHOD_DEF | methoddef_row, container);
-                       if (container)
-                               mono_metadata_load_generic_param_constraints (m, MONO_TOKEN_METHOD_DEF | methoddef_row, container);
+                       if (container) {
+                               mono_metadata_load_generic_param_constraints_checked (m, MONO_TOKEN_METHOD_DEF | methoddef_row, container, &error);
+                               g_assert (mono_error_ok (&error)); /*FIXME don't swallow the error message*/
+                       }
 
                        mono_metadata_decode_blob_size (sig, &sig);
-                       method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig, &sig);
+                       method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig, &sig, &error);
+                       g_assert (mono_error_ok (&error)); /*FIXME don't swallow the error message*/
                        free_method = 1;
                }
 
@@ -1350,12 +1356,10 @@ get_field_signature (MonoImage *m, guint32 blob_signature, MonoGenericContainer
 {
        char *allocated_modifier_string, *allocated_type_string;
        const char *ptr = mono_metadata_blob_heap (m, blob_signature);
-       const char *base;
        char *res;
        int len;
        
        len = mono_metadata_decode_value (ptr, &ptr);
-       base = ptr;
        /* FIELD is 0x06 */
        g_assert (*ptr == 0x06);
 /*     hex_dump (ptr, 0, len); */
@@ -1622,7 +1626,15 @@ static dis_map_t field_flags_map [] = {
        { FIELD_ATTRIBUTE_SPECIAL_NAME,        "specialname " },
        { FIELD_ATTRIBUTE_PINVOKE_IMPL,        "FIXME:pinvokeimpl " },
        { FIELD_ATTRIBUTE_RT_SPECIAL_NAME,        "rtspecialname " },
-       /*{ FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL,        "hasfieldmarshal " },*/
+
+       /* This is set when a MarshalAs attribute is seen. FIXME: round-trip?  */
+       { FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL,        "" },
+
+       /* This seems to be set if LITERAL is set. FIXME: round-trip? */
+       { FIELD_ATTRIBUTE_HAS_DEFAULT,          "" },
+
+       /* This seems to be set on compiler-generated array initializer fields. FIXME: round-trip? */
+       { FIELD_ATTRIBUTE_HAS_FIELD_RVA,                "" },
        { 0, NULL }
 };
 
@@ -1636,11 +1648,12 @@ field_flags (guint32 f)
 {
        char buffer [1024];
        int access = f & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK;
+       int rest = f & ~access;
        
        buffer [0] = 0;
 
        strcat (buffer, map (access, field_access_map));
-       strcat (buffer, flags (f, field_flags_map));
+       strcat (buffer, flags (rest, field_flags_map));
        return g_strdup (buffer);
 }
 
@@ -1655,11 +1668,11 @@ get_methodref_signature (MonoImage *m, guint32 blob_signature, const char *fancy
        char *allocated_ret_type, *s;
        const char *cconv_str;
        gboolean seen_vararg = 0;
-       int param_count, signature_len;
+       int param_count;
        int i, gen_count = 0;
        int cconv;
 
-       signature_len = mono_metadata_decode_value (ptr, &ptr);
+       /* signature_len = */ mono_metadata_decode_value (ptr, &ptr);
 
        if (*ptr & 0x20){
                if (*ptr & 0x40)
@@ -2297,10 +2310,10 @@ get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
                readr4 (ptr, &r);
 
                /* Crazy solaris systems doesn't have isnormal */
-#ifdef HAVE_FINITE
-               normal = finite (r);
+#ifdef HAVE_ISFINITE
+               normal = isfinite (r);
 #else
-               normal = isnormal (r);
+               normal = !dis_isinf (r) && !dis_isnan (r);
 #endif
                if (!normal) {
                        return g_strdup_printf ("float32(0x%08x)", read32 (ptr));
@@ -2317,8 +2330,8 @@ get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
                readr8 (ptr, &r);
 
                /* Crazy solaris systems doesn't have isnormal */
-#ifdef HAVE_FINITE
-               normal = finite (r);
+#ifdef HAVE_ISFINITE
+               normal = isfinite (r);
 #else
                normal = isnormal (r);
 #endif
@@ -2552,9 +2565,9 @@ dis_get_custom_attrs (MonoImage *m, guint32 token)
 
 char*
 get_marshal_info (MonoImage *m, const char *blob) {
-       int len, size = 0;
+       int size = 0;
 
-       len = mono_metadata_decode_blob_size (blob, &blob);
+       /* len = */ mono_metadata_decode_blob_size (blob, &blob);
 
        switch (*blob) {
        case MONO_NATIVE_BOOLEAN:
@@ -2894,6 +2907,7 @@ init_key_table (void)
        g_hash_table_insert (key_table, (char *) "ldvirtftn", GINT_TO_POINTER (TRUE));
        g_hash_table_insert (key_table, (char *) "leave", GINT_TO_POINTER (TRUE));
        g_hash_table_insert (key_table, (char *) "leave.s", GINT_TO_POINTER (TRUE));
+       g_hash_table_insert (key_table, (char *) "legacy", GINT_TO_POINTER (TRUE));
        g_hash_table_insert (key_table, (char *) "linkcheck", GINT_TO_POINTER (TRUE));
        g_hash_table_insert (key_table, (char *) "literal", GINT_TO_POINTER (TRUE));
        g_hash_table_insert (key_table, (char *) "localloc", GINT_TO_POINTER (TRUE));
@@ -3161,3 +3175,46 @@ cant_print_generic_param_name (MonoGenericParam *gparam)
 }
 
 
+static dis_map_t method_impl_map [] = {
+       { METHOD_IMPL_ATTRIBUTE_IL,              "cil " },
+       { METHOD_IMPL_ATTRIBUTE_NATIVE,          "native " },
+       { METHOD_IMPL_ATTRIBUTE_OPTIL,           "optil " },
+       { METHOD_IMPL_ATTRIBUTE_RUNTIME,         "runtime " },
+       { 0, NULL }
+};
+
+static dis_map_t managed_type_map [] = {
+       { METHOD_IMPL_ATTRIBUTE_UNMANAGED,       "unmanaged " },
+       { METHOD_IMPL_ATTRIBUTE_MANAGED,         "managed " },
+       { 0, NULL }
+};
+
+static dis_map_t managed_impl_flags [] = {
+       { METHOD_IMPL_ATTRIBUTE_FORWARD_REF,     "fwdref " },
+       { METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG,    "preservesig " },
+       { METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL,   "internalcall " },
+       { METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED,    "synchronized " },
+       { METHOD_IMPL_ATTRIBUTE_NOINLINING,      "noinlining " },
+       { METHOD_IMPL_ATTRIBUTE_NOOPTIMIZATION,  "nooptimization " },
+       { METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING,  "agressive-inlining" },
+       { 0, NULL }
+};
+
+char *
+get_method_impl_flags (guint32 f)
+{
+       GString *str = g_string_new ("");
+       char *s;
+       int code_type = f & METHOD_IMPL_ATTRIBUTE_CODE_TYPE_MASK;
+       int managed_type = f & METHOD_IMPL_ATTRIBUTE_MANAGED_MASK;
+       int rest = f & ~(code_type | managed_type);
+
+       g_string_append (str, map (code_type, method_impl_map));
+       g_string_append (str, map (managed_type, managed_type_map));
+       g_string_append (str, flags (rest, managed_impl_flags));
+       
+       s = str->str;
+       g_string_free (str, FALSE);
+       return s;
+}
+
my mono mirror. check out Moved to http://github.com/mono/mono