gcc/tree-dump.c

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