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

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