1/* Call-backs for C++ error reporting. 2 This code is non-reentrant. 3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 4 2003, 2004, 2005 Free Software Foundation, Inc. 5 This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to 19the Free Software Foundation, 51 Franklin Street, Fifth Floor, 20Boston, MA 02110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "tree.h" 27#include "cp-tree.h" 28#include "real.h" 29#include "toplev.h" 30#include "flags.h" 31#include "diagnostic.h" 32#include "langhooks-def.h" 33#include "cxx-pretty-print.h" 34 35#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',') 36 37/* The global buffer where we dump everything. It is there only for 38 transitional purpose. It is expected, in the near future, to be 39 completely removed. */ 40static cxx_pretty_printer scratch_pretty_printer; 41#define cxx_pp (&scratch_pretty_printer) 42 43# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) 44 45static const char *args_to_string (tree, int); 46static const char *assop_to_string (enum tree_code); 47static const char *code_to_string (enum tree_code); 48static const char *cv_to_string (tree, int); 49static const char *decl_to_string (tree, int); 50static const char *expr_to_string (tree); 51static const char *fndecl_to_string (tree, int); 52static const char *op_to_string (enum tree_code); 53static const char *parm_to_string (int); 54static const char *type_to_string (tree, int); 55 56static void dump_type (tree, int); 57static void dump_typename (tree, int); 58static void dump_simple_decl (tree, tree, int); 59static void dump_decl (tree, int); 60static void dump_template_decl (tree, int); 61static void dump_function_decl (tree, int); 62static void dump_expr (tree, int); 63static void dump_unary_op (const char *, tree, int); 64static void dump_binary_op (const char *, tree, int); 65static void dump_aggr_type (tree, int); 66static void dump_type_prefix (tree, int); 67static void dump_type_suffix (tree, int); 68static void dump_function_name (tree, int); 69static void dump_expr_list (tree, int); 70static void dump_global_iord (tree); 71static void dump_parameters (tree, int); 72static void dump_exception_spec (tree, int); 73static void dump_template_argument (tree, int); 74static void dump_template_argument_list (tree, int); 75static void dump_template_parameter (tree, int); 76static void dump_template_bindings (tree, tree); 77static void dump_scope (tree, int); 78static void dump_template_parms (tree, int, int); 79 80static const char *function_category (tree); 81static void maybe_print_instantiation_context (diagnostic_context *); 82static void print_instantiation_full_context (diagnostic_context *); 83static void print_instantiation_partial_context (diagnostic_context *, 84 tree, location_t); 85static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); 86static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); 87static void cp_print_error_function (diagnostic_context *, diagnostic_info *); 88 89static bool cp_printer (pretty_printer *, text_info *, const char *, 90 int, bool, bool, bool); 91static location_t location_of (tree); 92 93void 94init_error (void) 95{ 96 diagnostic_starter (global_dc) = cp_diagnostic_starter; 97 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer; 98 diagnostic_format_decoder (global_dc) = cp_printer; 99 100 pp_construct (pp_base (cxx_pp), NULL, 0); 101 pp_cxx_pretty_printer_init (cxx_pp); 102} 103 104/* Dump a scope, if deemed necessary. */ 105 106static void 107dump_scope (tree scope, int flags) 108{ 109 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF)); 110 111 if (scope == NULL_TREE) 112 return; 113 114 if (TREE_CODE (scope) == NAMESPACE_DECL) 115 { 116 if (scope != global_namespace) 117 { 118 dump_decl (scope, f); 119 pp_cxx_colon_colon (cxx_pp); 120 } 121 } 122 else if (AGGREGATE_TYPE_P (scope)) 123 { 124 dump_type (scope, f); 125 pp_cxx_colon_colon (cxx_pp); 126 } 127 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) 128 { 129 dump_function_decl (scope, f); 130 pp_cxx_colon_colon (cxx_pp); 131 } 132} 133 134/* Dump the template ARGument under control of FLAGS. */ 135 136static void 137dump_template_argument (tree arg, int flags) 138{ 139 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) 140 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); 141 else 142 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); 143} 144 145/* Dump a template-argument-list ARGS (always a TREE_VEC) under control 146 of FLAGS. */ 147 148static void 149dump_template_argument_list (tree args, int flags) 150{ 151 int n = TREE_VEC_LENGTH (args); 152 int need_comma = 0; 153 int i; 154 155 for (i = 0; i< n; ++i) 156 { 157 if (need_comma) 158 pp_separate_with_comma (cxx_pp); 159 dump_template_argument (TREE_VEC_ELT (args, i), flags); 160 need_comma = 1; 161 } 162} 163 164/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ 165 166static void 167dump_template_parameter (tree parm, int flags) 168{ 169 tree p; 170 tree a; 171 172 if (parm == error_mark_node) 173 return; 174 175 p = TREE_VALUE (parm); 176 a = TREE_PURPOSE (parm); 177 178 if (TREE_CODE (p) == TYPE_DECL) 179 { 180 if (flags & TFF_DECL_SPECIFIERS) 181 { 182 pp_cxx_identifier (cxx_pp, "class"); 183 if (DECL_NAME (p)) 184 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 185 } 186 else if (DECL_NAME (p)) 187 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 188 else 189 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p)); 190 } 191 else 192 dump_decl (p, flags | TFF_DECL_SPECIFIERS); 193 194 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) 195 { 196 pp_cxx_whitespace (cxx_pp); 197 pp_equal (cxx_pp); 198 pp_cxx_whitespace (cxx_pp); 199 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) 200 dump_type (a, flags & ~TFF_CHASE_TYPEDEF); 201 else 202 dump_expr (a, flags | TFF_EXPR_IN_PARENS); 203 } 204} 205 206/* Dump, under control of FLAGS, a template-parameter-list binding. 207 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a 208 TREE_VEC. */ 209 210static void 211dump_template_bindings (tree parms, tree args) 212{ 213 int need_comma = 0; 214 215 while (parms) 216 { 217 tree p = TREE_VALUE (parms); 218 int lvl = TMPL_PARMS_DEPTH (parms); 219 int arg_idx = 0; 220 int i; 221 222 for (i = 0; i < TREE_VEC_LENGTH (p); ++i) 223 { 224 tree arg = NULL_TREE; 225 226 /* Don't crash if we had an invalid argument list. */ 227 if (TMPL_ARGS_DEPTH (args) >= lvl) 228 { 229 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl); 230 if (NUM_TMPL_ARGS (lvl_args) > arg_idx) 231 arg = TREE_VEC_ELT (lvl_args, arg_idx); 232 } 233 234 if (need_comma) 235 pp_separate_with_comma (cxx_pp); 236 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); 237 pp_cxx_whitespace (cxx_pp); 238 pp_equal (cxx_pp); 239 pp_cxx_whitespace (cxx_pp); 240 if (arg) 241 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); 242 else 243 pp_identifier (cxx_pp, "<missing>"); 244 245 ++arg_idx; 246 need_comma = 1; 247 } 248 249 parms = TREE_CHAIN (parms); 250 } 251} 252 253/* Dump a human-readable equivalent of TYPE. FLAGS controls the 254 format. */ 255 256static void 257dump_type (tree t, int flags) 258{ 259 if (t == NULL_TREE) 260 return; 261 262 if (TYPE_PTRMEMFUNC_P (t)) 263 goto offset_type; 264 265 switch (TREE_CODE (t)) 266 { 267 case UNKNOWN_TYPE: 268 pp_identifier (cxx_pp, "<unresolved overloaded function type>"); 269 break; 270 271 case TREE_LIST: 272 /* A list of function parms. */ 273 dump_parameters (t, flags); 274 break; 275 276 case IDENTIFIER_NODE: 277 pp_cxx_tree_identifier (cxx_pp, t); 278 break; 279 280 case TREE_BINFO: 281 dump_type (BINFO_TYPE (t), flags); 282 break; 283 284 case RECORD_TYPE: 285 case UNION_TYPE: 286 case ENUMERAL_TYPE: 287 dump_aggr_type (t, flags); 288 break; 289 290 case TYPE_DECL: 291 if (flags & TFF_CHASE_TYPEDEF) 292 { 293 dump_type (DECL_ORIGINAL_TYPE (t) 294 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); 295 break; 296 } 297 /* Else fall through. */ 298 299 case TEMPLATE_DECL: 300 case NAMESPACE_DECL: 301 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS); 302 break; 303 304 case INTEGER_TYPE: 305 case REAL_TYPE: 306 case VOID_TYPE: 307 case BOOLEAN_TYPE: 308 case COMPLEX_TYPE: 309 case VECTOR_TYPE: 310 pp_type_specifier_seq (cxx_pp, t); 311 break; 312 313 case TEMPLATE_TEMPLATE_PARM: 314 /* For parameters inside template signature. */ 315 if (TYPE_IDENTIFIER (t)) 316 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 317 else 318 pp_cxx_canonical_template_parameter (cxx_pp, t); 319 break; 320 321 case BOUND_TEMPLATE_TEMPLATE_PARM: 322 { 323 tree args = TYPE_TI_ARGS (t); 324 pp_cxx_cv_qualifier_seq (cxx_pp, t); 325 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 326 pp_cxx_begin_template_argument_list (cxx_pp); 327 dump_template_argument_list (args, flags); 328 pp_cxx_end_template_argument_list (cxx_pp); 329 } 330 break; 331 332 case TEMPLATE_TYPE_PARM: 333 pp_cxx_cv_qualifier_seq (cxx_pp, t); 334 if (TYPE_IDENTIFIER (t)) 335 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 336 else 337 pp_cxx_canonical_template_parameter 338 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t)); 339 break; 340 341 /* This is not always necessary for pointers and such, but doing this 342 reduces code size. */ 343 case ARRAY_TYPE: 344 case POINTER_TYPE: 345 case REFERENCE_TYPE: 346 case OFFSET_TYPE: 347 offset_type: 348 case FUNCTION_TYPE: 349 case METHOD_TYPE: 350 { 351 dump_type_prefix (t, flags); 352 dump_type_suffix (t, flags); 353 break; 354 } 355 case TYPENAME_TYPE: 356 pp_cxx_cv_qualifier_seq (cxx_pp, t); 357 pp_cxx_identifier (cxx_pp, 358 TYPENAME_IS_ENUM_P (t) ? "enum" 359 : TYPENAME_IS_CLASS_P (t) ? "class" 360 : "typename"); 361 dump_typename (t, flags); 362 break; 363 364 case UNBOUND_CLASS_TEMPLATE: 365 dump_type (TYPE_CONTEXT (t), flags); 366 pp_cxx_colon_colon (cxx_pp); 367 pp_cxx_identifier (cxx_pp, "template"); 368 dump_type (DECL_NAME (TYPE_NAME (t)), flags); 369 break; 370 371 case TYPEOF_TYPE: 372 pp_cxx_identifier (cxx_pp, "__typeof__"); 373 pp_cxx_whitespace (cxx_pp); 374 pp_cxx_left_paren (cxx_pp); 375 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 376 pp_cxx_right_paren (cxx_pp); 377 break; 378 379 default: 380 pp_unsupported_tree (cxx_pp, t); 381 /* Fall through to error. */ 382 383 case ERROR_MARK: 384 pp_identifier (cxx_pp, "<type error>"); 385 break; 386 } 387} 388 389/* Dump a TYPENAME_TYPE. We need to notice when the context is itself 390 a TYPENAME_TYPE. */ 391 392static void 393dump_typename (tree t, int flags) 394{ 395 tree ctx = TYPE_CONTEXT (t); 396 397 if (TREE_CODE (ctx) == TYPENAME_TYPE) 398 dump_typename (ctx, flags); 399 else 400 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); 401 pp_cxx_colon_colon (cxx_pp); 402 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); 403} 404 405/* Return the name of the supplied aggregate, or enumeral type. */ 406 407const char * 408class_key_or_enum_as_string (tree t) 409{ 410 if (TREE_CODE (t) == ENUMERAL_TYPE) 411 return "enum"; 412 else if (TREE_CODE (t) == UNION_TYPE) 413 return "union"; 414 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 415 return "class"; 416 else 417 return "struct"; 418} 419 420/* Print out a class declaration T under the control of FLAGS, 421 in the form `class foo'. */ 422 423static void 424dump_aggr_type (tree t, int flags) 425{ 426 tree name; 427 const char *variety = class_key_or_enum_as_string (t); 428 int typdef = 0; 429 int tmplate = 0; 430 431 pp_cxx_cv_qualifier_seq (cxx_pp, t); 432 433 if (flags & TFF_CLASS_KEY_OR_ENUM) 434 pp_cxx_identifier (cxx_pp, variety); 435 436 if (flags & TFF_CHASE_TYPEDEF) 437 t = TYPE_MAIN_VARIANT (t); 438 439 name = TYPE_NAME (t); 440 441 if (name) 442 { 443 typdef = !DECL_ARTIFICIAL (name); 444 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE 445 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t) 446 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL 447 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); 448 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE); 449 if (tmplate) 450 { 451 /* Because the template names are mangled, we have to locate 452 the most general template, and use that name. */ 453 tree tpl = CLASSTYPE_TI_TEMPLATE (t); 454 455 while (DECL_TEMPLATE_INFO (tpl)) 456 tpl = DECL_TI_TEMPLATE (tpl); 457 name = tpl; 458 } 459 name = DECL_NAME (name); 460 } 461 462 if (name == 0 || ANON_AGGRNAME_P (name)) 463 { 464 if (flags & TFF_CLASS_KEY_OR_ENUM) 465 pp_identifier (cxx_pp, "<anonymous>"); 466 else 467 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety); 468 } 469 else 470 pp_cxx_tree_identifier (cxx_pp, name); 471 if (tmplate) 472 dump_template_parms (TYPE_TEMPLATE_INFO (t), 473 !CLASSTYPE_USE_TEMPLATE (t), 474 flags & ~TFF_TEMPLATE_HEADER); 475} 476 477/* Dump into the obstack the initial part of the output for a given type. 478 This is necessary when dealing with things like functions returning 479 functions. Examples: 480 481 return type of `int (* fee ())()': pointer -> function -> int. Both 482 pointer (and reference and offset) and function (and member) types must 483 deal with prefix and suffix. 484 485 Arrays must also do this for DECL nodes, like int a[], and for things like 486 int *[]&. */ 487 488static void 489dump_type_prefix (tree t, int flags) 490{ 491 if (TYPE_PTRMEMFUNC_P (t)) 492 { 493 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 494 goto offset_type; 495 } 496 497 switch (TREE_CODE (t)) 498 { 499 case POINTER_TYPE: 500 case REFERENCE_TYPE: 501 { 502 tree sub = TREE_TYPE (t); 503 504 dump_type_prefix (sub, flags); 505 if (TREE_CODE (sub) == ARRAY_TYPE) 506 { 507 pp_cxx_whitespace (cxx_pp); 508 pp_cxx_left_paren (cxx_pp); 509 } 510 pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]); 511 pp_base (cxx_pp)->padding = pp_before; 512 pp_cxx_cv_qualifier_seq (cxx_pp, t); 513 } 514 break; 515 516 case OFFSET_TYPE: 517 offset_type: 518 dump_type_prefix (TREE_TYPE (t), flags); 519 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ 520 { 521 pp_maybe_space (cxx_pp); 522 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 523 pp_cxx_left_paren (cxx_pp); 524 dump_type (TYPE_OFFSET_BASETYPE (t), flags); 525 pp_cxx_colon_colon (cxx_pp); 526 } 527 pp_cxx_star (cxx_pp); 528 pp_cxx_cv_qualifier_seq (cxx_pp, t); 529 pp_base (cxx_pp)->padding = pp_before; 530 break; 531 532 /* Can only be reached through function pointer -- this would not be 533 correct if FUNCTION_DECLs used it. */ 534 case FUNCTION_TYPE: 535 dump_type_prefix (TREE_TYPE (t), flags); 536 pp_maybe_space (cxx_pp); 537 pp_cxx_left_paren (cxx_pp); 538 break; 539 540 case METHOD_TYPE: 541 dump_type_prefix (TREE_TYPE (t), flags); 542 pp_maybe_space (cxx_pp); 543 pp_cxx_left_paren (cxx_pp); 544 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); 545 pp_cxx_colon_colon (cxx_pp); 546 break; 547 548 case ARRAY_TYPE: 549 dump_type_prefix (TREE_TYPE (t), flags); 550 break; 551 552 case ENUMERAL_TYPE: 553 case IDENTIFIER_NODE: 554 case INTEGER_TYPE: 555 case BOOLEAN_TYPE: 556 case REAL_TYPE: 557 case RECORD_TYPE: 558 case TEMPLATE_TYPE_PARM: 559 case TEMPLATE_TEMPLATE_PARM: 560 case BOUND_TEMPLATE_TEMPLATE_PARM: 561 case TREE_LIST: 562 case TYPE_DECL: 563 case TREE_VEC: 564 case UNION_TYPE: 565 case UNKNOWN_TYPE: 566 case VOID_TYPE: 567 case TYPENAME_TYPE: 568 case COMPLEX_TYPE: 569 case VECTOR_TYPE: 570 case TYPEOF_TYPE: 571 dump_type (t, flags); 572 pp_base (cxx_pp)->padding = pp_before; 573 break; 574 575 default: 576 pp_unsupported_tree (cxx_pp, t); 577 /* fall through. */ 578 case ERROR_MARK: 579 pp_identifier (cxx_pp, "<typeprefixerror>"); 580 break; 581 } 582} 583 584/* Dump the suffix of type T, under control of FLAGS. This is the part 585 which appears after the identifier (or function parms). */ 586 587static void 588dump_type_suffix (tree t, int flags) 589{ 590 if (TYPE_PTRMEMFUNC_P (t)) 591 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 592 593 switch (TREE_CODE (t)) 594 { 595 case POINTER_TYPE: 596 case REFERENCE_TYPE: 597 case OFFSET_TYPE: 598 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 599 pp_cxx_right_paren (cxx_pp); 600 dump_type_suffix (TREE_TYPE (t), flags); 601 break; 602 603 /* Can only be reached through function pointer. */ 604 case FUNCTION_TYPE: 605 case METHOD_TYPE: 606 { 607 tree arg; 608 pp_cxx_right_paren (cxx_pp); 609 arg = TYPE_ARG_TYPES (t); 610 if (TREE_CODE (t) == METHOD_TYPE) 611 arg = TREE_CHAIN (arg); 612 613 /* Function pointers don't have default args. Not in standard C++, 614 anyway; they may in g++, but we'll just pretend otherwise. */ 615 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); 616 617 if (TREE_CODE (t) == METHOD_TYPE) 618 pp_cxx_cv_qualifier_seq 619 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t)))); 620 else 621 pp_cxx_cv_qualifier_seq(cxx_pp, t); 622 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags); 623 dump_type_suffix (TREE_TYPE (t), flags); 624 break; 625 } 626 627 case ARRAY_TYPE: 628 pp_maybe_space (cxx_pp); 629 pp_cxx_left_bracket (cxx_pp); 630 if (TYPE_DOMAIN (t)) 631 { 632 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0)) 633 pp_wide_integer 634 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1); 635 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR) 636 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), 637 flags & ~TFF_EXPR_IN_PARENS); 638 else 639 dump_expr (fold (cp_build_binary_op 640 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 641 integer_one_node)), 642 flags & ~TFF_EXPR_IN_PARENS); 643 } 644 pp_cxx_right_bracket (cxx_pp); 645 dump_type_suffix (TREE_TYPE (t), flags); 646 break; 647 648 case ENUMERAL_TYPE: 649 case IDENTIFIER_NODE: 650 case INTEGER_TYPE: 651 case BOOLEAN_TYPE: 652 case REAL_TYPE: 653 case RECORD_TYPE: 654 case TEMPLATE_TYPE_PARM: 655 case TEMPLATE_TEMPLATE_PARM: 656 case BOUND_TEMPLATE_TEMPLATE_PARM: 657 case TREE_LIST: 658 case TYPE_DECL: 659 case TREE_VEC: 660 case UNION_TYPE: 661 case UNKNOWN_TYPE: 662 case VOID_TYPE: 663 case TYPENAME_TYPE: 664 case COMPLEX_TYPE: 665 case VECTOR_TYPE: 666 case TYPEOF_TYPE: 667 break; 668 669 default: 670 pp_unsupported_tree (cxx_pp, t); 671 case ERROR_MARK: 672 /* Don't mark it here, we should have already done in 673 dump_type_prefix. */ 674 break; 675 } 676} 677 678static void 679dump_global_iord (tree t) 680{ 681 const char *p = NULL; 682 683 if (DECL_GLOBAL_CTOR_P (t)) 684 p = "initializers"; 685 else if (DECL_GLOBAL_DTOR_P (t)) 686 p = "destructors"; 687 else 688 gcc_unreachable (); 689 690 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename); 691} 692 693static void 694dump_simple_decl (tree t, tree type, int flags) 695{ 696 if (flags & TFF_DECL_SPECIFIERS) 697 { 698 dump_type_prefix (type, flags); 699 pp_maybe_space (cxx_pp); 700 } 701 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX) 702 dump_scope (CP_DECL_CONTEXT (t), flags); 703 if (DECL_NAME (t)) 704 dump_decl (DECL_NAME (t), flags); 705 else 706 pp_identifier (cxx_pp, "<anonymous>"); 707 if (flags & TFF_DECL_SPECIFIERS) 708 dump_type_suffix (type, flags); 709} 710 711/* Dump a human readable string for the decl T under control of FLAGS. */ 712 713static void 714dump_decl (tree t, int flags) 715{ 716 if (t == NULL_TREE) 717 return; 718 719 switch (TREE_CODE (t)) 720 { 721 case TYPE_DECL: 722 /* Don't say 'typedef class A' */ 723 if (DECL_ARTIFICIAL (t)) 724 { 725 if ((flags & TFF_DECL_SPECIFIERS) 726 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) 727 /* Say `class T' not just `T'. */ 728 pp_cxx_identifier (cxx_pp, "class"); 729 730 dump_type (TREE_TYPE (t), flags); 731 break; 732 } 733 if (flags & TFF_DECL_SPECIFIERS) 734 pp_cxx_identifier (cxx_pp, "typedef"); 735 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) 736 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), 737 flags); 738 break; 739 740 case VAR_DECL: 741 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) 742 { 743 pp_string (cxx_pp, "vtable for "); 744 gcc_assert (TYPE_P (DECL_CONTEXT (t))); 745 dump_type (DECL_CONTEXT (t), flags); 746 break; 747 } 748 /* Else fall through. */ 749 case FIELD_DECL: 750 case PARM_DECL: 751 dump_simple_decl (t, TREE_TYPE (t), flags); 752 break; 753 754 case RESULT_DECL: 755 pp_string (cxx_pp, "<return value> "); 756 dump_simple_decl (t, TREE_TYPE (t), flags); 757 break; 758 759 case NAMESPACE_DECL: 760 if (flags & TFF_DECL_SPECIFIERS) 761 pp_cxx_declaration (cxx_pp, t); 762 else 763 { 764 dump_scope (CP_DECL_CONTEXT (t), flags); 765 if (DECL_NAME (t) == NULL_TREE) 766 pp_identifier (cxx_pp, "<unnamed>"); 767 else 768 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 769 } 770 break; 771 772 case SCOPE_REF: 773 pp_expression (cxx_pp, t); 774 break; 775 776 case ARRAY_REF: 777 dump_decl (TREE_OPERAND (t, 0), flags); 778 pp_cxx_left_bracket (cxx_pp); 779 dump_decl (TREE_OPERAND (t, 1), flags); 780 pp_cxx_right_bracket (cxx_pp); 781 break; 782 783 /* So that we can do dump_decl on an aggr type. */ 784 case RECORD_TYPE: 785 case UNION_TYPE: 786 case ENUMERAL_TYPE: 787 dump_type (t, flags); 788 break; 789 790 case BIT_NOT_EXPR: 791 /* This is a pseudo destructor call which has not been folded into 792 a PSEUDO_DTOR_EXPR yet. */ 793 pp_cxx_complement (cxx_pp); 794 dump_type (TREE_OPERAND (t, 0), flags); 795 break; 796 797 case TYPE_EXPR: 798 gcc_unreachable (); 799 break; 800 801 /* These special cases are duplicated here so that other functions 802 can feed identifiers to error and get them demangled properly. */ 803 case IDENTIFIER_NODE: 804 if (IDENTIFIER_TYPENAME_P (t)) 805 { 806 pp_cxx_identifier (cxx_pp, "operator"); 807 /* Not exactly IDENTIFIER_TYPE_VALUE. */ 808 dump_type (TREE_TYPE (t), flags); 809 break; 810 } 811 else 812 pp_cxx_tree_identifier (cxx_pp, t); 813 break; 814 815 case OVERLOAD: 816 if (OVL_CHAIN (t)) 817 { 818 t = OVL_CURRENT (t); 819 if (DECL_CLASS_SCOPE_P (t)) 820 { 821 dump_type (DECL_CONTEXT (t), flags); 822 pp_cxx_colon_colon (cxx_pp); 823 } 824 else if (DECL_CONTEXT (t)) 825 { 826 dump_decl (DECL_CONTEXT (t), flags); 827 pp_cxx_colon_colon (cxx_pp); 828 } 829 dump_decl (DECL_NAME (t), flags); 830 break; 831 } 832 833 /* If there's only one function, just treat it like an ordinary 834 FUNCTION_DECL. */ 835 t = OVL_CURRENT (t); 836 /* Fall through. */ 837 838 case FUNCTION_DECL: 839 if (! DECL_LANG_SPECIFIC (t)) 840 pp_identifier (cxx_pp, "<built-in>"); 841 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) 842 dump_global_iord (t); 843 else 844 dump_function_decl (t, flags); 845 break; 846 847 case TEMPLATE_DECL: 848 dump_template_decl (t, flags); 849 break; 850 851 case TEMPLATE_ID_EXPR: 852 { 853 tree name = TREE_OPERAND (t, 0); 854 855 if (is_overloaded_fn (name)) 856 name = DECL_NAME (get_first_fn (name)); 857 dump_decl (name, flags); 858 pp_cxx_begin_template_argument_list (cxx_pp); 859 if (TREE_OPERAND (t, 1)) 860 dump_template_argument_list (TREE_OPERAND (t, 1), flags); 861 pp_cxx_end_template_argument_list (cxx_pp); 862 } 863 break; 864 865 case LABEL_DECL: 866 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 867 break; 868 869 case CONST_DECL: 870 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) 871 || (DECL_INITIAL (t) && 872 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) 873 dump_simple_decl (t, TREE_TYPE (t), flags); 874 else if (DECL_NAME (t)) 875 dump_decl (DECL_NAME (t), flags); 876 else if (DECL_INITIAL (t)) 877 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); 878 else 879 pp_identifier (cxx_pp, "<enumerator>"); 880 break; 881 882 case USING_DECL: 883 pp_cxx_identifier (cxx_pp, "using"); 884 dump_type (USING_DECL_SCOPE (t), flags); 885 pp_cxx_colon_colon (cxx_pp); 886 dump_decl (DECL_NAME (t), flags); 887 break; 888 889 case BASELINK: 890 dump_decl (BASELINK_FUNCTIONS (t), flags); 891 break; 892 893 case NON_DEPENDENT_EXPR: 894 dump_expr (t, flags); 895 break; 896 897 case TEMPLATE_TYPE_PARM: 898 if (flags & TFF_DECL_SPECIFIERS) 899 pp_cxx_declaration (cxx_pp, t); 900 else 901 pp_type_id (cxx_pp, t); 902 break; 903 904 default: 905 pp_unsupported_tree (cxx_pp, t); 906 /* Fall through to error. */ 907 908 case ERROR_MARK: 909 pp_identifier (cxx_pp, "<declaration error>"); 910 break; 911 } 912} 913 914/* Dump a template declaration T under control of FLAGS. This means the 915 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ 916 917static void 918dump_template_decl (tree t, int flags) 919{ 920 tree orig_parms = DECL_TEMPLATE_PARMS (t); 921 tree parms; 922 int i; 923 924 if (flags & TFF_TEMPLATE_HEADER) 925 { 926 for (parms = orig_parms = nreverse (orig_parms); 927 parms; 928 parms = TREE_CHAIN (parms)) 929 { 930 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); 931 int len = TREE_VEC_LENGTH (inner_parms); 932 933 pp_cxx_identifier (cxx_pp, "template"); 934 pp_cxx_begin_template_argument_list (cxx_pp); 935 936 /* If we've shown the template prefix, we'd better show the 937 parameters' and decl's type too. */ 938 flags |= TFF_DECL_SPECIFIERS; 939 940 for (i = 0; i < len; i++) 941 { 942 if (i) 943 pp_separate_with_comma (cxx_pp); 944 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); 945 } 946 pp_cxx_end_template_argument_list (cxx_pp); 947 pp_cxx_whitespace (cxx_pp); 948 } 949 nreverse(orig_parms); 950 951 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 952 /* Say `template<arg> class TT' not just `template<arg> TT'. */ 953 pp_cxx_identifier (cxx_pp, "class"); 954 } 955 956 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) 957 dump_type (TREE_TYPE (t), 958 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 959 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); 960 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) 961 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); 962 else 963 { 964 gcc_assert (TREE_TYPE (t)); 965 switch (NEXT_CODE (t)) 966 { 967 case METHOD_TYPE: 968 case FUNCTION_TYPE: 969 dump_function_decl (t, flags | TFF_TEMPLATE_NAME); 970 break; 971 default: 972 /* This case can occur with some invalid code. */ 973 dump_type (TREE_TYPE (t), 974 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 975 | (flags & TFF_DECL_SPECIFIERS 976 ? TFF_CLASS_KEY_OR_ENUM : 0)); 977 } 978 } 979} 980 981/* Pretty print a function decl. There are several ways we want to print a 982 function declaration. The TFF_ bits in FLAGS tells us how to behave. 983 As error can only apply the '#' flag once to give 0 and 1 for V, there 984 is %D which doesn't print the throw specs, and %F which does. */ 985 986static void 987dump_function_decl (tree t, int flags) 988{ 989 tree fntype; 990 tree parmtypes; 991 tree cname = NULL_TREE; 992 tree template_args = NULL_TREE; 993 tree template_parms = NULL_TREE; 994 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; 995 996 if (TREE_CODE (t) == TEMPLATE_DECL) 997 t = DECL_TEMPLATE_RESULT (t); 998 999 /* Pretty print template instantiations only. */ 1000 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)) 1001 { 1002 tree tmpl; 1003 1004 template_args = DECL_TI_ARGS (t); 1005 tmpl = most_general_template (t); 1006 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) 1007 { 1008 template_parms = DECL_TEMPLATE_PARMS (tmpl); 1009 t = tmpl; 1010 } 1011 } 1012 1013 fntype = TREE_TYPE (t); 1014 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); 1015 1016 if (DECL_CLASS_SCOPE_P (t)) 1017 cname = DECL_CONTEXT (t); 1018 /* This is for partially instantiated template methods. */ 1019 else if (TREE_CODE (fntype) == METHOD_TYPE) 1020 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 1021 1022 if (!(flags & TFF_DECL_SPECIFIERS)) 1023 /* OK */; 1024 else if (DECL_STATIC_FUNCTION_P (t)) 1025 pp_cxx_identifier (cxx_pp, "static"); 1026 else if (DECL_VIRTUAL_P (t)) 1027 pp_cxx_identifier (cxx_pp, "virtual"); 1028 1029 /* Print the return type? */ 1030 if (show_return) 1031 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) 1032 && !DECL_DESTRUCTOR_P (t); 1033 if (show_return) 1034 dump_type_prefix (TREE_TYPE (fntype), flags); 1035 1036 /* Print the function name. */ 1037 if (cname) 1038 { 1039 dump_type (cname, flags); 1040 pp_cxx_colon_colon (cxx_pp); 1041 } 1042 else 1043 dump_scope (CP_DECL_CONTEXT (t), flags); 1044 1045 dump_function_name (t, flags); 1046 1047 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) 1048 { 1049 dump_parameters (parmtypes, flags); 1050 1051 if (TREE_CODE (fntype) == METHOD_TYPE) 1052 { 1053 pp_base (cxx_pp)->padding = pp_before; 1054 pp_cxx_cv_qualifier_seq 1055 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); 1056 } 1057 1058 if (flags & TFF_EXCEPTION_SPECIFICATION) 1059 { 1060 pp_base (cxx_pp)->padding = pp_before; 1061 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); 1062 } 1063 1064 if (show_return) 1065 dump_type_suffix (TREE_TYPE (fntype), flags); 1066 } 1067 1068 /* If T is a template instantiation, dump the parameter binding. */ 1069 if (template_parms != NULL_TREE && template_args != NULL_TREE) 1070 { 1071 pp_cxx_whitespace (cxx_pp); 1072 pp_cxx_left_bracket (cxx_pp); 1073 pp_cxx_identifier (cxx_pp, "with"); 1074 pp_cxx_whitespace (cxx_pp); 1075 dump_template_bindings (template_parms, template_args); 1076 pp_cxx_right_bracket (cxx_pp); 1077 } 1078} 1079 1080/* Print a parameter list. If this is for a member function, the 1081 member object ptr (and any other hidden args) should have 1082 already been removed. */ 1083 1084static void 1085dump_parameters (tree parmtypes, int flags) 1086{ 1087 int first; 1088 1089 pp_cxx_left_paren (cxx_pp); 1090 1091 for (first = 1; parmtypes != void_list_node; 1092 parmtypes = TREE_CHAIN (parmtypes)) 1093 { 1094 if (!first) 1095 pp_separate_with_comma (cxx_pp); 1096 first = 0; 1097 if (!parmtypes) 1098 { 1099 pp_cxx_identifier (cxx_pp, "..."); 1100 break; 1101 } 1102 dump_type (TREE_VALUE (parmtypes), flags); 1103 1104 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) 1105 { 1106 pp_cxx_whitespace (cxx_pp); 1107 pp_equal (cxx_pp); 1108 pp_cxx_whitespace (cxx_pp); 1109 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); 1110 } 1111 } 1112 1113 pp_cxx_right_paren (cxx_pp); 1114} 1115 1116/* Print an exception specification. T is the exception specification. */ 1117 1118static void 1119dump_exception_spec (tree t, int flags) 1120{ 1121 if (t) 1122 { 1123 pp_cxx_identifier (cxx_pp, "throw"); 1124 pp_cxx_whitespace (cxx_pp); 1125 pp_cxx_left_paren (cxx_pp); 1126 if (TREE_VALUE (t) != NULL_TREE) 1127 while (1) 1128 { 1129 dump_type (TREE_VALUE (t), flags); 1130 t = TREE_CHAIN (t); 1131 if (!t) 1132 break; 1133 pp_separate_with_comma (cxx_pp); 1134 } 1135 pp_cxx_right_paren (cxx_pp); 1136 } 1137} 1138 1139/* Handle the function name for a FUNCTION_DECL node, grokking operators 1140 and destructors properly. */ 1141 1142static void 1143dump_function_name (tree t, int flags) 1144{ 1145 tree name = DECL_NAME (t); 1146 1147 /* We can get here with a decl that was synthesized by language- 1148 independent machinery (e.g. coverage.c) in which case it won't 1149 have a lang_specific structure attached and DECL_CONSTRUCTOR_P 1150 will crash. In this case it is safe just to print out the 1151 literal name. */ 1152 if (!DECL_LANG_SPECIFIC (t)) 1153 { 1154 pp_cxx_tree_identifier (cxx_pp, name); 1155 return; 1156 } 1157 1158 if (TREE_CODE (t) == TEMPLATE_DECL) 1159 t = DECL_TEMPLATE_RESULT (t); 1160 1161 /* Don't let the user see __comp_ctor et al. */ 1162 if (DECL_CONSTRUCTOR_P (t) 1163 || DECL_DESTRUCTOR_P (t)) 1164 name = constructor_name (DECL_CONTEXT (t)); 1165 1166 if (DECL_DESTRUCTOR_P (t)) 1167 { 1168 pp_cxx_complement (cxx_pp); 1169 dump_decl (name, TFF_PLAIN_IDENTIFIER); 1170 } 1171 else if (DECL_CONV_FN_P (t)) 1172 { 1173 /* This cannot use the hack that the operator's return 1174 type is stashed off of its name because it may be 1175 used for error reporting. In the case of conflicting 1176 declarations, both will have the same name, yet 1177 the types will be different, hence the TREE_TYPE field 1178 of the first name will be clobbered by the second. */ 1179 pp_cxx_identifier (cxx_pp, "operator"); 1180 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1181 } 1182 else if (IDENTIFIER_OPNAME_P (name)) 1183 pp_cxx_tree_identifier (cxx_pp, name); 1184 else 1185 dump_decl (name, flags); 1186 1187 if (DECL_TEMPLATE_INFO (t) 1188 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) 1189 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1190 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1191 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags); 1192} 1193 1194/* Dump the template parameters from the template info INFO under control of 1195 FLAGS. PRIMARY indicates whether this is a primary template decl, or 1196 specialization (partial or complete). For partial specializations we show 1197 the specialized parameter values. For a primary template we show no 1198 decoration. */ 1199 1200static void 1201dump_template_parms (tree info, int primary, int flags) 1202{ 1203 tree args = info ? TI_ARGS (info) : NULL_TREE; 1204 1205 if (primary && flags & TFF_TEMPLATE_NAME) 1206 return; 1207 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); 1208 pp_cxx_begin_template_argument_list (cxx_pp); 1209 1210 /* Be careful only to print things when we have them, so as not 1211 to crash producing error messages. */ 1212 if (args && !primary) 1213 { 1214 int len, ix; 1215 1216 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) 1217 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); 1218 1219 len = TREE_VEC_LENGTH (args); 1220 1221 for (ix = 0; ix != len; ix++) 1222 { 1223 tree arg = TREE_VEC_ELT (args, ix); 1224 1225 if (ix) 1226 pp_separate_with_comma (cxx_pp); 1227 1228 if (!arg) 1229 pp_identifier (cxx_pp, "<template parameter error>"); 1230 else 1231 dump_template_argument (arg, flags); 1232 } 1233 } 1234 else if (primary) 1235 { 1236 tree tpl = TI_TEMPLATE (info); 1237 tree parms = DECL_TEMPLATE_PARMS (tpl); 1238 int len, ix; 1239 1240 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE; 1241 len = parms ? TREE_VEC_LENGTH (parms) : 0; 1242 1243 for (ix = 0; ix != len; ix++) 1244 { 1245 tree parm; 1246 1247 if (TREE_VEC_ELT (parms, ix) == error_mark_node) 1248 { 1249 pp_identifier (cxx_pp, "<template parameter error>"); 1250 continue; 1251 } 1252 1253 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix)); 1254 1255 if (ix) 1256 pp_separate_with_comma (cxx_pp); 1257 1258 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS); 1259 } 1260 } 1261 pp_cxx_end_template_argument_list (cxx_pp); 1262} 1263 1264/* Print out a list of initializers (subr of dump_expr). */ 1265 1266static void 1267dump_expr_list (tree l, int flags) 1268{ 1269 while (l) 1270 { 1271 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS); 1272 l = TREE_CHAIN (l); 1273 if (l) 1274 pp_separate_with_comma (cxx_pp); 1275 } 1276} 1277 1278/* Print out a vector of initializers (subr of dump_expr). */ 1279 1280static void 1281dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags) 1282{ 1283 unsigned HOST_WIDE_INT idx; 1284 tree value; 1285 1286 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1287 { 1288 dump_expr (value, flags | TFF_EXPR_IN_PARENS); 1289 if (idx != VEC_length (constructor_elt, v) - 1) 1290 pp_separate_with_comma (cxx_pp); 1291 } 1292} 1293 1294 1295/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual 1296 function. Resolve it to a close relative -- in the sense of static 1297 type -- variant being overridden. That is close to what was written in 1298 the source code. Subroutine of dump_expr. */ 1299 1300static tree 1301resolve_virtual_fun_from_obj_type_ref (tree ref) 1302{ 1303 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref)); 1304 int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1); 1305 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type))); 1306 while (index--) 1307 fun = TREE_CHAIN (fun); 1308 1309 return BV_FN (fun); 1310} 1311 1312/* Print out an expression E under control of FLAGS. */ 1313 1314static void 1315dump_expr (tree t, int flags) 1316{ 1317 if (t == 0) 1318 return; 1319 1320 switch (TREE_CODE (t)) 1321 { 1322 case VAR_DECL: 1323 case PARM_DECL: 1324 case FIELD_DECL: 1325 case CONST_DECL: 1326 case FUNCTION_DECL: 1327 case TEMPLATE_DECL: 1328 case NAMESPACE_DECL: 1329 case LABEL_DECL: 1330 case OVERLOAD: 1331 case IDENTIFIER_NODE: 1332 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS); 1333 break; 1334 1335 case INTEGER_CST: 1336 case REAL_CST: 1337 case STRING_CST: 1338 pp_constant (cxx_pp, t); 1339 break; 1340 1341 case THROW_EXPR: 1342 pp_cxx_identifier (cxx_pp, "throw"); 1343 dump_expr (TREE_OPERAND (t, 0), flags); 1344 break; 1345 1346 case PTRMEM_CST: 1347 pp_ampersand (cxx_pp); 1348 dump_type (PTRMEM_CST_CLASS (t), flags); 1349 pp_cxx_colon_colon (cxx_pp); 1350 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); 1351 break; 1352 1353 case COMPOUND_EXPR: 1354 pp_cxx_left_paren (cxx_pp); 1355 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1356 pp_separate_with_comma (cxx_pp); 1357 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1358 pp_cxx_right_paren (cxx_pp); 1359 break; 1360 1361 case COND_EXPR: 1362 pp_cxx_left_paren (cxx_pp); 1363 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1364 pp_string (cxx_pp, " ? "); 1365 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1366 pp_string (cxx_pp, " : "); 1367 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); 1368 pp_cxx_right_paren (cxx_pp); 1369 break; 1370 1371 case SAVE_EXPR: 1372 if (TREE_HAS_CONSTRUCTOR (t)) 1373 { 1374 pp_cxx_identifier (cxx_pp, "new"); 1375 pp_cxx_whitespace (cxx_pp); 1376 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1377 } 1378 else 1379 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1380 break; 1381 1382 case AGGR_INIT_EXPR: 1383 { 1384 tree fn = NULL_TREE; 1385 1386 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR) 1387 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0); 1388 1389 if (fn && TREE_CODE (fn) == FUNCTION_DECL) 1390 { 1391 if (DECL_CONSTRUCTOR_P (fn)) 1392 dump_type (DECL_CONTEXT (fn), flags); 1393 else 1394 dump_decl (fn, 0); 1395 } 1396 else 1397 dump_expr (TREE_OPERAND (t, 0), 0); 1398 } 1399 pp_cxx_left_paren (cxx_pp); 1400 if (TREE_OPERAND (t, 1)) 1401 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1402 pp_cxx_right_paren (cxx_pp); 1403 break; 1404 1405 case CALL_EXPR: 1406 { 1407 tree fn = TREE_OPERAND (t, 0); 1408 tree args = TREE_OPERAND (t, 1); 1409 1410 if (TREE_CODE (fn) == ADDR_EXPR) 1411 fn = TREE_OPERAND (fn, 0); 1412 1413 /* Nobody is interested in seeing the guts of vcalls. */ 1414 if (TREE_CODE (fn) == OBJ_TYPE_REF) 1415 fn = resolve_virtual_fun_from_obj_type_ref (fn); 1416 1417 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE) 1418 { 1419 tree ob = TREE_VALUE (args); 1420 if (TREE_CODE (ob) == ADDR_EXPR) 1421 { 1422 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1423 pp_dot (cxx_pp); 1424 } 1425 else if (TREE_CODE (ob) != PARM_DECL 1426 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1427 { 1428 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1429 pp_arrow (cxx_pp); 1430 } 1431 args = TREE_CHAIN (args); 1432 } 1433 dump_expr (fn, flags | TFF_EXPR_IN_PARENS); 1434 pp_cxx_left_paren (cxx_pp); 1435 dump_expr_list (args, flags); 1436 pp_cxx_right_paren (cxx_pp); 1437 } 1438 break; 1439 1440 case NEW_EXPR: 1441 { 1442 tree type = TREE_OPERAND (t, 1); 1443 tree init = TREE_OPERAND (t, 2); 1444 if (NEW_EXPR_USE_GLOBAL (t)) 1445 pp_cxx_colon_colon (cxx_pp); 1446 pp_cxx_identifier (cxx_pp, "new"); 1447 if (TREE_OPERAND (t, 0)) 1448 { 1449 pp_cxx_left_paren (cxx_pp); 1450 dump_expr_list (TREE_OPERAND (t, 0), flags); 1451 pp_cxx_right_paren (cxx_pp); 1452 pp_cxx_whitespace (cxx_pp); 1453 } 1454 if (TREE_CODE (type) == ARRAY_REF) 1455 type = build_cplus_array_type 1456 (TREE_OPERAND (type, 0), 1457 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node, 1458 TREE_OPERAND (type, 1), 1459 integer_one_node))); 1460 dump_type (type, flags); 1461 if (init) 1462 { 1463 pp_cxx_left_paren (cxx_pp); 1464 if (TREE_CODE (init) == TREE_LIST) 1465 dump_expr_list (init, flags); 1466 else if (init == void_zero_node) 1467 /* This representation indicates an empty initializer, 1468 e.g.: "new int()". */ 1469 ; 1470 else 1471 dump_expr (init, flags); 1472 pp_cxx_right_paren (cxx_pp); 1473 } 1474 } 1475 break; 1476 1477 case TARGET_EXPR: 1478 /* Note that this only works for G++ target exprs. If somebody 1479 builds a general TARGET_EXPR, there's no way to represent that 1480 it initializes anything other that the parameter slot for the 1481 default argument. Note we may have cleared out the first 1482 operand in expand_expr, so don't go killing ourselves. */ 1483 if (TREE_OPERAND (t, 1)) 1484 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1485 break; 1486 1487 case INIT_EXPR: 1488 case MODIFY_EXPR: 1489 case PLUS_EXPR: 1490 case MINUS_EXPR: 1491 case MULT_EXPR: 1492 case TRUNC_DIV_EXPR: 1493 case TRUNC_MOD_EXPR: 1494 case MIN_EXPR: 1495 case MAX_EXPR: 1496 case LSHIFT_EXPR: 1497 case RSHIFT_EXPR: 1498 case BIT_IOR_EXPR: 1499 case BIT_XOR_EXPR: 1500 case BIT_AND_EXPR: 1501 case TRUTH_ANDIF_EXPR: 1502 case TRUTH_ORIF_EXPR: 1503 case LT_EXPR: 1504 case LE_EXPR: 1505 case GT_EXPR: 1506 case GE_EXPR: 1507 case EQ_EXPR: 1508 case NE_EXPR: 1509 case EXACT_DIV_EXPR: 1510 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags); 1511 break; 1512 1513 case CEIL_DIV_EXPR: 1514 case FLOOR_DIV_EXPR: 1515 case ROUND_DIV_EXPR: 1516 case RDIV_EXPR: 1517 dump_binary_op ("/", t, flags); 1518 break; 1519 1520 case CEIL_MOD_EXPR: 1521 case FLOOR_MOD_EXPR: 1522 case ROUND_MOD_EXPR: 1523 dump_binary_op ("%", t, flags); 1524 break; 1525 1526 case COMPONENT_REF: 1527 { 1528 tree ob = TREE_OPERAND (t, 0); 1529 if (TREE_CODE (ob) == INDIRECT_REF) 1530 { 1531 ob = TREE_OPERAND (ob, 0); 1532 if (TREE_CODE (ob) != PARM_DECL 1533 || (DECL_NAME (ob) 1534 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))) 1535 { 1536 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1537 pp_cxx_arrow (cxx_pp); 1538 } 1539 } 1540 else 1541 { 1542 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1543 pp_cxx_dot (cxx_pp); 1544 } 1545 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); 1546 } 1547 break; 1548 1549 case ARRAY_REF: 1550 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1551 pp_cxx_left_bracket (cxx_pp); 1552 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1553 pp_cxx_right_bracket (cxx_pp); 1554 break; 1555 1556 case UNARY_PLUS_EXPR: 1557 dump_unary_op ("+", t, flags); 1558 break; 1559 1560 case ADDR_EXPR: 1561 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 1562 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST 1563 /* An ADDR_EXPR can have reference type. In that case, we 1564 shouldn't print the `&' doing so indicates to the user 1565 that the expression has pointer type. */ 1566 || (TREE_TYPE (t) 1567 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)) 1568 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1569 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL) 1570 dump_unary_op ("&&", t, flags); 1571 else 1572 dump_unary_op ("&", t, flags); 1573 break; 1574 1575 case INDIRECT_REF: 1576 if (TREE_HAS_CONSTRUCTOR (t)) 1577 { 1578 t = TREE_OPERAND (t, 0); 1579 gcc_assert (TREE_CODE (t) == CALL_EXPR); 1580 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1581 pp_cxx_left_paren (cxx_pp); 1582 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1583 pp_cxx_right_paren (cxx_pp); 1584 } 1585 else 1586 { 1587 if (TREE_OPERAND (t,0) != NULL_TREE 1588 && TREE_TYPE (TREE_OPERAND (t, 0)) 1589 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 1590 dump_expr (TREE_OPERAND (t, 0), flags); 1591 else 1592 dump_unary_op ("*", t, flags); 1593 } 1594 break; 1595 1596 case NEGATE_EXPR: 1597 case BIT_NOT_EXPR: 1598 case TRUTH_NOT_EXPR: 1599 case PREDECREMENT_EXPR: 1600 case PREINCREMENT_EXPR: 1601 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags); 1602 break; 1603 1604 case POSTDECREMENT_EXPR: 1605 case POSTINCREMENT_EXPR: 1606 pp_cxx_left_paren (cxx_pp); 1607 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1608 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); 1609 pp_cxx_right_paren (cxx_pp); 1610 break; 1611 1612 case NON_LVALUE_EXPR: 1613 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 1614 should be another level of INDIRECT_REF so that I don't have to do 1615 this. */ 1616 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 1617 { 1618 tree next = TREE_TYPE (TREE_TYPE (t)); 1619 1620 while (TREE_CODE (next) == POINTER_TYPE) 1621 next = TREE_TYPE (next); 1622 1623 if (TREE_CODE (next) == FUNCTION_TYPE) 1624 { 1625 if (flags & TFF_EXPR_IN_PARENS) 1626 pp_cxx_left_paren (cxx_pp); 1627 pp_cxx_star (cxx_pp); 1628 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1629 if (flags & TFF_EXPR_IN_PARENS) 1630 pp_cxx_right_paren (cxx_pp); 1631 break; 1632 } 1633 /* Else fall through. */ 1634 } 1635 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1636 break; 1637 1638 case NOP_EXPR: 1639 case CONVERT_EXPR: 1640 { 1641 tree op = TREE_OPERAND (t, 0); 1642 1643 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))) 1644 { 1645 /* It is a cast, but we cannot tell whether it is a 1646 reinterpret or static cast. Use the C style notation. */ 1647 if (flags & TFF_EXPR_IN_PARENS) 1648 pp_cxx_left_paren (cxx_pp); 1649 pp_cxx_left_paren (cxx_pp); 1650 dump_type (TREE_TYPE (t), flags); 1651 pp_cxx_right_paren (cxx_pp); 1652 dump_expr (op, flags | TFF_EXPR_IN_PARENS); 1653 if (flags & TFF_EXPR_IN_PARENS) 1654 pp_cxx_right_paren (cxx_pp); 1655 } 1656 else 1657 dump_expr (op, flags); 1658 break; 1659 } 1660 1661 case CONSTRUCTOR: 1662 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 1663 { 1664 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier); 1665 1666 if (integer_zerop (idx)) 1667 { 1668 /* A NULL pointer-to-member constant. */ 1669 pp_cxx_left_paren (cxx_pp); 1670 pp_cxx_left_paren (cxx_pp); 1671 dump_type (TREE_TYPE (t), flags); 1672 pp_cxx_right_paren (cxx_pp); 1673 pp_character (cxx_pp, '0'); 1674 pp_cxx_right_paren (cxx_pp); 1675 break; 1676 } 1677 else if (host_integerp (idx, 0)) 1678 { 1679 tree virtuals; 1680 unsigned HOST_WIDE_INT n; 1681 1682 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 1683 t = TYPE_METHOD_BASETYPE (t); 1684 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 1685 1686 n = tree_low_cst (idx, 0); 1687 1688 /* Map vtable index back one, to allow for the null pointer to 1689 member. */ 1690 --n; 1691 1692 while (n > 0 && virtuals) 1693 { 1694 --n; 1695 virtuals = TREE_CHAIN (virtuals); 1696 } 1697 if (virtuals) 1698 { 1699 dump_expr (BV_FN (virtuals), 1700 flags | TFF_EXPR_IN_PARENS); 1701 break; 1702 } 1703 } 1704 } 1705 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t)) 1706 { 1707 dump_type (TREE_TYPE (t), 0); 1708 pp_cxx_left_paren (cxx_pp); 1709 pp_cxx_right_paren (cxx_pp); 1710 } 1711 else 1712 { 1713 pp_cxx_left_brace (cxx_pp); 1714 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags); 1715 pp_cxx_right_brace (cxx_pp); 1716 } 1717 1718 break; 1719 1720 case OFFSET_REF: 1721 { 1722 tree ob = TREE_OPERAND (t, 0); 1723 if (is_dummy_object (ob)) 1724 { 1725 t = TREE_OPERAND (t, 1); 1726 if (TREE_CODE (t) == FUNCTION_DECL) 1727 /* A::f */ 1728 dump_expr (t, flags | TFF_EXPR_IN_PARENS); 1729 else if (BASELINK_P (t)) 1730 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 1731 flags | TFF_EXPR_IN_PARENS); 1732 else 1733 dump_decl (t, flags); 1734 } 1735 else 1736 { 1737 if (TREE_CODE (ob) == INDIRECT_REF) 1738 { 1739 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1740 pp_cxx_arrow (cxx_pp); 1741 pp_cxx_star (cxx_pp); 1742 } 1743 else 1744 { 1745 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1746 pp_cxx_dot (cxx_pp); 1747 pp_cxx_star (cxx_pp); 1748 } 1749 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1750 } 1751 break; 1752 } 1753 1754 case TEMPLATE_PARM_INDEX: 1755 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS); 1756 break; 1757 1758 case SCOPE_REF: 1759 pp_expression (cxx_pp, t); 1760 break; 1761 1762 case CAST_EXPR: 1763 if (TREE_OPERAND (t, 0) == NULL_TREE 1764 || TREE_CHAIN (TREE_OPERAND (t, 0))) 1765 { 1766 dump_type (TREE_TYPE (t), flags); 1767 pp_cxx_left_paren (cxx_pp); 1768 dump_expr_list (TREE_OPERAND (t, 0), flags); 1769 pp_cxx_right_paren (cxx_pp); 1770 } 1771 else 1772 { 1773 pp_cxx_left_paren (cxx_pp); 1774 dump_type (TREE_TYPE (t), flags); 1775 pp_cxx_right_paren (cxx_pp); 1776 pp_cxx_left_paren (cxx_pp); 1777 dump_expr_list (TREE_OPERAND (t, 0), flags); 1778 pp_cxx_right_paren (cxx_pp); 1779 } 1780 break; 1781 1782 case STATIC_CAST_EXPR: 1783 pp_cxx_identifier (cxx_pp, "static_cast"); 1784 goto cast; 1785 case REINTERPRET_CAST_EXPR: 1786 pp_cxx_identifier (cxx_pp, "reinterpret_cast"); 1787 goto cast; 1788 case CONST_CAST_EXPR: 1789 pp_cxx_identifier (cxx_pp, "const_cast"); 1790 goto cast; 1791 case DYNAMIC_CAST_EXPR: 1792 pp_cxx_identifier (cxx_pp, "dynamic_cast"); 1793 cast: 1794 pp_cxx_begin_template_argument_list (cxx_pp); 1795 dump_type (TREE_TYPE (t), flags); 1796 pp_cxx_end_template_argument_list (cxx_pp); 1797 pp_cxx_left_paren (cxx_pp); 1798 dump_expr (TREE_OPERAND (t, 0), flags); 1799 pp_cxx_right_paren (cxx_pp); 1800 break; 1801 1802 case ARROW_EXPR: 1803 dump_expr (TREE_OPERAND (t, 0), flags); 1804 pp_cxx_arrow (cxx_pp); 1805 break; 1806 1807 case SIZEOF_EXPR: 1808 case ALIGNOF_EXPR: 1809 if (TREE_CODE (t) == SIZEOF_EXPR) 1810 pp_cxx_identifier (cxx_pp, "sizeof"); 1811 else 1812 { 1813 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); 1814 pp_cxx_identifier (cxx_pp, "__alignof__"); 1815 } 1816 pp_cxx_whitespace (cxx_pp); 1817 pp_cxx_left_paren (cxx_pp); 1818 if (TYPE_P (TREE_OPERAND (t, 0))) 1819 dump_type (TREE_OPERAND (t, 0), flags); 1820 else 1821 dump_expr (TREE_OPERAND (t, 0), flags); 1822 pp_cxx_right_paren (cxx_pp); 1823 break; 1824 1825 case REALPART_EXPR: 1826 case IMAGPART_EXPR: 1827 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name); 1828 pp_cxx_whitespace (cxx_pp); 1829 dump_expr (TREE_OPERAND (t, 0), flags); 1830 break; 1831 1832 case DEFAULT_ARG: 1833 pp_identifier (cxx_pp, "<unparsed>"); 1834 break; 1835 1836 case TRY_CATCH_EXPR: 1837 case WITH_CLEANUP_EXPR: 1838 case CLEANUP_POINT_EXPR: 1839 dump_expr (TREE_OPERAND (t, 0), flags); 1840 break; 1841 1842 case PSEUDO_DTOR_EXPR: 1843 dump_expr (TREE_OPERAND (t, 2), flags); 1844 pp_cxx_dot (cxx_pp); 1845 dump_type (TREE_OPERAND (t, 0), flags); 1846 pp_cxx_colon_colon (cxx_pp); 1847 pp_cxx_complement (cxx_pp); 1848 dump_type (TREE_OPERAND (t, 1), flags); 1849 break; 1850 1851 case TEMPLATE_ID_EXPR: 1852 dump_decl (t, flags); 1853 break; 1854 1855 case BIND_EXPR: 1856 case STMT_EXPR: 1857 case STATEMENT_LIST: 1858 /* We don't yet have a way of dumping statements in a 1859 human-readable format. */ 1860 pp_string (cxx_pp, "({...})"); 1861 break; 1862 1863 case LOOP_EXPR: 1864 pp_string (cxx_pp, "while (1) { "); 1865 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1866 pp_cxx_right_brace (cxx_pp); 1867 break; 1868 1869 case EXIT_EXPR: 1870 pp_string (cxx_pp, "if ("); 1871 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1872 pp_string (cxx_pp, ") break; "); 1873 break; 1874 1875 case BASELINK: 1876 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS); 1877 break; 1878 1879 case EMPTY_CLASS_EXPR: 1880 dump_type (TREE_TYPE (t), flags); 1881 pp_cxx_left_paren (cxx_pp); 1882 pp_cxx_right_paren (cxx_pp); 1883 break; 1884 1885 case NON_DEPENDENT_EXPR: 1886 dump_expr (TREE_OPERAND (t, 0), flags); 1887 break; 1888 1889 /* This list is incomplete, but should suffice for now. 1890 It is very important that `sorry' does not call 1891 `report_error_function'. That could cause an infinite loop. */ 1892 default: 1893 pp_unsupported_tree (cxx_pp, t); 1894 /* fall through to ERROR_MARK... */ 1895 case ERROR_MARK: 1896 pp_identifier (cxx_pp, "<expression error>"); 1897 break; 1898 } 1899} 1900 1901static void 1902dump_binary_op (const char *opstring, tree t, int flags) 1903{ 1904 pp_cxx_left_paren (cxx_pp); 1905 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1906 pp_cxx_whitespace (cxx_pp); 1907 if (opstring) 1908 pp_cxx_identifier (cxx_pp, opstring); 1909 else 1910 pp_identifier (cxx_pp, "<unknown operator>"); 1911 pp_cxx_whitespace (cxx_pp); 1912 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1913 pp_cxx_right_paren (cxx_pp); 1914} 1915 1916static void 1917dump_unary_op (const char *opstring, tree t, int flags) 1918{ 1919 if (flags & TFF_EXPR_IN_PARENS) 1920 pp_cxx_left_paren (cxx_pp); 1921 pp_cxx_identifier (cxx_pp, opstring); 1922 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1923 if (flags & TFF_EXPR_IN_PARENS) 1924 pp_cxx_right_paren (cxx_pp); 1925} 1926 1927static void 1928reinit_cxx_pp (void) 1929{ 1930 pp_clear_output_area (cxx_pp); 1931 pp_base (cxx_pp)->padding = pp_none; 1932 pp_indentation (cxx_pp) = 0; 1933 pp_needs_newline (cxx_pp) = false; 1934 cxx_pp->enclosing_scope = 0; 1935} 1936 1937 1938/* Exported interface to stringifying types, exprs and decls under TFF_* 1939 control. */ 1940 1941const char * 1942type_as_string (tree typ, int flags) 1943{ 1944 reinit_cxx_pp (); 1945 dump_type (typ, flags); 1946 return pp_formatted_text (cxx_pp); 1947} 1948 1949const char * 1950expr_as_string (tree decl, int flags) 1951{ 1952 reinit_cxx_pp (); 1953 dump_expr (decl, flags); 1954 return pp_formatted_text (cxx_pp); 1955} 1956 1957const char * 1958decl_as_string (tree decl, int flags) 1959{ 1960 reinit_cxx_pp (); 1961 dump_decl (decl, flags); 1962 return pp_formatted_text (cxx_pp); 1963} 1964 1965/* Generate the three forms of printable names for cxx_printable_name. */ 1966 1967const char * 1968lang_decl_name (tree decl, int v) 1969{ 1970 if (v >= 2) 1971 return decl_as_string (decl, TFF_DECL_SPECIFIERS); 1972 1973 reinit_cxx_pp (); 1974 if (v == 1 && DECL_CLASS_SCOPE_P (decl)) 1975 { 1976 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); 1977 pp_cxx_colon_colon (cxx_pp); 1978 } 1979 1980 if (TREE_CODE (decl) == FUNCTION_DECL) 1981 dump_function_name (decl, TFF_PLAIN_IDENTIFIER); 1982 else 1983 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER); 1984 1985 return pp_formatted_text (cxx_pp); 1986} 1987 1988/* Return the location of a tree passed to %+ formats. */ 1989 1990static location_t 1991location_of (tree t) 1992{ 1993 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 1994 t = DECL_CONTEXT (t); 1995 else if (TYPE_P (t)) 1996 t = TYPE_MAIN_DECL (t); 1997 else if (TREE_CODE (t) == OVERLOAD) 1998 t = OVL_FUNCTION (t); 1999 2000 return DECL_SOURCE_LOCATION (t); 2001} 2002 2003/* Now the interfaces from error et al to dump_type et al. Each takes an 2004 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_ 2005 function. */ 2006 2007static const char * 2008decl_to_string (tree decl, int verbose) 2009{ 2010 int flags = 0; 2011 2012 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE 2013 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE) 2014 flags = TFF_CLASS_KEY_OR_ENUM; 2015 if (verbose) 2016 flags |= TFF_DECL_SPECIFIERS; 2017 else if (TREE_CODE (decl) == FUNCTION_DECL) 2018 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; 2019 flags |= TFF_TEMPLATE_HEADER; 2020 2021 reinit_cxx_pp (); 2022 dump_decl (decl, flags); 2023 return pp_formatted_text (cxx_pp); 2024} 2025 2026static const char * 2027expr_to_string (tree decl) 2028{ 2029 reinit_cxx_pp (); 2030 dump_expr (decl, 0); 2031 return pp_formatted_text (cxx_pp); 2032} 2033 2034static const char * 2035fndecl_to_string (tree fndecl, int verbose) 2036{ 2037 int flags; 2038 2039 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS 2040 | TFF_TEMPLATE_HEADER; 2041 if (verbose) 2042 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; 2043 reinit_cxx_pp (); 2044 dump_decl (fndecl, flags); 2045 return pp_formatted_text (cxx_pp); 2046} 2047 2048 2049static const char * 2050code_to_string (enum tree_code c) 2051{ 2052 return tree_code_name [c]; 2053} 2054 2055const char * 2056language_to_string (enum languages c) 2057{ 2058 switch (c) 2059 { 2060 case lang_c: 2061 return "C"; 2062 2063 case lang_cplusplus: 2064 return "C++"; 2065 2066 case lang_java: 2067 return "Java"; 2068 2069 default: 2070 gcc_unreachable (); 2071 } 2072 return NULL; 2073} 2074 2075/* Return the proper printed version of a parameter to a C++ function. */ 2076 2077static const char * 2078parm_to_string (int p) 2079{ 2080 reinit_cxx_pp (); 2081 if (p < 0) 2082 pp_string (cxx_pp, "'this'"); 2083 else 2084 pp_decimal_int (cxx_pp, p + 1); 2085 return pp_formatted_text (cxx_pp); 2086} 2087 2088static const char * 2089op_to_string (enum tree_code p) 2090{ 2091 tree id = operator_name_info[(int) p].identifier; 2092 return id ? IDENTIFIER_POINTER (id) : "<unknown>"; 2093} 2094 2095static const char * 2096type_to_string (tree typ, int verbose) 2097{ 2098 int flags = 0; 2099 if (verbose) 2100 flags |= TFF_CLASS_KEY_OR_ENUM; 2101 flags |= TFF_TEMPLATE_HEADER; 2102 2103 reinit_cxx_pp (); 2104 dump_type (typ, flags); 2105 return pp_formatted_text (cxx_pp); 2106} 2107 2108static const char * 2109assop_to_string (enum tree_code p) 2110{ 2111 tree id = assignment_operator_name_info[(int) p].identifier; 2112 return id ? IDENTIFIER_POINTER (id) : "{unknown}"; 2113} 2114 2115static const char * 2116args_to_string (tree p, int verbose) 2117{ 2118 int flags = 0; 2119 if (verbose) 2120 flags |= TFF_CLASS_KEY_OR_ENUM; 2121 2122 if (p == NULL_TREE) 2123 return ""; 2124 2125 if (TYPE_P (TREE_VALUE (p))) 2126 return type_as_string (p, flags); 2127 2128 reinit_cxx_pp (); 2129 for (; p; p = TREE_CHAIN (p)) 2130 { 2131 if (TREE_VALUE (p) == null_node) 2132 pp_cxx_identifier (cxx_pp, "NULL"); 2133 else 2134 dump_type (error_type (TREE_VALUE (p)), flags); 2135 if (TREE_CHAIN (p)) 2136 pp_separate_with_comma (cxx_pp); 2137 } 2138 return pp_formatted_text (cxx_pp); 2139} 2140 2141static const char * 2142cv_to_string (tree p, int v) 2143{ 2144 reinit_cxx_pp (); 2145 pp_base (cxx_pp)->padding = v ? pp_before : pp_none; 2146 pp_cxx_cv_qualifier_seq (cxx_pp, p); 2147 return pp_formatted_text (cxx_pp); 2148} 2149 2150/* Langhook for print_error_function. */ 2151void 2152cxx_print_error_function (diagnostic_context *context, const char *file) 2153{ 2154 lhd_print_error_function (context, file); 2155 pp_base_set_prefix (context->printer, file); 2156 maybe_print_instantiation_context (context); 2157} 2158 2159static void 2160cp_diagnostic_starter (diagnostic_context *context, 2161 diagnostic_info *diagnostic) 2162{ 2163 diagnostic_report_current_module (context); 2164 cp_print_error_function (context, diagnostic); 2165 maybe_print_instantiation_context (context); 2166 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic)); 2167} 2168 2169static void 2170cp_diagnostic_finalizer (diagnostic_context *context, 2171 diagnostic_info *diagnostic ATTRIBUTE_UNUSED) 2172{ 2173 pp_base_destroy_prefix (context->printer); 2174} 2175 2176/* Print current function onto BUFFER, in the process of reporting 2177 a diagnostic message. Called from cp_diagnostic_starter. */ 2178static void 2179cp_print_error_function (diagnostic_context *context, 2180 diagnostic_info *diagnostic) 2181{ 2182 if (diagnostic_last_function_changed (context)) 2183 { 2184 const char *old_prefix = context->printer->prefix; 2185 const char *file = LOCATION_FILE (diagnostic->location); 2186 char *new_prefix = file ? file_name_as_prefix (file) : NULL; 2187 2188 pp_base_set_prefix (context->printer, new_prefix); 2189 2190 if (current_function_decl == NULL) 2191 pp_base_string (context->printer, "At global scope:"); 2192 else 2193 pp_printf (context->printer, "In %s %qs:", 2194 function_category (current_function_decl), 2195 cxx_printable_name (current_function_decl, 2)); 2196 pp_base_newline (context->printer); 2197 2198 diagnostic_set_last_function (context); 2199 pp_base_destroy_prefix (context->printer); 2200 context->printer->prefix = old_prefix; 2201 } 2202} 2203 2204/* Returns a description of FUNCTION using standard terminology. */ 2205static const char * 2206function_category (tree fn) 2207{ 2208 if (DECL_FUNCTION_MEMBER_P (fn)) 2209 { 2210 if (DECL_STATIC_FUNCTION_P (fn)) 2211 return "static member function"; 2212 else if (DECL_COPY_CONSTRUCTOR_P (fn)) 2213 return "copy constructor"; 2214 else if (DECL_CONSTRUCTOR_P (fn)) 2215 return "constructor"; 2216 else if (DECL_DESTRUCTOR_P (fn)) 2217 return "destructor"; 2218 else 2219 return "member function"; 2220 } 2221 else 2222 return "function"; 2223} 2224 2225/* Report the full context of a current template instantiation, 2226 onto BUFFER. */ 2227static void 2228print_instantiation_full_context (diagnostic_context *context) 2229{ 2230 tree p = current_instantiation (); 2231 location_t location = input_location; 2232 2233 if (p) 2234 { 2235 if (current_function_decl != TINST_DECL (p) 2236 && current_function_decl != NULL_TREE) 2237 /* We can get here during the processing of some synthesized 2238 method. Then, TINST_DECL (p) will be the function that's causing 2239 the synthesis. */ 2240 ; 2241 else 2242 { 2243 if (current_function_decl == TINST_DECL (p)) 2244 /* Avoid redundancy with the "In function" line. */; 2245 else 2246 pp_verbatim (context->printer, 2247 "%s: In instantiation of %qs:\n", 2248 LOCATION_FILE (location), 2249 decl_as_string (TINST_DECL (p), 2250 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2251 2252 location = TINST_LOCATION (p); 2253 p = TREE_CHAIN (p); 2254 } 2255 } 2256 2257 print_instantiation_partial_context (context, p, location); 2258} 2259 2260/* Same as above but less verbose. */ 2261static void 2262print_instantiation_partial_context (diagnostic_context *context, 2263 tree t, location_t loc) 2264{ 2265 expanded_location xloc; 2266 for (; ; t = TREE_CHAIN (t)) 2267 { 2268 xloc = expand_location (loc); 2269 if (t == NULL_TREE) 2270 break; 2271 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n", 2272 xloc.file, xloc.line, 2273 decl_as_string (TINST_DECL (t), 2274 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2275 loc = TINST_LOCATION (t); 2276 } 2277 pp_verbatim (context->printer, "%s:%d: instantiated from here", 2278 xloc.file, xloc.line); 2279 pp_base_newline (context->printer); 2280} 2281 2282/* Called from cp_thing to print the template context for an error. */ 2283static void 2284maybe_print_instantiation_context (diagnostic_context *context) 2285{ 2286 if (!problematic_instantiation_changed () || current_instantiation () == 0) 2287 return; 2288 2289 record_last_problematic_instantiation (); 2290 print_instantiation_full_context (context); 2291} 2292 2293/* Report the bare minimum context of a template instantiation. */ 2294void 2295print_instantiation_context (void) 2296{ 2297 print_instantiation_partial_context 2298 (global_dc, current_instantiation (), input_location); 2299 diagnostic_flush_buffer (global_dc); 2300} 2301 2302/* Called from output_format -- during diagnostic message processing -- 2303 to handle C++ specific format specifier with the following meanings: 2304 %A function argument-list. 2305 %C tree code. 2306 %D declaration. 2307 %E expression. 2308 %F function declaration. 2309 %L language as used in extern "lang". 2310 %O binary operator. 2311 %P function parameter whose position is indicated by an integer. 2312 %Q assignment operator. 2313 %T type. 2314 %V cv-qualifier. */ 2315static bool 2316cp_printer (pretty_printer *pp, text_info *text, const char *spec, 2317 int precision, bool wide, bool set_locus, bool verbose) 2318{ 2319 const char *result; 2320 tree t = NULL; 2321#define next_tree (t = va_arg (*text->args_ptr, tree)) 2322#define next_tcode va_arg (*text->args_ptr, enum tree_code) 2323#define next_lang va_arg (*text->args_ptr, enum languages) 2324#define next_int va_arg (*text->args_ptr, int) 2325 2326 if (precision != 0 || wide) 2327 return false; 2328 2329 if (text->locus == NULL) 2330 set_locus = false; 2331 2332 switch (*spec) 2333 { 2334 case 'A': result = args_to_string (next_tree, verbose); break; 2335 case 'C': result = code_to_string (next_tcode); break; 2336 case 'D': 2337 { 2338 tree temp = next_tree; 2339 if (DECL_P (temp) 2340 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp)) 2341 { 2342 temp = DECL_DEBUG_EXPR (temp); 2343 if (!DECL_P (temp)) 2344 { 2345 result = expr_to_string (temp); 2346 break; 2347 } 2348 } 2349 result = decl_to_string (temp, verbose); 2350 } 2351 break; 2352 case 'E': result = expr_to_string (next_tree); break; 2353 case 'F': result = fndecl_to_string (next_tree, verbose); break; 2354 case 'L': result = language_to_string (next_lang); break; 2355 case 'O': result = op_to_string (next_tcode); break; 2356 case 'P': result = parm_to_string (next_int); break; 2357 case 'Q': result = assop_to_string (next_tcode); break; 2358 case 'T': result = type_to_string (next_tree, verbose); break; 2359 case 'V': result = cv_to_string (next_tree, verbose); break; 2360 2361 default: 2362 return false; 2363 } 2364 2365 pp_base_string (pp, result); 2366 if (set_locus && t != NULL) 2367 *text->locus = location_of (t); 2368 return true; 2369#undef next_tree 2370#undef next_tcode 2371#undef next_lang 2372#undef next_int 2373} 2374 2375/* Callback from cpp_error for PFILE to print diagnostics arising from 2376 interpreting strings. The diagnostic is of type LEVEL; MSG is the 2377 translated message and AP the arguments. */ 2378 2379void 2380cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, 2381 const char *msg, va_list *ap) 2382{ 2383 diagnostic_info diagnostic; 2384 diagnostic_t dlevel; 2385 switch (level) 2386 { 2387 case CPP_DL_WARNING: 2388 case CPP_DL_WARNING_SYSHDR: 2389 dlevel = DK_WARNING; 2390 break; 2391 case CPP_DL_PEDWARN: 2392 dlevel = pedantic_error_kind (); 2393 break; 2394 case CPP_DL_ERROR: 2395 dlevel = DK_ERROR; 2396 break; 2397 case CPP_DL_ICE: 2398 dlevel = DK_ICE; 2399 break; 2400 default: 2401 gcc_unreachable (); 2402 } 2403 diagnostic_set_info_translated (&diagnostic, msg, ap, 2404 input_location, dlevel); 2405 report_diagnostic (&diagnostic); 2406} 2407