gcc/print-tree.c

   1 /* Prints out tree in human readable form - GCC
   2    Copyright (C) 1990-2019 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "cgraph.h"
  27 #include "diagnostic.h"
  28 #include "varasm.h"
  29 #include "print-rtl.h"
  30 #include "stor-layout.h"
  31 #include "langhooks.h"
  32 #include "tree-iterator.h"
  33 #include "gimple-pretty-print.h" /* FIXME */
  34 #include "tree-cfg.h"
  35 #include "dumpfile.h"
  36 #include "print-tree.h"
  37
  38 /* Define the hash table of nodes already seen.
  39    Such nodes are not repeated; brief cross-references are used.  */
  40
  41 #define HASH_SIZE 37
  42
  43 static hash_set<tree> *table = NULL;
  44
  45 /* Print PREFIX and ADDR to FILE.  */
  46 void
  47 dump_addr (FILE *file, const char *prefix, const void *addr)
  48 {
  49   if (flag_dump_noaddr || flag_dump_unnumbered)
  50     fprintf (file, "%s#", prefix);
  51   else
  52     fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr);
  53 }
  54
  55 /* Print to FILE a NODE representing a REAL_CST constant, including
  56    Infinity and NaN.  Be verbose when BFRIEF is false.  */
  57
  58 static void
  59 print_real_cst (FILE *file, const_tree node, bool brief)
  60 {
  61   if (TREE_OVERFLOW (node))
  62     fprintf (file, " overflow");
  63
  64   REAL_VALUE_TYPE d = TREE_REAL_CST (node);
  65   if (REAL_VALUE_ISINF (d))
  66     fprintf (file,  REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
  67   else if (REAL_VALUE_ISNAN (d))
  68     {
  69       /* Print a NaN in the format [-][Q]NaN[(significand[exponent])]
  70          where significand is a hexadecimal string that starts with
  71          the 0x prefix followed by 0 if the number is not canonical
  72          and a non-zero digit if it is, and exponent is decimal.  */
  73       unsigned start = 0;
  74       const char *psig = (const char *) d.sig;
  75       for (unsigned i = 0; i != sizeof d.sig; ++i)
  76         if (psig[i])
  77           {
  78             start = i;
  79             break;
  80           }
  81
  82       fprintf (file, " %s%sNaN", d.sign ? "-" : "",
  83                d.signalling ? "S" : "Q");
  84
  85       if (brief)
  86         return;
  87
  88       if (start)
  89         fprintf (file, "(0x%s", d.canonical ? "" : "0");
  90       else if (d.uexp)
  91         fprintf (file, "(%s", d.canonical ? "" : "0");
  92       else if (!d.canonical)
  93         {
  94           fprintf (file, "(0)");
  95           return;
  96         }
  97
  98       if (psig[start])
  99         {
 100           for (unsigned i = start; i != sizeof d.sig; ++i)
 101             if (i == start)
 102               fprintf (file, "%x", psig[i]);
 103             else
 104               fprintf (file, "%02x", psig[i]);
 105         }
 106
 107       if (d.uexp)
 108         fprintf (file, "%se%u)", psig[start] ? "," : "", d.uexp);
 109       else if (psig[start])
 110         fputc (')', file);
 111     }
 112   else
 113     {
 114       char string[64];
 115       real_to_decimal (string, &d, sizeof (string), 0, 1);
 116       fprintf (file, " %s", string);
 117     }
 118 }
 119
 120 /* Print a node in brief fashion, with just the code, address and name.  */
 121
 122 void
 123 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
 124 {
 125   enum tree_code_class tclass;
 126
 127   if (node == 0)
 128     return;
 129
 130   tclass = TREE_CODE_CLASS (TREE_CODE (node));
 131
 132   /* Always print the slot this node is in, and its code, address and
 133      name if any.  */
 134   if (indent > 0)
 135     fprintf (file, " ");
 136   fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
 137   dump_addr (file, " ", node);
 138
 139   if (tclass == tcc_declaration)
 140     {
 141       if (DECL_NAME (node))
 142         fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
 143       else if (TREE_CODE (node) == LABEL_DECL
 144                && LABEL_DECL_UID (node) != -1)
 145         {
 146           if (dump_flags & TDF_NOUID)
 147             fprintf (file, " L.xxxx");
 148           else
 149             fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
 150         }
 151       else
 152         {
 153           if (dump_flags & TDF_NOUID)
 154             fprintf (file, " %c.xxxx",
 155                      TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
 156           else
 157             fprintf (file, " %c.%u",
 158                      TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
 159                      DECL_UID (node));
 160         }
 161     }
 162   else if (tclass == tcc_type)
 163     {
 164       if (TYPE_NAME (node))
 165         {
 166           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 167             fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
 168           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 169                    && DECL_NAME (TYPE_NAME (node)))
 170             fprintf (file, " %s",
 171                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
 172         }
 173       if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
 174         fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
 175     }
 176   if (TREE_CODE (node) == IDENTIFIER_NODE)
 177     fprintf (file, " %s", IDENTIFIER_POINTER (node));
 178
 179   /* We might as well always print the value of an integer or real.  */
 180   if (TREE_CODE (node) == INTEGER_CST)
 181     {
 182       if (TREE_OVERFLOW (node))
 183         fprintf (file, " overflow");
 184
 185       fprintf (file, " ");
 186       print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
 187     }
 188   if (TREE_CODE (node) == REAL_CST)
 189     print_real_cst (file, node, true);
 190   if (TREE_CODE (node) == FIXED_CST)
 191     {
 192       FIXED_VALUE_TYPE f;
 193       char string[60];
 194
 195       if (TREE_OVERFLOW (node))
 196         fprintf (file, " overflow");
 197
 198       f = TREE_FIXED_CST (node);
 199       fixed_to_decimal (string, &f, sizeof (string));
 200       fprintf (file, " %s", string);
 201     }
 202
 203   fprintf (file, ">");
 204 }
 205
 206 void
 207 indent_to (FILE *file, int column)
 208 {
 209   int i;
 210
 211   /* Since this is the long way, indent to desired column.  */
 212   if (column > 0)
 213     fprintf (file, "\n");
 214   for (i = 0; i < column; i++)
 215     fprintf (file, " ");
 216 }
 217 \f
 218 /* Print the node NODE in full on file FILE, preceded by PREFIX,
 219    starting in column INDENT.  */
 220
 221 void
 222 print_node (FILE *file, const char *prefix, tree node, int indent,
 223             bool brief_for_visited)
 224 {
 225   machine_mode mode;
 226   enum tree_code_class tclass;
 227   int len;
 228   int i;
 229   expanded_location xloc;
 230   enum tree_code code;
 231
 232   if (node == 0)
 233     return;
 234
 235   code = TREE_CODE (node);
 236
 237   /* It is unsafe to look at any other fields of a node with ERROR_MARK or
 238      invalid code.  */
 239   if (code == ERROR_MARK || code >= MAX_TREE_CODES)
 240     {
 241       print_node_brief (file, prefix, node, indent);
 242       return;
 243     }
 244
 245   tclass = TREE_CODE_CLASS (code);
 246
 247   /* Don't get too deep in nesting.  If the user wants to see deeper,
 248      it is easy to use the address of a lowest-level node
 249      as an argument in another call to debug_tree.  */
 250
 251   if (indent > 24)
 252     {
 253       print_node_brief (file, prefix, node, indent);
 254       return;
 255     }
 256
 257   if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
 258     {
 259       print_node_brief (file, prefix, node, indent);
 260       return;
 261     }
 262
 263   /* Allow this function to be called if the table is not there.  */
 264   if (table)
 265     {
 266       /* If node is in the table, just mention its address.  */
 267       if (table->contains (node) && brief_for_visited)
 268         {
 269           print_node_brief (file, prefix, node, indent);
 270           return;
 271         }
 272
 273       table->add (node);
 274     }
 275
 276   /* Indent to the specified column, since this is the long form.  */
 277   indent_to (file, indent);
 278
 279   /* Print the slot this node is in, and its code, and address.  */
 280   fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
 281   dump_addr (file, " ", node);
 282
 283   /* Print the name, if any.  */
 284   if (tclass == tcc_declaration)
 285     {
 286       if (DECL_NAME (node))
 287         fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
 288       else if (code == LABEL_DECL
 289                && LABEL_DECL_UID (node) != -1)
 290         {
 291           if (dump_flags & TDF_NOUID)
 292             fprintf (file, " L.xxxx");
 293           else
 294             fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
 295         }
 296       else
 297         {
 298           if (dump_flags & TDF_NOUID)
 299             fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
 300           else
 301             fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
 302                      DECL_UID (node));
 303         }
 304     }
 305   else if (tclass == tcc_type)
 306     {
 307       if (TYPE_NAME (node))
 308         {
 309           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 310             fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
 311           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 312                    && DECL_NAME (TYPE_NAME (node)))
 313             fprintf (file, " %s",
 314                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
 315         }
 316     }
 317   if (code == IDENTIFIER_NODE)
 318     fprintf (file, " %s", IDENTIFIER_POINTER (node));
 319
 320   if (code == INTEGER_CST)
 321     {
 322       if (indent <= 4)
 323         print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
 324     }
 325   else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 326     {
 327       print_node (file, "type", TREE_TYPE (node), indent + 4);
 328       if (TREE_TYPE (node))
 329         indent_to (file, indent + 3);
 330     }
 331
 332   if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
 333     fputs (" side-effects", file);
 334
 335   if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
 336     fputs (" readonly", file);
 337   if (TYPE_P (node) && TYPE_ATOMIC (node))
 338     fputs (" atomic", file);
 339   if (!TYPE_P (node) && TREE_CONSTANT (node))
 340     fputs (" constant", file);
 341   else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
 342     fputs (" sizes-gimplified", file);
 343
 344   if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
 345     fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
 346
 347   if (TREE_ADDRESSABLE (node))
 348     fputs (" addressable", file);
 349   if (TREE_THIS_VOLATILE (node))
 350     fputs (" volatile", file);
 351   if (TREE_ASM_WRITTEN (node))
 352     fputs (" asm_written", file);
 353   if (TREE_USED (node))
 354     fputs (" used", file);
 355   if (TREE_NOTHROW (node))
 356     fputs (" nothrow", file);
 357   if (TREE_PUBLIC (node))
 358     fputs (" public", file);
 359   if (TREE_PRIVATE (node))
 360     fputs (" private", file);
 361   if (TREE_PROTECTED (node))
 362     fputs (" protected", file);
 363   if (TREE_STATIC (node))
 364     fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
 365   if (TREE_DEPRECATED (node))
 366     fputs (" deprecated", file);
 367   if (TREE_VISITED (node))
 368     fputs (" visited", file);
 369
 370   if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
 371     {
 372       if (TREE_LANG_FLAG_0 (node))
 373         fputs (" tree_0", file);
 374       if (TREE_LANG_FLAG_1 (node))
 375         fputs (" tree_1", file);
 376       if (TREE_LANG_FLAG_2 (node))
 377         fputs (" tree_2", file);
 378       if (TREE_LANG_FLAG_3 (node))
 379         fputs (" tree_3", file);
 380       if (TREE_LANG_FLAG_4 (node))
 381         fputs (" tree_4", file);
 382       if (TREE_LANG_FLAG_5 (node))
 383         fputs (" tree_5", file);
 384       if (TREE_LANG_FLAG_6 (node))
 385         fputs (" tree_6", file);
 386     }
 387
 388   /* DECL_ nodes have additional attributes.  */
 389
 390   switch (TREE_CODE_CLASS (code))
 391     {
 392     case tcc_declaration:
 393       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 394         {
 395           if (DECL_UNSIGNED (node))
 396             fputs (" unsigned", file);
 397           if (DECL_IGNORED_P (node))
 398             fputs (" ignored", file);
 399           if (DECL_ABSTRACT_P (node))
 400             fputs (" abstract", file);
 401           if (DECL_EXTERNAL (node))
 402             fputs (" external", file);
 403           if (DECL_NONLOCAL (node))
 404             fputs (" nonlocal", file);
 405         }
 406       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 407         {
 408           if (DECL_WEAK (node))
 409             fputs (" weak", file);
 410           if (DECL_IN_SYSTEM_HEADER (node))
 411             fputs (" in_system_header", file);
 412         }
 413       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
 414           && code != LABEL_DECL
 415           && code != FUNCTION_DECL
 416           && DECL_REGISTER (node))
 417         fputs (" regdecl", file);
 418
 419       if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
 420         fputs (" suppress-debug", file);
 421
 422       if (code == FUNCTION_DECL
 423           && DECL_FUNCTION_SPECIFIC_TARGET (node))
 424         fputs (" function-specific-target", file);
 425       if (code == FUNCTION_DECL
 426           && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
 427         fputs (" function-specific-opt", file);
 428       if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
 429         fputs (" autoinline", file);
 430       if (code == FUNCTION_DECL && DECL_UNINLINABLE (node))
 431         fputs (" uninlinable", file);
 432       if (code == FUNCTION_DECL && fndecl_built_in_p (node))
 433         fputs (" built-in", file);
 434       if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
 435         fputs (" static-chain", file);
 436       if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
 437         fputs (" tm-clone", file);
 438
 439       if (code == FIELD_DECL && DECL_PACKED (node))
 440         fputs (" packed", file);
 441       if (code == FIELD_DECL && DECL_BIT_FIELD (node))
 442         fputs (" bit-field", file);
 443       if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
 444         fputs (" nonaddressable", file);
 445
 446       if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
 447         fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
 448
 449       if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
 450         fputs (" in-text-section", file);
 451       if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
 452         fputs (" in-constant-pool", file);
 453       if (code == VAR_DECL && DECL_COMMON (node))
 454         fputs (" common", file);
 455       if ((code == VAR_DECL || code == PARM_DECL) && DECL_READ_P (node))
 456         fputs (" read", file);
 457       if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
 458         {
 459           fputs (" ", file);
 460           fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
 461         }
 462
 463       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 464         {
 465           if (DECL_VIRTUAL_P (node))
 466             fputs (" virtual", file);
 467           if (DECL_PRESERVE_P (node))
 468             fputs (" preserve", file);
 469           if (DECL_LANG_FLAG_0 (node))
 470             fputs (" decl_0", file);
 471           if (DECL_LANG_FLAG_1 (node))
 472             fputs (" decl_1", file);
 473           if (DECL_LANG_FLAG_2 (node))
 474             fputs (" decl_2", file);
 475           if (DECL_LANG_FLAG_3 (node))
 476             fputs (" decl_3", file);
 477           if (DECL_LANG_FLAG_4 (node))
 478             fputs (" decl_4", file);
 479           if (DECL_LANG_FLAG_5 (node))
 480             fputs (" decl_5", file);
 481           if (DECL_LANG_FLAG_6 (node))
 482             fputs (" decl_6", file);
 483           if (DECL_LANG_FLAG_7 (node))
 484             fputs (" decl_7", file);
 485
 486           mode = DECL_MODE (node);
 487           fprintf (file, " %s", GET_MODE_NAME (mode));
 488         }
 489
 490       if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
 491           && DECL_BY_REFERENCE (node))
 492         fputs (" passed-by-reference", file);
 493
 494       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)  && DECL_DEFER_OUTPUT (node))
 495         fputs (" defer-output", file);
 496
 497
 498       xloc = expand_location (DECL_SOURCE_LOCATION (node));
 499       fprintf (file, " %s:%d:%d", xloc.file, xloc.line,
 500                xloc.column);
 501
 502       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 503         {
 504           print_node (file, "size", DECL_SIZE (node), indent + 4);
 505           print_node (file, "unit-size", DECL_SIZE_UNIT (node), indent + 4);
 506
 507           if (code != FUNCTION_DECL || fndecl_built_in_p (node))
 508             indent_to (file, indent + 3);
 509
 510           if (DECL_USER_ALIGN (node))
 511             fprintf (file, " user");
 512
 513           fprintf (file, " align:%d warn_if_not_align:%d",
 514                    DECL_ALIGN (node), DECL_WARN_IF_NOT_ALIGN (node));
 515           if (code == FIELD_DECL)
 516             fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
 517                      DECL_OFFSET_ALIGN (node));
 518
 519           if (code == FUNCTION_DECL && fndecl_built_in_p (node))
 520             {
 521               if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
 522                 fprintf (file, " built-in: BUILT_IN_MD:%d",
 523                          DECL_MD_FUNCTION_CODE (node));
 524               else if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_FRONTEND)
 525                 fprintf (file, " built-in: BUILT_IN_FRONTEND:%d",
 526                          DECL_FE_FUNCTION_CODE (node));
 527               else
 528                 fprintf (file, " built-in: %s:%s",
 529                          built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
 530                          built_in_names[(int) DECL_FUNCTION_CODE (node)]);
 531             }
 532         }
 533       if (code == FIELD_DECL)
 534         {
 535           print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
 536           print_node (file, "bit-offset", DECL_FIELD_BIT_OFFSET (node),
 537                       indent + 4);
 538           if (DECL_BIT_FIELD_TYPE (node))
 539             print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
 540                         indent + 4);
 541         }
 542
 543       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
 544
 545       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 546         {
 547           print_node (file, "attributes",
 548                             DECL_ATTRIBUTES (node), indent + 4);
 549           if (code != PARM_DECL)
 550             print_node_brief (file, "initial", DECL_INITIAL (node),
 551                               indent + 4);
 552         }
 553       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 554         {
 555           print_node_brief (file, "abstract_origin",
 556                             DECL_ABSTRACT_ORIGIN (node), indent + 4);
 557         }
 558       if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 559         {
 560           print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
 561         }
 562
 563       lang_hooks.print_decl (file, node, indent);
 564
 565       if (DECL_RTL_SET_P (node))
 566         {
 567           indent_to (file, indent + 4);
 568           print_rtl (file, DECL_RTL (node));
 569         }
 570
 571       if (code == PARM_DECL)
 572         {
 573           print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
 574
 575           if (DECL_INCOMING_RTL (node) != 0)
 576             {
 577               indent_to (file, indent + 4);
 578               fprintf (file, "incoming-rtl ");
 579               print_rtl (file, DECL_INCOMING_RTL (node));
 580             }
 581         }
 582       else if (code == FUNCTION_DECL
 583                && DECL_STRUCT_FUNCTION (node) != 0)
 584         {
 585           print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
 586           indent_to (file, indent + 4);
 587           dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
 588         }
 589
 590       if ((code == VAR_DECL || code == PARM_DECL)
 591           && DECL_HAS_VALUE_EXPR_P (node))
 592         print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
 593
 594       /* Print the decl chain only if decl is at second level.  */
 595       if (indent == 4)
 596         print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 597       else
 598         print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
 599       break;
 600
 601     case tcc_type:
 602       if (TYPE_UNSIGNED (node))
 603         fputs (" unsigned", file);
 604
 605       if (TYPE_NO_FORCE_BLK (node))
 606         fputs (" no-force-blk", file);
 607
 608       if (code == ARRAY_TYPE && TYPE_STRING_FLAG (node))
 609         fputs (" string-flag", file);
 610
 611       if (TYPE_NEEDS_CONSTRUCTING (node))
 612         fputs (" needs-constructing", file);
 613
 614       if ((code == RECORD_TYPE
 615            || code == UNION_TYPE
 616            || code == QUAL_UNION_TYPE
 617            || code == ARRAY_TYPE)
 618           && TYPE_REVERSE_STORAGE_ORDER (node))
 619         fputs (" reverse-storage-order", file);
 620
 621       if ((code == RECORD_TYPE
 622            || code == UNION_TYPE)
 623           && TYPE_CXX_ODR_P (node))
 624         fputs (" cxx-odr-p", file);
 625
 626       /* The transparent-union flag is used for different things in
 627          different nodes.  */
 628       if ((code == UNION_TYPE || code == RECORD_TYPE)
 629           && TYPE_TRANSPARENT_AGGR (node))
 630         fputs (" transparent-aggr", file);
 631       else if (code == ARRAY_TYPE
 632                && TYPE_NONALIASED_COMPONENT (node))
 633         fputs (" nonaliased-component", file);
 634
 635       if (TYPE_PACKED (node))
 636         fputs (" packed", file);
 637
 638       if (TYPE_RESTRICT (node))
 639         fputs (" restrict", file);
 640
 641       if (TYPE_LANG_FLAG_0 (node))
 642         fputs (" type_0", file);
 643       if (TYPE_LANG_FLAG_1 (node))
 644         fputs (" type_1", file);
 645       if (TYPE_LANG_FLAG_2 (node))
 646         fputs (" type_2", file);
 647       if (TYPE_LANG_FLAG_3 (node))
 648         fputs (" type_3", file);
 649       if (TYPE_LANG_FLAG_4 (node))
 650         fputs (" type_4", file);
 651       if (TYPE_LANG_FLAG_5 (node))
 652         fputs (" type_5", file);
 653       if (TYPE_LANG_FLAG_6 (node))
 654         fputs (" type_6", file);
 655       if (TYPE_LANG_FLAG_7 (node))
 656         fputs (" type_7", file);
 657
 658       mode = TYPE_MODE (node);
 659       fprintf (file, " %s", GET_MODE_NAME (mode));
 660
 661       print_node (file, "size", TYPE_SIZE (node), indent + 4);
 662       print_node (file, "unit-size", TYPE_SIZE_UNIT (node), indent + 4);
 663       indent_to (file, indent + 3);
 664
 665       if (TYPE_USER_ALIGN (node))
 666         fprintf (file, " user");
 667
 668       fprintf (file, " align:%d warn_if_not_align:%d symtab:%d alias-set "
 669                HOST_WIDE_INT_PRINT_DEC,
 670                TYPE_ALIGN (node), TYPE_WARN_IF_NOT_ALIGN (node),
 671                TYPE_SYMTAB_ADDRESS (node),
 672                (HOST_WIDE_INT) TYPE_ALIAS_SET (node));
 673
 674       if (TYPE_STRUCTURAL_EQUALITY_P (node))
 675         fprintf (file, " structural-equality");
 676       else
 677         dump_addr (file, " canonical-type ", TYPE_CANONICAL (node));
 678
 679       print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
 680
 681       if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
 682           || code == FIXED_POINT_TYPE)
 683         {
 684           fprintf (file, " precision:%d", TYPE_PRECISION (node));
 685           print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
 686           print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
 687         }
 688
 689       if (code == ENUMERAL_TYPE)
 690         print_node (file, "values", TYPE_VALUES (node), indent + 4);
 691       else if (code == ARRAY_TYPE)
 692         print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
 693       else if (code == VECTOR_TYPE)
 694         {
 695           fprintf (file, " nunits:");
 696           print_dec (TYPE_VECTOR_SUBPARTS (node), file);
 697         }
 698       else if (code == RECORD_TYPE
 699                || code == UNION_TYPE
 700                || code == QUAL_UNION_TYPE)
 701         print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
 702       else if (code == FUNCTION_TYPE
 703                || code == METHOD_TYPE)
 704         {
 705           if (TYPE_METHOD_BASETYPE (node))
 706             print_node_brief (file, "method basetype",
 707                               TYPE_METHOD_BASETYPE (node), indent + 4);
 708           print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
 709         }
 710       else if (code == OFFSET_TYPE)
 711         print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
 712                           indent + 4);
 713
 714       if (TYPE_CONTEXT (node))
 715         print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
 716
 717       lang_hooks.print_type (file, node, indent);
 718
 719       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
 720         indent_to (file, indent + 3);
 721
 722       print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
 723                         indent + 4);
 724       print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
 725                         indent + 4);
 726       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
 727       break;
 728
 729     case tcc_expression:
 730     case tcc_comparison:
 731     case tcc_unary:
 732     case tcc_binary:
 733     case tcc_reference:
 734     case tcc_statement:
 735     case tcc_vl_exp:
 736       if (code == BIND_EXPR)
 737         {
 738           print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
 739           print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
 740           print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
 741           break;
 742         }
 743       if (code == CALL_EXPR)
 744         {
 745           call_expr_arg_iterator iter;
 746           tree arg;
 747           print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
 748           print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
 749                       indent + 4);
 750           i = 0;
 751           FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
 752             {
 753               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 754                  the text.  */
 755               char temp[15];
 756               sprintf (temp, "arg:%u", i);
 757               print_node (file, temp, arg, indent + 4);
 758               i++;
 759             }
 760         }
 761       else
 762         {
 763           len = TREE_OPERAND_LENGTH (node);
 764
 765           for (i = 0; i < len; i++)
 766             {
 767               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 768                  the text.  */
 769               char temp[15];
 770
 771               sprintf (temp, "arg:%d", i);
 772               print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
 773             }
 774         }
 775       if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
 776         print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 777       break;
 778
 779     case tcc_constant:
 780     case tcc_exceptional:
 781       switch (code)
 782         {
 783         case INTEGER_CST:
 784           if (TREE_OVERFLOW (node))
 785             fprintf (file, " overflow");
 786
 787           fprintf (file, " ");
 788           print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
 789           break;
 790
 791         case REAL_CST:
 792           print_real_cst (file, node, false);
 793           break;
 794
 795         case FIXED_CST:
 796           {
 797             FIXED_VALUE_TYPE f;
 798             char string[64];
 799
 800             if (TREE_OVERFLOW (node))
 801               fprintf (file, " overflow");
 802
 803             f = TREE_FIXED_CST (node);
 804             fixed_to_decimal (string, &f, sizeof (string));
 805             fprintf (file, " %s", string);
 806           }
 807           break;
 808
 809         case VECTOR_CST:
 810           {
 811             /* Big enough for UINT_MAX plus the string below.  */
 812             char buf[32];
 813
 814             fprintf (file, " npatterns:%u nelts-per-pattern:%u",
 815                      VECTOR_CST_NPATTERNS (node),
 816                      VECTOR_CST_NELTS_PER_PATTERN (node));
 817             unsigned int count = vector_cst_encoded_nelts (node);
 818             for (unsigned int i = 0; i < count; ++i)
 819               {
 820                 sprintf (buf, "elt:%u: ", i);
 821                 print_node (file, buf, VECTOR_CST_ENCODED_ELT (node, i),
 822                             indent + 4);
 823               }
 824           }
 825           break;
 826
 827         case COMPLEX_CST:
 828           print_node (file, "real", TREE_REALPART (node), indent + 4);
 829           print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
 830           break;
 831
 832         case STRING_CST:
 833           {
 834             const char *p = TREE_STRING_POINTER (node);
 835             int i = TREE_STRING_LENGTH (node);
 836             fputs (" \"", file);
 837             while (--i >= 0)
 838               {
 839                 char ch = *p++;
 840                 if (ch >= ' ' && ch < 127)
 841                   putc (ch, file);
 842                 else
 843                   fprintf (file, "\\%03o", ch & 0xFF);
 844               }
 845             fputc ('\"', file);
 846           }
 847           break;
 848
 849         case POLY_INT_CST:
 850           {
 851             char buf[10];
 852             for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
 853               {
 854                 snprintf (buf, sizeof (buf), "elt%u: ", i);
 855                 print_node (file, buf, POLY_INT_CST_COEFF (node, i),
 856                             indent + 4);
 857               }
 858           }
 859           break;
 860
 861         case IDENTIFIER_NODE:
 862           lang_hooks.print_identifier (file, node, indent);
 863           break;
 864
 865         case TREE_LIST:
 866           print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
 867           print_node (file, "value", TREE_VALUE (node), indent + 4);
 868           print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 869           break;
 870
 871         case TREE_VEC:
 872           len = TREE_VEC_LENGTH (node);
 873           fprintf (file, " length:%d", len);
 874           for (i = 0; i < len; i++)
 875             if (TREE_VEC_ELT (node, i))
 876               {
 877               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 878                  the text.  */
 879                 char temp[15];
 880                 sprintf (temp, "elt:%d", i);
 881                 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4);
 882               }
 883           break;
 884
 885         case CONSTRUCTOR:
 886           {
 887             unsigned HOST_WIDE_INT cnt;
 888             tree index, value;
 889             len = CONSTRUCTOR_NELTS (node);
 890             fprintf (file, " length:%d", len);
 891             FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
 892                                       cnt, index, value)
 893               {
 894                 print_node (file, "idx", index, indent + 4, false);
 895                 print_node (file, "val", value, indent + 4, false);
 896               }
 897           }
 898           break;
 899
 900         case STATEMENT_LIST:
 901           dump_addr (file, " head ", node->stmt_list.head);
 902           dump_addr (file, " tail ", node->stmt_list.tail);
 903           fprintf (file, " stmts");
 904           {
 905             tree_stmt_iterator i;
 906             for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
 907               {
 908                 /* Not printing the addresses of the (not-a-tree)
 909                    'struct tree_stmt_list_node's.  */
 910                 dump_addr (file, " ", tsi_stmt (i));
 911               }
 912             fprintf (file, "\n");
 913             for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
 914               {
 915                 /* Not printing the addresses of the (not-a-tree)
 916                    'struct tree_stmt_list_node's.  */
 917                 print_node (file, "stmt", tsi_stmt (i), indent + 4);
 918               }
 919           }
 920           break;
 921
 922         case BLOCK:
 923           print_node (file, "vars", BLOCK_VARS (node), indent + 4);
 924           print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
 925                       indent + 4);
 926           print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
 927           print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
 928           print_node (file, "abstract_origin",
 929                       BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
 930           break;
 931
 932         case SSA_NAME:
 933           print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
 934           indent_to (file, indent + 4);
 935           fprintf (file, "def_stmt ");
 936           {
 937             pretty_printer buffer;
 938             buffer.buffer->stream = file;
 939             pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4,
 940                               TDF_NONE);
 941             pp_flush (&buffer);
 942           }
 943
 944           indent_to (file, indent + 4);
 945           fprintf (file, "version:%u", SSA_NAME_VERSION (node));
 946           if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
 947             fprintf (file, " in-abnormal-phi");
 948           if (SSA_NAME_IN_FREE_LIST (node))
 949             fprintf (file, " in-free-list");
 950
 951           if (SSA_NAME_PTR_INFO (node))
 952             {
 953               indent_to (file, indent + 3);
 954               if (SSA_NAME_PTR_INFO (node))
 955                 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
 956             }
 957           break;
 958
 959         case OMP_CLAUSE:
 960             {
 961               int i;
 962               fprintf (file, " %s",
 963                        omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
 964               for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
 965                 {
 966                   indent_to (file, indent + 4);
 967                   fprintf (file, "op-%d:", i);
 968                   print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
 969                 }
 970             }
 971           break;
 972
 973         case OPTIMIZATION_NODE:
 974           cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node));
 975           break;
 976
 977         case TARGET_OPTION_NODE:
 978           cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node));
 979           break;
 980         case IMPORTED_DECL:
 981           fprintf (file, " imported-declaration");
 982           print_node_brief (file, "associated-declaration",
 983                             IMPORTED_DECL_ASSOCIATED_DECL (node),
 984                             indent + 4);
 985           break;
 986
 987         case TREE_BINFO:
 988           fprintf (file, " bases:%d",
 989                    vec_safe_length (BINFO_BASE_BINFOS (node)));
 990           print_node_brief (file, "offset", BINFO_OFFSET (node), indent + 4);
 991           print_node_brief (file, "virtuals", BINFO_VIRTUALS (node),
 992                             indent + 4);
 993           print_node_brief (file, "inheritance-chain",
 994                             BINFO_INHERITANCE_CHAIN (node),
 995                             indent + 4);
 996           break;
 997
 998         default:
 999           if (EXCEPTIONAL_CLASS_P (node))
