gcc/cp/dump.c

   1 /* Tree-dumping functionality for intermediate representation.
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3    Written by Mark Mitchell <mark@codesourcery.com>
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "cp-tree.h"
  26 #include "splay-tree.h"
  27
  28 /* Flags used with queue functions.  */
  29 #define DUMP_NONE     0
  30 #define DUMP_CHILDREN 1
  31 #define DUMP_BINFO    2
  32
  33 /* Information about a node to be dumped.  */
  34
  35 typedef struct dump_node_info
  36 {
  37   /* The index for the node.  */
  38   unsigned int index;
  39   /* Nonzero if we should dump the children of the node.  */
  40   unsigned int dump_children_p : 1;
  41   /* Nonzero if the node is a binfo.  */
  42   unsigned int binfo_p : 1;
  43 } *dump_node_info_p;
  44
  45 /* A dump_queue is a link in the queue of things to be dumped.  */
  46
  47 typedef struct dump_queue
  48 {
  49   /* The queued tree node.  */
  50   splay_tree_node node;
  51   /* The next node in the queue.  */
  52   struct dump_queue *next;
  53 } *dump_queue_p;
  54
  55 /* A dump_info gives information about how we should perform the dump
  56    and about the current state of the dump.  */
  57
  58 typedef struct dump_info
  59 {
  60   /* The stream on which to dump the information.  */
  61   FILE *stream;
  62   /* The next unused node index.  */
  63   unsigned int index;
  64   /* The next column.  */
  65   unsigned int column;
  66   /* The first node in the queue of nodes to be written out.  */
  67   dump_queue_p queue;
  68   /* The last node in the queue.  */
  69   dump_queue_p queue_end;
  70   /* Free queue nodes.  */
  71   dump_queue_p free_list;
  72   /* The tree nodes which we have already written out.  The
  73      keys are the addresses of the nodes; the values are the integer
  74      indices we assigned them.  */
  75   splay_tree nodes;
  76 } *dump_info_p;
  77
  78 static unsigned int queue PROTO ((dump_info_p, tree, int));
  79 static void dump_index PROTO ((dump_info_p, unsigned int));
  80 static void queue_and_dump_index PROTO ((dump_info_p, const char *, tree, int));
  81 static void queue_and_dump_type PROTO ((dump_info_p, tree, int));
  82 static void dequeue_and_dump PROTO ((dump_info_p));
  83 static void dump_new_line PROTO ((dump_info_p));
  84 static void dump_maybe_newline PROTO ((dump_info_p));
  85 static void dump_int PROTO ((dump_info_p, const char *, int));
  86 static void dump_string PROTO ((dump_info_p, const char *));
  87 static void dump_string_field PROTO ((dump_info_p, const char *, const char *));
  88 static void dump_node PROTO ((tree, FILE *));
  89 static void dump_stmt PROTO ((dump_info_p, tree));
  90 static void dump_next_stmt PROTO ((dump_info_p, tree));
  91
  92 /* Add T to the end of the queue of nodes to dump.  If DUMP_CHILDREN_P
  93    is non-zero, then its children should be dumped as well.  Returns
  94    the index assigned to T.  */
  95
  96 static unsigned int
  97 queue (di, t, flags)
  98      dump_info_p di;
  99      tree t;
 100      int flags;
 101 {
 102   dump_queue_p dq;
 103   dump_node_info_p dni;
 104   unsigned int index;
 105
 106   /* Assign the next available index to T.  */
 107   index = ++di->index;
 108
 109   /* Obtain a new queue node.  */
 110   if (di->free_list)
 111     {
 112       dq = di->free_list;
 113       di->free_list = dq->next;
 114     }
 115   else
 116     dq = (dump_queue_p) xmalloc (sizeof (struct dump_queue));
 117
 118   /* Create a new entry in the splay-tree.  */
 119   dni = (dump_node_info_p) xmalloc (sizeof (struct dump_node_info));
 120   dni->index = index;
 121   dni->dump_children_p = ((flags & DUMP_CHILDREN) != 0);
 122   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
 123   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
 124                                 (splay_tree_value) dni);
 125
 126   /* Add it to the end of the queue.  */
 127   dq->next = 0;
 128   if (!di->queue_end)
 129     di->queue = dq;
 130   else
 131     di->queue_end->next = dq;
 132   di->queue_end = dq;
 133
 134   /* Return the index.  */
 135   return index;
 136 }
 137
 138 static void
 139 dump_index (di, index)
 140      dump_info_p di;
 141      unsigned int index;
 142 {
 143   fprintf (di->stream, "@%-6u ", index);
 144   di->column += 8;
 145 }
 146
 147 /* If T has not already been output, queue it for subsequent output.
 148    FIELD is a string to print before printing the index.  Then, the
 149    index of T is printed.  */
 150
 151 static void
 152 queue_and_dump_index (di, field, t, flags)
 153      dump_info_p di;
 154      const char *field;
 155      tree t;
 156      int flags;
 157 {
 158   unsigned int index;
 159   splay_tree_node n;
 160
 161   /* If there's no node, just return.  This makes for fewer checks in
 162      our callers.  */
 163   if (!t)
 164     return;
 165
 166   /* See if we've already queued or dumped this node.  */
 167   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
 168   if (n)
 169     index = ((dump_node_info_p) n->value)->index;
 170   else
 171     /* If we haven't, add it to the queue.  */
 172     index = queue (di, t, flags);
 173
 174   /* Print the index of the node.  */
 175   dump_maybe_newline (di);
 176   fprintf (di->stream, "%-4s: ", field);
 177   di->column += 6;
 178   dump_index (di, index);
 179 }
 180
 181 /* Dump the type of T.  */
 182
 183 static void
 184 queue_and_dump_type (di, t, dump_children_p)
 185      dump_info_p di;
 186      tree t;
 187      int dump_children_p;
 188 {
 189   queue_and_dump_index (di, "type", TREE_TYPE (t), dump_children_p);
 190 }
 191
 192 /* Insert a new line in the dump output, and indent to an appropriate
 193    place to start printing more fields.  */
 194
 195 static void
 196 dump_new_line (di)
 197      dump_info_p di;
 198 {
 199   fprintf (di->stream, "\n%25s", "");
 200   di->column = 25;
 201 }
 202
 203 /* If necessary, insert a new line.  */
 204
 205 static void
 206 dump_maybe_newline (di)
 207      dump_info_p di;
 208 {
 209   /* See if we need a new line.  */
 210   if (di->column > 53)
 211     dump_new_line (di);
 212   /* See if we need any padding.  */
 213   else if ((di->column - 25) % 14 != 0)
 214     {
 215       fprintf (di->stream, "%*s", 14 - ((di->column - 25) % 14), "");
 216       di->column += 14 - (di->column - 25) % 14;
 217     }
 218 }
 219
 220 /* Dump I using FIELD to identity it.  */
 221
 222 static void
 223 dump_int (di, field, i)
 224      dump_info_p di;
 225      const char *field;
 226      int i;
 227 {
 228   dump_maybe_newline (di);
 229   fprintf (di->stream, "%-4s: %-7d ", field, i);
 230   di->column += 14;
 231 }
 232
 233 /* Dump the string S.  */
 234
 235 static void
 236 dump_string (di, string)
 237      dump_info_p di;
 238      const char *string;
 239 {
 240   dump_maybe_newline (di);
 241   fprintf (di->stream, "%-13s ", string);
 242   if (strlen (string) > 13)
 243     di->column += strlen (string) + 1;
 244   else
 245     di->column += 14;
 246 }
 247
 248 /* Dump the string field S.  */
 249
 250 static void
 251 dump_string_field (di, field, string)
 252      dump_info_p di;
 253      const char *field;
 254      const char *string;
 255 {
 256   dump_maybe_newline (di);
 257   fprintf (di->stream, "%-4s: %-7s ", field, string);
 258   if (strlen (string) > 7)
 259     di->column += 6 + strlen (string) + 1;
 260   else
 261     di->column += 14;
 262 }
 263
 264 /* Dump information common to statements from STMT.  */
 265
 266 static void
 267 dump_stmt (di, t)
 268      dump_info_p di;
 269      tree t;
 270 {
 271   dump_int (di, "line", STMT_LINENO (t));
 272 }
 273
 274 /* Dump the CHILD and its children.  */
 275 #define dump_child(field, child) \
 276   queue_and_dump_index (di, field, child, DUMP_CHILDREN)
 277
 278 /* Dump the next statement after STMT.  */
 279
 280 static void
 281 dump_next_stmt (di, t)
 282      dump_info_p di;
 283      tree t;
 284 {
 285   dump_child ("next", TREE_CHAIN (t));
 286 }
 287
 288 /* Dump the next node in the queue.  */
 289
 290 static void
 291 dequeue_and_dump (di)
 292      dump_info_p di;
 293 {
 294   dump_queue_p dq;
 295   splay_tree_node stn;
 296   dump_node_info_p dni;
 297   tree t;
 298   unsigned int index;
 299   int dump_children_p;
 300   enum tree_code code;
 301   char code_class;
 302   const char* code_name;
 303
 304   /* Get the next node from the queue.  */
 305   dq = di->queue;
 306   stn = dq->node;
 307   t = (tree) stn->key;
 308   dni = (dump_node_info_p) stn->value;
 309   index = dni->index;
 310   dump_children_p = dni->dump_children_p;
 311
 312   /* Remove the node from the queue, and put it on the free list.  */
 313   di->queue = dq->next;
 314   if (!di->queue)
 315     di->queue_end = 0;
 316   dq->next = di->free_list;
 317   di->free_list = dq;
 318
 319   /* Print the node index.  */
 320   dump_index (di, index);
 321   /* And the type of node this is.  */
 322   if (dni->binfo_p)
 323     code_name = "binfo";
 324   else
 325     code_name = tree_code_name[(int) TREE_CODE (t)];
 326   fprintf (di->stream, "%-16s ", code_name);
 327   di->column = 25;
 328
 329   /* Figure out what kind of node this is.  */
 330   code = TREE_CODE (t);
 331   code_class = TREE_CODE_CLASS (code);
 332
 333   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
 334      more informative.  */
 335   if (dni->binfo_p)
 336     {
 337       if (TREE_VIA_PUBLIC (t))
 338         dump_string (di, "pub");
 339       else if (TREE_VIA_PROTECTED (t))
 340         dump_string (di, "prot");
 341       else if (TREE_VIA_PRIVATE (t))
 342         dump_string (di, "priv");
 343       if (TREE_VIA_VIRTUAL (t))
 344         dump_string (di, "virt");
 345
 346       if (dump_children_p)
 347         {
 348           dump_child ("type", BINFO_TYPE (t));
 349           dump_child ("base", BINFO_BASETYPES (t));
 350         }
 351
 352       goto done;
 353     }
 354
 355   /* We can knock off a bunch of expression nodes in exactly the same
 356      way.  */
 357   if (IS_EXPR_CODE_CLASS (code_class))
 358     {
 359       /* If we're dumping children, dump them now.  */
 360       if (dump_children_p)
 361         {
 362           queue_and_dump_type (di, t, 1);
 363
 364           switch (code_class)
 365             {
 366             case '1':
 367               dump_child ("op 0", TREE_OPERAND (t, 0));
 368               break;
 369
 370             case '2':
 371             case '<':
 372               dump_child ("op 0", TREE_OPERAND (t, 0));
 373               dump_child ("op 1", TREE_OPERAND (t, 1));
 374               break;
 375
 376             case 'e':
 377               /* These nodes are handled explicitly below.  */
 378               break;
 379
 380             default:
 381               my_friendly_abort (19990726);
 382             }
 383         }
 384     }
 385   else if (code_class == 'd')
 386     {
 387       /* All declarations have names.  */
 388       if (DECL_NAME (t))
 389         dump_child ("name", DECL_NAME (t));
 390       /* And types.  */
 391       if (dump_children_p)
 392         {
 393           queue_and_dump_type (di, t, 1);
 394           queue_and_dump_index (di, "scpe", DECL_CONTEXT (t), 0);
 395         }
 396       /* And a source position.  */
 397       if (DECL_SOURCE_FILE (t))
 398         {
 399           const char *filename = rindex (DECL_SOURCE_FILE (t), '/');
 400           if (!filename)
 401             filename = DECL_SOURCE_FILE (t);
 402           else
 403             /* Skip the slash.  */
 404             ++filename;
 405
 406           dump_maybe_newline (di);
 407           fprintf (di->stream, "srcp: %s:%-6d ", filename,
 408                    DECL_SOURCE_LINE (t));
 409           di->column += 6 + strlen (filename) + 8;
 410         }
 411       /* And any declaration can be compiler-generated.  */
 412       if (DECL_ARTIFICIAL (t))
 413         dump_string (di, "artificial");
 414       if (TREE_CHAIN (t))
 415         dump_child ("chan", TREE_CHAIN (t));
 416     }
 417   else if (code_class == 't')
 418     {
 419       /* All types have qualifiers.  */
 420       int quals = CP_TYPE_QUALS (t);
 421       if (quals != TYPE_UNQUALIFIED)
 422         {
 423           fprintf (di->stream, "qual: %c%c%c     ",
 424                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
 425                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
 426                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
 427           di->column += 14;
 428         }
 429
 430       /* All types have associated declarations.  */
 431       dump_child ("name", TYPE_NAME (t));
 432
 433       if (dump_children_p)
 434         {
 435           /* All types have a main variant.  */
 436           if (TYPE_MAIN_VARIANT (t) != t)
 437             dump_child ("unql", TYPE_MAIN_VARIANT (t));
 438
 439           /* And sizes.  */
 440           dump_child ("size", TYPE_SIZE (t));
 441         }
 442
 443       /* All types have alignments.  */
 444       dump_int (di, "algn", TYPE_ALIGN (t));
 445     }
 446
 447   /* Now handle the various kinds of nodes.  */
 448   switch (code)
 449     {
 450       int i;
 451
 452     case IDENTIFIER_NODE:
 453       if (IDENTIFIER_OPNAME_P (t))
 454         dump_string (di, "operator");
 455       else if (IDENTIFIER_TYPENAME_P (t))
 456         queue_and_dump_index (di, "tynm", TREE_TYPE (t), 0);
 457       else if (t == anonymous_namespace_name)
 458         dump_string (di, "unnamed");
 459       else
 460         {
 461           dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
 462           dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 463         }
 464       break;
 465
 466     case TREE_LIST:
 467       if (dump_children_p)
 468         {
 469           dump_child ("purp", TREE_PURPOSE (t));
 470           dump_child ("valu", TREE_VALUE (t));
 471           dump_child ("chan", TREE_CHAIN (t));
 472         }
 473       break;
 474
 475     case TREE_VEC:
 476       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 477       if (dump_children_p)
 478         for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 479           {
 480             char buffer[32];
 481             sprintf (buffer, "%u", i);
 482             queue_and_dump_index (di, buffer, TREE_VEC_ELT (t, i), 1);
 483           }
 484       break;
 485
 486     case INTEGER_TYPE:
 487     case ENUMERAL_TYPE:
 488       dump_int (di, "prec", TYPE_PRECISION (t));
 489       if (TREE_UNSIGNED (t))
 490         dump_string (di, "unsigned");
 491       if (dump_children_p)
 492         {
 493           dump_child ("min", TYPE_MIN_VALUE (t));
 494           dump_child ("max", TYPE_MAX_VALUE (t));
 495         }
 496
 497       if (code == ENUMERAL_TYPE && dump_children_p)
 498         dump_child ("csts", TYPE_VALUES (t));
 499       break;
 500
 501     case REAL_TYPE:
 502       dump_int (di, "prec", TYPE_PRECISION (t));
 503       break;
 504
 505     case POINTER_TYPE:
 506       if (dump_children_p)
 507         {
 508           if (TYPE_PTRMEM_P (t))
 509             {
 510               dump_string (di, "ptrmem");
 511               queue_and_dump_index (di, "ptd",
 512                                     TYPE_PTRMEM_POINTED_TO_TYPE (t), 1);
 513               queue_and_dump_index (di, "cls",
 514                                     TYPE_PTRMEM_CLASS_TYPE (t), 1);
 515             }
 516           else
 517             dump_child ("ptd", TREE_TYPE (t));
 518         }
 519       break;
 520
 521     case REFERENCE_TYPE:
 522       if (dump_children_p)
 523         dump_child ("refd", TREE_TYPE (t));
 524       break;
 525
 526     case METHOD_TYPE:
 527       if (dump_children_p)
 528         dump_child ("clas", TYPE_METHOD_BASETYPE (t));
 529       /* Fall through.  */
 530
 531     case FUNCTION_TYPE:
 532       if (dump_children_p)
 533         {
 534           dump_child ("retn", TREE_TYPE (t));
 535           dump_child ("prms", TYPE_ARG_TYPES (t));
 536         }
 537       break;
 538
 539     case ARRAY_TYPE:
 540       if (dump_children_p)
 541         {
 542           dump_child ("elts", TREE_TYPE (t));
 543           dump_child ("domn", TYPE_DOMAIN (t));
 544         }
 545       break;
 546
 547     case RECORD_TYPE:
 548     case UNION_TYPE:
 549       if (TYPE_PTRMEMFUNC_P (t))
 550         {
 551           dump_string (di, "ptrmem");
 552           queue_and_dump_index (di, "ptd",
 553                                 TYPE_PTRMEM_POINTED_TO_TYPE (t), 1);
 554           queue_and_dump_index (di, "cls",
 555                                 TYPE_PTRMEM_CLASS_TYPE (t), 1);
 556         }
 557       else
 558         {
 559           if (CLASSTYPE_DECLARED_CLASS (t))
 560             dump_string (di, "class");
 561           else if (TREE_CODE (t) == RECORD_TYPE)
 562             dump_string (di, "struct");
 563           else
 564             dump_string (di, "union");
 565
 566           if (dump_children_p)
 567             {
 568               dump_child ("flds", TYPE_FIELDS (t));
 569               dump_child ("fncs", TYPE_METHODS (t));
 570               queue_and_dump_index (di, "binf", TYPE_BINFO (t),
 571                                     DUMP_CHILDREN | DUMP_BINFO);
 572             }
 573         }
 574       break;
 575
 576     case CONST_DECL:
 577       if (dump_children_p)
 578         dump_child ("cnst", DECL_INITIAL (t));
 579       break;
 580
 581     case VAR_DECL:
 582     case PARM_DECL:
 583     case FIELD_DECL:
 584       if (dump_children_p)
 585         {
 586           dump_child ("init", DECL_INITIAL (t));
 587           dump_child ("size", DECL_SIZE (t));
 588         }
 589       dump_int (di, "algn", DECL_ALIGN (t));
 590
 591       if (TREE_CODE (t) == FIELD_DECL && dump_children_p)
 592         dump_child ("bpos", DECL_FIELD_BITPOS (t));
 593       break;
 594
 595     case FUNCTION_DECL:
 596       if (dump_children_p)
 597         {
 598           queue_and_dump_index (di, "scpe", DECL_REAL_CONTEXT (t), 0);
 599           dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
 600           dump_child ("args", DECL_ARGUMENTS (t));
 601         }
 602       if (TREE_PUBLIC (t))
 603         dump_string(di, "extern");
 604       else
 605         dump_string (di, "static");
 606       if (DECL_FUNCTION_MEMBER_P (t))
 607         dump_string (di, "member");
 608       if (DECL_CONSTRUCTOR_P (t))
 609         dump_string (di, "constructor");
 610       if (DECL_DESTRUCTOR_P (t))
 611         dump_string (di, "destructor");
 612       if (DECL_OVERLOADED_OPERATOR_P (t))
 613         dump_string (di, "operator");
 614       if (DECL_CONV_FN_P (t))
 615         dump_string (di, "conversion");
 616       if (dump_children_p)
 617         dump_child ("body", DECL_SAVED_TREE (t));
 618       break;
 619
 620     case NAMESPACE_DECL:
 621       /* The fake `::std' namespace does not have DECL_LANG_SPECIFIC,
 622          and therefore many other macros do not work on it.  */
 623       if (t == std_node)
 624         break;
 625       if (dump_children_p)
 626         dump_child ("dcls", cp_namespace_decls (t));
 627       break;
 628
 629     case TEMPLATE_DECL:
 630       if (dump_children_p)
 631         dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
 632       break;
 633
 634     case OVERLOAD:
 635       if (dump_children_p)
 636         {
 637           dump_child ("crnt", OVL_CURRENT (t));
 638           dump_child ("chan", OVL_CHAIN (t));
 639         }
 640       break;
 641
 642     case ASM_STMT:
 643       dump_stmt (di, t);
 644       if (ASM_VOLATILE_P (t))
 645         dump_string (di, "volatile");
 646       if (dump_children_p)
 647         {
 648           dump_child ("strg", ASM_STRING (t));
 649           dump_child ("outs", ASM_OUTPUTS (t));
 650           dump_child ("ins", ASM_INPUTS (t));
 651           dump_child ("clbr", ASM_CLOBBERS (t));
 652         }
 653       dump_next_stmt (di, t);
 654       break;
 655
 656     case BREAK_STMT:
 657     case CONTINUE_STMT:
 658       dump_stmt (di, t);
 659       dump_next_stmt (di, t);
 660       break;
 661
 662     case CASE_LABEL:
 663       /* Note that a case label is not like other statments; there is
 664          no way to get the line-number of a case label.  */
 665       if (dump_children_p)
 666         {
 667           dump_child ("low", CASE_LOW (t));
 668           dump_child ("high", CASE_HIGH (t));
 669         }
 670       dump_next_stmt (di, t);
 671       break;
 672
 673     case COMPOUND_STMT:
 674       dump_stmt (di, t);
 675       if (dump_children_p)
 676         dump_child ("body", COMPOUND_BODY (t));
 677       dump_next_stmt (di, t);
 678       break;
 679
 680     case DECL_STMT:
 681       dump_stmt (di, t);
 682       if (dump_children_p)
 683         dump_child ("decl", DECL_STMT_DECL (t));
 684       dump_next_stmt (di, t);
 685       break;
 686
 687     case DO_STMT:
 688       dump_stmt (di, t);
 689       if (dump_children_p)
 690         {
 691           dump_child ("body", DO_BODY (t));
 692           dump_child ("cond", DO_COND (t));
 693         }
 694       dump_next_stmt (di, t);
 695       break;
 696
 697     case EXPR_STMT:
 698       dump_stmt (di, t);
 699       if (dump_children_p)
 700         dump_child ("expr", EXPR_STMT_EXPR (t));
 701       dump_next_stmt (di, t);
 702       break;
 703
 704     case FOR_STMT:
 705       dump_stmt (di, t);
 706       if (dump_children_p)
 707         {
 708           dump_child ("init", FOR_INIT_STMT (t));
 709           dump_child ("cond", FOR_COND (t));
 710           dump_child ("expr", FOR_EXPR (t));
 711           dump_child ("body", FOR_BODY (t));
 712         }
 713       dump_next_stmt (di, t);
 714       break;
 715
 716     case GOTO_STMT:
 717       dump_stmt (di, t);
 718       if (dump_children_p)
 719         dump_child ("dest", GOTO_DESTINATION (t));
 720       dump_next_stmt (di, t);
 721       break;
 722
 723     case IF_STMT:
 724       dump_stmt (di, t);
 725       if (dump_children_p)
 726         {
 727           dump_child ("cond", IF_COND (t));
 728           dump_child ("then", THEN_CLAUSE (t));
 729           dump_child ("else", ELSE_CLAUSE (t));
 730         }
 731       dump_next_stmt (di, t);
 732       break;
 733
 734     case RETURN_STMT:
 735       dump_stmt (di, t);
 736       if (dump_children_p)
 737         dump_child ("expr", RETURN_EXPR (t));
 738       dump_next_stmt (di, t);
 739       break;
 740
 741     case SWITCH_STMT:
 742       dump_stmt (di, t);
 743       if (dump_children_p)
 744         {
 745           dump_child ("cond", SWITCH_COND (t));
 746           dump_child ("body", SWITCH_BODY (t));
 747         }
 748       dump_next_stmt (di, t);
 749       break;
 750
 751     case TRY_BLOCK:
 752       dump_stmt (di, t);
 753       if (dump_children_p)
 754         {
 755           dump_child ("body", TRY_STMTS (t));
 756           dump_child ("hdlr", TRY_HANDLERS (t));
 757         }
 758       dump_next_stmt (di, t);
 759       break;
 760
 761     case WHILE_STMT:
 762       dump_stmt (di, t);
 763       if (dump_children_p)
 764         {
 765           dump_child ("cond", WHILE_COND (t));
 766           dump_child ("body", WHILE_BODY (t));
 767         }
 768       dump_next_stmt (di, t);
 769       break;
 770
 771     case INTEGER_CST:
 772       if (TREE_INT_CST_HIGH (t))
 773         dump_int (di, "high", TREE_INT_CST_HIGH (t));
 774       dump_int (di, "low", TREE_INT_CST_LOW (t));
 775       break;
 776
 777     case STRING_CST:
 778       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
 779       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
 780       break;
 781
 782     case PTRMEM_CST:
 783       if (dump_children_p)
 784         {
 785           dump_child ("clas", PTRMEM_CST_CLASS (t));
 786           dump_child ("mbr", PTRMEM_CST_MEMBER (t));
 787         }
 788       break;
 789
 790     case TRUTH_NOT_EXPR:
 791     case ADDR_EXPR:
 792     case INDIRECT_REF:
 793     case THROW_EXPR:
 794       /* These nodes are unary, but do not have code class `1'.  */
 795       if (dump_children_p)
 796         dump_child ("op 0", TREE_OPERAND (t, 0));
 797       break;
 798
 799     case TRUTH_ANDIF_EXPR:
 800     case TRUTH_ORIF_EXPR:
 801     case MODIFY_EXPR:
 802     case COMPONENT_REF:
 803     case COMPOUND_EXPR:
 804     case COND_EXPR:
 805       /* These nodes are binary, but do not have code class `2'.  */
 806       if (dump_children_p)
 807         {
 808           dump_child ("op 0", TREE_OPERAND (t, 0));
 809           dump_child ("op 1", TREE_OPERAND (t, 1));
 810         }
 811       break;
 812
 813     case CALL_EXPR:
 814       if (dump_children_p)
 815         {
 816           dump_child ("fn", TREE_OPERAND (t, 0));
 817           dump_child ("args", TREE_OPERAND (t, 1));
 818         }
 819       break;
 820
 821     case CONSTRUCTOR:
 822       if (dump_children_p)
 823         dump_child ("elts", TREE_OPERAND (t, 1));
 824       break;
 825
 826     case STMT_EXPR:
 827       if (dump_children_p)
 828         dump_child ("stmt", STMT_EXPR_STMT (t));
 829       break;
 830
 831     case TARGET_EXPR:
 832       if (dump_children_p)
 833         {
 834           dump_child ("decl", TREE_OPERAND (t, 0));
 835           dump_child ("init", TREE_OPERAND (t, 1));
 836           dump_child ("clnp", TREE_OPERAND (t, 2));
 837           /* There really are two possible places the initializer can
 838              be.  After RTL expansion, the second operand is moved to
 839              the position of the fourth operand, and the second
 840              operand becomes NULL.  */
 841           dump_child ("init", TREE_OPERAND (t, 3));
 842         }
 843       break;
 844
 845     default:
 846       /* There are no additional fields to print.  */
 847       break;
 848     }
 849
 850  done:
 851   /* Terminate the line.  */
 852   fprintf (di->stream, "\n");
 853 }
 854
 855 /* Dump T, and all its children, on STREAM.  */
 856
 857 static void
 858 dump_node (t, stream)
 859      tree t;
 860      FILE *stream;
 861 {
 862   struct dump_info di;
 863   dump_queue_p dq;
 864   dump_queue_p next_dq;
 865
 866   /* Initialize the dump-information structure.  */
 867   di.stream = stream;
 868   di.index = 0;
 869   di.column = 0;
 870   di.queue = 0;
 871   di.queue_end = 0;
 872   di.free_list = 0;
 873   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
 874                              (splay_tree_delete_value_fn) &free);
 875
 876   /* Queue up the first node.  */
 877   queue (&di, t, DUMP_CHILDREN);
 878
 879   /* Until the queue is empty, keep dumping nodes.  */
 880   while (di.queue)
 881     dequeue_and_dump (&di);
 882
 883   /* Now, clean up.  */
 884   for (dq = di.free_list; dq; dq = next_dq)
 885     {
 886       next_dq = dq->next;
 887       free (dq);
 888     }
 889   splay_tree_delete (di.nodes);
 890 }
 891
 892 /* Dump T, and all its children, to FILE.  */
 893
 894 void
 895 dump_node_to_file (t, file)
 896      tree t;
 897      const char *file;
 898 {
 899   FILE *f;
 900
 901   f = fopen (file, "w");
 902   if (!f)
 903     cp_error ("could not open `%s'", file);
 904   else
 905     {
 906       dump_node (t, f);
 907       fclose (f);
 908     }
 909 }