#include "util.h"
#include "dump.h"
#include "get.h"
+#include "declsec.h"
#include "mono/metadata/loader.h"
#include "mono/metadata/class.h"
#include "mono/metadata/class-internals.h"
cols [MONO_ASSEMBLYREF_BUILD_NUMBER],
cols [MONO_ASSEMBLYREF_REV_NUMBER],
mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]));
+ fprintf (output, "\tFlags=0x%08x\n", cols [MONO_ASSEMBLYREF_FLAGS]);
ptr = mono_metadata_blob_heap (m, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
len = mono_metadata_decode_value (ptr, &ptr);
if (len > 0){
if (*blob == 0x6) { /* it's a field */
sig = get_field_signature (m, cols [MONO_MEMBERREF_SIGNATURE], NULL);
} else {
- sig = get_methodref_signature (m, cols [MONO_MEMBERREF_SIGNATURE], NULL, NULL);
+ sig = get_methodref_signature (m, cols [MONO_MEMBERREF_SIGNATURE], NULL);
}
fprintf (output, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n",
i + 1,
g_warning("incorrect signature in propert blob: 0x%x", *ptr);
ptr++;
pcount = mono_metadata_decode_value (ptr, &ptr);
- ptr = get_type (m, ptr, &type, NULL);
+ ptr = get_type (m, ptr, &type, FALSE, NULL);
fprintf (output, "%d: %s %s (",
i + 1, type, mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME]));
g_free (type);
mono_metadata_string_heap (m, mono_metadata_decode_row_col (td, current_type - 2, MONO_TYPEDEF_NAME)));
first_m = last_m;
type_container = mono_metadata_load_generic_params (m, MONO_TOKEN_TYPE_DEF | (current_type - 1), NULL);
+ if (type_container)
+ mono_metadata_load_generic_param_constraints (m, MONO_TOKEN_TYPE_DEF | (current_type - 1), type_container);
}
method_container = mono_metadata_load_generic_params (m, MONO_TOKEN_METHOD_DEF | i, type_container);
- mono_metadata_decode_row (t, i - 1, cols, MONO_METHOD_SIZE);
+ if (method_container)
+ mono_metadata_load_generic_param_constraints (m, MONO_TOKEN_METHOD_DEF | i, method_container);
+ mono_metadata_decode_table_row (m, MONO_TABLE_METHOD, i - 1, cols, MONO_METHOD_SIZE);
sigblob = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
mono_metadata_decode_blob_size (sigblob, &sigblob);
method = mono_metadata_parse_method_signature_full (m, method_container ? method_container : type_container, i, sigblob, &sigblob);
- sig = dis_stringify_method_signature (m, method, i, (MonoGenericContext *) (method_container ? method_container : type_container), FALSE);
+ sig = dis_stringify_method_signature (m, method, i, method_container ? method_container : type_container, FALSE);
fprintf (output, "%d: %s (param: %d)\n", i, sig, cols [MONO_METHOD_PARAMLIST]);
g_free (sig);
mono_metadata_free_method_signature (method);
case MONO_CUSTOM_ATTR_MANIFEST:
table = "Manifest";
break;
+ case MONO_CUSTOM_ATTR_GENERICPAR:
+ table = "GenericParam";
+ break;
default:
table = "Unknown";
break;
fprintf (output, "%d: %s on %s %d%s", i, action, parent [idx & MONO_HAS_DECL_SECURITY_MASK], idx >> MONO_HAS_DECL_SECURITY_BITS, len? ":\n\t":"\n");
if (!len)
continue;
- for (idx = 0; idx < len; ++idx)
- fprintf (output, "%c", blob [idx]);
+ if (blob [0] == MONO_DECLSEC_FORMAT_20) {
+ /* 2.0 declarative security format */
+ char *declsec = dump_declsec_entry20 (m, blob, "\t");
+ fprintf (output, "%s", declsec);
+ g_free (declsec);
+ } else {
+ /* 1.0 declarative security format - Unicode XML */
+ for (idx = 0; idx < len; ++idx)
+ fprintf (output, "%c", blob [idx]);
+ }
fprintf (output, "\n");
}
}
fprintf (output, "\n");
}
+void
+dump_stream_strings (MonoImage *m)
+{
+ guint32 i;
+
+ fprintf (output, "Strings heap contents\n");
+
+ for (i = 0; i < m->heap_strings.size; ) {
+ const char *str = mono_metadata_string_heap (m, i);
+ fprintf (output, "%02x: \"%s\"\n", i, str);
+ i += strlen (str) + 1;
+ }
+}
+
+void
+dump_stream_us (MonoImage *m)
+{
+ guint32 i;
+
+ fprintf (output, "User Strings heap contents\n");
+
+ for (i = 0; i < m->heap_us.size; ) {
+ const char *us_ptr = mono_metadata_user_string (m, i);
+ int len = mono_metadata_decode_blob_size (us_ptr, (const char**)&us_ptr);
+
+ char *str = get_encoded_user_string_or_bytearray ((const guchar*)us_ptr, len);
+ fprintf (output, "%02x: %s\n", i, str);
+ g_free (str);
+ i += len + 1;
+ }
+}
+
void
dump_table_standalonesig (MonoImage *m)
{
fprintf (output, "\n");
}
}
+
+static void
+dump_table_ptr (MonoImage *m, int table, const char *name)
+{
+ MonoTableInfo *t = &m->tables [table];
+ guint32 cols [1];
+ int i;
+
+ fprintf (output, "%s (1..%d)\n", name, t->rows);
+
+ for (i = 1; i <= t->rows; i++) {
+ mono_metadata_decode_row (t, i - 1, cols, 1);
+
+ fprintf (output, "%d: %d\n", i, cols [0]);
+ }
+}
+
+void
+dump_table_methodptr (MonoImage *m)
+{
+ dump_table_ptr (m, MONO_TABLE_METHOD_POINTER, "Method Ptr");
+}
+
+void
+dump_table_fieldptr (MonoImage *m)
+{
+ dump_table_ptr (m, MONO_TABLE_FIELD_POINTER, "Field Ptr");
+}
+
+void
+dump_table_paramptr (MonoImage *m)
+{
+ dump_table_ptr (m, MONO_TABLE_PARAM_POINTER, "Param Ptr");
+}
+
+void
+dump_table_eventptr (MonoImage *m)
+{
+ dump_table_ptr (m, MONO_TABLE_EVENT_POINTER, "Event Ptr");
+}
+
+void
+dump_table_propertyptr (MonoImage *m)
+{
+ dump_table_ptr (m, MONO_TABLE_PROPERTY_POINTER, "Property Ptr");
+}