1000             lang_hooks.print_xnode (file, node, indent);
1001           break;
1002         }
1003
1004       break;
1005     }
1006
1007   if (EXPR_HAS_LOCATION (node))
1008     {
1009       expanded_location xloc = expand_location (EXPR_LOCATION (node));
1010       indent_to (file, indent+4);
1011       fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
1012
1013       /* Print the range, if any */
1014       source_range r = EXPR_LOCATION_RANGE (node);
1015       if (r.m_start)
1016         {
1017           xloc = expand_location (r.m_start);
1018           fprintf (file, " start: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1019         }
1020       else
1021         {
1022           fprintf (file, " start: unknown");
1023         }
1024       if (r.m_finish)
1025         {
1026           xloc = expand_location (r.m_finish);
1027           fprintf (file, " finish: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1028         }
1029       else
1030         {
1031           fprintf (file, " finish: unknown");
1032         }
1033     }
1034
1035   fprintf (file, ">");
1036 }
1037
1038
1039 /* Print the node NODE on standard error, for debugging.
1040    Most nodes referred to by this one are printed recursively
1041    down to a depth of six.  */
1042
1043 DEBUG_FUNCTION void
1044 debug_tree (tree node)
1045 {
1046   table = new hash_set<tree> (HASH_SIZE);
1047   print_node (stderr, "", node, 0);
1048   delete table;
1049   table = NULL;
1050   putc ('\n', stderr);
1051 }
1052
1053 DEBUG_FUNCTION void
1054 debug_raw (const tree_node &ref)
1055 {
1056   debug_tree (const_cast <tree> (&ref));
1057 }
1058
1059 DEBUG_FUNCTION void
1060 debug_raw (const tree_node *ptr)
1061 {
1062   if (ptr)
1063     debug_raw (*ptr);
1064   else
1065     fprintf (stderr, "<nil>\n");
1066 }
1067
1068 static void
1069 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options)
1070 {
1071   if (DECL_P (ptr))
1072     lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0);
1073   else if (TYPE_P (ptr))
1074     lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0);
1075   else if (TREE_CODE (ptr) == IDENTIFIER_NODE)
1076     lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0);
1077   else
1078     print_generic_expr (stderr, const_cast <tree_node*> (ptr), options);
1079   fprintf (stderr, "\n");
1080 }
1081
1082 DEBUG_FUNCTION void
1083 debug (const tree_node &ref)
1084 {
1085   dump_tree_via_hooks (&ref, TDF_NONE);
1086 }
1087
1088 DEBUG_FUNCTION void
1089 debug (const tree_node *ptr)
1090 {
1091   if (ptr)
1092     debug (*ptr);
1093   else
1094     fprintf (stderr, "<nil>\n");
1095 }
1096
1097 DEBUG_FUNCTION void
1098 debug_head (const tree_node &ref)
1099 {
1100   debug (ref);
1101 }
1102
1103 DEBUG_FUNCTION void
1104 debug_head (const tree_node *ptr)
1105 {
1106   if (ptr)
1107     debug_head (*ptr);
1108   else
1109     fprintf (stderr, "<nil>\n");
1110 }
1111
1112 DEBUG_FUNCTION void
1113 debug_body (const tree_node &ref)
1114 {
1115   if (TREE_CODE (&ref) == FUNCTION_DECL)
1116     dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE);
1117   else
1118     debug (ref);
1119 }
1120
1121 DEBUG_FUNCTION void
1122 debug_body (const tree_node *ptr)
1123 {
1124   if (ptr)
1125     debug_body (*ptr);
1126   else
1127     fprintf (stderr, "<nil>\n");
1128 }
1129
1130 /* Print the vector of trees VEC on standard error, for debugging.
1131    Most nodes referred to by this one are printed recursively
1132    down to a depth of six.  */
1133
1134 DEBUG_FUNCTION void
1135 debug_raw (vec<tree, va_gc> &ref)
1136 {
1137   tree elt;
1138   unsigned ix;
1139
1140   /* Print the slot this node is in, and its code, and address.  */
1141   fprintf (stderr, "<VEC");
1142   dump_addr (stderr, " ", ref.address ());
1143
1144   FOR_EACH_VEC_ELT (ref, ix, elt)
1145     {
1146       fprintf (stderr, "elt:%d ", ix);
1147       debug_raw (elt);
1148     }
1149 }
1150
1151 DEBUG_FUNCTION void
1152 debug_raw (vec<tree, va_gc> *ptr)
1153 {
1154   if (ptr)
1155     debug_raw (*ptr);
1156   else
1157     fprintf (stderr, "<nil>\n");
1158 }
1159
1160 static void
1161 debug_slim (tree t)
1162 {
1163   print_node_brief (stderr, "", t, 0);
1164 }
1165
1166 DEFINE_DEBUG_VEC (tree)
1167 DEFINE_DEBUG_HASH_SET (tree)