gcc/print-tree.c

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