gcc/tree-dump.c

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