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 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 "tree-pass.h"
  33 #include "langhooks.h"
  34 #include "tree-iterator.h"
  35
  36 /* If non-NULL, return one past-the-end of the matching SUBPART of
  37    the WHOLE string.  */
  38 #define skip_leading_substring(whole,  part) \
  39    (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
  40
  41 static unsigned int queue (dump_info_p, const_tree, int);
  42 static void dump_index (dump_info_p, unsigned int);
  43 static void dequeue_and_dump (dump_info_p);
  44 static void dump_new_line (dump_info_p);
  45 static void dump_maybe_newline (dump_info_p);
  46
  47 /* Add T to the end of the queue of nodes to dump.  Returns the index
  48    assigned to T.  */
  49
  50 static unsigned int
  51 queue (dump_info_p di, const_tree t, int flags)
  52 {
  53   dump_queue_p dq;
  54   dump_node_info_p dni;
  55   unsigned int index;
  56
  57   /* Assign the next available index to T.  */
  58   index = ++di->index;
  59
  60   /* Obtain a new queue node.  */
  61   if (di->free_list)
  62     {
  63       dq = di->free_list;
  64       di->free_list = dq->next;
  65     }
  66   else
  67     dq = XNEW (struct dump_queue);
  68
  69   /* Create a new entry in the splay-tree.  */
  70   dni = XNEW (struct dump_node_info);
  71   dni->index = index;
  72   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
  73   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
  74                                 (splay_tree_value) dni);
  75
  76   /* Add it to the end of the queue.  */
  77   dq->next = 0;
  78   if (!di->queue_end)
  79     di->queue = dq;
  80   else
  81     di->queue_end->next = dq;
  82   di->queue_end = dq;
  83
  84   /* Return the index.  */
  85   return index;
  86 }
  87
  88 static void
  89 dump_index (dump_info_p di, unsigned int index)
  90 {
  91   fprintf (di->stream, "@%-6u ", index);
  92   di->column += 8;
  93 }
  94
  95 /* If T has not already been output, queue it for subsequent output.
  96    FIELD is a string to print before printing the index.  Then, the
  97    index of T is printed.  */
  98
  99 void
 100 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
 101 {
 102   unsigned int index;
 103   splay_tree_node n;
 104
 105   /* If there's no node, just return.  This makes for fewer checks in
 106      our callers.  */
 107   if (!t)
 108     return;
 109
 110   /* See if we've already queued or dumped this node.  */
 111   n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
 112   if (n)
 113     index = ((dump_node_info_p) n->value)->index;
 114   else
 115     /* If we haven't, add it to the queue.  */
 116     index = queue (di, t, flags);
 117
 118   /* Print the index of the node.  */
 119   dump_maybe_newline (di);
 120   fprintf (di->stream, "%-4s: ", field);
 121   di->column += 6;
 122   dump_index (di, index);
 123 }
 124
 125 /* Dump the type of T.  */
 126
 127 void
 128 queue_and_dump_type (dump_info_p di, const_tree t)
 129 {
 130   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
 131 }
 132
 133 /* Dump column control */
 134 #define SOL_COLUMN 25           /* Start of line column.  */
 135 #define EOL_COLUMN 55           /* End of line column.  */
 136 #define COLUMN_ALIGNMENT 15     /* Alignment.  */
 137
 138 /* Insert a new line in the dump output, and indent to an appropriate
 139    place to start printing more fields.  */
 140
 141 static void
 142 dump_new_line (dump_info_p di)
 143 {
 144   fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
 145   di->column = SOL_COLUMN;
 146 }
 147
 148 /* If necessary, insert a new line.  */
 149
 150 static void
 151 dump_maybe_newline (dump_info_p di)
 152 {
 153   int extra;
 154
 155   /* See if we need a new line.  */
 156   if (di->column > EOL_COLUMN)
 157     dump_new_line (di);
 158   /* See if we need any padding.  */
 159   else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
 160     {
 161       fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
 162       di->column += COLUMN_ALIGNMENT - extra;
 163     }
 164 }
 165
 166 /* Dump pointer PTR using FIELD to identify it.  */
 167
 168 void
 169 dump_pointer (dump_info_p di, const char *field, void *ptr)
 170 {
 171   dump_maybe_newline (di);
 172   fprintf (di->stream, "%-4s: %-8lx ", field, (unsigned long) ptr);
 173   di->column += 15;
 174 }
 175
 176 /* Dump integer I using FIELD to identify it.  */
 177
 178 void
 179 dump_int (dump_info_p di, const char *field, int i)
 180 {
 181   dump_maybe_newline (di);
 182   fprintf (di->stream, "%-4s: %-7d ", field, i);
 183   di->column += 14;
 184 }
 185
 186 /* Dump the floating point value R, using FIELD to identify it.  */
 187
 188 static void
 189 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
 190 {
 191   char buf[32];
 192   real_to_decimal (buf, r, sizeof (buf), 0, true);
 193   dump_maybe_newline (di);
 194   fprintf (di->stream, "%-4s: %s ", field, buf);
 195   di->column += strlen (buf) + 7;
 196 }
 197
 198 /* Dump the fixed-point value F, using FIELD to identify it.  */
 199
 200 static void
 201 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
 202 {
 203   char buf[32];
 204   fixed_to_decimal (buf, f, sizeof (buf));
 205   dump_maybe_newline (di);
 206   fprintf (di->stream, "%-4s: %s ", field, buf);
 207   di->column += strlen (buf) + 7;
 208 }
 209
 210
 211 /* Dump the string S.  */
 212
 213 void
 214 dump_string (dump_info_p di, const char *string)
 215 {
 216   dump_maybe_newline (di);
 217   fprintf (di->stream, "%-13s ", string);
 218   if (strlen (string) > 13)
 219     di->column += strlen (string) + 1;
 220   else
 221     di->column += 14;
 222 }
 223
 224 /* Dump the string field S.  */
 225
 226 void
 227 dump_string_field (dump_info_p di, const char *field, const char *string)
 228 {
 229   dump_maybe_newline (di);
 230   fprintf (di->stream, "%-4s: %-7s ", field, string);
 231   if (strlen (string) > 7)
 232     di->column += 6 + strlen (string) + 1;
 233   else
 234     di->column += 14;
 235 }
 236
 237 /* Dump the next node in the queue.  */
 238
 239 static void
 240 dequeue_and_dump (dump_info_p di)
 241 {
 242   dump_queue_p dq;
 243   splay_tree_node stn;
 244   dump_node_info_p dni;
 245   tree t;
 246   unsigned int index;
 247   enum tree_code code;
 248   enum tree_code_class code_class;
 249   const char* code_name;
 250
 251   /* Get the next node from the queue.  */
 252   dq = di->queue;
 253   stn = dq->node;
 254   t = (tree) stn->key;
 255   dni = (dump_node_info_p) stn->value;
 256   index = dni->index;
 257
 258   /* Remove the node from the queue, and put it on the free list.  */
 259   di->queue = dq->next;
 260   if (!di->queue)
 261     di->queue_end = 0;
 262   dq->next = di->free_list;
 263   di->free_list = dq;
 264
 265   /* Print the node index.  */
 266   dump_index (di, index);
 267   /* And the type of node this is.  */
 268   if (dni->binfo_p)
 269     code_name = "binfo";
 270   else
 271     code_name = tree_code_name[(int) TREE_CODE (t)];
 272   fprintf (di->stream, "%-16s ", code_name);
 273   di->column = 25;
 274
 275   /* Figure out what kind of node this is.  */
 276   code = TREE_CODE (t);
 277   code_class = TREE_CODE_CLASS (code);
 278
 279   /* Although BINFOs are TREE_VECs, we dump them specially so as to be
 280      more informative.  */
 281   if (dni->binfo_p)
 282     {
 283       unsigned ix;
 284       tree base;
 285       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
 286
 287       dump_child ("type", BINFO_TYPE (t));
 288
 289       if (BINFO_VIRTUAL_P (t))
 290         dump_string_field (di, "spec", "virt");
 291
 292       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
 293       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
 294         {
 295           tree access = (accesses ? VEC_index (tree, accesses, ix)
 296                          : access_public_node);
 297           const char *string = NULL;
 298
 299           if (access == access_public_node)
 300             string = "pub";
 301           else if (access == access_protected_node)
 302             string = "prot";
 303           else if (access == access_private_node)
 304             string = "priv";
 305           else
 306             gcc_unreachable ();
 307
 308           dump_string_field (di, "accs", string);
 309           queue_and_dump_index (di, "binf", base, DUMP_BINFO);
 310         }
 311
 312       goto done;
 313     }
 314
 315   /* We can knock off a bunch of expression nodes in exactly the same
 316      way.  */
 317   if (IS_EXPR_CODE_CLASS (code_class))
 318     {
 319       /* If we're dumping children, dump them now.  */
 320       queue_and_dump_type (di, t);
 321
 322       switch (code_class)
 323         {
 324         case tcc_unary:
 325           dump_child ("op 0", TREE_OPERAND (t, 0));
 326           break;
 327
 328         case tcc_binary:
 329         case tcc_comparison:
 330           dump_child ("op 0", TREE_OPERAND (t, 0));
 331           dump_child ("op 1", TREE_OPERAND (t, 1));
 332           break;
 333
 334         case tcc_expression:
 335         case tcc_reference:
 336         case tcc_statement:
 337         case tcc_vl_exp:
 338           /* These nodes are handled explicitly below.  */
 339           break;
 340
 341         default:
 342           gcc_unreachable ();
 343         }
 344     }
 345   else if (DECL_P (t))
 346     {
 347       expanded_location xloc;
 348       /* All declarations have names.  */
 349       if (DECL_NAME (t))
 350         dump_child ("name", DECL_NAME (t));
 351       if (DECL_ASSEMBLER_NAME_SET_P (t)
 352           && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
 353         dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
 354       if (DECL_ABSTRACT_ORIGIN (t))
 355         dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
 356       /* And types.  */
 357       queue_and_dump_type (di, t);
 358       dump_child ("scpe", DECL_CONTEXT (t));
 359       /* And a source position.  */
 360       xloc = expand_location (DECL_SOURCE_LOCATION (t));
 361       if (xloc.file)
 362         {
 363           const char *filename = lbasename (xloc.file);
 364
 365           dump_maybe_newline (di);
 366           fprintf (di->stream, "srcp: %s:%-6d ", filename,
 367                    xloc.line);
 368           di->column += 6 + strlen (filename) + 8;
 369         }
 370       /* And any declaration can be compiler-generated.  */
 371       if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
 372           && DECL_ARTIFICIAL (t))
 373         dump_string_field (di, "note", "artificial");
 374       if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
 375         dump_child ("chain", DECL_CHAIN (t));
 376     }
 377   else if (code_class == tcc_type)
 378     {
 379       /* All types have qualifiers.  */
 380       int quals = lang_hooks.tree_dump.type_quals (t);
 381
 382       if (quals != TYPE_UNQUALIFIED)
 383         {
 384           fprintf (di->stream, "qual: %c%c%c     ",
 385                    (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
 386                    (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
 387                    (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
 388           di->column += 14;
 389         }
 390
 391       /* All types have associated declarations.  */
 392       dump_child ("name", TYPE_NAME (t));
 393
 394       /* All types have a main variant.  */
 395       if (TYPE_MAIN_VARIANT (t) != t)
 396         dump_child ("unql", TYPE_MAIN_VARIANT (t));
 397
 398       /* And sizes.  */
 399       dump_child ("size", TYPE_SIZE (t));
 400
 401       /* All types have alignments.  */
 402       dump_int (di, "algn", TYPE_ALIGN (t));
 403     }
 404   else if (code_class == tcc_constant)
 405     /* All constants can have types.  */
 406     queue_and_dump_type (di, t);
 407
 408   /* Give the language-specific code a chance to print something.  If
 409      it's completely taken care of things, don't bother printing
 410      anything more ourselves.  */
 411   if (lang_hooks.tree_dump.dump_tree (di, t))
 412     goto done;
 413
 414   /* Now handle the various kinds of nodes.  */
 415   switch (code)
 416     {
 417       int i;
 418
 419     case IDENTIFIER_NODE:
 420       dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
 421       dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
 422       break;
 423
 424     case TREE_LIST:
 425       dump_child ("purp", TREE_PURPOSE (t));
 426       dump_child ("valu", TREE_VALUE (t));
 427       dump_child ("chan", TREE_CHAIN (t));
 428       break;
 429
 430     case STATEMENT_LIST:
 431       {
 432         tree_stmt_iterator it;
 433         for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
 434           {
 435             char buffer[32];
 436             sprintf (buffer, "%u", i);
 437             dump_child (buffer, tsi_stmt (it));
 438           }
 439       }
 440       break;
 441
 442     case TREE_VEC:
 443       dump_int (di, "lngt", TREE_VEC_LENGTH (t));
 444       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
 445         {
 446           char buffer[32];
 447           sprintf (buffer, "%u", i);
 448           dump_child (buffer, TREE_VEC_ELT (t, i));
 449         }
 450       break;
 451
 452     case INTEGER_TYPE:
 453     case ENUMERAL_TYPE:
 454       dump_int (di, "prec", TYPE_PRECISION (t));
 455       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 456       dump_child ("min", TYPE_MIN_VALUE (t));
 457       dump_child ("max", TYPE_MAX_VALUE (t));
 458
 459       if (code == ENUMERAL_TYPE)
 460         dump_child ("csts", TYPE_VALUES (t));
 461       break;
 462
 463     case REAL_TYPE:
 464       dump_int (di, "prec", TYPE_PRECISION (t));
 465       break;
 466
 467     case FIXED_POINT_TYPE:
 468       dump_int (di, "prec", TYPE_PRECISION (t));
 469       dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
 470       dump_string_field (di, "saturating",
 471                          TYPE_SATURATING (t) ? "saturating": "non-saturating");
 472       break;
 473
 474     case POINTER_TYPE:
 475       dump_child ("ptd", TREE_TYPE (t));
 476       break;
 477
 478     case REFERENCE_TYPE:
 479       dump_child ("refd", TREE_TYPE (t));
 480       break;
 481
 482     case METHOD_TYPE:
 483       dump_child ("clas", TYPE_METHOD_BASETYPE (t));
 484       /* Fall through.  */
 485
 486     case FUNCTION_TYPE:
 487       dump_child ("retn", TREE_TYPE (t));
 488       dump_child ("prms", TYPE_ARG_TYPES (t));
 489       break;
 490
 491     case ARRAY_TYPE:
 492       dump_child ("elts", TREE_TYPE (t));
 493       dump_child ("domn", TYPE_DOMAIN (t));
 494       break;
 495
 496     case RECORD_TYPE:
 497     case UNION_TYPE:
 498       if (TREE_CODE (t) == RECORD_TYPE)
 499         dump_string_field (di, "tag", "struct");
 500       else
 501         dump_string_field (di, "tag", "union");
 502
 503       dump_child ("flds", TYPE_FIELDS (t));
 504       dump_child ("fncs", TYPE_METHODS (t));
 505       queue_and_dump_index (di, "binf", TYPE_BINFO (t),
 506                             DUMP_BINFO);
 507       break;
 508
 509     case CONST_DECL:
 510       dump_child ("cnst", DECL_INITIAL (t));
 511       break;
 512
 513     case DEBUG_EXPR_DECL:
 514       dump_int (di, "-uid", DEBUG_TEMP_UID (t));
 515       /* Fall through.  */
 516
 517     case VAR_DECL:
 518     case PARM_DECL:
 519     case FIELD_DECL:
 520     case RESULT_DECL:
 521       if (TREE_CODE (t) == PARM_DECL)
 522         dump_child ("argt", DECL_ARG_TYPE (t));
 523       else
 524         dump_child ("init", DECL_INITIAL (t));
 525       dump_child ("size", DECL_SIZE (t));
 526       dump_int (di, "algn", DECL_ALIGN (t));
 527
 528       if (TREE_CODE (t) == FIELD_DECL)
 529         {
 530           if (DECL_FIELD_OFFSET (t))
 531             dump_child ("bpos", bit_position (t));
 532         }
 533       else if (TREE_CODE (t) == VAR_DECL
 534                || TREE_CODE (t) == PARM_DECL)
 535         {
 536           dump_int (di, "used", TREE_USED (t));
 537           if (DECL_REGISTER (t))
 538             dump_string_field (di, "spec", "register");
 539         }
 540       break;
 541
 542     case FUNCTION_DECL:
 543       dump_child ("args", DECL_ARGUMENTS (t));
 544       if (DECL_EXTERNAL (t))
 545         dump_string_field (di, "body", "undefined");
 546       if (TREE_PUBLIC (t))
 547         dump_string_field (di, "link", "extern");
 548       else
 549         dump_string_field (di, "link", "static");
 550       if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
 551         dump_child ("body", DECL_SAVED_TREE (t));
 552       break;
 553
 554     case INTEGER_CST:
 555       if (TREE_INT_CST_HIGH (t))
 556         dump_int (di, "high", TREE_INT_CST_HIGH (t));
 557       dump_int (di, "low", TREE_INT_CST_LOW (t));
 558       break;
 559
 560     case STRING_CST:
 561       fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
 562       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
 563       break;
 564
 565     case REAL_CST:
 566       dump_real (di, "valu", TREE_REAL_CST_PTR (t));
 567       break;
 568
 569     case FIXED_CST:
 570       dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
 571       break;
 572
 573     case TRUTH_NOT_EXPR:
 574     case ADDR_EXPR:
 575     case INDIRECT_REF:
 576     case CLEANUP_POINT_EXPR:
 577     case SAVE_EXPR:
 578     case REALPART_EXPR:
 579     case IMAGPART_EXPR:
 580       /* These nodes are unary, but do not have code class `1'.  */
 581       dump_child ("op 0", TREE_OPERAND (t, 0));
 582       break;
 583
 584     case TRUTH_ANDIF_EXPR:
 585     case TRUTH_ORIF_EXPR:
 586     case INIT_EXPR:
 587     case MODIFY_EXPR:
 588     case COMPOUND_EXPR:
 589     case PREDECREMENT_EXPR:
 590     case PREINCREMENT_EXPR:
 591     case POSTDECREMENT_EXPR:
 592     case POSTINCREMENT_EXPR:
 593       /* These nodes are binary, but do not have code class `2'.  */
 594       dump_child ("op 0", TREE_OPERAND (t, 0));
 595       dump_child ("op 1", TREE_OPERAND (t, 1));
 596       break;
 597
 598     case COMPONENT_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   {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
 827             | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC | TDF_VERBOSE
 828             | TDF_RHS_ONLY | TDF_NOUID | TDF_ENUMERATE_LOCALS)},
 829   {NULL, 0}
 830 };
 831
 832 unsigned int
 833 dump_register (const char *suffix, const char *swtch, const char *glob,
 834                int flags)
 835 {
 836   static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
 837   int num = next_dump++;
 838
 839   size_t count = extra_dump_files_in_use++;
 840
 841   if (count >= extra_dump_files_alloced)
 842     {
 843       if (extra_dump_files_alloced == 0)
 844         extra_dump_files_alloced = 32;
 845       else
 846         extra_dump_files_alloced *= 2;
 847       extra_dump_files = XRESIZEVEC (struct dump_file_info,
 848                                      extra_dump_files,
 849                                      extra_dump_files_alloced);
 850     }
 851
 852   memset (&extra_dump_files[count], 0, sizeof (struct dump_file_info));
 853   extra_dump_files[count].suffix = suffix;
 854   extra_dump_files[count].swtch = swtch;
 855   extra_dump_files[count].glob = glob;
 856   extra_dump_files[count].flags = flags;
 857   extra_dump_files[count].num = num;
 858
 859   return count + TDI_end;
 860 }
 861
 862
 863 /* Return the dump_file_info for the given phase.  */
 864
 865 struct dump_file_info *
 866 get_dump_file_info (int phase)
 867 {
 868   if (phase < TDI_end)
 869     return &dump_files[phase];
 870   else if ((size_t) (phase - TDI_end) >= extra_dump_files_in_use)
 871     return NULL;
 872   else
 873     return extra_dump_files + (phase - TDI_end);
 874 }
 875
 876
 877 /* Return the name of the dump file for the given phase.
 878    If the dump is not enabled, returns NULL.  */
 879
 880 char *
 881 get_dump_file_name (int phase)
 882 {
 883   char dump_id[10];
 884   struct dump_file_info *dfi;
 885
 886   if (phase == TDI_none)
 887     return NULL;
 888
 889   dfi = get_dump_file_info (phase);
 890   if (dfi->state == 0)
 891     return NULL;
 892
 893   if (dfi->num < 0)
 894     dump_id[0] = '\0';
 895   else
 896     {
 897       char suffix;
 898       if (dfi->flags & TDF_TREE)
 899         suffix = 't';
 900       else if (dfi->flags & TDF_IPA)
 901         suffix = 'i';
 902       else
 903         suffix = 'r';
 904
 905       if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
 906         dump_id[0] = '\0';
 907     }
 908
 909   return concat (dump_base_name, dump_id, dfi->suffix, NULL);
 910 }
 911
 912 /* Begin a tree dump for PHASE. Stores any user supplied flag in
 913    *FLAG_PTR and returns a stream to write to. If the dump is not
 914    enabled, returns NULL.
 915    Multiple calls will reopen and append to the dump file.  */
 916
 917 FILE *
 918 dump_begin (int phase, int *flag_ptr)
 919 {
 920   char *name;
 921   struct dump_file_info *dfi;
 922   FILE *stream;
 923
 924   if (phase == TDI_none || !dump_enabled_p (phase))
 925     return NULL;
 926
 927   name = get_dump_file_name (phase);
 928   dfi = get_dump_file_info (phase);
 929   stream = fopen (name, dfi->state < 0 ? "w" : "a");
 930   if (!stream)
 931     error ("could not open dump file %qs: %m", name);
 932   else
 933     dfi->state = 1;
 934   free (name);
 935
 936   if (flag_ptr)
 937     *flag_ptr = dfi->flags;
 938
 939   return stream;
 940 }
 941
 942 /* Returns nonzero if tree dump PHASE is enabled.  If PHASE is
 943    TDI_tree_all, return nonzero if any dump is enabled.  */
 944
 945 int
 946 dump_enabled_p (int phase)
 947 {
 948   if (phase == TDI_tree_all)
 949     {
 950       size_t i;
 951       for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 952         if (dump_files[i].state)
 953           return 1;
 954       for (i = 0; i < extra_dump_files_in_use; i++)
 955         if (extra_dump_files[i].state)
 956           return 1;
 957       return 0;
 958     }
 959   else
 960     {
 961       struct dump_file_info *dfi = get_dump_file_info (phase);
 962       return dfi->state;
 963     }
 964 }
 965
 966 /* Returns nonzero if tree dump PHASE has been initialized.  */
 967
 968 int
 969 dump_initialized_p (int phase)
 970 {
 971   struct dump_file_info *dfi = get_dump_file_info (phase);
 972   return dfi->state > 0;
 973 }
 974
 975 /* Returns the switch name of PHASE.  */
 976
 977 const char *
 978 dump_flag_name (int phase)
 979 {
 980   struct dump_file_info *dfi = get_dump_file_info (phase);
 981   return dfi->swtch;
 982 }
 983
 984 /* Finish a tree dump for PHASE. STREAM is the stream created by
 985    dump_begin.  */
 986
 987 void
 988 dump_end (int phase ATTRIBUTE_UNUSED, FILE *stream)
 989 {
 990   fclose (stream);
 991 }
 992
 993 /* Enable all tree dumps.  Return number of enabled tree dumps.  */
 994
 995 static int
 996 dump_enable_all (int flags)
 997 {
 998   int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));
 999   int n = 0;
1000   size_t i;
1001
1002   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
1003     if ((dump_files[i].flags & ir_dump_type))
1004       {
1005         dump_files[i].state = -1;
1006         dump_files[i].flags |= flags;
1007         n++;
1008       }
1009
1010   for (i = 0; i < extra_dump_files_in_use; i++)
1011     if ((extra_dump_files[i].flags & ir_dump_type))
1012       {
1013         extra_dump_files[i].state = -1;
1014         extra_dump_files[i].flags |= flags;
1015         n++;
1016       }
1017
1018   return n;
1019 }
1020
1021 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1022    relevant details in the dump_files array.  */
1023
1024 static int
1025 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
1026 {
1027   const char *option_value;
1028   const char *ptr;
1029   int flags;
1030
1031   if (doglob && !dfi->glob)
1032     return 0;
1033
1034   option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
1035   if (!option_value)
1036     return 0;
1037
1038   if (*option_value && *option_value != '-')
1039     return 0;
1040
1041   ptr = option_value;
1042   flags = 0;
1043
1044   while (*ptr)
1045     {
1046       const struct dump_option_value_info *option_ptr;
1047       const char *end_ptr;
1048       unsigned length;
1049
1050       while (*ptr == '-')
1051         ptr++;
1052       end_ptr = strchr (ptr, '-');
1053       if (!end_ptr)
1054         end_ptr = ptr + strlen (ptr);
1055       length = end_ptr - ptr;
1056
1057       for (option_ptr = dump_options; option_ptr->name; option_ptr++)
1058         if (strlen (option_ptr->name) == length
1059             && !memcmp (option_ptr->name, ptr, length))
1060           {
1061             flags |= option_ptr->value;
1062             goto found;
1063           }
1064       warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1065                length, ptr, dfi->swtch);
1066     found:;
1067       ptr = end_ptr;
1068     }
1069
1070   dfi->state = -1;
1071   dfi->flags |= flags;
1072
1073   /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1074      known dumps.  */
1075   if (dfi->suffix == NULL)
1076     dump_enable_all (dfi->flags);
1077
1078   return 1;
1079 }
1080
1081 int
1082 dump_switch_p (const char *arg)
1083 {
1084   size_t i;
1085   int any = 0;
1086
1087   for (i = TDI_none + 1; i != TDI_end; i++)
1088     any |= dump_switch_p_1 (arg, &dump_files[i], false);
1089
1090   /* Don't glob if we got a hit already */
1091   if (!any)
1092     for (i = TDI_none + 1; i != TDI_end; i++)
1093       any |= dump_switch_p_1 (arg, &dump_files[i], true);
1094
1095   for (i = 0; i < extra_dump_files_in_use; i++)
1096     any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
1097
1098   if (!any)
1099     for (i = 0; i < extra_dump_files_in_use; i++)
1100       any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
1101
1102
1103   return any;
1104 }
1105
1106 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
1107
1108 void
1109 dump_function (int phase, tree fn)
1110 {
1111   FILE *stream;
1112   int flags;
1113
1114   stream = dump_begin (phase, &flags);
1115   if (stream)
1116     {
1117       dump_function_to_file (fn, stream, flags);
1118       dump_end (phase, stream);
1119     }
1120 }
1121
1122 bool
1123 enable_rtl_dump_file (void)
1124 {
1125   return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS) > 0;
1126 }