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