gcc/tree-dump.c

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