gcc/tree-dump.c

   1 /* Tree-dumping functionality for intermediate representation.
   2    Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4    Written by Mark Mitchell <mark@codesourcery.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "splay-tree.h"
  28 #include "diagnostic.h"
  29 #include "toplev.h"
  30 #include "tree-dump.h"
  31 #include "tree-pass.h"
  32 #include "langhooks.h"
  33 #include "tree-iterator.h"
  34 #include "real.h"
  35 #include "fixed-value.h"
  36
  37 static unsigned int queue (dump_info_p, const_tree, int);
  38 static void dump_index (dump_info_p, unsigned int);
  39 static void dequeue_and_dump (dump_info_p);
  40 static void dump_new_line (dump_info_p);
  41 static void dump_maybe_newline (dump_info_p);
  42
  43 /* Add T to the end of the queue of nodes to dump.  Returns the index
  44    assigned to T.  */
  45
  46 static unsigned int
  47 queue (dump_info_p di, const_tree t, int flags)
  48 {
  49   dump_queue_p dq;
  50   dump_node_info_p dni;
  51   unsigned int index;
  52
  53   /* Assign the next available index to T.  */
  54   index = ++di->index;
  55
  56   /* Obtain a new queue node.  */
  57   if (di->free_list)
  58     {
  59       dq = di->free_list;
  60       di->free_list = dq->next;
  61     }
  62   else
  63     dq = XNEW (struct dump_queue);
  64
  65   /* Create a new entry in the splay-tree.  */
  66   dni = XNEW (struct dump_node_info);
  67   dni->index = index;
  68   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
  69   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
  70                                 (splay_tree_value) dni);
  71
  72   /* Add it to the end of the queue.  */
  73   dq->next = 0;
  74   if (!di->queue_end)
  75     di->queue = dq;
  76   else
  77     di->queue_end->next = dq;
  78   di->queue_end = dq;
  79
  80   /* Return the index.  */
  81   return index;
  82 }
  83
  84 static void
  85 dump_index (dump_info_p di, unsigned int index)
  86 {
  87   fprintf (di->stream, "@%-6u ", index);
  88   di->column += 8;
  89 }
  90
  91 /* If T has not already been output, queue it for subsequent output.
  92    FIELD is a string to print before printing the index.  Then, the
  93    index of T is printed.  */
  94
  95 void
  96 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
  97 {
  98   unsigned int index;
  99   splay_tree_node n;
 100
 101   /* If there's no node, just return.  This makes for fewer checks in
 102      our callers.  */
 103   if (!t)
 104     return;
 105
 106   /* See if we've already queued or dumped this node.  */
 107   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
 108   if (n)
 109     index = ((dump_node_info_p) n->value)->index;
 110   else
 111     /* If we haven't, add it to the queue.  */
 112     index = queue (di, t, flags);
 113
 114   /* Print the index of the node.  */
 115   dump_maybe_newline (di);
 116   fprintf (di->stream, "%-4s: ", field);
 117   di->column += 6;
 118   dump_index (di, index);
 119 }
 120
 121 /* Dump the type of T.  */
 122
 123 void
 124 queue_and_dump_type (dump_info_p di, const_tree t)
 125 {
 126   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
 127 }
 128
 129 /* Dump column control */
 130 #define SOL_COLUMN 25           /* Start of line column.  */
 131 #define EOL_COLUMN 55           /* End of line column.  */
 132 #define COLUMN_ALIGNMENT 15     /* Alignment.  */
 133
 134 /* Insert a new line in the dump output, and indent to an appropriate
 135    place to start printing more fields.  */
 136
 137 static void
 138 dump_new_line (dump_info_p di)
 139 {
 140   fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
 141   di->column = SOL_COLUMN;
 142 }
 143
 144 /* If necessary, insert a new line.  */
 145
 146 static void
 147 dump_maybe_newline (dump_info_p di)
 148 {
 149   int extra;
 150
 151   /* See if we need a new line.  */
 152   if (di->column > EOL_COLUMN)
 153     dump_new_line (di);
 154   /* See if we need any padding.  */
 155   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
 156     {
 157       fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
 158       di->column += COLUMN_ALIGNMENT - extra;
 159     }
 160 }
 161
 162 /* Dump pointer PTR using FIELD to identify it.  */
 163
 164 void
 165 dump_pointer (dump_info_p di, const char *field, void *ptr)
 166 {
 167   dump_maybe_newline (di);
 168   fprintf (di->stream, "%-4s: %-8lx ", field, (unsigned long) ptr);
 169   di->column += 15;
 170 }
 171
 172 /* Dump integer I using FIELD to identify it.  */
 173
 174 void
 175 dump_int (dump_info_p di, const char *field, int i)
 176 {
 177   dump_maybe_newline (di);
 178   fprintf (di->stream, "%-4s: %-7d ", field, i);
 179   di->column += 14;
 180 }
 181
 182 /* Dump the floating point value R, using FIELD to identify it.  */
 183
 184 static void
 185 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
 186 {
 187   char buf[32];
 188   real_to_decimal (buf, r, sizeof (buf), 0, true);
 189   dump_maybe_newline (di);
 190   fprintf (di->stream, "%-4s: %s ", field, buf);
 191   di->column += strlen (buf) + 7;
 192 }
 193
 194 /* Dump the fixed-point value F, using FIELD to identify it.  */
 195
 196 static void
 197 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
 198 {
 199   char buf[32];
 200   fixed_to_decimal (buf, f, sizeof (buf));
 201   dump_maybe_newline (di);
 202   fprintf (di->stream, "%-4s: %s ", field, buf);
 203   di->column += strlen (buf) + 7;
 204 }
 205
 206
 207 /* Dump the string S.  */
 208
 209 void
 210 dump_string (dump_info_p di, const char *string)
 211 {
 212   dump_maybe_newline (di);
 213   fprintf (di->stream, "%-13s ", string);
 214   if (strlen (string) > 13)
 215     di->column += strlen (string) + 1;
 216   else
 217     di->column += 14;
 218 }
 219
 220 /* Dump the string field S.  */
 221
 222 void
 223 dump_string_field (dump_info_p di, const char *field, const char *string)
 224 {
 225   dump_maybe_newline (di);
 226   fprintf (di->stream, "%-4s: %-7s ", field, string);
 227   if (strlen (string) > 7)
 228     di->column += 6 + strlen (string) + 1;
 229   else
 230     di->column += 14;
 231 }
 232
 233 /* Dump the next node in the queue.  */
 234
 235 static void
 236 dequeue_and_dump (dump_info_p di)
 237 {
 238   dump_queue_p dq;
 239   splay_tree_node stn;
 240   dump_node_info_p dni;
 241   tree t;
 242   unsigned int index;
 243   enum tree_code code;
 244   enum tree_code_class code_class;
 245   const char* code_name;
 246
 247   /* Get the next node from the queue.  */
 248   dq = di->queue;
 249   stn = dq->node;
 250   t = (tree) stn->key;
 251   dni = (dump_node_info_p) stn->value;
 252   index = dni->index;
 253
 254   /* Remove the node from the queue, and put it on the free list.  */
 255   di->queue = dq->next;
 256   if (!di->queue)
 257     di->queue_end = 0;
 258   dq->next = di->free_list;
 259   di->free_list = dq;
 260
 261   /* Print the node index.  */
 262   dump_index (di, index);
 263   /* And the type of node this is.  */
 264   if (dni->binfo_p)
 265     code_name = "binfo";
 266   else
 267     code_name = tree_code_name[(int) TREE_CODE (t)];
 268   fprintf (di->stream, "%-16s ", code_name);
 269   di->column = 25;
 270
 271   /* Figure out what kind of node this is.  */
 272   code = TREE_CODE (t);
 273   code_class = TREE_CODE_CLASS (code);
 274
 275   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
 276      more informative.  */
 277   if (dni->binfo_p)
 278     {
 279       unsigned ix;
 280       tree base;
 281       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
 282
 283       dump_child ("type", BINFO_TYPE (t));
 284
 285       if (BINFO_VIRTUAL_P (t))
 286         dump_string_field (di, "spec", "virt");
 287
 288       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
 289       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
 290         {
 291           tree access = (accesses ? VEC_index (tree, accesses, ix)
 292                          : access_public_node);
 293           const char *string = NULL;
 294
 295           if (access == access_public_node)
 296             string = "pub";
 297           else if (access == access_protected_node)
 298             string = "prot";
 299           else if (access == access_private_node)
 300             string = "priv";
 301           else
 302             gcc_unreachable ();
 303
 304           dump_string_field (di, "accs", string);
 305           queue_and_dump_index (di, "binf", base, DUMP_BINFO);
 306         }
 307
 308       goto done;
 309     }
 310
 311   /* We can knock off a bunch of expression nodes in exactly the same
 312      way.  */
 313   if (IS_EXPR_CODE_CLASS (code_class))
 314     {
 315       /* If we're dumping children, dump them now.  */
 316       queue_and_dump_type (di, t);
 317
 318       switch (code_class)
 319         {
 320         case tcc_unary:
 321           dump_child ("op 0", TREE_OPERAND (t, 0));
 322           break;
 323
 324         case tcc_binary:
 325         case tcc_comparison:
 326           dump_child ("op 0", TREE_OPERAND (t, 0));
 327           dump_child ("op 1", TREE_OPERAND (t, 1));
 328           break;
 329
 330         case tcc_expression:
 331         case tcc_reference:
 332         case tcc_statement:
 333         case tcc_vl_exp:
 334           /* These nodes are handled explicitly below.  */
 335           break;
 336
 337         default:
 338           gcc_unreachable ();
 339         }
 340     }
 341   else if (DECL_P (t))
 342     {
 343       expanded_location xloc;
 344       /* All declarations have names.  */
 345       if (DECL_NAME (t))
 346         dump_child ("name", DECL_NAME (t));
 347       if (DECL_ASSEMBLER_NAME_SET_P (t)
 348           && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
 349         dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
 350       if (DECL_ABSTRACT_ORIGIN (t))
 351         dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
 352       /* And types.  */
 353       queue_and_dump_type (di, t);
 354       dump_child ("scpe", DECL_CONTEXT (t));
 355       /* And a source position.  */
 356       xloc = expand_location (DECL_SOURCE_LOCATION (t));
 357       if (xloc.file)
 358         {
 359           const char *filename = strrchr (xloc.file, '/');
 360           if (!filename)
 361             filename = xloc.file;
 362           else
 363             /* Skip the slash.  */
 364             ++filename;
 365
 366           dump_maybe_newline (di);
 367           fprintf (di->stream, "srcp: %s:%-6d ", filename,
 368                    xloc.line);
 369           di->column += 6 + strlen (filename) + 8;
 370         }
 371       /* And any declaration can be compiler-generated.  */
 372       if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
 373           && DECL_ARTIFICIAL (t))
 374         dump_string_field (di, "note", "artificial");
 375       if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
 376         dump_child ("chan", TREE_CHAIN (t));
 377     }
 378   else if (code_class == tcc_type)
 379     {
 380       /* All types have qualifiers.  */
 381       int quals = lang_hooks.tree_dump.type_quals (t);
 382
 383       if (quals != TYPE_UNQUALIFIED)
 384         {
 385           fprintf (di->stream, "qual: %c%c%c     ",
 386                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
 387                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
 388                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
 389           di->column += 14;
 390         }
 391
 392       /* All types have associated declarations.  */
 393       dump_child ("name", TYPE_NAME (t));
 394
 395       /* All types have a main variant.  */
 396       if (TYPE_MAIN_VARIANT (t) != t)
 397         dump_child ("unql", TYPE_MAIN_VARIANT (t));
 398
 399       /* And sizes.  */
 400       dump_child ("size", TYPE_SIZE (t));
 401
 402       /* All types have alignments.  */
 403       dump_int (di, "algn", TYPE_ALIGN (t));
 404     }
 405   else if (code_class == tcc_constant)
 406     /* All constants can have types.  */
 407     queue_and_dump_type (di, t);
 408
 409   /* Give the language-specific code a chance to print something.  If
 410      it's completely taken care of things, don't bother printing
 411      anything more ourselves.  */
 412   if (lang_hooks.tree_dump.dump_tree (di, t))
 413     goto done;
 414
 415   /* Now handle the various kinds of nodes.  */
 416   switch (code)
 417     {
 418       int i;
 419
 420     case IDENTIFIER_NODE:
 421       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
 422       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 423       break;
 424
 425     case TREE_LIST:
 426       dump_child ("purp", TREE_PURPOSE (t));
 427       dump_child ("valu", TREE_VALUE (t));
 428       dump_child ("chan", TREE_CHAIN (t));
 429       break;
 430
 431     case STATEMENT_LIST:
 432       {
 433         tree_stmt_iterator it;
 434         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
 435           {
 436             char buffer[32];
 437             sprintf (buffer, "%u", i);
 438             dump_child (buffer, tsi_stmt (it));
 439           }
 440       }
 441       break;
 442
 443     case TREE_VEC:
 444       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
 445       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 446         {
 447           char buffer[32];
 448           sprintf (buffer, "%u", i);
 449           dump_child (buffer, TREE_VEC_ELT (t, i));
 450         }
 451       break;
 452
 453     case INTEGER_TYPE:
 454     case ENUMERAL_TYPE:
 455       dump_int (di, "prec", TYPE_PRECISION (t));
 456       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 457       dump_child ("min", TYPE_MIN_VALUE (t));
 458       dump_child ("max", TYPE_MAX_VALUE (t));
 459
 460       if (code == ENUMERAL_TYPE)
 461         dump_child ("csts", TYPE_VALUES (t));
 462       break;
 463
 464     case REAL_TYPE:
 465       dump_int (di, "prec", TYPE_PRECISION (t));
 466       break;
 467
 468     case FIXED_POINT_TYPE:
 469       dump_int (di, "prec", TYPE_PRECISION (t));
 470       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 471       dump_string_field (di, "saturating",
 472                          TYPE_SATURATING (t) ? "saturating": "non-saturating");
 473       break;
 474
 475     case POINTER_TYPE:
 476       dump_child ("ptd", TREE_TYPE (t));
 477       break;
 478
 479     case REFERENCE_TYPE:
 480       dump_child ("refd", TREE_TYPE (t));
 481       break;
 482
 483     case METHOD_TYPE:
 484       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
 485       /* Fall through.  */
 486
 487     case FUNCTION_TYPE:
 488       dump_child ("retn", TREE_TYPE (t));
 489       dump_child ("prms", TYPE_ARG_TYPES (t));
 490       break;
 491
 492     case ARRAY_TYPE:
 493       dump_child ("elts", TREE_TYPE (t));
 494       dump_child ("domn", TYPE_DOMAIN (t));
 495       break;
 496
 497     case RECORD_TYPE:
 498     case UNION_TYPE:
 499       if (TREE_CODE (t) == RECORD_TYPE)
 500         dump_string_field (di, "tag", "struct");
 501       else
 502         dump_string_field (di, "tag", "union");
 503
 504       dump_child ("flds", TYPE_FIELDS (t));
 505       dump_child ("fncs", TYPE_METHODS (t));
 506       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
 507                             DUMP_BINFO);
 508       break;
 509
 510     case CONST_DECL:
 511       dump_child ("cnst", DECL_INITIAL (t));
 512       break;
 513
 514     case DEBUG_EXPR_DECL:
 515       dump_int (di, "-uid", DEBUG_TEMP_UID (t));
 516       /* Fall through.  */
 517
 518     case VAR_DECL:
 519     case PARM_DECL:
 520     case FIELD_DECL:
 521     case RESULT_DECL:
 522       if (TREE_CODE (t) == PARM_DECL)
 523         dump_child ("argt", DECL_ARG_TYPE (t));
 524       else
 525         dump_child ("init", DECL_INITIAL (t));
 526       dump_child ("size", DECL_SIZE (t));
 527       dump_int (di, "algn", DECL_ALIGN (t));
 528
 529       if (TREE_CODE (t) == FIELD_DECL)
 530         {
 531           if (DECL_FIELD_OFFSET (t))
 532             dump_child ("bpos", bit_position (t));
 533         }
 534       else if (TREE_CODE (t) == VAR_DECL
 535                || TREE_CODE (t) == PARM_DECL)
 536         {
 537           dump_int (di, "used", TREE_USED (t));
 538           if (DECL_REGISTER (t))
 539             dump_string_field (di, "spec", "register");
 540         }
 541       break;
 542
 543     case FUNCTION_DECL:
 544       dump_child ("args", DECL_ARGUMENTS (t));
 545       if (DECL_EXTERNAL (t))
 546         dump_string_field (di, "body", "undefined");
 547       if (TREE_PUBLIC (t))
 548         dump_string_field (di, "link", "extern");
 549       else
 550         dump_string_field (di, "link", "static");
 551       if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
 552         dump_child ("body", DECL_SAVED_TREE (t));
 553       break;
 554
 555     case INTEGER_CST:
 556       if (TREE_INT_CST_HIGH (t))
 557         dump_int (di, "high", TREE_INT_CST_HIGH (t));
 558       dump_int (di, "low", TREE_INT_CST_LOW (t));
 559       break;
 560
 561     case STRING_CST:
 562       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
 563       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
 564       break;
 565
 566     case REAL_CST:
 567       dump_real (di, "valu", TREE_REAL_CST_PTR (t));
 568       break;
 569
 570     case FIXED_CST:
 571       dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
 572       break;
 573
 574     case TRUTH_NOT_EXPR:
 575     case ADDR_EXPR:
 576     case INDIRECT_REF:
 577     case ALIGN_INDIRECT_REF:
 578     case MISALIGNED_INDIRECT_REF:
 579     case CLEANUP_POINT_EXPR:
 580     case SAVE_EXPR:
 581     case REALPART_EXPR:
 582     case IMAGPART_EXPR:
 583       /* These nodes are unary, but do not have code class `1'.  */
 584       dump_child ("op 0", TREE_OPERAND (t, 0));
 585       break;
 586
 587     case TRUTH_ANDIF_EXPR:
 588     case TRUTH_ORIF_EXPR:
 589     case INIT_EXPR:
 590     case MODIFY_EXPR:
 591     case COMPOUND_EXPR:
 592     case PREDECREMENT_EXPR:
 593     case PREINCREMENT_EXPR:
 594     case POSTDECREMENT_EXPR:
 595     case POSTINCREMENT_EXPR:
 596       /* These nodes are binary, but do not have code class `2'.  */
 597       dump_child ("op 0", TREE_OPERAND (t, 0));
 598       dump_child ("op 1", TREE_OPERAND (t, 1));
 599       break;
 600
 601     case COMPONENT_REF:
 602       dump_child ("op 0", TREE_OPERAND (t, 0));
 603       dump_child ("op 1", TREE_OPERAND (t, 1));
 604       dump_child ("op 2", TREE_OPERAND (t, 2));
 605       break;
 606
 607     case ARRAY_REF:
 608     case ARRAY_RANGE_REF:
 609       dump_child ("op 0", TREE_OPERAND (t, 0));
 610       dump_child ("op 1", TREE_OPERAND (t, 1));
 611       dump_child ("op 2", TREE_OPERAND (t, 2));
 612       dump_child ("op 3", TREE_OPERAND (t, 3));
 613       break;
 614
 615     case COND_EXPR:
 616       dump_child ("op 0", TREE_OPERAND (t, 0));
 617       dump_child ("op 1", TREE_OPERAND (t, 1));
 618       dump_child ("op 2", TREE_OPERAND (t, 2));
 619       break;
 620
 621     case TRY_FINALLY_EXPR:
 622       dump_child ("op 0", TREE_OPERAND (t, 0));
 623       dump_child ("op 1", TREE_OPERAND (t, 1));
 624       break;
 625
 626     case CALL_EXPR:
 627       {
 628         int i = 0;
 629         tree arg;
 630         call_expr_arg_iterator iter;
 631         dump_child ("fn", CALL_EXPR_FN (t));
 632         FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
 633           {
 634             char buffer[32];
 635             sprintf (buffer, "%u", i);
 636             dump_child (buffer, arg);
 637             i++;
 638           }
 639       }
 640       break;
 641
 642     case CONSTRUCTOR:
 643       {
 644         unsigned HOST_WIDE_INT cnt;
 645         tree index, value;
 646         dump_int (di, "lngt", VEC_length (constructor_elt,
 647                                           CONSTRUCTOR_ELTS (t)));
 648         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
 649           {
 650             dump_child ("idx", index);
 651             dump_child ("val", value);
 652           }
 653       }
 654       break;
 655
 656     case BIND_EXPR:
 657       dump_child ("vars", TREE_OPERAND (t, 0));
 658       dump_child ("body", TREE_OPERAND (t, 1));
 659       break;
 660
 661     case LOOP_EXPR:
 662       dump_child ("body", TREE_OPERAND (t, 0));
 663       break;
 664
 665     case EXIT_EXPR:
 666       dump_child ("cond", TREE_OPERAND (t, 0));
 667       break;
 668
 669     case RETURN_EXPR:
 670       dump_child ("expr", TREE_OPERAND (t, 0));
 671       break;
 672
 673     case TARGET_EXPR:
 674       dump_child ("decl", TREE_OPERAND (t, 0));
 675       dump_child ("init", TREE_OPERAND (t, 1));
 676       dump_child ("clnp", TREE_OPERAND (t, 2));
 677       /* There really are two possible places the initializer can be.
 678          After RTL expansion, the second operand is moved to the
 679          position of the fourth operand, and the second operand
 680          becomes NULL.  */
 681       dump_child ("init", TREE_OPERAND (t, 3));
 682       break;
 683
 684     case CASE_LABEL_EXPR:
 685       dump_child ("name", CASE_LABEL (t));
 686       if (CASE_LOW (t))
 687         {
 688           dump_child ("low ", CASE_LOW (t));
 689           if (CASE_HIGH (t))
 690             dump_child ("high", CASE_HIGH (t));
 691         }
 692       break;
 693     case LABEL_EXPR:
 694       dump_child ("name", TREE_OPERAND (t,0));
 695       break;
 696     case GOTO_EXPR:
 697       dump_child ("labl", TREE_OPERAND (t, 0));
 698       break;
 699     case SWITCH_EXPR:
 700       dump_child ("cond", TREE_OPERAND (t, 0));
 701       dump_child ("body", TREE_OPERAND (t, 1));
 702       if (TREE_OPERAND (t, 2))
 703         {
 704           dump_child ("labl", TREE_OPERAND (t,2));
 705         }
 706       break;
 707     case OMP_CLAUSE:
 708       {
 709         int i;
 710         fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
 711         for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
 712           dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
 713       }
 714       break;
 715     default:
 716       /* There are no additional fields to print.  */
 717       break;
 718     }
 719
 720  done:
 721   if (dump_flag (di, TDF_ADDRESS, NULL))
 722     dump_pointer (di, "addr", (void *)t);
 723
 724   /* Terminate the line.  */
 725   fprintf (di->stream, "\n");
 726 }
 727
 728 /* Return nonzero if FLAG has been specified for the dump, and NODE
 729    is not the root node of the dump.  */
 730
 731 int dump_flag (dump_info_p di, int flag, const_tree node)
 732 {
 733   return (di->flags & flag) && (node != di->node);
 734 }
 735
 736 /* Dump T, and all its children, on STREAM.  */
 737
 738 void
 739 dump_node (const_tree t, int flags, FILE *stream)
 740 {
 741   struct dump_info di;
 742   dump_queue_p dq;
 743   dump_queue_p next_dq;
 744
 745   /* Initialize the dump-information structure.  */
 746   di.stream = stream;
 747   di.index = 0;
 748   di.column = 0;
 749   di.queue = 0;
 750   di.queue_end = 0;
 751   di.free_list = 0;
 752   di.flags = flags;
 753   di.node = t;
 754   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
 755                              (splay_tree_delete_value_fn) &free);
 756
 757   /* Queue up the first node.  */
 758   queue (&di, t, DUMP_NONE);
 759
 760   /* Until the queue is empty, keep dumping nodes.  */
 761   while (di.queue)
 762     dequeue_and_dump (&di);
 763
 764   /* Now, clean up.  */
 765   for (dq = di.free_list; dq; dq = next_dq)
 766     {
 767       next_dq = dq->next;
 768       free (dq);
 769     }
 770   splay_tree_delete (di.nodes);
 771 }
 772 \f
 773
 774 /* Table of tree dump switches. This must be consistent with the
 775    tree_dump_index enumeration in tree-pass.h.  */
 776 static struct dump_file_info dump_files[TDI_end] =
 777 {
 778   {NULL, NULL, NULL, 0, 0, 0},
 779   {".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0,  0},
 780   {".tu", "translation-unit", NULL, TDF_TREE, 0, 1},
 781   {".class", "class-hierarchy", NULL, TDF_TREE, 0, 2},
 782   {".original", "tree-original", NULL, TDF_TREE, 0, 3},
 783   {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 4},
 784   {".nested", "tree-nested", NULL, TDF_TREE, 0, 5},
 785   {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6},
 786 #define FIRST_AUTO_NUMBERED_DUMP 7
 787
 788   {NULL, "tree-all", NULL, TDF_TREE, 0, 0},
 789   {NULL, "rtl-all", NULL, TDF_RTL, 0, 0},
 790   {NULL, "ipa-all", NULL, TDF_IPA, 0, 0},
 791 };
 792
 793 /* Dynamically registered tree dump files and switches.  */
 794 static struct dump_file_info *extra_dump_files;
 795 static size_t extra_dump_files_in_use;
 796 static size_t extra_dump_files_alloced;
 797
 798 /* Define a name->number mapping for a dump flag value.  */
 799 struct dump_option_value_info
 800 {
 801   const char *const name;       /* the name of the value */
 802   const int value;              /* the value of the name */
 803 };
 804
 805 /* Table of dump options. This must be consistent with the TDF_* flags
 806    in tree.h */
 807 static const struct dump_option_value_info dump_options[] =
 808 {
 809   {"address", TDF_ADDRESS},
 810   {"asmname", TDF_ASMNAME},
 811   {"slim", TDF_SLIM},
 812   {"raw", TDF_RAW},
 813   {"graph", TDF_GRAPH},
 814   {"details", TDF_DETAILS},
 815   {"stats", TDF_STATS},
 816   {"blocks", TDF_BLOCKS},
 817   {"vops", TDF_VOPS},
 818   {"lineno", TDF_LINENO},
 819   {"uid", TDF_UID},
 820   {"stmtaddr", TDF_STMTADDR},
 821   {"memsyms", TDF_MEMSYMS},
 822   {"verbose", TDF_VERBOSE},
 823   {"eh", TDF_EH},
 824   {"alias", TDF_ALIAS},
 825   {"nouid", TDF_NOUID},
 826   {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
 827             | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC | TDF_VERBOSE
 828             | TDF_RHS_ONLY | TDF_NOUID)},
 829   {NULL, 0}
 830 };
 831
 832 unsigned int
 833 dump_register (const char *suffix, const char *swtch, const char *glob,
 834                int flags)
 835 {
 836   static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
 837   int num = next_dump++;
 838
 839   size_t count = extra_dump_files_in_use++;
 840
 841   if (count >= extra_dump_files_alloced)
 842     {
 843       if (extra_dump_files_alloced == 0)
 844         extra_dump_files_alloced = 32;
 845       else
 846         extra_dump_files_alloced *= 2;
 847       extra_dump_files = XRESIZEVEC (struct dump_file_info,
 848                                      extra_dump_files,
 849                                      extra_dump_files_alloced);
 850     }
 851
 852   memset (&extra_dump_files[count], 0, sizeof (struct dump_file_info));
 853   extra_dump_files[count].suffix = suffix;
 854   extra_dump_files[count].swtch = swtch;
 855   extra_dump_files[count].glob = glob;
 856   extra_dump_files[count].flags = flags;
 857   extra_dump_files[count].num = num;
 858
 859   return count + TDI_end;
 860 }
 861
 862
 863 /* Return the dump_file_info for the given phase.  */
 864
 865 struct dump_file_info *
 866 get_dump_file_info (int phase)
 867 {
 868   if (phase < TDI_end)
 869     return &dump_files[phase];
 870   else if ((size_t) (phase - TDI_end) >= extra_dump_files_in_use)
 871     return NULL;
 872   else
 873     return extra_dump_files + (phase - TDI_end);
 874 }
 875
 876
 877 /* Return the name of the dump file for the given phase.
 878    If the dump is not enabled, returns NULL.  */
 879
 880 char *
 881 get_dump_file_name (int phase)
 882 {
 883   char dump_id[10];
 884   struct dump_file_info *dfi;
 885
 886   if (phase == TDI_none)
 887     return NULL;
 888
 889   dfi = get_dump_file_info (phase);
 890   if (dfi->state == 0)
 891     return NULL;
 892
 893   if (dfi->num < 0)
 894     dump_id[0] = '\0';
 895   else
 896     {
 897       char suffix;
 898       if (dfi->flags & TDF_TREE)
 899         suffix = 't';
 900       else if (dfi->flags & TDF_IPA)
 901         suffix = 'i';
 902       else
 903         suffix = 'r';
 904
 905       if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
 906         dump_id[0] = '\0';
 907     }
 908
 909   return concat (dump_base_name, dump_id, dfi->suffix, NULL);
 910 }
 911
 912 /* Begin a tree dump for PHASE. Stores any user supplied flag in
 913    *FLAG_PTR and returns a stream to write to. If the dump is not
 914    enabled, returns NULL.
 915    Multiple calls will reopen and append to the dump file.  */
 916
 917 FILE *
 918 dump_begin (int phase, int *flag_ptr)
 919 {
 920   char *name;
 921   struct dump_file_info *dfi;
 922   FILE *stream;
 923
 924   if (phase == TDI_none || !dump_enabled_p (phase))
 925     return NULL;
 926
 927   name = get_dump_file_name (phase);
 928   dfi = get_dump_file_info (phase);
 929   stream = fopen (name, dfi->state < 0 ? "w" : "a");
 930   if (!stream)
 931     error ("could not open dump file %qs: %s", name, strerror (errno));
 932   else
 933     dfi->state = 1;
 934   free (name);
 935
 936   if (flag_ptr)
 937     *flag_ptr = dfi->flags;
 938
 939   return stream;
 940 }
 941
 942 /* Returns nonzero if tree dump PHASE is enabled.  If PHASE is
 943    TDI_tree_all, return nonzero if any dump is enabled.  */
 944
 945 int
 946 dump_enabled_p (int phase)
 947 {
 948   if (phase == TDI_tree_all)
 949     {
 950       size_t i;
 951       for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 952         if (dump_files[i].state)
 953           return 1;
 954       for (i = 0; i < extra_dump_files_in_use; i++)
 955         if (extra_dump_files[i].state)
 956           return 1;
 957       return 0;
 958     }
 959   else
 960     {
 961       struct dump_file_info *dfi = get_dump_file_info (phase);
 962       return dfi->state;
 963     }
 964 }
 965
 966 /* Returns nonzero if tree dump PHASE has been initialized.  */
 967
 968 int
 969 dump_initialized_p (int phase)
 970 {
 971   struct dump_file_info *dfi = get_dump_file_info (phase);
 972   return dfi->state > 0;
 973 }
 974
 975 /* Returns the switch name of PHASE.  */
 976
 977 const char *
 978 dump_flag_name (int phase)
 979 {
 980   struct dump_file_info *dfi = get_dump_file_info (phase);
 981   return dfi->swtch;
 982 }
 983
 984 /* Finish a tree dump for PHASE. STREAM is the stream created by
 985    dump_begin.  */
 986
 987 void
 988 dump_end (int phase ATTRIBUTE_UNUSED, FILE *stream)
 989 {
 990   fclose (stream);
 991 }
 992
 993 /* Enable all tree dumps.  Return number of enabled tree dumps.  */
 994
 995 static int
 996 dump_enable_all (int flags)
 997 {
 998   int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));
 999   int n = 0;
