gcc/tree-dump.c

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