gcc/tree-dump.c

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