1000   size_t i;
1001
1002   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
1003     if ((dump_files[i].flags & ir_dump_type))
1004       {
1005         dump_files[i].state = -1;
1006         dump_files[i].flags |= flags;
1007         n++;
1008       }
1009
1010   for (i = 0; i < extra_dump_files_in_use; i++)
1011     if ((extra_dump_files[i].flags & ir_dump_type))
1012       {
1013         extra_dump_files[i].state = -1;
1014         extra_dump_files[i].flags |= flags;
1015         n++;
1016       }
1017
1018   return n;
1019 }
1020
1021 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1022    relevant details in the dump_files array.  */
1023
1024 static int
1025 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
1026 {
1027   const char *option_value;
1028   const char *ptr;
1029   int flags;
1030
1031   if (doglob && !dfi->glob)
1032     return 0;
1033
1034   option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
1035   if (!option_value)
1036     return 0;
1037
1038   if (*option_value && *option_value != '-')
1039     return 0;
1040
1041   ptr = option_value;
1042   flags = 0;
1043
1044   while (*ptr)
1045     {
1046       const struct dump_option_value_info *option_ptr;
1047       const char *end_ptr;
1048       unsigned length;
1049
1050       while (*ptr == '-')
1051         ptr++;
1052       end_ptr = strchr (ptr, '-');
1053       if (!end_ptr)
1054         end_ptr = ptr + strlen (ptr);
1055       length = end_ptr - ptr;
1056
1057       for (option_ptr = dump_options; option_ptr->name; option_ptr++)
1058         if (strlen (option_ptr->name) == length
1059             && !memcmp (option_ptr->name, ptr, length))
1060           {
1061             flags |= option_ptr->value;
1062             goto found;
1063           }
1064       warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1065                length, ptr, dfi->swtch);
1066     found:;
1067       ptr = end_ptr;
1068     }
1069
1070   dfi->state = -1;
1071   dfi->flags |= flags;
1072
1073   /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1074      known dumps.  */
1075   if (dfi->suffix == NULL)
1076     dump_enable_all (dfi->flags);
1077
1078   return 1;
1079 }
1080
1081 int
1082 dump_switch_p (const char *arg)
1083 {
1084   size_t i;
1085   int any = 0;
1086
1087   for (i = TDI_none + 1; i != TDI_end; i++)
1088     any |= dump_switch_p_1 (arg, &dump_files[i], false);
1089
1090   /* Don't glob if we got a hit already */
1091   if (!any)
1092     for (i = TDI_none + 1; i != TDI_end; i++)
1093       any |= dump_switch_p_1 (arg, &dump_files[i], true);
1094
1095   for (i = 0; i < extra_dump_files_in_use; i++)
1096     any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
1097
1098   if (!any)
1099     for (i = 0; i < extra_dump_files_in_use; i++)
1100       any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
1101
1102
1103   return any;
1104 }
1105
1106 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
1107
1108 void
1109 dump_function (int phase, tree fn)
1110 {
1111   FILE *stream;
1112   int flags;
1113
1114   stream = dump_begin (phase, &flags);
1115   if (stream)
1116     {
1117       dump_function_to_file (fn, stream, flags);
1118       dump_end (phase, stream);
1119     }
1120 }
1121
1122 bool
1123 enable_rtl_dump_file (void)
1124 {
1125   return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS) > 0;
1126 }