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, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, 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) *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       /* And types.  */
 326       queue_and_dump_type (di, t);
 327       dump_child ("scpe", DECL_CONTEXT (t));
 328       /* And a source position.  */
 329       xloc = expand_location (DECL_SOURCE_LOCATION (t));
 330       if (xloc.file)
 331         {
 332           const char *filename = strrchr (xloc.file, '/');
 333           if (!filename)
 334             filename = xloc.file;
 335           else
 336             /* Skip the slash.  */
 337             ++filename;
 338
 339           dump_maybe_newline (di);
 340           fprintf (di->stream, "srcp: %s:%-6d ", filename,
 341                    xloc.line);
 342           di->column += 6 + strlen (filename) + 8;
 343         }
 344       /* And any declaration can be compiler-generated.  */
 345       if (DECL_ARTIFICIAL (t))
 346         dump_string (di, "artificial");
 347       if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
 348         dump_child ("chan", TREE_CHAIN (t));
 349     }
 350   else if (code_class == tcc_type)
 351     {
 352       /* All types have qualifiers.  */
 353       int quals = lang_hooks.tree_dump.type_quals (t);
 354
 355       if (quals != TYPE_UNQUALIFIED)
 356         {
 357           fprintf (di->stream, "qual: %c%c%c     ",
 358                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
 359                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
 360                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
 361           di->column += 14;
 362         }
 363
 364       /* All types have associated declarations.  */
 365       dump_child ("name", TYPE_NAME (t));
 366
 367       /* All types have a main variant.  */
 368       if (TYPE_MAIN_VARIANT (t) != t)
 369         dump_child ("unql", TYPE_MAIN_VARIANT (t));
 370
 371       /* And sizes.  */
 372       dump_child ("size", TYPE_SIZE (t));
 373
 374       /* All types have alignments.  */
 375       dump_int (di, "algn", TYPE_ALIGN (t));
 376     }
 377   else if (code_class == tcc_constant)
 378     /* All constants can have types.  */
 379     queue_and_dump_type (di, t);
 380
 381   /* Give the language-specific code a chance to print something.  If
 382      it's completely taken care of things, don't bother printing
 383      anything more ourselves.  */
 384   if (lang_hooks.tree_dump.dump_tree (di, t))
 385     goto done;
 386
 387   /* Now handle the various kinds of nodes.  */
 388   switch (code)
 389     {
 390       int i;
 391
 392     case IDENTIFIER_NODE:
 393       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
 394       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 395       break;
 396
 397     case TREE_LIST:
 398       dump_child ("purp", TREE_PURPOSE (t));
 399       dump_child ("valu", TREE_VALUE (t));
 400       dump_child ("chan", TREE_CHAIN (t));
 401       break;
 402
 403     case STATEMENT_LIST:
 404       {
 405         tree_stmt_iterator it;
 406         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
 407           {
 408             char buffer[32];
 409             sprintf (buffer, "%u", i);
 410             dump_child (buffer, tsi_stmt (it));
 411           }
 412       }
 413       break;
 414
 415     case TREE_VEC:
 416       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
 417       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 418         {
 419           char buffer[32];
 420           sprintf (buffer, "%u", i);
 421           dump_child (buffer, TREE_VEC_ELT (t, i));
 422         }
 423       break;
 424
 425     case INTEGER_TYPE:
 426     case ENUMERAL_TYPE:
 427       dump_int (di, "prec", TYPE_PRECISION (t));
 428       if (TYPE_UNSIGNED (t))
 429         dump_string (di, "unsigned");
 430       dump_child ("min", TYPE_MIN_VALUE (t));
 431       dump_child ("max", TYPE_MAX_VALUE (t));
 432
 433       if (code == ENUMERAL_TYPE)
 434         dump_child ("csts", TYPE_VALUES (t));
 435       break;
 436
 437     case REAL_TYPE:
 438       dump_int (di, "prec", TYPE_PRECISION (t));
 439       break;
 440
 441     case POINTER_TYPE:
 442       dump_child ("ptd", TREE_TYPE (t));
 443       break;
 444
 445     case REFERENCE_TYPE:
 446       dump_child ("refd", TREE_TYPE (t));
 447       break;
 448
 449     case METHOD_TYPE:
 450       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
 451       /* Fall through.  */
 452
 453     case FUNCTION_TYPE:
 454       dump_child ("retn", TREE_TYPE (t));
 455       dump_child ("prms", TYPE_ARG_TYPES (t));
 456       break;
 457
 458     case ARRAY_TYPE:
 459       dump_child ("elts", TREE_TYPE (t));
 460       dump_child ("domn", TYPE_DOMAIN (t));
 461       break;
 462
 463     case RECORD_TYPE:
 464     case UNION_TYPE:
 465       if (TREE_CODE (t) == RECORD_TYPE)
 466         dump_string (di, "struct");
 467       else
 468         dump_string (di, "union");
 469
 470       dump_child ("flds", TYPE_FIELDS (t));
 471       dump_child ("fncs", TYPE_METHODS (t));
 472       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
 473                             DUMP_BINFO);
 474       break;
 475
 476     case CONST_DECL:
 477       dump_child ("cnst", DECL_INITIAL (t));
 478       break;
 479
 480     case VAR_DECL:
 481     case PARM_DECL:
 482     case FIELD_DECL:
 483     case RESULT_DECL:
 484       if (TREE_CODE (t) == PARM_DECL)
 485         dump_child ("argt", DECL_ARG_TYPE (t));
 486       else
 487         dump_child ("init", DECL_INITIAL (t));
 488       dump_child ("size", DECL_SIZE (t));
 489       dump_int (di, "algn", DECL_ALIGN (t));
 490
 491       if (TREE_CODE (t) == FIELD_DECL)
 492         {
 493           if (DECL_FIELD_OFFSET (t))
 494             dump_child ("bpos", bit_position (t));
 495         }
 496       else if (TREE_CODE (t) == VAR_DECL
 497                || TREE_CODE (t) == PARM_DECL)
 498         {
 499           dump_int (di, "used", TREE_USED (t));
 500           if (DECL_REGISTER (t))
 501             dump_string (di, "register");
 502         }
 503       break;
 504
 505     case FUNCTION_DECL:
 506       dump_child ("args", DECL_ARGUMENTS (t));
 507       if (DECL_EXTERNAL (t))
 508         dump_string (di, "undefined");
 509       if (TREE_PUBLIC (t))
 510         dump_string (di, "extern");
 511       else
 512         dump_string (di, "static");
 513       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
 514         dump_child ("body", DECL_SAVED_TREE (t));
 515       break;
 516
 517     case INTEGER_CST:
 518       if (TREE_INT_CST_HIGH (t))
 519         dump_int (di, "high", TREE_INT_CST_HIGH (t));
 520       dump_int (di, "low", TREE_INT_CST_LOW (t));
 521       break;
 522
 523     case STRING_CST:
 524       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
 525       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
 526       break;
 527
 528     case TRUTH_NOT_EXPR:
 529     case ADDR_EXPR:
 530     case INDIRECT_REF:
 531     case ALIGN_INDIRECT_REF:
 532     case MISALIGNED_INDIRECT_REF:
 533     case CLEANUP_POINT_EXPR:
 534     case SAVE_EXPR:
 535     case REALPART_EXPR:
 536     case IMAGPART_EXPR:
 537       /* These nodes are unary, but do not have code class `1'.  */
 538       dump_child ("op 0", TREE_OPERAND (t, 0));
 539       break;
 540
 541     case TRUTH_ANDIF_EXPR:
 542     case TRUTH_ORIF_EXPR:
 543     case INIT_EXPR:
 544     case MODIFY_EXPR:
 545     case COMPOUND_EXPR:
 546     case PREDECREMENT_EXPR:
 547     case PREINCREMENT_EXPR:
 548     case POSTDECREMENT_EXPR:
 549     case POSTINCREMENT_EXPR:
 550       /* These nodes are binary, but do not have code class `2'.  */
 551       dump_child ("op 0", TREE_OPERAND (t, 0));
 552       dump_child ("op 1", TREE_OPERAND (t, 1));
 553       break;
 554
 555     case COMPONENT_REF:
 556       dump_child ("op 0", TREE_OPERAND (t, 0));
 557       dump_child ("op 1", TREE_OPERAND (t, 1));
 558       dump_child ("op 2", TREE_OPERAND (t, 2));
 559       break;
 560
 561     case ARRAY_REF:
 562     case ARRAY_RANGE_REF:
 563       dump_child ("op 0", TREE_OPERAND (t, 0));
 564       dump_child ("op 1", TREE_OPERAND (t, 1));
 565       dump_child ("op 2", TREE_OPERAND (t, 2));
 566       dump_child ("op 3", TREE_OPERAND (t, 3));
 567       break;
 568
 569     case COND_EXPR:
 570       dump_child ("op 0", TREE_OPERAND (t, 0));
 571       dump_child ("op 1", TREE_OPERAND (t, 1));
 572       dump_child ("op 2", TREE_OPERAND (t, 2));
 573       break;
 574
 575     case CALL_EXPR:
 576       dump_child ("fn", TREE_OPERAND (t, 0));
 577       dump_child ("args", TREE_OPERAND (t, 1));
 578       break;
 579
 580     case CONSTRUCTOR:
 581       dump_child ("elts", CONSTRUCTOR_ELTS (t));
 582       break;
 583
 584     case BIND_EXPR:
 585       dump_child ("vars", TREE_OPERAND (t, 0));
 586       dump_child ("body", TREE_OPERAND (t, 1));
 587       break;
 588
 589     case LOOP_EXPR:
 590       dump_child ("body", TREE_OPERAND (t, 0));
 591       break;
 592
 593     case EXIT_EXPR:
 594       dump_child ("cond", TREE_OPERAND (t, 0));
 595       break;
 596
 597     case TARGET_EXPR:
 598       dump_child ("decl", TREE_OPERAND (t, 0));
 599       dump_child ("init", TREE_OPERAND (t, 1));
 600       dump_child ("clnp", TREE_OPERAND (t, 2));
 601       /* There really are two possible places the initializer can be.
 602          After RTL expansion, the second operand is moved to the
 603          position of the fourth operand, and the second operand
 604          becomes NULL.  */
 605       dump_child ("init", TREE_OPERAND (t, 3));
 606       break;
 607
 608     default:
 609       /* There are no additional fields to print.  */
 610       break;
 611     }
 612
 613  done:
 614   if (dump_flag (di, TDF_ADDRESS, NULL))
 615     dump_pointer (di, "addr", (void *)t);
 616
 617   /* Terminate the line.  */
 618   fprintf (di->stream, "\n");
 619 }
 620
 621 /* Return nonzero if FLAG has been specified for the dump, and NODE
 622    is not the root node of the dump.  */
 623
 624 int dump_flag (dump_info_p di, int flag, tree node)
 625 {
 626   return (di->flags & flag) && (node != di->node);
 627 }
 628
 629 /* Dump T, and all its children, on STREAM.  */
 630
 631 void
 632 dump_node (tree t, int flags, FILE *stream)
 633 {
 634   struct dump_info di;
 635   dump_queue_p dq;
 636   dump_queue_p next_dq;
 637
 638   /* Initialize the dump-information structure.  */
 639   di.stream = stream;
 640   di.index = 0;
 641   di.column = 0;
 642   di.queue = 0;
 643   di.queue_end = 0;
 644   di.free_list = 0;
 645   di.flags = flags;
 646   di.node = t;
 647   di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
 648                              (splay_tree_delete_value_fn) &free);
 649
 650   /* Queue up the first node.  */
 651   queue (&di, t, DUMP_NONE);
 652
 653   /* Until the queue is empty, keep dumping nodes.  */
 654   while (di.queue)
 655     dequeue_and_dump (&di);
 656
 657   /* Now, clean up.  */
 658   for (dq = di.free_list; dq; dq = next_dq)
 659     {
 660       next_dq = dq->next;
 661       free (dq);
 662     }
 663   splay_tree_delete (di.nodes);
 664 }
 665 \f
 666
 667 /* Table of tree dump switches. This must be consistent with the
 668    TREE_DUMP_INDEX enumeration in tree.h */
 669 static struct dump_file_info dump_files[TDI_end] =
 670 {
 671   {NULL, NULL, NULL, 0, 0, 0, 0},
 672   {".tu", "translation-unit", NULL, TDF_TREE, 0, 0, 0},
 673   {".class", "class-hierarchy", NULL, TDF_TREE, 0, 1, 0},
 674   {".original", "tree-original", NULL, TDF_TREE, 0, 2, 0},
 675   {".generic", "tree-generic", NULL, TDF_TREE, 0, 3, 0},
 676   {".nested", "tree-nested", NULL, TDF_TREE, 0, 4, 0},
 677   {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 5, 0},
 678   {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6, 0},
 679   {NULL, "tree-all", NULL, TDF_TREE, 0, 0, 0},
 680   {NULL, "rtl-all", NULL, TDF_RTL, 0, 0, 0},
 681   {NULL, "ipa-all", NULL, TDF_IPA, 0, 0, 0},
 682
 683   { ".cgraph", "ipa-cgraph", NULL,      TDF_IPA, 0,  1, 0},
 684
 685   { ".sibling", "rtl-sibling", NULL,    TDF_RTL, 0,  1, 'i'},
 686   { ".eh", "rtl-eh", NULL,              TDF_RTL, 0,  2, 'h'},
 687   { ".jump", "rtl-jump", NULL,          TDF_RTL, 0,  3, 'j'},
 688   { ".cse", "rtl-cse", NULL,             TDF_RTL, 0,  4, 's'},
 689   { ".gcse", "rtl-gcse", NULL,          TDF_RTL, 0,  5, 'G'},
 690   { ".loop", "rtl-loop", NULL,          TDF_RTL, 0,  6, 'L'},
 691   { ".bypass", "rtl-bypass", NULL,              TDF_RTL, 0,  7, 'G'},
 692   { ".cfg", "rtl-cfg", NULL,                    TDF_RTL, 0,  8, 'f'},
 693   { ".bp", "rtl-bp", NULL,                      TDF_RTL, 0,  9, 'b'},
 694   { ".vpt", "rtl-vpt", NULL,                    TDF_RTL, 0, 10, 'V'},
 695   { ".ce1", "rtl-ce1", NULL,                    TDF_RTL, 0, 11, 'C'},
 696   { ".tracer", "rtl-tracer", NULL,              TDF_RTL, 0, 12, 'T'},
 697   { ".loop2", "rtl-loop2", NULL,                TDF_RTL, 0, 13, 'L'},
 698   { ".web", "rtl-web", NULL,                    TDF_RTL, 0, 14, 'Z'},
 699   { ".cse2", "rtl-cse2", NULL,          TDF_RTL, 0, 15, 't'},
 700   { ".life", "rtl-life", NULL,          TDF_RTL, 0, 16, 'f'},
 701   { ".combine", "rtl-combine", NULL,            TDF_RTL, 0, 17, 'c'},
 702   { ".ce2", "rtl-ce2", NULL,                    TDF_RTL, 0, 18, 'C'},
 703   { ".regmove", "rtl-regmove", NULL,            TDF_RTL, 0, 19, 'N'},
 704   { ".sms", "rtl-sms", NULL,                    TDF_RTL, 0, 20, 'm'},
 705   { ".sched", "rtl-sched", NULL,                TDF_RTL, 0, 21, 'S'},
 706   { ".lreg", "rtl-lreg", NULL,          TDF_RTL, 0, 22, 'l'},
 707   { ".greg", "rtl-greg", NULL,          TDF_RTL, 0, 23, 'g'},
 708   { ".postreload", "rtl-postreload", NULL,      TDF_RTL, 0, 24, 'o'},
 709   { ".gcse2", "rtl-gcse2", NULL,                TDF_RTL, 0, 25, 'J'},
 710   { ".flow2", "rtl-flow2", NULL,                TDF_RTL, 0, 26, 'w'},
 711   { ".peephole2", "rtl-peephole2", NULL,        TDF_RTL, 0, 27, 'z'},
 712   { ".ce3", "rtl-ce3", NULL,                    TDF_RTL, 0, 28, 'E'},
 713   { ".rnreg", "rtl-rnreg", NULL,                TDF_RTL, 0, 29, 'n'},
 714   { ".bbro", "rtl-bbro", NULL,          TDF_RTL, 0, 30, 'B'},
 715   { ".btl", "rtl-btl", NULL,                    TDF_RTL, 0, 31, 'd'},
 716   { ".sched2", "rtl-sched2", NULL,              TDF_RTL, 0, 32, 'R'},
 717   { ".stack", "rtl-stack", NULL,                TDF_RTL, 0, 33, 'k'},
 718   { ".vartrack", "rtl-vartrack", NULL,  TDF_RTL, 0, 34, 'V'},
 719   { ".mach", "rtl-mach", NULL,          TDF_RTL, 0, 35, 'M'},
 720   { ".dbr", "rtl-dbr", NULL,                    TDF_RTL, 0, 36, 'd'}
 721 };
 722
 723 /* Dynamically registered tree dump files and switches.  */
 724 static struct dump_file_info *extra_dump_files;
 725 static size_t extra_dump_files_in_use;
 726 static size_t extra_dump_files_alloced;
 727
 728 /* Define a name->number mapping for a dump flag value.  */
 729 struct dump_option_value_info
 730 {
 731   const char *const name;       /* the name of the value */
 732   const int value;              /* the value of the name */
 733 };
 734
 735 /* Table of dump options. This must be consistent with the TDF_* flags
 736    in tree.h */
 737 static const struct dump_option_value_info dump_options[] =
 738 {
 739   {"address", TDF_ADDRESS},
 740   {"slim", TDF_SLIM},
 741   {"raw", TDF_RAW},
 742   {"details", TDF_DETAILS},
 743   {"stats", TDF_STATS},
 744   {"blocks", TDF_BLOCKS},
 745   {"vops", TDF_VOPS},
 746   {"lineno", TDF_LINENO},
 747   {"uid", TDF_UID},
 748   {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA)},
 749   {NULL, 0}
 750 };
 751
 752 unsigned int
 753 dump_register (const char *suffix, const char *swtch, const char *glob,
 754                int flags, unsigned int num, int letter)
 755 {
 756   size_t this = extra_dump_files_in_use++;
 757
 758   if (this >= extra_dump_files_alloced)
 759     {
 760       if (extra_dump_files_alloced == 0)
 761         extra_dump_files_alloced = 32;
 762       else
 763         extra_dump_files_alloced *= 2;
 764       extra_dump_files = xrealloc (extra_dump_files,
 765                                    sizeof (struct dump_file_info)
 766                                    * extra_dump_files_alloced);
 767     }
 768
 769   memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info));
 770   extra_dump_files[this].suffix = suffix;
 771   extra_dump_files[this].swtch = swtch;
 772   extra_dump_files[this].glob = glob;
 773   extra_dump_files[this].flags = flags;
 774   extra_dump_files[this].num = num;
 775   extra_dump_files[this].letter = letter;
 776
 777   return this + TDI_end;
 778 }
 779
 780
 781 /* Return the dump_file_info for the given phase.  */
 782
 783 struct dump_file_info *
 784 get_dump_file_info (enum tree_dump_index phase)
 785 {
 786   if (phase < TDI_end)
 787     return &dump_files[phase];
 788   else if (phase - TDI_end >= extra_dump_files_in_use)
 789     return NULL;
 790   else
 791     return extra_dump_files + (phase - TDI_end);
 792 }
 793
 794
 795 /* Return the name of the dump file for the given phase.
 796    If the dump is not enabled, returns NULL.  */
 797
 798 char *
 799 get_dump_file_name (enum tree_dump_index phase)
 800 {
 801   char dump_id[7];
 802   struct dump_file_info *dfi;
 803
 804   if (phase == TDI_none)
 805     return NULL;
 806
 807   dfi = get_dump_file_info (phase);
 808   if (dfi->state == 0)
 809     return NULL;
 810
 811   if (dfi->num < 0)
 812     dump_id[0] = '\0';
 813   else
 814     {
 815       const char *template;
 816       if (dfi->flags & TDF_TREE)
 817         template = ".t%02d";
 818       else if (dfi->flags & TDF_IPA)
 819         template = ".i%02d";
 820       else
 821         template = ".%02d";
 822
 823       if (snprintf (dump_id, sizeof (dump_id), template, dfi->num) < 0)
 824         dump_id[0] = '\0';
 825     }
 826
 827   return concat (dump_base_name, dump_id, dfi->suffix, NULL);
 828 }
 829
 830 /* Begin a tree dump for PHASE. Stores any user supplied flag in
 831    *FLAG_PTR and returns a stream to write to. If the dump is not
 832    enabled, returns NULL.
 833    Multiple calls will reopen and append to the dump file.  */
 834
 835 FILE *
 836 dump_begin (enum tree_dump_index phase, int *flag_ptr)
 837 {
 838   char *name;
 839   struct dump_file_info *dfi;
 840   FILE *stream;
 841
 842   if (phase == TDI_none || !dump_enabled_p (phase))
 843     return NULL;
 844
 845   name = get_dump_file_name (phase);
 846   dfi = get_dump_file_info (phase);
 847   stream = fopen (name, dfi->state < 0 ? "w" : "a");
 848   if (!stream)
 849     error ("could not open dump file %qs: %s", name, strerror (errno));
 850   else
 851     dfi->state = 1;
 852   free (name);
 853
 854   if (flag_ptr)
 855     *flag_ptr = dfi->flags;
 856
 857   return stream;
 858 }
 859
 860 /* Returns nonzero if tree dump PHASE is enabled.  */
 861
 862 int
 863 dump_enabled_p (enum tree_dump_index phase)
 864 {
 865   struct dump_file_info *dfi = get_dump_file_info (phase);
 866   return dfi->state;
 867 }
 868
 869 /* Returns nonzero if tree dump PHASE has been initialized.  */
 870
 871 int
 872 dump_initialized_p (enum tree_dump_index phase)
 873 {
 874   struct dump_file_info *dfi = get_dump_file_info (phase);
 875   return dfi->state > 0;
 876 }
 877
 878 /* Returns the switch name of PHASE.  */
 879
 880 const char *
 881 dump_flag_name (enum tree_dump_index phase)
 882 {
 883   struct dump_file_info *dfi = get_dump_file_info (phase);
 884   return dfi->swtch;
 885 }
 886
 887 /* Finish a tree dump for PHASE. STREAM is the stream created by
 888    dump_begin.  */
 889
 890 void
 891 dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
 892 {
 893   fclose (stream);
 894 }
 895
 896 /* Enable all tree dumps.  Return number of enabled tree dumps.  */
 897
 898 static int
 899 dump_enable_all (int flags, int letter)
 900 {
 901   int n = 0;
 902   size_t i;
 903
 904   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 905     if ((dump_files[i].flags & flags)
 906         && (letter == 0 || letter == dump_files[i].letter))
 907       {
 908         dump_files[i].state = -1;
 909         dump_files[i].flags = flags;
 910         n++;
 911       }
 912
 913   for (i = 0; i < extra_dump_files_in_use; i++)
 914     if ((extra_dump_files[i].flags & flags)
 915         && (letter == 0 || letter == extra_dump_files[i].letter))
 916       {
 917         extra_dump_files[i].state = -1;
 918         extra_dump_files[i].flags = flags;
 919         n++;
 920       }
 921
 922   return n;
 923 }
 924
 925 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
 926    relevant details in the dump_files array.  */
 927
 928 static int
 929 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
 930 {
 931   const char *option_value;
 932   const char *ptr;
 933   int flags;
 934
 935   if (doglob && !dfi->glob)
 936     return 0;
 937
 938   option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
 939   if (!option_value)
 940     return 0;
 941
 942   ptr = option_value;
 943   flags = 0;
 944
 945   while (*ptr)
 946     {
 947       const struct dump_option_value_info *option_ptr;
 948       const char *end_ptr;
 949       unsigned length;
 950
 951       while (*ptr == '-')
 952         ptr++;
 953       end_ptr = strchr (ptr, '-');
 954       if (!end_ptr)
 955         end_ptr = ptr + strlen (ptr);
 956       length = end_ptr - ptr;
 957
 958       for (option_ptr = dump_options; option_ptr->name; option_ptr++)
 959         if (strlen (option_ptr->name) == length
 960             && !memcmp (option_ptr->name, ptr, length))
 961           {
 962             flags |= option_ptr->value;
 963             goto found;
 964           }
 965       warning ("ignoring unknown option %q.*s in %<-fdump-%s%>",
 966                length, ptr, dfi->swtch);
 967     found:;
 968       ptr = end_ptr;
 969     }
 970
 971   dfi->state = -1;
 972   dfi->flags |= flags;
 973
 974   /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
 975      known dumps.  */
 976   if (dfi->suffix == NULL)
 977     dump_enable_all (dfi->flags, 0);
 978
 979   return 1;
 980 }
 981
 982 int
 983 dump_switch_p (const char *arg)
 984 {
 985   size_t i;
 986   int any = 0;
 987
 988   for (i = TDI_none + 1; i != TDI_end; i++)
 989     any |= dump_switch_p_1 (arg, &dump_files[i], false);
 990
 991   /* Don't glob if we got a hit already */
 992   if (!any)
 993     for (i = TDI_none + 1; i != TDI_end; i++)
 994       any |= dump_switch_p_1 (arg, &dump_files[i], true);
 995
 996   for (i = 0; i < extra_dump_files_in_use; i++)
 997     any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
 998
 999   if (!any)
1000     for (i = 0; i < extra_dump_files_in_use; i++)
1001       any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
1002
1003
1004   return any;
1005 }
1006
1007 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
1008
1009 void
1010 dump_function (enum tree_dump_index phase, tree fn)
1011 {
1012   FILE *stream;
1013   int flags;
1014
1015   stream = dump_begin (phase, &flags);
1016   if (stream)
1017     {
1018       dump_function_to_file (fn, stream, flags);
1019       dump_end (phase, stream);
1020     }
1021 }
1022
1023 bool
1024 enable_rtl_dump_file (int letter)
1025 {
1026   if (letter == 'a')
1027     letter = 0;
1028
1029   return dump_enable_all (TDF_RTL, letter) > 0;
1030 }
1031
1032