?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[System] Always pass -noconfig to codedom c# compiler
[mono-project.git] / mono / dis / main.c
blobd1b85c5509abb7c864ff51ac4b92202f38dc5475
1 /*
2 * main.c: Sample disassembler
3 *
4 * Author:
5 * Miguel de Icaza (miguel@ximian.com)
6 *
7 * (C) 2001 Ximian, Inc.
8 *
9 * TODO:
10 * Investigate how interface inheritance works and how it should be dumped.
11 * Structs are not being labeled as `valuetype' classes
12 *
13 * How are fields with literals mapped to constants?
14 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
15 */
16 #include <config.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <glib.h>
20 #include <stdlib.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include "meta.h"
24 #include "util.h"
25 #include "dump.h"
26 #include "get.h"
27 #include "dis-cil.h"
28 #include "declsec.h"
29 #include <mono/metadata/class-internals.h>
30 #include <mono/metadata/object-internals.h>
31 #include <mono/metadata/loader.h>
32 #include <mono/metadata/assembly.h>
33 #include <mono/metadata/appdomain.h>
34 #include <mono/utils/bsearch.h>
35
36 static void setup_filter (MonoImage *image);
37 static gboolean should_include_type (int idx);
38 static gboolean should_include_method (int idx);
39 static gboolean should_include_field (int idx);
40
41 FILE *output;
42
43 /* True if you want to get a dump of the header data */
44 gboolean dump_header_data_p = FALSE;
45
46 /* True if you want to get forward declarations */
47 gboolean dump_forward_decls = FALSE;
48
49 /* True if you want to dump managed resources as files */
50 gboolean dump_managed_resources = FALSE;
51
52 gboolean substitute_with_mscorlib_p = FALSE;
53
54 int dump_table = -1;
55
56 static void
57 dump_header_data (MonoImage *img)
58 {
59 if (!dump_header_data_p)
60 return;
61
62 fprintf (output,
63 "// Ximian's CIL disassembler, version 1.0\n"
64 "// Copyright (C) 2001 Ximian, Inc.\n\n");
65 }
66
67 static void
68 dump_cattrs_list (GList *list, const char *indent)
69 {
70 GList *tmp;
71
72 for (tmp = list; tmp; tmp = tmp->next) {
73 fprintf (output, "%s%s\n", indent, (char*)tmp->data);
74 g_free (tmp->data);
75 }
76 g_list_free (list);
77 }
78
79 static void
80 dump_cattrs (MonoImage *m, guint32 token, const char *indent)
81 {
82 GList *list;
83
84 list = dis_get_custom_attrs (m, token);
85 dump_cattrs_list (list, indent);
86 }
87
88 static const char*
89 get_il_security_action (int val)
90 {
91 static char buf [32];
92
93 switch (val) {
94 case SECURITY_ACTION_DEMAND:
95 return "demand";
96 case SECURITY_ACTION_ASSERT:
97 return "assert";
98 case SECURITY_ACTION_DENY:
99 return "deny";
100 case SECURITY_ACTION_PERMITONLY:
101 return "permitonly";
102 case SECURITY_ACTION_LINKDEMAND:
103 return "linkcheck";
104 case SECURITY_ACTION_INHERITDEMAND:
105 return "inheritcheck";
106 case SECURITY_ACTION_REQMIN:
107 return "reqmin";
108 case SECURITY_ACTION_REQOPT:
109 return "reqopt";
110 case SECURITY_ACTION_REQREFUSE:
111 return "reqrefuse";
112 /* Special actions (for non CAS permissions) */
113 case SECURITY_ACTION_NONCASDEMAND:
114 return "noncasdemand";
115 case SECURITY_ACTION_NONCASLINKDEMAND:
116 return "noncaslinkdemand";
117 case SECURITY_ACTION_NONCASINHERITANCE:
118 return "noncasinheritance";
119 /* Fx 2.0 actions (for both CAS and non-CAS permissions) */
120 case SECURITY_ACTION_LINKDEMANDCHOICE:
121 return "linkdemandor";
122 case SECURITY_ACTION_INHERITDEMANDCHOICE:
123 return "inheritancedemandor";
124 case SECURITY_ACTION_DEMANDCHOICE:
125 return "demandor";
126 default:
127 g_snprintf (buf, sizeof (buf), "0x%04X", val);
128 return buf;
129 }
130 }
131
132 #define OBJECT_TYPE_TYPEDEF 0
133 #define OBJECT_TYPE_METHODDEF 1
134 #define OBJECT_TYPE_ASSEMBLYDEF 2
135
136 static void
137 dump_declarative_security (MonoImage *m, guint32 objectType, guint32 token, const char *indent)
138 {
139 MonoTableInfo *t = &m->tables [MONO_TABLE_DECLSECURITY];
140 guint32 cols [MONO_DECL_SECURITY_SIZE];
141 int i, len;
142 guint32 idx;
143 const char *blob, *action;
144
145 for (i = 1; i <= t->rows; i++) {
146 mono_metadata_decode_row (t, i - 1, cols, MONO_DECL_SECURITY_SIZE);
147 blob = mono_metadata_blob_heap (m, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
148 len = mono_metadata_decode_blob_size (blob, &blob);
149 action = get_il_security_action (cols [MONO_DECL_SECURITY_ACTION]);
150 idx = cols [MONO_DECL_SECURITY_PARENT];
151 if (((idx & MONO_HAS_DECL_SECURITY_MASK) == objectType) && ((idx >> MONO_HAS_DECL_SECURITY_BITS) == token)) {
152 char *dump;
153 if (blob [0] == MONO_DECLSEC_FORMAT_20) {
154 /* 2.0 declarative security format */
155 dump = dump_declsec_entry20 (m, blob, indent);
156 fprintf (output, "%s.permissionset %s = %s\n", indent, action, dump);
157 } else {
158 /* 1.x declarative security metadata format */
159 dump = data_dump (blob, len, indent);
160 fprintf (output, "%s.permissionset %s = %s", indent, action, dump);
161 }
162 g_free (dump);
163 }
164 }
165 }
166
167 static char *
168 assembly_flags (guint32 f)
169 {
170 if (f & ASSEMBLYREF_RETARGETABLE_FLAG)
171 return g_strdup ("retargetable ");
172 return g_strdup ("");
173 }
174
175 static void
176 dis_directive_assembly (MonoImage *m)
177 {
178 MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLY];
179 guint32 cols [MONO_ASSEMBLY_SIZE];
180 char *flags;
181
182 if (t->base == NULL)
183 return;
184
185 mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
186 flags = assembly_flags (cols [MONO_ASSEMBLY_FLAGS]);
187
188 fprintf (output, ".assembly %s'%s'\n{\n",
189 flags, mono_metadata_string_heap (m, cols [MONO_ASSEMBLY_NAME]));
190 dump_cattrs (m, MONO_TOKEN_ASSEMBLY | 1, " ");
191 dump_declarative_security (m, OBJECT_TYPE_ASSEMBLYDEF, 1, " ");
192 fprintf (output,
193 " .hash algorithm 0x%08x\n"
194 " .ver %d:%d:%d:%d\n",
195 cols [MONO_ASSEMBLY_HASH_ALG],
196 cols [MONO_ASSEMBLY_MAJOR_VERSION], cols [MONO_ASSEMBLY_MINOR_VERSION],
197 cols [MONO_ASSEMBLY_BUILD_NUMBER], cols [MONO_ASSEMBLY_REV_NUMBER]);
198 if (cols [MONO_ASSEMBLY_CULTURE]){
199 const char *locale = mono_metadata_string_heap (m, cols [MONO_ASSEMBLY_CULTURE]);
200 glong items_read, items_written;
201 gunichar2 *render = g_utf8_to_utf16 (locale, strlen (locale), &items_read, &items_written, NULL);
202 char *dump = data_dump ((const char *) render, items_written * sizeof (gunichar2), "\t\t");
203 fprintf (output, " .locale %s\n", dump);
204 g_free (dump);
205 g_free (render);
206
207 } if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
208 const char* b = mono_metadata_blob_heap (m, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
209 int len = mono_metadata_decode_blob_size (b, &b);
210 char *dump = data_dump (b, len, "\t\t");
211 fprintf (output, " .publickey =%s", dump);
212 g_free (dump);
213 }
214 fprintf (output, "}\n");
215
216 g_free (flags);
217 }
218
219 static void
220 dis_directive_assemblyref (MonoImage *m)
221 {
222 MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLYREF];
223 guint32 cols [MONO_ASSEMBLYREF_SIZE];
224 int i;
225
226 if (t->base == NULL)
227 return;
228
229 for (i = 0; i < t->rows; i++){
230 char *esc, *flags;
231
232 mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
233
234 esc = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]));
235 flags = assembly_flags (cols [MONO_ASSEMBLYREF_FLAGS]);
236
237 fprintf (output,
238 ".assembly extern %s%s\n"
239 "{\n"
240 " .ver %d:%d:%d:%d\n",
241 flags,
242 esc,
243 cols [MONO_ASSEMBLYREF_MAJOR_VERSION], cols [MONO_ASSEMBLYREF_MINOR_VERSION],
244 cols [MONO_ASSEMBLYREF_BUILD_NUMBER], cols [MONO_ASSEMBLYREF_REV_NUMBER]
245 );
246 dump_cattrs (m, MONO_TOKEN_ASSEMBLY_REF | (i + 1), " ");
247 if (cols [MONO_ASSEMBLYREF_CULTURE]){
248 fprintf (output, " .locale %s\n", mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_CULTURE]));
249 }
250 if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]){
251 const char* b = mono_metadata_blob_heap (m, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
252 int len = mono_metadata_decode_blob_size (b, &b);
253 char *dump = data_dump (b, len, "\t\t");
254 fprintf (output, " .publickeytoken =%s", dump);
255 g_free (dump);
256 }
257 fprintf (output, "}\n");
258 g_free (flags);
259 g_free (esc);
260 }
261 }
262
263 static void
264 dis_directive_module (MonoImage *m)
265 {
266 MonoTableInfo *t = &m->tables [MONO_TABLE_MODULE];
267 int i;
268
269 for (i = 0; i < t->rows; i++){
270 guint32 cols [MONO_MODULE_SIZE];
271 const char *name;
272 char *guid, *ename;
273
274 mono_metadata_decode_row (t, i, cols, MONO_MODULE_SIZE);
275
276 name = mono_metadata_string_heap (m, cols [MONO_MODULE_NAME]);
277 ename = get_escaped_name (name);
278 guid = get_guid (m, cols [MONO_MODULE_MVID]);
279 fprintf (output, ".module %s // GUID = %s\n\n", ename, guid);
280 g_free (ename);
281
282 dump_cattrs (m, MONO_TOKEN_MODULE | (i + 1), "");
283 }
284 }
285
286 static void
287 dis_directive_moduleref (MonoImage *m)
288 {
289 MonoTableInfo *t = &m->tables [MONO_TABLE_MODULEREF];
290 int i;
291
292 for (i = 0; i < t->rows; i++){
293 guint32 cols [MONO_MODULEREF_SIZE];
294
295 mono_metadata_decode_row (t, i, cols, MONO_MODULEREF_SIZE);
296
297 fprintf (output, ".module extern '%s'\n", mono_metadata_string_heap (m, cols [MONO_MODULEREF_NAME]));
298 }
299
300 }
301
302 static void
303 dis_nt_header (MonoImage *m)
304 {
305 MonoCLIImageInfo *image_info = (MonoCLIImageInfo *)m->image_info;
306 if (image_info && image_info->cli_header.nt.pe_stack_reserve != 0x100000)
307 fprintf (output, ".stackreserve 0x%x\n", image_info->cli_header.nt.pe_stack_reserve);
308 }
309
310 static void
311 dis_directive_file (MonoImage *m)
312 {
313 MonoTableInfo *t = &m->tables [MONO_TABLE_FILE];
314 int i, j, len;
315 guint32 entry_point;
316
317 entry_point = mono_image_get_entry_point (m);
318
319 for (i = 0; i < t->rows; i++){
320 guint32 cols [MONO_FILE_SIZE];
321 const char *name, *hash;
322 guint32 token;
323
324 mono_metadata_decode_row (t, i, cols, MONO_FILE_SIZE);
325
326 name = mono_metadata_string_heap (m, cols [MONO_FILE_NAME]);
327
328 hash = mono_metadata_blob_heap (m, cols [MONO_FILE_HASH_VALUE]);
329 len = mono_metadata_decode_blob_size (hash, &hash);
330
331 fprintf (output, ".file %s%s .hash = (",
332 cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA ? "nometadata " : "", name);
333
334 for (j = 0; j < len; ++j)
335 fprintf (output, " %02X", hash [j] & 0xff);
336
337 token = mono_metadata_make_token (MONO_TABLE_FILE, i + 1);
338 fprintf (output, " )%s\n", (token == entry_point) ? " .entrypoint" : "");
339 }
340
341 }
342
343 static void
344 dis_directive_mresource (MonoImage *m)
345 {
346 MonoTableInfo *t = &m->tables [MONO_TABLE_MANIFESTRESOURCE];
347 int i;
348
349 for (i = 0; i < t->rows; i++){
350 guint32 cols [MONO_MANIFEST_SIZE];
351 const char *name;
352 guint32 impl, idx, name_token;
353
354 mono_metadata_decode_row (t, i, cols, MONO_MANIFEST_SIZE);
355
356 name = mono_metadata_string_heap (m, cols [MONO_MANIFEST_NAME]);
357
358 fprintf (output, ".mresource %s '%s'\n", (cols [MONO_MANIFEST_FLAGS] & MANIFEST_RESOURCE_VISIBILITY_MASK) == (MANIFEST_RESOURCE_PUBLIC) ? "public" : "private", name);
359 fprintf (output, "{\n");
360 impl = cols [MONO_MANIFEST_IMPLEMENTATION];
361 if (impl) {
362 idx = impl >> MONO_IMPLEMENTATION_BITS;
363 if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE) {
364 name_token = mono_metadata_decode_row_col (&m->tables [MONO_TABLE_FILE], idx - 1, MONO_FILE_NAME);
365
366 fprintf (output, " .file '%s' at 0x0\n", mono_metadata_string_heap (m, name_token));
367 }
368 if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_ASSEMBLYREF) {
369 name_token = mono_metadata_decode_row_col (&m->tables [MONO_TABLE_ASSEMBLYREF], idx - 1, MONO_ASSEMBLYREF_NAME);
370 fprintf (output, " .assembly extern '%s'\n", mono_metadata_string_heap (m, name_token));
371 }
372 }
373 fprintf (output, "}\n");
374 }
375
376 }
377
378 static dis_map_t visibility_map [] = {
379 { TYPE_ATTRIBUTE_NOT_PUBLIC, "private " },
380 { TYPE_ATTRIBUTE_PUBLIC, "public " },
381 { TYPE_ATTRIBUTE_NESTED_PUBLIC, "nested public " },
382 { TYPE_ATTRIBUTE_NESTED_PRIVATE, "nested private " },
383 { TYPE_ATTRIBUTE_NESTED_FAMILY, "nested family " },
384 { TYPE_ATTRIBUTE_NESTED_ASSEMBLY, "nested assembly " },
385 { TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM, "nested famandassem " },
386 { TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM, "nested famorassem " },
387 { 0, NULL }
388 };
389
390 static dis_map_t layout_map [] = {
391 { TYPE_ATTRIBUTE_AUTO_LAYOUT, "auto " },
392 { TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT, "sequential " },
393 { TYPE_ATTRIBUTE_EXPLICIT_LAYOUT, "explicit " },
394 { 0, NULL }
395 };
396
397 static dis_map_t format_map [] = {
398 { TYPE_ATTRIBUTE_ANSI_CLASS, "ansi " },
399 { TYPE_ATTRIBUTE_UNICODE_CLASS, "unicode " },
400 { TYPE_ATTRIBUTE_AUTO_CLASS, "auto " },
401 { 0, NULL }
402 };
403
404 static char *
405 typedef_flags (guint32 flags)
406 {
407 static char buffer [1024];
408 int visibility = flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
409 int layout = flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
410 int format = flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK;
411
412 buffer [0] = 0;
413
414 strcat (buffer, map (visibility, visibility_map));
415 strcat (buffer, map (layout, layout_map));
416 strcat (buffer, map (format, format_map));
417
418 if (flags & TYPE_ATTRIBUTE_ABSTRACT)
419 strcat (buffer, "abstract ");
420 if (flags & TYPE_ATTRIBUTE_SEALED)
421 strcat (buffer, "sealed ");
422 if (flags & TYPE_ATTRIBUTE_SPECIAL_NAME)
423 strcat (buffer, "specialname ");
424 if (flags & TYPE_ATTRIBUTE_IMPORT)
425 strcat (buffer, "import ");
426 if (flags & TYPE_ATTRIBUTE_SERIALIZABLE)
427 strcat (buffer, "serializable ");
428 if (flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)
429 strcat (buffer, "beforefieldinit ");
430 if (flags & TYPE_ATTRIBUTE_FORWARDER)
431 strcat (buffer, "forwarder ");
432
433 return buffer;
434 }
435
436 /**
437 * dis_field_list:
438 * @m: metadata context
439 * @start: starting index into the Field Table.
440 * @end: ending index into Field table.
441 *
442 * This routine displays all the decoded fields from @start to @end
443 */
444 static void
445 dis_field_list (MonoImage *m, guint32 start, guint32 end, MonoGenericContainer *container)
446 {
447 MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
448 guint32 cols [MONO_FIELD_SIZE];
449 char *esname;
450 char rva_desc [32];
451 guint32 rva;
452 int i;
453
454 if (end > t->rows + 1) {
455 g_warning ("ERROR index out of range in fields");
456 end = t->rows;
457 }
458
459 for (i = start; i < end; i++){
460 char *sig, *flags, *attrs = NULL;
461 char *marshal_str = NULL;
462 guint32 field_offset = -1;
463
464 if (!should_include_field (i + 1))
465 continue;
466 mono_metadata_decode_row (t, i, cols, MONO_FIELD_SIZE);
467 sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE], container);
468 flags = field_flags (cols [MONO_FIELD_FLAGS]);
469
470 if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL) {
471 const char *tp;
472 MonoMarshalSpec *spec;
473
474 tp = mono_metadata_get_marshal_info (m, i, TRUE);
475 spec = mono_metadata_parse_marshal_spec (m, tp);
476 marshal_str = dis_stringify_marshal_spec (spec);
477 }
478
479 if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
480 mono_metadata_field_info (m, i, NULL, &rva, NULL);
481 g_snprintf (rva_desc, sizeof (rva_desc), " at D_%08x", rva);
482 } else {
483 rva_desc [0] = 0;
484 }
485
486 mono_metadata_field_info (m, i, &field_offset, NULL, NULL);
487 if (field_offset != -1)
488 attrs = g_strdup_printf ("[%d]", field_offset);
489 esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]));
490 if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_DEFAULT){
491 char *lit;
492 guint32 const_cols [MONO_CONSTANT_SIZE];
493 guint32 crow;
494
495 if ((crow = mono_metadata_get_constant_index (m, MONO_TOKEN_FIELD_DEF | (i+1), 0))) {
496 mono_metadata_decode_row (&m->tables [MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
497 lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
498 } else {
499 lit = g_strdup ("not found");
500 }
501
502 fprintf (output, " .field %s%s%s %s = ",
503 flags, marshal_str ? marshal_str : " ", sig, esname);
504 fprintf (output, "%s\n", lit);
505 g_free (lit);
506 } else
507 fprintf (output, " .field %s %s%s%s %s%s\n",
508 attrs? attrs: "", flags, marshal_str ? marshal_str : " ", sig, esname, rva_desc);
509 g_free (attrs);
510 g_free (flags);
511 g_free (marshal_str);
512 g_free (sig);
513 g_free (esname);
514 dump_cattrs (m, MONO_TOKEN_FIELD_DEF | (i + 1), " ");
515 }
516 }
517
518 static dis_map_t method_access_map [] = {
519 { METHOD_ATTRIBUTE_COMPILER_CONTROLLED, "privatescope " },
520 { METHOD_ATTRIBUTE_PRIVATE, "private " },
521 { METHOD_ATTRIBUTE_FAM_AND_ASSEM, "famandassem " },
522 { METHOD_ATTRIBUTE_ASSEM, "assembly " },
523 { METHOD_ATTRIBUTE_FAMILY, "family " },
524 { METHOD_ATTRIBUTE_FAM_OR_ASSEM, "famorassem " },
525 { METHOD_ATTRIBUTE_PUBLIC, "public " },
526 { 0, NULL }
527 };
528
529 static dis_map_t method_flags_map [] = {
530 { METHOD_ATTRIBUTE_STATIC, "static " },
531 { METHOD_ATTRIBUTE_FINAL, "final " },
532 { METHOD_ATTRIBUTE_VIRTUAL, "virtual " },
533 { METHOD_ATTRIBUTE_HIDE_BY_SIG, "hidebysig " },
534 { METHOD_ATTRIBUTE_VTABLE_LAYOUT_MASK, "newslot " },
535 { METHOD_ATTRIBUTE_ABSTRACT, "abstract " },
536 { METHOD_ATTRIBUTE_SPECIAL_NAME, "specialname " },
537 { METHOD_ATTRIBUTE_RT_SPECIAL_NAME, "rtspecialname " },
538 { METHOD_ATTRIBUTE_UNMANAGED_EXPORT, "export " },
539 /* MS ilasm doesn't compile this statement - is must be added automagically when permissionset are present */
540 { METHOD_ATTRIBUTE_HAS_SECURITY, "" /*"hassecurity"*/ },
541 { METHOD_ATTRIBUTE_REQUIRE_SEC_OBJECT, "requiresecobj " },
542 { METHOD_ATTRIBUTE_PINVOKE_IMPL, "pinvokeimpl " },
543 { METHOD_ATTRIBUTE_STRICT, "strict " },
544 { 0, NULL }
545 };
546
547 /**
548 * method_flags:
549 *
550 * Returns a stringified version of the Method's flags
551 */
552 static char *
553 method_flags (guint32 f)
554 {
555 GString *str = g_string_new ("");
556 int access = f & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK;
557 int rest = f & ~access;
558 char *s;
559
560 g_string_append (str, map (access, method_access_map));
561 g_string_append (str, flags (rest, method_flags_map));
562
563 s = str->str;
564 g_string_free (str, FALSE);
565
566 return s;
567 }
568
569 static dis_map_t pinvoke_flags_map [] = {
570 { PINVOKE_ATTRIBUTE_NO_MANGLE , "nomangle " },
571 { PINVOKE_ATTRIBUTE_SUPPORTS_LAST_ERROR, "lasterr " },
572 { PINVOKE_ATTRIBUTE_BEST_FIT_ENABLED, "bestfit:on " },
573 { PINVOKE_ATTRIBUTE_BEST_FIT_DISABLED, "bestfit:off " },
574 { PINVOKE_ATTRIBUTE_THROW_ON_UNMAPPABLE_ENABLED, "charmaperror:on " },
575 { PINVOKE_ATTRIBUTE_THROW_ON_UNMAPPABLE_DISABLED, "charmaperror:off " },
576 { 0, NULL }
577 };
578
579 static dis_map_t pinvoke_call_conv_map [] = {
580 { PINVOKE_ATTRIBUTE_CALL_CONV_WINAPI, "winapi " },
581 { PINVOKE_ATTRIBUTE_CALL_CONV_CDECL, "cdecl " },
582 { PINVOKE_ATTRIBUTE_CALL_CONV_STDCALL, "stdcall " },
583 { PINVOKE_ATTRIBUTE_CALL_CONV_THISCALL, "thiscall " },
584 { PINVOKE_ATTRIBUTE_CALL_CONV_FASTCALL, "fastcall " },
585 { 0, "" },
586 { -1, NULL }
587 };
588
589 static dis_map_t pinvoke_char_set_map [] = {
590 { PINVOKE_ATTRIBUTE_CHAR_SET_NOT_SPEC, "" },
591 { PINVOKE_ATTRIBUTE_CHAR_SET_ANSI, "ansi " },
592 { PINVOKE_ATTRIBUTE_CHAR_SET_UNICODE , "unicode " },
593 { PINVOKE_ATTRIBUTE_CHAR_SET_AUTO, "autochar " },
594 { 0, NULL }
595 };
596
597 /**
598 * pinvoke_flags:
599 *
600 * Returns a stringified version of the Method's pinvoke flags
601 */
602 static char *
603 pinvoke_flags (guint32 f)
604 {
605 GString *str = g_string_new ("");
606 int cset = f & PINVOKE_ATTRIBUTE_CHAR_SET_MASK;
607 int cconv = f & PINVOKE_ATTRIBUTE_CALL_CONV_MASK;
608 int rest = f & ~(cset | cconv);
609 char *s;
610
611 g_string_append (str, map (cset, pinvoke_char_set_map));
612 g_string_append (str, map (cconv, pinvoke_call_conv_map));
613 g_string_append (str, flags (rest, pinvoke_flags_map));
614
615 s = g_strdup(str->str);
616 g_string_free (str, FALSE);
617
618 return s;
619 }
620
621 static void
622 dis_locals (MonoImage *m, MonoMethodHeader *mh, const char *ptr)
623 {
624 int i;
625
626 if (show_tokens) {
627 unsigned char flags = *(const unsigned char *) ptr;
628 unsigned char format = flags & METHOD_HEADER_FORMAT_MASK;
629 guint16 fat_flags;
630 guint32 local_var_sig_tok, init_locals;
631
632 g_assert (format == METHOD_HEADER_FAT_FORMAT);
633 fat_flags = read16 (ptr);
634 ptr += 2;
635 /* max_stack = read16 (ptr); */
636 ptr += 2;
637 /* code_size = read32 (ptr); */
638 ptr += 4;
639 local_var_sig_tok = read32 (ptr);
640 ptr += 4;
641
642 if (fat_flags & METHOD_HEADER_INIT_LOCALS)
643 init_locals = 1;
644 else
645 init_locals = 0;
646
647 fprintf(output, "\t.locals /*%08x*/ %s(\n",
648 local_var_sig_tok, init_locals ? "init " : "");
649 } else
650 fprintf(output, "\t.locals %s(\n", mh->init_locals ? "init " : "");
651
652 for (i=0; i < mh->num_locals; ++i) {
653 char * desc;
654 if (i)
655 fprintf(output, ",\n");
656 /* print also byref and pinned attributes */
657 desc = dis_stringify_type (m, mh->locals[i], TRUE);
658 fprintf(output, "\t\t%s\tV_%d", desc, i);
659 g_free(desc);
660 }
661 fprintf(output, ")\n");
662 }
663
664 static void
665 dis_code (MonoImage *m, guint32 token, guint32 rva, MonoGenericContainer *container)
666 {
667 MonoError error;
668 MonoMethodHeader *mh;
669 const char *ptr = mono_image_rva_map (m, rva);
670 const char *loc;
671 gchar *override;
672 guint32 entry_point;
673
674 if (rva == 0)
675 return;
676
677 override = get_method_override (m, token, container);
678 if (override) {
679 fprintf (output, "\t.override %s\n", override);
680 g_free (override);
681 }
682
683 mh = mono_metadata_parse_mh_full (m, container, ptr, &error);
684 entry_point = mono_image_get_entry_point (m);
685 if (entry_point && mono_metadata_token_index (entry_point) && mono_metadata_token_table (entry_point) == MONO_TABLE_METHOD) {
686 loc = mono_metadata_locate_token (m, entry_point);
687 if (rva == read32 (loc))
688 fprintf (output, "\t.entrypoint\n");
689 }
690
691 if (mh) {
692 fprintf (output, "\t// Code size %d (0x%x)\n", mh->code_size, mh->code_size);
693 fprintf (output, "\t.maxstack %d\n", mh->max_stack);
694 if (mh->num_locals)
695 dis_locals (m, mh, ptr);
696 disassemble_cil (m, mh, container);
697 /*
698 hex_dump (mh->code, 0, mh->code_size);
699 printf ("\nAfter the code\n");
700 hex_dump (mh->code + mh->code_size, 0, 64);
701 */
702 mono_metadata_free_mh (mh);
703 } else {
704 mono_error_cleanup (&error);
705 }
706 }
707
708 static char *
709 pinvoke_info (MonoImage *m, guint32 mindex)
710 {
711 MonoTableInfo *im = &m->tables [MONO_TABLE_IMPLMAP];
712 MonoTableInfo *mr = &m->tables [MONO_TABLE_MODULEREF];
713 guint32 im_cols [MONO_IMPLMAP_SIZE];
714 guint32 mr_cols [MONO_MODULEREF_SIZE];
715 const char *import, *scope;
716 char *flags;
717 int i;
718
719 for (i = 0; i < im->rows; i++) {
720
721 mono_metadata_decode_row (im, i, im_cols, MONO_IMPLMAP_SIZE);
722
723 if ((im_cols [MONO_IMPLMAP_MEMBER] >> 1) == mindex + 1) {
724
725 flags = pinvoke_flags (im_cols [MONO_IMPLMAP_FLAGS]);
726
727 import = mono_metadata_string_heap (m, im_cols [MONO_IMPLMAP_NAME]);
728
729 mono_metadata_decode_row (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1,
730 mr_cols, MONO_MODULEREF_SIZE);
731
732 scope = mono_metadata_string_heap (m, mr_cols [MONO_MODULEREF_NAME]);
733
734 return g_strdup_printf ("(\"%s\" as \"%s\" %s)", scope, import,
735 flags);
736 g_free (flags);
737 }
738 }
739
740 return NULL;
741 }
742
743 /*
744 * dump_cattrs_for_type_params
745 *
746 * @m:
747 * @token: TypeOrMethodDef token, owner for GenericParam
748 *
749 * Dumps the custom attributes for @token's type parameters
750 */
751 static void
752 dump_cattrs_for_type_params (MonoImage *m, guint32 token, const char *indent)
753 {
754 MonoTableInfo *tdef = &m->tables [MONO_TABLE_GENERICPARAM];
755 guint32 cols [MONO_GENERICPARAM_SIZE];
756 guint32 owner = 0, i;
757 GList *list = NULL;
758
759 if (! (i = mono_metadata_get_generic_param_row (m, token, &owner)))
760 return;
761
762 mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
763 do {
764 list = dis_get_custom_attrs (m, mono_metadata_make_token (MONO_TABLE_GENERICPARAM, i));
765 if (list) {
766 fprintf (output, "%s.param type %s\n", indent, mono_metadata_string_heap (m, cols [MONO_GENERICPARAM_NAME]));
767 dump_cattrs_list (list, indent);
768 }
769
770 if (++i > tdef->rows)
771 break;
772 mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
773 } while (cols [MONO_GENERICPARAM_OWNER] == owner);
774 }
775
776 static void
777 dump_cattrs_for_method_params (MonoImage *m, guint32 midx, MonoMethodSignature *sig) {
778 MonoTableInfo *methodt;
779 MonoTableInfo *paramt;
780 guint param_index, lastp, i;
781
782 methodt = &m->tables [MONO_TABLE_METHOD];
783 paramt = &m->tables [MONO_TABLE_PARAM];
784 param_index = mono_metadata_decode_row_col (methodt, midx, MONO_METHOD_PARAMLIST);
785 if (midx + 1 < methodt->rows)
786 lastp = mono_metadata_decode_row_col (methodt, midx + 1, MONO_METHOD_PARAMLIST);
787 else
788 lastp = paramt->rows + 1;
789 for (i = param_index; i < lastp; ++i) {
790 char *lit;
791 int crow;
792 guint32 param_cols [MONO_PARAM_SIZE];
793 GList *list;
794
795 list = dis_get_custom_attrs (m, MONO_TOKEN_PARAM_DEF | i);
796
797 mono_metadata_decode_row (paramt, i-1, param_cols, MONO_PARAM_SIZE);
798 if (!(param_cols[MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
799 if(list != NULL)
800 fprintf (output, "\t.param [%d]\n", param_cols[MONO_PARAM_SEQUENCE]);
801 } else {
802 fprintf (output, "\t.param [%d] = ", param_cols[MONO_PARAM_SEQUENCE]);
803
804 if ((crow = mono_metadata_get_constant_index(m, MONO_TOKEN_PARAM_DEF | i, 0))) {
805 guint32 const_cols [MONO_CONSTANT_SIZE];
806 mono_metadata_decode_row( &m->tables[MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
807 lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
808 }
809 else {
810 lit = g_strdup ("not found");
811 }
812 fprintf(output, "%s\n", lit);
813 g_free(lit);
814 }
815 dump_cattrs_list (list, "\t");
816 }
817 }
818
819 /**
820 * dis_method_list:
821 * @m: metadata context
822 * @start: starting index into the Method Table.
823 * @end: ending index into Method table.
824 *
825 * This routine displays the methods in the Method Table from @start to @end
826 */
827 static void
828 dis_method_list (const char *klass_name, MonoImage *m, guint32 start, guint32 end, MonoGenericContainer *type_container)
829 {
830 MonoTableInfo *t = &m->tables [MONO_TABLE_METHOD];
831 guint32 cols [MONO_METHOD_SIZE];
832 int i;
833
834 if (end > t->rows){
835 fprintf (output, "ERROR index out of range in methods");
836 /*exit (1);*/
837 end = t->rows;
838 }
839
840 for (i = start; i < end; i++){
841 MonoError error;
842 MonoMethodSignature *ms;
843 MonoGenericContainer *container;
844 char *flags, *impl_flags;
845 const char *sig, *method_name;
846 char *sig_str;
847 guint32 token;
848
849 if (!should_include_method (i + 1))
850 continue;
851 mono_metadata_decode_row (t, i, cols, MONO_METHOD_SIZE);
852
853 flags = method_flags (cols [MONO_METHOD_FLAGS]);
854 impl_flags = get_method_impl_flags (cols [MONO_METHOD_IMPLFLAGS]);
855
856 sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
857 mono_metadata_decode_blob_size (sig, &sig);
858
859 container = mono_metadata_load_generic_params (m, MONO_TOKEN_METHOD_DEF | (i + 1), type_container);
860 if (container) {
861 MonoError error;
862 mono_metadata_load_generic_param_constraints_checked (m, MONO_TOKEN_METHOD_DEF | (i + 1), container, &error);
863 g_assert (mono_error_ok (&error)); /*FIXME don't swallow the error message*/
864 } else {
865 container = type_container;
866 }
867
868 ms = mono_metadata_parse_method_signature_full (m, container, i + 1, sig, &sig, &error);
869 if (ms != NULL){
870 sig_str = dis_stringify_method_signature (m, ms, i + 1, container, FALSE);
871 method_name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]);
872 } else {
873 sig_str = NULL;
874 method_name = g_strdup ("<NULL METHOD SIGNATURE>");
875 mono_error_cleanup (&error);
876 }
877
878 fprintf (output, " // method line %d\n", i + 1);
879 fprintf (output, " .method %s", flags);
880
881 if ((cols [MONO_METHOD_FLAGS] & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (cols [MONO_METHOD_RVA] == 0)) {
882 gchar *pi = pinvoke_info (m, i);
883 if (pi) {
884 fprintf (output, "%s", pi);
885 g_free (pi);
886 }
887 }
888
889 fprintf (output, "\n %s", sig_str);
890 fprintf (output, " %s\n", impl_flags);
891 g_free (flags);
892 g_free (impl_flags);
893
894 token = MONO_TOKEN_METHOD_DEF | (i + 1);
895
896 fprintf (output, " {\n");
897 dump_cattrs (m, token, " ");
898 dump_cattrs_for_type_params (m, MONO_TOKEN_METHOD_DEF | (i + 1), " ");
899 dump_cattrs_for_method_params (m, i, ms);
900
901 fprintf (output, " // Method begins at RVA 0x%x\n", cols [MONO_METHOD_RVA]);
902 dump_declarative_security (m, OBJECT_TYPE_METHODDEF, i + 1, " ");
903 if (cols [MONO_METHOD_IMPLFLAGS] & METHOD_IMPL_ATTRIBUTE_NATIVE)
904 fprintf (output, " // Disassembly of native methods is not supported\n");
905 else
906 dis_code (m, token, cols [MONO_METHOD_RVA], container);
907 if (klass_name)
908 fprintf (output, " } // end of method %s::%s\n\n", klass_name, method_name);
909 else
910 fprintf (output, " } // end of global method %s\n\n", method_name);
911 mono_metadata_free_method_signature (ms);
912 g_free (sig_str);
913 }
914 }
915
916 typedef struct {
917 MonoTableInfo *t;
918 guint32 col_idx;
919 guint32 idx;
920 guint32 result;
921 } plocator_t;
922
923 static int
924 table_locator (const void *a, const void *b)
925 {
926 plocator_t *loc = (plocator_t *) a;
927 const char *bb = (const char *) b;
928 guint32 table_index = (bb - loc->t->base) / loc->t->row_size;
929 guint32 col;
930
931 col = mono_metadata_decode_row_col (loc->t, table_index, loc->col_idx);
932
933 if (loc->idx == col) {
934 loc->result = table_index;
935 return 0;
936 }
937 if (loc->idx < col)
938 return -1;
939 else
940 return 1;
941 }
942
943 static void
944 dis_property_methods (MonoImage *m, guint32 prop, MonoGenericContainer *container)
945 {
946 guint start, end;
947 MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS];
948 guint32 cols [MONO_METHOD_SEMA_SIZE];
949 char *sig;
950 const char *type[] = {NULL, ".set", ".get", NULL, ".other"};
951
952 start = mono_metadata_methods_from_property (m, prop, &end);
953 for (; start < end; ++start) {
954 mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE);
955 if (!should_include_method (cols [MONO_METHOD_SEMA_METHOD]))
956 continue;
957 sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], container, TRUE, FALSE);
958 fprintf (output, "\t\t%s %s\n", type [cols [MONO_METHOD_SEMA_SEMANTICS]], sig);
959 g_free (sig);
960 }
961 }
962 static char*
963 dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *container)
964 {
965 MonoError error;
966 MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY];
967 const char *ptr;
968 guint32 pcount, i;
969 guint32 cols [MONO_PROPERTY_SIZE];
970 MonoType *type;
971 MonoType *param;
972 char *blurb, *qk;
973 const char *name;
974 int prop_flags;
975 GString *res = g_string_new ("");
976
977 mono_metadata_decode_row (propt, prop_idx, cols, MONO_PROPERTY_SIZE);
978 name = mono_metadata_string_heap (m, cols [MONO_PROPERTY_NAME]);
979 prop_flags = cols [MONO_PROPERTY_FLAGS];
980 ptr = mono_metadata_blob_heap (m, cols [MONO_PROPERTY_TYPE]);
981 mono_metadata_decode_blob_size (ptr, &ptr);
982 if (!(*ptr & 0x08))
983 g_warning("incorrect signature in property blob: 0x%x", *ptr);
984 if (*ptr & 0x20)
985 g_string_append (res, "instance ");
986 ptr++;
987 pcount = mono_metadata_decode_value (ptr, &ptr);
988 type = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
989 if (type) {
990 blurb = dis_stringify_type (m, type, TRUE);
991 } else {
992 blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
993 mono_error_cleanup (&error);
994 }
995 if (prop_flags & 0x0200)
996 g_string_append (res, "specialname ");
997 if (prop_flags & 0x0400)
998 g_string_append (res, "rtspecialname ");
999 qk = get_escaped_name (name);
1000 g_string_append_printf (res, "%s %s (", blurb, qk);
1001 g_free (qk);
1002 g_free (blurb);
1003 for (i = 0; i < pcount; i++) {
1004 if (i)
1005 g_string_append (res, ", ");
1006 param = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
1007 if (type) {
1008 blurb = dis_stringify_param (m, param);
1009 } else {
1010 blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
1011 mono_error_cleanup (&error);
1012 }
1013
1014 g_string_append (res, blurb);
1015 g_free (blurb);
1016 }
1017 g_string_append_c (res, ')');
1018 blurb = res->str;
1019 g_string_free (res, FALSE);
1020 return blurb;
1021
1022 }
1023
1024 static void
1025 dis_property_list (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container)
1026 {
1027 guint start, end, i;
1028 start = mono_metadata_properties_from_typedef (m, typedef_row, &end);
1029
1030 for (i = start; i < end; ++i) {
1031 char *sig = dis_property_signature (m, i, container);
1032 fprintf (output, "\t.property %s\n\t{\n", sig);
1033 dump_cattrs (m, MONO_TOKEN_PROPERTY | (i + 1), "\t\t");
1034 dis_property_methods (m, i, container);
1035 fprintf (output, "\t}\n");
1036 g_free (sig);
1037 }
1038 }
1039
1040 static char*
1041 dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContainer *container)
1042 {
1043 MonoTableInfo *et = &m->tables [MONO_TABLE_EVENT];
1044 char *type, *result, *esname;
1045 guint32 cols [MONO_EVENT_SIZE];
1046 int event_flags;
1047 GString *res = g_string_new ("");
1048
1049 mono_metadata_decode_row (et, event_idx, cols, MONO_EVENT_SIZE);
1050 esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_EVENT_NAME]));
1051 type = get_typedef_or_ref (m, cols [MONO_EVENT_TYPE], container);
1052 event_flags = cols [MONO_EVENT_FLAGS];
1053
1054 if (event_flags & 0x0200)
1055 g_string_append (res, "specialname ");
1056 if (event_flags & 0x0400)
1057 g_string_append (res, "rtspecialname ");
1058 g_string_append_printf (res, "%s %s", type, esname);
1059
1060 g_free (type);
1061 g_free (esname);
1062 result = res->str;
1063 g_string_free (res, FALSE);
1064 return result;
1065 }
1066
1067 static void
1068 dis_event_methods (MonoImage *m, guint32 event, MonoGenericContainer *container)
1069 {
1070 guint start, end;
1071 MonoTableInfo *msemt = &m->tables [MONO_TABLE_METHODSEMANTICS];
1072 guint32 cols [MONO_METHOD_SEMA_SIZE];
1073 char *sig;
1074 const char *type = "";
1075
1076 start = mono_metadata_methods_from_event (m, event, &end);
1077 for (; start < end; ++start) {
1078 mono_metadata_decode_row (msemt, start, cols, MONO_METHOD_SEMA_SIZE);
1079 if (!should_include_method (cols [MONO_METHOD_SEMA_METHOD]))
1080 continue;
1081 sig = dis_stringify_method_signature_full (m, NULL, cols [MONO_METHOD_SEMA_METHOD], container, TRUE, FALSE);
1082 switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
1083 case METHOD_SEMANTIC_OTHER:
1084 type = ".other"; break;
1085 case METHOD_SEMANTIC_ADD_ON:
1086 type = ".addon"; break;
1087 case METHOD_SEMANTIC_REMOVE_ON:
1088 type = ".removeon"; break;
1089 case METHOD_SEMANTIC_FIRE:
1090 type = ".fire"; break;
1091 default:
1092 break;
1093 }
1094 fprintf (output, "\t\t%s %s\n", type, sig);
1095 g_free (sig);
1096 }
1097 }
1098
1099 static void
1100 dis_event_list (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container)
1101 {
1102 guint start, end, i;
1103 start = mono_metadata_events_from_typedef (m, typedef_row, &end);
1104
1105 for (i = start; i < end; ++i) {
1106 char *sig = dis_event_signature (m, i, container);
1107 fprintf (output, "\t.event %s\n\t{\n", sig);
1108 dump_cattrs (m, MONO_TOKEN_EVENT | (i + 1), "\t\t");
1109 dis_event_methods (m, i, container);
1110 fprintf (output, "\t}\n");
1111 g_free (sig);
1112 }
1113 }
1114
1115 static void
1116 dis_interfaces (MonoImage *m, guint32 typedef_row, MonoGenericContainer *container)
1117 {
1118 plocator_t loc;
1119 guint start;
1120 gboolean first_interface = 1;
1121 guint32 cols [MONO_INTERFACEIMPL_SIZE];
1122 char *intf;
1123 MonoTableInfo *table = &m->tables [MONO_TABLE_INTERFACEIMPL];
1124
1125 if (!table->base)
1126 return;
1127
1128 loc.t = table;
1129 loc.col_idx = MONO_INTERFACEIMPL_CLASS;
1130 loc.idx = typedef_row;
1131
1132 if (!mono_binary_search (&loc, table->base, table->rows, table->row_size, table_locator))
1133 return;
1134
1135 start = loc.result;
1136 /*
1137 * We may end up in the middle of the rows...
1138 */
1139 while (start > 0) {
1140 if (loc.idx == mono_metadata_decode_row_col (table, start - 1, MONO_INTERFACEIMPL_CLASS))
1141 start--;
1142 else
1143 break;
1144 }
1145 while (start < table->rows) {
1146 mono_metadata_decode_row (table, start, cols, MONO_INTERFACEIMPL_SIZE);
1147 if (cols [MONO_INTERFACEIMPL_CLASS] != loc.idx)
1148 break;
1149 intf = get_typedef_or_ref (m, cols [MONO_INTERFACEIMPL_INTERFACE], container);
1150 if (first_interface) {
1151 fprintf (output, " \timplements %s", intf);
1152 first_interface = 0;
1153 } else {
1154 fprintf (output, ", %s", intf);
1155 }
1156 g_free (intf);
1157 ++start;
1158 }
1159 }
1160
1161 /**
1162 * dis_type:
1163 * @m: metadata context
1164 * @n: index of type to disassemble
1165 * @is_nested: nested type ?
1166 * @forward: forward declarations?
1167 *
1168 * Disassembles the type whose index in the TypeDef table is @n.
1169 */
1170 static void
1171 dis_type (MonoImage *m, int n, int is_nested, int forward)
1172 {
1173 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
1174 guint32 cols [MONO_TYPEDEF_SIZE];
1175 guint32 cols_next [MONO_TYPEDEF_SIZE];
1176 const char *name, *nspace;
1177 char *esname, *param;
1178 MonoGenericContainer *container;
1179 guint32 packing_size, class_size;
1180 gboolean next_is_valid, last;
1181 guint32 nested;
1182
1183 if (!should_include_type (n + 1))
1184 return;
1185 mono_metadata_decode_row (t, n, cols, MONO_TYPEDEF_SIZE);
1186
1187 if (t->rows > n + 1) {
1188 mono_metadata_decode_row (t, n + 1, cols_next, MONO_TYPEDEF_SIZE);
1189 next_is_valid = 1;
1190 } else
1191 next_is_valid = 0;
1192
1193 name = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME]);
1194 nspace = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE]);
1195 if (*nspace && !is_nested) {
1196 char *esnspace;
1197 esnspace = get_escaped_name (nspace);
1198 fprintf (output, ".namespace %s\n{\n", esnspace);
1199 g_free (esnspace);
1200 }
1201
1202 container = mono_metadata_load_generic_params (m, MONO_TOKEN_TYPE_DEF | (n + 1), NULL);
1203 if (container) {
1204 MonoError error;
1205 mono_metadata_load_generic_param_constraints_checked (m, MONO_TOKEN_TYPE_DEF | (n + 1), container, &error);
1206 g_assert (mono_error_ok (&error)); /*FIXME don't swallow the error message*/
1207 }
1208
1209 esname = get_escaped_name (name);
1210 if ((cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_CLASS_SEMANTIC_MASK) == TYPE_ATTRIBUTE_CLASS){
1211 fprintf (output, " .class %s%s", typedef_flags (cols [MONO_TYPEDEF_FLAGS]), esname);
1212
1213 param = get_generic_param (m, container);
1214 if (param) {
1215 fprintf (output, "%s", param);
1216 g_free (param);
1217 }
1218 fprintf (output, "\n");
1219 if (cols [MONO_TYPEDEF_EXTENDS]) {
1220 char *base = get_typedef_or_ref (m, cols [MONO_TYPEDEF_EXTENDS], container);
1221 fprintf (output, " \textends %s\n", base);
1222 g_free (base);
1223 }
1224 } else {
1225 fprintf (output, " .class interface %s%s", typedef_flags (cols [MONO_TYPEDEF_FLAGS]), esname);
1226
1227 param = get_generic_param (m, container);
1228 if (param) {
1229 fprintf (output, "%s", param);
1230 g_free (param);
1231 }
1232 fprintf (output, "\n");
1233 }
1234
1235 g_free (esname);
1236 dis_interfaces (m, n + 1, container);
1237 fprintf (output, " {\n");
1238 if (!forward) {
1239 dump_cattrs (m, MONO_TOKEN_TYPE_DEF | (n + 1), " ");
1240 dump_cattrs_for_type_params (m, MONO_TOKEN_TYPE_DEF | (n + 1), " ");
1241 dump_declarative_security (m, OBJECT_TYPE_TYPEDEF, (n + 1), " ");
1242
1243 if (mono_metadata_packing_from_typedef (m, n + 1, &packing_size, &class_size)) {
1244 fprintf (output, " .pack %d\n", packing_size);
1245 fprintf (output, " .size %d\n", class_size);
1246 }
1247 /*
1248 * The value in the table is always valid, we know we have fields
1249 * if the value stored is different than the next record.
1250 */
1251
1252 if (next_is_valid)
1253 last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
1254 else
1255 last = m->tables [MONO_TABLE_FIELD].rows;
1256
1257 if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= m->tables [MONO_TABLE_FIELD].rows)
1258 dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last, container);
1259 fprintf (output, "\n");
1260
1261 if (next_is_valid)
1262 last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
1263 else
1264 last = m->tables [MONO_TABLE_METHOD].rows;
1265
1266 if (cols [MONO_TYPEDEF_METHOD_LIST] && cols [MONO_TYPEDEF_METHOD_LIST] <= m->tables [MONO_TABLE_METHOD].rows)
1267 dis_method_list (name, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last, container);
1268
1269 dis_property_list (m, n, container);
1270 dis_event_list (m, n, container);
1271 }
1272
1273 t = &m->tables [MONO_TABLE_NESTEDCLASS];
1274 nested = mono_metadata_nesting_typedef (m, n + 1, 1);
1275 while (nested) {
1276 dis_type (m, mono_metadata_decode_row_col (t, nested - 1, MONO_NESTED_CLASS_NESTED) - 1, 1, forward);
1277 nested = mono_metadata_nesting_typedef (m, n + 1, nested + 1);
1278 }
1279
1280 fprintf (output, " } // end of class %s%s%s\n", nspace, *nspace? ".": "", name);
1281 if (*nspace && !is_nested)
1282 fprintf (output, "}\n");
1283 fprintf (output, "\n");
1284 }
1285
1286
1287 /**
1288 * dis_globals
1289 * @m: metadata context
1290 *
1291 * disassembles all the global fields and methods
1292 */
1293 static void
1294 dis_globals (MonoImage *m)
1295 {
1296 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
1297 guint32 cols [MONO_TYPEDEF_SIZE];
1298 guint32 cols_next [MONO_TYPEDEF_SIZE];
1299 gboolean next_is_valid, last;
1300
1301 mono_metadata_decode_row (t, 0, cols, MONO_TYPEDEF_SIZE);
1302
1303 if (t->rows > 1) {
1304 mono_metadata_decode_row (t, 1, cols_next, MONO_TYPEDEF_SIZE);
1305 next_is_valid = 1;
1306 } else
1307 next_is_valid = 0;
1308
1309 /*
1310 * The value in the table is always valid, we know we have fields
1311 * if the value stored is different than the next record.
1312 */
1313
1314 if (next_is_valid)
1315 last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
1316 else
1317 last = m->tables [MONO_TABLE_FIELD].rows;
1318
1319 if (cols [MONO_TYPEDEF_FIELD_LIST] && cols [MONO_TYPEDEF_FIELD_LIST] <= m->tables [MONO_TABLE_FIELD].rows)
1320 dis_field_list (m, cols [MONO_TYPEDEF_FIELD_LIST] - 1, last, NULL);
1321 fprintf (output, "\n");
1322
1323 if (next_is_valid)
1324 last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
1325 else
1326 last = m->tables [MONO_TABLE_METHOD].rows;
1327
1328 if (cols [MONO_TYPEDEF_METHOD_LIST] && cols [MONO_TYPEDEF_METHOD_LIST] <= m->tables [MONO_TABLE_METHOD].rows)
1329 dis_method_list (NULL, m, cols [MONO_TYPEDEF_METHOD_LIST] - 1, last, NULL);
1330
1331 }
1332
1333 static void dis_resources_worker (MonoImage *m, gboolean just_print)
1334 {
1335 MonoTableInfo *t = &m->tables [MONO_TABLE_MANIFESTRESOURCE];
1336 int i;
1337
1338 for (i = 0; i < t->rows; i++){
1339 guint32 cols [MONO_MANIFEST_SIZE];
1340 const char *name, *res;
1341 guint32 size;
1342 FILE* fp;
1343
1344 mono_metadata_decode_row (t, i, cols, MONO_MANIFEST_SIZE);
1345 name = mono_metadata_string_heap (m, cols [MONO_MANIFEST_NAME]);
1346
1347 if (just_print)
1348 fprintf (output, "%8x: %s", cols [MONO_MANIFEST_OFFSET], name);
1349
1350 if (! (res = mono_image_get_resource (m, cols [MONO_MANIFEST_OFFSET], &size))) {
1351 if (just_print)
1352 fprintf (output, " (absent from image)\n");
1353 continue;
1354 }
1355
1356 if (just_print) {
1357 fprintf (output, " (size %u)\n", size);
1358 continue;
1359 }
1360
1361 if ( (fp = fopen (name, "ab")) ) {
1362 if (ftell (fp) == 0)
1363 fwrite (res, size, 1, fp);
1364 else
1365 g_warning ("Error creating managed resource - %s : File already exists.", name);
1366
1367 fclose (fp);
1368 } else
1369 g_warning ("Error creating managed resource - %s : %s", name, g_strerror (errno));
1370 }
1371 }
1372
1373 static void
1374 dis_mresource (MonoImage *m)
1375 {
1376 dis_resources_worker (m, FALSE);
1377 }
1378
1379 static void
1380 dis_presource (MonoImage *m)
1381 {
1382 dis_resources_worker (m, TRUE);
1383 }
1384
1385 static char *
1386 exported_type_flags (guint32 flags)
1387 {
1388 static char buffer [1024];
1389 int visibility = flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
1390
1391 buffer [0] = 0;
1392
1393 if (flags & TYPE_ATTRIBUTE_FORWARDER) {
1394 strcat (buffer, "forwarder ");
1395 return buffer;
1396 }
1397
1398 strcat (buffer, map (visibility, visibility_map));
1399 return buffer;
1400 }
1401
1402 static char *
1403 get_escaped_fullname (MonoImage *m, guint32 nspace_idx, guint32 name_idx)
1404 {
1405 const char *name, *nspace;
1406 char *fullname, *esfullname;
1407
1408 nspace = mono_metadata_string_heap (m, nspace_idx);
1409 name = mono_metadata_string_heap (m, name_idx);
1410
1411 fullname = g_strdup_printf ("%s%s%s", nspace, *nspace ? "." : "", name);
1412 esfullname = get_escaped_name (fullname);
1413
1414 g_free (fullname);
1415
1416 return esfullname;
1417 }
1418
1419 static void
1420 dis_exported_types (MonoImage *m)
1421 {
1422 MonoTableInfo *t = &m->tables [MONO_TABLE_EXPORTEDTYPE];
1423 int i;
1424
1425 for (i = 1; i <= t->rows; i++) {
1426 char *fullname;
1427 guint32 impl, idx, type_token;
1428 guint32 cols [MONO_EXP_TYPE_SIZE];
1429
1430 mono_metadata_decode_row (t, i - 1, cols, MONO_EXP_TYPE_SIZE);
1431
1432 fullname = get_escaped_fullname (m, cols [MONO_EXP_TYPE_NAMESPACE], cols [MONO_EXP_TYPE_NAME]);
1433
1434 fprintf (output, "\n");
1435 fprintf (output, ".class extern %s%s\n", exported_type_flags (cols [MONO_EXP_TYPE_FLAGS]), fullname);
1436 fprintf (output, "{\n");
1437
1438 g_free (fullname);
1439
1440 impl = cols [MONO_EXP_TYPE_IMPLEMENTATION];
1441 if (impl) {
1442 idx = impl >> MONO_IMPLEMENTATION_BITS;
1443 switch (impl & MONO_IMPLEMENTATION_MASK) {
1444 case MONO_IMPLEMENTATION_FILE:
1445 fprintf (output, " .file '%s'\n",
1446 mono_metadata_string_heap (m, mono_metadata_decode_row_col (&m->tables [MONO_TABLE_FILE], idx - 1, MONO_FILE_NAME)));
1447 break;
1448 case MONO_IMPLEMENTATION_ASSEMBLYREF:
1449 fprintf (output, " .assembly extern '%s'\n",
1450 mono_metadata_string_heap (m, mono_metadata_decode_row_col (&m->tables [MONO_TABLE_ASSEMBLYREF], idx - 1, MONO_ASSEMBLYREF_NAME)));
1451 break;
1452 case MONO_IMPLEMENTATION_EXP_TYPE:
1453 fullname = get_escaped_fullname (
1454 m,
1455 mono_metadata_decode_row_col (&m->tables [MONO_TABLE_EXPORTEDTYPE], idx - 1, MONO_EXP_TYPE_NAMESPACE),
1456 mono_metadata_decode_row_col (&m->tables [MONO_TABLE_EXPORTEDTYPE], idx - 1, MONO_EXP_TYPE_NAME));
1457 fprintf (output, " .class extern %s\n", fullname);
1458 g_free (fullname);
1459 break;
1460 default:
1461 g_assert_not_reached ();
1462 break;
1463 }
1464 }
1465
1466 type_token = cols [MONO_EXP_TYPE_TYPEDEF];
1467 if (type_token)
1468 fprintf (output, " .class 0x%08x\n", type_token | MONO_TOKEN_TYPE_DEF);
1469
1470 fprintf (output, "}\n");
1471 }
1472 }
1473
1474 /**
1475 * dis_types:
1476 * @m: metadata context
1477 *
1478 * disassembles all types in the @m context
1479 */
1480 static void
1481 dis_types (MonoImage *m, int forward)
1482 {
1483 MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
1484 int i;
1485 guint32 flags;
1486
1487 dis_globals (m);
1488
1489 for (i = 1; i < t->rows; i++) {
1490 flags = mono_metadata_decode_row_col (t, i, MONO_TYPEDEF_FLAGS);
1491 flags &= TYPE_ATTRIBUTE_VISIBILITY_MASK;
1492 if (flags == TYPE_ATTRIBUTE_PUBLIC || flags == TYPE_ATTRIBUTE_NOT_PUBLIC)
1493 dis_type (m, i, 0, forward);
1494 }
1495 }
1496
1497 static const char *
1498 get_uninitialized_data_type (guint32 size)
1499 {
1500 switch (size) {
1501 case 1:
1502 return "int8";
1503 case 2:
1504 return "int16";
1505 case 4:
1506 return "int32";
1507 case 8:
1508 return "int64";
1509 default:
1510 g_error ("get_uninitialized_data_type for size: %d\n", size);
1511 }
1512 return NULL;
1513 }
1514
1515 /**
1516 * dis_data:
1517 * @m: metadata context
1518 *
1519 * disassembles all data blobs references in the FieldRVA table in the @m context
1520 */
1521 static void
1522 dis_data (MonoImage *m)
1523 {
1524 MonoTableInfo *t = &m->tables [MONO_TABLE_FIELDRVA];
1525 MonoTableInfo *ft = &m->tables [MONO_TABLE_FIELD];
1526 int i, b;
1527 const char *rva, *sig;
1528 guint32 size;
1529 gint align;
1530 guint32 cols [MONO_FIELD_RVA_SIZE];
1531 MonoType *type;
1532
1533 for (i = 0; i < t->rows; i++) {
1534 MonoError error;
1535 mono_metadata_decode_row (t, i, cols, MONO_FIELD_RVA_SIZE);
1536 rva = mono_image_rva_map (m, cols [MONO_FIELD_RVA_RVA]);
1537 sig = mono_metadata_blob_heap (m, mono_metadata_decode_row_col (ft, cols [MONO_FIELD_RVA_FIELD] -1, MONO_FIELD_SIGNATURE));
1538 mono_metadata_decode_value (sig, &sig);
1539 /* FIELD signature == 0x06 */
1540 g_assert (*sig == 0x06);
1541 type = mono_metadata_parse_type_checked (m, NULL, 0, FALSE, sig + 1, &sig, &error);
1542 if (!type) {
1543 fprintf (output, "// invalid field %d due to %s\n", i, mono_error_get_message (&error));
1544 mono_error_cleanup (&error);
1545 continue;
1546 }
1547 mono_class_init (mono_class_from_mono_type (type));
1548 size = mono_type_size (type, &align);
1549
1550 if (rva) {
1551 fprintf (output, ".data D_%08x = bytearray (", cols [MONO_FIELD_RVA_RVA]);
1552 for (b = 0; b < size; ++b) {
1553 if (!(b % 16))
1554 fprintf (output, "\n\t");
1555 fprintf (output, " %02X", rva [b] & 0xff);
1556 }
1557 fprintf (output, ") // size: %d\n", size);
1558 } else
1559 fprintf (output, ".data D_%08x = %s [%d]\n",
1560 cols [MONO_FIELD_RVA_RVA], get_uninitialized_data_type (size), size);
1561 }
1562 }
1563
1564 struct {
1565 const char *name;
1566 int table;
1567 void (*dumper) (MonoImage *m);
1568 } table_list [] = {
1569 { "--assembly", MONO_TABLE_ASSEMBLY, dump_table_assembly },
1570 { "--assemblyref", MONO_TABLE_ASSEMBLYREF, dump_table_assemblyref },
1571 { "--classlayout", MONO_TABLE_CLASSLAYOUT, dump_table_class_layout },
1572 { "--constant", MONO_TABLE_CONSTANT, dump_table_constant },
1573 { "--customattr", MONO_TABLE_CUSTOMATTRIBUTE, dump_table_customattr },
1574 { "--declsec", MONO_TABLE_DECLSECURITY, dump_table_declsec },
1575 { "--event", MONO_TABLE_EVENT, dump_table_event },
1576 { "--exported", MONO_TABLE_EXPORTEDTYPE, dump_table_exported },
1577 { "--fields", MONO_TABLE_FIELD, dump_table_field },
1578 { "--file", MONO_TABLE_FILE, dump_table_file },
1579 { "--genericpar", MONO_TABLE_GENERICPARAM, dump_table_genericpar },
1580 { "--interface", MONO_TABLE_INTERFACEIMPL, dump_table_interfaceimpl },
1581 { "--manifest", MONO_TABLE_MANIFESTRESOURCE, dump_table_manifest },
1582 { "--marshal", MONO_TABLE_FIELDMARSHAL, dump_table_field_marshal },
1583 { "--memberref", MONO_TABLE_MEMBERREF, dump_table_memberref },
1584 { "--method", MONO_TABLE_METHOD, dump_table_method },
1585 { "--methodimpl", MONO_TABLE_METHODIMPL, dump_table_methodimpl },
1586 { "--methodsem", MONO_TABLE_METHODSEMANTICS, dump_table_methodsem },
1587 { "--methodspec", MONO_TABLE_METHODSPEC, dump_table_methodspec },
1588 { "--moduleref", MONO_TABLE_MODULEREF, dump_table_moduleref },
1589 { "--module", MONO_TABLE_MODULE, dump_table_module },
1590 { "--mresources", 0, dis_mresource },
1591 { "--presources", 0, dis_presource },
1592 { "--nested", MONO_TABLE_NESTEDCLASS, dump_table_nestedclass },
1593 { "--param", MONO_TABLE_PARAM, dump_table_param },
1594 { "--parconst", MONO_TABLE_GENERICPARAMCONSTRAINT, dump_table_parconstraint },
1595 { "--property", MONO_TABLE_PROPERTY, dump_table_property },
1596 { "--propertymap", MONO_TABLE_PROPERTYMAP, dump_table_property_map },
1597 { "--typedef", MONO_TABLE_TYPEDEF, dump_table_typedef },
1598 { "--typeref", MONO_TABLE_TYPEREF, dump_table_typeref },
1599 { "--typespec", MONO_TABLE_TYPESPEC, dump_table_typespec },
1600 { "--implmap", MONO_TABLE_IMPLMAP, dump_table_implmap },
1601 { "--fieldrva", MONO_TABLE_FIELDRVA, dump_table_fieldrva },
1602 { "--standalonesig", MONO_TABLE_STANDALONESIG, dump_table_standalonesig },
1603 { "--methodptr", MONO_TABLE_METHOD_POINTER, dump_table_methodptr },
1604 { "--fieldptr", MONO_TABLE_FIELD_POINTER, dump_table_fieldptr },
1605 { "--paramptr", MONO_TABLE_PARAM_POINTER, dump_table_paramptr },
1606 { "--eventptr", MONO_TABLE_EVENT_POINTER, dump_table_eventptr },
1607 { "--propertyptr", MONO_TABLE_PROPERTY_POINTER, dump_table_propertyptr },
1608 { "--blob", 0, dump_stream_blob },
1609 { "--strings", 0, dump_stream_strings },
1610 { "--userstrings", 0, dump_stream_us },
1611 { NULL, -1, }
1612 };
1613
1614 /**
1615 * disassemble_file:
1616 * @file: file containing CIL code.
1617 *
1618 * Disassembles the @file file.
1619 */
1620 static void
1621 disassemble_file (const char *file)
1622 {
1623 MonoImageOpenStatus status;
1624 MonoImage *img;
1625
1626 img = mono_image_open (file, &status);
1627 if (!img) {
1628 fprintf (stderr, "Error while trying to process %s\n", file);
1629 return;
1630 } else {
1631 /* FIXME: is this call necessary? */
1632 mono_assembly_load_from_full (img, file, &status, FALSE);
1633 }
1634
1635 setup_filter (img);
1636
1637 if (dump_table != -1){
1638 (*table_list [dump_table].dumper) (img);
1639 } else {
1640 dump_header_data (img);
1641
1642 dis_directive_assemblyref (img);
1643 dis_directive_assembly (img);
1644 dis_directive_file (img);
1645 dis_directive_mresource (img);
1646 dis_directive_module (img);
1647 dis_directive_moduleref (img);
1648 dis_exported_types (img);
1649 dis_nt_header (img);
1650 if (dump_managed_resources)
1651 dis_mresource (img);
1652 if (dump_forward_decls) {
1653 fprintf (output, "// *************** Forward Declarations for Classes ***************\n\n");
1654 dis_types (img, 1);
1655 fprintf (output, "// *************** End-Of Forward Declarations for Classes ***************\n\n");
1656 }
1657 dis_types (img, 0);
1658 dis_data (img);
1659 }
1660
1661 mono_image_close (img);
1662 }
1663
1664 typedef struct {
1665 int size;
1666 int count;
1667 int *elems;
1668 } TableFilter;
1669
1670 typedef struct {
1671 char *name;
1672 char *guid;
1673 TableFilter types;
1674 TableFilter fields;
1675 TableFilter methods;
1676 } ImageFilter;
1677
1678 static GList *filter_list = NULL;
1679 static ImageFilter *cur_filter = NULL;
1680
1681 static void
1682 setup_filter (MonoImage *image)
1683 {
1684 ImageFilter *ifilter;
1685 GList *item;
1686 const char *name = mono_image_get_name (image);
1687
1688 for (item = filter_list; item; item = item->next) {
1689 ifilter = (ImageFilter *)item->data;
1690 if (strcmp (ifilter->name, name) == 0) {
1691 cur_filter = ifilter;
1692 return;
1693 }
1694 }
1695 cur_filter = NULL;
1696 }
1697
1698 static int
1699 int_cmp (const void *e1, const void *e2)
1700 {
1701 const int *i1 = (const int *)e1;
1702 const int *i2 = (const int *)e2;
1703 return *i1 - *i2;
1704 }
1705
1706 static gboolean
1707 table_includes (TableFilter *tf, int idx)
1708 {
1709 if (!tf->count)
1710 return FALSE;
1711 return mono_binary_search (&idx, tf->elems, tf->count, sizeof (int), int_cmp) != NULL;
1712 }
1713
1714 static gboolean
1715 should_include_type (int idx)
1716 {
1717 if (!cur_filter)
1718 return TRUE;
1719 return table_includes (&cur_filter->types, idx);
1720 }
1721
1722 static gboolean
1723 should_include_method (int idx)
1724 {
1725 if (!cur_filter)
1726 return TRUE;
1727 return table_includes (&cur_filter->methods, idx);
1728 }
1729
1730 static gboolean
1731 should_include_field (int idx)
1732 {
1733 if (!cur_filter)
1734 return TRUE;
1735 return table_includes (&cur_filter->fields, idx);
1736 }
1737
1738 static ImageFilter*
1739 add_filter (const char *name)
1740 {
1741 ImageFilter *ifilter;
1742 GList *item;
1743
1744 for (item = filter_list; item; item = item->next) {
1745 ifilter = (ImageFilter *)item->data;
1746 if (strcmp (ifilter->name, name) == 0)
1747 return ifilter;
1748 }
1749 ifilter = g_new0 (ImageFilter, 1);
1750 ifilter->name = g_strdup (name);
1751 filter_list = g_list_prepend (filter_list, ifilter);
1752 return ifilter;
1753 }
1754
1755 static void
1756 add_item (TableFilter *tf, int val)
1757 {
1758 if (tf->count >= tf->size) {
1759 if (!tf->size) {
1760 tf->size = 8;
1761 tf->elems = (int *)g_malloc (sizeof (int) * tf->size);
1762 } else {
1763 tf->size *= 2;
1764 tf->elems = (int *)g_realloc (tf->elems, sizeof (int) * tf->size);
1765 }
1766 }
1767 tf->elems [tf->count++] = val;
1768 }
1769
1770 static void
1771 sort_filter_elems (void)
1772 {
1773 ImageFilter *ifilter;
1774 GList *item;
1775
1776 for (item = filter_list; item; item = item->next) {
1777 ifilter = (ImageFilter *)item->data;
1778 qsort (ifilter->types.elems, ifilter->types.count, sizeof (int), int_cmp);
1779 qsort (ifilter->fields.elems, ifilter->fields.count, sizeof (int), int_cmp);
1780 qsort (ifilter->methods.elems, ifilter->methods.count, sizeof (int), int_cmp);
1781 }
1782 }
1783
1784 static void
1785 load_filter (const char* filename)
1786 {
1787 FILE *file;
1788 char buf [1024];
1789 char *p, *s, *endptr;
1790 int line = 0;
1791 ImageFilter *ifilter = NULL;
1792 int value = 0;
1793
1794 if (!(file = fopen (filename, "r"))) {
1795 g_print ("Cannot open filter file '%s'\n", filename);
1796 exit (1);
1797 }
1798 while (fgets (buf, sizeof (buf), file) != NULL) {
1799 ++line;
1800 s = buf;
1801 while (*s && g_ascii_isspace (*s)) ++s;
1802 switch (*s) {
1803 case 0:
1804 case '#':
1805 break;
1806 case '[':
1807 p = strchr (s, ']');
1808 if (!p)
1809 g_error ("No matching ']' in filter at line %d\n", line);
1810 *p = 0;
1811 ifilter = add_filter (s + 1);
1812 break;
1813 case 'T':
1814 if (!ifilter)
1815 g_error ("Invalid format in filter at line %d\n", line);
1816 if ((s [1] != ':') || !(value = strtol (s + 2, &endptr, 0)) || (endptr == s + 2))
1817 g_error ("Invalid type number in filter at line %d\n", line);
1818 add_item (&ifilter->types, value);
1819 break;
1820 case 'M':
1821 if (!ifilter)
1822 g_error ("Invalid format in filter at line %d\n", line);
1823 if ((s [1] != ':') || !(value = strtol (s + 2, &endptr, 0)) || (endptr == s + 2))
1824 g_error ("Invalid method number in filter at line %d\n", line);
1825 add_item (&ifilter->methods, value);
1826 break;
1827 case 'F':
1828 if (!ifilter)
1829 g_error ("Invalid format in filter at line %d\n", line);
1830 if ((s [1] != ':') || !(value = strtol (s + 2, &endptr, 0)) || (endptr == s + 2))
1831 g_error ("Invalid field number in filter at line %d\n", line);
1832 add_item (&ifilter->fields, value);
1833 break;
1834 default:
1835 g_error ("Invalid format in filter at line %d\n", line);
1836 }
1837 }
1838 fclose (file);
1839 sort_filter_elems ();
1840 }
1841
1842
1843 static gboolean
1844 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
1845 const gchar *path3, const gchar *path4, gboolean refonly)
1846 {
1847 gchar *fullpath;
1848
1849 *assembly = NULL;
1850 fullpath = g_build_filename (path1, path2, path3, path4, NULL);
1851 if (g_file_test (fullpath, G_FILE_TEST_IS_REGULAR))
1852 *assembly = mono_assembly_open_full (fullpath, NULL, refonly);
1853
1854 g_free (fullpath);
1855 return (*assembly != NULL);
1856 }
1857
1858 static MonoAssembly *
1859 real_load (gchar **search_path, const gchar *culture, const gchar *name, gboolean refonly)
1860 {
1861 MonoAssembly *result = NULL;
1862 gchar **path;
1863 gchar *filename;
1864 const gchar *local_culture;
1865 gint len;
1866
1867 if (!culture || *culture == '\0') {
1868 local_culture = "";
1869 } else {
1870 local_culture = culture;
1871 }
1872
1873 filename = g_strconcat (name, ".dll", NULL);
1874 len = strlen (filename);
1875
1876 for (path = search_path; *path; path++) {
1877 if (**path == '\0')
1878 continue; /* Ignore empty ApplicationBase */
1879
1880 /* See test cases in bug #58992 and bug #57710 */
1881 /* 1st try: [culture]/[name].dll (culture may be empty) */
1882 strcpy (filename + len - 4, ".dll");
1883 if (try_load_from (&result, *path, local_culture, "", filename, refonly))
1884 break;
1885
1886 /* 2nd try: [culture]/[name].exe (culture may be empty) */
1887 strcpy (filename + len - 4, ".exe");
1888 if (try_load_from (&result, *path, local_culture, "", filename, refonly))
1889 break;
1890
1891 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
1892 strcpy (filename + len - 4, ".dll");
1893 if (try_load_from (&result, *path, local_culture, name, filename, refonly))
1894 break;
1895
1896 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
1897 strcpy (filename + len - 4, ".exe");
1898 if (try_load_from (&result, *path, local_culture, name, filename, refonly))
1899 break;
1900 }
1901
1902 g_free (filename);
1903 return result;
1904 }
1905
1906 /*
1907 * Try to load referenced assemblies from assemblies_path.
1908 */
1909 static MonoAssembly *
1910 monodis_preload (MonoAssemblyName *aname,
1911 gchar **assemblies_path,
1912 gpointer user_data)
1913 {
1914 MonoAssembly *result = NULL;
1915 gboolean refonly = GPOINTER_TO_UINT (user_data);
1916
1917 if (assemblies_path && assemblies_path [0] != NULL) {
1918 result = real_load (assemblies_path, aname->culture, aname->name, refonly);
1919 }
1920
1921 return result;
1922 }
1923
1924 static GList *loaded_assemblies = NULL;
1925
1926 static void
1927 monodis_assembly_load_hook (MonoAssembly *assembly, gpointer user_data)
1928 {
1929 loaded_assemblies = g_list_prepend (loaded_assemblies, assembly);
1930 }
1931
1932 static MonoAssembly *
1933 monodis_assembly_search_hook (MonoAssemblyName *aname, gpointer user_data)
1934 {
1935 GList *tmp;
1936
1937 for (tmp = loaded_assemblies; tmp; tmp = tmp->next) {
1938 MonoAssembly *ass = (MonoAssembly *)tmp->data;
1939 if (mono_assembly_names_equal (aname, &ass->aname))
1940 return ass;
1941 }
1942 return NULL;
1943 }
1944
1945 static void
1946 usage (void)
1947 {
1948 GString *args = g_string_new ("[--output=filename] [--filter=filename] [--help] [--mscorlib]\n");
1949 int i;
1950
1951 for (i = 0; table_list [i].name != NULL; i++){
1952 g_string_append (args, "[");
1953 g_string_append (args, table_list [i].name);
1954 g_string_append (args, "] ");
1955 if (((i-2) % 5) == 0)
1956 g_string_append_c (args, '\n');
1957 }
1958 g_string_append (args, "[--forward-decls]");
1959 fprintf (stderr,
1960 "monodis -- Mono Common Intermediate Language Disassembler\n"
1961 "Usage is: monodis %s file ..\n", args->str);
1962 exit (1);
1963 }
1964
1965 int
1966 main (int argc, char *argv [])
1967 {
1968 GList *input_files = NULL, *l;
1969 int i, j;
1970
1971 output = stdout;
1972 init_key_table ();
1973 for (i = 1; i < argc; i++){
1974 if (argv [i][0] == '-'){
1975 if (argv [i][1] == 'h')
1976 usage ();
1977 else if (argv [i][1] == 'd')
1978 dump_header_data_p = TRUE;
1979 else if (strcmp (argv [i], "--mscorlib") == 0) {
1980 substitute_with_mscorlib_p = TRUE;
1981 continue;
1982 } else if (strcmp (argv [i], "--show-method-tokens") == 0) {
1983 show_method_tokens = TRUE;
1984 continue;
1985 } else if (strcmp (argv [i], "--show-tokens") == 0) {
1986 show_tokens = TRUE;
1987 continue;
1988 } else if (strncmp (argv [i], "--output=", 9) == 0) {
1989 output = fopen (argv [i]+9, "w");
1990 if (output == NULL) {
1991 fprintf (stderr, "Can't open output file `%s': %s\n",
1992 argv [i]+9, strerror (errno));
1993 exit (1);
1994 }
1995 dump_managed_resources = TRUE;
1996 continue;
1997 } else if (strncmp (argv [i], "--filter=", 9) == 0) {
1998 load_filter (argv [i]+9);
1999 continue;
2000 } else if (strcmp (argv [i], "--forward-decls") == 0) {
2001 dump_forward_decls = TRUE;
2002 continue;
2003 } else if (strcmp (argv [i], "--help") == 0)
2004 usage ();
2005 for (j = 0; table_list [j].name != NULL; j++) {
2006 if (strcmp (argv [i], table_list [j].name) == 0)
2007 dump_table = j;
2008 }
2009 if (dump_table < 0)
2010 usage ();
2011 } else
2012 input_files = g_list_append (input_files, argv [i]);
2013 }
2014
2015 if (input_files == NULL)
2016 usage ();
2017
2018 mono_install_assembly_load_hook (monodis_assembly_load_hook, NULL);
2019 mono_install_assembly_search_hook (monodis_assembly_search_hook, NULL);
2020
2021 /*
2022 * If we just have one file, use the corlib version it requires.
2023 */
2024 if (!input_files->next) {
2025 char *filename = (char *)input_files->data;
2026
2027 mono_init_from_assembly (argv [0], filename);
2028
2029 mono_install_assembly_preload_hook (monodis_preload, GUINT_TO_POINTER (FALSE));
2030
2031 disassemble_file (filename);
2032 } else {
2033 mono_init (argv [0]);
2034
2035 for (l = input_files; l; l = l->next)
2036 disassemble_file ((const char *)l->data);
2037 }
2038
2039 return 0;
2040 }
Mirror of the official Mono project git repository