2 * main.c: Sample disassembler
5 * Miguel de Icaza (miguel@ximian.com)
7 * (C) 2001 Ximian, Inc.
10 * Investigate how interface inheritance works and how it should be dumped.
11 * Structs are not being labeled as `valuetype' classes
13 * How are fields with literals mapped to constants?
26 #include <mono/metadata/loader.h>
27 #include <mono/metadata/assembly.h>
28 #include <mono/metadata/appdomain.h>
32 /* True if you want to get a dump of the header data */
33 gboolean dump_header_data_p = FALSE;
35 gboolean substitute_with_mscorlib_p = FALSE;
40 dump_header_data (MonoImage *img)
42 if (!dump_header_data_p)
46 "// Ximian's CIL disassembler, version 1.0\n"
47 "// Copyright (C) 2001 Ximian, Inc.\n\n");
51 dump_cattrs (MonoImage *m, guint32 token, const char *indent)
55 list = dis_get_custom_attrs (m, token);
56 for (tmp = list; tmp; tmp = tmp->next) {
57 fprintf (output, "%s%s\n", indent, (char*)tmp->data);
64 dis_directive_assembly (MonoImage *m)
66 MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLY];
67 guint32 cols [MONO_ASSEMBLY_SIZE];
72 mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
74 fprintf (output, ".assembly '%s'\n{\n",
75 mono_metadata_string_heap (m, cols [MONO_ASSEMBLY_NAME]));
76 dump_cattrs (m, MONO_TOKEN_ASSEMBLY | 1, " ");
78 " .hash algorithm 0x%08x\n"
79 " .ver %d:%d:%d:%d\n",
80 cols [MONO_ASSEMBLY_HASH_ALG],
81 cols [MONO_ASSEMBLY_MAJOR_VERSION], cols [MONO_ASSEMBLY_MINOR_VERSION],
82 cols [MONO_ASSEMBLY_BUILD_NUMBER], cols [MONO_ASSEMBLY_REV_NUMBER]);
83 if (cols [MONO_ASSEMBLY_CULTURE])
84 fprintf (output, " .locale %s\n", mono_metadata_string_heap (m, cols [MONO_ASSEMBLY_CULTURE]));
85 if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
86 const char* b = mono_metadata_blob_heap (m, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
87 int len = mono_metadata_decode_blob_size (b, &b);
88 char *dump = data_dump (b, len, "\t\t");
89 fprintf (output, " .publickey =%s", dump);
92 fprintf (output, "}\n");
96 dis_directive_assemblyref (MonoImage *m)
98 MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLYREF];
99 guint32 cols [MONO_ASSEMBLYREF_SIZE];
105 for (i = 0; i < t->rows; i++){
106 mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
109 ".assembly extern %s\n"
111 " .ver %d:%d:%d:%d\n"
113 mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]),
114 cols [MONO_ASSEMBLYREF_MAJOR_VERSION], cols [MONO_ASSEMBLYREF_MINOR_VERSION],
115 cols [MONO_ASSEMBLYREF_BUILD_NUMBER], cols [MONO_ASSEMBLYREF_REV_NUMBER]
121 dis_directive_module (MonoImage *m)
123 MonoTableInfo *t = &m->tables [MONO_TABLE_MODULE];
126 for (i = 0; i < t->rows; i++){
127 guint32 cols [MONO_MODULE_SIZE];
131 mono_metadata_decode_row (t, i, cols, MONO_MODULE_SIZE);
133 name = mono_metadata_string_heap (m, cols [MONO_MODULE_NAME]);
134 ename = get_escaped_name (name);
135 guid = get_guid (m, cols [MONO_MODULE_MVID]);
136 fprintf (output, ".module %s // GUID = %s\n\n", ename, guid);
139 dump_cattrs (m, MONO_TOKEN_MODULE | (i + 1), "");
144 dis_directive_moduleref (MonoImage *m)
146 MonoTableInfo *t = &m->tables [MONO_TABLE_MODULEREF];
149 for (i = 0; i < t->rows; i++){
150 guint32 cols [MONO_MODULEREF_SIZE];
153 mono_metadata_decode_row (t, i, cols, MONO_MODULEREF_SIZE);
155 name = mono_metadata_string_heap (m, cols [MONO_MODULEREF_NAME]);
156 fprintf (output, ".module extern %s\n", name);
162 dis_directive_file (MonoImage *m)
164 MonoTableInfo *t = &m->tables [MONO_TABLE_FILE];
168 entry_point = mono_image_get_entry_point (m);
170 for (i = 0; i < t->rows; i++){
171 guint32 cols [MONO_FILE_SIZE];
172 const char *name, *hash;
175 mono_metadata_decode_row (t, i, cols, MONO_FILE_SIZE);
177 name = mono_metadata_string_heap (m, cols [MONO_FILE_NAME]);
179 hash = mono_metadata_blob_heap (m, cols [MONO_FILE_HASH_VALUE]);
180 len = mono_metadata_decode_blob_size (hash, &hash);
182 fprintf (output, ".file %s%s .hash = (", name,
183 cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA ? " nometadata" : "");
185 for (j = 0; j < len; ++j)
186 fprintf (output, " %02X", hash [j] & 0xff);
188 token = mono_metadata_make_token (MONO_TABLE_FILE, i + 1);
189 fprintf (output, " )%s\n", (token == entry_point) ? " .entrypoint" : "");
194 static dis_map_t visibility_map [] = {
195 { TYPE_ATTRIBUTE_NOT_PUBLIC, "private " },
196 { TYPE_ATTRIBUTE_PUBLIC, "public " },
197 { TYPE_ATTRIBUTE_NESTED_PUBLIC, "nested public " },
198 { TYPE_ATTRIBUTE_NESTED_PRIVATE, "nested private " },
199 { TYPE_ATTRIBUTE_NESTED_FAMILY, "nested family " },
200 { TYPE_ATTRIBUTE_NESTED_ASSEMBLY, "nested assembly " },
201 { TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM, "nested famandassem " },
202 { TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM, "nested famorassem " },
206 static dis_map_t layout_map [] = {
207 { TYPE_ATTRIBUTE_AUTO_LAYOUT, "auto " },
208 { TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT, "sequential " },
209 { TYPE_ATTRIBUTE_EXPLICIT_LAYOUT, "explicit " },
213 static dis_map_t format_map [] = {
214 { TYPE_ATTRIBUTE_ANSI_CLASS, "ansi " },
215 { TYPE_ATTRIBUTE_UNICODE_CLASS, "unicode " },
216 { TYPE_ATTRIBUTE_AUTO_CLASS, "auto " },
221 typedef_flags (guint32 flags)
223 static char buffer [1024];
224 int visibility = flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
225 int layout = flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
226 int format = flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK;
230 strcat (buffer, map (visibility, visibility_map));
231 strcat (buffer, map (layout, layout_map));
232 strcat (buffer, map (format, format_map));
234 if (flags & TYPE_ATTRIBUTE_ABSTRACT)
235 strcat (buffer, "abstract ");
236 if (flags & TYPE_ATTRIBUTE_SEALED)
237 strcat (buffer, "sealed ");
238 if (flags & TYPE_ATTRIBUTE_SPECIAL_NAME)
239 strcat (buffer, "special-name ");
240 if (flags & TYPE_ATTRIBUTE_IMPORT)
241 strcat (buffer, "import ");
242 if (flags & TYPE_ATTRIBUTE_SERIALIZABLE)
243 strcat (buffer, "serializable ");
244 if (flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)
245 strcat (buffer, "beforefieldinit ");
252 * @m: metadata context
253 * @start: starting index into the Field Table.
254 * @end: ending index into Field table.
256 * This routine displays all the decoded fields from @start to @end
259 dis_field_list (MonoImage *m, guint32 start, guint32 end)
261 MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
262 guint32 cols [MONO_FIELD_SIZE];
268 if (end > t->rows + 1) {
269 g_warning ("ERROR index out of range in fields");
273 for (i = start; i < end; i++){
274 char *sig, *flags, *attrs = NULL;
275 guint32 field_offset = -1;
277 mono_metadata_decode_row (t, i, cols, MONO_FIELD_SIZE);
278 sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE]);
279 flags = field_flags (cols [MONO_FIELD_FLAGS]);
281 if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
282 mono_metadata_field_info (m, i, NULL, &rva, NULL);
283 g_snprintf (rva_desc, sizeof (rva_desc), " at D_%08x", rva);
288 mono_metadata_field_info (m, i, &field_offset, NULL, NULL);
289 if (field_offset != -1)
290 attrs = g_strdup_printf ("[%d]", field_offset);
291 esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]));
292 if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_LITERAL){
294 guint32 const_cols [MONO_CONSTANT_SIZE];
297 if ((crow = mono_metadata_get_constant_index (m, MONO_TOKEN_FIELD_DEF | (i+1), 0))) {
298 mono_metadata_decode_row (&m->tables [MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
299 lit = get_constant (m, const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
301 lit = g_strdup ("not found");
305 fprintf (output, " .field %s %s %s = ",
307 fprintf (output, "%s\n", lit);
310 fprintf (output, " .field %s %s %s %s%s\n",
311 attrs? attrs: "", flags, sig, esname, rva_desc);
316 dump_cattrs (m, MONO_TOKEN_FIELD_DEF | (i + 1), " ");
320 static dis_map_t method_access_map [] = {
321 { METHOD_ATTRIBUTE_COMPILER_CONTROLLED, "compilercontrolled " },
322 { METHOD_ATTRIBUTE_PRIVATE, "private " },
323 { METHOD_ATTRIBUTE_FAM_AND_ASSEM, "famandassem " },
324 { METHOD_ATTRIBUTE_ASSEM, "assembly " },
325 { METHOD_ATTRIBUTE_FAMILY, "family " },
326 { METHOD_ATTRIBUTE_FAM_OR_ASSEM, "famorassem " },
327 { METHOD_ATTRIBUTE_PUBLIC, "public " },
331 static dis_map_t method_flags_map [] = {
332 { METHOD_ATTRIBUTE_STATIC, "static " },
333 { METHOD_ATTRIBUTE_FINAL, "final " },
334 { METHOD_ATTRIBUTE_VIRTUAL, "virtual " },
335 { METHOD_ATTRIBUTE_HIDE_BY_SIG, "hidebysig " },
336 { METHOD_ATTRIBUTE_VTABLE_LAYOUT_MASK, "newslot " },
337 { METHOD_ATTRIBUTE_ABSTRACT, "abstract " },
338 { METHOD_ATTRIBUTE_SPECIAL_NAME, "specialname " },
339 { METHOD_ATTRIBUTE_RT_SPECIAL_NAME, "rtspecialname " },
340 { METHOD_ATTRIBUTE_UNMANAGED_EXPORT, "export " },
341 { METHOD_ATTRIBUTE_HAS_SECURITY, "hassecurity" },
342 { METHOD_ATTRIBUTE_REQUIRE_SEC_OBJECT, "requiresecobj" },
343 { METHOD_ATTRIBUTE_PINVOKE_IMPL, "pinvokeimpl " },
350 * Returns a stringified version of the Method's flags
353 method_flags (guint32 f)
355 GString *str = g_string_new ("");
356 int access = f & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK;
359 g_string_append (str, map (access, method_access_map));
360 g_string_append (str, flags (f, method_flags_map));
363 g_string_free (str, FALSE);
368 static dis_map_t pinvoke_flags_map [] = {
369 { PINVOKE_ATTRIBUTE_NO_MANGLE , "nomangle " },
370 { PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR, "lasterr " },
374 static dis_map_t pinvoke_call_conv_map [] = {
375 { PINVOKE_ATTRIBUTE_CALL_CONV_WINAPI, "winapi " },
376 { PINVOKE_ATTRIBUTE_CALL_CONV_CDECL, "cdecl " },
377 { PINVOKE_ATTRIBUTE_CALL_CONV_STDCALL, "stdcall " },
378 { PINVOKE_ATTRIBUTE_CALL_CONV_THISCALL, "thiscall " },
379 { PINVOKE_ATTRIBUTE_CALL_CONV_FASTCALL, "fastcall " },
383 static dis_map_t pinvoke_char_set_map [] = {
384 { PINVOKE_ATTRIBUTE_CHAR_SET_NOT_SPEC, "" },
385 { PINVOKE_ATTRIBUTE_CHAR_SET_ANSI, "ansi " },
386 { PINVOKE_ATTRIBUTE_CHAR_SET_UNICODE , "unicode " },
387 { PINVOKE_ATTRIBUTE_CHAR_SET_AUTO, "autochar " },
394 * Returns a stringified version of the Method's pinvoke flags
397 pinvoke_flags (guint32 f)
399 GString *str = g_string_new ("");
400 int cset = f & PINVOKE_ATTRIBUTE_CHAR_SET_MASK;
401 int cconv = f & PINVOKE_ATTRIBUTE_CALL_CONV_MASK;
404 g_string_append (str, map (cset, pinvoke_char_set_map));
405 g_string_append (str, map (cconv, pinvoke_call_conv_map));
406 g_string_append (str, flags (f, pinvoke_flags_map));
408 s = g_strdup(str->str);
409 g_string_free (str, FALSE);
414 static dis_map_t method_impl_map [] = {
415 { METHOD_IMPL_ATTRIBUTE_IL, "cil " },
416 { METHOD_IMPL_ATTRIBUTE_NATIVE, "native " },
417 { METHOD_IMPL_ATTRIBUTE_OPTIL, "optil " },
418 { METHOD_IMPL_ATTRIBUTE_RUNTIME, "runtime " },
422 static dis_map_t managed_type_map [] = {
423 { METHOD_IMPL_ATTRIBUTE_UNMANAGED, "unmanaged " },
424 { METHOD_IMPL_ATTRIBUTE_MANAGED, "managed " },
428 static dis_map_t managed_impl_flags [] = {
429 { METHOD_IMPL_ATTRIBUTE_FORWARD_REF, "fwdref " },
430 { METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG, "preservesig " },
431 { METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL, "internalcall " },
432 { METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED, "synchronized " },
433 { METHOD_IMPL_ATTRIBUTE_NOINLINING, "noinline " },
438 method_impl_flags (guint32 f)
440 GString *str = g_string_new ("");
442 int code_type = f & METHOD_IMPL_ATTRIBUTE_CODE_TYPE_MASK;
443 int managed_type = f & METHOD_IMPL_ATTRIBUTE_MANAGED_MASK;
445 g_string_append (str, map (code_type, method_impl_map));
446 g_string_append (str, map (managed_type, managed_type_map));
447 g_string_append (str, flags (f, managed_impl_flags));
450 g_string_free (str, FALSE);
455 dis_locals (MonoImage *m, MonoMethodHeader *mh, const char *ptr)
460 unsigned char flags = *(const unsigned char *) ptr;
461 unsigned char format = flags & METHOD_HEADER_FORMAT_MASK;
463 guint32 local_var_sig_tok, max_stack, code_size, init_locals;
466 g_assert (format == METHOD_HEADER_FAT_FORMAT);
467 fat_flags = read16 (ptr);
469 hsize = (fat_flags >> 12) & 0xf;
470 max_stack = read16 (ptr);
472 code_size = read32 (ptr);
474 local_var_sig_tok = read32 (ptr);
477 if (fat_flags & METHOD_HEADER_INIT_LOCALS)
482 fprintf(output, "\t.locals /*%08x*/ %s(\n",
483 local_var_sig_tok, init_locals ? "init " : "");
485 fprintf(output, "\t.locals %s(\n", mh->init_locals ? "init " : "");
487 for (i=0; i < mh->num_locals; ++i) {
490 fprintf(output, ",\n");
491 /* print also byref and pinned attributes */
492 desc = dis_stringify_type (m, mh->locals[i]);
493 fprintf(output, "\t\t%s\tV_%d", desc, i);
496 fprintf(output, ")\n");
500 dis_code (MonoImage *m, guint32 rva)
502 MonoMethodHeader *mh;
503 const char *ptr = mono_image_rva_map (m, rva);
510 mh = mono_metadata_parse_mh (m, ptr);
511 if ((entry_point = mono_image_get_entry_point (m))){
512 loc = mono_metadata_locate_token (m, entry_point);
513 if (rva == read32 (loc))
514 fprintf (output, "\t.entrypoint\n");
517 fprintf (output, "\t// Code size %d (0x%x)\n", mh->code_size, mh->code_size);
518 fprintf (output, "\t.maxstack %d\n", mh->max_stack);
520 dis_locals (m, mh, ptr);
521 dissasemble_cil (m, mh);
524 hex_dump (mh->code, 0, mh->code_size);
525 printf ("\nAfter the code\n");
526 hex_dump (mh->code + mh->code_size, 0, 64);
528 mono_metadata_free_mh (mh);
532 pinvoke_info (MonoImage *m, guint32 mindex)
534 MonoTableInfo *im = &m->tables [MONO_TABLE_IMPLMAP];
535 MonoTableInfo *mr = &m->tables [MONO_TABLE_MODULEREF];
536 guint32 im_cols [MONO_IMPLMAP_SIZE];
537 guint32 mr_cols [MONO_MODULEREF_SIZE];
538 const char *import, *scope;
542 for (i = 0; i < im->rows; i++) {
544 mono_metadata_decode_row (im, i, im_cols, MONO_IMPLMAP_SIZE);
546 if ((im_cols [MONO_IMPLMAP_MEMBER] >> 1) == mindex + 1) {
548 flags = pinvoke_flags (im_cols [MONO_IMPLMAP_FLAGS]);
550 import = mono_metadata_string_heap (m, im_cols [MONO_IMPLMAP_NAME]);
552 mono_metadata_decode_row (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1,
553 mr_cols, MONO_MODULEREF_SIZE);
555 scope = mono_metadata_string_heap (m, mr_cols [MONO_MODULEREF_NAME]);
557 return g_strdup_printf ("(\"%s\" as \"%s\" %s)", scope, import,
567 cattrs_for_method (MonoImage *m, guint32 midx, MonoMethodSignature *sig) {
568 MonoTableInfo *methodt;
569 MonoTableInfo *paramt;
570 guint param_index, lastp, i, pid;
572 methodt = &m->tables [MONO_TABLE_METHOD];
573 paramt = &m->tables [MONO_TABLE_PARAM];
574 param_index = mono_metadata_decode_row_col (methodt, midx, MONO_METHOD_PARAMLIST);
575 if (midx + 1 < methodt->rows)
576 lastp = mono_metadata_decode_row_col (methodt, midx + 1, MONO_METHOD_PARAMLIST);
578 lastp = paramt->rows + 1;
579 for (i = param_index; i < lastp; ++i) {
580 pid = mono_metadata_decode_row_col (paramt, i - 1, MONO_PARAM_SEQUENCE);
581 fprintf (output, "\t.param [%d]\n", pid);
582 dump_cattrs (m, MONO_TOKEN_PARAM_DEF | i, "\t");
588 * @m: metadata context
589 * @start: starting index into the Method Table.
590 * @end: ending index into Method table.
592 * This routine displays the methods in the Method Table from @start to @end
595 dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 end)
597 MonoTableInfo *t = &m->tables [MONO_TABLE_METHOD];
598 guint32 cols [MONO_METHOD_SIZE];
602 fprintf (output, "ERROR index out of range in methods");
607 for (i = start; i < end; i++){
608 MonoMethodSignature *ms;
609 char *flags, *impl_flags;
613 mono_metadata_decode_row (t, i, cols, MONO_METHOD_SIZE);
615 flags = method_flags (cols [MONO_METHOD_FLAGS]);
616 impl_flags = method_impl_flags (cols [MONO_METHOD_IMPLFLAGS]);
618 sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
619 mono_metadata_decode_blob_size (sig, &sig);
620 ms = mono_metadata_parse_method_signature (m, i + 1, sig, &sig);
621 sig_str = dis_stringify_method_signature (m, ms, i + 1, FALSE);
623 fprintf (output, " // method line %d\n", i + 1);
624 fprintf (output, " .method %s", flags);
626 if ((cols [MONO_METHOD_FLAGS] & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (cols [MONO_METHOD_RVA] == 0)) {
627 gchar *pi = pinvoke_info (m, i);
629 fprintf (output, "%s", pi);
634 fprintf (output, "\n %s", sig_str);
635 fprintf (output, " %s\n", impl_flags);
639 fprintf (output, " {\n");
640 dump_cattrs (m, MONO_TOKEN_METHOD_DEF | (i + 1), " ");
641 cattrs_for_method (m, i, ms);
642 /* FIXME: need to sump also param custom attributes */
643 fprintf (output, " // Method begins at RVA 0x%x\n", cols [MONO_METHOD_RVA]);
644 if (cols [MONO_METHOD_IMPLFLAGS] & METHOD_IMPL_ATTRIBUTE_NATIVE)
645 fprintf (output, " // Disassembly of native methods is not supported\n");
647 dis_code (m, cols [MONO_METHOD_RVA]);
648 fprintf (output, " } // end of method %s::%s\n\n", klass_name, sig_str);
649 mono_metadata_free_method_signature (ms);
662 table_locator (const void *a, const void *b)
664 plocator_t *loc = (plocator_t *) a;
665 const char *bb = (const char *) b;
666 guint32 table_index = (bb - loc->t->base) / loc->t->row_size;
669 col = mono_metadata_decode_row_col (loc->t, table_index, loc->col_idx);
671 if (loc->idx == col) {
672 loc->result = table_index;
682 dis_property_methods (MonoImage *m, guint32 prop)
685 MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS];
686 guint32 cols [MONO_METHOD_SEMA_SIZE];
688 const char *type[] = {NULL, ".set", ".get", NULL, ".other"};
690 start = mono_metadata_methods_from_property (m, prop, &end);
691 while (start < end) {
692 mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE);
693 sig = dis_stringify_method_signature (m, NULL, cols [MONO_METHOD_SEMA_METHOD], TRUE);
694 fprintf (output, "\t\t%s %s\n", type [cols [MONO_METHOD_SEMA_SEMANTICS]], sig);
701 dis_property_signature (MonoImage *m, guint32 prop_idx)
703 MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY];
706 guint32 cols [MONO_PROPERTY_SIZE];
712 GString *res = g_string_new ("");
714 mono_metadata_decode_row (propt, prop_idx, cols, MONO_PROPERTY_SIZE);
715 name = mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME]);
716 prop_flags = cols [MONO_PROPERTY_FLAGS];
717 ptr = mono_metadata_blob_heap (m, cols [MONO_PROPERTY_TYPE]);
718 mono_metadata_decode_blob_size (ptr, &ptr);
719 /* ECMA claims 0x08 ... */
720 if (*ptr != 0x28 && *ptr != 0x08)
721 g_warning("incorrect signature in propert blob: 0x%x", *ptr);
723 pcount = mono_metadata_decode_value (ptr, &ptr);
724 type = mono_metadata_parse_type (m, MONO_PARSE_TYPE, 0, ptr, &ptr);
725 blurb = dis_stringify_type (m, type);
726 if (prop_flags & 0x0200)
727 g_string_append (res, "specialname ");
728 if (prop_flags & 0x0400)
729 g_string_append (res, "rtspecialname ");
730 g_string_sprintfa (res, "%s %s (", blurb, name);
732 mono_metadata_free_type (type);
733 for (i = 0; i < pcount; i++) {
735 g_string_append (res, ", ");
736 param = mono_metadata_parse_param (m, ptr, &ptr);
737 blurb = dis_stringify_param (m, param);
738 g_string_append (res, blurb);
739 mono_metadata_free_type (param);
742 g_string_append_c (res, ')');
744 g_string_free (res, FALSE);
750 dis_property_list (MonoImage *m, guint32 typedef_row)
753 start = mono_metadata_properties_from_typedef (m, typedef_row, &end);
755 for (i = start; i < end; ++i) {
756 char *sig = dis_property_signature (m, i);
757 fprintf (output, "\t.property %s\n\t{\n", sig);
758 dump_cattrs (m, MONO_TOKEN_PROPERTY | (i + 1), "\t\t");
759 dis_property_methods (m, i);
760 fprintf (output, "\t}\n");
766 dis_event_signature (MonoImage *m, guint32 event_idx)
768 MonoTableInfo *et = &m->tables [MONO_TABLE_EVENT];
769 char *type, *result, *esname;
770 guint32 cols [MONO_EVENT_SIZE];
772 GString *res = g_string_new ("");
774 mono_metadata_decode_row (et, event_idx, cols, MONO_EVENT_SIZE);
775 esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_EVENT_NAME]));
776 type = get_typedef_or_ref (m, cols [MONO_EVENT_TYPE]);
777 event_flags = cols [MONO_EVENT_FLAGS];
779 if (event_flags & 0x0200)
780 g_string_append (res, "specialname ");
781 if (event_flags & 0x0400)
782 g_string_append (res, "rtspecialname ");
783 g_string_sprintfa (res, "%s %s", type, esname);
788 g_string_free (res, FALSE);
793 dis_event_methods (MonoImage *m, guint32 event)
796 MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS];
797 guint32 cols [MONO_METHOD_SEMA_SIZE];
799 const char *type = "";
801 start = mono_metadata_methods_from_event (m, event, &end);
802 while (start < end) {
803 mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE);
804 sig = dis_stringify_method_signature (m, NULL, cols [MONO_METHOD_SEMA_METHOD], TRUE);
805 switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
806 case METHOD_SEMANTIC_OTHER:
807 type = ".other"; break;
808 case METHOD_SEMANTIC_ADD_ON:
809 type = ".addon"; break;
810 case METHOD_SEMANTIC_REMOVE_ON:
811 type = ".removeon"; break;
812 case METHOD_SEMANTIC_FIRE:
813 type = ".fire"; break;
817 fprintf (output, "\t\t%s %s\n", type, sig);
824 dis_event_list (MonoImage *m, guint32 typedef_row)
827 start = mono_metadata_events_from_typedef (m, typedef_row, &end);
829 for (i = start; i < end; ++i) {
830 char *sig = dis_event_signature (m, i);
831 fprintf (output, "\t.event %s\n\t{\n", sig);
832 dump_cattrs (m, MONO_TOKEN_EVENT | (i + 1), "\t\t");
833 dis_event_methods (m, i);
834 fprintf (output, "\t}\n");
840 dis_interfaces (MonoImage *m, guint32 typedef_row)
844 gboolean first_interface = 1;
845 guint32 cols [MONO_INTERFACEIMPL_SIZE];
847 MonoTableInfo *table = &m->tables [MONO_TABLE_INTERFACEIMPL];
853 loc.col_idx = MONO_INTERFACEIMPL_CLASS;
854 loc.idx = typedef_row;
856 if (!bsearch (&loc, table->base, table->rows, table->row_size, table_locator))
861 * We may end up in the middle of the rows...
864 if (loc.idx == mono_metadata_decode_row_col (table, start - 1, MONO_INTERFACEIMPL_CLASS))
869 while (start < table->rows) {
870 mono_metadata_decode_row (table, start, cols, MONO_INTERFACEIMPL_SIZE);
871 if (cols [MONO_INTERFACEIMPL_CLASS] != loc.idx)
873 intf = get_typedef_or_ref (m, cols [MONO_INTERFACEIMPL_INTERFACE]);
874 if (first_interface) {
875 fprintf (output, " \timplements %s", intf);
878 fprintf (output, ", %s", intf);
886 * dis_generic_param_and_constraints:
887 * @m: metadata context
888 * @table_type: Type of table (0 for typedef, 1 for methoddef)
891 * Dissasembles the generic parameters for this type or method, also
892 * returns an allocated GString containing the generic constraints NULL
893 * if their are no generic constraints.
896 dis_generic_param_and_constraints (MonoImage *m, int table_type, guint32 typedef_row)
898 MonoTableInfo *t = &m->tables [MONO_TABLE_GENERICPARAM];
899 MonoTableInfo *ct = &m->tables [MONO_TABLE_GENERICPARAMCONSTRAINT];
900 GString* cnst_block = NULL;
901 guint32 cols [MONO_GENERICPARAM_SIZE];
902 guint32 ccols [MONO_GENPARCONSTRAINT_SIZE];
903 int i, own_tok, table, idx, found_count, cnst_start, cnst_ind;
905 g_assert (table_type != MONO_TYPEORMETHOD_TYPE || table_type != MONO_TYPEORMETHOD_METHOD);
907 found_count = cnst_start = 0;
908 for (i = 1; i <= t->rows; i++) {
909 mono_metadata_decode_row (t, i-1, cols, MONO_GENERICPARAM_SIZE);
910 own_tok = cols [MONO_GENERICPARAM_OWNER];
911 table = own_tok & MONO_TYPEORMETHOD_MASK;
912 idx = own_tok >> MONO_TYPEORMETHOD_BITS;
914 if (table != table_type || idx != typedef_row)
917 if (found_count == 0)
918 fprintf (output, "<");
920 fprintf (output, ", ");
922 for (cnst_ind = cnst_start; cnst_ind < ct->rows; cnst_ind++) {
924 mono_metadata_decode_row (ct, cnst_ind, ccols, MONO_GENPARCONSTRAINT_SIZE);
925 if (ccols [MONO_GENPARCONSTRAINT_GENERICPAR] != i)
927 if (cnst_block == NULL)
928 cnst_block = g_string_new ("");
929 sig = get_typedef_or_ref (m, ccols [MONO_GENPARCONSTRAINT_CONSTRAINT]);
930 fprintf (output, "(%s) ", sig);
932 cnst_start = cnst_ind;
935 fprintf (output, "%s", mono_metadata_string_heap (m, cols [MONO_GENERICPARAM_NAME]));
941 fprintf (output, ">");
948 * @m: metadata context
949 * @n: index of type to disassemble
951 * Disassembles the type whose index in the TypeDef table is @n.
954 dis_type (MonoImage *m, int n)
956 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
957 GString *cnst_block = NULL;
958 guint32 cols [MONO_TYPEDEF_SIZE];
959 guint32 cols_next [MONO_TYPEDEF_SIZE];
960 const char *name, *nspace;
962 guint32 packing_size, class_size;
963 gboolean next_is_valid, last;
966 mono_metadata_decode_row (t, n, cols, MONO_TYPEDEF_SIZE);
968 if (t->rows > n + 1) {
969 mono_metadata_decode_row (t, n + 1, cols_next, MONO_TYPEDEF_SIZE);
974 name = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME]);
975 nspace = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE]);
977 fprintf (output, ".namespace %s\n{\n", nspace);
979 esname = get_escaped_name (name);
980 if ((cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_CLASS_SEMANTIC_MASK) == TYPE_ATTRIBUTE_CLASS){
981 fprintf (output, " .class %s%s", typedef_flags (cols [MONO_TYPEDEF_FLAGS]), esname);
983 cnst_block = dis_generic_param_and_constraints (m, MONO_TYPEORMETHOD_TYPE, n+1);
984 fprintf (output, "\n");
985 if (cols [MONO_TYPEDEF_EXTENDS]) {
986 char *base = get_typedef_or_ref (m, cols [MONO_TYPEDEF_EXTENDS]);
987 fprintf (output, " \textends %s\n", base);
991 fprintf (output, " .class interface %s%s\n", typedef_flags (cols [MONO_TYPEDEF_FLAGS]), esname);
993 dis_interfaces (m, n + 1);
994 fprintf (output, " {\n");
996 fprintf (output, "%s", cnst_block->str);
997 g_string_free (cnst_block, TRUE);
999 dump_cattrs (m, MONO_TOKEN_TYPE_DEF | (n + 1), " ");
1001 if (mono_metadata_packing_from_typedef (m, n + 1, &packing_size, &class_size)) {
1002 fprintf (output, " .pack %d\n", packing_size);
1003 fprintf (output, " .size %d\n", class_size);
1006 * The value in the table is always valid, we know we have fields
1007 * if the value stored is different than the next record.
1011 last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
1013 last = m->tables [MONO_TABLE_FIELD].rows;
1015 if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= m->tables [MONO_TABLE_FIELD].rows)
1016 dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last);
1017 fprintf (output, "\n");
1020 last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
1022 last = m->tables [MONO_TABLE_METHOD].rows;
1024 if (cols [MONO_TYPEDEF_METHOD_LIST] && cols [MONO_TYPEDEF_METHOD_LIST] <= m->tables [MONO_TABLE_METHOD].rows)
1025 dis_method_list (name, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last);
1027 dis_property_list (m, n);
1028 dis_event_list (m, n);
1030 t = &m->tables [MONO_TABLE_NESTEDCLASS];
1031 nested = mono_metadata_nesting_typedef (m, n + 1, 1);
1033 dis_type (m, mono_metadata_decode_row_col (t, nested - 1, MONO_NESTED_CLASS_NESTED) - 1);
1034 nested = mono_metadata_nesting_typedef (m, n + 1, nested + 1);
1037 fprintf (output, " } // end of class %s%s%s\n", nspace, *nspace? ".": "", name);
1039 fprintf (output, "}\n");
1040 fprintf (output, "\n");
1046 * @m: metadata context
1048 * disassembles all the global fields and methods
1051 dis_globals (MonoImage *m)
1053 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
1054 guint32 cols [MONO_TYPEDEF_SIZE];
1055 guint32 cols_next [MONO_TYPEDEF_SIZE];
1056 gboolean next_is_valid, last;
1059 name = g_strdup ("<Module>");
1061 mono_metadata_decode_row (t, 0, cols, MONO_TYPEDEF_SIZE);
1064 mono_metadata_decode_row (t, 1, cols_next, MONO_TYPEDEF_SIZE);
1070 * The value in the table is always valid, we know we have fields
1071 * if the value stored is different than the next record.
1075 last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
1077 last = m->tables [MONO_TABLE_FIELD].rows;
1079 if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= m->tables [MONO_TABLE_FIELD].rows)
1080 dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last);
1081 fprintf (output, "\n");
1084 last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
1086 last = m->tables [MONO_TABLE_METHOD].rows;
1088 if (cols [MONO_TYPEDEF_METHOD_LIST] && cols [MONO_TYPEDEF_METHOD_LIST] <= m->tables [MONO_TABLE_METHOD].rows)
1089 dis_method_list (name, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last);
1095 * @m: metadata context
1097 * disassembles all types in the @m context
1100 dis_types (MonoImage *m)
1102 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
1108 for (i = 1; i < t->rows; i++) {
1109 flags = mono_metadata_decode_row_col (t, i, MONO_TYPEDEF_FLAGS);
1110 flags &= TYPE_ATTRIBUTE_VISIBILITY_MASK;
1111 if (flags == TYPE_ATTRIBUTE_PUBLIC || flags == TYPE_ATTRIBUTE_NOT_PUBLIC)
1118 * @m: metadata context
1120 * disassembles all data blobs references in the FieldRVA table in the @m context
1123 dis_data (MonoImage *m)
1125 MonoTableInfo *t = &m->tables [MONO_TABLE_FIELDRVA];
1126 MonoTableInfo *ft = &m->tables [MONO_TABLE_FIELD];
1128 const char *rva, *sig;
1129 guint32 align, size;
1130 guint32 cols [MONO_FIELD_RVA_SIZE];
1133 for (i = 0; i < t->rows; i++) {
1134 mono_metadata_decode_row (t, i, cols, MONO_FIELD_RVA_SIZE);
1135 rva = mono_image_rva_map (m, cols [MONO_FIELD_RVA_RVA]);
1136 sig = mono_metadata_blob_heap (m, mono_metadata_decode_row_col (ft, cols [MONO_FIELD_RVA_FIELD] -1, MONO_FIELD_SIGNATURE));
1137 mono_metadata_decode_value (sig, &sig);
1138 /* FIELD signature == 0x06 */
1139 g_assert (*sig == 0x06);
1140 type = mono_metadata_parse_field_type (m, 0, sig + 1, &sig);
1141 mono_class_init (mono_class_from_mono_type (type));
1142 size = mono_type_size (type, &align);
1143 fprintf (output, ".data D_%08x = bytearray (", cols [MONO_FIELD_RVA_RVA]);
1144 for (b = 0; b < size; ++b) {
1146 fprintf (output, "\n\t");
1147 fprintf (output, " %02X", rva [b] & 0xff);
1149 fprintf (output, ") // size: %d\n", size);
1156 void (*dumper) (MonoImage *m);
1158 { "--assembly", MONO_TABLE_ASSEMBLY, dump_table_assembly },
1159 { "--assemblyref", MONO_TABLE_ASSEMBLYREF, dump_table_assemblyref },
1160 { "--classlayout", MONO_TABLE_CLASSLAYOUT, dump_table_class_layout },
1161 { "--constant", MONO_TABLE_CONSTANT, dump_table_constant },
1162 { "--customattr", MONO_TABLE_CUSTOMATTRIBUTE, dump_table_customattr },
1163 { "--declsec", MONO_TABLE_DECLSECURITY, dump_table_declsec },
1164 { "--event", MONO_TABLE_EVENT, dump_table_event },
1165 { "--exported", MONO_TABLE_EXPORTEDTYPE, dump_table_exported },
1166 { "--fields", MONO_TABLE_FIELD, dump_table_field },
1167 { "--file", MONO_TABLE_FILE, dump_table_file },
1168 { "--genericpar", MONO_TABLE_GENERICPARAM, dump_table_genericpar },
1169 { "--interface", MONO_TABLE_INTERFACEIMPL, dump_table_interfaceimpl },
1170 { "--manifest", MONO_TABLE_MANIFESTRESOURCE, dump_table_manifest },
1171 { "--marshal", MONO_TABLE_FIELDMARSHAL, dump_table_field_marshal },
1172 { "--memberref", MONO_TABLE_MEMBERREF, dump_table_memberref },
1173 { "--method", MONO_TABLE_METHOD, dump_table_method },
1174 { "--methodimpl", MONO_TABLE_METHODIMPL, dump_table_methodimpl },
1175 { "--methodsem", MONO_TABLE_METHODSEMANTICS, dump_table_methodsem },
1176 { "--methodspec", MONO_TABLE_METHODSPEC, dump_table_methodspec },
1177 { "--moduleref", MONO_TABLE_MODULEREF, dump_table_moduleref },
1178 { "--module", MONO_TABLE_MODULE, dump_table_module },
1179 { "--nested", MONO_TABLE_NESTEDCLASS, dump_table_nestedclass },
1180 { "--param", MONO_TABLE_PARAM, dump_table_param },
1181 { "--parconst", MONO_TABLE_GENERICPARAMCONSTRAINT, dump_table_parconstraint },
1182 { "--property", MONO_TABLE_PROPERTY, dump_table_property },
1183 { "--propertymap", MONO_TABLE_PROPERTYMAP, dump_table_property_map },
1184 { "--typedef", MONO_TABLE_TYPEDEF, dump_table_typedef },
1185 { "--typeref", MONO_TABLE_TYPEREF, dump_table_typeref },
1186 { "--typespec", MONO_TABLE_TYPESPEC, dump_table_typespec },
1187 { "--implmap", MONO_TABLE_IMPLMAP, dump_table_implmap },
1188 { "--standalonesig", MONO_TABLE_STANDALONESIG, dump_table_standalonesig },
1189 { "--blob", NULL, dump_stream_blob },
1195 * @file: file containing CIL code.
1197 * Disassembles the @file file.
1200 disassemble_file (const char *file)
1203 MonoImageOpenStatus status;
1206 ass = mono_assembly_open (file, &status);
1208 fprintf (stderr, "Error while trying to process %s\n", file);
1214 if (dump_table != -1){
1215 (*table_list [dump_table].dumper) (img);
1217 dump_header_data (img);
1219 dis_directive_assemblyref (img);
1220 dis_directive_assembly (img);
1221 dis_directive_file (img);
1222 dis_directive_module (img);
1223 dis_directive_moduleref (img);
1228 mono_image_close (img);
1234 GString *args = g_string_new ("[--output=filename] [--help] [--mscorlib]\n");
1237 for (i = 0; table_list [i].name != NULL; i++){
1238 g_string_append (args, "[");
1239 g_string_append (args, table_list [i].name);
1240 g_string_append (args, "] ");
1241 if (((i-2) % 5) == 0)
1242 g_string_append_c (args, '\n');
1245 "Usage is: monodis %s file ..\n", args->str);
1250 main (int argc, char *argv [])
1252 GList *input_files = NULL, *l;
1257 for (i = 1; i < argc; i++){
1258 if (argv [i][0] == '-'){
1259 if (argv [i][1] == 'h')
1261 else if (argv [i][1] == 'd')
1262 dump_header_data_p = TRUE;
1263 else if (strcmp (argv [i], "--mscorlib") == 0) {
1264 substitute_with_mscorlib_p = TRUE;
1266 } else if (strcmp (argv [i], "--show-method-tokens") == 0) {
1267 show_method_tokens = TRUE;
1269 } else if (strcmp (argv [i], "--show-tokens") == 0) {
1272 } else if (strncmp (argv [i], "--output=", 9) == 0) {
1273 output = fopen (argv [i]+9, "w");
1274 if (output == NULL) {
1275 fprintf (stderr, "Can't open output file `%s': %s\n",
1276 argv [i]+9, strerror (errno));
1280 } else if (strcmp (argv [i], "--help") == 0)
1282 for (j = 0; table_list [j].name != NULL; j++) {
1283 if (strcmp (argv [i], table_list [j].name) == 0)
1289 input_files = g_list_append (input_files, argv [i]);
1292 if (input_files == NULL)
1295 mono_init (argv [0]);
1297 for (l = input_files; l; l = l->next)
1298 disassemble_file (l->data);