nsz Git - libfirm/blob - ir/ir/irdump.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irdump.c
   4  * Purpose:     Write vcg representation of firm to file.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier, Hubert Schmidt
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universit�t Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12 #ifdef HAVE_CONFIG_H
  13 #include "config.h"
  14 #endif
  15
  16 #ifdef HAVE_STRING_H
  17 #include <string.h>
  18 #endif
  19 #ifdef HAVE_STDLIB_H
  20 #include <stdlib.h>
  21 #endif
  22 #include <stdarg.h>
  23
  24 #include "firm_common_t.h"
  25
  26 #include "irnode.h"
  27 #include "irgraph.h"
  28 #include "irprog_t.h"
  29 #include "entity_t.h"
  30 #include "irop.h"
  31
  32 #include "irdump_t.h"
  33
  34 #include "irgwalk.h"
  35 #include "typewalk.h"
  36 #include "tv_t.h"
  37 #include "type_or_entity.h"
  38 #include "irouts.h"
  39 #include "irdom.h"
  40 #include "irloop_t.h"
  41 #include "callgraph.h"
  42 #include "irextbb_t.h"
  43 #include "dbginfo_t.h"
  44 #include "irtools.h"
  45
  46 #include "irvrfy.h"
  47
  48 #include "panic.h"
  49 #include "array.h"
  50 #include "pmap.h"
  51 #include "eset.h"
  52 #include "pset.h"
  53
  54 #if DO_HEAPANALYSIS
  55 extern void dump_irn_chi_term(FILE *FL, ir_node *n);
  56 extern void dump_irn_state(FILE *FL, ir_node *n);
  57 extern int  get_opt_dump_abstvals(void);
  58 typedef unsigned long SeqNo;
  59 extern SeqNo get_Block_seqno(ir_node *n);
  60 #endif
  61
  62 /* basis for a color range for vcg */
  63 static int n_colors   = 0;
  64 static int base_color = 0;
  65
  66 /** Dump only irgs with names that start with this string */
  67 static ident *dump_file_filter_id = NULL;
  68
  69 #define ERROR_TXT       "<ERROR>"
  70
  71 /*******************************************************************/
  72 /* flags to steer output                                           */
  73 /*******************************************************************/
  74
  75 /** An option to turn off edge labels */
  76 static int edge_label = 1;
  77 /** An option to turn off dumping values of constant entities */
  78 static int const_entities = 1;
  79 /** An option to dump the keep alive edges */
  80 static int dump_keepalive = 0;
  81 /** An option to dump ld_names instead of names. */
  82 static int dump_ld_name = 1;
  83 /** Compiler options to dump analysis information in dump_ir_graph */
  84 int dump_out_edge_flag = 0;
  85 int dump_dominator_information_flag = 0;
  86 int dump_loop_information_flag = 0;
  87 int dump_backedge_information_flag = 1;
  88 int dump_const_local = 0;
  89 int opt_dump_analysed_type_info = 1;
  90 int opt_dump_pointer_values_to_info = 0;  /* default off: for test compares!! */
  91
  92 static dumper_colors overrule_nodecolor = ird_color_default;
  93
  94 /** An additional edge hook. */
  95 static DUMP_NODE_EDGE_FUNC dump_node_edge_hook = NULL;
  96
  97 void set_dump_node_edge_hook(DUMP_NODE_EDGE_FUNC func)
  98 {
  99   dump_node_edge_hook = func;
 100 }
 101
 102 DUMP_NODE_EDGE_FUNC get_dump_node_edge_hook(void)
 103 {
 104   return dump_node_edge_hook;
 105 }
 106
 107
 108 /** The vcg node attribute hook. */
 109 static DUMP_IR_GRAPH_FUNC dump_ir_graph_hook = NULL;
 110 /** The vcg node attribute hook. */
 111 static DUMP_NODE_VCGATTR_FUNC dump_node_vcgattr_hook = NULL;
 112 /** The vcg edge attribute hook. */
 113 static DUMP_EDGE_VCGATTR_FUNC dump_edge_vcgattr_hook = NULL;
 114
 115 /* set the ir graph hook */
 116 void set_dump_ir_graph_hook(DUMP_IR_GRAPH_FUNC hook) {
 117   dump_ir_graph_hook = hook;
 118 }
 119 /* set the node attribute hook */
 120 void set_dump_node_vcgattr_hook(DUMP_NODE_VCGATTR_FUNC hook) {
 121   dump_node_vcgattr_hook = hook;
 122 }
 123 /* set the edge attribute hook */
 124 void set_dump_edge_vcgattr_hook(DUMP_EDGE_VCGATTR_FUNC hook) {
 125   dump_edge_vcgattr_hook = hook;
 126 }
 127
 128 INLINE int get_opt_dump_const_local(void) {
 129   if (!dump_out_edge_flag && !dump_loop_information_flag)
 130     return dump_const_local;
 131   else
 132     return 0;
 133 }
 134
 135 void only_dump_method_with_name(ident *name) {
 136   dump_file_filter_id = name;
 137 }
 138
 139 ident *get_dump_file_filter_ident(void) {
 140   return dump_file_filter_id;
 141 }
 142
 143 /** Returns non-zero if dump file filter is not set, or if it is a
 144  *  prefix of name. */
 145 int is_filtered_dump_name(ident *name) {
 146   if (!dump_file_filter_id) return 1;
 147   return id_is_prefix(dump_file_filter_id, name);
 148 }
 149
 150 /* To turn off display of edge labels.  Edge labels often cause xvcg to
 151    abort with a segmentation fault. */
 152 void turn_off_edge_labels(void) {
 153   edge_label = 0;
 154 }
 155
 156 void dump_consts_local(int flag) {
 157   dump_const_local = flag;
 158 }
 159
 160 void dump_constant_entity_values(int flag) {
 161   const_entities = flag;
 162 }
 163
 164 void dump_keepalive_edges(int flag) {
 165   dump_keepalive = flag;
 166 }
 167
 168 int get_opt_dump_keepalive_edges(void) {
 169   return dump_keepalive;
 170 }
 171
 172 void dump_out_edges(int flag) {
 173   dump_out_edge_flag = flag;
 174 }
 175
 176 void dump_dominator_information(int flag) {
 177   dump_dominator_information_flag = flag;
 178 }
 179
 180 void dump_loop_information(int flag) {
 181   dump_loop_information_flag = flag;
 182 }
 183
 184 void dump_backedge_information(int flag) {
 185   dump_backedge_information_flag = flag;
 186 }
 187
 188 /* Dump the information of type field specified in ana/irtypeinfo.h.
 189  * If the flag is set, the type name is output in [] in the node label,
 190  * else it is output as info.
 191  */
 192 void set_opt_dump_analysed_type_info(int flag) {
 193   opt_dump_analysed_type_info = flag;
 194 }
 195
 196 void dump_pointer_values_to_info(int flag) {
 197   opt_dump_pointer_values_to_info = flag;
 198 }
 199
 200 void dump_ld_names(int flag) {
 201   dump_ld_name = flag;
 202 }
 203
 204 /* -------------- some extended helper functions ----------------- */
 205
 206 /**
 207  * returns the name of a mode or <ERROR> if mode is NOT a mode object.
 208  * in the later case, sets bad
 209  */
 210 const char *get_mode_name_ex(ir_mode *mode, int *bad)
 211 {
 212   if (is_mode(mode))
 213     return get_mode_name(mode);
 214   *bad |= 1;
 215   return ERROR_TXT;
 216 }
 217
 218 /**
 219  * returns the name of a type or <ERROR> if mode is NOT a mode object.
 220  * in the later case, sets bad
 221  */
 222 const char *get_type_name_ex(type *tp, int *bad)
 223 {
 224   if (is_type(tp))
 225     return get_type_name(tp);
 226   *bad |= 1;
 227   return ERROR_TXT;
 228 }
 229
 230 /**
 231  * printf the VCG color
 232  */
 233 static void print_vcg_color(FILE *F, dumper_colors color) {
 234   static const char *color_names[32] = {
 235     "white",        "blue",      "red",        "green",
 236     "yellow",       "magenta",   "cyan",       "darkgray",
 237     "darkblue",     "darkred",   "darkgreen",  "darkyellow",
 238     "darkmagenta",  "darkcyan",  "gold",       "lightgray",
 239     "lightblue",    "lightred",  "lightgreen", "lightyellow",
 240     "lightmagenta", "lightcyan", "lilac",      "turquoise",
 241     "aquamarine",   "khaki",     "purple",     "yellowgreen",
 242     "pink",         "orange",    "orchid",     "black"
 243   };
 244
 245   if (color != ird_color_default)
 246     fprintf(F, "color:%s", color_names[color]);
 247 }
 248
 249 /**
 250  * prints the edge from a type S to a type T with additional info fmt, ...
 251  * to the file F
 252  */
 253 static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...)
 254 {
 255   va_list ap;
 256
 257   va_start(ap, fmt);
 258   fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(S);
 259   fprintf(F, " targetname: "); PRINT_TYPEID(T);
 260   vfprintf(F, fmt, ap);
 261   fprintf(F,"}\n");
 262   va_end(ap);
 263 }
 264
 265 /**
 266  * prints the edge from a type T to an entity E with additional info fmt, ...
 267  * to the file F
 268  */
 269 static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ...)
 270 {
 271   va_list ap;
 272
 273   va_start(ap, fmt);
 274   fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(T);
 275   fprintf(F, " targetname: \""); PRINT_ENTID(E); fprintf(F, "\"");
 276   vfprintf(F, fmt, ap);
 277   fprintf(F, "}\n");
 278   va_end(ap);
 279 }
 280
 281 /**
 282  * prints the edge from an entity E to an entity T with additional info fmt, ...
 283  * to the file F
 284  */
 285 static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, const char *fmt, ...)
 286 {
 287   va_list ap;
 288
 289   va_start(ap, fmt);
 290   if (backedge)
 291     fprintf(F, "backedge: { sourcename: \"");
 292    else
 293     fprintf(F, "edge: { sourcename: \"");
 294   PRINT_ENTID(E);
 295   fprintf(F, "\" targetname: \""); PRINT_ENTID(T);  fprintf(F, "\"");
 296   vfprintf(F, fmt, ap);
 297   fprintf(F, "}\n");
 298   va_end(ap);
 299 }
 300
 301 /**
 302  * prints the edge from an entity E to a type T with additional info fmt, ...
 303  * to the file F
 304  */
 305 static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ...)
 306 {
 307   va_list ap;
 308
 309   va_start(ap, fmt);
 310   fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
 311   fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
 312   vfprintf(F, fmt, ap);
 313   fprintf(F,"}\n");
 314   va_end(ap);
 315 }
 316
 317 /**
 318  * prints the edge from a node N to a type T with additional info fmt, ...
 319  * to the file F
 320  */
 321 static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...)
 322 {
 323   va_list ap;
 324
 325   va_start(ap, fmt);
 326   fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
 327   fprintf(F, "\" targetname: "); PRINT_TYPEID(T);
 328   vfprintf(F, fmt, ap);
 329   fprintf(F,"}\n");
 330   va_end(ap);
 331 }
 332
 333 /**
 334  * prints the edge from a node N to an entity E with additional info fmt, ...
 335  * to the file F
 336  */
 337 static void print_node_ent_edge(FILE *F, const ir_node *N, entity *E, const char *fmt, ...)
 338 {
 339   va_list ap;
 340
 341   va_start(ap, fmt);
 342   fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(N);
 343   fprintf(F, "\" targetname: \""); PRINT_ENTID(E);
 344   fprintf(F, "\"");
 345   vfprintf(F, fmt, ap);
 346   fprintf(F,"}\n");
 347   va_end(ap);
 348 }
 349
 350 /**
 351  * prints the edge from an entity E to a node N with additional info fmt, ...
 352  * to the file F
 353  */
 354 static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char *fmt, ...)
 355 {
 356   va_list ap;
 357
 358   va_start(ap, fmt);
 359   fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(E);
 360   fprintf(F, "\" targetname: \""); PRINT_NODEID(N); fprintf(F, "\"");
 361   vfprintf(F, fmt, ap);
 362   fprintf(F,"}\n");
 363   va_end(ap);
 364 }
 365
 366 /**
 367  * prints the edge from a type E to an enumeration item item with additional info fmt, ...
 368  * to the file F
 369  */
 370 static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...)
 371 {
 372   va_list ap;
 373
 374   va_start(ap, fmt);
 375   fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(E);
 376   fprintf(F, " targetname: \""); PRINT_ITEMID(E, item); fprintf(F, "\" ");
 377   vfprintf(F, fmt, ap);
 378   fprintf(F,"}\n");
 379   va_end(ap);
 380 }
 381
 382 /*-----------------------------------------------------------------*/
 383 /* global and ahead declarations                                   */
 384 /*-----------------------------------------------------------------*/
 385
 386 static void dump_whole_node(ir_node *n, void *env);
 387 static INLINE void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg);
 388
 389 /*-----------------------------------------------------------------*/
 390 /* Helper functions.                                                */
 391 /*-----------------------------------------------------------------*/
 392
 393 /**
 394  * This map is used as a private link attr to be able to call dumper
 395  * anywhere without destroying link fields.
 396  */
 397 static pmap *irdump_link_map = NULL;
 398
 399 /** NOT A STANDARD LIBFIRM INIT METHOD
 400  *
 401  * We do not want to integrate dumping into libfirm, i.e., if the dumpers
 402  * are off, we want to have as few interferences as possible.  Therefore the
 403  * initialization is performed lazily and not called from within init_firm.
 404  *
 405  * Creates the link attribute map. */
 406 static void init_irdump(void) {
 407   /* We need a new, empty map. */
 408   if (irdump_link_map) pmap_destroy(irdump_link_map);
 409   irdump_link_map = pmap_create();
 410   if (!dump_file_filter_id)
 411     dump_file_filter_id = new_id_from_str("");
 412 }
 413 /**
 414  * Returns the private link field.
 415  */
 416 static void *ird_get_irn_link(ir_node *n) {
 417   void *res = NULL;
 418   if (!irdump_link_map) return NULL;
 419
 420   if (pmap_contains(irdump_link_map, (void *)n))
 421     res = pmap_get(irdump_link_map, (void *)n);
 422   return res;
 423 }
 424
 425 /**
 426  * Sets the private link field.
 427  */
 428 static void ird_set_irn_link(ir_node *n, void *x) {
 429   if (!irdump_link_map)
 430     init_irdump();
 431   pmap_insert(irdump_link_map, (void *)n, x);
 432 }
 433
 434 /**
 435  * Gets the private link field of an irg.
 436  */
 437 static void *ird_get_irg_link(ir_graph *irg) {
 438   void *res = NULL;
 439   if (!irdump_link_map) return NULL;
 440
 441   if (pmap_contains(irdump_link_map, (void *)irg))
 442     res = pmap_get(irdump_link_map, (void *)irg);
 443   return res;
 444 }
 445
 446 /**
 447  * Sets the private link field of an irg.
 448  */
 449 static void ird_set_irg_link(ir_graph *irg, void *x) {
 450   if (!irdump_link_map) init_irdump();
 451   pmap_insert(irdump_link_map, (void *)irg, x);
 452 }
 453
 454 /**
 455  * Walker, clears the private link field.
 456  */
 457 static void clear_link(ir_node * node, void * env) {
 458   ird_set_irn_link(node, NULL);
 459 }
 460
 461 /**
 462  * If the entity has a ld_name, returns it if the dump_ld_name is set,
 463  * else returns the name of the entity.
 464  */
 465 static const char *_get_ent_dump_name(entity *ent, int dump_ld_name) {
 466   if (!ent)
 467     return "<NULL entity>";
 468   if (dump_ld_name) {
 469     /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
 470     if (ent->ld_name) return get_id_str(ent->ld_name);
 471   }
 472   return get_id_str(ent->name);
 473 }
 474
 475 /**
 476  * If the entity has a ld_name, returns it if the option dump_ld_name is set,
 477  * else returns the name of the entity.
 478  */
 479 const char *get_ent_dump_name(entity *ent) {
 480   return _get_ent_dump_name(ent, dump_ld_name);
 481 }
 482
 483 /* Returns the name of an IRG. */
 484 const char *get_irg_dump_name(ir_graph *irg) {
 485   /* Don't use get_entity_ld_ident (ent) as it computes the mangled name! */
 486   return _get_ent_dump_name(get_irg_entity(irg), 1);
 487 }
 488
 489 /**
 490  * Returns non-zero if a node is in floating state.
 491  */
 492 static int node_floats(ir_node *n) {
 493   return ((get_irn_pinned(n) == op_pin_state_floats) &&
 494       (get_irg_pinned(current_ir_graph) == op_pin_state_floats));
 495 }
 496
 497 /**
 498  * Walker, allocates an array for all blocks and puts it's nodes non-floating nodes into this array.
 499  */
 500 static void collect_node(ir_node * node, void *env) {
 501   if (is_Block(node)
 502       || node_floats(node)
 503       || get_irn_op(node) == op_Bad
 504       || get_irn_op(node) == op_Unknown
 505       || get_irn_op(node) == op_NoMem) {
 506     ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
 507     if (!arr) arr = NEW_ARR_F(ir_node *, 0);
 508     ARR_APP1(ir_node *, arr, node);
 509     ird_set_irg_link(get_irn_irg(node), arr);    /* arr is an l-value, APP_ARR might change it! */
 510   } else {
 511     ir_node * block = get_nodes_block(node);
 512
 513     if (is_Bad(block)) {
 514       /* this node is in a Bad block, so we must place it into the graph's list */
 515       ir_node ** arr = (ir_node **) ird_get_irg_link(get_irn_irg(node));
 516       if (!arr) arr = NEW_ARR_F(ir_node *, 0);
 517       ARR_APP1(ir_node *, arr, node);
 518       ird_set_irg_link(get_irn_irg(node), arr);    /* arr is an l-value, APP_ARR might change it! */
 519     }
 520     else {
 521       ird_set_irn_link(node, ird_get_irn_link(block));
 522       ird_set_irn_link(block, node);
 523     }
 524   }
 525 }
 526
 527 /** Construct lists to walk ir block-wise.
 528  *
 529  * Collects all blocks, nodes not op_pin_state_pinned,
 530  * Bad, NoMem and Unknown into a flexible array in link field of
 531  * irg they belong to.  Sets the irg link field to NULL in all
 532  * graphs not visited.
 533  * Free the list with DEL_ARR_F().
 534  */
 535 static ir_node **construct_block_lists(ir_graph *irg) {
 536   int i, rem_view = get_interprocedural_view();
 537   ir_graph *rem = current_ir_graph;
 538   current_ir_graph = irg;
 539
 540   for (i = 0; i < get_irp_n_irgs(); i++)
 541     ird_set_irg_link(get_irp_irg(i), NULL);
 542
 543   irg_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph);
 544
 545   /* Collect also EndReg and EndExcept. We do not want to change the walker. */
 546   set_interprocedural_view(0);
 547
 548   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
 549   irg_walk(get_irg_end_reg(current_ir_graph), clear_link, collect_node, current_ir_graph);
 550   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
 551   irg_walk(get_irg_end_except(current_ir_graph), clear_link, collect_node, current_ir_graph);
 552
 553   set_interprocedural_view(rem_view);
 554
 555   current_ir_graph = rem;
 556   return ird_get_irg_link(irg);
 557 }
 558
 559 typedef struct _list_tuple {
 560   ir_node **blk_list;
 561   ir_extblk **extbb_list;
 562 } list_tuple;
 563
 564 /** Construct lists to walk ir extended block-wise.
 565  * Free the lists in the tuple with DEL_ARR_F().
 566  */
 567 static list_tuple *construct_extblock_lists(ir_graph *irg) {
 568   ir_node **blk_list = construct_block_lists(irg);
 569   int i;
 570   ir_graph *rem = current_ir_graph;
 571   list_tuple *lists = xmalloc(sizeof(*lists));
 572
 573   current_ir_graph = irg;
 574
 575   lists->blk_list   = NEW_ARR_F(ir_node *, 0);
 576   lists->extbb_list = NEW_ARR_F(ir_extblk *, 0);
 577
 578   for (i = ARR_LEN(blk_list) - 1; i >= 0; --i) {
 579     ir_extblk *ext;
 580
 581     if (is_Block(blk_list[i])) {
 582       ext = get_Block_extbb(blk_list[i]);
 583
 584       if (extbb_not_visited(ext)) {
 585         ARR_APP1(ir_extblk *, lists->extbb_list, ext);
 586         mark_extbb_visited(ext);
 587       }
 588     }
 589     else
 590       ARR_APP1(ir_node *, lists->blk_list, blk_list[i]);
 591   }
 592
 593   current_ir_graph = rem;
 594   DEL_ARR_F(blk_list);
 595   ird_set_irg_link(irg, lists);
 596   return lists;
 597 }
 598
 599 /*-----------------------------------------------------------------*/
 600 /* Routines to dump information about a single ir node.            */
 601 /*-----------------------------------------------------------------*/
 602
 603 /*
 604  * dump the name of a node n to the File F.
 605  */
 606 int dump_node_opcode(FILE *F, ir_node *n)
 607 {
 608   int bad = 0;
 609   const ir_op_ops *ops = get_op_ops(get_irn_op(n));
 610
 611   /* call the dump_node operation if available */
 612   if (ops->dump_node)
 613     return ops->dump_node(n, F, dump_node_opcode_txt);
 614
 615   /* implementation for default nodes */
 616   switch (get_irn_opcode(n)) {
 617
 618   case iro_Const: {
 619     int res;
 620     char buf[1024];
 621     res = tarval_snprintf(buf, sizeof(buf), get_Const_tarval(n));
 622     assert(res < sizeof(buf) && "buffer to small for tarval_snprintf");
 623     fprintf(F, buf);
 624   } break;
 625
 626   case iro_SymConst: {
 627     if (get_SymConst_kind(n) == symconst_addr_name) {
 628       /* don't use get_SymConst_ptr_info as it mangles the name. */
 629       fprintf (F, "SymC %s", get_id_str(get_SymConst_name(n)));
 630     } else if (get_SymConst_kind(n) == symconst_addr_ent) {
 631       assert(get_SymConst_entity(n));
 632       assert(is_entity(get_SymConst_entity(n)));
 633       fprintf (F, "SymC &%s", get_entity_name(get_SymConst_entity(n)));
 634     } else {
 635       assert(get_kind(get_SymConst_type(n)) == k_type);
 636       assert(get_type_ident(get_SymConst_type(n)));
 637       fprintf (F, "SymC %s ", get_type_name_ex(get_SymConst_type(n), &bad));
 638       if (get_SymConst_kind(n) == symconst_type_tag)
 639         fprintf (F, "tag");
 640       else
 641         fprintf (F, "size");
 642     }
 643   } break;
 644
 645   case iro_Filter: {
 646     if (!get_interprocedural_view())
 647       fprintf(F, "Proj'");
 648     else
 649       goto default_case;
 650   } break;
 651
 652   case iro_Proj: {
 653     ir_node *pred = get_Proj_pred(n);
 654
 655     if (get_irn_opcode(pred) == iro_Cond
 656         && get_Proj_proj(n) == get_Cond_defaultProj(pred)
 657         && get_irn_mode(get_Cond_selector(pred)) != mode_b)
 658       fprintf (F, "defProj");
 659     else
 660       goto default_case;
 661   } break;
 662   case iro_Start:
 663   case iro_End:
 664   case iro_EndExcept:
 665   case iro_EndReg: {
 666     if (get_interprocedural_view()) {
 667       fprintf(F, "%s %s", get_irn_opname(n), get_ent_dump_name(get_irg_entity(get_irn_irg(n))));
 668       break;
 669     } else
 670       goto default_case;
 671   }
 672   case iro_CallBegin: {
 673     ir_node *addr = get_CallBegin_ptr(n);
 674     entity *ent = NULL;
 675     if (get_irn_op(addr) == op_Sel)
 676       ent = get_Sel_entity(addr);
 677     else if ((get_irn_op(addr) == op_SymConst) && (get_SymConst_kind(addr) == symconst_addr_ent))
 678       ent = get_SymConst_entity(addr);
 679     fprintf (F, "%s", get_irn_opname(n));
 680     if (ent) fprintf (F, " %s", get_entity_name(ent));
 681     break;
 682   }
 683   case iro_Load:
 684     fprintf (F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), &bad));
 685     break;
 686   case iro_Block:
 687     fprintf (F, "%s%s", is_Block_dead(n) ? "Dead " : "", get_irn_opname(n));
 688     break;
 689
 690   default:
 691 default_case:
 692     fprintf (F, "%s", get_irn_opname(n));
 693
 694   }  /* end switch */
 695   return bad;
 696 }
 697
 698 /**
 699  * Dump the mode of a node n to a file F.
 700  * Ignore modes that are "always known".
 701  */
 702 static int dump_node_mode(FILE *F, ir_node *n)
 703 {
 704   int bad = 0;
 705   const ir_op_ops *ops = get_op_ops(get_irn_op(n));
 706   opcode iro;
 707
 708   /* call the dump_node operation if available */
 709   if (ops->dump_node)
 710     return ops->dump_node(n, F, dump_node_mode_txt);
 711
 712   /* default implementation */
 713   iro = get_irn_opcode(n);
 714   switch (iro) {
 715     case iro_SymConst:
 716     case iro_Sel:
 717     case iro_End:
 718     case iro_Return:
 719     case iro_Free:
 720     case iro_Sync:
 721     case iro_Jmp:
 722     case iro_NoMem:
 723       break;
 724     default: {
 725       ir_mode *mode = get_irn_mode(n);
 726
 727       if (mode && mode != mode_BB && mode != mode_ANY && mode != mode_BAD &&
 728           (mode != mode_T || iro == iro_Proj))
 729         fprintf(F, "%s", get_mode_name_ex(mode, &bad));
 730     }
 731   }
 732
 733   return bad;
 734 }
 735
 736 /**
 737  * Dump the type of a node n to a file F if it's known.
 738  */
 739 static int dump_node_typeinfo(FILE *F, ir_node *n) {
 740   int bad = 0;
 741
 742   if (opt_dump_analysed_type_info) {
 743     if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent  ||
 744         get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) {
 745       type *tp = get_irn_typeinfo_type(n);
 746       if (tp != firm_none_type)
 747         fprintf(F, "[%s] ", get_type_name_ex(tp, &bad));
 748       else
 749         fprintf(F, "[] ");
 750     }
 751   }
 752   return bad;
 753 }
 754
 755 typedef struct _pns_lookup {
 756   long       nr;      /**< the proj number */
 757   const char *name;   /**< the name of the Proj */
 758 } pns_lookup_t;
 759
 760 typedef struct _proj_lookup {
 761   opcode             code;      /**< the opcode of the Proj predecessor */
 762   unsigned           num_data;  /**< number of data entries */
 763   const pns_lookup_t *data;     /**< the data */
 764 } proj_lookup_t;
 765
 766 #define ARR_SIZE(a)       (sizeof(a)/sizeof(a[0]))
 767
 768 /** the lookup table for Proj(Start) names */
 769 static const pns_lookup_t start_lut[] = {
 770 #define X(a)    { pn_Start_##a, #a }
 771   X(X_initial_exec),
 772   X(P_frame_base),
 773   X(P_globals),
 774   X(T_args),
 775   X(P_value_arg_base)
 776 #undef X
 777 };
 778
 779 /** the lookup table for Proj(Cond) names */
 780 static const pns_lookup_t cond_lut[] = {
 781 #define X(a)    { pn_Cond_##a, #a }
 782   X(false),
 783   X(true)
 784 #undef X
 785 };
 786
 787 /** the lookup table for Proj(Call) names */
 788 static const pns_lookup_t call_lut[] = {
 789 #define X(a)    { pn_Call_##a, #a }
 790   X(M_regular),
 791   X(T_result),
 792   X(P_value_res_base),
 793   X(X_except),
 794   X(M_except)
 795 #undef X
 796 };
 797
 798 /** the lookup table for Proj(Quot) names */
 799 static const pns_lookup_t quot_lut[] = {
 800 #define X(a)    { pn_Quot_##a, #a }
 801   X(M),
 802   X(X_except),
 803   X(res)
 804 #undef X
 805 };
 806
 807 /** the lookup table for Proj(DivMod) names */
 808 static const pns_lookup_t divmod_lut[] = {
 809 #define X(a)    { pn_DivMod_##a, #a }
 810   X(M),
 811   X(X_except),
 812   X(res_div),
 813   X(res_mod)
 814 #undef X
 815 };
 816
 817 /** the lookup table for Proj(Div) names */
 818 static const pns_lookup_t div_lut[] = {
 819 #define X(a)    { pn_Div_##a, #a }
 820   X(M),
 821   X(X_except),
 822   X(res)
 823 #undef X
 824 };
 825
 826 /** the lookup table for Proj(Mod) names */
 827 static const pns_lookup_t mod_lut[] = {
 828 #define X(a)    { pn_Mod_##a, #a }
 829   X(M),
 830   X(X_except),
 831   X(res)
 832 #undef X
 833 };
 834
 835 /** the lookup table for Proj(Load) names */
 836 static const pns_lookup_t load_lut[] = {
 837 #define X(a)    { pn_Load_##a, #a }
 838   X(M),
 839   X(X_except),
 840   X(res)
 841 #undef X
 842 };
 843
 844 /** the lookup table for Proj(Store) names */
 845 static const pns_lookup_t store_lut[] = {
 846 #define X(a)    { pn_Store_##a, #a }
 847   X(M),
 848   X(X_except)
 849 #undef X
 850 };
 851
 852 /** the lookup table for Proj(Alloc) names */
 853 static const pns_lookup_t alloc_lut[] = {
 854 #define X(a)    { pn_Alloc_##a, #a }
 855   X(M),
 856   X(X_except),
 857   X(res)
 858 #undef X
 859 };
 860
 861 /** the lookup table for Proj(CopyB) names */
 862 static const pns_lookup_t copyb_lut[] = {
 863 #define X(a)    { pn_CopyB_##a, #a }
 864   X(M),
 865   X(X_except),
 866   X(M_except)
 867 #undef X
 868 };
 869
 870 /** the lookup table for Proj(Bound) names */
 871 static const pns_lookup_t bound_lut[] = {
 872 #define X(a)    { pn_Bound_##a, #a }
 873   X(M),
 874   X(X_except),
 875   X(res),
 876   X(M_except)
 877 #undef X
 878 };
 879
 880 /** the Proj lookup table */
 881 static const proj_lookup_t proj_lut[] = {
 882 #define E(a)  ARR_SIZE(a), a
 883   { iro_Start,   E(start_lut) },
 884   { iro_Cond,    E(cond_lut) },
 885   { iro_Call,    E(call_lut) },
 886   { iro_Quot,    E(quot_lut) },
 887   { iro_DivMod,  E(divmod_lut) },
 888   { iro_Div,     E(div_lut) },
 889   { iro_Mod,     E(mod_lut) },
 890   { iro_Load,    E(load_lut) },
 891   { iro_Store,   E(store_lut) },
 892   { iro_Alloc,   E(alloc_lut) },
 893   { iro_CopyB,   E(copyb_lut) },
 894   { iro_Bound,   E(bound_lut) }
 895 #undef E
 896 };
 897
 898 /**
 899  * Dump additional node attributes of some nodes to a file F.
 900  */
 901 static int
 902 dump_node_nodeattr(FILE *F, ir_node *n)
 903 {
 904   int bad = 0;
 905   ir_node *pred;
 906   opcode code;
 907   long proj_nr;
 908   const ir_op_ops *ops = get_op_ops(get_irn_op(n));
 909
 910   /* call the dump_node operation if available */
 911   if (ops->dump_node)
 912     return ops->dump_node(n, F, dump_node_nodeattr_txt);
 913
 914   switch (get_irn_opcode(n)) {
 915   case iro_Start:
 916     if (0 && get_interprocedural_view()) {
 917       fprintf (F, "%s ", get_ent_dump_name(get_irg_entity(current_ir_graph)));
 918     }
 919     break;
 920
 921   case iro_Proj:
 922     pred    = get_Proj_pred(n);
 923     proj_nr = get_Proj_proj(n);
 924 handle_lut:
 925     code    = get_irn_opcode(pred);
 926
 927     if (code == iro_Cmp)
 928       fprintf (F, "%s ", get_pnc_string(get_Proj_proj(n)));
 929     else if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start)
 930       fprintf (F, "Arg %ld ", proj_nr);
 931     else {
 932       unsigned i, j, f = 0;
 933
 934       for (i = 0; i < ARR_SIZE(proj_lut); ++i) {
 935         if (code == proj_lut[i].code) {
 936           for (j = 0; j < proj_lut[i].num_data; ++j) {
 937             if (proj_nr == proj_lut[i].data[j].nr) {
 938               fprintf (F, "%s ", proj_lut[i].data[j].name);
 939               f = 1;
 940               break;
 941             }
 942           }
 943           break;
 944         }
 945       }
 946       if (! f)
 947         fprintf (F, "%ld ", proj_nr);
 948       if (code == iro_Cond && get_Cond_jmp_pred(pred) != COND_JMP_PRED_NONE) {
 949         if (proj_nr == pn_Cond_false && get_Cond_jmp_pred(pred) == COND_JMP_PRED_FALSE)
 950           fprintf(F, "PRED ");
 951         if (proj_nr == pn_Cond_true && get_Cond_jmp_pred(pred) == COND_JMP_PRED_TRUE)
 952           fprintf(F, "PRED ");
 953       }
 954     }
 955     break;
 956   case iro_Filter:
 957     proj_nr = get_Filter_proj(n);
 958     if (! get_interprocedural_view()) {
 959       /* it's a Proj' */
 960       pred    = get_Filter_pred(n);
 961       goto handle_lut;
 962     }
 963     else
 964       fprintf (F, "%ld ", proj_nr);
 965     break;
 966   case iro_Sel:
 967     fprintf (F, "%s ", get_ent_dump_name(get_Sel_entity(n)));
 968     break;
 969   case iro_Cast:
 970     fprintf (F, "(%s) ", get_type_name_ex(get_Cast_type(n), &bad));
 971     break;
 972   case iro_Confirm:
 973     fprintf (F, "%s ", get_pnc_string(get_Confirm_cmp(n)));
 974     break;
 975   case iro_CopyB:
 976     fprintf (F, "(%s) ", get_type_name_ex(get_CopyB_type(n), &bad));
 977     break;
 978
 979   default:
 980     ;
 981   } /* end switch */
 982
 983   return bad;
 984 }
 985
 986 #include <math.h>
 987 #include "execution_frequency.h"
 988 #include "callgraph.h"
 989
 990 void dump_node_ana_vals(FILE *F, ir_node *n) {
 991   return;
 992   fprintf(F, " %lf*(%2.0lf + %2.0lf) = %2.0lf ",
 993           get_irn_exec_freq(n),
 994           get_irg_method_execution_frequency(get_irn_irg(n)),
 995           pow(5, get_irg_recursion_depth(get_irn_irg(n))),
 996           get_irn_exec_freq(n) * (get_irg_method_execution_frequency(get_irn_irg(n)) + pow(5, get_irg_recursion_depth(get_irn_irg(n))))
 997           );
 998 }
 999
