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 "tree-dump.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 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, int 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 } 1147