gcc/print-tree.c

   1 /* Prints out tree in human readable form - GCC
   2    Copyright (C) 1990-2020 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 /* Print the identifier for DECL according to FLAGS.  */
1039
1040 void
1041 print_decl_identifier (FILE *file, tree decl, int flags)
1042 {
1043   bool needs_colon = false;
1044   const char *name;
1045   char c;
1046
1047   if (flags & PRINT_DECL_ORIGIN)
1048     {
1049       if (DECL_IS_BUILTIN (decl))
1050         fputs ("<built-in>", file);
1051       else
1052         {
1053           expanded_location loc
1054             = expand_location (DECL_SOURCE_LOCATION (decl));
1055           fprintf (file, "%s:%d:%d", loc.file, loc.line, loc.column);
1056         }
1057       needs_colon = true;
1058     }
1059
1060   if (flags & PRINT_DECL_UNIQUE_NAME)
1061     {
1062       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1063       if (!TREE_PUBLIC (decl)
1064           || (DECL_WEAK (decl) && !DECL_EXTERNAL (decl)))
1065         /* The symbol has internal or weak linkage so its assembler name
1066            is not necessarily unique among the compilation units of the
1067            program.  We therefore have to further mangle it.  But we can't
1068            simply use DECL_SOURCE_FILE because it contains the name of the
1069            file the symbol originates from so, e.g. for function templates
1070            in C++ where the templates are defined in a header file, we can
1071            have symbols with the same assembler name and DECL_SOURCE_FILE.
1072            That's why we use the name of the top-level source file of the
1073            compilation unit.  ??? Unnecessary for Ada.  */
1074         name = ACONCAT ((main_input_filename, ":", name, NULL));
1075     }
1076   else if (flags & PRINT_DECL_NAME)
1077     {
1078       /* We don't want to print the full qualified name because it can be long,
1079          so we strip the scope prefix, but we may need to deal with the suffix
1080          created by the compiler.  */
1081       const char *suffix = strchr (IDENTIFIER_POINTER (DECL_NAME (decl)), '.');
1082       name = lang_hooks.decl_printable_name (decl, 2);
1083       if (suffix)
1084         {
1085           const char *dot = strchr (name, '.');
1086           while (dot && strcasecmp (dot, suffix) != 0)
1087             {
1088               name = dot + 1;
1089               dot = strchr (name, '.');
1090             }
1091         }
1092       else
1093         {
1094           const char *dot = strrchr (name, '.');
1095           if (dot)
1096             name = dot + 1;
1097         }
1098     }
1099   else
1100     return;
1101
1102   if (needs_colon)
1103     fputc (':', file);
1104
1105   while ((c = *name++) != '\0')
1106     {
1107       /* Strip double-quotes because of VCG.  */
1108       if (c == '"')
1109         continue;
1110       fputc (c, file);
1111     }
1112 }
1113
1114
1115 /* Print the node NODE on standard error, for debugging.
1116    Most nodes referred to by this one are printed recursively
1117    down to a depth of six.  */
1118
1119 DEBUG_FUNCTION void
1120 debug_tree (tree node)
1121 {
1122   table = new hash_set<tree> (HASH_SIZE);
1123   print_node (stderr, "", node, 0);
1124   delete table;
1125   table = NULL;
1126   putc ('\n', stderr);
1127 }
1128
1129 DEBUG_FUNCTION void
1130 debug_raw (const tree_node &ref)
1131 {
1132   debug_tree (const_cast <tree> (&ref));
1133 }
1134
1135 DEBUG_FUNCTION void
1136 debug_raw (const tree_node *ptr)
1137 {
1138   if (ptr)
1139     debug_raw (*ptr);
1140   else
1141     fprintf (stderr, "<nil>\n");
1142 }
1143
1144 static void
1145 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options)
1146 {
1147   if (DECL_P (ptr))
1148     lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0);
1149   else if (TYPE_P (ptr))
1150     lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0);
1151   else if (TREE_CODE (ptr) == IDENTIFIER_NODE)
1152     lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0);
1153   else
1154     print_generic_expr (stderr, const_cast <tree_node*> (ptr), options);
1155   fprintf (stderr, "\n");
1156 }
1157
1158 DEBUG_FUNCTION void
1159 debug (const tree_node &ref)
1160 {
1161   dump_tree_via_hooks (&ref, TDF_NONE);
1162 }
1163
1164 DEBUG_FUNCTION void
1165 debug (const tree_node *ptr)
1166 {
1167   if (ptr)
1168     debug (*ptr);
1169   else
1170     fprintf (stderr, "<nil>\n");
1171 }
1172
1173 DEBUG_FUNCTION void
1174 debug_head (const tree_node &ref)
1175 {
1176   debug (ref);
1177 }
1178
1179 DEBUG_FUNCTION void
1180 debug_head (const tree_node *ptr)
1181 {
1182   if (ptr)
1183     debug_head (*ptr);
1184   else
1185     fprintf (stderr, "<nil>\n");
1186 }
1187
1188 DEBUG_FUNCTION void
1189 debug_body (const tree_node &ref)
1190 {
1191   if (TREE_CODE (&ref) == FUNCTION_DECL)
1192     dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE);
1193   else
1194     debug (ref);
1195 }
1196
1197 DEBUG_FUNCTION void
1198 debug_body (const tree_node *ptr)
1199 {
1200   if (ptr)
1201     debug_body (*ptr);
1202   else
1203     fprintf (stderr, "<nil>\n");
1204 }
1205
1206 /* Print the vector of trees VEC on standard error, for debugging.
1207    Most nodes referred to by this one are printed recursively
1208    down to a depth of six.  */
1209
1210 DEBUG_FUNCTION void
1211 debug_raw (vec<tree, va_gc> &ref)
1212 {
1213   tree elt;
1214   unsigned ix;
1215
1216   /* Print the slot this node is in, and its code, and address.  */
1217   fprintf (stderr, "<VEC");
1218   dump_addr (stderr, " ", ref.address ());
1219
1220   FOR_EACH_VEC_ELT (ref, ix, elt)
1221     {
1222       fprintf (stderr, "elt:%d ", ix);
1223       debug_raw (elt);
1224     }
1225 }
1226
1227 DEBUG_FUNCTION void
1228 debug_raw (vec<tree, va_gc> *ptr)
1229 {
1230   if (ptr)
1231     debug_raw (*ptr);
1232   else
1233     fprintf (stderr, "<nil>\n");
1234 }
1235
1236 static void
1237 debug_slim (tree t)
1238 {
1239   print_node_brief (stderr, "", t, 0);
1240 }
1241
1242 DEFINE_DEBUG_VEC (tree)
1243 DEFINE_DEBUG_HASH_SET (tree)