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