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
 922   default:
 923     ;
 924   } /* end switch */
 925
 926   return bad;
 927 }
 928
 929 #include <math.h>
 930 #include "execution_frequency.h"
 931 #include "callgraph.h"
 932
 933 void dump_node_ana_vals(FILE *F, ir_node *n) {
 934   return;
 935   fprintf(F, " %lf*(%2.0lf + %2.0lf) = %2.0lf ",
 936           get_irn_exec_freq(n),
 937           get_irg_method_execution_frequency(get_irn_irg(n)),
 938           pow(5, get_irg_recursion_depth(get_irn_irg(n))),
 939           get_irn_exec_freq(n) * (get_irg_method_execution_frequency(get_irn_irg(n)) + pow(5, get_irg_recursion_depth(get_irn_irg(n))))
 940           );
 941 }
 942
 943
 944 /* Dumps a node label without the enclosing ". */
 945 int dump_node_label(FILE *F, ir_node *n) {
 946   int bad = 0;
 947
 948   bad |= dump_node_opcode(F, n);
 949   bad |= dump_node_mode(F, n);
 950   fprintf (F, " ");
 951   bad |= dump_node_typeinfo(F, n);
 952   bad |= dump_node_nodeattr(F, n);
 953   fprintf(F, "%ld", get_irn_node_nr(n));
 954
 955   return bad;
 956 }
 957
 958
 959 /**
 960  * Dumps the attributes of a node n into the file F.
 961  * Currently this is only the color of a node.
 962  */
 963 static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad)
 964 {
 965   ir_node *n;
 966
 967   if (bad) {
 968     fprintf(F, "color: red");
 969     return;
 970   }
 971
 972   if (dump_node_vcgattr_hook)
 973     if (dump_node_vcgattr_hook(F, node, local))
 974       return;
 975
 976   n = local ? local : node;
 977
 978   switch (get_irn_opcode(n)) {
 979   case iro_Start:
 980   case iro_EndReg:
 981     /* fall through */
 982   case iro_EndExcept:
 983     /* fall through */
 984   case iro_End:
 985     fprintf (F, "color: blue");
 986     break;
 987   case iro_Block:
 988     if (is_Block_dead(n))
 989       fprintf (F, "color: lightred");
 990     else
 991       fprintf (F, "color: lightyellow");
 992     break;
 993   case iro_Phi:
 994     fprintf (F, "color: green");
 995     break;
 996   case iro_Const:
 997   case iro_Proj:
 998   case iro_Filter:
 999   case iro_Tuple:
1000     fprintf (F, "color: yellow");
1001     break;
1002   default:
1003     PRINT_DEFAULT_NODE_ATTR;
1004   }
1005
1006   if (overrule_nodecolor) fprintf(F, " color: %s", overrule_nodecolor);
1007 }
1008
1009
1010 /**
1011  * Dump the node information of a node n to a file F.
1012  */
1013 static INLINE int dump_node_info(FILE *F, ir_node *n)
1014 { int bad = 0;
1015   fprintf (F, " info1: \"");
1016   bad = dump_irnode_to_file(F, n);
1017   fprintf(F, "\"\n");
1018   return bad;
1019 }
1020
1021 /**
1022  * checks whether a node is "constant-like" ie can be treated "block-less"
1023  */
1024 static INLINE
1025 bool is_constlike_node(ir_node *n) {
1026   ir_op *op = get_irn_op(n);
1027   return (op == op_Const || op == op_Bad || op == op_NoMem || op == op_SymConst || op == op_Unknown);
1028 }
1029
1030
1031 /** outputs the predecessors of n, that are constants, local.  I.e.,
1032    generates a copy of the constant predecessors for each node called with. */
1033 static void dump_const_node_local(FILE *F, ir_node *n) {
1034   int i;
1035   if (!get_opt_dump_const_local()) return;
1036
1037   /* Use visited flag to avoid outputting nodes twice.
1038      initialize it first. */
1039   for (i = 0; i < get_irn_arity(n); i++) {
1040     ir_node *con = get_irn_n(n, i);
1041     if (is_constlike_node(con)) {
1042       set_irn_visited(con, get_irg_visited(current_ir_graph) - 1);
1043     }
1044   }
1045
1046   for (i = 0; i < get_irn_arity(n); i++) {
1047     ir_node *con = get_irn_n(n, i);
1048     if (is_constlike_node(con) && irn_not_visited(con)) {
1049       int bad = 0;
1050
1051       mark_irn_visited(con);
1052       /* Generate a new name for the node by appending the names of
1053          n and const. */
1054       fprintf(F, "node: {title: "); PRINT_CONSTID(n, con);
1055       fprintf(F, " label: \"");
1056       bad |= dump_node_label(F, con);
1057       fprintf(F, "\" ");
1058       bad |= dump_node_info(F, con);
1059       dump_node_vcgattr(F, n, con, bad);
1060       fprintf(F, "}\n");
1061     }
1062   }
1063 }
1064
1065 /** If the block of an edge is a const_like node, dump it local with an edge */
1066 static void dump_const_block_local(FILE *F, ir_node *n) {
1067   ir_node *blk;
1068
1069   if (!get_opt_dump_const_local()) return;
1070
1071   blk = get_nodes_block(n);
1072   if (is_constlike_node(blk)) {
1073     int bad = 0;
1074
1075     /* Generate a new name for the node by appending the names of
1076        n and blk. */
1077     fprintf(F, "node: {title: \""); PRINT_CONSTBLKID(n, blk);
1078     fprintf(F, "\" label: \"");
1079     bad |= dump_node_label(F, blk);
1080     fprintf(F, "\" ");
1081     bad |= dump_node_info(F, blk);
1082     dump_node_vcgattr(F, n, blk, bad);
1083     fprintf(F, "}\n");
1084
1085     fprintf (F, "edge: { sourcename: \"");
1086     PRINT_NODEID(n);
1087     fprintf (F, "\" targetname: \""); PRINT_CONSTBLKID(n,blk);
1088
1089         if (dump_edge_vcgattr_hook) {
1090           fprintf (F, "\" ");
1091       if (dump_edge_vcgattr_hook(F, n, -1)) {
1092         fprintf (F, "}\n");
1093         return;
1094       }
1095           else {
1096         fprintf (F, " " BLOCK_EDGE_ATTR "}\n");
1097                 return;
1098           }
1099     }
1100
1101     fprintf (F, "\" "   BLOCK_EDGE_ATTR "}\n");
1102   }
1103 }
1104
1105 /**
1106  * prints the error message of a node to a file F as info2.
1107  */
1108 static void INLINE print_node_error(FILE *F, const char *err_msg)
1109 {
1110   if (! err_msg)
1111     return;
1112
1113   fprintf (F, " info2: \"%s\"", err_msg);
1114 }
1115
1116 /**
1117  * prints debug messages of a node to file F as info3.
1118  */
1119 static void print_node_dbg_info(FILE *F, dbg_info *dbg)
1120 {
1121   char buf[1024];
1122
1123   if (__dbg_info_snprint) {
1124     buf[0] = '\0';
1125     if (__dbg_info_snprint(buf, sizeof(buf), dbg) > 0)
1126       fprintf (F, " info3: \"%s\"\n", buf);
1127   }
1128 }
1129
1130 /**
1131  * Dump a node
1132  */
1133 static void dump_node(FILE *F, ir_node *n)
1134 {
1135   int bad = 0;
1136   const char *p;
1137
1138   if (get_opt_dump_const_local() && is_constlike_node(n))
1139     return;
1140
1141   /* dump this node */
1142   fprintf(F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
1143
1144   bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p);
1145   bad |= dump_node_label(F, n);
1146   dump_node_ana_vals(F, n);
1147   //dump_node_ana_info(F, n);
1148   fprintf(F, "\" ");
1149   bad |= dump_node_info(F, n);
1150   print_node_error(F, p);
1151   print_node_dbg_info(F, get_irn_dbg_info(n));
1152   dump_node_vcgattr(F, n, NULL, bad);
1153   fprintf(F, "}\n");
1154   dump_const_node_local(F, n);
1155
1156   if(dump_node_edge_hook)
1157     dump_node_edge_hook(F, n);
1158 #if DO_HEAPANALYSIS
1159   dump_irn_chi_term(F, n);
1160   dump_irn_state(F, n);
1161 #endif
1162 }
1163
1164 /** dump the edge to the block this node belongs to */
1165 static void
1166 dump_ir_block_edge(FILE *F, ir_node *n)  {
1167   if (get_opt_dump_const_local() && is_constlike_node(n)) return;
1168   if (is_no_Block(n)) {
1169     ir_node *block = get_nodes_block(n);
1170
1171     if (get_opt_dump_const_local() && is_constlike_node(block)) {
1172       dump_const_block_local(F, n);
1173     }
1174     else {
1175       fprintf (F, "edge: { sourcename: \"");
1176       PRINT_NODEID(n);
1177       fprintf (F, "\" targetname: ");
1178       fprintf(F, "\""); PRINT_NODEID(block); fprintf(F, "\"");
1179
1180           if (dump_edge_vcgattr_hook) {
1181             fprintf (F, " ");
1182         if (dump_edge_vcgattr_hook(F, n, -1)) {
1183           fprintf (F, "}\n");
1184           return;
1185         }
1186             else {
1187           fprintf (F, " "  BLOCK_EDGE_ATTR "}\n");
1188                   return;
1189             }
1190       }
1191
1192       fprintf (F, " "   BLOCK_EDGE_ATTR "}\n");
1193     }
1194   }
1195 }
1196
1197 static void
1198 print_data_edge_vcgattr(FILE *F, ir_node *from, int to) {
1199         /*
1200          * do not use get_nodes_block() here, will fail
1201          * if the irg is not pinned.
1202          */
1203   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
1204     fprintf (F, INTRA_DATA_EDGE_ATTR);
1205   else
1206     fprintf (F, INTER_DATA_EDGE_ATTR);
1207 }
1208
1209 static void
1210 print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) {
1211         /*
1212          * do not use get_nodes_block() here, will fail
1213          * if the irg is not pinned.
1214          */
1215   if (get_irn_n(from, -1) == get_irn_n(get_irn_n(from, to), -1))
1216     fprintf (F, INTRA_MEM_EDGE_ATTR);
1217   else
1218     fprintf (F, INTER_MEM_EDGE_ATTR);
1219 }
1220
1221 static void
1222 print_edge_vcgattr(FILE *F, ir_node *from, int to) {
1223   assert(from);
1224
1225   if (dump_edge_vcgattr_hook)
1226         if (dump_edge_vcgattr_hook(F, from, to))
1227                 return;
1228
1229   if (dump_backedge_information_flag && is_backedge(from, to))
1230     fprintf (F, BACK_EDGE_ATTR);
1231
1232   switch (get_irn_opcode(from)) {
1233   case iro_Block:
1234     fprintf (F, CF_EDGE_ATTR);
1235     break;
1236   case iro_Start:   break;
1237   case iro_End:
1238     if (to >= 0) {
1239       if (get_irn_mode(get_End_keepalive(from, to)) == mode_BB)
1240     fprintf (F, CF_EDGE_ATTR);
1241       if (get_irn_mode(get_End_keepalive(from, to)) == mode_X)
1242     fprintf (F, INTER_MEM_EDGE_ATTR);
1243     }
1244     break;
1245   case iro_EndReg:
1246   case iro_EndExcept:
1247   case iro_Jmp:
1248   case iro_Break:
1249   case iro_Cond:
1250     print_data_edge_vcgattr(F, from, to);
1251     break;
1252   case iro_Return:
1253   case iro_Raise:
1254     if (to == 0)
1255       print_mem_edge_vcgattr(F, from, to);
1256     else
1257       print_data_edge_vcgattr(F, from, to);
1258     break;
1259   case iro_Const:
1260   case iro_SymConst:
1261     print_data_edge_vcgattr(F, from, to);
1262     break;
1263   case iro_Sel:
1264   case iro_Call:
1265     if (to == 0)
1266       print_mem_edge_vcgattr(F, from, to);
1267     else
1268       print_data_edge_vcgattr(F, from, to);
1269     break;
1270   case iro_CallBegin:
1271   case iro_Add:
1272   case iro_Sub:
1273   case iro_Minus:
1274   case iro_Mul:
1275     print_data_edge_vcgattr(F, from, to);
1276     break;
1277   case iro_Quot:
1278   case iro_DivMod:
1279   case iro_Div:
1280   case iro_Mod:
1281     if (to == 0)
1282       print_mem_edge_vcgattr(F, from, to);
1283     else
1284       print_data_edge_vcgattr(F, from, to);
1285     break;
1286   case iro_Abs:
1287   case iro_And:
1288   case iro_Or:
1289   case iro_Eor:
1290   case iro_Shl:
1291   case iro_Shr:
1292   case iro_Shrs:
1293   case iro_Rot:
1294   case iro_Cmp:
1295   case iro_Conv:
1296       print_data_edge_vcgattr(F, from, to);
1297     break;
1298   case iro_Phi:
1299     if (get_irn_modecode(from) == irm_M)
1300       fprintf (F, INTER_MEM_EDGE_ATTR);
1301     else
1302       print_data_edge_vcgattr(F, from, to);
1303     break;
1304   case iro_Load:
1305   case iro_Store:
1306   case iro_Alloc:
1307   case iro_Free:
1308     if (to == 0)
1309       print_mem_edge_vcgattr(F, from, to);
1310     else
1311       print_data_edge_vcgattr(F, from, to);
1312     break;
1313   case iro_Sync:
1314     print_mem_edge_vcgattr(F, from, to);
1315     break;
1316   case iro_Tuple:  break;
1317   case iro_Proj:
1318   case iro_Filter:
1319     switch (get_irn_modecode(from)) {
1320     case irm_X:
1321       fprintf (F, CF_EDGE_ATTR);
1322       break;
1323     case irm_M:
1324       fprintf (F, INTER_MEM_EDGE_ATTR);
1325       break;
1326     default:
1327       print_data_edge_vcgattr(F, from, to);
1328       break;
1329     }
1330     break;
1331   case iro_Bad:     break;
1332   case iro_Unknown: break;
1333   case iro_Id:
1334     switch (get_irn_modecode(from)) {
1335     case irm_M:
1336       fprintf (F, INTRA_MEM_EDGE_ATTR);
1337       break;
1338     case irm_X:
1339       fprintf (F, CF_EDGE_ATTR);
1340       break;
1341     default:
1342       print_data_edge_vcgattr(F, from, to);
1343       break;
1344     } break;
1345   default:
1346     ;
1347   }
1348 }
1349
1350 /* dump edges to our inputs */
1351 static void
1352 dump_ir_data_edges(FILE *F, ir_node *n)  {
1353   int i;
1354   unsigned long visited = get_irn_visited(n);
1355
1356   if ((get_irn_op(n) == op_End) && (!dump_keepalive))
1357     return;
1358
1359   for (i = 0; i < get_irn_arity(n); i++) {
1360     ir_node * pred = get_irn_n(n, i);
1361     assert(pred);
1362
1363     if ((get_interprocedural_view() && get_irn_visited(pred) < visited))
1364       continue; /* pred not dumped */
1365
1366     if (dump_backedge_information_flag && is_backedge(n, i))
1367       fprintf (F, "backedge: {sourcename: \"");
1368     else
1369       fprintf (F, "edge: {sourcename: \"");
1370     PRINT_NODEID(n);
1371     fprintf (F, "\" targetname: ");
1372     if ((get_opt_dump_const_local()) && is_constlike_node(pred)) {
1373       PRINT_CONSTID(n, pred);
1374     } else {
1375       fprintf(F, "\""); PRINT_NODEID(pred); fprintf(F, "\"");
1376     }
1377     fprintf (F, " label: \"%d\" ", i);
1378     print_edge_vcgattr(F, n, i);
1379     fprintf (F, "}\n");
1380   }
1381 }
1382
1383 /** Dumps a node and its edges but not the block edge
1384  */
1385 static INLINE void
1386 dump_node_wo_blockedge (ir_node *n, void *env) {
1387   FILE *F = env;
1388   dump_node(F, n);
1389   dump_ir_data_edges(F, n);
1390 }
1391
1392 /** Dumps a node and its edges.
1393  */
1394 static void
1395 dump_whole_node (ir_node *n, void *env) {
1396   FILE *F = env;
1397   dump_node_wo_blockedge(n, env);
1398   if (!node_floats(n)) dump_ir_block_edge(F, n);
1399 }
1400
1401 static void
1402 dump_const_node(ir_node *n, void *env) {
1403   if (is_Block(n)) return;
1404   dump_node_wo_blockedge(n, env);
1405 }
1406
1407 /***********************************************************************/
1408 /* the following routines dump the nodes/irgs bracketed to graphs.     */
1409 /***********************************************************************/
1410
1411 /** Dumps a constant expression as entity initializer, array bound ...
1412  */
1413 static void dump_const_expression(FILE *F, ir_node *value) {
1414   ir_graph *rem = current_ir_graph;
1415   int rem_dump_const_local = dump_const_local;
1416   dump_const_local = 0;
1417   current_ir_graph = get_const_code_irg();
1418   irg_walk(value, dump_const_node, NULL, F);
1419   /* Decrease visited flag so that we walk with the same flag for the next
1420      expression.  This guarantees that we don't dump the same node twice,
1421      as for const expressions cse is performed to save memory. */
1422   set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph) -1);
1423   current_ir_graph = rem;
1424   dump_const_local = rem_dump_const_local;
1425 }
1426
1427 /** Dump a block as graph containing its nodes.
1428  *
1429  *  Expects to find nodes belonging to the block as list in its
1430  *  link field.
1431  *  Dumps the edges of all nodes including itself. */
1432 static void
1433 dump_whole_block(FILE *F, ir_node *block) {
1434   ir_node *node;
1435   const char *color = "yellow";
1436
1437   assert(is_Block(block));
1438
1439   fprintf(F, "graph: { title: \"");
1440   PRINT_NODEID(block);
1441   fprintf(F, "\"  label: \"");
1442   dump_node_label(F, block);
1443 #if DO_HEAPANALYSIS
1444   if (get_opt_dump_abstvals())
1445     fprintf (F, " seqno: %d", (int)get_Block_seqno(block));
1446 #endif
1447
1448   /* colorize blocks */
1449   if (! get_Block_matured(block))
1450     color = "red";
1451   if (is_Block_dead(block))
1452     color = "orange";
1453
1454   fprintf(F, "\" status:clustered color:%s \n", color);
1455
1456   /* ycomp can show attributs for blocks, VCG parses but ignores them */
1457   dump_node_info(F, block);
1458
1459   /* dump the blocks edges */
1460   dump_ir_data_edges(F, block);
1461
1462   /* dump the nodes that go into the block */
1463   for (node = ird_get_irn_link(block); node; node = ird_get_irn_link(node)) {
1464     dump_node(F, node);
1465     dump_ir_data_edges(F, node);
1466   }
1467
1468   /* Close the vcg information for the block */
1469   fprintf(F, "}\n");
1470   dump_const_node_local(F, block);
1471 #if DO_HEAPANALYSIS
1472   dump_irn_chi_term(F, block);
1473 #endif
1474   fprintf(F, "\n");
1475 }
1476
1477 /** dumps a graph block-wise. Expects all blockless nodes in arr in irgs link.
1478  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
1479 static void
1480 dump_block_graph(FILE *F, ir_graph *irg) {
1481   int i;
1482   ir_graph *rem = current_ir_graph;
1483   ir_node **arr = ird_get_irg_link(irg);
1484   current_ir_graph = irg;
1485
1486   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
1487     ir_node * node = arr[i];
1488     if (is_Block(node)) {
1489       /* Dumps the block and all the nodes in the block, which are to
1490          be found in Block->link. */
1491       dump_whole_block(F, node);
1492     } else {
1493       /* Nodes that are not in a Block. */
1494       dump_node(F, node);
1495       if (!node_floats(node) && is_Bad(get_nodes_block(node))) {
1496         dump_const_block_local(F, node);
1497       }
1498       dump_ir_data_edges(F, node);
1499     }
1500   }
1501
1502   if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid))
1503     dump_loop_nodes_into_graph(F, irg);
1504
1505   current_ir_graph = rem;
1506 }
1507
1508 /** Dumps an irg as a graph clustered by block nodes.
1509  *  If interprocedural view edges can point to nodes out of this graph.
1510  */
1511 static void dump_graph_from_list(FILE *F, ir_graph *irg) {
1512
1513   fprintf(F, "graph: { title: \"");
1514   PRINT_IRGID(irg);
1515   fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
1516       get_ent_dump_name(get_irg_entity(irg)));
1517
1518   dump_block_graph(F, irg);
1519
1520   /* Close the vcg information for the irg */
1521   fprintf(F, "}\n\n");
1522 }
1523
1524 /** dumps a graph extended block-wise. Expects all blockless nodes in arr in irgs link.
1525  *  The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */
1526 static void
1527 dump_extblock_graph(FILE *F, ir_graph *irg) {
1528   int i;
1529   ir_graph *rem = current_ir_graph;
1530   ir_extblk **arr = ird_get_irg_link(irg);
1531   current_ir_graph = irg;
1532
1533   compute_extbb(irg);
1534   for (i = ARR_LEN(arr) - 1; i >= 0; --i) {
1535     ir_extblk *extbb = arr[i];
1536     ir_node *leader = get_extbb_leader(extbb);
1537     int j;
1538
1539     fprintf(F, "graph: { title: \"");
1540     PRINT_EXTBBID(leader);
1541     fprintf(F, "\"  label: \"ExtBB %ld\" status:clustered color:lightgreen\n",
1542             get_irn_node_nr(leader));
1543
1544     for (j = ARR_LEN(extbb->blks) - 1; j >= 0; --j) {
1545       ir_node * node = extbb->blks[j];
1546       if (is_Block(node)) {
1547         /* Dumps the block and all the nodes in the block, which are to
1548            be found in Block->link. */
1549         dump_whole_block(F, node);
1550       } else {
1551         /* Nodes that are not in a Block. */
1552         dump_node(F, node);
1553         if (is_Bad(get_nodes_block(node)) && !node_floats(node)) {
1554           dump_const_block_local(F, node);
1555         }
1556         dump_ir_data_edges(F, node);
1557       }
1558     }
1559     fprintf(F, "}\n");
1560   }
1561
1562   if (dump_loop_information_flag && (get_irg_loopinfo_state(irg) & loopinfo_valid))
1563     dump_loop_nodes_into_graph(F, irg);
1564
1565   current_ir_graph = rem;
1566   free_extbb(irg);
1567 }
1568
1569
1570 /*******************************************************************/
1571 /* Basic type and entity nodes and edges.                          */
1572 /*******************************************************************/
1573
1574 /** dumps the edges between nodes and their type or entity attributes. */
1575 static void dump_node2type_edges(ir_node *n, void *env)
1576 {
1577   FILE *F = env;
1578   assert(n);
1579
1580   switch (get_irn_opcode(n)) {
1581   case iro_Const :
1582     /* @@@ some consts have an entity */
1583     break;
1584   case iro_SymConst:
1585     if (   (get_SymConst_kind(n) ==symconst_type_tag)
1586        || (get_SymConst_kind(n) ==symconst_size))
1587       {
1588         print_node_type_edge(F,n,get_SymConst_type(n),NODE2TYPE_EDGE_ATTR);
1589       }
1590     break;
1591   case iro_Sel: {
1592       print_node_ent_edge(F,n,get_Sel_entity(n),NODE2TYPE_EDGE_ATTR);
1593     } break;
1594   case iro_Call: {
1595       print_node_type_edge(F,n,get_Call_type(n),NODE2TYPE_EDGE_ATTR);
1596     } break;
1597   case iro_Alloc: {
1598       print_node_type_edge(F,n,get_Alloc_type(n),NODE2TYPE_EDGE_ATTR);
1599     } break;
1600   case iro_Free: {
1601       print_node_type_edge(F,n,get_Free_type(n),NODE2TYPE_EDGE_ATTR);
1602     } break;
1603   case iro_Cast: {
1604       print_node_type_edge(F,n,get_Cast_type(n),NODE2TYPE_EDGE_ATTR);
1605     } break;
1606   default:
1607     break;
1608   }
1609 }
1610
1611 #if 0
1612 static int print_type_info(FILE *F, type *tp) {
1613   int bad = 0;
1614
1615   if (get_type_state(tp) == layout_undefined) {
1616     fprintf(F, "state: layout_undefined\n");
1617   } else {
1618     fprintf(F, "state: layout_fixed,\n");
1619   }
1620   if (get_type_mode(tp))
1621     fprintf(F, "mode: %s,\n", get_mode_name_ex(get_type_mode(tp), &bad));
1622   fprintf(F, "size: %db,\n", get_type_size_bits(tp));
1623
1624   return bad;
1625 }
1626
1627 static void print_typespecific_info(FILE *F, type *tp) {
1628   switch (get_type_tpop_code(tp)) {
1629   case tpo_class:
1630     {
1631       fprintf(F, "peculiarity: %s\n", get_peculiarity_string(get_class_peculiarity(tp)));
1632     } break;
1633   case tpo_struct:
1634     {
1635     } break;
1636   case tpo_method:
1637     {
1638       fprintf(F, "variadicity: %s\n", get_variadicity_name(get_method_variadicity(tp)));
1639       fprintf(F, "params: %d\n", get_method_n_params(tp));
1640       fprintf(F, "results: %d\n", get_method_n_ress(tp));
1641     } break;
1642   case tpo_union:
1643     {
1644     } break;
1645   case tpo_array:
1646     {
1647     } break;
1648   case tpo_enumeration:
1649     {
1650     } break;
1651   case tpo_pointer:
1652     {
1653     } break;
1654   case tpo_primitive:
1655     {
1656     } break;
1657   default: break;
1658   } /* switch type */
1659 }
1660 #endif
1661
1662 static void print_typespecific_vcgattr(FILE *F, type *tp) {
1663   switch (get_type_tpop_code(tp)) {
1664   case tpo_class:
1665     {
1666       if (peculiarity_existent == get_class_peculiarity(tp))
1667     fprintf (F, " " TYPE_CLASS_NODE_ATTR);
1668       else
1669     fprintf (F, " " TYPE_DESCRIPTION_NODE_ATTR);
1670     } break;
1671   case tpo_struct:
1672     {
1673       fprintf (F, " " TYPE_METH_NODE_ATTR);
1674     } break;
1675   case tpo_method:
1676     {
1677     } break;
1678   case tpo_union:
1679     {
1680     } break;
1681   case tpo_array:
1682     {
1683     } break;
1684   case tpo_enumeration:
1685     {
1686     } break;
1687   case tpo_pointer:
1688     {
1689     } break;
1690   case tpo_primitive:
1691     {
1692     } break;
1693   default: break;
1694   } /* switch type */
1695 }
1696
1697
1698 int dump_type_node(FILE *F, type *tp)
1699 {
1700   int bad = 0;
1701
1702   fprintf (F, "node: {title: ");
1703   PRINT_TYPEID(tp);
1704   fprintf (F, " label: \"%s %s\"", get_type_tpop_name(tp), get_type_name_ex(tp, &bad));
1705   fprintf (F, " info1: \"");
1706 #if 0
1707   bad |= print_type_info(F, tp);
1708   print_typespecific_info(F, tp);
1709 #else
1710   dump_type_to_file(F, tp, dump_verbosity_max);
1711 #endif
1712   fprintf (F, "\"\n");
1713   print_node_dbg_info(F, get_type_dbg_info(tp));
1714   print_typespecific_vcgattr(F, tp);
1715   fprintf (F, "}\n");
1716
1717   return bad;
1718 }
1719
1720
1721 #define X(a)    case a: fprintf(F, #a); break
1722 void dump_entity_node(FILE *F, entity *ent, int color)
1723 {
1724   fprintf (F, "node: {title: \"");
1725   PRINT_ENTID(ent); fprintf(F, "\"");
1726   fprintf (F, DEFAULT_TYPE_ATTRIBUTE);
1727   fprintf (F, "label: ");
1728   fprintf (F, "\"ent %s\" ", get_ent_dump_name(ent));
1729   if (color)
1730     fprintf(F, "color: %d", color);
1731   else
1732     fprintf (F, ENTITY_NODE_ATTR);
1733   fprintf (F, "\n info1: \"");
1734
1735   dump_entity_to_file(F, ent, dump_verbosity_entattrs | dump_verbosity_entconsts);
1736
1737   fprintf(F, "\"\n");
1738   print_node_dbg_info(F, get_entity_dbg_info(ent));
1739   fprintf(F, "}\n");
1740 }
1741 #undef X
1742
1743 static void dump_enum_item(FILE *F, type *tp, int pos)
1744 {
1745   char buf[1024];
1746   ident *id  = get_enumeration_nameid(tp, pos);
1747   tarval *tv = get_enumeration_enum(tp, pos);
1748
1749   tarval_snprintf(buf, sizeof(buf), tv);
1750   fprintf (F, "node: {title: \"");
1751   PRINT_ITEMID(tp, pos); fprintf(F, "\"");
1752   fprintf (F, DEFAULT_ENUM_ITEM_ATTRIBUTE);
1753   fprintf (F, "label: ");
1754   fprintf (F, "\"enum item %s\" " ENUM_ITEM_NODE_ATTR, get_id_str(id));
1755   fprintf (F, "\n info1: \"value: %s\"}\n", buf);
1756 }
1757
1758 /* dumps a type or entity and it's edges. */
1759 static void
1760 dump_type_info(type_or_ent *tore, void *env) {
1761   FILE *F = env;
1762   int i = 0;  /* to shutup gcc */
1763
1764   /* dump this type or entity */
1765
1766   switch (get_kind(tore)) {
1767   case k_entity:
1768     {
1769       entity *ent = (entity *)tore;
1770       ir_node *value;
1771       /* The node */
1772       dump_entity_node(F, ent, 0);
1773       /* The Edges */
1774       /* skip this to reduce graph.  Member edge of type is parallel to this edge. *
1775       fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
1776                 ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/
1777       print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR);
1778       if (is_Class_type(get_entity_owner(ent))) {
1779         for(i = 0; i < get_entity_n_overwrites(ent); i++)
1780           print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, ENT_OVERWRITES_EDGE_ATTR);
1781       }
1782       /* attached subgraphs */
1783       if (const_entities && (get_entity_variability(ent) != variability_uninitialized)) {
1784         if (is_atomic_entity(ent)) {
1785           value = get_atomic_ent_value(ent);
1786           if (value) {
1787             print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
1788             /* DDMN(value);  $$$ */
1789             dump_const_expression(F, value);
1790           }
1791         }
1792         if (is_compound_entity(ent)) {
1793           for (i = 0; i < get_compound_ent_n_values(ent); i++) {
1794             value = get_compound_ent_value(ent, i);
1795             if (value) {
1796               print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i);
1797               dump_const_expression(F, value);
1798               print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, ENT_CORR_EDGE_ATTR, i);
1799               /*
1800               fprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
1801               ENT_CORR_EDGE_ATTR  "}\n", GET_ENTID(ent),
1802               get_compound_ent_value_member(ent, i), i);
1803               */
1804             }
1805           }
1806         }
1807       }
1808     } break;
1809   case k_type:
1810     {
1811       type *tp = (type *)tore;
1812       dump_type_node(F, tp);
1813       /* and now the edges */
1814       switch (get_type_tpop_code(tp)) {
1815       case tpo_class:
1816         {
1817           for (i=0; i < get_class_n_supertypes(tp); i++)
1818             print_type_type_edge(F, tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
1819           for (i=0; i < get_class_n_members(tp); i++)
1820             print_type_ent_edge(F,tp,get_class_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
1821         } break;
1822       case tpo_struct:
1823         {
1824           for (i=0; i < get_struct_n_members(tp); i++)
1825             print_type_ent_edge(F,tp,get_struct_member(tp, i),TYPE_MEMBER_EDGE_ATTR);
1826         } break;
1827       case tpo_method:
1828         {
1829           for (i = 0; i < get_method_n_params(tp); i++)
1830             print_type_type_edge(F,tp,get_method_param_type(tp, i),METH_PAR_EDGE_ATTR,i);
1831           for (i = 0; i < get_method_n_ress(tp); i++)
1832             print_type_type_edge(F,tp,get_method_res_type(tp, i),METH_RES_EDGE_ATTR,i);
1833         } break;
1834       case tpo_union:
1835         {
1836           for (i = 0; i < get_union_n_members(tp); i++)
1837             print_type_ent_edge(F,tp,get_union_member(tp, i),UNION_EDGE_ATTR);
1838         } break;
1839       case tpo_array:
1840         {
1841           print_type_type_edge(F,tp,get_array_element_type(tp),ARR_ELT_TYPE_EDGE_ATTR);
1842           print_type_ent_edge(F,tp,get_array_element_entity(tp),ARR_ENT_EDGE_ATTR);
1843           for (i = 0; i < get_array_n_dimensions(tp); i++) {
1844             ir_node *upper = get_array_upper_bound(tp, i);
1845             ir_node *lower = get_array_lower_bound(tp, i);
1846             print_node_type_edge(F, upper, tp, "label: \"upper %d\"", get_array_order(tp, i));
1847             print_node_type_edge(F, lower, tp, "label: \"lower %d\"", get_array_order(tp, i));
1848             dump_const_expression(F, upper);
1849             dump_const_expression(F, lower);
1850           }
1851
1852         } break;
1853       case tpo_enumeration:
1854         {
1855           for (i = 0; i < get_enumeration_n_enums(tp); ++i) {
1856             dump_enum_item(F, tp, i);
1857             print_enum_item_edge(F, tp, i, "label: \"item %d\"", i);
1858           }
1859         } break;
1860       case tpo_pointer:
1861         {
1862           print_type_type_edge(F,tp,get_pointer_points_to_type(tp), PTR_PTS_TO_EDGE_ATTR);
1863         } break;
1864       case tpo_primitive:
1865         {
1866         } break;
1867       default: break;
1868       } /* switch type */
1869     }
1870     break; /* case k_type */
1871   default:
1872     {
1873       printf(" *** irdump,  dump_type_info(l.%i), faulty type.\n", __LINE__);
1874     } break;
1875   } /* switch kind_or_entity */
1876 }
1877
1878 typedef struct _h_env {
1879   int dump_ent;
1880   FILE *f;
1881 } h_env_t;
1882
1883 /** For dumping class hierarchies.
1884  * Dumps a class type node and a superclass edge.
1885  * If env->dump_ent dumps entities of classes and overwrites edges.
1886  */
1887 static void
1888 dump_class_hierarchy_node (type_or_ent *tore, void *ctx) {
1889   h_env_t *env = ctx;
1890   FILE *F = env->f;
1891   int i = 0;  /* to shutup gcc */
1892
1893   /* dump this type or entity */
1894   switch (get_kind(tore)) {
1895   case k_entity: {
1896     entity *ent = (entity *)tore;
1897     if (get_entity_owner(ent) == get_glob_type()) break;
1898     if (!is_Method_type(get_entity_type(ent))) break;  /* GL */
1899     if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
1900       /* The node */
1901       dump_entity_node(F, ent, 0);
1902       /* The edges */
1903       print_type_ent_edge(F,get_entity_owner(ent),ent,TYPE_MEMBER_EDGE_ATTR);
1904       for(i = 0; i < get_entity_n_overwrites(ent); i++)
1905         print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ENT_OVERWRITES_EDGE_ATTR);
1906     }
1907   } break; /* case k_entity */
1908   case k_type:
1909     {
1910       type *tp = (type *)tore;
1911       if (tp == get_glob_type()) break;
1912       switch (get_type_tpop_code(tp)) {
1913         case tpo_class: {
1914           dump_type_node(F, tp);
1915           /* and now the edges */
1916           for (i=0; i < get_class_n_supertypes(tp); i++)
1917           {
1918               print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR);
1919           }
1920         } break;
1921         default: break;
1922       } /* switch type */
1923     }
1924     break; /* case k_type */
1925   default:
1926     {
1927       printf(" *** irdump,  dump_class_hierarchy_node(l.%i), faulty type.\n", __LINE__);
1928     } break;
1929   } /* switch kind_or_entity */
1930 }
1931
1932 /*******************************************************************/
1933 /* dump analysis information that is expressed in graph terms.     */
1934 /*******************************************************************/
1935
1936 /* dump out edges */
1937 static void
1938 dump_out_edge(ir_node *n, void *env) {
1939   FILE *F = env;
1940   int i;
1941   for (i = 0; i < get_irn_n_outs(n); i++) {
1942     assert(get_irn_out(n, i));
1943     fprintf (F, "edge: {sourcename: \"");
1944     PRINT_NODEID(n);
1945     fprintf (F, "\" targetname: \"");
1946     PRINT_NODEID(get_irn_out(n, i));
1947     fprintf (F, "\" color: red linestyle: dashed");
1948     fprintf (F, "}\n");
1949   }
1950 }
1951
1952 static INLINE void
1953 dump_loop_label(FILE *F, ir_loop *loop) {
1954   fprintf (F, "loop %d, %d sons, %d nodes",
1955        get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop));
1956 }
1957
1958 static INLINE void dump_loop_info(FILE *F, ir_loop *loop) {
1959   fprintf (F, " info1: \"");
1960   fprintf (F, " loop nr: %d", get_loop_loop_nr(loop));
1961 #if DEBUG_libfirm   /* GL @@@ debug analyses */
1962   fprintf (F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop)));
1963 #endif
1964   fprintf (F, "\"");
1965 }
1966
1967 static INLINE void
1968 dump_loop_node(FILE *F, ir_loop *loop) {
1969   fprintf (F, "node: {title: \"");
1970   PRINT_LOOPID(loop);
1971   fprintf (F, "\" label: \"");
1972   dump_loop_label(F, loop);
1973   fprintf (F, "\" ");
1974   dump_loop_info(F, loop);
1975   fprintf (F, "}\n");
1976
1977 }
1978
1979 static INLINE void
1980 dump_loop_node_edge(FILE *F, ir_loop *loop, int i) {
1981   assert(loop);
1982   fprintf (F, "edge: {sourcename: \"");
1983   PRINT_LOOPID(loop);
1984   fprintf (F, "\" targetname: \"");
1985   PRINT_NODEID(get_loop_node(loop, i));
1986   fprintf (F, "\" color: green");
1987   fprintf (F, "}\n");
1988 }
1989
1990 static INLINE void
1991 dump_loop_son_edge(FILE *F, ir_loop *loop, int i) {
1992   assert(loop);
1993   fprintf (F, "edge: {sourcename: \"");
1994   PRINT_LOOPID(loop);
1995   fprintf (F, "\" targetname: \"");
1996   PRINT_LOOPID(get_loop_son(loop, i));
1997   fprintf (F, "\" color: darkgreen label: \"%d\"}\n",
1998        get_loop_element_pos(loop, get_loop_son(loop, i)));
1999 }
2000
2001 static
2002 void dump_loops(FILE *F, ir_loop *loop) {
2003   int i;
2004   /* dump this loop node */
2005   dump_loop_node(F, loop);
2006
2007   /* dump edges to nodes in loop -- only if it is a real loop */
2008   if (get_loop_depth(loop) != 0) {
2009     for (i = 0; i < get_loop_n_nodes(loop); i++) {
2010       dump_loop_node_edge(F, loop, i);
2011     }
2012   }
2013   for (i = 0; i < get_loop_n_sons(loop); i++) {
2014     dump_loops(F, get_loop_son(loop, i));
2015     dump_loop_son_edge(F, loop, i);
2016   }
2017 }
2018
2019 static INLINE
2020 void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg) {
2021   ir_graph *rem = current_ir_graph;
2022   current_ir_graph = irg;
2023
2024   if (get_irg_loop(irg)) dump_loops(F, get_irg_loop(irg));
2025
2026   current_ir_graph = rem;
2027 }
2028
2029
2030 /**
2031  * dumps the VCG header
2032  */
2033 void dump_vcg_header(FILE *F, const char *name, const char *orientation) {
2034   char *label;
2035
2036   if (edge_label) {
2037     label = "yes";
2038   } else {
2039     label = "no";
2040   }
2041
2042   if (!orientation) orientation = "bottom_to_top";
2043
2044   /* print header */
2045   fprintf (F,
2046        "graph: { title: \"ir graph of %s\"\n"
2047        "display_edge_labels: %s\n"
2048        "layoutalgorithm: mindepth\n"
2049        "manhattan_edges: yes\n"
2050        "port_sharing: no\n"
2051        "orientation: %s\n"
2052        "classname 1:  \"intrablock Data\"\n"
2053        "classname 16: \"interblock Data\"\n"
2054        "classname 2:  \"Block\"\n"
2055        "classname 13: \"Control Flow\"\n"
2056        "classname 18: \"Exception Control Flow for Interval Analysis\"\n"
2057        "classname 14: \"intrablock Memory\"\n"
2058        "classname 17: \"interblock Memory\"\n"
2059        "classname 15: \"Dominators\"\n"
2060        "classname 3:  \"Entity type\"\n"
2061        "classname 4:  \"Entity owner\"\n"
2062        "classname 5:  \"Method Param\"\n"
2063        "classname 6:  \"Method Res\"\n"
2064        "classname 7:  \"Super\"\n"
2065        "classname 8:  \"Union\"\n"
2066        "classname 9:  \"Points-to\"\n"
2067        "classname 10: \"Array Element Type\"\n"
2068        "classname 11: \"Overwrites\"\n"
2069        "classname 12: \"Member\"\n"
2070        "infoname 1: \"Attribute\"\n"
2071        "infoname 2: \"Verification errors\"\n"
2072        "infoname 3: \"Debug info\"\n",
2073        name, label, orientation);
2074
2075   /* don't use all, the range is too whith/black. */
2076   n_colors   = 18;
2077   base_color = 105;
2078   fprintf (F,
2079        "colorentry 100:    0   0    0\n"
2080        "colorentry 101:   20   0    0\n"
2081        "colorentry 102:   40   0    0\n"
2082        "colorentry 103:   60   0    0\n"
2083        "colorentry 104:   80   0    0\n"
2084        "colorentry 105:  100   0    0\n"
2085        "colorentry 106:  120   0    0\n"
2086        "colorentry 107:  140   0    0\n"
2087        "colorentry 108:  150   0    0\n"
2088        "colorentry 109:  180   0    0\n"
2089        "colorentry 110:  200   0    0\n"
2090        "colorentry 111:  220   0    0\n"
2091        "colorentry 112:  240   0    0\n"
2092        "colorentry 113:  255   0    0\n"
2093        "colorentry 113:  255  20   20\n"
2094        "colorentry 114:  255  40   40\n"
2095        "colorentry 115:  255  60   60\n"
2096        "colorentry 116:  255  80   80\n"
2097        "colorentry 117:  255 100  100\n"
2098        "colorentry 118:  255 120  120\n"
2099        "colorentry 119:  255 140  140\n"
2100        "colorentry 120:  255 150  150\n"
2101        "colorentry 121:  255 180  180\n"
2102        "colorentry 122:  255 200  200\n"
2103        "colorentry 123:  255 220  220\n"
2104        "colorentry 124:  255 240  240\n"
2105        "colorentry 125:  255 250  250\n"
2106        );
2107
2108   fprintf (F, "\n");        /* a separator */
2109 }
2110
2111 /**
2112  * open a vcg file
2113  *
2114  * @param irg     The graph to be dumped
2115  * @param suffix1 first filename suffix
2116  * @param suffix2 second filename suffix
2117  */
2118 FILE *vcg_open (ir_graph *irg, const char * suffix1, const char *suffix2) {
2119   FILE *F;
2120   const char *nm = get_irg_dump_name(irg);
2121   int len = strlen(nm), i, j;
2122   char *fname;  /* filename to put the vcg information in */
2123
2124   if (!suffix1) suffix1 = "";
2125   if (!suffix2) suffix2 = "";
2126
2127   /* open file for vcg graph */
2128   fname = malloc (len * 2 + strlen(suffix1) + strlen(suffix2) + 5);
2129
2130   /* strncpy (fname, nm, len); */     /* copy the filename */
2131   j = 0;
2132   for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
2133     if (nm[i] == '/') {
2134       fname[j] = '@'; j++; fname[j] = '1'; j++;
2135     } else if (nm[i] == '@') {
2136       fname[j] = '@'; j++; fname[j] = '2'; j++;
2137     } else {
2138       fname[j] = nm[i]; j++;
2139     }
2140   }
2141   fname[j] = '\0';
2142   strcat (fname, suffix1);  /* append file suffix */
2143   strcat (fname, suffix2);  /* append file suffix */
2144   strcat (fname, ".vcg");   /* append the .vcg suffix */
2145
2146   /* vcg really expect only a <CR> at end of line, so
2147    * the "b"inary mode is what you mean (and even needed for Win32)
2148    */
2149   F = fopen (fname, "wb");  /* open file for writing */
2150   if (!F) {
2151     panic("cannot open %s for writing (%m)", fname);  /* not reached */
2152   }
2153   free(fname);
2154
2155   return F;
2156 }
2157
2158 /**
2159  * open a vcg file
2160  *
2161  * @param name    prefix file name
2162  * @param suffix  filename suffix
2163  */
2164 FILE *vcg_open_name (const char *name, const char *suffix) {
2165   FILE *F;
2166   char *fname;  /* filename to put the vcg information in */
2167   int i, j, len = strlen(name);
2168
2169   if (!suffix) suffix = "";
2170
2171   /** open file for vcg graph */
2172   fname = xmalloc(len * 2 + 5 + strlen(suffix));
2173   /* strcpy (fname, name);*/    /* copy the filename */
2174   j = 0;
2175   for (i = 0; i < len; ++i) {  /* replace '/' in the name: escape by @. */
2176     if (name[i] == '/') {
2177       fname[j] = '@'; j++; fname[j] = '1'; j++;
2178     } else if (name[i] == '@') {
2179       fname[j] = '@'; j++; fname[j] = '2'; j++;
2180     } else {
2181       fname[j] = name[i]; j++;
2182     }
2183   }
2184   fname[j] = '\0';
2185   strcat (fname, suffix);
2186   strcat (fname, ".vcg");  /* append the .vcg suffix */
2187
2188   /* vcg really expect only a <CR> at end of line, so
2189    * the "b"inary mode is what you mean (and even needed for Win32)
2190    */
2191   F = fopen (fname, "wb");  /* open file for writing */
2192   if (!F) {
2193     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
2194   }
2195   free(fname);
2196
2197   return F;
2198 }
2199
2200 /**
2201  * Dumps the vcg file footer
2202  */
2203 static INLINE void dump_vcg_footer (FILE *F) {
2204   fprintf (F, "}\n");
2205 }
2206
2207 /**
2208  * close the vcg file
2209  */
2210 void vcg_close (FILE *F) {
2211   dump_vcg_footer(F);    /* print footer */
2212   fclose (F);           /* close vcg file */
2213 }
2214
2215 /************************************************************************/
2216 /************************************************************************/
2217 /* Routines that dump all or parts of the firm representation to a file */
2218 /************************************************************************/
2219 /************************************************************************/
2220
2221 /************************************************************************/
2222 /* Dump ir graphs, different formats and additional information.        */
2223 /************************************************************************/
2224
2225 /** Routine to dump a graph, blocks as conventional nodes.  */
2226 void
2227 dump_ir_graph (ir_graph *irg, const char *suffix )
2228 {
2229   FILE *f;
2230   ir_graph *rem;
2231   char *suffix1;
2232   rem = current_ir_graph;
2233
2234   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2235
2236   current_ir_graph = irg;
2237   if (get_interprocedural_view()) suffix1 = "-pure-ip";
2238   else                            suffix1 = "-pure";
2239   f = vcg_open(irg, suffix, suffix1);
2240   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2241
2242   /* call the dump graph hook */
2243   if (dump_ir_graph_hook)
2244     if (dump_ir_graph_hook(f, irg))
2245       return;
2246
2247   /* walk over the graph */
2248   /* dump_whole_node must be called in post visiting predecessors */
2249   irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
2250
2251   /* dump the out edges in a separate walk */
2252   if ((dump_out_edge_flag) && (get_irg_outs_state(irg) != outs_none)) {
2253     irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, f);
2254   }
2255
2256   vcg_close(f);
2257
2258   current_ir_graph = rem;
2259 }
2260
2261 /* Dump a firm graph without explicit block nodes. */
2262 void dump_ir_block_graph (ir_graph *irg, const char *suffix)
2263 {
2264   FILE *f;
2265   int i;
2266   char *suffix1;
2267
2268   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2269     return;
2270
2271   if (get_interprocedural_view()) suffix1 = "-ip";
2272   else                            suffix1 = "";
2273   f = vcg_open(irg, suffix, suffix1);
2274   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2275
2276   construct_block_lists(irg);
2277
2278   /*
2279    * If we are in the interprocedural view, we dump not
2280    * only the requested irg but also all irgs that can be reached
2281    * from irg.
2282    */
2283   for (i = 0; i < get_irp_n_irgs(); i++) {
2284     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
2285     if (arr) {
2286       dump_graph_from_list(f, get_irp_irg(i));
2287       DEL_ARR_F(arr);
2288     }
2289   }
2290
2291   vcg_close(f);
2292 }
2293
2294 /* Dump a firm graph without explicit block nodes but grouped in extended blocks. */
2295 void dump_ir_extblock_graph (ir_graph *irg, const char *suffix)
2296 {
2297   FILE *F;
2298   int i;
2299   char *suffix1;
2300
2301   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2302     return;
2303
2304   compute_extbb(irg);
2305
2306   if (get_interprocedural_view()) suffix1 = "-ip";
2307   else                            suffix1 = "";
2308   F = vcg_open(irg, suffix, suffix1);
2309   dump_vcg_header(F, get_irg_dump_name(irg), NULL);
2310
2311   construct_extblock_lists(irg);
2312
2313   fprintf(F, "graph: { title: \"");
2314   PRINT_IRGID(irg);
2315   fprintf(F, "\" label: \"%s\" status:clustered color:white \n",
2316     get_ent_dump_name(get_irg_entity(irg)));
2317
2318   for (i = 0; i < get_irp_n_irgs(); i++) {
2319     ir_graph *irg     = get_irp_irg(i);
2320     list_tuple *lists = ird_get_irg_link(irg);
2321
2322     if (lists) {
2323       /* dump the extended blocks first */
2324       if (ARR_LEN(lists->extbb_list)) {
2325         ird_set_irg_link(irg, lists->extbb_list);
2326         dump_extblock_graph(F, irg);
2327       }
2328
2329       /* we may have blocks without extended blocks, bad for instance */
2330       if (ARR_LEN(lists->blk_list)) {
2331         ird_set_irg_link(irg, lists->blk_list);
2332         dump_block_graph(F, irg);
2333       }
2334
2335       DEL_ARR_F(lists->extbb_list);
2336       DEL_ARR_F(lists->blk_list);
2337       xfree(lists);
2338     }
2339   }
2340
2341   /* Close the vcg information for the irg */
2342   fprintf(F, "}\n\n");
2343
2344   vcg_close(F);
2345   free_extbb(irg);
2346 }
2347
2348 /* dumps a graph with type information */
2349 void
2350 dump_ir_graph_w_types (ir_graph *irg, const char *suffix)
2351 {
2352   FILE *f;
2353   ir_graph *rem = current_ir_graph;
2354   char *suffix1;
2355   int rem_dump_const_local;
2356
2357   /* if a filter is set, dump only the irg's that match the filter */
2358   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2359     return;
2360
2361   current_ir_graph = irg;
2362   rem_dump_const_local = dump_const_local;
2363   /* dumping types does not work with local nodes */
2364   dump_const_local = 0;
2365
2366   if (get_interprocedural_view()) suffix1 = "-pure-wtypes-ip";
2367   else                            suffix1 = "-pure-wtypes";
2368   f = vcg_open(irg,suffix, suffix1);
2369   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2370
2371   /* dump common ir graph */
2372   irg_walk(get_irg_end(irg), NULL, dump_whole_node, f);
2373   /* dump type info */
2374   type_walk_irg(irg, dump_type_info, NULL, f);
2375   inc_irg_visited(get_const_code_irg());
2376   /* dump edges from graph to type info */
2377   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
2378
2379   vcg_close(f);
2380   dump_const_local = rem_dump_const_local;
2381   current_ir_graph = rem;
2382 }
2383
2384 void
2385 dump_ir_block_graph_w_types (ir_graph *irg, const char *suffix)
2386 {
2387   FILE *f;
2388   int i;
2389   char *suffix1;
2390   ir_graph *rem = current_ir_graph;
2391   int rem_dump_const_local;
2392
2393   /* if a filter is set, dump only the irg's that match the filter */
2394   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2395     return;
2396
2397   rem_dump_const_local = dump_const_local;
2398   /* dumping types does not work with local nodes */
2399   dump_const_local = 0;
2400
2401   if (get_interprocedural_view()) suffix1 = "-wtypes-ip";
2402   else                            suffix1 = "-wtypes";
2403   f = vcg_open(irg, suffix, suffix1);
2404   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2405
2406   /* dump common blocked ir graph */
2407   construct_block_lists(irg);
2408
2409   for (i = 0; i < get_irp_n_irgs(); i++) {
2410     ir_node **arr = ird_get_irg_link(get_irp_irg(i));
2411     if (arr) {
2412       dump_graph_from_list(f, get_irp_irg(i));
2413       DEL_ARR_F(arr);
2414     }
2415   }
2416
2417   /* dump type info */
2418   current_ir_graph = irg;
2419   type_walk_irg(irg, dump_type_info, NULL, f);
2420   inc_irg_visited(get_const_code_irg());
2421
2422   /* dump edges from graph to type info */
2423   irg_walk(get_irg_end(irg), dump_node2type_edges, NULL, f);
2424
2425   vcg_close(f);
2426   dump_const_local = rem_dump_const_local;
2427   current_ir_graph = rem;
2428 }
2429
2430 /*---------------------------------------------------------------------*/
2431 /* The following routines dump a control flow graph.                   */
2432 /*---------------------------------------------------------------------*/
2433
2434 static void
2435 dump_block_to_cfg(ir_node *block, void *env) {
2436   FILE *F = env;
2437   int i, fl = 0;
2438   ir_node *pred;
2439
2440   if (is_Block(block)) {
2441     /* This is a block. Dump a node for the block. */
2442     fprintf (F, "node: {title: \""); PRINT_NODEID(block);
2443     fprintf (F, "\" label: \"");
2444     if (block == get_irg_start_block(get_irn_irg(block)))
2445       fprintf(F, "Start ");
2446     if (block == get_irg_end_block(get_irn_irg(block)))
2447       fprintf(F, "End ");
2448
2449     fprintf (F, "%s ", get_op_name(get_irn_op(block)));
2450     PRINT_NODEID(block);
2451     fprintf (F, "\" ");
2452     fprintf(F, "info1:\"");
2453
2454 #if 0
2455     if (dump_dominator_information_flag) {
2456       fprintf(F, "dom depth %d\n", get_Block_dom_depth(block));
2457       fprintf(F, "tree pre num %d\n", get_Block_dom_tree_pre_num(block));
2458       fprintf(F, "max subtree pre num %d\n", get_Block_dom_max_subtree_pre_num(block));
2459     }
2460
2461     /* show arity and possible Bad predecessors of the block */
2462     fprintf(F, "arity: %d\n", get_Block_n_cfgpreds(block));
2463     for (fl = i = 0; i < get_Block_n_cfgpreds(block); ++i) {
2464       ir_node *pred = get_Block_cfgpred(block, i);
2465       if (is_Bad(pred)) {
2466         if (! fl)
2467           fprintf(F, "Bad pred at pos: ");
2468         fprintf(F, "%d ", i);
2469         fl = 1;
2470       }
2471     }
2472     if (fl)
2473       fprintf(F, "\n");
2474 #else
2475     /* the generic version. */
2476     dump_irnode_to_file(F, block);
2477
2478     /* Check whether we have bad predecessors to color the block. */
2479     for (i = 0; i < get_Block_n_cfgpreds(block); ++i)
2480       if ((fl = is_Bad(get_Block_cfgpred(block, i))))
2481         break;
2482 #endif
2483
2484     fprintf (F, "\"");  /* closing quote of info */
2485
2486     if ((block == get_irg_start_block(get_irn_irg(block))) ||
2487     (block == get_irg_end_block(get_irn_irg(block)))     )
2488       fprintf(F, " color:blue ");
2489     else if (fl)
2490       fprintf(F, " color:yellow ");
2491
2492     fprintf (F, "}\n");
2493     /* Dump the edges */
2494     for ( i = 0; i < get_Block_n_cfgpreds(block); i++)
2495       if (get_irn_op(skip_Proj(get_Block_cfgpred(block, i))) != op_Bad) {
2496         pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i)));
2497         fprintf (F, "edge: { sourcename: \"");
2498         PRINT_NODEID(block);
2499         fprintf (F, "\" targetname: \"");
2500         PRINT_NODEID(pred);
2501         fprintf (F, "\"}\n");
2502       }
2503
2504     /* Dump dominator edge */
2505     if (dump_dominator_information_flag && get_Block_idom(block)) {
2506       pred = get_Block_idom(block);
2507       fprintf (F, "edge: { sourcename: \"");
2508       PRINT_NODEID(block);
2509       fprintf (F, "\" targetname: \"");
2510       PRINT_NODEID(pred);
2511       fprintf (F, "\" " DOMINATOR_EDGE_ATTR "}\n");
2512     }
2513   }
2514 }
2515
2516 void
2517 dump_cfg (ir_graph *irg, const char *suffix)
2518 {
2519   FILE *f;
2520   ir_graph *rem = current_ir_graph;
2521   int ddif = dump_dominator_information_flag;
2522   int ipv = get_interprocedural_view();
2523
2524   /* if a filter is set, dump only the irg's that match the filter */
2525   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
2526     return;
2527
2528   current_ir_graph = irg;
2529
2530   f = vcg_open(irg, suffix, "-cfg");
2531   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2532
2533   if (ipv) {
2534     printf("Warning: dumping cfg not in interprocedural view!\n");
2535     set_interprocedural_view(false);
2536   }
2537
2538   if (get_irg_dom_state(irg) != dom_consistent)
2539     dump_dominator_information_flag = 0;
2540
2541   /* walk over the blocks in the graph */
2542   irg_block_walk(get_irg_end(irg), dump_block_to_cfg, NULL, f);
2543   dump_node(f, get_irg_bad(irg));
2544
2545   dump_dominator_information_flag = ddif;
2546   set_interprocedural_view(ipv);
2547   vcg_close(f);
2548   current_ir_graph = rem;
2549 }
2550
2551
2552 static void descend_and_dump(FILE *F, ir_node *n, int depth, pset *mark_set) {
2553   if (pset_find_ptr(mark_set, n)) return;
2554
2555   pset_insert_ptr(mark_set, n);
2556
2557   if (depth > 0) {
2558     int i, start = is_Block(n) ? 0 : -1;
2559     dump_whole_node(n, F);
2560     for (i = start; i < get_irn_arity(n); ++i)
2561       descend_and_dump(F, get_irn_n(n, i), depth-1, mark_set);
2562   } else {
2563     dump_node(F, n);
2564     /* Don't dump edges to nodes further out.  These might be edges to
2565        nodes we already dumped, if there is a shorter path to these. */
2566   }
2567 }
2568
2569 static int subgraph_counter = 0;
2570 void dump_subgraph (ir_node *root, int depth, const char *suffix) {
2571   FILE *F;
2572   char buf[32];
2573   pset *mark_set = pset_new_ptr(1);
2574   sprintf(buf, "-subg_%03d", subgraph_counter++);
2575   F = vcg_open(get_irn_irg(root), suffix, buf);
2576   dump_vcg_header(F, get_irg_dump_name(get_irn_irg(root)), NULL);
2577   descend_and_dump(F, root, depth, mark_set);
2578   vcg_close(F);
2579   del_pset(mark_set);
2580 }
2581
2582
2583 static int weight_overall(int rec, int loop) {
2584   return 2*rec + loop;
2585 }
2586
2587 static int compute_color (int my, int max) {
2588   int color;
2589   if (!max) {
2590     color = 0;
2591   } else {
2592     int step;
2593
2594     /* if small, scale to the full color range. */
2595     if (max < n_colors)
2596       my = my * (n_colors/max);
2597
2598     step = 1 + (max / n_colors);
2599
2600     color = my/step;
2601   }
2602   return base_color + n_colors - color;
2603 }
2604
2605 static int get_entity_color(entity *ent) {
2606   ir_graph *irg = get_entity_irg(ent);
2607   assert(irg);
2608
2609   {
2610     int rec_depth     = get_irg_recursion_depth(irg);
2611     int loop_depth    = get_irg_loop_depth(irg);
2612     int overall_depth = weight_overall(rec_depth, loop_depth);
2613
2614     int max_rec_depth     = irp->max_callgraph_recursion_depth;
2615     int max_loop_depth    = irp->max_callgraph_loop_depth;
2616     int max_overall_depth = weight_overall(max_rec_depth, max_loop_depth);
2617
2618     /* int my_rec_color     = compute_color(rec_depth, max_rec_depth); */
2619     /* int my_loop_color    = compute_color(loop_depth, max_loop_depth); */
2620     int my_overall_color = compute_color(overall_depth, max_overall_depth);;
2621
2622     return my_overall_color;
2623   }
2624 }
2625
2626 void dump_callgraph(const char *suffix) {
2627   FILE *F;
2628   int i, n_irgs = get_irp_n_irgs();
2629   int rem = edge_label;
2630   edge_label = 1;
2631   //ident *prefix = new_id_from_str("java/");
2632
2633   F = vcg_open_name("Callgraph", suffix);
2634   dump_vcg_header(F, "Callgraph", NULL);
2635
2636   for (i = 0; i < n_irgs; ++i) {
2637     ir_graph *irg = get_irp_irg(i);
2638     entity *ent = get_irg_entity(irg);
2639     int j, n_callees = get_irg_n_callees(irg);
2640
2641     /* Do not dump runtime system. */
2642     //if (id_is_prefix(prefix, get_entity_ld_ident(ent))) continue;
2643
2644     dump_entity_node(F, ent, get_entity_color(ent));
2645     for (j = 0; j < n_callees; ++j) {
2646       entity *c = get_irg_entity(get_irg_callee(irg, j));
2647       //if (id_is_prefix(prefix, get_entity_ld_ident(c))) continue;
2648       int be = is_irg_callee_backedge(irg, j);
2649       char *attr;
2650       attr = (be) ?
2651         "label:\"recursion %d\" color: %d" :
2652         "label:\"calls %d\" color: %d";
2653       print_ent_ent_edge(F, ent, c, be, attr, get_irg_callee_loop_depth(irg, j), get_entity_color(ent));
2654     }
2655   }
2656
2657   edge_label = rem;
2658   vcg_close(F);
2659 }
2660
2661 /* Dump all irgs in interprocedural view to a single file. */
2662 void dump_all_cg_block_graph(const char *suffix) {
2663   FILE *f;
2664   int i;
2665   int rem_view = get_interprocedural_view();
2666   set_interprocedural_view(true);
2667
2668   f = vcg_open_name("All_graphs", suffix);
2669   dump_vcg_header(f, "All_graphs", NULL);
2670
2671   /* collect nodes in all irgs reachable in call graph*/
2672   for (i = 0; i < get_irp_n_irgs(); i++)
2673     ird_set_irg_link(get_irp_irg(i), NULL);
2674
2675   cg_walk(clear_link, collect_node, NULL);
2676
2677   /* dump all graphs */
2678   for (i = 0; i < get_irp_n_irgs(); i++) {
2679     current_ir_graph = get_irp_irg(i);
2680     assert(ird_get_irg_link(current_ir_graph));
2681     dump_graph_from_list(f, current_ir_graph);
2682     DEL_ARR_F(ird_get_irg_link(current_ir_graph));
2683   }
2684
2685   vcg_close(f);
2686   set_interprocedural_view(rem_view);
2687 }
2688
2689 /*---------------------------------------------------------------------*/
2690 /* the following routines dumps type information without any ir nodes. */
2691 /*---------------------------------------------------------------------*/
2692
2693 void
2694 dump_type_graph (ir_graph *irg, const char *suffix)
2695 {
2696   FILE *f;
2697   ir_graph *rem;
2698   rem = current_ir_graph;
2699
2700   /* if a filter is set, dump only the irg's that match the filter */
2701   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2702
2703   current_ir_graph = irg;
2704
2705   f = vcg_open(irg, suffix, "-type");
2706   dump_vcg_header(f, get_irg_dump_name(irg), NULL);
2707
2708   /* walk over the blocks in the graph */
2709   type_walk_irg(irg, dump_type_info, NULL, f);
2710   /* The walker for the const code can be called several times for the
2711      same (sub) expression.  So that no nodes are dumped several times
2712      we decrease the visited flag of the corresponding graph after each
2713      walk.  So now increase it finally. */
2714   inc_irg_visited(get_const_code_irg());
2715
2716   vcg_close(f);
2717   current_ir_graph = rem;
2718 }
2719
2720 void
2721 dump_all_types (const char *suffix)
2722 {
2723   FILE *f = vcg_open_name("All_types", suffix);
2724   dump_vcg_header(f, "All_types", NULL);
2725   type_walk(dump_type_info, NULL, f);
2726   inc_irg_visited(get_const_code_irg());
2727   vcg_close(f);
2728 }
2729
2730 void
2731 dump_class_hierarchy (bool entities, const char *suffix)
2732 {
2733   FILE *f = vcg_open_name("class_hierarchy", suffix);
2734   h_env_t env;
2735
2736   env.f = f;
2737   dump_vcg_header(f, "class_hierarchy", NULL);
2738   if (entities)
2739     env.dump_ent = 1;
2740   else
2741     env.dump_ent = 0;
2742   type_walk(dump_class_hierarchy_node, NULL, &env);
2743   vcg_close(f);
2744 }
2745
2746 /*---------------------------------------------------------------------*/
2747 /* dumps all graphs with the graph-dumper passed. Possible dumpers:    */
2748 /*  dump_ir_graph                                                      */
2749 /*  dump_ir_block_graph                                                */
2750 /*  dump_cfg                                                           */
2751 /*  dump_type_graph                                                    */
2752 /*  dump_ir_graph_w_types                                              */
2753 /*---------------------------------------------------------------------*/
2754
2755 void dump_all_ir_graphs(dump_graph_func *dmp_grph, const char *suffix) {
2756   int i, n_irgs = get_irp_n_irgs();
2757   for (i = 0; i < n_irgs; ++i) {
2758     dmp_grph(get_irp_irg(i), suffix);
2759   }
2760 }
2761
2762
2763 /*--------------------------------------------------------------------------------*
2764  * Dumps a stand alone loop graph with firm nodes which belong to one loop node   *
2765  * packed together in one subgraph/box                                            *
2766  *--------------------------------------------------------------------------------*/
2767
2768 void dump_loops_standalone(FILE *F, ir_loop *loop) {
2769   int i = 0, loop_node_started = 0, son_number = 0, first = 0;
2770   loop_element le;
2771   ir_loop *son = NULL;
2772
2773   /* Dump a new loop node. */
2774   dump_loop_node(F, loop);
2775
2776   /* Dump the loop elements. */
2777
2778   for(i = 0; i < get_loop_n_elements(loop); i++) {
2779     le = get_loop_element(loop, i);
2780     son = le.son;
2781     if (get_kind(son) == k_ir_loop) {
2782
2783       /* We are a loop son -> Recurse */
2784
2785       if(loop_node_started) { /* Close the "firm-nodes" node first if we started one. */
2786         fprintf(F, "\" }\n");
2787         fprintf (F, "edge: {sourcename: \"");
2788         PRINT_LOOPID(loop);
2789         fprintf (F, "\" targetname: \"");
2790         PRINT_LOOPID(loop);
2791         fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
2792         loop_node_started = 0;
2793       }
2794       dump_loop_son_edge(F, loop, son_number++);
2795       dump_loops_standalone(F, son);
2796     } else if (get_kind(son) == k_ir_node) {
2797       /* We are a loop node -> Collect firm nodes */
2798
2799       ir_node *n = le.node;
2800       int bad = 0;
2801
2802       if (!loop_node_started) {
2803         /* Start a new node which contains all firm nodes of the current loop */
2804         fprintf (F, "node: { title: \"");
2805         PRINT_LOOPID(loop);
2806         fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
2807         loop_node_started = 1;
2808         first = i;
2809       }
2810       else
2811         fprintf(F, "\n");
2812
2813       bad |= dump_node_label(F, n);
2814       /* Causes indeterministic output: if (is_Block(n)) fprintf (F, "\t ->%d", (int)get_irn_link(n)); */
2815       if (has_backedges(n)) fprintf(F, "\t loop head!");
2816     } else { /* for callgraph loop tree */
2817       ir_graph *n;
2818       assert(get_kind(son) == k_ir_graph);
2819
2820       /* We are a loop node -> Collect firm graphs */
2821       n = (ir_graph *)le.node;
2822       if (!loop_node_started) {
2823         /* Start a new node which contains all firm nodes of the current loop */
2824         fprintf (F, "node: { title: \"");
2825         PRINT_LOOPID(loop);
2826         fprintf (F, "-%d-nodes\" color: lightyellow label: \"", i);
2827         loop_node_started = 1;
2828         first = i;
2829       }
2830       else
2831         fprintf(F, "\n");
2832       fprintf (F, " %s", get_irg_dump_name(n));
2833       /* fprintf (F, " %s (depth %d)", get_irg_dump_name(n), n->callgraph_weighted_loop_depth); */
2834     }
2835   }
2836
2837   if (loop_node_started) {
2838     fprintf(F, "\" }\n");
2839     fprintf (F, "edge: {sourcename: \"");
2840     PRINT_LOOPID(loop);
2841     fprintf (F, "\" targetname: \"");
2842     PRINT_LOOPID(loop);
2843     fprintf (F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1);
2844     loop_node_started = 0;
2845   }
2846 }
2847
2848 void dump_loop_tree(ir_graph *irg, const char *suffix)
2849 {
2850   FILE *f;
2851   ir_graph *rem = current_ir_graph;
2852   int el_rem = edge_label;
2853   edge_label = 1;
2854
2855   /* if a filter is set, dump only the irg's that match the filter */
2856   if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg)))) return;
2857
2858   current_ir_graph = irg;
2859
2860   f = vcg_open(irg, suffix, "-looptree");
2861   dump_vcg_header(f, get_irg_dump_name(irg), "top_to_bottom");
2862
2863   if (get_irg_loop(irg)) dump_loops_standalone(f, get_irg_loop(irg));
2864
2865   vcg_close(f);
2866
2867   edge_label = el_rem;
2868   current_ir_graph = rem;
2869 }
2870
2871 void dump_callgraph_loop_tree(const char *suffix) {
2872   FILE *F;
2873   F = vcg_open_name("Callgraph_looptree", suffix);
2874   dump_vcg_header(F, "callgraph looptree", "top_to_bottom");
2875   dump_loops_standalone(F, irp->outermost_cg_loop);
2876   vcg_close(F);
2877 }
2878
2879
2880 /*-----------------------------------------------------------------------------*/
2881 /* Dumps the firm nodes in the loop tree to a graph along with the loop nodes. */
2882 /*-----------------------------------------------------------------------------*/
2883
2884 void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) {
2885   int i, son_number = 0, node_number = 0;
2886
2887   if (dump_loop_information_flag) dump_loop_node(F, loop);
2888
2889   for (i = 0; i < get_loop_n_elements(loop); i++) {
2890     loop_element le = get_loop_element(loop, i);
2891     if (*(le.kind) == k_ir_loop) {
2892       if (dump_loop_information_flag) dump_loop_son_edge(F, loop, son_number++);
2893       /* Recur */
2894       collect_nodeloop(F, le.son, loopnodes);
2895     } else {
2896       if (dump_loop_information_flag) dump_loop_node_edge(F, loop, node_number++);
2897       eset_insert(loopnodes, le.node);
2898     }
2899   }
2900 }
2901
2902 void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extnodes) {
2903   int i, j, start;
2904
2905   for(i = 0; i < get_loop_n_elements(loop); i++) {
2906     loop_element le = get_loop_element(loop, i);
2907     if (*(le.kind) == k_ir_loop) {
2908       /* Recur */
2909       collect_nodeloop_external_nodes(le.son, loopnodes, extnodes);
2910     } else {
2911       if (is_Block(le.node)) start = 0; else start = -1;
2912       for (j = start; j < get_irn_arity(le.node); j++) {
2913         ir_node *pred = get_irn_n(le.node, j);
2914         if (!eset_contains(loopnodes, pred)) {
2915           eset_insert(extnodes, pred);
2916           if (!is_Block(pred)) {
2917             pred = get_nodes_block(pred);
2918             if (!eset_contains(loopnodes, pred)) eset_insert(extnodes, pred);
2919           }
2920         }
2921       }
2922     }
2923   }
2924 }
2925
2926 void dump_loop(ir_loop *l, const char *suffix) {
2927   FILE *F;
2928   char name[50];
2929   eset *loopnodes = eset_create();
2930   eset *extnodes = eset_create();
2931   ir_node *n, *b;
2932
2933   snprintf(name, sizeof(name), "loop_%d", get_loop_loop_nr(l));
2934   F = vcg_open_name (name, suffix);
2935   dump_vcg_header(F, name, NULL);
2936
2937   /* collect all nodes to dump */
2938   collect_nodeloop(F, l, loopnodes);
2939   collect_nodeloop_external_nodes(l, loopnodes, extnodes);
2940
2941   /* build block lists */
2942   for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
2943     set_irn_link(n, NULL);
2944   for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
2945     set_irn_link(n, NULL);
2946   for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes))
2947     if (!is_Block(n)) {
2948       b = get_nodes_block(n);
2949       set_irn_link(n, get_irn_link(b));
2950       set_irn_link(b, n);
2951     }
2952   for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes))
2953     if (!is_Block(n)) {
2954       b = get_nodes_block(n);
2955       set_irn_link(n, get_irn_link(b));
2956       set_irn_link(b, n);
2957     }
2958
2959   for (b = eset_first(loopnodes); b != NULL; b = eset_next(loopnodes))
2960     if (is_Block(b)) {
2961       fprintf(F, "graph: { title: \"");
2962       PRINT_NODEID(b);
2963       fprintf(F, "\"  label: \"");
2964       dump_node_opcode(F, b);
2965       fprintf (F, " %ld", get_irn_node_nr(b));
2966       fprintf(F, "\" status:clustered color:yellow\n");
2967
2968       /* dump the blocks edges */
2969       dump_ir_data_edges(F, b);
2970
2971       /* dump the nodes that go into the block */
2972       for (n = get_irn_link(b); n; n = get_irn_link(n)) {
2973         if (eset_contains(extnodes, n)) overrule_nodecolor = "lightblue";
2974         dump_node(F, n);
2975         overrule_nodecolor = NULL;
2976         if (!eset_contains(extnodes, n)) dump_ir_data_edges(F, n);
2977       }
2978
2979       /* Close the vcg information for the block */
2980       fprintf(F, "}\n");
2981       dump_const_node_local(F, b);
2982       fprintf(F, "\n");
2983     }
2984   for (b = eset_first(extnodes); b != NULL; b = eset_next(extnodes))
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:lightblue\n");
2992
2993       /* dump the nodes that go into the block */
2994       for (n = get_irn_link(b); n; n = get_irn_link(n)) {
2995         if (!eset_contains(loopnodes, n)) overrule_nodecolor = "lightblue";
2996         dump_node(F, n);
2997         overrule_nodecolor = NULL;
2998         if (eset_contains(loopnodes, n)) dump_ir_data_edges(F, n);
2999       }
3000
3001       /* Close the vcg information for the block */
3002       fprintf(F, "}\n");
3003       dump_const_node_local(F, b);
3004       fprintf(F, "\n");
3005     }
3006
3007   eset_destroy(loopnodes);
3008   eset_destroy(extnodes);
3009   vcg_close(F);
3010 }