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