1 /* Tree-dumping functionality for intermediate representation. 2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 3 2010, 2011 Free Software Foundation, Inc. 4 Written by Mark Mitchell <mark@codesourcery.com> 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 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "tree.h" 27 #include "splay-tree.h" 28 #include "filenames.h" 29 #include "diagnostic-core.h" 30 #include "toplev.h" 31 #include "tree-dump.h" 32 #include "tree-pass.h" 33 #include "langhooks.h" 34 #include "tree-iterator.h" 35 36 /* If non-NULL, return one past-the-end of the matching SUBPART of 37 the WHOLE string. */ 38 #define skip_leading_substring(whole, part) \ 39 (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part)) 40 41 static unsigned int queue (dump_info_p, const_tree, int); 42 static void dump_index (dump_info_p, unsigned int); 43 static void dequeue_and_dump (dump_info_p); 44 static void dump_new_line (dump_info_p); 45 static void dump_maybe_newline (dump_info_p); 46 47 /* Add T to the end of the queue of nodes to dump. Returns the index 48 assigned to T. */ 49 50 static unsigned int 51 queue (dump_info_p di, const_tree t, int flags) 52 { 53 dump_queue_p dq; 54 dump_node_info_p dni; 55 unsigned int index; 56 57 /* Assign the next available index to T. */ 58 index = ++di->index; 59 60 /* Obtain a new queue node. */ 61 if (di->free_list) 62 { 63 dq = di->free_list; 64 di->free_list = dq->next; 65 } 66 else 67 dq = XNEW (struct dump_queue); 68 69 /* Create a new entry in the splay-tree. */ 70 dni = XNEW (struct dump_node_info); 71 dni->index = index; 72 dni->binfo_p = ((flags & DUMP_BINFO) != 0); 73 dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t, 74 (splay_tree_value) dni); 75 76 /* Add it to the end of the queue. */ 77 dq->next = 0; 78 if (!di->queue_end) 79 di->queue = dq; 80 else 81 di->queue_end->next = dq; 82 di->queue_end = dq; 83 84 /* Return the index. */ 85 return index; 86 } 87 88 static void 89 dump_index (dump_info_p di, unsigned int index) 90 { 91 fprintf (di->stream, "@%-6u ", index); 92 di->column += 8; 93 } 94 95 /* If T has not already been output, queue it for subsequent output. 96 FIELD is a string to print before printing the index. Then, the 97 index of T is printed. */ 98 99 void 100 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags) 101 { 102 unsigned int index; 103 splay_tree_node n; 104 105 /* If there's no node, just return. This makes for fewer checks in 106 our callers. */ 107 if (!t) 108 return; 109 110 /* See if we've already queued or dumped this node. */ 111 n = splay_tree_lookup (di->nodes, (splay_tree_key) t); 112 if (n) 113 index = ((dump_node_info_p) n->value)->index; 114 else 115 /* If we haven't, add it to the queue. */ 116 index = queue (di, t, flags); 117 118 /* Print the index of the node. */ 119 dump_maybe_newline (di); 120 fprintf (di->stream, "%-4s: ", field); 121 di->column += 6; 122 dump_index (di, index); 123 } 124 125 /* Dump the type of T. */ 126 127 void 128 queue_and_dump_type (dump_info_p di, const_tree t) 129 { 130 queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE); 131 } 132 133 /* Dump column control */ 134 #define SOL_COLUMN 25 /* Start of line column. */ 135 #define EOL_COLUMN 55 /* End of line column. */ 136 #define COLUMN_ALIGNMENT 15 /* Alignment. */ 137 138 /* Insert a new line in the dump output, and indent to an appropriate 139 place to start printing more fields. */ 140 141 static void 142 dump_new_line (dump_info_p di) 143 { 144 fprintf (di->stream, "\n%*s", SOL_COLUMN, ""); 145 di->column = SOL_COLUMN; 146 } 147 148 /* If necessary, insert a new line. */ 149 150 static void 151 dump_maybe_newline (dump_info_p di) 152 { 153 int extra; 154 155 /* See if we need a new line. */ 156 if (di->column > EOL_COLUMN) 157 dump_new_line (di); 158 /* See if we need any padding. */ 159 else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0) 160 { 161 fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, ""); 162 di->column += COLUMN_ALIGNMENT - extra; 163 } 164 } 165 166 /* Dump pointer PTR using FIELD to identify it. */ 167 168 void 169 dump_pointer (dump_info_p di, const char *field, void *ptr) 170 { 171 dump_maybe_newline (di); 172 fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field, 173 (unsigned HOST_WIDE_INT) (uintptr_t) ptr); 174 di->column += 15; 175 } 176 177 /* Dump integer I using FIELD to identify it. */ 178 179 void 180 dump_int (dump_info_p di, const char *field, int i) 181 { 182 dump_maybe_newline (di); 183 fprintf (di->stream, "%-4s: %-7d ", field, i); 184 di->column += 14; 185 } 186 187 /* Dump the floating point value R, using FIELD to identify it. */ 188 189 static void 190 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r) 191 { 192 char buf[32]; 193 real_to_decimal (buf, r, sizeof (buf), 0, true); 194 dump_maybe_newline (di); 195 fprintf (di->stream, "%-4s: %s ", field, buf); 196 di->column += strlen (buf) + 7; 197 } 198 199 /* Dump the fixed-point value F, using FIELD to identify it. */ 200 201 static void 202 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f) 203 { 204 char buf[32]; 205 fixed_to_decimal (buf, f, sizeof (buf)); 206 dump_maybe_newline (di); 207 fprintf (di->stream, "%-4s: %s ", field, buf); 208 di->column += strlen (buf) + 7; 209 } 210 211 212 /* Dump the string S. */ 213 214 void 215 dump_string (dump_info_p di, const char *string) 216 { 217 dump_maybe_newline (di); 218 fprintf (di->stream, "%-13s ", string); 219 if (strlen (string) > 13) 220 di->column += strlen (string) + 1; 221 else 222 di->column += 14; 223 } 224 225 /* Dump the string field S. */ 226 227 void 228 dump_string_field (dump_info_p di, const char *field, const char *string) 229 { 230 dump_maybe_newline (di); 231 fprintf (di->stream, "%-4s: %-7s ", field, string); 232 if (strlen (string) > 7) 233 di->column += 6 + strlen (string) + 1; 234 else 235 di->column += 14; 236 } 237 238 /* Dump the next node in the queue. */ 239 240 static void 241 dequeue_and_dump (dump_info_p di) 242 { 243 dump_queue_p dq; 244 splay_tree_node stn; 245 dump_node_info_p dni; 246 tree t; 247 unsigned int index; 248 enum tree_code code; 249 enum tree_code_class code_class; 250 const char* code_name; 251 252 /* Get the next node from the queue. */ 253 dq = di->queue; 254 stn = dq->node; 255 t = (tree) stn->key; 256 dni = (dump_node_info_p) stn->value; 257 index = dni->index; 258 259 /* Remove the node from the queue, and put it on the free list. */ 260 di->queue = dq->next; 261 if (!di->queue) 262 di->queue_end = 0; 263 dq->next = di->free_list; 264 di->free_list = dq; 265 266 /* Print the node index. */ 267 dump_index (di, index); 268 /* And the type of node this is. */ 269 if (dni->binfo_p) 270 code_name = "binfo"; 271 else 272 code_name = tree_code_name[(int) TREE_CODE (t)]; 273 fprintf (di->stream, "%-16s ", code_name); 274 di->column = 25; 275 276 /* Figure out what kind of node this is. */ 277 code = TREE_CODE (t); 278 code_class = TREE_CODE_CLASS (code); 279 280 /* Although BINFOs are TREE_VECs, we dump them specially so as to be 281 more informative. */ 282 if (dni->binfo_p) 283 { 284 unsigned ix; 285 tree base; 286 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t); 287 288 dump_child ("type", BINFO_TYPE (t)); 289 290 if (BINFO_VIRTUAL_P (t)) 291 dump_string_field (di, "spec", "virt"); 292 293 dump_int (di, "bases", BINFO_N_BASE_BINFOS (t)); 294 for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++) 295 { 296 tree access = (accesses ? VEC_index (tree, accesses, ix) 297 : access_public_node); 298 const char *string = NULL; 299 300 if (access == access_public_node) 301 string = "pub"; 302 else if (access == access_protected_node) 303 string = "prot"; 304 else if (access == access_private_node) 305 string = "priv"; 306 else 307 gcc_unreachable (); 308 309 dump_string_field (di, "accs", string); 310 queue_and_dump_index (di, "binf", base, DUMP_BINFO); 311 } 312 313 goto done; 314 } 315 316 /* We can knock off a bunch of expression nodes in exactly the same 317 way. */ 318 if (IS_EXPR_CODE_CLASS (code_class)) 319 { 320 /* If we're dumping children, dump them now. */ 321 queue_and_dump_type (di, t); 322 323 switch (code_class) 324 { 325 case tcc_unary: 326 dump_child ("op 0", TREE_OPERAND (t, 0)); 327 break; 328 329 case tcc_binary: 330 case tcc_comparison: 331 dump_child ("op 0", TREE_OPERAND (t, 0)); 332 dump_child ("op 1", TREE_OPERAND (t, 1)); 333 break; 334 335 case tcc_expression: 336 case tcc_reference: 337 case tcc_statement: 338 case tcc_vl_exp: 339 /* These nodes are handled explicitly below. */ 340 break; 341 342 default: 343 gcc_unreachable (); 344 } 345 } 346 else if (DECL_P (t)) 347 { 348 expanded_location xloc; 349 /* All declarations have names. */ 350 if (DECL_NAME (t)) 351 dump_child ("name", DECL_NAME (t)); 352 if (DECL_ASSEMBLER_NAME_SET_P (t) 353 && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t)) 354 dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); 355 if (DECL_ABSTRACT_ORIGIN (t)) 356 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t)); 357 /* And types. */ 358 queue_and_dump_type (di, t); 359 dump_child ("scpe", DECL_CONTEXT (t)); 360 /* And a source position. */ 361 xloc = expand_location (DECL_SOURCE_LOCATION (t)); 362 if (xloc.file) 363 { 364 const char *filename = lbasename (xloc.file); 365 366 dump_maybe_newline (di); 367 fprintf (di->stream, "srcp: %s:%-6d ", filename, 368 xloc.line); 369 di->column += 6 + strlen (filename) + 8; 370 } 371 /* And any declaration can be compiler-generated. */ 372 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON) 373 && DECL_ARTIFICIAL (t)) 374 dump_string_field (di, "note", "artificial"); 375 if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL)) 376 dump_child ("chain", DECL_CHAIN (t)); 377 } 378 else if (code_class == tcc_type) 379 { 380 /* All types have qualifiers. */ 381 int quals = lang_hooks.tree_dump.type_quals (t); 382 383 if (quals != TYPE_UNQUALIFIED) 384 { 385 fprintf (di->stream, "qual: %c%c%c ", 386 (quals & TYPE_QUAL_CONST) ? 'c' : ' ', 387 (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ', 388 (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' '); 389 di->column += 14; 390 } 391 392 /* All types have associated declarations. */ 393 dump_child ("name", TYPE_NAME (t)); 394 395 /* All types have a main variant. */ 396 if (TYPE_MAIN_VARIANT (t) != t) 397 dump_child ("unql", TYPE_MAIN_VARIANT (t)); 398 399 /* And sizes. */ 400 dump_child ("size", TYPE_SIZE (t)); 401 402 /* All types have alignments. */ 403 dump_int (di, "algn", TYPE_ALIGN (t)); 404 } 405 else if (code_class == tcc_constant) 406 /* All constants can have types. */ 407 queue_and_dump_type (di, t); 408 409 /* Give the language-specific code a chance to print something. If 410 it's completely taken care of things, don't bother printing 411 anything more ourselves. */ 412 if (lang_hooks.tree_dump.dump_tree (di, t)) 413 goto done; 414 415 /* Now handle the various kinds of nodes. */ 416 switch (code) 417 { 418 int i; 419 420 case IDENTIFIER_NODE: 421 dump_string_field (di, "strg", IDENTIFIER_POINTER (t)); 422 dump_int (di, "lngt", IDENTIFIER_LENGTH (t)); 423 break; 424 425 case TREE_LIST: 426 dump_child ("purp", TREE_PURPOSE (t)); 427 dump_child ("valu", TREE_VALUE (t)); 428 dump_child ("chan", TREE_CHAIN (t)); 429 break; 430 431 case STATEMENT_LIST: 432 { 433 tree_stmt_iterator it; 434 for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++) 435 { 436 char buffer[32]; 437 sprintf (buffer, "%u", i); 438 dump_child (buffer, tsi_stmt (it)); 439 } 440 } 441 break; 442 443 case TREE_VEC: 444 dump_int (di, "lngt", TREE_VEC_LENGTH (t)); 445 for (i = 0; i < TREE_VEC_LENGTH (t); ++i) 446 { 447 char buffer[32]; 448 sprintf (buffer, "%u", i); 449 dump_child (buffer, TREE_VEC_ELT (t, i)); 450 } 451 break; 452 453 case INTEGER_TYPE: 454 case ENUMERAL_TYPE: 455 dump_int (di, "prec", TYPE_PRECISION (t)); 456 dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); 457 dump_child ("min", TYPE_MIN_VALUE (t)); 458 dump_child ("max", TYPE_MAX_VALUE (t)); 459 460 if (code == ENUMERAL_TYPE) 461 dump_child ("csts", TYPE_VALUES (t)); 462 break; 463 464 case REAL_TYPE: 465 dump_int (di, "prec", TYPE_PRECISION (t)); 466 break; 467 468 case FIXED_POINT_TYPE: 469 dump_int (di, "prec", TYPE_PRECISION (t)); 470 dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); 471 dump_string_field (di, "saturating", 472 TYPE_SATURATING (t) ? "saturating": "non-saturating"); 473 break; 474 475 case POINTER_TYPE: 476 dump_child ("ptd", TREE_TYPE (t)); 477 break; 478 479 case REFERENCE_TYPE: 480 dump_child ("refd", TREE_TYPE (t)); 481 break; 482 483 case METHOD_TYPE: 484 dump_child ("clas", TYPE_METHOD_BASETYPE (t)); 485 /* Fall through. */ 486 487 case FUNCTION_TYPE: 488 dump_child ("retn", TREE_TYPE (t)); 489 dump_child ("prms", TYPE_ARG_TYPES (t)); 490 break; 491 492 case ARRAY_TYPE: 493 dump_child ("elts", TREE_TYPE (t)); 494 dump_child ("domn", TYPE_DOMAIN (t)); 495 break; 496 497 case RECORD_TYPE: 498 case UNION_TYPE: 499 if (TREE_CODE (t) == RECORD_TYPE) 500 dump_string_field (di, "tag", "struct"); 501 else 502 dump_string_field (di, "tag", "union"); 503 504 dump_child ("flds", TYPE_FIELDS (t)); 505 dump_child ("fncs", TYPE_METHODS (t)); 506 queue_and_dump_index (di, "binf", TYPE_BINFO (t), 507 DUMP_BINFO); 508 break; 509 510 case CONST_DECL: 511 dump_child ("cnst", DECL_INITIAL (t)); 512 break; 513 514 case DEBUG_EXPR_DECL: 515 dump_int (di, "-uid", DEBUG_TEMP_UID (t)); 516 /* Fall through. */ 517 518 case VAR_DECL: 519 case PARM_DECL: 520 case FIELD_DECL: 521 case RESULT_DECL: 522 if (TREE_CODE (t) == PARM_DECL) 523 dump_child ("argt", DECL_ARG_TYPE (t)); 524 else 525 dump_child ("init", DECL_INITIAL (t)); 526 dump_child ("size", DECL_SIZE (t)); 527 dump_int (di, "algn", DECL_ALIGN (t)); 528 529 if (TREE_CODE (t) == FIELD_DECL) 530 { 531 if (DECL_FIELD_OFFSET (t)) 532 dump_child ("bpos", bit_position (t)); 533 } 534 else if (TREE_CODE (t) == VAR_DECL 535 || TREE_CODE (t) == PARM_DECL) 536 { 537 dump_int (di, "used", TREE_USED (t)); 538 if (DECL_REGISTER (t)) 539 dump_string_field (di, "spec", "register"); 540 } 541 break; 542 543 case FUNCTION_DECL: 544 dump_child ("args", DECL_ARGUMENTS (t)); 545 if (DECL_EXTERNAL (t)) 546 dump_string_field (di, "body", "undefined"); 547 if (TREE_PUBLIC (t)) 548 dump_string_field (di, "link", "extern"); 549 else 550 dump_string_field (di, "link", "static"); 551 if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t)) 552 dump_child ("body", DECL_SAVED_TREE (t)); 553 break; 554 555 case INTEGER_CST: 556 if (TREE_INT_CST_HIGH (t)) 557 dump_int (di, "high", TREE_INT_CST_HIGH (t)); 558 dump_int (di, "low", TREE_INT_CST_LOW (t)); 559 break; 560 561 case STRING_CST: 562 fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t)); 563 dump_int (di, "lngt", TREE_STRING_LENGTH (t)); 564 break; 565 566 case REAL_CST: 567 dump_real (di, "valu", TREE_REAL_CST_PTR (t)); 568 break; 569 570 case FIXED_CST: 571 dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t)); 572 break; 573 574 case TRUTH_NOT_EXPR: 575 case ADDR_EXPR: 576 case INDIRECT_REF: 577 case CLEANUP_POINT_EXPR: 578 case SAVE_EXPR: 579 case REALPART_EXPR: 580 case IMAGPART_EXPR: 581 /* These nodes are unary, but do not have code class `1'. */ 582 dump_child ("op 0", TREE_OPERAND (t, 0)); 583 break; 584 585 case TRUTH_ANDIF_EXPR: 586 case TRUTH_ORIF_EXPR: 587 case INIT_EXPR: 588 case MODIFY_EXPR: 589 case COMPOUND_EXPR: 590 case PREDECREMENT_EXPR: 591 case PREINCREMENT_EXPR: 592 case POSTDECREMENT_EXPR: 593 case POSTINCREMENT_EXPR: 594 /* These nodes are binary, but do not have code class `2'. */ 595 dump_child ("op 0", TREE_OPERAND (t, 0)); 596 dump_child ("op 1", TREE_OPERAND (t, 1)); 597 break; 598 599 case COMPONENT_REF: 600 dump_child ("op 0", TREE_OPERAND (t, 0)); 601 dump_child ("op 1", TREE_OPERAND (t, 1)); 602 dump_child ("op 2", TREE_OPERAND (t, 2)); 603 break; 604 605 case ARRAY_REF: 606 case ARRAY_RANGE_REF: 607 dump_child ("op 0", TREE_OPERAND (t, 0)); 608 dump_child ("op 1", TREE_OPERAND (t, 1)); 609 dump_child ("op 2", TREE_OPERAND (t, 2)); 610 dump_child ("op 3", TREE_OPERAND (t, 3)); 611 break; 612 613 case COND_EXPR: 614 dump_child ("op 0", TREE_OPERAND (t, 0)); 615 dump_child ("op 1", TREE_OPERAND (t, 1)); 616 dump_child ("op 2", TREE_OPERAND (t, 2)); 617 break; 618 619 case TRY_FINALLY_EXPR: 620 dump_child ("op 0", TREE_OPERAND (t, 0)); 621 dump_child ("op 1", TREE_OPERAND (t, 1)); 622 break; 623 624 case CALL_EXPR: 625 { 626 int i = 0; 627 tree arg; 628 call_expr_arg_iterator iter; 629 dump_child ("fn", CALL_EXPR_FN (t)); 630 FOR_EACH_CALL_EXPR_ARG (arg, iter, t) 631 { 632 char buffer[32]; 633 sprintf (buffer, "%u", i); 634 dump_child (buffer, arg); 635 i++; 636 } 637 } 638 break; 639 640 case CONSTRUCTOR: 641 { 642 unsigned HOST_WIDE_INT cnt; 643 tree index, value; 644 dump_int (di, "lngt", VEC_length (constructor_elt, 645 CONSTRUCTOR_ELTS (t))); 646 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value) 647 { 648 dump_child ("idx", index); 649 dump_child ("val", value); 650 } 651 } 652 break; 653 654 case BIND_EXPR: 655 dump_child ("vars", TREE_OPERAND (t, 0)); 656 dump_child ("body", TREE_OPERAND (t, 1)); 657 break; 658 659 case LOOP_EXPR: 660 dump_child ("body", TREE_OPERAND (t, 0)); 661 break; 662 663 case EXIT_EXPR: 664 dump_child ("cond", TREE_OPERAND (t, 0)); 665 break; 666 667 case RETURN_EXPR: 668 dump_child ("expr", TREE_OPERAND (t, 0)); 669 break; 670 671 case TARGET_EXPR: 672 dump_child ("decl", TREE_OPERAND (t, 0)); 673 dump_child ("init", TREE_OPERAND (t, 1)); 674 dump_child ("clnp", TREE_OPERAND (t, 2)); 675 /* There really are two possible places the initializer can be. 676 After RTL expansion, the second operand is moved to the 677 position of the fourth operand, and the second operand 678 becomes NULL. */ 679 dump_child ("init", TREE_OPERAND (t, 3)); 680 break; 681 682 case CASE_LABEL_EXPR: 683 dump_child ("name", CASE_LABEL (t)); 684 if (CASE_LOW (t)) 685 { 686 dump_child ("low ", CASE_LOW (t)); 687 if (CASE_HIGH (t)) 688 dump_child ("high", CASE_HIGH (t)); 689 } 690 break; 691 case LABEL_EXPR: 692 dump_child ("name", TREE_OPERAND (t,0)); 693 break; 694 case GOTO_EXPR: 695 dump_child ("labl", TREE_OPERAND (t, 0)); 696 break; 697 case SWITCH_EXPR: 698 dump_child ("cond", TREE_OPERAND (t, 0)); 699 dump_child ("body", TREE_OPERAND (t, 1)); 700 if (TREE_OPERAND (t, 2)) 701 { 702 dump_child ("labl", TREE_OPERAND (t,2)); 703 } 704 break; 705 case OMP_CLAUSE: 706 { 707 int i; 708 fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]); 709 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) 710 dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i)); 711 } 712 break; 713 default: 714 /* There are no additional fields to print. */ 715 break; 716 } 717 718 done: 719 if (dump_flag (di, TDF_ADDRESS, NULL)) 720 dump_pointer (di, "addr", (void *)t); 721 722 /* Terminate the line. */ 723 fprintf (di->stream, "\n"); 724 } 725 726 /* Return nonzero if FLAG has been specified for the dump, and NODE 727 is not the root node of the dump. */ 728 729 int dump_flag (dump_info_p di, int flag, const_tree node) 730 { 731 return (di->flags & flag) && (node != di->node); 732 } 733 734 /* Dump T, and all its children, on STREAM. */ 735 736 void 737 dump_node (const_tree t, int flags, FILE *stream) 738 { 739 struct dump_info di; 740 dump_queue_p dq; 741 dump_queue_p next_dq; 742 743 /* Initialize the dump-information structure. */ 744 di.stream = stream; 745 di.index = 0; 746 di.column = 0; 747 di.queue = 0; 748 di.queue_end = 0; 749 di.free_list = 0; 750 di.flags = flags; 751 di.node = t; 752 di.nodes = splay_tree_new (splay_tree_compare_pointers, 0, 753 (splay_tree_delete_value_fn) &free); 754 755 /* Queue up the first node. */ 756 queue (&di, t, DUMP_NONE); 757 758 /* Until the queue is empty, keep dumping nodes. */ 759 while (di.queue) 760 dequeue_and_dump (&di); 761 762 /* Now, clean up. */ 763 for (dq = di.free_list; dq; dq = next_dq) 764 { 765 next_dq = dq->next; 766 free (dq); 767 } 768 splay_tree_delete (di.nodes); 769 } 770 771 772 /* Table of tree dump switches. This must be consistent with the 773 tree_dump_index enumeration in tree-pass.h. */ 774 static struct dump_file_info dump_files[TDI_end] = 775 { 776 {NULL, NULL, NULL, 0, 0, 0}, 777 {".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0, 0}, 778 {".tu", "translation-unit", NULL, TDF_TREE, 0, 1}, 779 {".class", "class-hierarchy", NULL, TDF_TREE, 0, 2}, 780 {".original", "tree-original", NULL, TDF_TREE, 0, 3}, 781 {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 4}, 782 {".nested", "tree-nested", NULL, TDF_TREE, 0, 5}, 783 {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6}, 784 {".ads", "ada-spec", NULL, 0, 0, 7}, 785 #define FIRST_AUTO_NUMBERED_DUMP 8 786 787 {NULL, "tree-all", NULL, TDF_TREE, 0, 0}, 788 {NULL, "rtl-all", NULL, TDF_RTL, 0, 0}, 789 {NULL, "ipa-all", NULL, TDF_IPA, 0, 0}, 790 }; 791 792 /* Dynamically registered tree dump files and switches. */ 793 static struct dump_file_info *extra_dump_files; 794 static size_t extra_dump_files_in_use; 795 static size_t extra_dump_files_alloced; 796 797 /* Define a name->number mapping for a dump flag value. */ 798 struct dump_option_value_info 799 { 800 const char *const name; /* the name of the value */ 801 const int value; /* the value of the name */ 802 }; 803 804 /* Table of dump options. This must be consistent with the TDF_* flags 805 in tree.h */ 806 static const struct dump_option_value_info dump_options[] = 807 { 808 {"address", TDF_ADDRESS}, 809 {"asmname", TDF_ASMNAME}, 810 {"slim", TDF_SLIM}, 811 {"raw", TDF_RAW}, 812 {"graph", TDF_GRAPH}, 813 {"details", TDF_DETAILS}, 814 {"cselib", TDF_CSELIB}, 815 {"stats", TDF_STATS}, 816 {"blocks", TDF_BLOCKS}, 817 {"vops", TDF_VOPS}, 818 {"lineno", TDF_LINENO}, 819 {"uid", TDF_UID}, 820 {"stmtaddr", TDF_STMTADDR}, 821 {"memsyms", TDF_MEMSYMS}, 822 {"verbose", TDF_VERBOSE}, 823 {"eh", TDF_EH}, 824 {"alias", TDF_ALIAS}, 825 {"nouid", TDF_NOUID}, 826 {"enumerate_locals", TDF_ENUMERATE_LOCALS}, 827 {"scev", TDF_SCEV}, 828 {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA 829 | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC | TDF_VERBOSE 830 | TDF_RHS_ONLY | TDF_NOUID | TDF_ENUMERATE_LOCALS | TDF_SCEV)}, 831 {NULL, 0} 832 }; 833 834 unsigned int 835 dump_register (const char *suffix, const char *swtch, const char *glob, 836 int flags) 837 { 838 static int next_dump = FIRST_AUTO_NUMBERED_DUMP; 839 int num = next_dump++; 840 841 size_t count = extra_dump_files_in_use++; 842 843 if (count >= extra_dump_files_alloced) 844 { 845 if (extra_dump_files_alloced == 0) 846 extra_dump_files_alloced = 32; 847 else 848 extra_dump_files_alloced *= 2; 849 extra_dump_files = XRESIZEVEC (struct dump_file_info, 850 extra_dump_files, 851 extra_dump_files_alloced); 852 } 853 854 memset (&extra_dump_files[count], 0, sizeof (struct dump_file_info)); 855 extra_dump_files[count].suffix = suffix; 856 extra_dump_files[count].swtch = swtch; 857 extra_dump_files[count].glob = glob; 858 extra_dump_files[count].flags = flags; 859 extra_dump_files[count].num = num; 860 861 return count + TDI_end; 862 } 863 864 865 /* Return the dump_file_info for the given phase. */ 866 867 struct dump_file_info * 868 get_dump_file_info (int phase) 869 { 870 if (phase < TDI_end) 871 return &dump_files[phase]; 872 else if ((size_t) (phase - TDI_end) >= extra_dump_files_in_use) 873 return NULL; 874 else 875 return extra_dump_files + (phase - TDI_end); 876 } 877 878 879 /* Return the name of the dump file for the given phase. 880 If the dump is not enabled, returns NULL. */ 881 882 char * 883 get_dump_file_name (int phase) 884 { 885 char dump_id[10]; 886 struct dump_file_info *dfi; 887 888 if (phase == TDI_none) 889 return NULL; 890 891 dfi = get_dump_file_info (phase); 892 if (dfi->state == 0) 893 return NULL; 894 895 if (dfi->num < 0) 896 dump_id[0] = '\0'; 897 else 898 { 899 char suffix; 900 if (dfi->flags & TDF_TREE) 901 suffix = 't'; 902 else if (dfi->flags & TDF_IPA) 903 suffix = 'i'; 904 else 905 suffix = 'r'; 906 907 if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0) 908 dump_id[0] = '\0'; 909 } 910 911 return concat (dump_base_name, dump_id, dfi->suffix, NULL); 912 } 913 914 /* Begin a tree dump for PHASE. Stores any user supplied flag in 915 *FLAG_PTR and returns a stream to write to. If the dump is not 916 enabled, returns NULL. 917 Multiple calls will reopen and append to the dump file. */ 918 919 FILE * 920 dump_begin (int phase, int *flag_ptr) 921 { 922 char *name; 923 struct dump_file_info *dfi; 924 FILE *stream; 925 926 if (phase == TDI_none || !dump_enabled_p (phase)) 927 return NULL; 928 929 name = get_dump_file_name (phase); 930 dfi = get_dump_file_info (phase); 931 stream = fopen (name, dfi->state < 0 ? "w" : "a"); 932 if (!stream) 933 error ("could not open dump file %qs: %m", name); 934 else 935 dfi->state = 1; 936 free (name); 937 938 if (flag_ptr) 939 *flag_ptr = dfi->flags; 940 941 return stream; 942 } 943 944 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is 945 TDI_tree_all, return nonzero if any dump is enabled. */ 946 947 int 948 dump_enabled_p (int phase) 949 { 950 if (phase == TDI_tree_all) 951 { 952 size_t i; 953 for (i = TDI_none + 1; i < (size_t) TDI_end; i++) 954 if (dump_files[i].state) 955 return 1; 956 for (i = 0; i < extra_dump_files_in_use; i++) 957 if (extra_dump_files[i].state) 958 return 1; 959 return 0; 960 } 961 else 962 { 963 struct dump_file_info *dfi = get_dump_file_info (phase); 964 return dfi->state; 965 } 966 } 967 968 /* Returns nonzero if tree dump PHASE has been initialized. */ 969 970 int 971 dump_initialized_p (int phase) 972 { 973 struct dump_file_info *dfi = get_dump_file_info (phase); 974 return dfi->state > 0; 975 } 976 977 /* Returns the switch name of PHASE. */ 978 979 const char * 980 dump_flag_name (int phase) 981 { 982 struct dump_file_info *dfi = get_dump_file_info (phase); 983 return dfi->swtch; 984 } 985 986 /* Finish a tree dump for PHASE. STREAM is the stream created by 987 dump_begin. */ 988 989 void 990 dump_end (int phase ATTRIBUTE_UNUSED, FILE *stream) 991 { 992 fclose (stream); 993 } 994 995 /* Enable all tree dumps. Return number of enabled tree dumps. */ 996 997 static int 998 dump_enable_all (int flags) 999 { 1000 int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA)); 1001 int n = 0; 1002 size_t i; 1003 1004 for (i = TDI_none + 1; i < (size_t) TDI_end; i++) 1005 if ((dump_files[i].flags & ir_dump_type)) 1006 { 1007 dump_files[i].state = -1; 1008 dump_files[i].flags |= flags; 1009 n++; 1010 } 1011 1012 for (i = 0; i < extra_dump_files_in_use; i++) 1013 if ((extra_dump_files[i].flags & ir_dump_type)) 1014 { 1015 extra_dump_files[i].state = -1; 1016 extra_dump_files[i].flags |= flags; 1017 n++; 1018 } 1019 1020 return n; 1021 } 1022 1023 /* Parse ARG as a dump switch. Return nonzero if it is, and store the 1024 relevant details in the dump_files array. */ 1025 1026 static int 1027 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob) 1028 { 1029 const char *option_value; 1030 const char *ptr; 1031 int flags; 1032 1033 if (doglob && !dfi->glob) 1034 return 0; 1035 1036 option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch); 1037 if (!option_value) 1038 return 0; 1039 1040 if (*option_value && *option_value != '-') 1041 return 0; 1042 1043 ptr = option_value; 1044 flags = 0; 1045 1046 while (*ptr) 1047 { 1048 const struct dump_option_value_info *option_ptr; 1049 const char *end_ptr; 1050 unsigned length; 1051 1052 while (*ptr == '-') 1053 ptr++; 1054 end_ptr = strchr (ptr, '-'); 1055 if (!end_ptr) 1056 end_ptr = ptr + strlen (ptr); 1057 length = end_ptr - ptr; 1058 1059 for (option_ptr = dump_options; option_ptr->name; option_ptr++) 1060 if (strlen (option_ptr->name) == length 1061 && !memcmp (option_ptr->name, ptr, length)) 1062 { 1063 flags |= option_ptr->value; 1064 goto found; 1065 } 1066 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>", 1067 length, ptr, dfi->swtch); 1068 found:; 1069 ptr = end_ptr; 1070 } 1071 1072 dfi->state = -1; 1073 dfi->flags |= flags; 1074 1075 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the 1076 known dumps. */ 1077 if (dfi->suffix == NULL) 1078 dump_enable_all (dfi->flags); 1079 1080 return 1; 1081 } 1082 1083 int 1084 dump_switch_p (const char *arg) 1085 { 1086 size_t i; 1087 int any = 0; 1088 1089 for (i = TDI_none + 1; i != TDI_end; i++) 1090 any |= dump_switch_p_1 (arg, &dump_files[i], false); 1091 1092 /* Don't glob if we got a hit already */ 1093 if (!any) 1094 for (i = TDI_none + 1; i != TDI_end; i++) 1095 any |= dump_switch_p_1 (arg, &dump_files[i], true); 1096 1097 for (i = 0; i < extra_dump_files_in_use; i++) 1098 any |= dump_switch_p_1 (arg, &extra_dump_files[i], false); 1099 1100 if (!any) 1101 for (i = 0; i < extra_dump_files_in_use; i++) 1102 any |= dump_switch_p_1 (arg, &extra_dump_files[i], true); 1103 1104 1105 return any; 1106 } 1107 1108 /* Dump FUNCTION_DECL FN as tree dump PHASE. */ 1109 1110 void 1111 dump_function (int phase, tree fn) 1112 { 1113 FILE *stream; 1114 int flags; 1115 1116 stream = dump_begin (phase, &flags); 1117 if (stream) 1118 { 1119 dump_function_to_file (fn, stream, flags); 1120 dump_end (phase, stream); 1121 } 1122 } 1123 1124 bool 1125 enable_rtl_dump_file (void) 1126 { 1127 return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS) > 0; 1128 } 1129