gcc/print-tree.c

   1 /* Prints out tree in human readable form - GCC
   2    Copyright (C) 1990-2017 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 (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_BUILT_IN (node))
 381         fputs (" built-in", file);
 382       if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
 383         fputs (" static-chain", file);
 384       if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
 385         fputs (" tm-clone", file);
 386
 387       if (code == FIELD_DECL && DECL_PACKED (node))
 388         fputs (" packed", file);
 389       if (code == FIELD_DECL && DECL_BIT_FIELD (node))
 390         fputs (" bit-field", file);
 391       if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
 392         fputs (" nonaddressable", file);
 393
 394       if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
 395         fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
 396
 397       if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
 398         fputs (" in-text-section", file);
 399       if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
 400         fputs (" in-constant-pool", file);
 401       if (code == VAR_DECL && DECL_COMMON (node))
 402         fputs (" common", file);
 403       if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
 404         {
 405           fputs (" ", file);
 406           fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
 407         }
 408
 409       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 410         {
 411           if (DECL_VIRTUAL_P (node))
 412             fputs (" virtual", file);
 413           if (DECL_PRESERVE_P (node))
 414             fputs (" preserve", file);
 415           if (DECL_LANG_FLAG_0 (node))
 416             fputs (" decl_0", file);
 417           if (DECL_LANG_FLAG_1 (node))
 418             fputs (" decl_1", file);
 419           if (DECL_LANG_FLAG_2 (node))
 420             fputs (" decl_2", file);
 421           if (DECL_LANG_FLAG_3 (node))
 422             fputs (" decl_3", file);
 423           if (DECL_LANG_FLAG_4 (node))
 424             fputs (" decl_4", file);
 425           if (DECL_LANG_FLAG_5 (node))
 426             fputs (" decl_5", file);
 427           if (DECL_LANG_FLAG_6 (node))
 428             fputs (" decl_6", file);
 429           if (DECL_LANG_FLAG_7 (node))
 430             fputs (" decl_7", file);
 431
 432           mode = DECL_MODE (node);
 433           fprintf (file, " %s", GET_MODE_NAME (mode));
 434         }
 435
 436       if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
 437           && DECL_BY_REFERENCE (node))
 438         fputs (" passed-by-reference", file);
 439
 440       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)  && DECL_DEFER_OUTPUT (node))
 441         fputs (" defer-output", file);
 442
 443
 444       xloc = expand_location (DECL_SOURCE_LOCATION (node));
 445       fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
 446                xloc.column);
 447
 448       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 449         {
 450           print_node (file, "size", DECL_SIZE (node), indent + 4);
 451           print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
 452
 453           if (code != FUNCTION_DECL || DECL_BUILT_IN (node))
 454             indent_to (file, indent + 3);
 455
 456           if (DECL_USER_ALIGN (node))
 457             fprintf (file, " user");
 458
 459           fprintf (file, " align %d", DECL_ALIGN (node));
 460           if (code == FIELD_DECL)
 461             fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
 462                      DECL_OFFSET_ALIGN (node));
 463
 464           if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
 465             {
 466               if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
 467                 fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
 468               else
 469                 fprintf (file, " built-in %s:%s",
 470                          built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
 471                          built_in_names[(int) DECL_FUNCTION_CODE (node)]);
 472             }
 473         }
 474       if (code == FIELD_DECL)
 475         {
 476           print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
 477           print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
 478                       indent + 4);
 479           if (DECL_BIT_FIELD_TYPE (node))
 480             print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
 481                         indent + 4);
 482         }
 483
 484       print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
 485
 486       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 487         {
 488           print_node_brief (file, "attributes",
 489                             DECL_ATTRIBUTES (node), indent + 4);
 490           if (code != PARM_DECL)
 491             print_node_brief (file, "initial", DECL_INITIAL (node),
 492                               indent + 4);
 493         }
 494       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 495         {
 496           print_node_brief (file, "abstract_origin",
 497                             DECL_ABSTRACT_ORIGIN (node), indent + 4);
 498         }
 499       if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 500         {
 501           print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
 502         }
 503
 504       lang_hooks.print_decl (file, node, indent);
 505
 506       if (DECL_RTL_SET_P (node))
 507         {
 508           indent_to (file, indent + 4);
 509           print_rtl (file, DECL_RTL (node));
 510         }
 511
 512       if (code == PARM_DECL)
 513         {
 514           print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
 515
 516           if (DECL_INCOMING_RTL (node) != 0)
 517             {
 518               indent_to (file, indent + 4);
 519               fprintf (file, "incoming-rtl ");
 520               print_rtl (file, DECL_INCOMING_RTL (node));
 521             }
 522         }
 523       else if (code == FUNCTION_DECL
 524                && DECL_STRUCT_FUNCTION (node) != 0)
 525         {
 526           print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
 527           indent_to (file, indent + 4);
 528           dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
 529         }
 530
 531       if ((code == VAR_DECL || code == PARM_DECL)
 532           && DECL_HAS_VALUE_EXPR_P (node))
 533         print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
 534
 535       /* Print the decl chain only if decl is at second level.  */
 536       if (indent == 4)
 537         print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 538       else
 539         print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
 540       break;
 541
 542     case tcc_type:
 543       if (TYPE_UNSIGNED (node))
 544         fputs (" unsigned", file);
 545
 546       if (TYPE_NO_FORCE_BLK (node))
 547         fputs (" no-force-blk", file);
 548
 549       if (TYPE_STRING_FLAG (node))
 550         fputs (" string-flag", file);
 551
 552       if (TYPE_NEEDS_CONSTRUCTING (node))
 553         fputs (" needs-constructing", file);
 554
 555       if ((code == RECORD_TYPE
 556            || code == UNION_TYPE
 557            || code == QUAL_UNION_TYPE
 558            || code == ARRAY_TYPE)
 559           && TYPE_REVERSE_STORAGE_ORDER (node))
 560         fputs (" reverse-storage-order", file);
 561
 562       /* The transparent-union flag is used for different things in
 563          different nodes.  */
 564       if ((code == UNION_TYPE || code == RECORD_TYPE)
 565           && TYPE_TRANSPARENT_AGGR (node))
 566         fputs (" transparent-aggr", file);
 567       else if (code == ARRAY_TYPE
 568                && TYPE_NONALIASED_COMPONENT (node))
 569         fputs (" nonaliased-component", file);
 570
 571       if (TYPE_PACKED (node))
 572         fputs (" packed", file);
 573
 574       if (TYPE_RESTRICT (node))
 575         fputs (" restrict", file);
 576
 577       if (TYPE_LANG_FLAG_0 (node))
 578         fputs (" type_0", file);
 579       if (TYPE_LANG_FLAG_1 (node))
 580         fputs (" type_1", file);
 581       if (TYPE_LANG_FLAG_2 (node))
 582         fputs (" type_2", file);
 583       if (TYPE_LANG_FLAG_3 (node))
 584         fputs (" type_3", file);
 585       if (TYPE_LANG_FLAG_4 (node))
 586         fputs (" type_4", file);
 587       if (TYPE_LANG_FLAG_5 (node))
 588         fputs (" type_5", file);
 589       if (TYPE_LANG_FLAG_6 (node))
 590         fputs (" type_6", file);
 591       if (TYPE_LANG_FLAG_7 (node))
 592         fputs (" type_7", file);
 593
 594       mode = TYPE_MODE (node);
 595       fprintf (file, " %s", GET_MODE_NAME (mode));
 596
 597       print_node (file, "size", TYPE_SIZE (node), indent + 4);
 598       print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
 599       indent_to (file, indent + 3);
 600
 601       if (TYPE_USER_ALIGN (node))
 602         fprintf (file, " user");
 603
 604       fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
 605                TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
 606                (HOST_WIDE_INT) TYPE_ALIAS_SET (node));
 607
 608       if (TYPE_STRUCTURAL_EQUALITY_P (node))
 609         fprintf (file, " structural equality");
 610       else
 611         dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
 612
 613       print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
 614
 615       if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
 616           || code == FIXED_POINT_TYPE)
 617         {
 618           fprintf (file, " precision %d", TYPE_PRECISION (node));
 619           print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
 620           print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
 621         }
 622
 623       if (code == ENUMERAL_TYPE)
 624         print_node (file, "values", TYPE_VALUES (node), indent + 4);
 625       else if (code == ARRAY_TYPE)
 626         print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
 627       else if (code == VECTOR_TYPE)
 628         fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
 629       else if (code == RECORD_TYPE
 630                || code == UNION_TYPE
 631                || code == QUAL_UNION_TYPE)
 632         print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
 633       else if (code == FUNCTION_TYPE
 634                || code == METHOD_TYPE)
 635         {
 636           if (TYPE_METHOD_BASETYPE (node))
 637             print_node_brief (file, "method basetype",
 638                               TYPE_METHOD_BASETYPE (node), indent + 4);
 639           print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
 640         }
 641       else if (code == OFFSET_TYPE)
 642         print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
 643                           indent + 4);
 644
 645       if (TYPE_CONTEXT (node))
 646         print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
 647
 648       lang_hooks.print_type (file, node, indent);
 649
 650       if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
 651         indent_to (file, indent + 3);
 652
 653       print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
 654                         indent + 4);
 655       print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
 656                         indent + 4);
 657       print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
 658       break;
 659
 660     case tcc_expression:
 661     case tcc_comparison:
 662     case tcc_unary:
 663     case tcc_binary:
 664     case tcc_reference:
 665     case tcc_statement:
 666     case tcc_vl_exp:
 667       if (code == BIND_EXPR)
 668         {
 669           print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
 670           print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
 671           print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
 672           break;
 673         }
 674       if (code == CALL_EXPR)
 675         {
 676           call_expr_arg_iterator iter;
 677           tree arg;
 678           print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
 679           print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
 680                       indent + 4);
 681           i = 0;
 682           FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
 683             {
 684               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 685                  the text.  */
 686               char temp[15];
 687               sprintf (temp, "arg %u", i);
 688               print_node (file, temp, arg, indent + 4);
 689               i++;
 690             }
 691         }
 692       else
 693         {
 694           len = TREE_OPERAND_LENGTH (node);
 695
 696           for (i = 0; i < len; i++)
 697             {
 698               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 699                  the text.  */
 700               char temp[15];
 701
 702               sprintf (temp, "arg %d", i);
 703               print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
 704             }
 705         }
 706       if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
 707         print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 708       break;
 709
 710     case tcc_constant:
 711     case tcc_exceptional:
 712       switch (code)
 713         {
 714         case INTEGER_CST:
 715           if (TREE_OVERFLOW (node))
 716             fprintf (file, " overflow");
 717
 718           fprintf (file, " ");
 719           print_dec (node, file, TYPE_SIGN (TREE_TYPE (node)));
 720           break;
 721
 722         case REAL_CST:
 723           {
 724             REAL_VALUE_TYPE d;
 725
 726             if (TREE_OVERFLOW (node))
 727               fprintf (file, " overflow");
 728
 729             d = TREE_REAL_CST (node);
 730             if (REAL_VALUE_ISINF (d))
 731               fprintf (file,  REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
 732             else if (REAL_VALUE_ISNAN (d))
 733               fprintf (file, " Nan");
 734             else
 735               {
 736                 char string[64];
 737                 real_to_decimal (string, &d, sizeof (string), 0, 1);
 738                 fprintf (file, " %s", string);
 739               }
 740           }
 741           break;
 742
 743         case FIXED_CST:
 744           {
 745             FIXED_VALUE_TYPE f;
 746             char string[64];
 747
 748             if (TREE_OVERFLOW (node))
 749               fprintf (file, " overflow");
 750
 751             f = TREE_FIXED_CST (node);
 752             fixed_to_decimal (string, &f, sizeof (string));
 753             fprintf (file, " %s", string);
 754           }
 755           break;
 756
 757         case VECTOR_CST:
 758           {
 759             /* Big enough for 2 UINT_MAX plus the string below.  */
 760             char buf[32];
 761             unsigned i;
 762
 763             for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
 764               {
 765                 unsigned j;
 766                 /* Coalesce the output of identical consecutive elements.  */
 767                 for (j = i + 1; j < VECTOR_CST_NELTS (node); j++)
 768                   if (VECTOR_CST_ELT (node, j) != VECTOR_CST_ELT (node, i))
 769                     break;
 770                 j--;
 771                 if (i == j)
 772                   sprintf (buf, "elt%u: ", i);
 773                 else
 774                   sprintf (buf, "elt%u...elt%u: ", i, j);
 775                 print_node (file, buf, VECTOR_CST_ELT (node, i), indent + 4);
 776                 i = j;
 777               }
 778           }
 779           break;
 780
 781         case COMPLEX_CST:
 782           print_node (file, "real", TREE_REALPART (node), indent + 4);
 783           print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
 784           break;
 785
 786         case STRING_CST:
 787           {
 788             const char *p = TREE_STRING_POINTER (node);
 789             int i = TREE_STRING_LENGTH (node);
 790             fputs (" \"", file);
 791             while (--i >= 0)
 792               {
 793                 char ch = *p++;
 794                 if (ch >= ' ' && ch < 127)
 795                   putc (ch, file);
 796                 else
 797                   fprintf (file, "\\%03o", ch & 0xFF);
 798               }
 799             fputc ('\"', file);
 800           }
 801           break;
 802
 803         case IDENTIFIER_NODE:
 804           lang_hooks.print_identifier (file, node, indent);
 805           break;
 806
 807         case TREE_LIST:
 808           print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
 809           print_node (file, "value", TREE_VALUE (node), indent + 4);
 810           print_node (file, "chain", TREE_CHAIN (node), indent + 4);
 811           break;
 812
 813         case TREE_VEC:
 814           len = TREE_VEC_LENGTH (node);
 815           fprintf (file, " length %d", len);
 816           for (i = 0; i < len; i++)
 817             if (TREE_VEC_ELT (node, i))
 818               {
 819               /* Buffer big enough to format a 32-bit UINT_MAX into, plus
 820                  the text.  */
 821                 char temp[15];
 822                 sprintf (temp, "elt %d", i);
 823                 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4);
 824               }
 825           break;
 826
 827         case CONSTRUCTOR:
 828           {
 829             unsigned HOST_WIDE_INT cnt;
 830             tree index, value;
 831             len = CONSTRUCTOR_NELTS (node);
 832             fprintf (file, " lngt %d", len);
 833             FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
 834                                       cnt, index, value)
 835               {
 836                 print_node (file, "idx", index, indent + 4, false);
 837                 print_node (file, "val", value, indent + 4, false);
 838               }
 839           }
 840           break;
 841
 842         case STATEMENT_LIST:
 843           dump_addr (file, " head ", node->stmt_list.head);
 844           dump_addr (file, " tail ", node->stmt_list.tail);
 845           fprintf (file, " stmts");
 846           {
 847             tree_stmt_iterator i;
 848             for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
 849               {
 850                 /* Not printing the addresses of the (not-a-tree)
 851                    'struct tree_stmt_list_node's.  */
 852                 dump_addr (file, " ", tsi_stmt (i));
 853               }
 854             fprintf (file, "\n");
 855             for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
 856               {
 857                 /* Not printing the addresses of the (not-a-tree)
 858                    'struct tree_stmt_list_node's.  */
 859                 print_node (file, "stmt", tsi_stmt (i), indent + 4);
 860               }
 861           }
 862           break;
 863
 864         case BLOCK:
 865           print_node (file, "vars", BLOCK_VARS (node), indent + 4);
 866           print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
 867                       indent + 4);
 868           print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
 869           print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
 870           print_node (file, "abstract_origin",
 871                       BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
 872           break;
 873
 874         case SSA_NAME:
 875           print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
 876           indent_to (file, indent + 4);
 877           fprintf (file, "def_stmt ");
 878           {
 879             pretty_printer buffer;
 880             buffer.buffer->stream = file;
 881             pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4, 0);
 882             pp_flush (&buffer);
 883           }
 884
 885           indent_to (file, indent + 4);
 886           fprintf (file, "version %u", SSA_NAME_VERSION (node));
 887           if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
 888             fprintf (file, " in-abnormal-phi");
 889           if (SSA_NAME_IN_FREE_LIST (node))
 890             fprintf (file, " in-free-list");
 891
 892           if (SSA_NAME_PTR_INFO (node))
 893             {
 894               indent_to (file, indent + 3);
 895               if (SSA_NAME_PTR_INFO (node))
 896                 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
 897             }
 898           break;
 899
 900         case OMP_CLAUSE:
 901             {
 902               int i;
 903               fprintf (file, " %s",
 904                        omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
 905               for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
 906                 {
 907                   indent_to (file, indent + 4);
 908                   fprintf (file, "op %d:", i);
 909                   print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
 910                 }
 911             }
 912           break;
 913
 914         case OPTIMIZATION_NODE:
 915           cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node));
 916           break;
 917
 918         case TARGET_OPTION_NODE:
 919           cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node));
 920           break;
 921         case IMPORTED_DECL:
 922           fprintf (file, " imported declaration");
 923           print_node_brief (file, "associated declaration",
 924                             IMPORTED_DECL_ASSOCIATED_DECL (node),
 925                             indent + 4);
 926           break;
 927
 928         case TREE_BINFO:
 929           fprintf (file, " bases %d",
 930                    vec_safe_length (BINFO_BASE_BINFOS (node)));
 931           print_node_brief (file, "offset", BINFO_OFFSET (node), indent + 4);
 932           print_node_brief (file, "virtuals", BINFO_VIRTUALS (node),
 933                             indent + 4);
 934           print_node_brief (file, "inheritance chain",
 935                             BINFO_INHERITANCE_CHAIN (node),
 936                             indent + 4);
 937           break;
 938
 939         default:
 940           if (EXCEPTIONAL_CLASS_P (node))
 941             lang_hooks.print_xnode (file, node, indent);
 942           break;
 943         }
 944
 945       break;
 946     }
 947
 948   if (EXPR_HAS_LOCATION (node))
 949     {
 950       expanded_location xloc = expand_location (EXPR_LOCATION (node));
 951       indent_to (file, indent+4);
 952       fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
 953
 954       /* Print the range, if any */
 955       source_range r = EXPR_LOCATION_RANGE (node);
 956       if (r.m_start)
 957         {
 958           xloc = expand_location (r.m_start);
 959           fprintf (file, " start: %s:%d:%d", xloc.file, xloc.line, xloc.column);
 960         }
 961       else
 962         {
 963           fprintf (file, " start: unknown");
 964         }
 965       if (r.m_finish)
 966         {
 967           xloc = expand_location (r.m_finish);
 968           fprintf (file, " finish: %s:%d:%d", xloc.file, xloc.line, xloc.column);
 969         }
 970       else
 971         {
 972           fprintf (file, " finish: unknown");
 973         }
 974     }
 975
 976   fprintf (file, ">");
 977 }
 978
 979
 980 /* Print the node NODE on standard error, for debugging.
 981    Most nodes referred to by this one are printed recursively
 982    down to a depth of six.  */
 983
 984 DEBUG_FUNCTION void
 985 debug_tree (tree node)
 986 {
 987   table = new hash_set<tree> (HASH_SIZE);
 988   print_node (stderr, "", node, 0);
 989   delete table;
 990   table = NULL;
 991   putc ('\n', stderr);
 992 }
 993
 994 DEBUG_FUNCTION void
 995 debug_raw (const tree_node &ref)
 996 {
 997   debug_tree (const_cast <tree> (&ref));
 998 }
 999