1000
1001 /* Dumps a node label without the enclosing ". */
1002 int dump_node_label(FILE *F, ir_node *n) {
1003   int bad = 0;
1004
1005   bad |= dump_node_opcode(F, n);
1006   bad |= dump_node_mode(F, n);
1007   fprintf (F, " ");
1008   bad |= dump_node_typeinfo(F, n);
1009   bad |= dump_node_nodeattr(F, n);
1010   fprintf(F, "%ld", get_irn_node_nr(n));
1011
1012   return bad;
1013 }
1014
1015
1016 /**
1017  * Dumps the attributes of a node n into the file F.
1018  * Currently this is only the color of a node.
1019  */
1020 static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
1021 {
1022   ir_node *n;
1023
1024   if (bad) {
1025     print_vcg_color(F, ird_color_red);
1026     return;
1027   }
1028
1029   if (dump_node_vcgattr_hook)
1030     if (dump_node_vcgattr_hook(F, node, local))
1031       return;
1032
1033   n = local ? local : node;
1034
1035   if (overrule_nodecolor != ird_color_default) {
1036     print_vcg_color(F, overrule_nodecolor);
1037     return;
1038   }
1039
1040   switch (get_irn_opcode(n)) {
1041   case iro_Start:
1042   case iro_EndReg:
1043     /* fall through */
1044   case iro_EndExcept:
1045     /* fall through */
1046   case iro_End:
1047     print_vcg_color(F, ird_color_blue);
1048     break;
1049   case iro_Block:
1050     if (is_Block_dead(n))
1051       print_vcg_color(F, ird_color_lightred);
1052     else
1053       print_vcg_color(F, ird_color_lightyellow);
1054     break;
1055   case iro_Phi:
1056     print_vcg_color(F, ird_color_green);
1057     break;
1058   case iro_Const:
1059   case iro_Proj:
1060   case iro_Filter:
1061   case iro_Tuple:
1062     print_vcg_color(F, ird_color_yellow);
1063     break;
1064   default:
1065     PRINT_DEFAULT_NODE_ATTR;
1066   }
1067 }
1068
1069
1070 /**
1071  * Dump the node information of a node n to a file F.
1072  */
1073 static INLINE int dump_node_info(FILE *F, ir_node *n)
1074 {
1075   int bad = 0;
1076   const ir_op_ops *ops = get_op_ops(get_irn_op(n));
1077
1078   fprintf (F, " info1: \"");
1079   bad = dump_irnode_to_file(F, n);
1080   /* call the dump_node operation if available */
1081   if (ops->dump_node)
1082     bad = ops->dump_node(n, F, dump_node_info_txt);
1083   fprintf(F, "\"\n");
1084
1085   return bad;
1086 }
1087
1088 /**
1089  * checks whether a node is "constant-like" ie can be treated "block-less"
1090  */
1091 static INLINE
1092 int is_constlike_node(ir_node *n) {
1093   ir_op *op = get_irn_op(n);
1094   return (op == op_Const || op == op_Bad || op == op_NoMem || op == op_SymConst || op == op_Unknown);
1095 }
1096
1097
1098 /** outputs the predecessors of n, that are constants, local.  I.e.,
1099    generates a copy of the constant predecessors for each node called with. */
1100 static void dump_const_node_local(FILE *F, ir_node *n) {
1101   int i;
1102   if (!get_opt_dump_const_local()) return;
1103
1104   /* Use visited flag to avoid outputting nodes twice.
1105      initialize it first. */
1106   for (i = 0; i < get_irn_arity(n); i++) {
1107     ir_node *con = get_irn_n(n, i);
1108     if (is_constlike_node(con)) {
1109       set_irn_visited(con, get_irg_visited(current_ir_graph) - 1);
1110     }
1111   }
1112
1113   for (i = 0; i < get_irn_arity(n); i++) {
1114     ir_node *con = get_irn_n(n, i);
1115     if (is_constlike_node(con) && irn_not_visited(con)) {
1116       int bad = 0;
1117
1118       mark_irn_visited(con);
1119       /* Generate a new name for the node by appending the names of
1120          n and const. */
1121       fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
1122       fprintf(F, " label: \"");
1123       bad |= dump_node_label(F, con);
1124       fprintf(F, "\" ");
1125       bad |= dump_node_info(F, con);
1126       dump_node_vcgattr(F, n, con, bad);
1127       fprintf(F, "}\n");
1128     }
1129   }
1130 }
1131
1132 /** If the block of an edge is a const_like node, dump it local with an edge */
1133 static void dump_const_block_local(FILE *F, ir_node *n) {
1134   ir_node *blk;
1135
1136   if (!get_opt_dump_const_local()) return;
1137
1138   blk = get_nodes_block(n);
1139   if (is_constlike_node(blk)) {
1140     int bad = 0;
1141
1142     /* Generate a new name for the node by appending the names of
1143        n and blk. */
1144     fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
1145     fprintf(F, "\" label: \"");
1146     bad |= dump_node_label(F, blk);
1147     fprintf(F, "\" ");
1148     bad |= dump_node_info(F, blk);
1149     dump_node_vcgattr(F, n, blk, bad);
1150     fprintf(F, "}\n");
1151
1152     fprintf (F, "edge: { sourcename: \"");
1153     PRINT_NODEID(n);
1154     fprintf (F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
1155
1156     if (dump_edge_vcgattr_hook) {
1157       fprintf (F, "\" ");
1158       if (dump_edge_vcgattr_hook(F, n, -1)) {
1159         fprintf (F, "}\n");
1160         return;
1161       }
1162       else {
1163         fprintf (F, " " BLOCK_EDGE_ATTR "}\n");
1164         return;
1165       }
1166     }
1167
1168     fprintf (F, "\" "   BLOCK_EDGE_ATTR "}\n");
1169   }
1170 }
1171
1172 /**
1173  * prints the error message of a node to a file F as info2.
1174  */
1175 static void INLINE print_node_error(FILE *F, const char *err_msg)
1176 {
1177   if (! err_msg)
1178     return;
1179
1180   fprintf (F, " info2: \"%s\"", err_msg);
1181 }
1182
1183 /**
1184  * prints debug messages of a node to file F as info3.
1185  */
1186 static void print_dbg_info(FILE *F, dbg_info *dbg)
1187 {
1188   char buf[1024];
1189
1190   if (__dbg_info_snprint) {
1191     buf[0] = '\0';
1192     if (__dbg_info_snprint(buf, sizeof(buf), dbg) > 0)
1193       fprintf (F, " info3: \"%s\"\n", buf);
1194   }
1195 }
1196
1197 /**
1198  * Dump a node
1199  */
1200 static void dump_node(FILE *F, ir_node *n)
1201 {
1202   int bad = 0;
1203   const char *p;
1204
1205   if (get_opt_dump_const_local() && is_constlike_node(n))
1206     return;
1207
1208   /* dump this node */
1209   fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
1210
1211   bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
1212   bad |= dump_node_label(F, n);
1213   dump_node_ana_vals(F, n);
1214   //dump_node_ana_info(F, n);
1215   fprintf(F, "\" ");
1216   bad |= dump_node_info(F, n);
1217   print_node_error(F, p);
1218   print_dbg_info(F, get_irn_dbg_info(n));
1219   dump_node_vcgattr(F, n, NULL, bad);
1220   fprintf(F, "}\n");
1221   dump_const_node_local(F, n);
1222
1223   if(dump_node_edge_hook)
1224     dump_node_edge_hook(F, n);
1225 #if DO_HEAPANALYSIS
1226   dump_irn_chi_term(F, n);
1227   dump_irn_state(F, n);
1228 #endif
1229 }
1230
1231 /** dump the edge to the block this node belongs to */
1232 static void
1233 dump_ir_block_edge(FILE *F, ir_node *n)  {
1234   if (get_opt_dump_const_local() && is_constlike_node(n)) return;
1235   if (is_no_Block(n)) {
1236     ir_node *block = get_nodes_block(n);
1237
1238     if (get_opt_dump_const_local() && is_constlike_node(block)) {
1239       dump_const_block_local(F, n);
1240     }
1241     else {
1242       fprintf (F, "edge: { sourcename: \"");
1243       PRINT_NODEID(n);
1244       fprintf (F, "\" targetname: ");
1245       fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
1246
1247       if (dump_edge_vcgattr_hook) {
1248         fprintf (F, " ");
1249         if (dump_edge_vcgattr_hook(F, n, -1)) {
1250           fprintf (F, "}\n");
1251           return;
1252         }
1253         else {
1254           fprintf (F, " "  BLOCK_EDGE_ATTR "}\n");
1255           return;
1256         }
1257       }
1258
1259       fprintf (F, " "   BLOCK_EDGE_ATTR "}\n");
1260     }
1261   }
1262 }
1263
1264 static void
1265 print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
1266   /*
1267    * do not use get_nodes_block() here, will fail
1268    * if the irg is not pinned.
1269    */
1270   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
1271     fprintf (F, INTRA_DATA_EDGE_ATTR);
1272   else
1273     fprintf (F, INTER_DATA_EDGE_ATTR);
1274 }
1275
1276 static void
1277 print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
1278   /*
1279    * do not use get_nodes_block() here, will fail
1280    * if the irg is not pinned.
1281    */
1282   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
1283     fprintf (F, INTRA_MEM_EDGE_ATTR);
1284   else
1285     fprintf (F, INTER_MEM_EDGE_ATTR);
1286 }
1287
1288 static void
1289 print_edge_vcgattr(FILE *F, ir_node *from, int to) {
1290   assert(from);
1291
1292   if (dump_edge_vcgattr_hook)
1293     if (dump_edge_vcgattr_hook(F, from, to))
1294       return;
1295
1296   if (dump_backedge_information_flag && is_backedge(from, to))
1297     fprintf (F, BACK_EDGE_ATTR);
1298
1299   switch (get_irn_opcode(from)) {
1300   case iro_Block:
1301     fprintf (F, CF_EDGE_ATTR);
1302     break;
1303   case iro_Start:   break;
1304   case iro_End:
1305     if (to >= 0) {
1306       if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB)
1307     fprintf (F, CF_EDGE_ATTR);
1308       if (get_irn_mode(get_End_keepalive(from, to)) == mode_X)
1309     fprintf (F, INTER_MEM_EDGE_ATTR);
1310     }
1311     break;
1312   case iro_EndReg:
1313   case iro_EndExcept:
1314   case iro_Jmp:
1315   case iro_Break:
1316   case iro_Cond:
1317     print_data_edge_vcgattr(F, from, to);
1318     break;
1319   case iro_Return:
1320   case iro_Raise:
1321     if (to == 0)
1322       print_mem_edge_vcgattr(F, from, to);
1323     else
1324       print_data_edge_vcgattr(F, from, to);
1325     break;
1326   case iro_Const:
1327   case iro_SymConst:
1328     print_data_edge_vcgattr(F, from, to);
1329     break;
1330   case iro_Sel:
1331   case iro_Call:
1332     if (to == 0)
1333       print_mem_edge_vcgattr(F, from, to);
1334     else
1335       print_data_edge_vcgattr(F, from, to);
1336     break;
1337   case iro_CallBegin:
1338   case iro_Add:
1339   case iro_Sub:
1340   case iro_Minus:
1341   case iro_Mul:
1342     print_data_edge_vcgattr(F, from, to);
1343     break;
1344   case iro_Quot:
1345   case iro_DivMod:
1346   case iro_Div:
1347   case iro_Mod:
1348     if (to == 0)
1349       print_mem_edge_vcgattr(F, from, to);
1350     else
1351       print_data_edge_vcgattr(F, from, to);
1352     break;
1353   case iro_Abs:
1354   case iro_And:
1355   case iro_Or:
1356   case iro_Eor:
1357   case iro_Shl:
1358   case iro_Shr:
1359   case iro_Shrs:
1360   case iro_Rot:
1361   case iro_Cmp:
1362   case iro_Conv:
1363       print_data_edge_vcgattr(F, from, to);
1364     break;
1365   case iro_Phi:
1366     if (get_irn_modecode(from) == irm_M)
1367       fprintf (F, INTER_MEM_EDGE_ATTR);
1368     else
1369       print_data_edge_vcgattr(F, from, to);
1370     break;
1371   case iro_Load:
1372   case iro_Store:
1373   case iro_Alloc:
1374   case iro_Free:
1375     if (to == 0)
1376       print_mem_edge_vcgattr(F, from, to);
1377     else
1378       print_data_edge_vcgattr(F, from, to);
1379     break;
1380   case iro_Sync:
1381     print_mem_edge_vcgattr(F, from, to);
1382     break;
1383   case iro_Tuple:  break;
1384   case iro_Proj:
1385   case iro_Filter:
1386     switch (get_irn_modecode(from)) {
1387     case irm_X:
1388       fprintf (F, CF_EDGE_ATTR);
1389       break;
1390     case irm_M:
1391       fprintf (F, INTER_MEM_EDGE_ATTR);
1392       break;
1393     default:
1394       print_data_edge_vcgattr(F, from, to);
1395       break;
1396     }
1397     break;
1398   case iro_Bad:     break;
1399   case iro_Unknown: break;
1400   case iro_Id:
1401     switch (get_irn_modecode(from)) {
1402     case irm_M:
1403       fprintf (F, INTRA_MEM_EDGE_ATTR);
1404       break;
1405     case irm_X:
1406       fprintf (F, CF_EDGE_ATTR);
1407       break;
1408     default:
1409       print_data_edge_vcgattr(F, from, to);
1410       break;
1411     } break;
1412   default:
1413     ;
1414   }
1415 }
1416
1417 /* dump edges to our inputs */
1418 static void
1419 dump_ir_data_edges(FILE *F, ir_node *n)  {
1420   int i;
1421   unsigned long visited = get_irn_visited(n);
1422
1423   if ((get_irn_op(n) == op_End) && (!dump_keepalive))
1424     return;
1425
1426   for (i = 0; i < get_irn_arity(n); i++) {
1427     ir_node * pred = get_irn_n(n, i);
1428     assert(pred);
1429
1430     if ((get_interprocedural_view() && get_irn_visited(pred) < visited))
1431       continue; /* pred not dumped */
1432
1433     if (dump_backedge_information_flag && is_backedge(n, i))
1434       fprintf (F, "backedge: {sourcename: \"");
1435     else
1436       fprintf (F, "edge: {sourcename: \"");
1437     PRINT_NODEID(n);
1438     fprintf (F, "\" targetname: ");
1439     if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
1440       PRINT_CONSTID(n, pred);
1441     } else {
1442       fprintf(F, "\""); PRINT_NODEID(pred); fprintf(F, "\"");
1443     }
1444     fprintf (F, " label: \"%d\" ", i);
1445     print_edge_vcgattr(F, n, i);
1446     fprintf (F, "}\n");
1447   }
1448 }
1449
1450 /** Dumps a node and its edges but not the block edge
1451  */
1452 static INLINE void
1453 dump_node_wo_blockedge (ir_node *n, void *env) {
1454   FILE *F = env;
1455   dump_node(F, n);
1456   dump_ir_data_edges(F, n);
1457 }
1458
1459 /** Dumps a node and its edges.
1460  */
1461 static void
1462 dump_whole_node (ir_node *n, void *env) {
1463   FILE *F = env;
1464   dump_node_wo_blockedge(n, env);
1465   if (!node_floats(n)) dump_ir_block_edge(F, n);
1466 }
1467
1468 static void
1469 dump_const_node(ir_node *n, void *env) {
1470   if (is_Block(n)) return;
1471   dump_node_wo_blockedge(n, env);
1472 }
1473
1474 /***********************************************************************/
1475 /* the following routines dump the nodes/irgs bracketed to graphs.     */
1476 /***********************************************************************/
1477
1478 /** Dumps a constant expression as entity initializer, array bound ...
1479  */
1480 static void dump_const_expression(FILE *F, ir_node *value) {
1481   ir_graph *rem = current_ir_graph;
1482   int rem_dump_const_local = dump_const_local;
1483   dump_const_local = 0;
1484   current_ir_graph = get_const_code_irg();
1485   irg_walk(value, dump_const_node, NULL, F);
1486   /* Decrease visited flag so that we walk with the same flag for the next
1487      expression.  This guarantees that we don't dump the same node twice,
1488      as for const expressions cse is performed to save memory. */
1489   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph) -1);
1490   current_ir_graph = rem;
1491   dump_const_local = rem_dump_const_local;
1492 }
1493
1494 /** Dump a block as graph containing its nodes.
1495  *
1496  *  Expects to find nodes belonging to the block as list in its
1497  *  link field.
1498  *  Dumps the edges of all nodes including itself. */
1499 static void
1500 dump_whole_block(FILE *F, ir_node *block) {
1501   ir_node *node;
1502   dumper_colors color = ird_color_yellow;
1503
1504   assert(is_Block(block));
1505
1506   fprintf(F, "graph: { title: \"");
1507   PRINT_NODEID(block);
1508   fprintf(F, "\"  label: \"");
1509   dump_node_label(F, block);
1510 #if DO_HEAPANALYSIS
1511   if (get_opt_dump_abstvals())
1512     fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
1513 #endif
1514
1515   /* colorize blocks */
1516   if (! get_Block_matured(block))
1517     color = ird_color_red;
1518   if (is_Block_dead(block))
1519     color = ird_color_orange;
1520
1521   fprintf(F, "\" status:clustered ");
1522   print_vcg_color(F, color);
1523   fprintf(F, "\n");
1524
1525   /* yComp can show attributes for blocks, XVCG parses but ignores them */
1526   dump_node_info(F, block);
1527   print_dbg_info(F, get_irn_dbg_info(block));
1528
1529   /* dump the blocks edges */
1530   dump_ir_data_edges(F, block);
1531
1532   /* dump the nodes that go into the block */
1533   for (node = ird_get_irn_link(block); node; node = ird_get_irn_link(node)) {
1534     dump_node(F, node);
1535     dump_ir_data_edges(F, node);
1536   }
1537
1538   /* Close the vcg information for the block */
1539   fprintf(F, "}\n");
1540   dump_const_node_local(F, block);
1541 #if DO_HEAPANALYSIS
1542   dump_irn_chi_term(F, block);
1543 #endif
1544   fprintf(F, "\n");
1545 }
1546
1547 /** dumps a graph block-wise. Expects all blockless nodes in arr in irgs link.
1548  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
1549 static void
1550 dump_block_graph(FILE *F, ir_graph *irg) {
1551   int i;
1552   ir_graph *rem = current_ir_graph;
1553   ir_node **arr = ird_get_irg_link(irg);
1554   current_ir_graph = irg;
1555
1556   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
1557     ir_node * node = arr[i];
1558     if (is_Block(node)) {
1559       /* Dumps the block and all the nodes in the block, which are to
1560          be found in Block->link. */
1561       dump_whole_block(F, node);
1562     } else {
1563       /* Nodes that are not in a Block. */
1564       dump_node(F, node);
1565       if (!node_floats(node) && is_Bad(get_nodes_block(node))) {
1566         dump_const_block_local(F, node);
1567       }
1568       dump_ir_data_edges(F, node);
1569     }
1570   }
1571
1572   if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid))
1573     dump_loop_nodes_into_graph(F, irg);
1574
1575   current_ir_graph = rem;
1576 }
1577
1578 /**
1579  * Dump the info for an irg.
1580  * Parsed by XVCG but not shown. use yComp.
1581  */
1582 static void dump_graph_info(FILE *F, ir_graph *irg) {
1583   fprintf(F, "info1: \"");
1584   dump_entity_to_file(F, get_irg_entity(irg), dump_verbosity_entattrs | dump_verbosity_entconsts);
1585   fprintf(F, "\"\n");
1586 }
1587
1588 /** Dumps an irg as a graph clustered by block nodes.
1589  *  If interprocedural view edges can point to nodes out of this graph.
1590  */
1591 static void dump_graph_from_list(FILE *F, ir_graph *irg) {
1592   entity *ent = get_irg_entity(irg);
1593
1594   fprintf(F, "graph: { title: \"");
1595   PRINT_IRGID(irg);
1596   fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
1597       get_ent_dump_name(ent));
1598
1599   dump_graph_info(F, irg);
1600   print_dbg_info(F, get_entity_dbg_info(ent));
1601
1602   dump_block_graph(F, irg);
1603
1604   /* Close the vcg information for the irg */
1605   fprintf(F, "}\n\n");
1606 }
1607
1608 /** dumps a graph extended block-wise. Expects all blockless nodes in arr in irgs link.
1609  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
1610 static void
1611 dump_extblock_graph(FILE *F, ir_graph *irg) {
1612   int i;
1613   ir_graph *rem = current_ir_graph;
1614   ir_extblk **arr = ird_get_irg_link(irg);
1615   current_ir_graph = irg;
1616
1617   compute_extbb(irg);
1618   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
1619     ir_extblk *extbb = arr[i];
1620     ir_node *leader = get_extbb_leader(extbb);
1621     int j;
1622
1623     fprintf(F, "graph: { title: \"");
1624     PRINT_EXTBBID(leader);
1625     fprintf(F, "\"  label: \"ExtBB %ld\" status:clustered color:lightgreen\n",
1626             get_irn_node_nr(leader));
1627
1628     for (j = ARR_LEN(extbb->blks) - 1; j >= 0; --j) {
1629       ir_node * node = extbb->blks[j];
1630       if (is_Block(node)) {
1631         /* Dumps the block and all the nodes in the block, which are to
1632            be found in Block->link. */
1633         dump_whole_block(F, node);
1634       } else {
1635         /* Nodes that are not in a Block. */
1636         dump_node(F, node);
1637         if (is_Bad(get_nodes_block(node)) && !node_floats(node)) {
1638           dump_const_block_local(F, node);
1639         }
1640         dump_ir_data_edges(F, node);
1641       }
1642     }
1643     fprintf(F, "}\n");
1644   }
1645
1646   if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid))
1647     dump_loop_nodes_into_graph(F, irg);
1648
1649   current_ir_graph = rem;
1650   free_extbb(irg);
1651 }
1652
1653
1654 /*******************************************************************/
1655 /* Basic type and entity nodes and edges.                          */
1656 /*******************************************************************/
1657
1658 /** dumps the edges between nodes and their type or entity attributes. */
1659 static void dump_node2type_edges(ir_node *n, void *env)
1660 {
1661   FILE *F = env;
1662   assert(n);
1663
1664   switch (get_irn_opcode(n)) {
1665   case iro_Const :
1666     /* @@@ some consts have an entity */
1667     break;
1668   case iro_SymConst:
1669     if (   (get_SymConst_kind(n) ==symconst_type_tag)
1670        || (get_SymConst_kind(n) ==symconst_size))
1671       {
1672         print_node_type_edge(F,n,get_SymConst_type(n),NODE2TYPE_EDGE_ATTR);
1673       }
1674     break;
1675   case iro_Sel: {
1676       print_node_ent_edge(F,n,get_Sel_entity(n),NODE2TYPE_EDGE_ATTR);
1677     } break;
1678   case iro_Call: {
1679       print_node_type_edge(F,n,get_Call_type(n),NODE2TYPE_EDGE_ATTR);
1680     } break;
1681   case iro_Alloc: {
1682       print_node_type_edge(F,n,get_Alloc_type(n),NODE2TYPE_EDGE_ATTR);
1683     } break;
1684   case iro_Free: {
1685       print_node_type_edge(F,n,get_Free_type(n),NODE2TYPE_EDGE_ATTR);
1686     } break;
1687   case iro_Cast: {
1688       print_node_type_edge(F,n,get_Cast_type(n),NODE2TYPE_EDGE_ATTR);
1689     } break;
1690   default:
1691     break;
1692   }
1693 }
1694
1695 #if 0
1696 static int print_type_info(FILE *F, type *tp) {
1697   int bad = 0;
1698
1699   if (get_type_state(tp) == layout_undefined) {
1700     fprintf(F, "state: layout_undefined\n");
1701   } else {
1702     fprintf(F, "state: layout_fixed,\n");
1703   }
1704   if (get_type_mode(tp))
1705     fprintf(F, "mode: %s,\n", get_mode_name_ex(get_type_mode(tp), &bad));
1706   fprintf(F, "size: %db,\n", get_type_size_bits(tp));
1707
1708   return bad;
1709 }
1710
1711 static void print_typespecific_info(FILE *F, type *tp) {
1712   switch (get_type_tpop_code(tp)) {
1713   case tpo_class:
1714     {
1715       fprintf(F, "peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp)));
1716     } break;
1717   case tpo_struct:
1718     {
1719     } break;
1720   case tpo_method:
1721     {
1722       fprintf(F, "variadicity: %s\n", get_variadicity_name(get_method_variadicity(tp)));
1723       fprintf(F, "params: %d\n", get_method_n_params(tp));
1724       fprintf(F, "results: %d\n", get_method_n_ress(tp));
1725     } break;
1726   case tpo_union:
1727     {
1728     } break;
1729   case tpo_array:
1730     {
1731     } break;
1732   case tpo_enumeration:
1733     {
1734     } break;
1735   case tpo_pointer:
1736     {
1737     } break;
1738   case tpo_primitive:
1739     {
1740     } break;
1741   default: break;
1742   } /* switch type */
1743 }
1744 #endif
1745
1746 static void print_typespecific_vcgattr(FILE *F, type *tp) {
1747   switch (get_type_tpop_code(tp)) {
1748   case tpo_class:
1749     {
1750       if (peculiarity_existent == get_class_peculiarity(tp))
1751     fprintf (F, " " TYPE_CLASS_NODE_ATTR);
1752       else
1753     fprintf (F, " " TYPE_DESCRIPTION_NODE_ATTR);
1754     } break;
1755   case tpo_struct:
1756     {
1757       fprintf (F, " " TYPE_METH_NODE_ATTR);
1758     } break;
1759   case tpo_method:
1760     {
1761     } break;
1762   case tpo_union:
1763     {
1764     } break;
1765   case tpo_array:
1766     {
1767     } break;
1768   case tpo_enumeration:
1769     {
1770     } break;
1771   case tpo_pointer:
1772     {
1773     } break;
1774   case tpo_primitive:
1775     {
1776     } break;
1777   default: break;
1778   } /* switch type */
1779 }
1780
1781
1782 int dump_type_node(FILE *F, type *tp)
1783 {
1784   int bad = 0;
1785
1786   fprintf (F, "node: {title: ");
1787   PRINT_TYPEID(tp);
1788   fprintf (F, " label: \"%s %s\"", get_type_tpop_name(tp), get_type_name_ex(tp, &bad));
1789   fprintf (F, " info1: \"");
1790 #if 0
1791   bad |= print_type_info(F, tp);
1792   print_typespecific_info(F, tp);
1793 #else
1794   dump_type_to_file(F, tp, dump_verbosity_max);
1795 #endif
1796   fprintf (F, "\"\n");
1797   print_dbg_info(F, get_type_dbg_info(tp));
1798   print_typespecific_vcgattr(F, tp);
1799   fprintf (F, "}\n");
1800
1801   return bad;
1802 }
1803
1804
1805 #define X(a)    case a: fprintf(F, #a); break
1806 void dump_entity_node(FILE *F, entity *ent, int color)
1807 {
1808   fprintf (F, "node: {title: \"");
1809   PRINT_ENTID(ent); fprintf(F, "\"");
1810   fprintf (F, DEFAULT_TYPE_ATTRIBUTE);
1811   fprintf (F, "label: ");
1812   fprintf (F, "\"ent %s\" ", get_ent_dump_name(ent));
1813   if (color)
1814     fprintf(F, "color:%d", color);
1815   else
1816     fprintf (F, ENTITY_NODE_ATTR);
1817   fprintf (F, "\n info1: \"");
1818
1819   dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts);
1820
1821   fprintf(F, "\"\n");
1822   print_dbg_info(F, get_entity_dbg_info(ent));
1823   fprintf(F, "}\n");
1824 }
1825 #undef X
1826
1827 static void dump_enum_item(FILE *F, type *tp, int pos)
1828 {
1829   char buf[1024];
1830   ident *id  = get_enumeration_nameid(tp, pos);
1831   tarval *tv = get_enumeration_enum(tp, pos);
1832
1833   tarval_snprintf(buf, sizeof(buf), tv);
1834   fprintf (F, "node: {title: \"");
1835   PRINT_ITEMID(tp, pos); fprintf(F, "\"");
1836   fprintf (F, DEFAULT_ENUM_ITEM_ATTRIBUTE);
1837   fprintf (F, "label: ");
1838   fprintf (F, "\"enum item %s\" " ENUM_ITEM_NODE_ATTR, get_id_str(id));
1839   fprintf (F, "\n info1: \"value: %s\"}\n", buf);
1840 }
1841
1842 /* dumps a type or entity and it's edges. */
1843 static void
1844 dump_type_info(type_or_ent *tore, void *env) {
1845   FILE *F = env;
1846   int i = 0;  /* to shutup gcc */
1847
1848   /* dump this type or entity */
1849
1850   switch (get_kind(tore)) {
1851   case k_entity:
1852     {
1853       entity *ent = (entity *)tore;
1854       ir_node *value;
1855       /* The node */
1856       dump_entity_node(F, ent, 0);
1857       /* The Edges */
1858       /* skip this to reduce graph.  Member edge of type is parallel to this edge. *
1859       fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
1860                 ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
1861       print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
1862       if (is_Class_type(get_entity_owner(ent))) {
1863         for(i = 0; i < get_entity_n_overwrites(ent); i++)
1864           print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, ENT_OVERWRITES_EDGE_ATTR);
1865       }
1866       /* attached subgraphs */
1867       if (const_entities && (get_entity_variability(ent) != variability_uninitialized)) {
1868         if (is_atomic_entity(ent)) {
1869           value = get_atomic_ent_value(ent);
1870           if (value) {
1871             print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
1872             /* DDMN(value);  $$$ */
1873             dump_const_expression(F, value);
1874           }
1875         }
1876         if (is_compound_entity(ent)) {
1877           for (i = 0; i < get_compound_ent_n_values(ent); i++) {
1878             value = get_compound_ent_value(ent, i);
1879             if (value) {
1880               print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
1881               dump_const_expression(F, value);
1882               print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, ENT_CORR_EDGE_ATTR, i);
1883               /*
1884               fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
1885               ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
1886               get_compound_ent_value_member(ent, i), i);
1887               */
1888             }
1889           }
1890         }
1891       }
1892     } break;
1893   case k_type:
1894     {
1895       type *tp = (type *)tore;
1896       dump_type_node(F, tp);
1897       /* and now the edges */
1898       switch (get_type_tpop_code(tp)) {
1899       case tpo_class:
1900         {
1901           for (i=0; i < get_class_n_supertypes(tp); i++)
1902             print_type_type_edge(F, tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
1903           for (i=0; i < get_class_n_members(tp); i++)
1904             print_type_ent_edge(F,tp,get_class_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
1905         } break;
1906       case tpo_struct:
1907         {
1908           for (i=0; i < get_struct_n_members(tp); i++)
1909             print_type_ent_edge(F,tp,get_struct_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
1910         } break;
1911       case tpo_method:
1912         {
1913           for (i = 0; i < get_method_n_params(tp); i++)
1914             print_type_type_edge(F,tp,get_method_param_type(tp, i),METH_PAR_EDGE_ATTR,i);
1915           for (i = 0; i < get_method_n_ress(tp); i++)
1916             print_type_type_edge(F,tp,get_method_res_type(tp, i),METH_RES_EDGE_ATTR,i);
1917         } break;
1918       case tpo_union:
1919         {
1920           for (i = 0; i < get_union_n_members(tp); i++)
1921             print_type_ent_edge(F,tp,get_union_member(tp, i),UNION_EDGE_ATTR);
1922         } break;
1923       case tpo_array:
1924         {
1925           print_type_type_edge(F,tp,get_array_element_type(tp),ARR_ELT_TYPE_EDGE_ATTR);
1926           print_type_ent_edge(F,tp,get_array_element_entity(tp),ARR_ENT_EDGE_ATTR);
1927           for (i = 0; i < get_array_n_dimensions(tp); i++) {
1928             ir_node *upper = get_array_upper_bound(tp, i);
1929             ir_node *lower = get_array_lower_bound(tp, i);
1930             print_node_type_edge(F, upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
1931             print_node_type_edge(F, lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
1932             dump_const_expression(F, upper);
1933             dump_const_expression(F, lower);
1934           }
1935
1936         } break;
1937       case tpo_enumeration:
1938         {
1939           for (i = 0; i < get_enumeration_n_enums(tp); ++i) {
1940             dump_enum_item(F, tp, i);
1941             print_enum_item_edge(F, tp, i, "label: \"item %d\"", i);
1942           }
1943         } break;
1944       case tpo_pointer:
1945         {
1946           print_type_type_edge(F,tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
1947         } break;
1948       case tpo_primitive:
1949         {
1950         } break;
1951       default: break;
1952       } /* switch type */
1953     }
1954     break; /* case k_type */
1955   default:
1956     {
1957       printf(" *** irdump,  dump_type_info(l.%i), faulty type.\n", __LINE__);
1958     } break;
1959   } /* switch kind_or_entity */
1960 }
1961
1962 typedef struct _h_env {
1963   int dump_ent;
1964   FILE *f;
1965 } h_env_t;
1966
1967 /** For dumping class hierarchies.
1968  * Dumps a class type node and a superclass edge.
1969  * If env->dump_ent dumps entities of classes and overwrites edges.
1970  */
1971 static void
1972 dump_class_hierarchy_node (type_or_ent *tore, void *ctx) {
1973   h_env_t *env = ctx;
1974   FILE *F = env->f;
1975   int i = 0;  /* to shutup gcc */
1976
1977   /* dump this type or entity */
1978   switch (get_kind(tore)) {
1979   case k_entity: {
1980     entity *ent = (entity *)tore;
1981     if (get_entity_owner(ent) == get_glob_type()) break;
1982     if (!is_Method_type(get_entity_type(ent))) break;  /* GL */
1983     if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
1984       /* The node */
1985       dump_entity_node(F, ent, 0);
1986       /* The edges */
1987       print_type_ent_edge(F,get_entity_owner(ent),ent,TYPE_MEMBER_EDGE_ATTR);
1988       for(i = 0; i < get_entity_n_overwrites(ent); i++)
1989         print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ENT_OVERWRITES_EDGE_ATTR);
1990     }
1991   } break; /* case k_entity */
1992   case k_type:
1993     {
1994       type *tp = (type *)tore;
1995       if (tp == get_glob_type()) break;
1996       switch (get_type_tpop_code(tp)) {
1997         case tpo_class: {
1998           dump_type_node(F, tp);
1999           /* and now the edges */
2000           for (i=0; i < get_class_n_supertypes(tp); i++)
2001           {
2002               print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
2003           }
2004         } break;
2005         default: break;
2006       } /* switch type */
2007     }
2008     break; /* case k_type */
2009   default:
2010     {
2011       printf(" *** irdump,  dump_class_hierarchy_node(l.%i), faulty type.\n", __LINE__);
2012     } break;
2013   } /* switch kind_or_entity */
2014 }
2015
2016 /*******************************************************************/
2017 /* dump analysis information that is expressed in graph terms.     */
2018 /*******************************************************************/
2019
2020 /* dump out edges */
2021 static void
2022 dump_out_edge(ir_node *n, void *env) {
2023   FILE *F = env;
2024   int i;
2025   for (i = 0; i < get_irn_n_outs(n); i++) {
2026     assert(get_irn_out(n, i));
2027     fprintf (F, "edge: {sourcename: \"");
2028     PRINT_NODEID(n);
2029     fprintf (F, "\" targetname: \"");
2030     PRINT_NODEID(get_irn_out(n, i));
2031     fprintf (F, "\" color: red linestyle: dashed");
2032     fprintf (F, "}\n");
2033   }
2034 }
2035
2036 static INLINE void
2037 dump_loop_label(FILE *F, ir_loop *loop) {
2038   fprintf (F, "loop %d, %d sons, %d nodes",
2039        get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
2040 }
2041
2042 static INLINE void dump_loop_info(FILE *F, ir_loop *loop) {
2043   fprintf (F, " info1: \"");
2044   fprintf (F, " loop nr: %d", get_loop_loop_nr(loop));
2045 #if DEBUG_libfirm   /* GL @@@ debug analyses */
2046   fprintf (F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop)));
2047 #endif
2048   fprintf (F, "\"");
2049 }
2050
2051 static INLINE void
2052 dump_loop_node(FILE *F, ir_loop *loop) {
2053   fprintf (F, "node: {title: \"");
2054   PRINT_LOOPID(loop);
2055   fprintf (F, "\" label: \"");
2056   dump_loop_label(F, loop);
2057   fprintf (F, "\" ");
2058   dump_loop_info(F, loop);
2059   fprintf (F, "}\n");
2060
2061 }
2062
2063 static INLINE void
2064 dump_loop_node_edge(FILE *F, ir_loop *loop, int i) {
2065   assert(loop);
2066   fprintf (F, "edge: {sourcename: \"");
2067   PRINT_LOOPID(loop);
2068   fprintf (F, "\" targetname: \"");
2069   PRINT_NODEID(get_loop_node(loop, i));
2070   fprintf (F, "\" color: green");
2071   fprintf (F, "}\n");
2072 }
2073
2074 static INLINE void
2075 dump_loop_son_edge(FILE *F, ir_loop *loop, int i) {
2076   assert(loop);
2077   fprintf (F, "edge: {sourcename: \"");
2078   PRINT_LOOPID(loop);
2079   fprintf (F, "\" targetname: \"");
2080   PRINT_LOOPID(get_loop_son(loop, i));
2081   fprintf (F, "\" color: darkgreen label: \"%d\"}\n",
2082        get_loop_element_pos(loop, get_loop_son(loop, i)));
2083 }
2084
2085 static
2086 void dump_loops(FILE *F, ir_loop *loop) {
2087   int i;
2088   /* dump this loop node */
2089   dump_loop_node(F, loop);
2090
2091   /* dump edges to nodes in loop -- only if it is a real loop */
2092   if (get_loop_depth(loop) != 0) {
2093     for (i = 0; i < get_loop_n_nodes(loop); i++) {
2094       dump_loop_node_edge(F, loop, i);
2095     }
2096   }
2097   for (i = 0; i < get_loop_n_sons(loop); i++) {
2098     dump_loops(F, get_loop_son(loop, i));
2099     dump_loop_son_edge(F, loop, i);
2100   }
2101 }
2102
2103 static INLINE
2104 void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) {
2105   ir_graph *rem = current_ir_graph;
2106   current_ir_graph = irg;
2107
2108   if (get_irg_loop(irg)) dump_loops(F, get_irg_loop(irg));
2109
2110   current_ir_graph = rem;
2111 }
2112
2113
2114 /**
2115  * dumps the VCG header
2116  */
2117 void dump_vcg_header(FILE *F, const char *name, const char *orientation) {
2118   char *label;
2119
2120   if (edge_label) {
2121     label = "yes";
2122   } else {
2123     label = "no";
2124   }
2125
2126   if (!orientation) orientation = "bottom_to_top";
2127
2128   /* print header */
2129   fprintf (F,
2130        "graph: { title: \"ir graph of %s\"\n"
2131        "display_edge_labels: %s\n"
2132        "layoutalgorithm: mindepth\n"
2133        "manhattan_edges: yes\n"
2134        "port_sharing: no\n"
2135        "orientation: %s\n"
2136        "classname 1:  \"intrablock Data\"\n"
2137        "classname 2:  \"Block\"\n"
2138        "classname 3:  \"Entity type\"\n"
2139        "classname 4:  \"Entity owner\"\n"
2140        "classname 5:  \"Method Param\"\n"
2141        "classname 6:  \"Method Res\"\n"
2142        "classname 7:  \"Super\"\n"
2143        "classname 8:  \"Union\"\n"
2144        "classname 9:  \"Points-to\"\n"
2145        "classname 10: \"Array Element Type\"\n"
2146        "classname 11: \"Overwrites\"\n"
2147        "classname 12: \"Member\"\n"
2148        "classname 13: \"Control Flow\"\n"
2149        "classname 14: \"intrablock Memory\"\n"
2150        "classname 15: \"Dominators\"\n"
2151        "classname 16: \"interblock Data\"\n"
2152        "classname 17: \"interblock Memory\"\n"
2153        "classname 18: \"Exception Control Flow for Interval Analysis\"\n"
2154        "classname 19: \"Postdominators\"\n"
2155        "infoname 1: \"Attribute\"\n"
2156        "infoname 2: \"Verification errors\"\n"
2157        "infoname 3: \"Debug info\"\n",
2158        name, label, orientation);
2159
2160   /* don't use all, the range is too whith/black. */
2161   n_colors   = 18;
2162   base_color = 105;
2163   fprintf (F,
2164        "colorentry 100:    0   0    0\n"
2165        "colorentry 101:   20   0    0\n"
2166        "colorentry 102:   40   0    0\n"
2167        "colorentry 103:   60   0    0\n"
2168        "colorentry 104:   80   0    0\n"
2169        "colorentry 105:  100   0    0\n"
2170        "colorentry 106:  120   0    0\n"
2171        "colorentry 107:  140   0    0\n"
2172        "colorentry 108:  150   0    0\n"
2173        "colorentry 109:  180   0    0\n"
2174        "colorentry 110:  200   0    0\n"
2175        "colorentry 111:  220   0    0\n"
2176        "colorentry 112:  240   0    0\n"
2177        "colorentry 113:  255   0    0\n"
2178        "colorentry 113:  255  20   20\n"
2179        "colorentry 114:  255  40   40\n"
2180        "colorentry 115:  255  60   60\n"
2181        "colorentry 116:  255  80   80\n"
2182        "colorentry 117:  255 100  100\n"
2183        "colorentry 118:  255 120  120\n"
2184        "colorentry 119:  255 140  140\n"
2185        "colorentry 120:  255 150  150\n"
2186        "colorentry 121:  255 180  180\n"
2187        "colorentry 122:  255 200  200\n"
2188        "colorentry 123:  255 220  220\n"
2189        "colorentry 124:  255 240  240\n"
2190        "colorentry 125:  255 250  250\n"
2191        );
2192
2193   fprintf (F, "\n");        /* a separator */
2194 }
2195
2196 /**
2197  * open a vcg file
2198  *
2199  * @param irg     The graph to be dumped
2200  * @param suffix1 first filename suffix
2201  * @param suffix2 second filename suffix
2202  */
2203 FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
2204   FILE *F;
2205   const char *nm = get_irg_dump_name(irg);
2206   int len = strlen(nm), i, j;
2207   char *fname;  /* filename to put the vcg information in */
2208
2209   if (!suffix1) suffix1 = "";
2210   if (!suffix2) suffix2 = "";
2211
2212   /* open file for vcg graph */
2213   fname = malloc (len * 2 + strlen(suffix1) + strlen(suffix2) + 5);
2214
2215   /* strncpy (fname, nm, len); */     /* copy the filename */
2216   j = 0;
2217   for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
2218     if (nm[i] == '/') {
2219       fname[j] = '@'; j++; fname[j] = '1'; j++;
2220     } else if (nm[i] == '@') {
2221       fname[j] = '@'; j++; fname[j] = '2'; j++;
2222     } else {
2223       fname[j] = nm[i]; j++;
2224     }
2225   }
2226   fname[j] = '\0';
2227   strcat (fname, suffix1);  /* append file suffix */
2228   strcat (fname, suffix2);  /* append file suffix */
2229   strcat (fname, ".vcg");   /* append the .vcg suffix */
2230
2231   /* vcg really expect only a <CR> at end of line, so
2232    * the "b"inary mode is what you mean (and even needed for Win32)
2233    */
2234   F = fopen (fname, "wb");  /* open file for writing */
2235   if (!F) {
2236     panic("cannot open %s for writing (%m)", fname);  /* not reached */
2237   }
2238   free(fname);
2239
2240   return F;
2241 }
2242
2243 /**
2244  * open a vcg file
2245  *
2246  * @param name    prefix file name
2247  * @param suffix  filename suffix
2248  */
2249 FILE *vcg_open_name (const char *name, const char *suffix) {
2250   FILE *F;
2251   char *fname;  /* filename to put the vcg information in */
2252   int i, j, len = strlen(name);
2253
2254   if (!suffix) suffix = "";
2255
2256   /** open file for vcg graph */
2257   fname = xmalloc(len * 2 + 5 + strlen(suffix));
2258   /* strcpy (fname, name);*/    /* copy the filename */
2259   j = 0;
2260   for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
2261     if (name[i] == '/') {
2262       fname[j] = '@'; j++; fname[j] = '1'; j++;
2263     } else if (name[i] == '@') {
2264       fname[j] = '@'; j++; fname[j] = '2'; j++;
2265     } else {
2266       fname[j] = name[i]; j++;
2267     }
2268   }
2269   fname[j] = '\0';
2270   strcat (fname, suffix);
2271   strcat (fname, ".vcg");  /* append the .vcg suffix */
2272
2273   /* vcg really expect only a <CR> at end of line, so
2274    * the "b"inary mode is what you mean (and even needed for Win32)
2275    */
2276   F = fopen (fname, "wb");  /* open file for writing */
2277   if (!F) {
2278     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
2279   }
2280   free(fname);
2281
2282   return F;
2283 }
2284
2285 /**
2286  * Dumps the vcg file footer
2287  */
2288 static INLINE void dump_vcg_footer (FILE *F) {
2289   fprintf (F, "}\n");
2290 }
2291
2292 /**
2293  * close the vcg file
2294  */
2295 void vcg_close (FILE *F) {
2296   dump_vcg_footer(F);    /* print footer */
2297   fclose (F);           /* close vcg file */
2298 }
2299
2300 /************************************************************************/
2301 /************************************************************************/
2302 /* Routines that dump all or parts of the firm representation to a file */
2303 /************************************************************************/
2304 /************************************************************************/
2305
2306 /************************************************************************/
2307 /* Dump ir graphs, different formats and additional information.        */
2308 /************************************************************************/
2309
2310 /** Routine to dump a graph, blocks as conventional nodes.  */
2311 void
2312 dump_ir_graph (ir_graph *irg, const char *suffix )
2313 {
2314   FILE *f;
2315   ir_graph *rem;
2316   char *suffix1;
2317   rem = current_ir_graph;
2318
2319   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2320
2321   current_ir_graph = irg;
2322   if (get_interprocedural_view()) suffix1 = "-pure-ip";
2323   else                            suffix1 = "-pure";
2324   f = vcg_open(irg, suffix, suffix1);
2325   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2326
2327   /* call the dump graph hook */
2328   if (dump_ir_graph_hook)
2329     if (dump_ir_graph_hook(f, irg))
2330       return;
2331
2332   /* walk over the graph */
2333   /* dump_whole_node must be called in post visiting predecessors */
2334   irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
2335
2336   /* dump the out edges in a separate walk */
2337   if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) {
2338     irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, f);
2339   }
2340
2341   vcg_close(f);
2342
2343   current_ir_graph = rem;
2344 }
2345
2346 /* Dump a firm graph without explicit block nodes. */
2347 void dump_ir_block_graph (ir_graph *irg, const char *suffix)
2348 {
2349   FILE *f;
2350   int i;
2351   char *suffix1;
2352
2353   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2354     return;
2355
2356   if (get_interprocedural_view()) suffix1 = "-ip";
2357   else                            suffix1 = "";
2358   f = vcg_open(irg, suffix, suffix1);
2359   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2360
2361   construct_block_lists(irg);
2362
2363   /*
2364    * If we are in the interprocedural view, we dump not
2365    * only the requested irg but also all irgs that can be reached
2366    * from irg.
2367    */
2368   for (i = 0; i < get_irp_n_irgs(); i++) {
2369     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
2370     if (arr) {
2371       dump_graph_from_list(f, get_irp_irg(i));
2372       DEL_ARR_F(arr);
2373     }
2374   }
2375
2376   vcg_close(f);
2377 }
2378
2379 /* Dump a firm graph without explicit block nodes but grouped in extended blocks. */
2380 void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
2381 {
2382   FILE *F;
2383   int i;
2384   char *suffix1;
2385   entity *ent;
2386
2387   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2388     return;
2389
2390   compute_extbb(irg);
2391
2392   if (get_interprocedural_view()) suffix1 = "-ip";
2393   else                            suffix1 = "";
2394
2395   ent = get_irg_entity(irg);
2396
2397   F = vcg_open(irg, suffix, suffix1);
2398   dump_vcg_header(F, get_irg_dump_name(irg), NULL);
2399
2400   construct_extblock_lists(irg);
2401
2402   fprintf(F, "graph: { title: \"");
2403   PRINT_IRGID(irg);
2404   fprintf(F, "\" label: \"%s\" status:clustered color: white \n",
2405     get_ent_dump_name(ent));
2406
2407   dump_graph_info(F, irg);
2408   print_dbg_info(F, get_entity_dbg_info(ent));
2409
2410   for (i = 0; i < get_irp_n_irgs(); i++) {
2411     ir_graph *irg     = get_irp_irg(i);
2412     list_tuple *lists = ird_get_irg_link(irg);
2413
2414     if (lists) {
2415       /* dump the extended blocks first */
2416       if (ARR_LEN(lists->extbb_list)) {
2417         ird_set_irg_link(irg, lists->extbb_list);
2418         dump_extblock_graph(F, irg);
2419       }
2420
2421       /* we may have blocks without extended blocks, bad for instance */
2422       if (ARR_LEN(lists->blk_list)) {
2423         ird_set_irg_link(irg, lists->blk_list);
2424         dump_block_graph(F, irg);
2425       }
2426
2427       DEL_ARR_F(lists->extbb_list);
2428       DEL_ARR_F(lists->blk_list);
2429       xfree(lists);
2430     }
2431   }
2432
2433   /* Close the vcg information for the irg */
2434   fprintf(F, "}\n\n");
2435
2436   vcg_close(F);
2437   free_extbb(irg);
2438 }
2439
2440 /* dumps a graph with type information */
2441 void
2442 dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
2443 {
2444   FILE *f;
2445   ir_graph *rem = current_ir_graph;
2446   char *suffix1;
2447   int rem_dump_const_local;
2448
2449   /* if a filter is set, dump only the irg's that match the filter */
2450   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2451     return;
2452
2453   current_ir_graph = irg;
2454   rem_dump_const_local = dump_const_local;
2455   /* dumping types does not work with local nodes */
2456   dump_const_local = 0;
2457
2458   if (get_interprocedural_view()) suffix1 = "-pure-wtypes-ip";
2459   else                            suffix1 = "-pure-wtypes";
2460   f = vcg_open(irg,suffix, suffix1);
2461   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2462
2463   /* dump common ir graph */
2464   irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
2465   /* dump type info */
2466   type_walk_irg(irg, dump_type_info, NULL, f);
2467   inc_irg_visited(get_const_code_irg());
2468   /* dump edges from graph to type info */
2469   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
2470
2471   vcg_close(f);
2472   dump_const_local = rem_dump_const_local;
2473   current_ir_graph = rem;
2474 }
2475
2476 void
2477 dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
2478 {
2479   FILE *f;
2480   int i;
2481   char *suffix1;
2482   ir_graph *rem = current_ir_graph;
2483   int rem_dump_const_local;
2484
2485   /* if a filter is set, dump only the irg's that match the filter */
2486   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2487     return;
2488
2489   rem_dump_const_local = dump_const_local;
2490   /* dumping types does not work with local nodes */
2491   dump_const_local = 0;
2492
2493   if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
2494   else                            suffix1 = "-wtypes";
2495   f = vcg_open(irg, suffix, suffix1);
2496   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2497
2498   /* dump common blocked ir graph */
2499   construct_block_lists(irg);
2500
2501   for (i = 0; i < get_irp_n_irgs(); i++) {
2502     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
2503     if (arr) {
2504       dump_graph_from_list(f, get_irp_irg(i));
2505       DEL_ARR_F(arr);
2506     }
2507   }
2508
2509   /* dump type info */
2510   current_ir_graph = irg;
2511   type_walk_irg(irg, dump_type_info, NULL, f);
2512   inc_irg_visited(get_const_code_irg());
2513
2514   /* dump edges from graph to type info */
2515   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
2516
2517   vcg_close(f);
2518   dump_const_local = rem_dump_const_local;
2519   current_ir_graph = rem;
2520 }
2521
2522 /*---------------------------------------------------------------------*/
2523 /* The following routines dump a control flow graph.                   */
2524 /*---------------------------------------------------------------------*/
2525
2526 static void
2527 dump_block_to_cfg(ir_node *block, void *env) {
2528   FILE *F = env;
2529   int i, fl = 0;
2530   ir_node *pred;
2531
2532   if (is_Block(block)) {
2533     /* This is a block. Dump a node for the block. */
2534     fprintf (F, "node: {title: \""); PRINT_NODEID(block);
2535     fprintf (F, "\" label: \"");
2536     if (block == get_irg_start_block(get_irn_irg(block)))
2537       fprintf(F, "Start ");
2538     if (block == get_irg_end_block(get_irn_irg(block)))
2539       fprintf(F, "End ");
2540
2541     fprintf (F, "%s ", get_op_name(get_irn_op(block)));
2542     PRINT_NODEID(block);
2543     fprintf (F, "\" ");
2544     fprintf(F, "info1:\"");
2545
2546     /* the generic version. */
2547     dump_irnode_to_file(F, block);
2548
2549     /* Check whether we have bad predecessors to color the block. */
2550     for (i = 0; i < get_Block_n_cfgpreds(block); ++i)
2551       if ((fl = is_Bad(get_Block_cfgpred(block, i))))
2552         break;
2553
2554     fprintf (F, "\"");  /* closing quote of info */
2555
2556     if ((block == get_irg_start_block(get_irn_irg(block))) ||
2557     (block == get_irg_end_block(get_irn_irg(block)))     )
2558       fprintf(F, " color:blue ");
2559     else if (fl)
2560       fprintf(F, " color:yellow ");
2561
2562     fprintf (F, "}\n");
2563     /* Dump the edges */
2564     for ( i = 0; i < get_Block_n_cfgpreds(block); i++)
2565       if (get_irn_op(skip_Proj(get_Block_cfgpred(block, i))) != op_Bad) {
2566         pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
2567         fprintf (F, "edge: { sourcename: \"");
2568         PRINT_NODEID(block);
2569         fprintf (F, "\" targetname: \"");
2570         PRINT_NODEID(pred);
2571         fprintf (F, "\"}\n");
2572       }
2573
2574     /* Dump dominator/postdominator edge */
2575     if (dump_dominator_information_flag) {
2576       if (get_irg_dom_state(current_ir_graph) == dom_consistent && get_Block_idom(block)) {
2577         pred = get_Block_idom(block);
2578         fprintf (F, "edge: { sourcename: \"");
2579         PRINT_NODEID(block);
2580         fprintf (F, "\" targetname: \"");
2581         PRINT_NODEID(pred);
2582         fprintf (F, "\" " DOMINATOR_EDGE_ATTR "}\n");
2583       }
2584       if (get_irg_postdom_state(current_ir_graph) == dom_consistent && get_Block_ipostdom(block)) {
2585         pred = get_Block_ipostdom(block);
2586         fprintf (F, "edge: { sourcename: \"");
2587         PRINT_NODEID(block);
2588         fprintf (F, "\" targetname: \"");
2589         PRINT_NODEID(pred);
2590         fprintf (F, "\" " POSTDOMINATOR_EDGE_ATTR "}\n");
2591       }
2592     }
2593   }
2594 }
2595
2596 void
2597 dump_cfg (ir_graph *irg, const char *suffix)
2598 {
2599   FILE *f;
2600   ir_graph *rem = current_ir_graph;
2601   int ipv = get_interprocedural_view();
2602
2603   /* if a filter is set, dump only the irg's that match the filter */
2604   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2605     return;
2606
2607   current_ir_graph = irg;
2608
2609   f = vcg_open(irg, suffix, "-cfg");
2610   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2611
2612   if (ipv) {
2613     printf("Warning: dumping cfg not in interprocedural view!\n");
2614     set_interprocedural_view(0);
2615   }
2616
2617   /* walk over the blocks in the graph */
2618   irg_block_walk(get_irg_end(irg), dump_block_to_cfg, NULL, f);
2619   dump_node(f, get_irg_bad(irg));
2620
2621   set_interprocedural_view(ipv);
2622   vcg_close(f);
2623   current_ir_graph = rem;
2624 }
2625
2626
2627 static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
2628   if (pset_find_ptr(mark_set, n)) return;
2629
2630   pset_insert_ptr(mark_set, n);
2631
2632   if (depth > 0) {
2633     int i, start = is_Block(n) ? 0 : -1;
2634     dump_whole_node(n, F);
2635     for (i = start; i < get_irn_arity(n); ++i)
2636       descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
2637   } else {
2638     dump_node(F, n);
2639     /* Don't dump edges to nodes further out.  These might be edges to
2640        nodes we already dumped, if there is a shorter path to these. */
2641   }
2642 }
2643
2644 static int subgraph_counter = 0;
2645 void dump_subgraph (ir_node *root, int depth, const char *suffix) {
2646   FILE *F;
2647   char buf[32];
2648   pset *mark_set = pset_new_ptr(1);
2649   sprintf(buf, "-subg_%03d", subgraph_counter++);
2650   F = vcg_open(get_irn_irg(root), suffix, buf);
2651   dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
2652   descend_and_dump(F, root, depth, mark_set);
2653   vcg_close(F);
2654   del_pset(mark_set);
2655 }
2656
2657
2658 static int weight_overall(int rec, int loop) {
2659   return 2*rec + loop;
2660 }
2661
2662 static int compute_color (int my, int max) {
2663   int color;
2664   if (!max) {
2665     color = 0;
2666   } else {
2667     int step;
2668
2669     /* if small, scale to the full color range. */
2670     if (max < n_colors)
2671       my = my * (n_colors/max);
2672
2673     step = 1 + (max / n_colors);
2674
2675     color = my/step;
2676   }
2677   return base_color + n_colors - color;
2678 }
2679
2680 static int get_entity_color(entity *ent) {
2681   ir_graph *irg = get_entity_irg(ent);
2682   assert(irg);
2683
2684   {
2685     int rec_depth     = get_irg_recursion_depth(irg);
2686     int loop_depth    = get_irg_loop_depth(irg);
2687     int overall_depth = weight_overall(rec_depth, loop_depth);
2688
2689     int max_rec_depth     = irp->max_callgraph_recursion_depth;
2690     int max_loop_depth    = irp->max_callgraph_loop_depth;
2691     int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
2692
2693     /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
2694     /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
2695     int my_overall_color = compute_color(overall_depth, max_overall_depth);;
2696
2697     return my_overall_color;
2698   }
2699 }
2700
2701 void dump_callgraph(const char *suffix) {
2702   FILE *F;
2703   int i, n_irgs = get_irp_n_irgs();
2704   int rem = edge_label;
2705   edge_label = 1;
2706   //ident *prefix = new_id_from_str("java/");
2707
2708   F = vcg_open_name("Callgraph", suffix);
2709   dump_vcg_header(F, "Callgraph", NULL);
2710
2711   for (i = 0; i < n_irgs; ++i) {
2712     ir_graph *irg = get_irp_irg(i);
2713     entity *ent = get_irg_entity(irg);
2714     int j, n_callees = get_irg_n_callees(irg);
2715
2716     /* Do not dump runtime system. */
2717     //if (id_is_prefix(prefix, get_entity_ld_ident(ent))) continue;
2718
2719     dump_entity_node(F, ent, get_entity_color(ent));
2720     for (j = 0; j < n_callees; ++j) {
2721       entity *c = get_irg_entity(get_irg_callee(irg, j));
2722       //if (id_is_prefix(prefix, get_entity_ld_ident(c))) continue;
2723       int be = is_irg_callee_backedge(irg, j);
2724       char *attr;
2725       attr = (be) ?
2726         "label:\"recursion %d\" color:%d" :
2727         "label:\"calls %d\" color:%d";
2728       print_ent_ent_edge(F, ent, c, be, attr, get_irg_callee_loop_depth(irg, j), get_entity_color(ent));
2729     }
2730   }
2731
2732   edge_label = rem;
2733   vcg_close(F);
2734 }
2735
2736 /* Dump all irgs in interprocedural view to a single file. */
2737 void dump_all_cg_block_graph(const char *suffix) {
2738   FILE *f;
2739   int i;
2740   int rem_view = get_interprocedural_view();
2741   set_interprocedural_view(1);
2742
2743   f = vcg_open_name("All_graphs", suffix);
2744   dump_vcg_header(f, "All_graphs", NULL);
2745
2746   /* collect nodes in all irgs reachable in call graph*/
2747   for (i = 0; i < get_irp_n_irgs(); i++)
2748     ird_set_irg_link(get_irp_irg(i), NULL);
2749
2750   cg_walk(clear_link, collect_node, NULL);
2751
2752   /* dump all graphs */
2753   for (i = 0; i < get_irp_n_irgs(); i++) {
2754     current_ir_graph = get_irp_irg(i);
2755     assert(ird_get_irg_link(current_ir_graph));
2756     dump_graph_from_list(f, current_ir_graph);
2757     DEL_ARR_F(ird_get_irg_link(current_ir_graph));
2758   }
2759
2760   vcg_close(f);
2761   set_interprocedural_view(rem_view);
2762 }
2763
2764 /*---------------------------------------------------------------------*/
2765 /* the following routines dumps type information without any ir nodes. */
2766 /*---------------------------------------------------------------------*/
2767
2768 void
2769 dump_type_graph (ir_graph *irg, const char *suffix)
2770 {
2771   FILE *f;
2772   ir_graph *rem;
2773   rem = current_ir_graph;
2774
2775   /* if a filter is set, dump only the irg's that match the filter */
2776   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2777
2778   current_ir_graph = irg;
2779
2780   f = vcg_open(irg, suffix, "-type");
2781   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2782
2783   /* walk over the blocks in the graph */
2784   type_walk_irg(irg, dump_type_info, NULL, f);
2785   /* The walker for the const code can be called several times for the
2786      same (sub) expression.  So that no nodes are dumped several times
2787      we decrease the visited flag of the corresponding graph after each
2788      walk.  So now increase it finally. */
2789   inc_irg_visited(get_const_code_irg());
2790
2791   vcg_close(f);
2792   current_ir_graph = rem;
2793 }
2794
2795 void
2796 dump_all_types (const char *suffix)
2797 {
2798   FILE *f = vcg_open_name("All_types", suffix);
2799   dump_vcg_header(f, "All_types", NULL);
2800   type_walk(dump_type_info, NULL, f);
2801   inc_irg_visited(get_const_code_irg());
2802   vcg_close(f);
2803 }
2804
2805 void
2806 dump_class_hierarchy (int entities, const char *suffix)
2807 {
2808   FILE *f = vcg_open_name("class_hierarchy", suffix);
2809   h_env_t env;
2810
2811   env.f        = f;
2812   env.dump_ent = entities;
2813   dump_vcg_header(f, "class_hierarchy", NULL);
2814   type_walk(dump_class_hierarchy_node, NULL, &env);
2815   vcg_close(f);
2816 }
2817
2818 /*---------------------------------------------------------------------*/
2819 /* dumps all graphs with the graph-dumper passed. Possible dumpers:    */
2820 /*  dump_ir_graph                                                      */
2821 /*  dump_ir_block_graph                                                */
2822 /*  dump_cfg                                                           */
2823 /*  dump_type_graph                                                    */
2824 /*  dump_ir_graph_w_types                                              */
2825 /*---------------------------------------------------------------------*/
2826
2827 void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
2828   int i;
2829   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
2830     dmp_grph(get_irp_irg(i), suffix);
2831   }
2832 }
2833
2834
2835 /*--------------------------------------------------------------------------------*
2836  * Dumps a stand alone loop graph with firm nodes which belong to one loop node   *
2837  * packed together in one subgraph/box                                            *
2838  *--------------------------------------------------------------------------------*/
2839
2840 void dump_loops_standalone(FILE *F, ir_loop *loop) {
2841   int i = 0, loop_node_started = 0, son_number = 0, first = 0;
2842   loop_element le;
2843   ir_loop *son = NULL;
2844
2845   /* Dump a new loop node. */
2846   dump_loop_node(F, loop);
2847
2848   /* Dump the loop elements. */
2849
2850   for(i = 0; i < get_loop_n_elements(loop); i++) {
2851     le = get_loop_element(loop, i);
2852     son = le.son;
2853     if (get_kind(son) == k_ir_loop) {
2854
2855       /* We are a loop son -> Recurse */
2856
2857       if(loop_node_started) { /* Close the "firm-nodes" node first if we started one. */
2858         fprintf(F, "\" }\n");
2859         fprintf (F, "edge: {sourcename: \"");
2860         PRINT_LOOPID(loop);
2861         fprintf (F, "\" targetname: \"");
2862         PRINT_LOOPID(loop);
2863         fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
2864         loop_node_started = 0;
2865       }
2866       dump_loop_son_edge(F, loop, son_number++);
2867       dump_loops_standalone(F, son);
2868     } else if (get_kind(son) == k_ir_node) {
2869       /* We are a loop node -> Collect firm nodes */
2870
2871       ir_node *n = le.node;
2872       int bad = 0;
2873
2874       if (!loop_node_started) {
2875         /* Start a new node which contains all firm nodes of the current loop */
2876         fprintf (F, "node: { title: \"");
2877         PRINT_LOOPID(loop);
2878         fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
2879         loop_node_started = 1;
2880         first = i;
2881       }
2882       else
2883         fprintf(F, "\n");
2884
2885       bad |= dump_node_label(F, n);
2886       /* Causes indeterministic output: if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); */
2887       if (has_backedges(n)) fprintf(F, "\t loop head!");
2888     } else { /* for callgraph loop tree */
2889       ir_graph *n;
2890       assert(get_kind(son) == k_ir_graph);
2891
2892       /* We are a loop node -> Collect firm graphs */
2893       n = (ir_graph *)le.node;
2894       if (!loop_node_started) {
2895         /* Start a new node which contains all firm nodes of the current loop */
2896         fprintf (F, "node: { title: \"");
2897         PRINT_LOOPID(loop);
2898         fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
2899         loop_node_started = 1;
2900         first = i;
2901       }
2902       else
2903         fprintf(F, "\n");
2904       fprintf (F, " %s", get_irg_dump_name(n));
2905       /* fprintf (F, " %s (depth %d)", get_irg_dump_name(n), n->callgraph_weighted_loop_depth); */
2906     }
2907   }
2908
2909   if (loop_node_started) {
2910     fprintf(F, "\" }\n");
2911     fprintf (F, "edge: {sourcename: \"");
2912     PRINT_LOOPID(loop);
2913     fprintf (F, "\" targetname: \"");
2914     PRINT_LOOPID(loop);
2915     fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
2916     loop_node_started = 0;
2917   }
2918 }
2919
2920 void dump_loop_tree(ir_graph *irg, const char *suffix)
2921 {
2922   FILE *f;
2923   ir_graph *rem = current_ir_graph;
2924   int el_rem = edge_label;
2925   edge_label = 1;
2926
2927   /* if a filter is set, dump only the irg's that match the filter */
2928   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2929
2930   current_ir_graph = irg;
2931
2932   f = vcg_open(irg, suffix, "-looptree");
2933   dump_vcg_header(f, get_irg_dump_name(irg), "top_to_bottom");
2934
2935   if (get_irg_loop(irg)) dump_loops_standalone(f, get_irg_loop(irg));
2936
2937   vcg_close(f);
2938
2939   edge_label = el_rem;
2940   current_ir_graph = rem;
2941 }
2942
2943 void dump_callgraph_loop_tree(const char *suffix) {
2944   FILE *F;
2945   F = vcg_open_name("Callgraph_looptree", suffix);
2946   dump_vcg_header(F, "callgraph looptree", "top_to_bottom");
2947   dump_loops_standalone(F, irp->outermost_cg_loop);
2948   vcg_close(F);
2949 }
2950
2951
2952 /*-----------------------------------------------------------------------------*/
2953 /* Dumps the firm nodes in the loop tree to a graph along with the loop nodes. */
2954 /*-----------------------------------------------------------------------------*/
2955
2956 void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
2957   int i, son_number = 0, node_number = 0;
2958
2959   if (dump_loop_information_flag) dump_loop_node(F, loop);
2960
2961   for (i = 0; i < get_loop_n_elements(loop); i++) {
2962     loop_element le = get_loop_element(loop, i);
2963     if (*(le.kind) == k_ir_loop) {
2964       if (dump_loop_information_flag) dump_loop_son_edge(F, loop, son_number++);
2965       /* Recur */
2966       collect_nodeloop(F, le.son, loopnodes);
2967     } else {
2968       if (dump_loop_information_flag) dump_loop_node_edge(F, loop, node_number++);
2969       eset_insert(loopnodes, le.node);
2970     }
2971   }
2972 }
2973
2974 void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extnodes) {
2975   int i, j, start;
2976
2977   for(i = 0; i < get_loop_n_elements(loop); i++) {
2978     loop_element le = get_loop_element(loop, i);
2979     if (*(le.kind) == k_ir_loop) {
2980       /* Recur */
2981       collect_nodeloop_external_nodes(le.son, loopnodes, extnodes);
2982     } else {
2983       if (is_Block(le.node)) start = 0; else start = -1;
2984       for (j = start; j < get_irn_arity(le.node); j++) {
2985         ir_node *pred = get_irn_n(le.node, j);
2986         if (!eset_contains(loopnodes, pred)) {
2987           eset_insert(extnodes, pred);
2988           if (!is_Block(pred)) {
2989             pred = get_nodes_block(pred);
2990             if (!eset_contains(loopnodes, pred)) eset_insert(extnodes, pred);
2991           }
2992         }
2993       }
2994     }
2995   }
2996 }
2997
2998 void dump_loop(ir_loop *l, const char *suffix) {
2999   FILE *F;
3000   char name[50];
3001   eset *loopnodes = eset_create();
3002   eset *extnodes = eset_create();
3003   ir_node *n, *b;
3004
3005   snprintf(name, sizeof(name), "loop_%d", get_loop_loop_nr(l));
3006   F = vcg_open_name (name, suffix);
3007   dump_vcg_header(F, name, NULL);
3008
3009   /* collect all nodes to dump */
3010   collect_nodeloop(F, l, loopnodes);
3011   collect_nodeloop_external_nodes(l, loopnodes, extnodes);
3012
3013   /* build block lists */
3014   for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
3015     set_irn_link(n, NULL);
3016   for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
3017     set_irn_link(n, NULL);
3018   for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
3019     if (!is_Block(n)) {
3020       b = get_nodes_block(n);
3021       set_irn_link(n, get_irn_link(b));
3022       set_irn_link(b, n);
3023     }
3024   for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
3025     if (!is_Block(n)) {
3026       b = get_nodes_block(n);
3027       set_irn_link(n, get_irn_link(b));
3028       set_irn_link(b, n);
3029     }
3030
3031   for (b = eset_first(loopnodes); b != NULL; b = eset_next(loopnodes))
3032     if (is_Block(b)) {
3033       fprintf(F, "graph: { title: \"");
3034       PRINT_NODEID(b);
3035       fprintf(F, "\"  label: \"");
3036       dump_node_opcode(F, b);
3037       fprintf (F, " %ld", get_irn_node_nr(b));
3038       fprintf(F, "\" status:clustered color:yellow\n");
3039
3040       /* dump the blocks edges */
3041       dump_ir_data_edges(F, b);
3042
3043       /* dump the nodes that go into the block */
3044       for (n = get_irn_link(b); n; n = get_irn_link(n)) {
3045         if (eset_contains(extnodes, n))
3046           overrule_nodecolor = ird_color_lightblue;
3047         dump_node(F, n);
3048         overrule_nodecolor = ird_color_default;
3049         if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n);
3050       }
3051
3052       /* Close the vcg information for the block */
3053       fprintf(F, "}\n");
3054       dump_const_node_local(F, b);
3055       fprintf(F, "\n");
3056     }
3057   for (b = eset_first(extnodes); b != NULL; b = eset_next(extnodes))
3058     if (is_Block(b)) {
3059       fprintf(F, "graph: { title: \"");
3060       PRINT_NODEID(b);
3061       fprintf(F, "\"  label: \"");
3062       dump_node_opcode(F, b);
3063       fprintf (F, " %ld", get_irn_node_nr(b));
3064       fprintf(F, "\" status:clustered color:lightblue\n");
3065
3066       /* dump the nodes that go into the block */
3067       for (n = get_irn_link(b); n; n = get_irn_link(n)) {
3068         if (!eset_contains(loopnodes, n))
3069           overrule_nodecolor = ird_color_lightblue;
3070         dump_node(F, n);
3071         overrule_nodecolor = ird_color_default;
3072         if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n);
3073       }
3074
3075       /* Close the vcg information for the block */
3076       fprintf(F, "}\n");
3077       dump_const_node_local(F, b);
3078       fprintf(F, "\n");
3079     }
3080
3081   eset_destroy(loopnodes);
3082   eset_destroy(extnodes);
3083   vcg_close(F);
3084 }