gcc/tree-dump.c

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