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