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

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