gcc/tree-dump.c

   1 /* Tree-dumping functionality for intermediate representation.
   2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
   3    Written by Mark Mitchell <mark@codesourcery.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "tree-pretty-print.h"
  27 #include "alias.h"
  28 #include "splay-tree.h"
  29 #include "tree-dump.h"
  30 #include "langhooks.h"
  31 #include "tree-iterator.h"
  32 #include "tree-cfg.h"
  33
  34 static unsigned int queue (dump_info_p, const_tree, int);
  35 static void dump_index (dump_info_p, unsigned int);
  36 static void dequeue_and_dump (dump_info_p);
  37 static void dump_new_line (dump_info_p);
  38 static void dump_maybe_newline (dump_info_p);
  39
  40 /* Add T to the end of the queue of nodes to dump.  Returns the index
  41    assigned to T.  */
  42
  43 static unsigned int
  44 queue (dump_info_p di, const_tree t, int flags)
  45 {
  46   dump_queue_p dq;
  47   dump_node_info_p dni;
  48   unsigned int index;
  49
  50   /* Assign the next available index to T.  */
  51   index = ++di->index;
  52
  53   /* Obtain a new queue node.  */
  54   if (di->free_list)
  55     {
  56       dq = di->free_list;
  57       di->free_list = dq->next;
  58     }
  59   else
  60     dq = XNEW (struct dump_queue);
  61
  62   /* Create a new entry in the splay-tree.  */
  63   dni = XNEW (struct dump_node_info);
  64   dni->index = index;
  65   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
  66   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
  67                                 (splay_tree_value) dni);
  68
  69   /* Add it to the end of the queue.  */
  70   dq->next = 0;
  71   if (!di->queue_end)
  72     di->queue = dq;
  73   else
  74     di->queue_end->next = dq;
  75   di->queue_end = dq;
  76
  77   /* Return the index.  */
  78   return index;
  79 }
  80
  81 static void
  82 dump_index (dump_info_p di, unsigned int index)
  83 {
  84   fprintf (di->stream, "@%-6u ", index);
  85   di->column += 8;
  86 }
  87
  88 /* If T has not already been output, queue it for subsequent output.
  89    FIELD is a string to print before printing the index.  Then, the
  90    index of T is printed.  */
  91
  92 void
  93 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
  94 {
  95   unsigned int index;
  96   splay_tree_node n;
  97
  98   /* If there's no node, just return.  This makes for fewer checks in
  99      our callers.  */
 100   if (!t)
 101     return;
 102
 103   /* See if we've already queued or dumped this node.  */
 104   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
 105   if (n)
 106     index = ((dump_node_info_p) n->value)->index;
 107   else
 108     /* If we haven't, add it to the queue.  */
 109     index = queue (di, t, flags);
 110
 111   /* Print the index of the node.  */
 112   dump_maybe_newline (di);
 113   fprintf (di->stream, "%-4s: ", field);
 114   di->column += 6;
 115   dump_index (di, index);
 116 }
 117
 118 /* Dump the type of T.  */
 119
 120 void
 121 queue_and_dump_type (dump_info_p di, const_tree t)
 122 {
 123   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
 124 }
 125
 126 /* Dump column control */
 127 #define SOL_COLUMN 25           /* Start of line column.  */
 128 #define EOL_COLUMN 55           /* End of line column.  */
 129 #define COLUMN_ALIGNMENT 15     /* Alignment.  */
 130
 131 /* Insert a new line in the dump output, and indent to an appropriate
 132    place to start printing more fields.  */
 133
 134 static void
 135 dump_new_line (dump_info_p di)
 136 {
 137   fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
 138   di->column = SOL_COLUMN;
 139 }
 140
 141 /* If necessary, insert a new line.  */
 142
 143 static void
 144 dump_maybe_newline (dump_info_p di)
 145 {
 146   int extra;
 147
 148   /* See if we need a new line.  */
 149   if (di->column > EOL_COLUMN)
 150     dump_new_line (di);
 151   /* See if we need any padding.  */
 152   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
 153     {
 154       fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
 155       di->column += COLUMN_ALIGNMENT - extra;
 156     }
 157 }
 158
 159 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
 160
 161 void
 162 dump_function (int phase, tree fn)
 163 {
 164   FILE *stream;
 165   int flags;
 166
 167   stream = dump_begin (phase, &flags);
 168   if (stream)
 169     {
 170       dump_function_to_file (fn, stream, flags);
 171       dump_end (phase, stream);
 172     }
 173 }
 174
 175 /* Dump pointer PTR using FIELD to identify it.  */
 176
 177 void
 178 dump_pointer (dump_info_p di, const char *field, void *ptr)
 179 {
 180   dump_maybe_newline (di);
 181   fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field,
 182            (unsigned HOST_WIDE_INT) (uintptr_t) ptr);
 183   di->column += 15;
 184 }
 185
 186 /* Dump integer I using FIELD to identify it.  */
 187
 188 void
 189 dump_int (dump_info_p di, const char *field, int i)
 190 {
 191   dump_maybe_newline (di);
 192   fprintf (di->stream, "%-4s: %-7d ", field, i);
 193   di->column += 14;
 194 }
 195
 196 /* Dump the floating point value R, using FIELD to identify it.  */
 197
 198 static void
 199 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
 200 {
 201   char buf[32];
 202   real_to_decimal (buf, r, sizeof (buf), 0, true);
 203   dump_maybe_newline (di);
 204   fprintf (di->stream, "%-4s: %s ", field, buf);
 205   di->column += strlen (buf) + 7;
 206 }
 207
 208 /* Dump the fixed-point value F, using FIELD to identify it.  */
 209
 210 static void
 211 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
 212 {
 213   char buf[32];
 214   fixed_to_decimal (buf, f, sizeof (buf));
 215   dump_maybe_newline (di);
 216   fprintf (di->stream, "%-4s: %s ", field, buf);
 217   di->column += strlen (buf) + 7;
 218 }
 219
 220
 221 /* Dump the string S.  */
 222
 223 void
 224 dump_string (dump_info_p di, const char *string)
 225 {
 226   dump_maybe_newline (di);
 227   fprintf (di->stream, "%-13s ", string);
 228   if (strlen (string) > 13)
 229     di->column += strlen (string) + 1;
 230   else
 231     di->column += 14;
 232 }
 233
 234 /* Dump the string field S.  */
 235
 236 void
 237 dump_string_field (dump_info_p di, const char *field, const char *string)
 238 {
 239   dump_maybe_newline (di);
 240   fprintf (di->stream, "%-4s: %-7s ", field, string);
 241   if (strlen (string) > 7)
 242     di->column += 6 + strlen (string) + 1;
 243   else
 244     di->column += 14;
 245 }
 246
 247 /* Dump the next node in the queue.  */
 248
 249 static void
 250 dequeue_and_dump (dump_info_p di)
 251 {
 252   dump_queue_p dq;
 253   splay_tree_node stn;
 254   dump_node_info_p dni;
 255   tree t;
 256   unsigned int index;
 257   enum tree_code code;
 258   enum tree_code_class code_class;
 259   const char* code_name;
 260
 261   /* Get the next node from the queue.  */
 262   dq = di->queue;
 263   stn = dq->node;
 264   t = (tree) stn->key;
 265   dni = (dump_node_info_p) stn->value;
 266   index = dni->index;
 267
 268   /* Remove the node from the queue, and put it on the free list.  */
 269   di->queue = dq->next;
 270   if (!di->queue)
 271     di->queue_end = 0;
 272   dq->next = di->free_list;
 273   di->free_list = dq;
 274
 275   /* Print the node index.  */
 276   dump_index (di, index);
 277   /* And the type of node this is.  */
 278   if (dni->binfo_p)
 279     code_name = "binfo";
 280   else
 281     code_name = get_tree_code_name (TREE_CODE (t));
 282   fprintf (di->stream, "%-16s ", code_name);
 283   di->column = 25;
 284
 285   /* Figure out what kind of node this is.  */
 286   code = TREE_CODE (t);
 287   code_class = TREE_CODE_CLASS (code);
 288
 289   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
 290      more informative.  */
 291   if (dni->binfo_p)
 292     {
 293       unsigned ix;
 294       tree base;
 295       vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (t);
 296
 297       dump_child ("type", BINFO_TYPE (t));
 298
 299       if (BINFO_VIRTUAL_P (t))
 300         dump_string_field (di, "spec", "virt");
 301
 302       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
 303       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
 304         {
 305           tree access = (accesses ? (*accesses)[ix] : access_public_node);
 306           const char *string = NULL;
 307
 308           if (access == access_public_node)
 309             string = "pub";
 310           else if (access == access_protected_node)
 311             string = "prot";
 312           else if (access == access_private_node)
 313             string = "priv";
 314           else
 315             gcc_unreachable ();
 316
 317           dump_string_field (di, "accs", string);
 318           queue_and_dump_index (di, "binf", base, DUMP_BINFO);
 319         }
 320
 321       goto done;
 322     }
 323
 324   /* We can knock off a bunch of expression nodes in exactly the same
 325      way.  */
 326   if (IS_EXPR_CODE_CLASS (code_class))
 327     {
 328       /* If we're dumping children, dump them now.  */
 329       queue_and_dump_type (di, t);
 330
 331       switch (code_class)
 332         {
 333         case tcc_unary:
 334           dump_child ("op 0", TREE_OPERAND (t, 0));
 335           break;
 336
 337         case tcc_binary:
 338         case tcc_comparison:
 339           dump_child ("op 0", TREE_OPERAND (t, 0));
 340           dump_child ("op 1", TREE_OPERAND (t, 1));
 341           break;
 342
 343         case tcc_expression:
 344         case tcc_reference:
 345         case tcc_statement:
 346         case tcc_vl_exp:
 347           /* These nodes are handled explicitly below.  */
 348           break;
 349
 350         default:
 351           gcc_unreachable ();
 352         }
 353     }
 354   else if (DECL_P (t))
 355     {
 356       expanded_location xloc;
 357       /* All declarations have names.  */
 358       if (DECL_NAME (t))
 359         dump_child ("name", DECL_NAME (t));
 360       if (DECL_ASSEMBLER_NAME_SET_P (t)
 361           && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
 362         dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
 363       if (DECL_ABSTRACT_ORIGIN (t))
 364         dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
 365       /* And types.  */
 366       queue_and_dump_type (di, t);
 367       dump_child ("scpe", DECL_CONTEXT (t));
 368       /* And a source position.  */
 369       xloc = expand_location (DECL_SOURCE_LOCATION (t));
 370       if (xloc.file)
 371         {
 372           const char *filename = lbasename (xloc.file);
 373
 374           dump_maybe_newline (di);
 375           fprintf (di->stream, "srcp: %s:%-6d ", filename,
 376                    xloc.line);
 377           di->column += 6 + strlen (filename) + 8;
 378         }
 379       /* And any declaration can be compiler-generated.  */
 380       if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
 381           && DECL_ARTIFICIAL (t))
 382         dump_string_field (di, "note", "artificial");
 383       if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
 384         dump_child ("chain", DECL_CHAIN (t));
 385     }
 386   else if (code_class == tcc_type)
 387     {
 388       /* All types have qualifiers.  */
 389       int quals = lang_hooks.tree_dump.type_quals (t);
 390
 391       if (quals != TYPE_UNQUALIFIED)
 392         {
 393           fprintf (di->stream, "qual: %c%c%c     ",
 394                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
 395                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
 396                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
 397           di->column += 14;
 398         }
 399
 400       /* All types have associated declarations.  */
 401       dump_child ("name", TYPE_NAME (t));
 402
 403       /* All types have a main variant.  */
 404       if (TYPE_MAIN_VARIANT (t) != t)
 405         dump_child ("unql", TYPE_MAIN_VARIANT (t));
 406
 407       /* And sizes.  */
 408       dump_child ("size", TYPE_SIZE (t));
 409
 410       /* All types have alignments.  */
 411       dump_int (di, "algn", TYPE_ALIGN (t));
 412     }
 413   else if (code_class == tcc_constant)
 414     /* All constants can have types.  */
 415     queue_and_dump_type (di, t);
 416
 417   /* Give the language-specific code a chance to print something.  If
 418      it's completely taken care of things, don't bother printing
 419      anything more ourselves.  */
 420   if (lang_hooks.tree_dump.dump_tree (di, t))
 421     goto done;
 422
 423   /* Now handle the various kinds of nodes.  */
 424   switch (code)
 425     {
 426       int i;
 427
 428     case IDENTIFIER_NODE:
 429       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
 430       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 431       break;
 432
 433     case TREE_LIST:
 434       dump_child ("purp", TREE_PURPOSE (t));
 435       dump_child ("valu", TREE_VALUE (t));
 436       dump_child ("chan", TREE_CHAIN (t));
 437       break;
 438
 439     case STATEMENT_LIST:
 440       {
 441         tree_stmt_iterator it;
 442         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
 443           {
 444             char buffer[32];
 445             sprintf (buffer, "%u", i);
 446             dump_child (buffer, tsi_stmt (it));
 447           }
 448       }
 449       break;
 450
 451     case TREE_VEC:
 452       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
 453       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 454         {
 455           char buffer[32];
 456           sprintf (buffer, "%u", i);
 457           dump_child (buffer, TREE_VEC_ELT (t, i));
 458         }
 459       break;
 460
 461     case INTEGER_TYPE:
 462     case ENUMERAL_TYPE:
 463       dump_int (di, "prec", TYPE_PRECISION (t));
 464       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 465       dump_child ("min", TYPE_MIN_VALUE (t));
 466       dump_child ("max", TYPE_MAX_VALUE (t));
 467
 468       if (code == ENUMERAL_TYPE)
 469         dump_child ("csts", TYPE_VALUES (t));
 470       break;
 471
 472     case REAL_TYPE:
 473       dump_int (di, "prec", TYPE_PRECISION (t));
 474       break;
 475
 476     case FIXED_POINT_TYPE:
 477       dump_int (di, "prec", TYPE_PRECISION (t));
 478       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 479       dump_string_field (di, "saturating",
 480                          TYPE_SATURATING (t) ? "saturating": "non-saturating");
 481       break;
 482
 483     case POINTER_TYPE:
 484       dump_child ("ptd", TREE_TYPE (t));
 485       break;
 486
 487     case REFERENCE_TYPE:
 488       dump_child ("refd", TREE_TYPE (t));
 489       break;
 490
 491     case METHOD_TYPE:
 492       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
 493       /* Fall through.  */
 494
 495     case FUNCTION_TYPE:
 496       dump_child ("retn", TREE_TYPE (t));
 497       dump_child ("prms", TYPE_ARG_TYPES (t));
 498       break;
 499
 500     case ARRAY_TYPE:
 501       dump_child ("elts", TREE_TYPE (t));
 502       dump_child ("domn", TYPE_DOMAIN (t));
 503       break;
 504
 505     case RECORD_TYPE:
 506     case UNION_TYPE:
 507       if (TREE_CODE (t) == RECORD_TYPE)
 508         dump_string_field (di, "tag", "struct");
 509       else
 510         dump_string_field (di, "tag", "union");
 511
 512       dump_child ("flds", TYPE_FIELDS (t));
 513       dump_child ("fncs", TYPE_METHODS (t));
 514       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
 515                             DUMP_BINFO);
 516       break;
 517
 518     case CONST_DECL:
 519       dump_child ("cnst", DECL_INITIAL (t));
 520       break;
 521
 522     case DEBUG_EXPR_DECL:
 523       dump_int (di, "-uid", DEBUG_TEMP_UID (t));
 524       /* Fall through.  */
 525
 526     case VAR_DECL:
 527     case PARM_DECL:
 528     case FIELD_DECL:
 529     case RESULT_DECL:
 530       if (TREE_CODE (t) == PARM_DECL)
 531         dump_child ("argt", DECL_ARG_TYPE (t));
 532       else
 533         dump_child ("init", DECL_INITIAL (t));
 534       dump_child ("size", DECL_SIZE (t));
 535       dump_int (di, "algn", DECL_ALIGN (t));
 536
 537       if (TREE_CODE (t) == FIELD_DECL)
 538         {
 539           if (DECL_FIELD_OFFSET (t))
 540             dump_child ("bpos", bit_position (t));
 541         }
 542       else if (TREE_CODE (t) == VAR_DECL
 543                || TREE_CODE (t) == PARM_DECL)
 544         {
 545           dump_int (di, "used", TREE_USED (t));
 546           if (DECL_REGISTER (t))
 547             dump_string_field (di, "spec", "register");
 548         }
 549       break;
 550
 551     case FUNCTION_DECL:
 552       dump_child ("args", DECL_ARGUMENTS (t));
 553       if (DECL_EXTERNAL (t))
 554         dump_string_field (di, "body", "undefined");
 555       if (TREE_PUBLIC (t))
 556         dump_string_field (di, "link", "extern");
 557       else
 558         dump_string_field (di, "link", "static");
 559       if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
 560         dump_child ("body", DECL_SAVED_TREE (t));
 561       break;
 562
 563     case INTEGER_CST:
 564       fprintf (di->stream, "int: ");
 565       print_decs (t, di->stream);
 566       break;
 567
 568     case STRING_CST:
 569       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
 570       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
 571       break;
 572
 573     case REAL_CST:
 574       dump_real (di, "valu", TREE_REAL_CST_PTR (t));
 575       break;
 576
 577     case FIXED_CST:
 578       dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
 579       break;
 580
 581     case TRUTH_NOT_EXPR:
 582     case ADDR_EXPR:
 583     case INDIRECT_REF:
 584     case CLEANUP_POINT_EXPR:
 585     case SAVE_EXPR:
 586     case REALPART_EXPR:
 587     case IMAGPART_EXPR:
 588       /* These nodes are unary, but do not have code class `1'.  */
 589       dump_child ("op 0", TREE_OPERAND (t, 0));
 590       break;
 591
 592     case TRUTH_ANDIF_EXPR:
 593     case TRUTH_ORIF_EXPR:
 594     case INIT_EXPR:
 595     case MODIFY_EXPR:
 596     case COMPOUND_EXPR:
 597     case PREDECREMENT_EXPR:
 598     case PREINCREMENT_EXPR:
 599     case POSTDECREMENT_EXPR:
 600     case POSTINCREMENT_EXPR:
 601       /* These nodes are binary, but do not have code class `2'.  */
 602       dump_child ("op 0", TREE_OPERAND (t, 0));
 603       dump_child ("op 1", TREE_OPERAND (t, 1));
 604       break;
 605
 606     case COMPONENT_REF:
 607     case BIT_FIELD_REF:
 608       dump_child ("op 0", TREE_OPERAND (t, 0));
 609       dump_child ("op 1", TREE_OPERAND (t, 1));
 610       dump_child ("op 2", TREE_OPERAND (t, 2));
 611       break;
 612
 613     case ARRAY_REF:
 614     case ARRAY_RANGE_REF:
 615       dump_child ("op 0", TREE_OPERAND (t, 0));
 616       dump_child ("op 1", TREE_OPERAND (t, 1));
 617       dump_child ("op 2", TREE_OPERAND (t, 2));
 618       dump_child ("op 3", TREE_OPERAND (t, 3));
 619       break;
 620
 621     case COND_EXPR:
 622       dump_child ("op 0", TREE_OPERAND (t, 0));
 623       dump_child ("op 1", TREE_OPERAND (t, 1));
 624       dump_child ("op 2", TREE_OPERAND (t, 2));
 625       break;
 626
 627     case TRY_FINALLY_EXPR:
 628       dump_child ("op 0", TREE_OPERAND (t, 0));
 629       dump_child ("op 1", TREE_OPERAND (t, 1));
 630       break;
 631
 632     case CALL_EXPR:
 633       {
 634         int i = 0;
 635         tree arg;
 636         call_expr_arg_iterator iter;
 637         dump_child ("fn", CALL_EXPR_FN (t));
 638         FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
 639           {
 640             char buffer[32];
 641             sprintf (buffer, "%u", i);
 642             dump_child (buffer, arg);
 643             i++;
 644           }
 645       }
 646       break;
 647
 648     case CONSTRUCTOR:
 649       {
 650         unsigned HOST_WIDE_INT cnt;
 651         tree index, value;
 652         dump_int (di, "lngt", vec_safe_length (CONSTRUCTOR_ELTS (t)));
 653         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
 654           {
 655             dump_child ("idx", index);
 656             dump_child ("val", value);
 657           }
 658       }
 659       break;
 660
 661     case BIND_EXPR:
 662       dump_child ("vars", TREE_OPERAND (t, 0));
 663       dump_child ("body", TREE_OPERAND (t, 1));
 664       break;
 665
 666     case LOOP_EXPR:
 667       dump_child ("body", TREE_OPERAND (t, 0));
 668       break;
 669
 670     case EXIT_EXPR:
 671       dump_child ("cond", TREE_OPERAND (t, 0));
 672       break;
 673
 674     case RETURN_EXPR:
 675       dump_child ("expr", TREE_OPERAND (t, 0));
 676       break;
 677
 678     case TARGET_EXPR:
 679       dump_child ("decl", TREE_OPERAND (t, 0));
 680       dump_child ("init", TREE_OPERAND (t, 1));
 681       dump_child ("clnp", TREE_OPERAND (t, 2));
 682       /* There really are two possible places the initializer can be.
 683          After RTL expansion, the second operand is moved to the
 684          position of the fourth operand, and the second operand
 685          becomes NULL.  */
 686       dump_child ("init", TREE_OPERAND (t, 3));
 687       break;
 688
 689     case CASE_LABEL_EXPR:
 690       dump_child ("name", CASE_LABEL (t));
 691       if (CASE_LOW (t))
 692         {
 693           dump_child ("low ", CASE_LOW (t));
 694           if (CASE_HIGH (t))
 695             dump_child ("high", CASE_HIGH (t));
 696         }
 697       break;
 698     case LABEL_EXPR:
 699       dump_child ("name", TREE_OPERAND (t,0));
 700       break;
 701     case GOTO_EXPR:
 702       dump_child ("labl", TREE_OPERAND (t, 0));
 703       break;
 704     case SWITCH_EXPR:
 705       dump_child ("cond", TREE_OPERAND (t, 0));
 706       dump_child ("body", TREE_OPERAND (t, 1));
 707       if (TREE_OPERAND (t, 2))
 708         {
 709           dump_child ("labl", TREE_OPERAND (t,2));
 710         }
 711       break;
 712     case OMP_CLAUSE:
 713       {
 714         int i;
 715         fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
 716         for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
 717           dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
 718       }
 719       break;
 720     default:
 721       /* There are no additional fields to print.  */
 722       break;
 723     }
 724
 725  done:
 726   if (dump_flag (di, TDF_ADDRESS, NULL))
 727     dump_pointer (di, "addr", (void *)t);
 728
 729   /* Terminate the line.  */
 730   fprintf (di->stream, "\n");
 731 }
 732
 733 /* Return nonzero if FLAG has been specified for the dump, and NODE
 734    is not the root node of the dump.  */
 735
 736 int dump_flag (dump_info_p di, int flag, const_tree node)
 737 {
 738   return (di->flags & flag) && (node != di->node);
 739 }
 740
 741 /* Dump T, and all its children, on STREAM.  */
 742
 743 void
 744 dump_node (const_tree t, int flags, FILE *stream)
 745 {
 746   struct dump_info di;
 747   dump_queue_p dq;
 748   dump_queue_p next_dq;
 749
 750   /* Initialize the dump-information structure.  */
 751   di.stream = stream;
 752   di.index = 0;
 753   di.column = 0;
 754   di.queue = 0;
 755   di.queue_end = 0;
 756   di.free_list = 0;
 757   di.flags = flags;
 758   di.node = t;
 759   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
 760                              (splay_tree_delete_value_fn) &free);
 761
 762   /* Queue up the first node.  */
 763   queue (&di, t, DUMP_NONE);
 764
 765   /* Until the queue is empty, keep dumping nodes.  */
 766   while (di.queue)
 767     dequeue_and_dump (&di);
 768
 769   /* Now, clean up.  */
 770   for (dq = di.free_list; dq; dq = next_dq)
 771     {
 772       next_dq = dq->next;
 773       free (dq);
 774     }
 775   splay_tree_delete (di.nodes);
 776 }