X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fdis%2Fmain.c;h=fc5fdba07b045087dfd88a8c92e40685495de5ed;hb=a928b55352b4ae06d8d9ac1f86c4db0ee1b7a212;hp=d5d441c047f02d17169eefad2719e763546e8484;hpb=53e266903ec6b2d822cf5b0c566f6374df5307a4;p=mono.git diff --git a/mono/dis/main.c b/mono/dis/main.c index d5d441c047f..fc5fdba07b0 100644 --- a/mono/dis/main.c +++ b/mono/dis/main.c @@ -440,7 +440,7 @@ typedef_flags (guint32 flags) * This routine displays all the decoded fields from @start to @end */ static void -dis_field_list (MonoImage *m, guint32 start, guint32 end, MonoGenericContext *context) +dis_field_list (MonoImage *m, guint32 start, guint32 end, MonoGenericContainer *container) { MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD]; guint32 cols [MONO_FIELD_SIZE]; @@ -462,7 +462,7 @@ dis_field_list (MonoImage *m, guint32 start, guint32 end, MonoGenericContext *co if (!should_include_field (i + 1)) continue; mono_metadata_decode_row (t, i, cols, MONO_FIELD_SIZE); - sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE], context); + sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE], container); flags = field_flags (cols [MONO_FIELD_FLAGS]); if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL) { @@ -699,7 +699,7 @@ dis_locals (MonoImage *m, MonoMethodHeader *mh, const char *ptr) } static void -dis_code (MonoImage *m, guint32 token, guint32 rva, MonoGenericContext *context) +dis_code (MonoImage *m, guint32 token, guint32 rva, MonoGenericContainer *container) { MonoMethodHeader *mh; const char *ptr = mono_image_rva_map (m, rva); @@ -710,31 +710,32 @@ dis_code (MonoImage *m, guint32 token, guint32 rva, MonoGenericContext *context) if (rva == 0) return; - override = get_method_override (m, token, context); + override = get_method_override (m, token, container); if (override) { fprintf (output, "\t.override %s\n", override); g_free (override); } - mh = mono_metadata_parse_mh_full (m, context ? context->container : NULL, ptr); - if ((entry_point = mono_image_get_entry_point (m))){ + mh = mono_metadata_parse_mh_full (m, container, ptr); + if ((entry_point = mono_image_get_entry_point (m)) && mono_metadata_token_index (entry_point)){ loc = mono_metadata_locate_token (m, entry_point); if (rva == read32 (loc)) fprintf (output, "\t.entrypoint\n"); } - fprintf (output, "\t// Code size %d (0x%x)\n", mh->code_size, mh->code_size); - fprintf (output, "\t.maxstack %d\n", mh->max_stack); - if (mh->num_locals) - dis_locals (m, mh, ptr); - disassemble_cil (m, mh, context); - + if (mh) { + fprintf (output, "\t// Code size %d (0x%x)\n", mh->code_size, mh->code_size); + fprintf (output, "\t.maxstack %d\n", mh->max_stack); + if (mh->num_locals) + dis_locals (m, mh, ptr); + disassemble_cil (m, mh, container); /* hex_dump (mh->code, 0, mh->code_size); printf ("\nAfter the code\n"); hex_dump (mh->code + mh->code_size, 0, 64); */ - mono_metadata_free_mh (mh); + mono_metadata_free_mh (mh); + } } static char * @@ -857,7 +858,7 @@ dump_cattrs_for_method_params (MonoImage *m, guint32 midx, MonoMethodSignature * * This routine displays the methods in the Method Table from @start to @end */ static void -dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 end, MonoGenericContext *context) +dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 end, MonoGenericContainer *type_container) { MonoTableInfo *t = &m->tables [MONO_TABLE_METHOD]; guint32 cols [MONO_METHOD_SIZE]; @@ -872,7 +873,6 @@ dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 en for (i = start; i < end; i++){ MonoMethodSignature *ms; MonoGenericContainer *container; - MonoGenericContext *method_context = context; char *flags, *impl_flags; const char *sig, *method_name; char *sig_str; @@ -888,16 +888,14 @@ dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 en sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]); mono_metadata_decode_blob_size (sig, &sig); - container = mono_metadata_load_generic_params ( - m, MONO_TOKEN_METHOD_DEF | (i + 1), context ? context->container : NULL); - if (container) { - mono_metadata_load_generic_param_constraints ( - m, MONO_TOKEN_METHOD_DEF | (i + 1), container); - method_context = (MonoGenericContext *) container; - } + container = mono_metadata_load_generic_params (m, MONO_TOKEN_METHOD_DEF | (i + 1), type_container); + if (container) + mono_metadata_load_generic_param_constraints (m, MONO_TOKEN_METHOD_DEF | (i + 1), container); + else + container = type_container; - ms = mono_metadata_parse_method_signature_full (m, method_context ? method_context->container : NULL, i + 1, sig, &sig); - sig_str = dis_stringify_method_signature (m, ms, i + 1, method_context, FALSE); + ms = mono_metadata_parse_method_signature_full (m, container, i + 1, sig, &sig); + sig_str = dis_stringify_method_signature (m, ms, i + 1, container, FALSE); method_name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]); fprintf (output, " // method line %d\n", i + 1); @@ -928,7 +926,7 @@ dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 en if (cols [MONO_METHOD_IMPLFLAGS] & METHOD_IMPL_ATTRIBUTE_NATIVE) fprintf (output, " // Disassembly of native methods is not supported\n"); else - dis_code (m, token, cols [MONO_METHOD_RVA], method_context); + dis_code (m, token, cols [MONO_METHOD_RVA], container); if (klass_name) fprintf (output, " } // end of method %s::%s\n\n", klass_name, method_name); else @@ -966,7 +964,7 @@ table_locator (const void *a, const void *b) } static void -dis_property_methods (MonoImage *m, guint32 prop, MonoGenericContext *context) +dis_property_methods (MonoImage *m, guint32 prop, MonoGenericContainer *container) { guint start, end; MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS]; @@ -979,13 +977,13 @@ dis_property_methods (MonoImage *m, guint32 prop, MonoGenericContext *context) mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE); if (!should_include_method (cols [MONO_METHOD_SEMA_METHOD])) continue; - sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], context, TRUE, FALSE); + sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], container, TRUE, FALSE); fprintf (output, "\t\t%s %s\n", type [cols [MONO_METHOD_SEMA_SEMANTICS]], sig); g_free (sig); } } static char* -dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContext *context) +dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *container) { MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY]; const char *ptr; @@ -1009,7 +1007,7 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContext *cont g_string_append (res, "instance "); ptr++; pcount = mono_metadata_decode_value (ptr, &ptr); - type = mono_metadata_parse_type_full (m, context ? context->container : NULL, MONO_PARSE_TYPE, 0, ptr, &ptr); + type = mono_metadata_parse_type_full (m, container, MONO_PARSE_TYPE, 0, ptr, &ptr); blurb = dis_stringify_type (m, type, TRUE); if (prop_flags & 0x0200) g_string_append (res, "specialname "); @@ -1019,14 +1017,12 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContext *cont g_string_sprintfa (res, "%s %s (", blurb, qk); g_free (qk); g_free (blurb); - mono_metadata_free_type (type); for (i = 0; i < pcount; i++) { if (i) g_string_append (res, ", "); - param = mono_metadata_parse_type_full (m, context ? context->container : NULL, MONO_PARSE_PARAM, 0, ptr, &ptr); + param = mono_metadata_parse_type_full (m, container, MONO_PARSE_PARAM, 0, ptr, &ptr); blurb = dis_stringify_param (m, param); g_string_append (res, blurb); - mono_metadata_free_type (param); g_free (blurb); } g_string_append_c (res, ')'); @@ -1037,23 +1033,23 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContext *cont } static void -dis_property_list (MonoImage *m, guint32 typedef_row, MonoGenericContext *context) +dis_property_list (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container) { guint start, end, i; start = mono_metadata_properties_from_typedef (m, typedef_row, &end); for (i = start; i < end; ++i) { - char *sig = dis_property_signature (m, i, context); + char *sig = dis_property_signature (m, i, container); fprintf (output, "\t.property %s\n\t{\n", sig); dump_cattrs (m, MONO_TOKEN_PROPERTY | (i + 1), "\t\t"); - dis_property_methods (m, i, context); + dis_property_methods (m, i, container); fprintf (output, "\t}\n"); g_free (sig); } } static char* -dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContext *context) +dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContainer *container) { MonoTableInfo *et = &m->tables [MONO_TABLE_EVENT]; char *type, *result, *esname; @@ -1063,7 +1059,7 @@ dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContext *contex mono_metadata_decode_row (et, event_idx, cols, MONO_EVENT_SIZE); esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_EVENT_NAME])); - type = get_typedef_or_ref (m, cols [MONO_EVENT_TYPE], context); + type = get_typedef_or_ref (m, cols [MONO_EVENT_TYPE], container); event_flags = cols [MONO_EVENT_FLAGS]; if (event_flags & 0x0200) @@ -1080,7 +1076,7 @@ dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContext *contex } static void -dis_event_methods (MonoImage *m, guint32 event, MonoGenericContext *context) +dis_event_methods (MonoImage *m, guint32 event, MonoGenericContainer *container) { guint start, end; MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS]; @@ -1093,7 +1089,7 @@ dis_event_methods (MonoImage *m, guint32 event, MonoGenericContext *context) mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE); if (!should_include_method (cols [MONO_METHOD_SEMA_METHOD])) continue; - sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], context, TRUE, FALSE); + sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], container, TRUE, FALSE); switch (cols [MONO_METHOD_SEMA_SEMANTICS]) { case METHOD_SEMANTIC_OTHER: type = ".other"; break; @@ -1112,23 +1108,23 @@ dis_event_methods (MonoImage *m, guint32 event, MonoGenericContext *context) } static void -dis_event_list (MonoImage *m, guint32 typedef_row, MonoGenericContext *context) +dis_event_list (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container) { guint start, end, i; start = mono_metadata_events_from_typedef (m, typedef_row, &end); for (i = start; i < end; ++i) { - char *sig = dis_event_signature (m, i, context); + char *sig = dis_event_signature (m, i, container); fprintf (output, "\t.event %s\n\t{\n", sig); dump_cattrs (m, MONO_TOKEN_EVENT | (i + 1), "\t\t"); - dis_event_methods (m, i, context); + dis_event_methods (m, i, container); fprintf (output, "\t}\n"); g_free (sig); } } static void -dis_interfaces (MonoImage *m, guint32 typedef_row, MonoGenericContext *context) +dis_interfaces (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container) { plocator_t loc; guint start; @@ -1161,7 +1157,7 @@ dis_interfaces (MonoImage *m, guint32 typedef_row, MonoGenericContext *context) mono_metadata_decode_row (table, start, cols, MONO_INTERFACEIMPL_SIZE); if (cols [MONO_INTERFACEIMPL_CLASS] != loc.idx) break; - intf = get_typedef_or_ref (m, cols [MONO_INTERFACEIMPL_INTERFACE], context); + intf = get_typedef_or_ref (m, cols [MONO_INTERFACEIMPL_INTERFACE], container); if (first_interface) { fprintf (output, " \timplements %s", intf); first_interface = 0; @@ -1225,8 +1221,7 @@ dis_type (MonoImage *m, int n, int is_nested, int forward) } fprintf (output, "\n"); if (cols [MONO_TYPEDEF_EXTENDS]) { - char *base = get_typedef_or_ref ( - m, cols [MONO_TYPEDEF_EXTENDS], (MonoGenericContext *) container); + char *base = get_typedef_or_ref (m, cols [MONO_TYPEDEF_EXTENDS], container); fprintf (output, " \textends %s\n", base); g_free (base); } @@ -1242,7 +1237,7 @@ dis_type (MonoImage *m, int n, int is_nested, int forward) } g_free (esname); - dis_interfaces (m, n + 1, (MonoGenericContext *) container); + dis_interfaces (m, n + 1, container); fprintf (output, " {\n"); if (!forward) { dump_cattrs (m, MONO_TOKEN_TYPE_DEF | (n + 1), " "); @@ -1264,7 +1259,7 @@ dis_type (MonoImage *m, int n, int is_nested, int forward) last = m->tables [MONO_TABLE_FIELD].rows; if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= m->tables [MONO_TABLE_FIELD].rows) - dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last, (MonoGenericContext *) container); + dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last, container); fprintf (output, "\n"); if (next_is_valid) @@ -1273,10 +1268,10 @@ dis_type (MonoImage *m, int n, int is_nested, int forward) last = m->tables [MONO_TABLE_METHOD].rows; if (cols [MONO_TYPEDEF_METHOD_LIST] && cols [MONO_TYPEDEF_METHOD_LIST] <= m->tables [MONO_TABLE_METHOD].rows) - dis_method_list (name, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last, (MonoGenericContext *) container); + dis_method_list (name, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last, container); - dis_property_list (m, n, (MonoGenericContext *) container); - dis_event_list (m, n, (MonoGenericContext *) container); + dis_property_list (m, n, container); + dis_event_list (m, n, container); } t = &m->tables [MONO_TABLE_NESTEDCLASS]; @@ -1392,6 +1387,24 @@ dis_types (MonoImage *m, int forward) } } +static const char * +get_uninitialized_data_type (guint32 size) +{ + switch (size) { + case 1: + return "int8"; + case 2: + return "int16"; + case 4: + return "int32"; + case 8: + return "int64"; + default: + g_error ("get_uninitialized_data_type for size: %d\n", size); + } + return NULL; +} + /** * dis_data: * @m: metadata context @@ -1420,13 +1433,18 @@ dis_data (MonoImage *m) type = mono_metadata_parse_field_type (m, 0, sig + 1, &sig); mono_class_init (mono_class_from_mono_type (type)); size = mono_type_size (type, &align); - fprintf (output, ".data D_%08x = bytearray (", cols [MONO_FIELD_RVA_RVA]); - for (b = 0; b < size; ++b) { - if (!(b % 16)) - fprintf (output, "\n\t"); - fprintf (output, " %02X", rva [b] & 0xff); - } - fprintf (output, ") // size: %d\n", size); + + if (rva) { + fprintf (output, ".data D_%08x = bytearray (", cols [MONO_FIELD_RVA_RVA]); + for (b = 0; b < size; ++b) { + if (!(b % 16)) + fprintf (output, "\n\t"); + fprintf (output, " %02X", rva [b] & 0xff); + } + fprintf (output, ") // size: %d\n", size); + } else + fprintf (output, ".data D_%08x = %s [%d]\n", + cols [MONO_FIELD_RVA_RVA], get_uninitialized_data_type (size), size); } } @@ -1472,7 +1490,9 @@ struct { { "--paramptr", MONO_TABLE_PARAM_POINTER, dump_table_paramptr }, { "--eventptr", MONO_TABLE_EVENT_POINTER, dump_table_eventptr }, { "--propertyptr", MONO_TABLE_PROPERTY_POINTER, dump_table_propertyptr }, - { "--blob", 0, dump_stream_blob }, + { "--blob", 0, dump_stream_blob }, + { "--strings", 0, dump_stream_strings }, + { "--userstrings", 0, dump_stream_us }, { NULL, -1, } }; @@ -1485,18 +1505,19 @@ struct { static void disassemble_file (const char *file) { - MonoAssembly *ass; MonoImageOpenStatus status; MonoImage *img; + MonoAssembly *assembly; + - ass = mono_assembly_open (file, &status); - if (ass == NULL){ + img = mono_image_open (file, &status); + if (!img) { fprintf (stderr, "Error while trying to process %s\n", file); return; + } else { + assembly = mono_assembly_load_from_full (img, file, &status, FALSE); } - img = ass->image; - setup_filter (img); if (dump_table != -1){