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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer
   5 **
   6 ** irdump.h: dumping of an intermediate representation graph
   7 */
   8
   9 #ifdef HAVE_CONFIG_H
  10 # include <config.h>
  11 #endif
  12
  13 # include "irnode_t.h"
  14 # include "irgraph_t.h"
  15 # include "irprog.h"
  16 # include "irdump.h"
  17 # include "panic.h"
  18 # include <string.h>
  19 # include "entity.h"
  20 # include <stdlib.h>
  21 # include "array.h"
  22 # include "irop_t.h"
  23 # include "tv.h"
  24 # include "type_or_entity.h"
  25 # include "irgwalk.h"
  26 # include "typewalk.h"
  27
  28 /* Attributes of nodes */
  29 #define DEFAULT_NODE_ATTR ""
  30 #define DEFAULT_TYPE_ATTRIBUTE ""
  31
  32 /* Attributes of edges between Firm nodes */
  33 #define BLOCK_EDGE_ATTR "class: 2 priority: 2 linestyle: dotted"
  34 #define CF_EDGE_ATTR    "color: red"
  35 #define MEM_EDGE_ATTR   "color: blue"
  36
  37 /* Attributes of edges between Firm nodes and type/entity nodes */
  38 #define NODE2TYPE_EDGE_ATTR ""
  39
  40 /* Attributes of edges in type/entity graphs. */
  41 #define TYPE_METH_NODE_ATTR  "color: lightyellow"
  42 #define TYPE_CLASS_NODE_ATTR "color: green"
  43 #define ENTITY_NODE_ATTR     "color: yellow"
  44 #define ENT_TYPE_EDGE_ATTR   "class: 3 label: \"type\" color: red"
  45 #define ENT_OWN_EDGE_ATTR    "class: 4 label: \"owner\" color: black"
  46 #define METH_PAR_EDGE_ATTR   "class: 5 label: \"param %d\" color: green"
  47 #define METH_RES_EDGE_ATTR   "class: 6 label: \"res %d\" color: green"
  48 #define TYPE_SUPER_EDGE_ATTR "class: 7 label: \"supertype\" color: blue"
  49 #define UNION_EDGE_ATTR      "class: 8 label: \"component\" color: blue"
  50 #define PTR_PTS_TO_EDGE_ATTR "class: 9 label: \"points to\" color:green"
  51 #define ARR_ELT_TYPE_EDGE_ATTR "class: 10 label: \"arr elt\" color:green"
  52 #define ENT_OVERWRITES_EDGE_ATTR "class: 11 label: \"overwrites\" color:red"
  53 #define TYPE_MEMBER_EDGE_ATTR "class: 12 label: \"member\" color:blue"
  54
  55 #define PRINT_NODEID(X) fprintf(F, "%p", X)
  56
  57 /* file to dump to */
  58 static FILE *F;
  59
  60 /* A compiler option to turn off edge labels */
  61 int edge_label = 1;
  62
  63 /* A global variable to record output of the Bad node. */
  64 int Bad_dumped;
  65
  66 /*******************************************************************/
  67 /* routines to dump information about a single node                */
  68 /*******************************************************************/
  69
  70
  71
  72 inline void
  73 dump_node_opcode (ir_node *n)
  74 {
  75
  76   /* Const */
  77   if (n->op->code == iro_Const) {
  78     xfprintf (F, "%v", n->attr.con);
  79
  80   /* SymConst */
  81   } else if (n->op->code == iro_SymConst) {
  82     if (get_SymConst_kind(n) == linkage_ptr_info) {
  83       xfprintf (F, "%I", get_SymConst_ptrinfo(n));
  84     } else {
  85       assert(get_kind(get_SymConst_type(n)) == k_type);
  86       assert(get_type_ident(get_SymConst_type(n)));
  87       xfprintf (F, "%s ", id_to_str(get_type_ident(get_SymConst_type(n))));
  88       if (get_SymConst_kind == type_tag)
  89         xfprintf (F, "tag");
  90       else
  91         xfprintf (F, "size");
  92     }
  93   /* all others */
  94   } else {
  95     xfprintf (F, "%I", get_irn_opident(n));
  96   }
  97 }
  98
  99 inline void
 100 dump_node_mode (ir_node *n)
 101 {
 102   switch (n->op->code) {
 103   case iro_Phi:
 104   case iro_Const:
 105   case iro_Id:
 106   case iro_Proj:
 107   case iro_Conv:
 108   case iro_Tuple:
 109   case iro_Add:
 110   case iro_Sub:
 111   case iro_Mul:
 112   case iro_And:
 113   case iro_Or:
 114   case iro_Eor:
 115   case iro_Shl:
 116   case iro_Shr:
 117   case iro_Abs:
 118   case iro_Cmp:
 119     xfprintf (F, "%I", get_mode_ident(n->mode));
 120     break;
 121   default:
 122   }
 123 }
 124
 125 inline void
 126 dump_node_nodeattr (ir_node *n)
 127 {
 128   switch (n->op->code) {
 129   case iro_Proj:
 130     if (n->in[1]->op->code == iro_Cmp) {
 131       xfprintf (F, "%s", get_pnc_string(n->attr.proj));
 132     } else {
 133       xfprintf (F, "%ld", n->attr.proj);
 134     }
 135     break;
 136   case iro_Sel: {
 137     assert(get_kind(get_Sel_entity(n)) == k_entity);
 138     xfprintf (F, "%s", id_to_str(get_entity_ident(get_Sel_entity(n))));
 139     } break;
 140   default:
 141   } /* end switch */
 142 }
 143
 144 inline void
 145 dump_node_vcgattr (ir_node *n)
 146 {
 147   switch (n->op->code) {
 148   case iro_Start:
 149   case iro_End:
 150     xfprintf (F, "color: blue");
 151     break;
 152   case iro_Block:
 153     xfprintf (F, "color: lightyellow");
 154     break;
 155   case iro_Phi:
 156     xfprintf (F, "color: green");
 157     break;
 158   case iro_Const:
 159   case iro_Proj:
 160   case iro_Tuple:
 161     xfprintf (F, "color: yellow");
 162     break;
 163   default:
 164     xfprintf (F, DEFAULT_NODE_ATTR);
 165   }
 166 }
 167
 168 void
 169 dump_node (ir_node *n) {
 170
 171   /* dump this node */
 172   xfprintf (F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: \"");
 173
 174   dump_node_opcode(n);
 175   dump_node_mode (n);
 176   xfprintf (F, " ");
 177   dump_node_nodeattr(n);
 178 #ifdef DEBUG_libfirm
 179   xfprintf (F, " %ld", get_irn_node_nr(n));
 180 #endif
 181   xfprintf (F, "\" ");
 182   dump_node_vcgattr(n);
 183   xfprintf (F, "}\n");
 184 }
 185
 186 void
 187 dump_ir_node (ir_node *n)
 188 {
 189   /* dump this node */
 190   fprintf (F, "node: {title: \""); PRINT_NODEID(n); fprintf(F, "\" label: ");
 191
 192   switch (n->op->code) {  /* node label */
 193   case iro_Start:
 194     xfprintf (F, "\"%I\" color: blue ", get_irn_opident(n));
 195     xfprintf (F, DEFAULT_NODE_ATTR);
 196      break;
 197   case iro_End:
 198     xfprintf (F, "\"%I\" color: blue ", get_irn_opident(n));
 199     xfprintf (F, DEFAULT_NODE_ATTR);
 200     break;
 201   case iro_Block:
 202     xfprintf (F, "\"%I\" color: lightyellow ", get_irn_opident(n));
 203     xfprintf (F, DEFAULT_NODE_ATTR);
 204     break;
 205   case iro_Phi:
 206     xfprintf (F, "\"%I%I\" color: green", get_irn_opident(n), get_irn_modeident(n));
 207     if (get_irn_modecode(n) == irm_M)
 208       xfprintf (F, DEFAULT_NODE_ATTR " color: green");
 209     else
 210       xfprintf (F, DEFAULT_NODE_ATTR);
 211     break;
 212   case iro_Const:
 213     xfprintf (F, "\"%v%I\" color: yellow ", n->attr.con, get_irn_modeident(n));
 214     xfprintf (F, DEFAULT_NODE_ATTR);
 215     break;
 216   case iro_Id:
 217     xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n));
 218     xfprintf (F, DEFAULT_NODE_ATTR);
 219     break;
 220   case iro_Proj:
 221     if (n->in[1]->op->code == iro_Cmp) {
 222       xfprintf (F, "\"%I%I %s\" color: yellow", get_irn_opident(n), get_irn_modeident(n),
 223                 get_pnc_string(n->attr.proj));
 224     } else {
 225       xfprintf (F, "\"%I%I %ld\"", get_irn_opident(n), get_irn_modeident(n), n->attr.proj);
 226     }
 227     xfprintf (F, DEFAULT_NODE_ATTR);
 228     break;
 229   case iro_Conv:
 230     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 231     xfprintf (F, DEFAULT_NODE_ATTR);
 232     break;
 233   case iro_Tuple:
 234     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 235     xfprintf (F, DEFAULT_NODE_ATTR);
 236     break;
 237   case iro_Add:
 238     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 239     xfprintf (F, DEFAULT_NODE_ATTR);
 240     break;
 241   case iro_Sub:
 242     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 243     xfprintf (F, DEFAULT_NODE_ATTR);
 244     break;
 245   case iro_Mul:
 246     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 247     xfprintf (F, DEFAULT_NODE_ATTR);
 248     break;
 249   case iro_Quot:
 250     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 251     xfprintf (F, DEFAULT_NODE_ATTR);
 252     break;
 253   case iro_DivMod:
 254     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 255     xfprintf (F, DEFAULT_NODE_ATTR);
 256     break;
 257   case iro_Div:
 258     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 259     xfprintf (F, DEFAULT_NODE_ATTR);
 260     break;
 261   case iro_Mod:
 262     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 263     xfprintf (F, DEFAULT_NODE_ATTR);
 264     break;
 265   case iro_And:
 266     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 267     xfprintf (F, DEFAULT_NODE_ATTR);
 268     break;
 269   case iro_Or:
 270     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 271     xfprintf (F, DEFAULT_NODE_ATTR);
 272     break;
 273   case iro_Eor:
 274     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 275     xfprintf (F, DEFAULT_NODE_ATTR);
 276     break;
 277   case iro_Shl:
 278     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 279     xfprintf (F, DEFAULT_NODE_ATTR);
 280     break;
 281   case iro_Shr:
 282     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 283     xfprintf (F, DEFAULT_NODE_ATTR);
 284     break;
 285   case iro_Abs:
 286     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 287     xfprintf (F, DEFAULT_NODE_ATTR);
 288     break;
 289   case iro_Cmp:
 290     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 291     xfprintf (F, DEFAULT_NODE_ATTR);
 292     break;
 293   case iro_Jmp:
 294     xfprintf (F, "\"%I\"", get_irn_opident(n));
 295     xfprintf (F, DEFAULT_NODE_ATTR);
 296     break;
 297   case iro_Cond:
 298     xfprintf (F, "\"%I\"", get_irn_opident(n));
 299     xfprintf (F, DEFAULT_NODE_ATTR);
 300     break;
 301   case iro_Call:
 302     xfprintf (F, "\"%I\"", get_irn_opident(n));
 303     xfprintf (F, DEFAULT_NODE_ATTR);
 304     break;
 305   case iro_Return:
 306     xfprintf (F, "\"%I\"", get_irn_opident(n));
 307     xfprintf (F, DEFAULT_NODE_ATTR);
 308     break;
 309   case iro_Raise:
 310     xfprintf (F, "\"%I%I\"", get_irn_opident(n), get_irn_modeident(n));
 311     xfprintf (F, DEFAULT_NODE_ATTR);
 312     break;
 313   case iro_Load:
 314   case iro_Store:
 315     xfprintf (F, "\"%R\"", n);
 316     xfprintf (F, DEFAULT_NODE_ATTR);
 317     break;
 318   case iro_Alloc:
 319     xfprintf (F, "\"%I\" ", get_irn_opident(n));
 320     xfprintf (F, DEFAULT_NODE_ATTR);
 321     break;
 322   case iro_Sel:
 323     assert(get_kind(get_Sel_entity(n)) == k_entity);
 324     xfprintf (F, "\"%I ", get_irn_opident(n));
 325     xfprintf (F, "%s", id_to_str(get_entity_ident(get_Sel_entity(n))));
 326     xfprintf (F, DEFAULT_NODE_ATTR);
 327     break;
 328   case iro_SymConst:
 329     assert(get_kind(get_SymConst_type(n)) == k_type);
 330     assert(get_type_ident(get_SymConst_type(n)));
 331     xfprintf (F, "\"%s ", get_type_name(get_SymConst_type(n)));
 332     switch (n->attr.i.num){
 333     case type_tag:
 334       xfprintf (F, "tag\" ");
 335       break;
 336     case size:
 337       xfprintf (F, "size\" ");
 338       break;
 339     default:
 340       assert(0);
 341       break;
 342     }
 343     xfprintf (F, DEFAULT_NODE_ATTR);
 344     break;
 345   case iro_Sync:
 346     xfprintf (F, "\"%I\" ", get_irn_opident(n));
 347     xfprintf (F, DEFAULT_NODE_ATTR " color: green");
 348     break;
 349   case iro_Bad:
 350     xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n));
 351     xfprintf (F, DEFAULT_NODE_ATTR);
 352     break;
 353   default:
 354     xfprintf (F, "\"%I%I\" ", get_irn_opident(n), get_irn_modeident(n));
 355   }
 356   xfprintf (F, "}\n");          /* footer */
 357 }
 358
 359
 360 /* dump the edge to the block this node belongs to */
 361 void
 362 dump_ir_block_edge(ir_node *n)  {
 363   if (is_no_Block(n))
 364     xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 365                 BLOCK_EDGE_ATTR "}\n", n, get_nodes_Block(n));
 366 }
 367
 368 void print_edge_vcgattr(ir_node *from, int to) {
 369   assert(from);
 370
 371   switch (get_irn_opcode(from)) {
 372   case iro_Block:
 373     xfprintf (F, CF_EDGE_ATTR);
 374     break;
 375   case iro_Start:   break;
 376   case iro_End:     break;
 377   case iro_Jmp:     break;
 378   case iro_Cond:    break;
 379   case iro_Return:
 380   case iro_Raise:
 381     if (to == 0) xfprintf (F, MEM_EDGE_ATTR);
 382     break;
 383   case iro_Const:   break;
 384   case iro_SymConst:break;
 385   case iro_Sel:
 386   case iro_Call:
 387     if (to == 0) xfprintf (F, MEM_EDGE_ATTR);
 388     break;
 389   case iro_Add:     break;
 390   case iro_Sub:     break;
 391   case iro_Minus:   break;
 392   case iro_Mul:     break;
 393   case iro_Quot:
 394   case iro_DivMod:
 395   case iro_Div:
 396   case iro_Mod:
 397     if (to == 0) xfprintf (F, MEM_EDGE_ATTR);
 398     break;
 399   case iro_Abs:    break;
 400   case iro_And:    break;
 401   case iro_Or:     break;
 402   case iro_Eor:    break;
 403   case iro_Shl:    break;
 404   case iro_Shr:    break;
 405   case iro_Shrs:   break;
 406   case iro_Rot:    break;
 407   case iro_Cmp:    break;
 408   case iro_Conv:   break;
 409   case iro_Phi:
 410     if (get_irn_modecode(from) == irm_M) xfprintf (F, MEM_EDGE_ATTR);
 411     break;
 412   case iro_Load:
 413   case iro_Store:
 414   case iro_Alloc:
 415   case iro_Free:
 416     if (to == 0) xfprintf (F, MEM_EDGE_ATTR);
 417     break;
 418   case iro_Sync:
 419     xfprintf (F, MEM_EDGE_ATTR);
 420     break;
 421   case iro_Tuple:  break;
 422   case iro_Proj:
 423     switch (get_irn_modecode(from)) {
 424     case irm_X:
 425       xfprintf (F, CF_EDGE_ATTR);
 426       break;
 427     case irm_M:
 428       xfprintf (F, MEM_EDGE_ATTR);
 429       break;
 430     default: break;
 431     }
 432     break;
 433   case iro_Bad:    break;
 434   case iro_Id:     break;
 435   default:
 436   }
 437 }
 438
 439 /* dump edges to our inputs */
 440 void
 441 dump_ir_data_edges(ir_node *n)  {
 442   int i;
 443
 444   for (i = 0; i < get_irn_arity(n); i++) {
 445     assert(get_irn_n(n, i));
 446     xfprintf (F, "edge: {sourcename: \"%p\" targetname: \"%p\"",
 447               n, get_irn_n(n, i));
 448     fprintf (F, " label: \"%d\" ", i);
 449     print_edge_vcgattr(n, i);
 450     fprintf (F, "}\n");
 451   }
 452 }
 453
 454 /* dumps the edges between nodes and their type or entity attributes. */
 455 void dump_node2type_edges (ir_node *n, void *env)
 456 {
 457   assert(n);
 458
 459   switch (get_irn_opcode(n)) {
 460   case iro_SymConst:
 461     if (   (get_SymConst_kind(n) == type_tag)
 462         || (get_SymConst_kind(n) == size))
 463       xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 464                 NODE2TYPE_EDGE_ATTR "}\n", n, get_SymConst_type(n));
 465     break;
 466   case iro_Sel:
 467     xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 468               NODE2TYPE_EDGE_ATTR "}\n", n, get_Sel_entity(n));
 469     break;
 470   case iro_Call:
 471     xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 472               NODE2TYPE_EDGE_ATTR "}\n", n, get_Call_type(n));
 473     break;
 474   case iro_Alloc:
 475     xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 476               NODE2TYPE_EDGE_ATTR "}\n", n, get_Alloc_type(n));
 477     break;
 478   case iro_Free:
 479     xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 480               NODE2TYPE_EDGE_ATTR "}\n", n, get_Free_type(n));
 481     break;
 482   default:
 483     break;
 484   }
 485 }
 486
 487
 488 /* dumps a type or entity and it's edges. */
 489 void
 490 dump_type_info (type_or_ent *tore, void *env) {
 491   int i = 0;  /* to shutup gcc */
 492
 493   /* dump this type or entity */
 494   xfprintf (F, "node: {title: \"%p\" ", tore);
 495   xfprintf (F, DEFAULT_TYPE_ATTRIBUTE);
 496   xfprintf (F, "label: ");
 497
 498   switch (get_kind(tore)) {
 499   case k_entity:
 500     {
 501       entity *ent = (entity *)tore;
 502       xfprintf (F, "\"ent %I\" " ENTITY_NODE_ATTR , get_entity_ident(ent));
 503       if(dynamic_allocated == get_entity_allocation(ent))
 504         xfprintf (F, " info1:\"dynamic allocated\"}\n");
 505       else
 506         xfprintf (F, " info1:\"static allocated\"}\n");
 507       xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 508                 ENT_OWN_EDGE_ATTR "}\n", tore, get_entity_owner(ent));
 509       xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 510                 ENT_TYPE_EDGE_ATTR "}\n", tore, get_entity_type(ent));
 511       for(i = 0; i < get_entity_n_overwrites(ent); i++)
 512         xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 513                   ENT_OVERWRITES_EDGE_ATTR "}\n", tore, get_entity_overwrites(ent, i));
 514     } break;
 515   case k_type:
 516     {
 517       /* why can't I cast here??? @@@ */
 518       type *type = tore;
 519       xfprintf (F, "\"%I %I", get_type_tpop_nameid(type), get_type_ident(type));
 520
 521       switch (get_type_tpop_code(type)) {
 522       case tpo_class:
 523         {
 524           xfprintf (F, "\" " TYPE_CLASS_NODE_ATTR "}\n");
 525           for (i=0; i < get_class_n_supertype(type); i++)
 526             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 527                       TYPE_SUPER_EDGE_ATTR "}\n",
 528                       type, get_class_supertype(type, i));
 529           for (i=0; i < get_class_n_member(type); i++)
 530             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 531                       TYPE_MEMBER_EDGE_ATTR "}\n",
 532                       type, get_class_member(type, i));
 533         } break;
 534       case tpo_struct:
 535         {
 536           xfprintf (F, "\"}\n");
 537           for (i=0; i < get_struct_n_member(type); i++)
 538             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 539                       TYPE_MEMBER_EDGE_ATTR "}\n",
 540                       type, get_struct_member(type, i));
 541         } break;
 542       case tpo_method:
 543         {
 544           xfprintf (F, "\" " TYPE_METH_NODE_ATTR "}\n");
 545           for (i = 0; i < get_method_n_params(type); i++)
 546             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 547                       METH_PAR_EDGE_ATTR "}\n",
 548                       type, get_method_param_type(type, i), i);
 549           for (i = 0; i < get_method_n_res(type); i++)
 550             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 551                       METH_RES_EDGE_ATTR "}\n",
 552                       type, get_method_res_type(type, i), i);
 553         } break;
 554       case tpo_union:
 555         {
 556           xfprintf (F, "\"}\n");
 557           for (i = 0; i < get_union_n_members(type); i++)
 558             xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 559                       "label: \"\"f" UNION_EDGE_ATTR "}\n",
 560                       type, get_union_member(type, i));
 561         } break;
 562       case tpo_array:
 563         {
 564           xfprintf (F, "\"}\n");
 565           xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 566                     ARR_ELT_TYPE_EDGE_ATTR "}\n", type, get_array_element_type(type), i);
 567         } break;
 568       case tpo_enumeration:
 569         {
 570           xfprintf (F, "\"}\n");
 571         } break;
 572       case tpo_pointer:
 573         {
 574           xfprintf (F, "\"}\n");
 575           xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" "
 576                     PTR_PTS_TO_EDGE_ATTR "}\n", type,
 577                     get_pointer_points_to_type(type), i);
 578         } break;
 579       case tpo_primitive:
 580         {
 581           xfprintf (F, "mode %I\"}\n", get_mode_ident(get_type_mode(type)));
 582         } break;
 583       default: break;
 584       } /* switch type */
 585     }
 586     break; /* case k_type */
 587   default:
 588     {
 589       xfprintf (F, "\" faulty type \"}\n");
 590       printf(" *** irdump,  %s(l.%i), faulty type.\n", __FUNCTION__, __LINE__);
 591     } break;
 592   } /* switch kind_or_entity */
 593 }
 594
 595 /************************************************************************/
 596 /* open and close vcg file                                              */
 597 /************************************************************************/
 598
 599 void vcg_open (ir_graph *irg, char *suffix) {
 600   char *fname;  /* filename to put the vcg information in */
 601   const char *cp;
 602   ident *id;
 603   int len;
 604   char label[4];
 605
 606   /** open file for vcg graph */
 607   id    = get_entity_ld_ident (get_irg_ent(irg));
 608   len   = id_to_strlen (id);
 609   cp    = id_to_str (id);
 610
 611   fname = malloc (len + 5 + strlen(suffix));
 612   strncpy (fname, cp, len);      /* copy the filename */
 613   fname[len] = '\0';
 614   strcat (fname, suffix);  /* append file suffix */
 615
 616   fname = malloc (len + 5 + strlen(suffix));
 617   strncpy (fname, cp, len); /* copy the filename */
 618   fname[len] = '\0';        /* ensure string termination */
 619   /*strcpy (fname, cp);      * copy the filename *
 620     this produces wrong, too long strings in conjuction with the
 621     jocca frontend.  The \0 seems to be missing. */
 622   strcat (fname, suffix);   /* append file suffix */
 623   strcat (fname, ".vcg");   /* append the .vcg suffix */
 624   F = fopen (fname, "w");   /* open file for writing */
 625   if (!F) {
 626     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
 627   }
 628
 629   if (edge_label) {
 630     strcpy(label, "yes");
 631   } else {
 632     strcpy (label, "no");
 633   }
 634
 635   /* print header */
 636   xfprintf (F,
 637             "graph: { title: \"ir graph of %s\"\n"
 638             "display_edge_labels: %s\n"
 639             "layoutalgorithm: mindepth\n"
 640             "manhattan_edges: yes\n"
 641             "port_sharing: no\n"
 642             "orientation: bottom_to_top\n"
 643             "classname 1: \"Data\"\n"
 644             "classname 2: \"Block\"\n"
 645             "classname 3: \"Entity type\""
 646             "classname 4: \"Entity owner\""
 647             "classname 5: \"Method Param\""
 648             "classname 6: \"Method Res\""
 649             "classname 7: \"Super\""
 650             "classname 8: \"Union\""
 651             "classname 9: \"Points-to\""
 652             "classname 10: \"Array Element Type\""
 653             "classname 11: \"Overwrites\""
 654             "classname 12: \"Member\""
 655             , cp, label);
 656
 657   xfprintf (F, "\n");           /* a separator */
 658 }
 659
 660 void vcg_open_name (const char *name) {
 661   char *fname;  /* filename to put the vcg information in */
 662   int len;
 663   char label[4];
 664
 665   /** open file for vcg graph */
 666   len   = strlen(name);
 667   fname = malloc (len + 5);
 668   strcpy (fname, name);    /* copy the filename */
 669   strcat (fname, ".vcg");  /* append the .vcg suffix */
 670   F = fopen (fname, "w");  /* open file for writing */
 671   if (!F) {
 672     panic ("cannot open %s for writing (%m)", fname);  /* not reached */
 673   }
 674
 675   if (edge_label) {
 676     strcpy(label, "yes");
 677   } else {
 678     strcpy (label, "no");
 679   }
 680
 681   /* print header */
 682   xfprintf (F,
 683             "graph: { title: \"ir graph of %s\"\n"
 684             "display_edge_labels: %s\n"
 685             "layoutalgorithm: mindepth\n"
 686             "manhattan_edges: yes\n"
 687             "port_sharing: no\n"
 688             "orientation: bottom_to_top\n"
 689             "classname 1: \"Data\"\n"
 690             "classname 2: \"Block\"\n"
 691             "classname 3: \"Entity type\"\n"
 692             "classname 4: \"Entity owner\"\n"
 693             "classname 5: \"Method Param\"\n"
 694             "classname 6: \"Method Res\"\n"
 695             "classname 7: \"Super\"\n"
 696             "classname 8: \"Union\"\n"
 697             "classname 9: \"Points-to\"\n"
 698             "classname 10: \"Array Element Type\"\n"
 699             "classname 11: \"Overwrites\"\n"
 700             "classname 12: \"Member\"\n"
 701             , name, label);
 702
 703   xfprintf (F, "\n");           /* a separator */
 704 }
 705
 706 void
 707 vcg_close () {
 708   xfprintf (F, "}\n");  /* print footer */
 709   fclose (F);           /* close vcg file */
 710 }
 711
 712 /************************************************************************/
 713 /* routines to dump a graph, blocks as conventional nodes.              */
 714 /************************************************************************/
 715
 716 void
 717 dump_whole_node (ir_node *n, void* env) {
 718   dump_node(n);
 719   dump_ir_block_edge(n);
 720   dump_ir_data_edges(n);
 721 }
 722
 723 void
 724 dump_ir_graph (ir_graph *irg)
 725 {
 726   ir_graph *rem;
 727   rem = current_ir_graph;
 728   current_ir_graph = irg;
 729
 730   vcg_open (irg, "");
 731
 732   /* walk over the graph */
 733   irg_walk(irg->end, dump_whole_node, NULL, NULL);
 734
 735   vcg_close();
 736
 737   current_ir_graph = rem;
 738 }
 739
 740 /***********************************************************************/
 741 /* the following routines dump the nodes as attached to the blocks.    */
 742 /***********************************************************************/
 743
 744 void
 745 dump_ir_blocks_nodes (ir_node *n, void *env) {
 746   ir_node *block = (ir_node *)env;
 747
 748   if (is_no_Block(n) && get_nodes_Block(n) == block) {
 749     dump_node(n);
 750     dump_ir_data_edges(n);
 751   }
 752   if (get_irn_op(n) == op_Bad)
 753     Bad_dumped = 1;
 754 }
 755
 756 void
 757 dump_ir_block (ir_node *block, void *env) {
 758   ir_graph *irg = (ir_graph *)env;
 759
 760   if (get_irn_opcode(block) == iro_Block) {
 761
 762     /* This is a block. So dump the vcg information to make a block. */
 763     xfprintf(F, "graph: { title: \""); PRINT_NODEID(block); fprintf(F, "\"  label: \"");
 764 #ifdef DEBUG_libfirm
 765     xfprintf (F, "%ld", get_irn_node_nr(block));
 766 #else
 767     xfprintf (F, "%I", block->op->name);
 768 #endif
 769     xfprintf(F, "\" status:clustered color:lightyellow \n");
 770     /* dump the blocks edges */
 771     dump_ir_data_edges(block);
 772
 773     /* dump the nodes that go into the block */
 774     irg_walk(irg->end, dump_ir_blocks_nodes, NULL, block);
 775
 776     /* Close the vcg information for the block */
 777     xfprintf(F, "}\n\n");
 778   }
 779 }
 780
 781
 782 void
 783 dump_blockless_nodes (ir_node *n, void *env) {
 784   if (is_no_Block(n) && get_irn_op(get_nodes_Block(n)) == op_Bad) {
 785     dump_node(n);
 786     dump_ir_data_edges(n);
 787     dump_ir_block_edge(n);
 788   }
 789   if (get_irn_op(n) == op_Bad)
 790     Bad_dumped = 1;
 791 }
 792
 793 void
 794 dump_ir_block_graph (ir_graph *irg)
 795 {
 796   ir_graph *rem;
 797   rem = current_ir_graph;
 798   current_ir_graph = irg;
 799
 800   vcg_open (irg, "");
 801
 802   Bad_dumped = 0;
 803   /* walk over the blocks in the graph */
 804   irg_block_walk(irg->end, dump_ir_block, NULL, irg);
 805
 806   /* dump all nodes that are not in a Block */
 807   irg_walk(irg->end, dump_blockless_nodes, NULL, NULL);
 808
 809   /* dump the Bad node */
 810   if (!Bad_dumped)
 811     dump_node(get_irg_bad(irg));
 812   vcg_close();
 813   current_ir_graph = rem;
 814 }
 815
 816
 817 /***********************************************************************/
 818 /* the following routines dump a control flow graph                    */
 819 /***********************************************************************/
 820
 821
 822 void
 823 dump_block_to_cfg (ir_node *block, void *env) {
 824   int i;
 825   ir_node *pred;
 826
 827   if (get_irn_opcode(block) == iro_Block) {
 828     /* This is a block. Dump a node for the block. */
 829     xfprintf (F, "node: {title: \"%p\" label: \"%I\"}", block,
 830               block->op->name);
 831     /* Dump the edges */
 832     for ( i = 0; i < get_Block_n_cfgpreds(block); i++) {
 833       pred = get_nodes_Block(skip_Proj(get_Block_cfgpred(block, i)));
 834       xfprintf (F, "edge: { sourcename: \"%p\" targetname: \"%p\" }\n",
 835                 block, pred);
 836     }
 837   }
 838 }
 839
 840 void
 841 dump_cfg (ir_graph *irg)
 842 {
 843   vcg_open (irg, "-cfg");
 844
 845   /* walk over the blocks in the graph */
 846   irg_block_walk(irg->end, dump_block_to_cfg, NULL, NULL);
 847
 848   vcg_close();
 849 }
 850
 851
 852 /***********************************************************************/
 853 /* the following routine dumps all type information reachable from an  */
 854 /* irg                                                                 */
 855 /***********************************************************************/
 856
 857
 858 void
 859 dump_type_graph (ir_graph *irg)
 860 {
 861   ir_graph *rem;
 862   rem = current_ir_graph;
 863   current_ir_graph = irg;
 864
 865   vcg_open (irg, "-type");
 866
 867   /* walk over the blocks in the graph */
 868   type_walk_irg(irg, dump_type_info, NULL, NULL);
 869
 870   vcg_close();
 871   current_ir_graph = rem;
 872 }
 873
 874 /***********************************************************************/
 875 /* the following routine dumps all type information                    */
 876 /***********************************************************************/
 877
 878
 879 void
 880 dump_all_types (void)
 881 {
 882   vcg_open_name ("All_types");
 883   type_walk(dump_type_info, NULL, NULL);
 884   vcg_close();
 885 }
 886
 887 /***********************************************************************/
 888 /* dumps a graph with type information                                 */
 889 /***********************************************************************/
 890
 891
 892 void
 893 dump_ir_graph_w_types (ir_graph *irg)
 894 {
 895   ir_graph *rem;
 896   rem = current_ir_graph;
 897   current_ir_graph = irg;
 898
 899   vcg_open (irg, "-all");
 900
 901   /* dump common ir graph */
 902   /*  irg_block_walk(irg->end, dump_ir_block, NULL, irg); */
 903   irg_walk(irg->end, dump_whole_node, NULL, NULL);
 904   /* dump type info */
 905   type_walk_irg(irg, dump_type_info, NULL, NULL);
 906   /* dump edges from graph to type info */
 907   irg_walk(irg->end, dump_node2type_edges, NULL, NULL);
 908
 909   vcg_close();
 910   current_ir_graph = rem;
 911 }
 912
 913 /***********************************************************************/
 914 /* dumps all graphs with the graph-dumper passed. Possible dumpers:    */
 915 /*  dump_ir_graph                                                      */
 916 /*  dump_ir_block_graph                                                */
 917 /*  dump_cfg                                                           */
 918 /*  dump_type_graph                                                    */
 919 /*  dump_ir_graph_w_types                                              */
 920 /***********************************************************************/
 921 void dump_all_ir_graphs (void dump_graph(ir_graph*)) {
 922   int i;
 923   for (i=0; i < get_irp_n_irgs(); i++) {
 924     dump_graph(get_irp_irg(i));
 925   }
 926 }
 927
 928
 929 /* To turn off display of edge labels.  Edge labels offen cause xvcg to
 930    abort with a segmentation fault. */
 931 void turn_of_edge_labels() {
 932   edge_label = 0;
 933 }