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