1 /* Tree-dumping functionality for intermediate representation. 2 Copyright (C) 1999-2016 Free Software Foundation, Inc. 3 Written by Mark Mitchell <mark@codesourcery.com> 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tree.h" 25 #include "tree-pretty-print.h" 26 #include "tree-dump.h" 27 #include "langhooks.h" 28 #include "tree-iterator.h" 29 #include "tree-cfg.h" 30 31 static unsigned int queue (dump_info_p, const_tree, int); 32 static void dump_index (dump_info_p, unsigned int); 33 static void dequeue_and_dump (dump_info_p); 34 static void dump_new_line (dump_info_p); 35 static void dump_maybe_newline (dump_info_p); 36 37 /* Add T to the end of the queue of nodes to dump. Returns the index 38 assigned to T. */ 39 40 static unsigned int 41 queue (dump_info_p di, const_tree t, int flags) 42 { 43 dump_queue_p dq; 44 dump_node_info_p dni; 45 unsigned int index; 46 47 /* Assign the next available index to T. */ 48 index = ++di->index; 49 50 /* Obtain a new queue node. */ 51 if (di->free_list) 52 { 53 dq = di->free_list; 54 di->free_list = dq->next; 55 } 56 else 57 dq = XNEW (struct dump_queue); 58 59 /* Create a new entry in the splay-tree. */ 60 dni = XNEW (struct dump_node_info); 61 dni->index = index; 62 dni->binfo_p = ((flags & DUMP_BINFO) != 0); 63 dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t, 64 (splay_tree_value) dni); 65 66 /* Add it to the end of the queue. */ 67 dq->next = 0; 68 if (!di->queue_end) 69 di->queue = dq; 70 else 71 di->queue_end->next = dq; 72 di->queue_end = dq; 73 74 /* Return the index. */ 75 return index; 76 } 77 78 static void 79 dump_index (dump_info_p di, unsigned int index) 80 { 81 fprintf (di->stream, "@%-6u ", index); 82 di->column += 8; 83 } 84 85 /* If T has not already been output, queue it for subsequent output. 86 FIELD is a string to print before printing the index. Then, the 87 index of T is printed. */ 88 89 void 90 queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags) 91 { 92 unsigned int index; 93 splay_tree_node n; 94 95 /* If there's no node, just return. This makes for fewer checks in 96 our callers. */ 97 if (!t) 98 return; 99 100 /* See if we've already queued or dumped this node. */ 101 n = splay_tree_lookup (di->nodes, (splay_tree_key) t); 102 if (n) 103 index = ((dump_node_info_p) n->value)->index; 104 else 105 /* If we haven't, add it to the queue. */ 106 index = queue (di, t, flags); 107 108 /* Print the index of the node. */ 109 dump_maybe_newline (di); 110 fprintf (di->stream, "%-4s: ", field); 111 di->column += 6; 112 dump_index (di, index); 113 } 114 115 /* Dump the type of T. */ 116 117 void 118 queue_and_dump_type (dump_info_p di, const_tree t) 119 { 120 queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE); 121 } 122 123 /* Dump column control */ 124 #define SOL_COLUMN 25 /* Start of line column. */ 125 #define EOL_COLUMN 55 /* End of line column. */ 126 #define COLUMN_ALIGNMENT 15 /* Alignment. */ 127 128 /* Insert a new line in the dump output, and indent to an appropriate 129 place to start printing more fields. */ 130 131 static void 132 dump_new_line (dump_info_p di) 133 { 134 fprintf (di->stream, "\n%*s", SOL_COLUMN, ""); 135 di->column = SOL_COLUMN; 136 } 137 138 /* If necessary, insert a new line. */ 139 140 static void 141 dump_maybe_newline (dump_info_p di) 142 { 143 int extra; 144 145 /* See if we need a new line. */ 146 if (di->column > EOL_COLUMN) 147 dump_new_line (di); 148 /* See if we need any padding. */ 149 else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0) 150 { 151 fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, ""); 152 di->column += COLUMN_ALIGNMENT - extra; 153 } 154 } 155 156 /* Dump FUNCTION_DECL FN as tree dump PHASE. */ 157 158 void 159 dump_function (int phase, tree fn) 160 { 161 FILE *stream; 162 int flags; 163 164 stream = dump_begin (phase, &flags); 165 if (stream) 166 { 167 dump_function_to_file (fn, stream, flags); 168 dump_end (phase, stream); 169 } 170 } 171 172 /* Dump pointer PTR using FIELD to identify it. */ 173 174 void 175 dump_pointer (dump_info_p di, const char *field, void *ptr) 176 { 177 dump_maybe_newline (di); 178 fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field, 179 (unsigned HOST_WIDE_INT) (uintptr_t) ptr); 180 di->column += 15; 181 } 182 183 /* Dump integer I using FIELD to identify it. */ 184 185 void 186 dump_int (dump_info_p di, const char *field, int i) 187 { 188 dump_maybe_newline (di); 189 fprintf (di->stream, "%-4s: %-7d ", field, i); 190 di->column += 14; 191 } 192 193 /* Dump the floating point value R, using FIELD to identify it. */ 194 195 static void 196 dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r) 197 { 198 char buf[32]; 199 real_to_decimal (buf, r, sizeof (buf), 0, true); 200 dump_maybe_newline (di); 201 fprintf (di->stream, "%-4s: %s ", field, buf); 202 di->column += strlen (buf) + 7; 203 } 204 205 /* Dump the fixed-point value F, using FIELD to identify it. */ 206 207 static void 208 dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f) 209 { 210 char buf[32]; 211 fixed_to_decimal (buf, f, sizeof (buf)); 212 dump_maybe_newline (di); 213 fprintf (di->stream, "%-4s: %s ", field, buf); 214 di->column += strlen (buf) + 7; 215 } 216 217 218 /* Dump the string S. */ 219 220 void 221 dump_string (dump_info_p di, const char *string) 222 { 223 dump_maybe_newline (di); 224 fprintf (di->stream, "%-13s ", string); 225 if (strlen (string) > 13) 226 di->column += strlen (string) + 1; 227 else 228 di->column += 14; 229 } 230 231 /* Dump the string field S. */ 232 233 void 234 dump_string_field (dump_info_p di, const char *field, const char *string) 235 { 236 dump_maybe_newline (di); 237 fprintf (di->stream, "%-4s: %-7s ", field, string); 238 if (strlen (string) > 7) 239 di->column += 6 + strlen (string) + 1; 240 else 241 di->column += 14; 242 } 243 244 /* Dump the next node in the queue. */ 245 246 static void 247 dequeue_and_dump (dump_info_p di) 248 { 249 dump_queue_p dq; 250 splay_tree_node stn; 251 dump_node_info_p dni; 252 tree t; 253 unsigned int index; 254 enum tree_code code; 255 enum tree_code_class code_class; 256 const char* code_name; 257 258 /* Get the next node from the queue. */ 259 dq = di->queue; 260 stn = dq->node; 261 t = (tree) stn->key; 262 dni = (dump_node_info_p) stn->value; 263 index = dni->index; 264 265 /* Remove the node from the queue, and put it on the free list. */ 266 di->queue = dq->next; 267 if (!di->queue) 268 di->queue_end = 0; 269 dq->next = di->free_list; 270 di->free_list = dq; 271 272 /* Print the node index. */ 273 dump_index (di, index); 274 /* And the type of node this is. */ 275 if (dni->binfo_p) 276 code_name = "binfo"; 277 else 278 code_name = get_tree_code_name (TREE_CODE (t)); 279 fprintf (di->stream, "%-16s ", code_name); 280 di->column = 25; 281 282 /* Figure out what kind of node this is. */ 283 code = TREE_CODE (t); 284 code_class = TREE_CODE_CLASS (code); 285 286 /* Although BINFOs are TREE_VECs, we dump them specially so as to be 287 more informative. */ 288 if (dni->binfo_p) 289 { 290 unsigned ix; 291 tree base; 292 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (t); 293 294 dump_child ("type", BINFO_TYPE (t)); 295 296 if (BINFO_VIRTUAL_P (t)) 297 dump_string_field (di, "spec", "virt"); 298 299 dump_int (di, "bases", BINFO_N_BASE_BINFOS (t)); 300 for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++) 301 { 302 tree access = (accesses ? (*accesses)[ix] : access_public_node); 303 const char *string = NULL; 304 305 if (access == access_public_node) 306 string = "pub"; 307 else if (access == access_protected_node) 308 string = "prot"; 309 else if (access == access_private_node) 310 string = "priv"; 311 else 312 gcc_unreachable (); 313 314 dump_string_field (di, "accs", string); 315 queue_and_dump_index (di, "binf", base, DUMP_BINFO); 316 } 317 318 goto done; 319 } 320 321 /* We can knock off a bunch of expression nodes in exactly the same 322 way. */ 323 if (IS_EXPR_CODE_CLASS (code_class)) 324 { 325 /* If we're dumping children, dump them now. */ 326 queue_and_dump_type (di, t); 327 328 switch (code_class) 329 { 330 case tcc_unary: 331 dump_child ("op 0", TREE_OPERAND (t, 0)); 332 break; 333 334 case tcc_binary: 335 case tcc_comparison: 336 dump_child ("op 0", TREE_OPERAND (t, 0)); 337 dump_child ("op 1", TREE_OPERAND (t, 1)); 338 break; 339 340 case tcc_expression: 341 case tcc_reference: 342 case tcc_statement: 343 case tcc_vl_exp: 344 /* These nodes are handled explicitly below. */ 345 break; 346 347 default: 348 gcc_unreachable (); 349 } 350 } 351 else if (DECL_P (t)) 352 { 353 expanded_location xloc; 354 /* All declarations have names. */ 355 if (DECL_NAME (t)) 356 dump_child ("name", DECL_NAME (t)); 357 if (DECL_ASSEMBLER_NAME_SET_P (t) 358 && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t)) 359 dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); 360 if (DECL_ABSTRACT_ORIGIN (t)) 361 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t)); 362 /* And types. */ 363 queue_and_dump_type (di, t); 364 dump_child ("scpe", DECL_CONTEXT (t)); 365 /* And a source position. */ 366 xloc = expand_location (DECL_SOURCE_LOCATION (t)); 367 if (xloc.file) 368 { 369 const char *filename = lbasename (xloc.file); 370 371 dump_maybe_newline (di); 372 fprintf (di->stream, "srcp: %s:%-6d ", filename, 373 xloc.line); 374 di->column += 6 + strlen (filename) + 8; 375 } 376 /* And any declaration can be compiler-generated. */ 377 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON) 378 && DECL_ARTIFICIAL (t)) 379 dump_string_field (di, "note", "artificial"); 380 if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL)) 381 dump_child ("chain", DECL_CHAIN (t)); 382 } 383 else if (code_class == tcc_type) 384 { 385 /* All types have qualifiers. */ 386 int quals = lang_hooks.tree_dump.type_quals (t); 387 388 if (quals != TYPE_UNQUALIFIED) 389 { 390 fprintf (di->stream, "qual: %c%c%c ", 391 (quals & TYPE_QUAL_CONST) ? 'c' : ' ', 392 (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ', 393 (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' '); 394 di->column += 14; 395 } 396 397 /* All types have associated declarations. */ 398 dump_child ("name", TYPE_NAME (t)); 399 400 /* All types have a main variant. */ 401 if (TYPE_MAIN_VARIANT (t) != t) 402 dump_child ("unql", TYPE_MAIN_VARIANT (t)); 403 404 /* And sizes. */ 405 dump_child ("size", TYPE_SIZE (t)); 406 407 /* All types have alignments. */ 408 dump_int (di, "algn", TYPE_ALIGN (t)); 409 } 410 else if (code_class == tcc_constant) 411 /* All constants can have types. */ 412 queue_and_dump_type (di, t); 413 414 /* Give the language-specific code a chance to print something. If 415 it's completely taken care of things, don't bother printing 416 anything more ourselves. */ 417 if (lang_hooks.tree_dump.dump_tree (di, t)) 418 goto done; 419 420 /* Now handle the various kinds of nodes. */ 421 switch (code) 422 { 423 int i; 424 425 case IDENTIFIER_NODE: 426 dump_string_field (di, "strg", IDENTIFIER_POINTER (t)); 427 dump_int (di, "lngt", IDENTIFIER_LENGTH (t)); 428 break; 429 430 case TREE_LIST: 431 dump_child ("purp", TREE_PURPOSE (t)); 432 dump_child ("valu", TREE_VALUE (t)); 433 dump_child ("chan", TREE_CHAIN (t)); 434 break; 435 436 case STATEMENT_LIST: 437 { 438 tree_stmt_iterator it; 439 for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++) 440 { 441 char buffer[32]; 442 sprintf (buffer, "%u", i); 443 dump_child (buffer, tsi_stmt (it)); 444 } 445 } 446 break; 447 448 case TREE_VEC: 449 dump_int (di, "lngt", TREE_VEC_LENGTH (t)); 450 for (i = 0; i < TREE_VEC_LENGTH (t); ++i) 451 { 452 char buffer[32]; 453 sprintf (buffer, "%u", i); 454 dump_child (buffer, TREE_VEC_ELT (t, i)); 455 } 456 break; 457 458 case INTEGER_TYPE: 459 case ENUMERAL_TYPE: 460 dump_int (di, "prec", TYPE_PRECISION (t)); 461 dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); 462 dump_child ("min", TYPE_MIN_VALUE (t)); 463 dump_child ("max", TYPE_MAX_VALUE (t)); 464 465 if (code == ENUMERAL_TYPE) 466 dump_child ("csts", TYPE_VALUES (t)); 467 break; 468 469 case REAL_TYPE: 470 dump_int (di, "prec", TYPE_PRECISION (t)); 471 break; 472 473 case FIXED_POINT_TYPE: 474 dump_int (di, "prec", TYPE_PRECISION (t)); 475 dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); 476 dump_string_field (di, "saturating", 477 TYPE_SATURATING (t) ? "saturating": "non-saturating"); 478 break; 479 480 case POINTER_TYPE: 481 dump_child ("ptd", TREE_TYPE (t)); 482 break; 483 484 case REFERENCE_TYPE: 485 dump_child ("refd", TREE_TYPE (t)); 486 break; 487 488 case METHOD_TYPE: 489 dump_child ("clas", TYPE_METHOD_BASETYPE (t)); 490 /* Fall through. */ 491 492 case FUNCTION_TYPE: 493 dump_child ("retn", TREE_TYPE (t)); 494 dump_child ("prms", TYPE_ARG_TYPES (t)); 495 break; 496 497 case ARRAY_TYPE: 498 dump_child ("elts", TREE_TYPE (t)); 499 dump_child ("domn", TYPE_DOMAIN (t)); 500 break; 501 502 case RECORD_TYPE: 503 case UNION_TYPE: 504 if (TREE_CODE (t) == RECORD_TYPE) 505 dump_string_field (di, "tag", "struct"); 506 else 507 dump_string_field (di, "tag", "union"); 508 509 dump_child ("flds", TYPE_FIELDS (t)); 510 dump_child ("fncs", TYPE_METHODS (t)); 511 queue_and_dump_index (di, "binf", TYPE_BINFO (t), 512 DUMP_BINFO); 513 break; 514 515 case CONST_DECL: 516 dump_child ("cnst", DECL_INITIAL (t)); 517 break; 518 519 case DEBUG_EXPR_DECL: 520 dump_int (di, "-uid", DEBUG_TEMP_UID (t)); 521 /* Fall through. */ 522 523 case VAR_DECL: 524 case PARM_DECL: 525 case FIELD_DECL: 526 case RESULT_DECL: 527 if (TREE_CODE (t) == PARM_DECL) 528 dump_child ("argt", DECL_ARG_TYPE (t)); 529 else 530 dump_child ("init", DECL_INITIAL (t)); 531 dump_child ("size", DECL_SIZE (t)); 532 dump_int (di, "algn", DECL_ALIGN (t)); 533 534 if (TREE_CODE (t) == FIELD_DECL) 535 { 536 if (DECL_FIELD_OFFSET (t)) 537 dump_child ("bpos", bit_position (t)); 538 } 539 else if (TREE_CODE (t) == VAR_DECL 540 || TREE_CODE (t) == PARM_DECL) 541 { 542 dump_int (di, "used", TREE_USED (t)); 543 if (DECL_REGISTER (t)) 544 dump_string_field (di, "spec", "register"); 545 } 546 break; 547 548 case FUNCTION_DECL: 549 dump_child ("args", DECL_ARGUMENTS (t)); 550 if (DECL_EXTERNAL (t)) 551 dump_string_field (di, "body", "undefined"); 552 if (TREE_PUBLIC (t)) 553 dump_string_field (di, "link", "extern"); 554 else 555 dump_string_field (di, "link", "static"); 556 if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t)) 557 dump_child ("body", DECL_SAVED_TREE (t)); 558 break; 559 560 case INTEGER_CST: 561 fprintf (di->stream, "int: "); 562 print_decs (t, di->stream); 563 break; 564 565 case STRING_CST: 566 fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t)); 567 dump_int (di, "lngt", TREE_STRING_LENGTH (t)); 568 break; 569 570 case REAL_CST: 571 dump_real (di, "valu", TREE_REAL_CST_PTR (t)); 572 break; 573 574 case FIXED_CST: 575 dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t)); 576 break; 577 578 case TRUTH_NOT_EXPR: 579 case ADDR_EXPR: 580 case INDIRECT_REF: 581 case CLEANUP_POINT_EXPR: 582 case SAVE_EXPR: 583 case REALPART_EXPR: 584 case IMAGPART_EXPR: 585 /* These nodes are unary, but do not have code class `1'. */ 586 dump_child ("op 0", TREE_OPERAND (t, 0)); 587 break; 588 589 case TRUTH_ANDIF_EXPR: 590 case TRUTH_ORIF_EXPR: 591 case INIT_EXPR: 592 case MODIFY_EXPR: 593 case COMPOUND_EXPR: 594 case PREDECREMENT_EXPR: 595 case PREINCREMENT_EXPR: 596 case POSTDECREMENT_EXPR: 597 case POSTINCREMENT_EXPR: 598 /* These nodes are binary, but do not have code class `2'. */ 599 dump_child ("op 0", TREE_OPERAND (t, 0)); 600 dump_child ("op 1", TREE_OPERAND (t, 1)); 601 break; 602 603 case COMPONENT_REF: 604 case BIT_FIELD_REF: 605 dump_child ("op 0", TREE_OPERAND (t, 0)); 606 dump_child ("op 1", TREE_OPERAND (t, 1)); 607 dump_child ("op 2", TREE_OPERAND (t, 2)); 608 break; 609 610 case ARRAY_REF: 611 case ARRAY_RANGE_REF: 612 dump_child ("op 0", TREE_OPERAND (t, 0)); 613 dump_child ("op 1", TREE_OPERAND (t, 1)); 614 dump_child ("op 2", TREE_OPERAND (t, 2)); 615 dump_child ("op 3", TREE_OPERAND (t, 3)); 616 break; 617 618 case COND_EXPR: 619 dump_child ("op 0", TREE_OPERAND (t, 0)); 620 dump_child ("op 1", TREE_OPERAND (t, 1)); 621 dump_child ("op 2", TREE_OPERAND (t, 2)); 622 break; 623 624 case TRY_FINALLY_EXPR: 625 dump_child ("op 0", TREE_OPERAND (t, 0)); 626 dump_child ("op 1", TREE_OPERAND (t, 1)); 627 break; 628 629 case CALL_EXPR: 630 { 631 int i = 0; 632 tree arg; 633 call_expr_arg_iterator iter; 634 dump_child ("fn", CALL_EXPR_FN (t)); 635 FOR_EACH_CALL_EXPR_ARG (arg, iter, t) 636 { 637 char buffer[32]; 638 sprintf (buffer, "%u", i); 639 dump_child (buffer, arg); 640 i++; 641 } 642 } 643 break; 644 645 case CONSTRUCTOR: 646 { 647 unsigned HOST_WIDE_INT cnt; 648 tree index, value; 649 dump_int (di, "lngt", vec_safe_length (CONSTRUCTOR_ELTS (t))); 650 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value) 651 { 652 dump_child ("idx", index); 653 dump_child ("val", value); 654 } 655 } 656 break; 657 658 case BIND_EXPR: 659 dump_child ("vars", TREE_OPERAND (t, 0)); 660 dump_child ("body", TREE_OPERAND (t, 1)); 661 break; 662 663 case LOOP_EXPR: 664 dump_child ("body", TREE_OPERAND (t, 0)); 665 break; 666 667 case EXIT_EXPR: 668 dump_child ("cond", TREE_OPERAND (t, 0)); 669 break; 670 671 case RETURN_EXPR: 672 dump_child ("expr", TREE_OPERAND (t, 0)); 673 break; 674 675 case TARGET_EXPR: 676 dump_child ("decl", TREE_OPERAND (t, 0)); 677 dump_child ("init", TREE_OPERAND (t, 1)); 678 dump_child ("clnp", TREE_OPERAND (t, 2)); 679 /* There really are two possible places the initializer can be. 680 After RTL expansion, the second operand is moved to the 681 position of the fourth operand, and the second operand 682 becomes NULL. */ 683 dump_child ("init", TREE_OPERAND (t, 3)); 684 break; 685 686 case CASE_LABEL_EXPR: 687 dump_child ("name", CASE_LABEL (t)); 688 if (CASE_LOW (t)) 689 { 690 dump_child ("low ", CASE_LOW (t)); 691 if (CASE_HIGH (t)) 692 dump_child ("high", CASE_HIGH (t)); 693 } 694 break; 695 case LABEL_EXPR: 696 dump_child ("name", TREE_OPERAND (t,0)); 697 break; 698 case GOTO_EXPR: 699 dump_child ("labl", TREE_OPERAND (t, 0)); 700 break; 701 case SWITCH_EXPR: 702 dump_child ("cond", TREE_OPERAND (t, 0)); 703 dump_child ("body", TREE_OPERAND (t, 1)); 704 if (TREE_OPERAND (t, 2)) 705 { 706 dump_child ("labl", TREE_OPERAND (t,2)); 707 } 708 break; 709 case OMP_CLAUSE: 710 { 711 int i; 712 fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]); 713 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) 714 dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i)); 715 } 716 break; 717 default: 718 /* There are no additional fields to print. */ 719 break; 720 } 721 722 done: 723 if (dump_flag (di, TDF_ADDRESS, NULL)) 724 dump_pointer (di, "addr", (void *)t); 725 726 /* Terminate the line. */ 727 fprintf (di->stream, "\n"); 728 } 729 730 /* Return nonzero if FLAG has been specified for the dump, and NODE 731 is not the root node of the dump. */ 732 733 int dump_flag (dump_info_p di, int flag, const_tree node) 734 { 735 return (di->flags & flag) && (node != di->node); 736 } 737 738 /* Dump T, and all its children, on STREAM. */ 739 740 void 741 dump_node (const_tree t, int flags, FILE *stream) 742 { 743 struct dump_info di; 744 dump_queue_p dq; 745 dump_queue_p next_dq; 746 747 /* Initialize the dump-information structure. */ 748 di.stream = stream; 749 di.index = 0; 750 di.column = 0; 751 di.queue = 0; 752 di.queue_end = 0; 753 di.free_list = 0; 754 di.flags = flags; 755 di.node = t; 756 di.nodes = splay_tree_new (splay_tree_compare_pointers, 0, 757 (splay_tree_delete_value_fn) &free); 758 759 /* Queue up the first node. */ 760 queue (&di, t, DUMP_NONE); 761 762 /* Until the queue is empty, keep dumping nodes. */ 763 while (di.queue) 764 dequeue_and_dump (&di); 765 766 /* Now, clean up. */ 767 for (dq = di.free_list; dq; dq = next_dq) 768 { 769 next_dq = dq->next; 770 free (dq); 771 } 772 splay_tree_delete (di.nodes); 773 } 774