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