1 /* Prints out tree in human readable form - GCC 2 Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "tm.h" 27 #include "tree.h" 28 #include "ggc.h" 29 #include "langhooks.h" 30 #include "tree-iterator.h" 31 #include "diagnostic.h" 32 #include "gimple-pretty-print.h" 33 #include "tree-flow.h" 34 #include "tree-pass.h" 35 36 /* Define the hash table of nodes already seen. 37 Such nodes are not repeated; brief cross-references are used. */ 38 39 #define HASH_SIZE 37 40 41 struct bucket 42 { 43 tree node; 44 struct bucket *next; 45 }; 46 47 static struct bucket **table; 48 49 /* Print the node NODE on standard error, for debugging. 50 Most nodes referred to by this one are printed recursively 51 down to a depth of six. */ 52 53 DEBUG_FUNCTION void 54 debug_tree (tree node) 55 { 56 table = XCNEWVEC (struct bucket *, HASH_SIZE); 57 print_node (stderr, "", node, 0); 58 free (table); 59 table = 0; 60 putc ('\n', stderr); 61 } 62 63 /* Print the vector of trees VEC on standard error, for debugging. 64 Most nodes referred to by this one are printed recursively 65 down to a depth of six. */ 66 67 DEBUG_FUNCTION void 68 debug_vec_tree (VEC(tree,gc) *vec) 69 { 70 table = XCNEWVEC (struct bucket *, HASH_SIZE); 71 print_vec_tree (stderr, "", vec, 0); 72 free (table); 73 table = 0; 74 putc ('\n', stderr); 75 } 76 77 /* Print PREFIX and ADDR to FILE. */ 78 void 79 dump_addr (FILE *file, const char *prefix, const void *addr) 80 { 81 if (flag_dump_noaddr || flag_dump_unnumbered) 82 fprintf (file, "%s#", prefix); 83 else 84 fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr); 85 } 86 87 /* Print a node in brief fashion, with just the code, address and name. */ 88 89 void 90 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) 91 { 92 enum tree_code_class tclass; 93 94 if (node == 0) 95 return; 96 97 tclass = TREE_CODE_CLASS (TREE_CODE (node)); 98 99 /* Always print the slot this node is in, and its code, address and 100 name if any. */ 101 if (indent > 0) 102 fprintf (file, " "); 103 fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]); 104 dump_addr (file, " ", node); 105 106 if (tclass == tcc_declaration) 107 { 108 if (DECL_NAME (node)) 109 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); 110 else if (TREE_CODE (node) == LABEL_DECL 111 && LABEL_DECL_UID (node) != -1) 112 { 113 if (dump_flags & TDF_NOUID) 114 fprintf (file, " L.xxxx"); 115 else 116 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node)); 117 } 118 else 119 { 120 if (dump_flags & TDF_NOUID) 121 fprintf (file, " %c.xxxx", 122 TREE_CODE (node) == CONST_DECL ? 'C' : 'D'); 123 else 124 fprintf (file, " %c.%u", 125 TREE_CODE (node) == CONST_DECL ? 'C' : 'D', 126 DECL_UID (node)); 127 } 128 } 129 else if (tclass == tcc_type) 130 { 131 if (TYPE_NAME (node)) 132 { 133 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 134 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); 135 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 136 && DECL_NAME (TYPE_NAME (node))) 137 fprintf (file, " %s", 138 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); 139 } 140 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) 141 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node)); 142 } 143 if (TREE_CODE (node) == IDENTIFIER_NODE) 144 fprintf (file, " %s", IDENTIFIER_POINTER (node)); 145 146 /* We might as well always print the value of an integer or real. */ 147 if (TREE_CODE (node) == INTEGER_CST) 148 { 149 if (TREE_OVERFLOW (node)) 150 fprintf (file, " overflow"); 151 152 fprintf (file, " "); 153 if (TREE_INT_CST_HIGH (node) == 0) 154 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node)); 155 else if (TREE_INT_CST_HIGH (node) == -1 156 && TREE_INT_CST_LOW (node) != 0) 157 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED, 158 -TREE_INT_CST_LOW (node)); 159 else 160 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, 161 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (node), 162 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (node)); 163 } 164 if (TREE_CODE (node) == REAL_CST) 165 { 166 REAL_VALUE_TYPE d; 167 168 if (TREE_OVERFLOW (node)) 169 fprintf (file, " overflow"); 170 171 d = TREE_REAL_CST (node); 172 if (REAL_VALUE_ISINF (d)) 173 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); 174 else if (REAL_VALUE_ISNAN (d)) 175 fprintf (file, " Nan"); 176 else 177 { 178 char string[60]; 179 real_to_decimal (string, &d, sizeof (string), 0, 1); 180 fprintf (file, " %s", string); 181 } 182 } 183 if (TREE_CODE (node) == FIXED_CST) 184 { 185 FIXED_VALUE_TYPE f; 186 char string[60]; 187 188 if (TREE_OVERFLOW (node)) 189 fprintf (file, " overflow"); 190 191 f = TREE_FIXED_CST (node); 192 fixed_to_decimal (string, &f, sizeof (string)); 193 fprintf (file, " %s", string); 194 } 195 196 fprintf (file, ">"); 197 } 198 199 void 200 indent_to (FILE *file, int column) 201 { 202 int i; 203 204 /* Since this is the long way, indent to desired column. */ 205 if (column > 0) 206 fprintf (file, "\n"); 207 for (i = 0; i < column; i++) 208 fprintf (file, " "); 209 } 210 211 /* Print the node NODE in full on file FILE, preceded by PREFIX, 212 starting in column INDENT. */ 213 214 void 215 print_node (FILE *file, const char *prefix, tree node, int indent) 216 { 217 int hash; 218 struct bucket *b; 219 enum machine_mode mode; 220 enum tree_code_class tclass; 221 int len; 222 int i; 223 expanded_location xloc; 224 enum tree_code code; 225 226 if (node == 0) 227 return; 228 229 code = TREE_CODE (node); 230 tclass = TREE_CODE_CLASS (code); 231 232 /* Don't get too deep in nesting. If the user wants to see deeper, 233 it is easy to use the address of a lowest-level node 234 as an argument in another call to debug_tree. */ 235 236 if (indent > 24) 237 { 238 print_node_brief (file, prefix, node, indent); 239 return; 240 } 241 242 if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration)) 243 { 244 print_node_brief (file, prefix, node, indent); 245 return; 246 } 247 248 /* It is unsafe to look at any other fields of an ERROR_MARK node. */ 249 if (code == ERROR_MARK) 250 { 251 print_node_brief (file, prefix, node, indent); 252 return; 253 } 254 255 /* Allow this function to be called if the table is not there. */ 256 if (table) 257 { 258 hash = ((unsigned long) node) % HASH_SIZE; 259 260 /* If node is in the table, just mention its address. */ 261 for (b = table[hash]; b; b = b->next) 262 if (b->node == node) 263 { 264 print_node_brief (file, prefix, node, indent); 265 return; 266 } 267 268 /* Add this node to the table. */ 269 b = XNEW (struct bucket); 270 b->node = node; 271 b->next = table[hash]; 272 table[hash] = b; 273 } 274 275 /* Indent to the specified column, since this is the long form. */ 276 indent_to (file, indent); 277 278 /* Print the slot this node is in, and its code, and address. */ 279 fprintf (file, "%s <%s", prefix, tree_code_name[(int) code]); 280 dump_addr (file, " ", node); 281 282 /* Print the name, if any. */ 283 if (tclass == tcc_declaration) 284 { 285 if (DECL_NAME (node)) 286 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); 287 else if (code == LABEL_DECL 288 && LABEL_DECL_UID (node) != -1) 289 { 290 if (dump_flags & TDF_NOUID) 291 fprintf (file, " L.xxxx"); 292 else 293 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node)); 294 } 295 else 296 { 297 if (dump_flags & TDF_NOUID) 298 fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D'); 299 else 300 fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D', 301 DECL_UID (node)); 302 } 303 } 304 else if (tclass == tcc_type) 305 { 306 if (TYPE_NAME (node)) 307 { 308 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 309 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); 310 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 311 && DECL_NAME (TYPE_NAME (node))) 312 fprintf (file, " %s", 313 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); 314 } 315 } 316 if (code == IDENTIFIER_NODE) 317 fprintf (file, " %s", IDENTIFIER_POINTER (node)); 318 319 if (code == INTEGER_CST) 320 { 321 if (indent <= 4) 322 print_node_brief (file, "type", TREE_TYPE (node), indent + 4); 323 } 324 else if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) 325 { 326 print_node (file, "type", TREE_TYPE (node), indent + 4); 327 if (TREE_TYPE (node)) 328 indent_to (file, indent + 3); 329 } 330 331 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node)) 332 fputs (" side-effects", file); 333 334 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node)) 335 fputs (" readonly", file); 336 if (!TYPE_P (node) && TREE_CONSTANT (node)) 337 fputs (" constant", file); 338 else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node)) 339 fputs (" sizes-gimplified", file); 340 341 if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) 342 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node)); 343 344 if (TREE_ADDRESSABLE (node)) 345 fputs (" addressable", file); 346 if (TREE_THIS_VOLATILE (node)) 347 fputs (" volatile", file); 348 if (TREE_ASM_WRITTEN (node)) 349 fputs (" asm_written", file); 350 if (TREE_USED (node)) 351 fputs (" used", file); 352 if (TREE_NOTHROW (node)) 353 fputs (TYPE_P (node) ? " align-ok" : " nothrow", file); 354 if (TREE_PUBLIC (node)) 355 fputs (" public", file); 356 if (TREE_PRIVATE (node)) 357 fputs (" private", file); 358 if (TREE_PROTECTED (node)) 359 fputs (" protected", file); 360 if (TREE_STATIC (node)) 361 fputs (" static", file); 362 if (TREE_DEPRECATED (node)) 363 fputs (" deprecated", file); 364 if (TREE_VISITED (node)) 365 fputs (" visited", file); 366 if (TREE_LANG_FLAG_0 (node)) 367 fputs (" tree_0", file); 368 if (TREE_LANG_FLAG_1 (node)) 369 fputs (" tree_1", file); 370 if (TREE_LANG_FLAG_2 (node)) 371 fputs (" tree_2", file); 372 if (TREE_LANG_FLAG_3 (node)) 373 fputs (" tree_3", file); 374 if (TREE_LANG_FLAG_4 (node)) 375 fputs (" tree_4", file); 376 if (TREE_LANG_FLAG_5 (node)) 377 fputs (" tree_5", file); 378 if (TREE_LANG_FLAG_6 (node)) 379 fputs (" tree_6", file); 380 381 /* DECL_ nodes have additional attributes. */ 382 383 switch (TREE_CODE_CLASS (code)) 384 { 385 case tcc_declaration: 386 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 387 { 388 if (DECL_UNSIGNED (node)) 389 fputs (" unsigned", file); 390 if (DECL_IGNORED_P (node)) 391 fputs (" ignored", file); 392 if (DECL_ABSTRACT (node)) 393 fputs (" abstract", file); 394 if (DECL_EXTERNAL (node)) 395 fputs (" external", file); 396 if (DECL_NONLOCAL (node)) 397 fputs (" nonlocal", file); 398 } 399 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 400 { 401 if (DECL_WEAK (node)) 402 fputs (" weak", file); 403 if (DECL_IN_SYSTEM_HEADER (node)) 404 fputs (" in_system_header", file); 405 } 406 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL) 407 && code != LABEL_DECL 408 && code != FUNCTION_DECL 409 && DECL_REGISTER (node)) 410 fputs (" regdecl", file); 411 412 if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node)) 413 fputs (" suppress-debug", file); 414 415 if (code == FUNCTION_DECL 416 && DECL_FUNCTION_SPECIFIC_TARGET (node)) 417 fputs (" function-specific-target", file); 418 if (code == FUNCTION_DECL 419 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node)) 420 fputs (" function-specific-opt", file); 421 if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node)) 422 fputs (" autoinline", file); 423 if (code == FUNCTION_DECL && DECL_BUILT_IN (node)) 424 fputs (" built-in", file); 425 if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node)) 426 fputs (" static-chain", file); 427 if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node)) 428 fputs (" tm-clone", file); 429 430 if (code == FIELD_DECL && DECL_PACKED (node)) 431 fputs (" packed", file); 432 if (code == FIELD_DECL && DECL_BIT_FIELD (node)) 433 fputs (" bit-field", file); 434 if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node)) 435 fputs (" nonaddressable", file); 436 437 if (code == LABEL_DECL && DECL_ERROR_ISSUED (node)) 438 fputs (" error-issued", file); 439 if (code == LABEL_DECL && EH_LANDING_PAD_NR (node)) 440 fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node)); 441 442 if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node)) 443 fputs (" in-text-section", file); 444 if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node)) 445 fputs (" in-constant-pool", file); 446 if (code == VAR_DECL && DECL_COMMON (node)) 447 fputs (" common", file); 448 if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node)) 449 { 450 enum tls_model kind = DECL_TLS_MODEL (node); 451 switch (kind) 452 { 453 case TLS_MODEL_GLOBAL_DYNAMIC: 454 fputs (" tls-global-dynamic", file); 455 break; 456 case TLS_MODEL_LOCAL_DYNAMIC: 457 fputs (" tls-local-dynamic", file); 458 break; 459 case TLS_MODEL_INITIAL_EXEC: 460 fputs (" tls-initial-exec", file); 461 break; 462 case TLS_MODEL_LOCAL_EXEC: 463 fputs (" tls-local-exec", file); 464 break; 465 default: 466 gcc_unreachable (); 467 } 468 } 469 470 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 471 { 472 if (DECL_VIRTUAL_P (node)) 473 fputs (" virtual", file); 474 if (DECL_PRESERVE_P (node)) 475 fputs (" preserve", file); 476 if (DECL_LANG_FLAG_0 (node)) 477 fputs (" decl_0", file); 478 if (DECL_LANG_FLAG_1 (node)) 479 fputs (" decl_1", file); 480 if (DECL_LANG_FLAG_2 (node)) 481 fputs (" decl_2", file); 482 if (DECL_LANG_FLAG_3 (node)) 483 fputs (" decl_3", file); 484 if (DECL_LANG_FLAG_4 (node)) 485 fputs (" decl_4", file); 486 if (DECL_LANG_FLAG_5 (node)) 487 fputs (" decl_5", file); 488 if (DECL_LANG_FLAG_6 (node)) 489 fputs (" decl_6", file); 490 if (DECL_LANG_FLAG_7 (node)) 491 fputs (" decl_7", file); 492 493 mode = DECL_MODE (node); 494 fprintf (file, " %s", GET_MODE_NAME (mode)); 495 } 496 497 if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) 498 && DECL_BY_REFERENCE (node)) 499 fputs (" passed-by-reference", file); 500 501 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node)) 502 fputs (" defer-output", file); 503 504 505 xloc = expand_location (DECL_SOURCE_LOCATION (node)); 506 fprintf (file, " file %s line %d col %d", xloc.file, xloc.line, 507 xloc.column); 508 509 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 510 { 511 print_node (file, "size", DECL_SIZE (node), indent + 4); 512 print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4); 513 514 if (code != FUNCTION_DECL || DECL_BUILT_IN (node)) 515 indent_to (file, indent + 3); 516 517 if (DECL_USER_ALIGN (node)) 518 fprintf (file, " user"); 519 520 fprintf (file, " align %d", DECL_ALIGN (node)); 521 if (code == FIELD_DECL) 522 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED, 523 DECL_OFFSET_ALIGN (node)); 524 525 if (code == FUNCTION_DECL && DECL_BUILT_IN (node)) 526 { 527 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD) 528 fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node)); 529 else 530 fprintf (file, " built-in %s:%s", 531 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)], 532 built_in_names[(int) DECL_FUNCTION_CODE (node)]); 533 } 534 } 535 if (code == FIELD_DECL) 536 { 537 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4); 538 print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node), 539 indent + 4); 540 if (DECL_BIT_FIELD_TYPE (node)) 541 print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node), 542 indent + 4); 543 } 544 545 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4); 546 547 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 548 { 549 print_node_brief (file, "attributes", 550 DECL_ATTRIBUTES (node), indent + 4); 551 if (code != PARM_DECL) 552 print_node_brief (file, "initial", DECL_INITIAL (node), 553 indent + 4); 554 } 555 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) 556 { 557 print_node_brief (file, "abstract_origin", 558 DECL_ABSTRACT_ORIGIN (node), indent + 4); 559 } 560 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) 561 { 562 print_node (file, "arguments", DECL_ARGUMENT_FLD (node), indent + 4); 563 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4); 564 } 565 566 lang_hooks.print_decl (file, node, indent); 567 568 if (DECL_RTL_SET_P (node)) 569 { 570 indent_to (file, indent + 4); 571 print_rtl (file, DECL_RTL (node)); 572 } 573 574 if (code == PARM_DECL) 575 { 576 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4); 577 578 if (DECL_INCOMING_RTL (node) != 0) 579 { 580 indent_to (file, indent + 4); 581 fprintf (file, "incoming-rtl "); 582 print_rtl (file, DECL_INCOMING_RTL (node)); 583 } 584 } 585 else if (code == FUNCTION_DECL 586 && DECL_STRUCT_FUNCTION (node) != 0) 587 { 588 indent_to (file, indent + 4); 589 dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node)); 590 } 591 592 if ((code == VAR_DECL || code == PARM_DECL) 593 && DECL_HAS_VALUE_EXPR_P (node)) 594 print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4); 595 596 /* Print the decl chain only if decl is at second level. */ 597 if (indent == 4) 598 print_node (file, "chain", TREE_CHAIN (node), indent + 4); 599 else 600 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); 601 break; 602 603 case tcc_type: 604 if (TYPE_UNSIGNED (node)) 605 fputs (" unsigned", file); 606 607 /* The no-force-blk flag is used for different things in 608 different types. */ 609 if ((code == RECORD_TYPE 610 || code == UNION_TYPE 611 || code == QUAL_UNION_TYPE) 612 && TYPE_NO_FORCE_BLK (node)) 613 fputs (" no-force-blk", file); 614 else if (code == INTEGER_TYPE 615 && TYPE_IS_SIZETYPE (node)) 616 fputs (" sizetype", file); 617 618 if (TYPE_STRING_FLAG (node)) 619 fputs (" string-flag", file); 620 if (TYPE_NEEDS_CONSTRUCTING (node)) 621 fputs (" needs-constructing", file); 622 623 /* The transparent-union flag is used for different things in 624 different nodes. */ 625 if ((code == UNION_TYPE || code == RECORD_TYPE) 626 && TYPE_TRANSPARENT_AGGR (node)) 627 fputs (" transparent-aggr", file); 628 else if (code == ARRAY_TYPE 629 && TYPE_NONALIASED_COMPONENT (node)) 630 fputs (" nonaliased-component", file); 631 632 if (TYPE_PACKED (node)) 633 fputs (" packed", file); 634 635 if (TYPE_RESTRICT (node)) 636 fputs (" restrict", file); 637 638 if (TYPE_LANG_FLAG_0 (node)) 639 fputs (" type_0", file); 640 if (TYPE_LANG_FLAG_1 (node)) 641 fputs (" type_1", file); 642 if (TYPE_LANG_FLAG_2 (node)) 643 fputs (" type_2", file); 644 if (TYPE_LANG_FLAG_3 (node)) 645 fputs (" type_3", file); 646 if (TYPE_LANG_FLAG_4 (node)) 647 fputs (" type_4", file); 648 if (TYPE_LANG_FLAG_5 (node)) 649 fputs (" type_5", file); 650 if (TYPE_LANG_FLAG_6 (node)) 651 fputs (" type_6", file); 652 653 mode = TYPE_MODE (node); 654 fprintf (file, " %s", GET_MODE_NAME (mode)); 655 656 print_node (file, "size", TYPE_SIZE (node), indent + 4); 657 print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4); 658 indent_to (file, indent + 3); 659 660 if (TYPE_USER_ALIGN (node)) 661 fprintf (file, " user"); 662 663 fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC, 664 TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node), 665 (HOST_WIDE_INT) TYPE_ALIAS_SET (node)); 666 667 if (TYPE_STRUCTURAL_EQUALITY_P (node)) 668 fprintf (file, " structural equality"); 669 else 670 dump_addr (file, " canonical type ", TYPE_CANONICAL (node)); 671 672 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4); 673 674 if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE 675 || code == FIXED_POINT_TYPE) 676 { 677 fprintf (file, " precision %d", TYPE_PRECISION (node)); 678 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4); 679 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4); 680 } 681 682 if (code == ENUMERAL_TYPE) 683 print_node (file, "values", TYPE_VALUES (node), indent + 4); 684 else if (code == ARRAY_TYPE) 685 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4); 686 else if (code == VECTOR_TYPE) 687 fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node)); 688 else if (code == RECORD_TYPE 689 || code == UNION_TYPE 690 || code == QUAL_UNION_TYPE) 691 print_node (file, "fields", TYPE_FIELDS (node), indent + 4); 692 else if (code == FUNCTION_TYPE 693 || code == METHOD_TYPE) 694 { 695 if (TYPE_METHOD_BASETYPE (node)) 696 print_node_brief (file, "method basetype", 697 TYPE_METHOD_BASETYPE (node), indent + 4); 698 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4); 699 } 700 else if (code == OFFSET_TYPE) 701 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node), 702 indent + 4); 703 704 if (TYPE_CONTEXT (node)) 705 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4); 706 707 lang_hooks.print_type (file, node, indent); 708 709 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node)) 710 indent_to (file, indent + 3); 711 712 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), 713 indent + 4); 714 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), 715 indent + 4); 716 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); 717 break; 718 719 case tcc_expression: 720 case tcc_comparison: 721 case tcc_unary: 722 case tcc_binary: 723 case tcc_reference: 724 case tcc_statement: 725 case tcc_vl_exp: 726 if (code == BIND_EXPR) 727 { 728 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4); 729 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4); 730 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4); 731 break; 732 } 733 if (code == CALL_EXPR) 734 { 735 call_expr_arg_iterator iter; 736 tree arg; 737 print_node (file, "fn", CALL_EXPR_FN (node), indent + 4); 738 print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node), 739 indent + 4); 740 i = 0; 741 FOR_EACH_CALL_EXPR_ARG (arg, iter, node) 742 { 743 char temp[10]; 744 sprintf (temp, "arg %d", i); 745 print_node (file, temp, arg, indent + 4); 746 i++; 747 } 748 } 749 else 750 { 751 len = TREE_OPERAND_LENGTH (node); 752 753 for (i = 0; i < len; i++) 754 { 755 char temp[10]; 756 757 sprintf (temp, "arg %d", i); 758 print_node (file, temp, TREE_OPERAND (node, i), indent + 4); 759 } 760 } 761 if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) 762 print_node (file, "chain", TREE_CHAIN (node), indent + 4); 763 break; 764 765 case tcc_constant: 766 case tcc_exceptional: 767 switch (code) 768 { 769 case INTEGER_CST: 770 if (TREE_OVERFLOW (node)) 771 fprintf (file, " overflow"); 772 773 fprintf (file, " "); 774 if (TREE_INT_CST_HIGH (node) == 0) 775 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, 776 TREE_INT_CST_LOW (node)); 777 else if (TREE_INT_CST_HIGH (node) == -1 778 && TREE_INT_CST_LOW (node) != 0) 779 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED, 780 -TREE_INT_CST_LOW (node)); 781 else 782 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, 783 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (node), 784 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (node)); 785 break; 786 787 case REAL_CST: 788 { 789 REAL_VALUE_TYPE d; 790 791 if (TREE_OVERFLOW (node)) 792 fprintf (file, " overflow"); 793 794 d = TREE_REAL_CST (node); 795 if (REAL_VALUE_ISINF (d)) 796 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); 797 else if (REAL_VALUE_ISNAN (d)) 798 fprintf (file, " Nan"); 799 else 800 { 801 char string[64]; 802 real_to_decimal (string, &d, sizeof (string), 0, 1); 803 fprintf (file, " %s", string); 804 } 805 } 806 break; 807 808 case FIXED_CST: 809 { 810 FIXED_VALUE_TYPE f; 811 char string[64]; 812 813 if (TREE_OVERFLOW (node)) 814 fprintf (file, " overflow"); 815 816 f = TREE_FIXED_CST (node); 817 fixed_to_decimal (string, &f, sizeof (string)); 818 fprintf (file, " %s", string); 819 } 820 break; 821 822 case VECTOR_CST: 823 { 824 tree vals = TREE_VECTOR_CST_ELTS (node); 825 char buf[10]; 826 tree link; 827 int i; 828 829 i = 0; 830 for (link = vals; link; link = TREE_CHAIN (link), ++i) 831 { 832 sprintf (buf, "elt%d: ", i); 833 print_node (file, buf, TREE_VALUE (link), indent + 4); 834 } 835 } 836 break; 837 838 case COMPLEX_CST: 839 print_node (file, "real", TREE_REALPART (node), indent + 4); 840 print_node (file, "imag", TREE_IMAGPART (node), indent + 4); 841 break; 842 843 case STRING_CST: 844 { 845 const char *p = TREE_STRING_POINTER (node); 846 int i = TREE_STRING_LENGTH (node); 847 fputs (" \"", file); 848 while (--i >= 0) 849 { 850 char ch = *p++; 851 if (ch >= ' ' && ch < 127) 852 putc (ch, file); 853 else 854 fprintf(file, "\\%03o", ch & 0xFF); 855 } 856 fputc ('\"', file); 857 } 858 break; 859 860 case IDENTIFIER_NODE: 861 lang_hooks.print_identifier (file, node, indent); 862 break; 863 864 case TREE_LIST: 865 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4); 866 print_node (file, "value", TREE_VALUE (node), indent + 4); 867 print_node (file, "chain", TREE_CHAIN (node), indent + 4); 868 break; 869 870 case TREE_VEC: 871 len = TREE_VEC_LENGTH (node); 872 for (i = 0; i < len; i++) 873 if (TREE_VEC_ELT (node, i)) 874 { 875 char temp[10]; 876 sprintf (temp, "elt %d", i); 877 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4); 878 } 879 break; 880 881 case CONSTRUCTOR: 882 { 883 unsigned HOST_WIDE_INT cnt; 884 tree index, value; 885 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)); 886 fprintf (file, " lngt %d", len); 887 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), 888 cnt, index, value) 889 { 890 print_node (file, "idx", index, indent + 4); 891 print_node (file, "val", value, indent + 4); 892 } 893 } 894 break; 895 896 case STATEMENT_LIST: 897 dump_addr (file, " head ", node->stmt_list.head); 898 dump_addr (file, " tail ", node->stmt_list.tail); 899 fprintf (file, " stmts"); 900 { 901 tree_stmt_iterator i; 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 dump_addr (file, " ", tsi_stmt (i)); 907 } 908 fprintf (file, "\n"); 909 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i)) 910 { 911 /* Not printing the addresses of the (not-a-tree) 912 'struct tree_stmt_list_node's. */ 913 print_node (file, "stmt", tsi_stmt (i), indent + 4); 914 } 915 } 916 break; 917 918 case BLOCK: 919 print_node (file, "vars", BLOCK_VARS (node), indent + 4); 920 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), 921 indent + 4); 922 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4); 923 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4); 924 print_node (file, "abstract_origin", 925 BLOCK_ABSTRACT_ORIGIN (node), indent + 4); 926 break; 927 928 case SSA_NAME: 929 print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4); 930 fprintf (file, "def_stmt "); 931 print_gimple_stmt (file, SSA_NAME_DEF_STMT (node), indent + 4, 0); 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 default: 977 if (EXCEPTIONAL_CLASS_P (node)) 978 lang_hooks.print_xnode (file, node, indent); 979 break; 980 } 981 982 break; 983 } 984 985 if (EXPR_HAS_LOCATION (node)) 986 { 987 expanded_location xloc = expand_location (EXPR_LOCATION (node)); 988 indent_to (file, indent+4); 989 fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column); 990 } 991 992 fprintf (file, ">"); 993 } 994 995 /* Print the tree vector VEC in full on file FILE, preceded by PREFIX, 996 starting in column INDENT. */ 997 998 void 999 print_vec_tree (FILE *file, const char *prefix, VEC(tree,gc) *vec, int indent) 1000 { 1001 tree elt; 1002 unsigned ix; 1003 1004 /* Indent to the specified column, since this is the long form. */ 1005 indent_to (file, indent); 1006 1007 /* Print the slot this node is in, and its code, and address. */ 1008 fprintf (file, "%s <VEC", prefix); 1009 dump_addr (file, " ", vec); 1010 1011 FOR_EACH_VEC_ELT (tree, vec, ix, elt) 1012 { 1013 char temp[10]; 1014 sprintf (temp, "elt %d", ix); 1015 print_node (file, temp, elt, indent + 4); 1016 } 1017 } 1018