3 #include "mono/metadata/class.h"
4 #include "mono/metadata/assembly.h"
5 #include "mono/metadata/tokentype.h"
6 #include "mono/metadata/opcodes.h"
7 #include "mono/metadata/tabledefs.h"
8 #include "mono/metadata/mono-endian.h"
9 #include "mono/metadata/appdomain.h" /* mono_init */
10 #include "mono/metadata/debug-helpers.h"
13 static int include_namespace = 0;
14 static int max_depth = 6;
15 static int verbose = 0;
16 static const char *graph_properties = "\tnode [fontsize=8.0]\n\tedge [len=2,color=red]\n";
19 output_type_edge (MonoClass *first, MonoClass *second) {
20 if (include_namespace)
21 fprintf (output, "\t\"%s.%s\" -> \"%s.%s\"\n", first->name_space, first->name, second->name_space, second->name);
23 fprintf (output, "\t\"%s\" -> \"%s\"\n", first->name, second->name);
27 print_subtypes (MonoImage *image, MonoClass *class, int depth) {
32 if (depth++ > max_depth)
35 t = &image->tables [MONO_TABLE_TYPEDEF];
37 token = mono_metadata_token_index (class->type_token);
38 token <<= TYPEDEFORREF_BITS;
39 token |= TYPEDEFORREF_TYPEDEF;
42 for (i = 0; i < t->rows; ++i) {
43 if (token == mono_metadata_decode_row_col (t, i, MONO_TYPEDEF_EXTENDS)) {
44 child = mono_class_get (image, MONO_TOKEN_TYPE_DEF | (i + 1));
45 output_type_edge (class, child);
46 print_subtypes (image, child, depth);
52 type_graph (MonoImage *image, const char* cname) {
56 const char *name_space;
60 cname = g_strdup (cname);
61 p = strrchr (cname, '.');
69 class = mono_class_from_name (image, name_space, cname);
71 g_print ("class %s.%s not found\n", name_space, cname);
74 fprintf (output, "digraph blah {\n");
75 fprintf (output, "%s", graph_properties);
77 /* go back and print the parents for the node as well: not sure it's a good idea */
78 for (parent = class->parent; parent; parent = parent->parent) {
79 output_type_edge (parent, child);
82 print_subtypes (image, class, depth);
83 fprintf (output, "}\n");
87 interface_graph (MonoImage *image, const char* cname) {
90 const char *name_space;
92 guint32 cols [MONO_INTERFACEIMPL_SIZE];
93 guint32 token, i, count = 0;
94 MonoTableInfo *intf = &image->tables [MONO_TABLE_INTERFACEIMPL];
96 cname = g_strdup (cname);
97 p = strrchr (cname, '.');
105 class = mono_class_from_name (image, name_space, cname);
107 g_print ("interface %s.%s not found\n", name_space, cname);
110 /* chek if it's really an interface... */
111 fprintf (output, "digraph interface {\n");
112 fprintf (output, "%s", graph_properties);
113 /* TODO: handle inetrface defined in one image and class defined in another. */
114 token = mono_metadata_token_index (class->type_token);
115 token <<= TYPEDEFORREF_BITS;
116 token |= TYPEDEFORREF_TYPEDEF;
117 for (i = 0; i < intf->rows; ++i) {
118 mono_metadata_decode_row (intf, i, cols, MONO_INTERFACEIMPL_SIZE);
119 /*g_print ("index: %d [%d implements %d]\n", index, cols [MONO_INTERFACEIMPL_CLASS], cols [MONO_INTERFACEIMPL_INTERFACE]);*/
120 if (token == cols [MONO_INTERFACEIMPL_INTERFACE]) {
121 child = mono_class_get (image, MONO_TOKEN_TYPE_DEF | cols [MONO_INTERFACEIMPL_CLASS]);
122 output_type_edge (class, child);
126 fprintf (output, "}\n");
127 if (verbose && !count)
128 g_print ("No class implements %s.%s\n", class->name_space, class->name);
132 static int back_branch_waste = 0;
133 static int branch_waste = 0;
134 static int var_waste = 0;
135 static int int_waste = 0;
136 static int nop_waste = 0;
137 static int has_exceptions = 0;
138 static int num_exceptions = 0;
139 static int max_exceptions = 0;
140 static int has_locals = 0;
141 static int num_locals = 0;
142 static int max_locals = 0;
143 static int has_args = 0;
144 static int num_args = 0;
145 static int max_args = 0;
146 static int has_maxstack = 0;
147 static int num_maxstack = 0;
148 static int max_maxstack = 0;
149 static int has_code = 0;
150 static int num_code = 0;
151 static int max_code = 0;
152 static int has_branch = 0;
153 static int num_branch = 0;
154 static int max_branch = 0;
155 static int has_condbranch = 0;
156 static int num_condbranch = 0;
157 static int max_condbranch = 0;
158 static int has_calls = 0;
159 static int num_calls = 0;
160 static int max_calls = 0;
161 static int has_throw = 0;
162 static int num_throw = 0;
163 static int max_throw = 0;
164 static int has_switch = 0;
165 static int num_switch = 0;
166 static int max_switch = 0;
167 static int cast_sealed = 0;
168 static int cast_iface = 0;
169 static int total_cast = 0;
170 static int nonvirt_callvirt = 0;
171 static int total_callvirt = 0;
174 method_stats (MonoMethod *method) {
175 const MonoOpcode *opcode;
176 MonoMethodHeader *header;
177 const unsigned char *ip;
179 int local_branch = 0, local_condbranch = 0, local_throw = 0, local_calls = 0;
182 if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME))
184 if (method->flags & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT))
187 header = ((MonoMethodNormal *)method)->header;
188 if (header->num_clauses)
190 num_exceptions += header->num_clauses;
191 if (max_exceptions < header->num_clauses)
192 max_exceptions = header->num_clauses;
193 if (header->num_locals)
195 num_locals += header->num_locals;
196 if (max_locals < header->num_locals)
197 max_locals = header->num_locals;
199 if (max_maxstack < header->max_stack)
200 max_maxstack = header->max_stack;
201 num_maxstack += header->max_stack;
202 if (header->max_stack != 8) /* just a guess */
205 n = method->signature->hasthis + method->signature->param_count;
213 if (max_code < header->code_size)
214 max_code = header->code_size;
215 num_code += header->code_size;
219 while (ip < (header->code + header->code_size)) {
227 opcode = &mono_opcodes [i];
229 switch (opcode->argument) {
231 if (i == MONO_CEE_NOP)
237 if (n >= -1 && n <= 8) {
239 g_print ("%s %d\n", mono_opcode_names [i], n);
240 } else if (n < 128 && n >= -128) {
242 g_print ("%s %d\n", mono_opcode_names [i], n);
247 if (i == MONO_CEE_CASTCLASS || i == MONO_CEE_ISINST) {
248 guint32 token = read32 (ip + 1);
249 MonoClass *k = mono_class_get (method->klass->image, token);
250 if (k && k->flags & TYPE_ATTRIBUTE_SEALED)
252 if (k && k->flags & TYPE_ATTRIBUTE_INTERFACE)
258 case MonoInlineField:
260 case MonoInlineString:
262 case MonoShortInlineR:
265 case MonoInlineBrTarget:
267 if (n < 128 && n >= -128) {
270 back_branch_waste += 3;
283 g_print ("%s %d\n", mono_opcode_names [i], n);
287 g_print ("%s %d\n", mono_opcode_names [i], n);
292 g_print ("%s %d\n", mono_opcode_names [i], n);
297 case MonoShortInlineVar:
298 if ((signed char)ip [1] < 4 && (signed char)ip [1] >= 0) {
300 case MONO_CEE_LDARG_S:
301 case MONO_CEE_LDLOC_S:
302 case MONO_CEE_STLOC_S:
304 g_print ("%s %d\n", mono_opcode_names [i], (signed char)ip [1]);
312 case MonoShortInlineI:
313 if ((signed char)ip [1] <= 8 && (signed char)ip [1] >= -1) {
314 g_print ("%s %d\n", mono_opcode_names [i], (signed char)ip [1]);
319 case MonoShortInlineBrTarget:
322 case MonoInlineSwitch: {
339 /* should load and convert */
340 if (l >= -1 && l <= 8) {
342 } else if (l < 128 && l >= -128) {
344 } else if (l <= 2147483647 && l >= (-2147483647 -1)) {
349 case MonoInlineMethod:
350 if (i == MONO_CEE_CALLVIRT) {
351 MonoMethod *cm = mono_get_method (method->klass->image, read32 (ip + 1), NULL);
352 if (cm && !(cm->flags & METHOD_ATTRIBUTE_VIRTUAL))
359 g_assert_not_reached ();
362 switch (opcode->flow_type) {
363 case MONO_FLOW_BRANCH:
366 case MONO_FLOW_COND_BRANCH:
372 case MONO_FLOW_ERROR:
380 if (max_branch < local_branch)
381 max_branch = local_branch;
382 num_branch += local_branch;
384 if (local_condbranch)
386 if (max_condbranch < local_condbranch)
387 max_condbranch = local_condbranch;
388 num_condbranch += local_condbranch;
392 if (max_calls < local_calls)
393 max_calls = local_calls;
394 num_calls += local_calls;
398 if (max_throw < local_throw)
399 max_throw = local_throw;
400 num_throw += local_throw;
405 static int num_pdepth = 0;
406 static int max_pdepth = 0;
407 static int num_ifaces = 0;
410 type_stats (MonoClass *klass) {
414 if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
418 parent = klass->parent;
421 parent = parent->parent;
424 if (max_pdepth < depth)
429 stats (MonoImage *image, const char *name) {
430 int i, num_methods, num_types;
434 for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
435 method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
436 method_stats (method);
438 num_methods = image->tables [MONO_TABLE_METHOD].rows;
439 for (i = 0; i < image->tables [MONO_TABLE_TYPEDEF].rows; ++i) {
440 klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | (i + 1));
443 num_types = image->tables [MONO_TABLE_TYPEDEF].rows;
445 g_print ("Methods and code stats:\n");
446 g_print ("back branch waste: %d\n", back_branch_waste);
447 g_print ("branch waste: %d\n", branch_waste);
448 g_print ("var waste: %d\n", var_waste);
449 g_print ("int waste: %d\n", int_waste);
450 g_print ("nop waste: %d\n", nop_waste);
451 g_print ("has exceptions: %d/%d, total: %d, max: %d, mean: %f\n", has_exceptions, num_methods, num_exceptions, max_exceptions, num_exceptions/(double)has_exceptions);
452 g_print ("has locals: %d/%d, total: %d, max: %d, mean: %f\n", has_locals, num_methods, num_locals, max_locals, num_locals/(double)has_locals);
453 g_print ("has args: %d/%d, total: %d, max: %d, mean: %f\n", has_args, num_methods, num_args, max_args, num_args/(double)has_args);
454 g_print ("has maxstack: %d/%d, total: %d, max: %d, mean: %f\n", has_maxstack, num_methods, num_maxstack, max_maxstack, num_maxstack/(double)i);
455 g_print ("has code: %d/%d, total: %d, max: %d, mean: %f\n", has_code, num_methods, num_code, max_code, num_code/(double)has_code);
456 g_print ("has branch: %d/%d, total: %d, max: %d, mean: %f\n", has_branch, num_methods, num_branch, max_branch, num_branch/(double)has_branch);
457 g_print ("has condbranch: %d/%d, total: %d, max: %d, mean: %f\n", has_condbranch, num_methods, num_condbranch, max_condbranch, num_condbranch/(double)has_condbranch);
458 g_print ("has switch: %d/%d, total: %d, max: %d, mean: %f\n", has_switch, num_methods, num_switch, max_switch, num_switch/(double)has_switch);
459 g_print ("has calls: %d/%d, total: %d, max: %d, mean: %f\n", has_calls, num_methods, num_calls, max_calls, num_calls/(double)has_calls);
460 g_print ("has throw: %d/%d, total: %d, max: %d, mean: %f\n", has_throw, num_methods, num_throw, max_throw, num_throw/(double)has_throw);
461 g_print ("sealed type cast: %d/%d\n", cast_sealed, total_cast);
462 g_print ("interface type cast: %d/%d\n", cast_iface, total_cast);
463 g_print ("non virtual callvirt: %d/%d\n", nonvirt_callvirt, total_callvirt);
465 g_print ("\nType stats:\n");
466 g_print ("interface types: %d/%d\n", num_ifaces, num_types);
467 g_print ("parent depth: max: %d, mean: %d\n", max_pdepth, num_pdepth/(num_types - num_ifaces));
471 get_signature (MonoMethod *method) {
473 static GHashTable *hash = NULL;
477 hash = g_hash_table_new (g_direct_hash, g_direct_equal);
478 if ((result = g_hash_table_lookup (hash, method)))
481 res = g_string_new ("");
482 if (include_namespace && *(method->klass->name_space))
483 g_string_sprintfa (res, "%s.", method->klass->name_space);
484 result = mono_signature_get_desc (method->signature, include_namespace);
485 g_string_sprintfa (res, "%s:%s(%s)", method->klass->name, method->name, result);
487 g_hash_table_insert (hash, method, res->str);
490 g_string_free (res, FALSE);
496 output_method_edge (MonoMethod *first, MonoMethod *second) {
497 char * f = get_signature (first);
498 char * s = get_signature (second);
500 fprintf (output, "\t\"%s\" -> \"%s\"\n", f, s);
504 * We need to handle virtual calls is derived types.
505 * We could check what types implement the method and
506 * disassemble all of them: this can make the graph to explode.
507 * We could try and keep track of the 'this' pointer type and
508 * consider only the methods in the classes derived from that:
509 * this can reduce the graph complexity somewhat (and it would
510 * be the more correct approach).
513 print_method (MonoMethod *method, int depth) {
514 const MonoOpcode *opcode;
515 MonoMethodHeader *header;
517 const unsigned char *ip;
520 if (depth++ > max_depth)
522 if (method->info) /* avoid recursion */
524 method->info = method;
526 if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME))
528 if (method->flags & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT))
531 header = ((MonoMethodNormal *)method)->header;
534 hash = g_hash_table_new (g_direct_hash, g_direct_equal);
536 while (ip < (header->code + header->code_size)) {
544 opcode = &mono_opcodes [i];
546 switch (opcode->argument) {
551 case MonoInlineField:
553 case MonoInlineString:
555 case MonoShortInlineR:
557 case MonoInlineBrTarget:
563 case MonoShortInlineVar:
564 case MonoShortInlineI:
565 case MonoShortInlineBrTarget:
568 case MonoInlineSwitch: {
580 case MonoInlineMethod: {
586 called = mono_get_method (method->klass->image, token, NULL);
589 if (g_hash_table_lookup (hash, called))
591 g_hash_table_insert (hash, called, called);
592 output_method_edge (method, called);
593 print_method (called, depth);
597 g_assert_not_reached ();
600 g_hash_table_destroy (hash);
604 method_graph (MonoImage *image, const char *name) {
606 MonoMethod *method = NULL;
609 guint32 token = mono_image_get_entry_point (image);
610 if (!token || !(method = mono_get_method (image, token, NULL))) {
611 g_print ("Cannot find entry point in %s: specify an explict method name.\n", image->name);
615 /* search the method */
616 MonoMethodDesc *desc;
618 desc = mono_method_desc_new (name, include_namespace);
620 g_print ("Invalid method name %s\n", name);
623 method = mono_method_desc_search_in_image (desc, image);
625 g_print ("Cannot find method %s\n", name);
629 fprintf (output, "digraph blah {\n");
630 fprintf (output, "%s", graph_properties);
632 print_method (method, depth);
634 fprintf (output, "}\n");
637 typedef struct MonoBasicBlock MonoBasicBlock;
639 struct MonoBasicBlock {
640 const unsigned char* cil_code;
647 static const unsigned char *debug_start;
650 link_bblock (MonoBasicBlock *from, MonoBasicBlock* to)
652 from->out_bb = g_list_prepend (from->out_bb, to);
653 to->in_bb = g_list_prepend (to->in_bb, from);
654 /*fprintf (stderr, "linking IL_%04x to IL_%04x\n", from->cil_code-debug_start, to->cil_code-debug_start);*/
658 compare_bblock (const void *a, const void *b)
660 MonoBasicBlock * const *ab = a;
661 MonoBasicBlock * const *bb = b;
663 return (*ab)->cil_code - (*bb)->cil_code;
667 mono_method_find_bblocks (MonoMethodHeader *header)
669 const unsigned char *ip, *end, *start;
670 const MonoOpcode *opcode;
671 int i, block_end = 0;
672 GPtrArray *result = g_ptr_array_new ();
673 GHashTable *table = g_hash_table_new (g_direct_hash, g_direct_equal);
674 MonoBasicBlock *entry_bb, *end_bb, *bb, *target;
677 end = ip + header->code_size;
680 entry_bb = g_new0 (MonoBasicBlock, 1);
681 end_bb = g_new0 (MonoBasicBlock, 1);
682 g_ptr_array_add (result, entry_bb);
683 g_ptr_array_add (result, end_bb);
685 bb = g_new0 (MonoBasicBlock, 1);
687 g_ptr_array_add (result, bb);
688 link_bblock (entry_bb, bb);
689 g_hash_table_insert (table, (char*)ip, bb);
692 /* handle exception code blocks... */
695 if ((target = g_hash_table_lookup (table, ip)) && target != bb) {
697 link_bblock (bb, target);
702 /*fprintf (stderr, "processing bbclok at IL_%04x\n", ip - header->code);*/
703 if (!(bb = g_hash_table_lookup (table, ip))) {
704 bb = g_new0 (MonoBasicBlock, 1);
706 g_ptr_array_add (result, bb);
707 g_hash_table_insert (table, (char*)ip, bb);
718 opcode = &mono_opcodes [i];
719 switch (opcode->flow_type) {
720 case MONO_FLOW_RETURN:
721 link_bblock (bb, end_bb);
722 case MONO_FLOW_ERROR:
725 case MONO_FLOW_BRANCH: /* we handle branch when checking the argument type */
726 case MONO_FLOW_COND_BRANCH:
732 g_assert_not_reached ();
734 switch (opcode->argument) {
739 case MonoInlineField:
740 case MonoInlineMethod:
742 case MonoInlineString:
744 case MonoShortInlineR:
751 case MonoShortInlineVar:
752 case MonoShortInlineI:
755 case MonoShortInlineBrTarget:
756 case MonoInlineBrTarget:
758 if (opcode->argument == MonoShortInlineBrTarget) {
759 i = (signed char)*ip;
762 i = (gint32) read32 (ip);
765 if (opcode->flow_type == MONO_FLOW_COND_BRANCH) {
766 if (!(target = g_hash_table_lookup (table, ip))) {
767 target = g_new0 (MonoBasicBlock, 1);
768 target->cil_code = ip;
769 g_ptr_array_add (result, target);
770 g_hash_table_insert (table, (char*)ip, target);
772 link_bblock (bb, target);
774 if (!(target = g_hash_table_lookup (table, ip + i))) {
775 target = g_new0 (MonoBasicBlock, 1);
776 target->cil_code = ip + i;
777 g_ptr_array_add (result, target);
778 g_hash_table_insert (table, (char*)ip + i, target);
780 link_bblock (bb, target);
783 case MonoInlineSwitch: {
785 const char *itarget, *st;
789 st = (const char*)ip + 4 * n;
791 for (i = 0; i < n; i++) {
792 itarget = st + read32 (ip);
794 if (!(target = g_hash_table_lookup (table, itarget))) {
795 target = g_new0 (MonoBasicBlock, 1);
796 target->cil_code = itarget;
797 g_ptr_array_add (result, target);
798 g_hash_table_insert (table, (gpointer) itarget, target);
800 link_bblock (bb, target);
803 * Note: the code didn't set block_end in switch.
812 g_assert_not_reached ();
816 g_hash_table_destroy (table);
817 qsort (result->pdata, result->len, sizeof (gpointer), compare_bblock);
818 /* skip entry and end */
820 for (i = 2; i < result->len; ++i) {
821 bb = (MonoBasicBlock*)g_ptr_array_index (result, i);
823 target->cil_length = bb->cil_code - target->cil_code;
825 /*fprintf (stderr, "bblock %d at IL_%04x:\n", i, bb->cil_code - header->code);*/
827 bb->cil_length = header->code + header->code_size - bb->cil_code;
832 indenter (MonoDisHelper *dh, MonoMethod *method, guint32 ip_offset)
834 return g_strdup (" ");
837 static MonoDisHelper graph_dh = {
847 df_visit (MonoBasicBlock *bb, int *dfn, const unsigned char* code)
850 MonoBasicBlock *next;
856 for (tmp = bb->out_bb; tmp; tmp = tmp->next) {
860 fprintf (output, "\t\"DF entry\" -> \"IL_%04x (%d)\"\n", next->cil_code - code, *dfn + 1);
862 fprintf (output, "\t\"IL_%04x (%d)\" -> \"IL_%04x (%d)\"\n", bb->cil_code - code, bb->dfn, next->cil_code - code, *dfn + 1);
863 df_visit (next, dfn, code);
869 print_method_cfg (MonoMethod *method) {
872 MonoBasicBlock *bb, *target;
873 MonoMethodHeader *header;
877 header = ((MonoMethodNormal*)method)->header;
878 bblocks = mono_method_find_bblocks (header);
879 for (i = 0; i < bblocks->len; ++i) {
880 bb = (MonoBasicBlock*)g_ptr_array_index (bblocks, i);
882 fprintf (output, "\tB%p [shape=record,label=\"entry\"]\n", bb);
884 fprintf (output, "\tB%p [shape=record,label=\"end\"]\n", bb);
886 code = mono_disasm_code (&graph_dh, method, bb->cil_code, bb->cil_code + bb->cil_length);
887 fprintf (output, "\tB%p [shape=record,label=\"IL_%04x\\n%s\"]\n", bb, bb->cil_code - header->code, code);
891 for (i = 0; i < bblocks->len; ++i) {
892 bb = (MonoBasicBlock*)g_ptr_array_index (bblocks, i);
893 for (tmp = bb->out_bb; tmp; tmp = tmp->next) {
895 fprintf (output, "\tB%p -> B%p\n", bb, target);
899 for (i = 0; i < bblocks->len; ++i) {
900 bb = (MonoBasicBlock*)g_ptr_array_index (bblocks, i);
904 for (i = 0; i < bblocks->len; ++i) {
905 bb = (MonoBasicBlock*)g_ptr_array_index (bblocks, i);
906 df_visit (bb, &dfn, header->code);
912 * TODO: change to create the DF tree, dominance relation etc.
915 method_cfg (MonoImage *image, const char *name) {
916 MonoMethod *method = NULL;
917 const static char *cfg_graph_properties = "\tnode [fontsize=8.0]\n\tedge [len=1.5,color=red]\n";
920 guint32 token = mono_image_get_entry_point (image);
921 if (!token || !(method = mono_get_method (image, token, NULL))) {
922 g_print ("Cannot find entry point in %s: specify an explict method name.\n", image->name);
926 /* search the method */
927 MonoMethodDesc *desc;
929 desc = mono_method_desc_new (name, include_namespace);
931 g_print ("Invalid method name %s\n", name);
934 method = mono_method_desc_search_in_image (desc, image);
936 g_print ("Cannot find method %s\n", name);
940 fprintf (output, "digraph blah {\n");
941 fprintf (output, "%s", cfg_graph_properties);
943 print_method_cfg (method);
945 fprintf (output, "}\n");
950 printf ("monograph 0.2 Copyright (c) 2002 Ximian, Inc\n");
951 printf ("Create call graph or type hierarchy information from CIL assemblies.\n");
952 printf ("Usage: monograph [options] [assembly [typename|methodname]]\n\n");
953 printf ("Valid options are:\n");
954 printf ("\t-c|--call output call graph instead of type hierarchy\n");
955 printf ("\t-C|--control-flow output control flow of methodname\n");
956 printf ("\t--stats output some statistics about the assembly\n");
957 printf ("\t-d|--depth num max depth recursion (default: 6)\n");
958 printf ("\t-o|--output filename write graph to file filename (default: stdout)\n");
959 printf ("\t-f|--fullname include namespace in type and method names\n");
960 printf ("\t-n|--neato invoke neato directly\n");
961 printf ("\t-v|--verbose verbose operation\n\n");
962 printf ("The default assembly is mscorlib.dll. The default method for\n");
963 printf ("the --call and --control-flow options is the entrypoint.\n\n");
964 printf ("When the --neato option is used the output type info is taken\n");
965 printf ("from the output filename extension. You need the graphviz package\n");
966 printf ("installed to be able to use this option and build bitmap files.\n");
967 printf ("Without --neato, monograph will create .dot files, a description\n");
968 printf ("file for a graph.\n\n");
969 printf ("Sample runs:\n");
970 printf ("\tmonograph -n -o vt.png mscorlib.dll System.ValueType\n");
971 printf ("\tmonograph -n -o expr.png mcs.exe Mono.CSharp.Expression\n");
972 printf ("\tmonograph -n -o cfg.png -C mcs.exe Driver:Main\n");
973 printf ("\tmonograph -d 3 -n -o callgraph.png -c mis.exe\n");
987 * * virtual method calls as explained above
988 * * maybe track field references
989 * * track what exceptions a method could throw?
990 * * for some inputs neato appears to hang or take a long time: kill it?
991 * * allow passing additional command-line arguments to neato
992 * * allow setting different graph/node/edge options directly
993 * * option to avoid specialname methods
994 * * make --neato option the default?
995 * * use multiple classes/method roots?
997 * * reverse call graph: given a method what methods call it?
1000 main (int argc, char *argv[]) {
1001 MonoAssembly *assembly;
1002 const char *cname = NULL;
1003 const char *aname = NULL;
1004 char *outputfile = NULL;
1005 int graphtype = GRAPH_TYPES;
1009 mono_init (argv [0]);
1012 for (i = 1; i < argc; ++i) {
1013 if (argv [i] [0] != '-')
1015 if (strcmp (argv [i], "--call") == 0 || strcmp (argv [i], "-c") == 0) {
1016 graphtype = GRAPH_CALL;
1017 } else if (strcmp (argv [i], "--control-flow") == 0 || strcmp (argv [i], "-C") == 0) {
1018 graphtype = GRAPH_CONTROL_FLOW;
1019 } else if (strcmp (argv [i], "--interface") == 0 || strcmp (argv [i], "-i") == 0) {
1020 graphtype = GRAPH_INTERFACE;
1021 } else if (strcmp (argv [i], "--stats") == 0) {
1022 graphtype = GRAPH_STATS;
1023 } else if (strcmp (argv [i], "--fullname") == 0 || strcmp (argv [i], "-f") == 0) {
1024 include_namespace = 1;
1025 } else if (strcmp (argv [i], "--neato") == 0 || strcmp (argv [i], "-n") == 0) {
1027 } else if (strcmp (argv [i], "--verbose") == 0 || strcmp (argv [i], "-v") == 0) {
1029 } else if (strcmp (argv [i], "--output") == 0 || strcmp (argv [i], "-o") == 0) {
1032 outputfile = argv [++i];
1033 } else if (strcmp (argv [i], "--depth") == 0 || strcmp (argv [i], "-d") == 0) {
1036 max_depth = atoi (argv [++i]);
1045 cname = argv [i + 1];
1048 if (!cname && (graphtype == GRAPH_TYPES))
1049 cname = "System.Object";
1051 assembly = mono_assembly_open (aname, NULL);
1053 g_print ("cannot open assembly %s\n", aname);
1058 GString *command = g_string_new ("neato");
1062 type = strrchr (outputfile, '.');
1063 g_string_sprintfa (command, " -o %s", outputfile);
1066 g_string_sprintfa (command, " -T%s", type + 1);
1067 output = popen (command->str, "w");
1069 g_print ("Cannot run neato: you may need to install the graphviz package.\n");
1072 } else if (outputfile) {
1073 output = fopen (outputfile, "w");
1075 g_print ("Cannot open file: %s\n", outputfile);
1079 /* if it looks like a method name, we want a callgraph. */
1080 if (cname && strchr (cname, ':') && graphtype == GRAPH_TYPES)
1081 graphtype = GRAPH_CALL;
1083 switch (graphtype) {
1085 type_graph (assembly->image, cname);
1088 method_graph (assembly->image, cname);
1090 case GRAPH_INTERFACE:
1091 interface_graph (assembly->image, cname);
1093 case GRAPH_CONTROL_FLOW:
1094 method_cfg (assembly->image, cname);
1097 stats (assembly->image, cname);
1100 g_error ("wrong graph type");
1105 g_print ("waiting for neato.\n");
1107 } else if (outputfile)