1000 DEBUG_FUNCTION void
1001 debug_raw (const tree_node *ptr)
1002 {
1003   if (ptr)
1004     debug_raw (*ptr);
1005   else
1006     fprintf (stderr, "<nil>\n");
1007 }
1008
1009 static void
1010 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options)
1011 {
1012   if (DECL_P (ptr))
1013     lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0);
1014   else if (TYPE_P (ptr))
1015     lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0);
1016   else if (TREE_CODE (ptr) == IDENTIFIER_NODE)
1017     lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0);
1018   else
1019     print_generic_expr (stderr, const_cast <tree_node*> (ptr), options);
1020   fprintf (stderr, "\n");
1021 }
1022
1023 DEBUG_FUNCTION void
1024 debug (const tree_node &ref)
1025 {
1026   dump_tree_via_hooks (&ref, 0);
1027 }
1028
1029 DEBUG_FUNCTION void
1030 debug (const tree_node *ptr)
1031 {
1032   if (ptr)
1033     debug (*ptr);
1034   else
1035     fprintf (stderr, "<nil>\n");
1036 }
1037
1038 DEBUG_FUNCTION void
1039 debug_verbose (const tree_node &ref)
1040 {
1041   dump_tree_via_hooks (&ref, TDF_VERBOSE);
1042 }
1043
1044 DEBUG_FUNCTION void
1045 debug_verbose (const tree_node *ptr)
1046 {
1047   if (ptr)
1048     debug_verbose (*ptr);
1049   else
1050     fprintf (stderr, "<nil>\n");
1051 }
1052
1053 DEBUG_FUNCTION void
1054 debug_head (const tree_node &ref)
1055 {
1056   debug (ref);
1057 }
1058
1059 DEBUG_FUNCTION void
1060 debug_head (const tree_node *ptr)
1061 {
1062   if (ptr)
1063     debug_head (*ptr);
1064   else
1065     fprintf (stderr, "<nil>\n");
1066 }
1067
1068 DEBUG_FUNCTION void
1069 debug_body (const tree_node &ref)
1070 {
1071   if (TREE_CODE (&ref) == FUNCTION_DECL)
1072     dump_function_to_file (const_cast <tree_node*> (&ref), stderr, 0);
1073   else
1074     debug (ref);
1075 }
1076
1077 DEBUG_FUNCTION void
1078 debug_body (const tree_node *ptr)
1079 {
1080   if (ptr)
1081     debug_body (*ptr);
1082   else
1083     fprintf (stderr, "<nil>\n");
1084 }
1085
1086 /* Print the vector of trees VEC on standard error, for debugging.
1087    Most nodes referred to by this one are printed recursively
1088    down to a depth of six.  */
1089
1090 DEBUG_FUNCTION void
1091 debug_raw (vec<tree, va_gc> &ref)
1092 {
1093   tree elt;
1094   unsigned ix;
1095
1096   /* Print the slot this node is in, and its code, and address.  */
1097   fprintf (stderr, "<VEC");
1098   dump_addr (stderr, " ", ref.address ());
1099
1100   FOR_EACH_VEC_ELT (ref, ix, elt)
1101     {
1102       fprintf (stderr, "elt %d ", ix);
1103       debug_raw (elt);
1104     }
1105 }
1106
1107 DEBUG_FUNCTION void
1108 debug (vec<tree, va_gc> &ref)
1109 {
1110   tree elt;
1111   unsigned ix;
1112
1113   /* Print the slot this node is in, and its code, and address.  */
1114   fprintf (stderr, "<VEC");
1115   dump_addr (stderr, " ", ref.address ());
1116
1117   FOR_EACH_VEC_ELT (ref, ix, elt)
1118     {
1119       fprintf (stderr, "elt %d ", ix);
1120       debug (elt);
1121     }
1122 }
1123
1124 DEBUG_FUNCTION void
1125 debug (vec<tree, va_gc> *ptr)
1126 {
1127   if (ptr)
1128     debug (*ptr);
1129   else
1130     fprintf (stderr, "<nil>\n");
1131 }
1132
1133 DEBUG_FUNCTION void
1134 debug_raw (vec<tree, va_gc> *ptr)
1135 {
1136   if (ptr)
1137     debug_raw (*ptr);
1138   else
1139     fprintf (stderr, "<nil>\n");
1140 }
1141
1142 DEBUG_FUNCTION void
1143 debug_vec_tree (vec<tree, va_gc> *vec)
1144 {
1145   debug_raw (vec);
1146 }