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 case UNBOUND_CLASS_TEMPLATE: 905 dump_type (t, flags); 906 break; 907 908 default: 909 pp_unsupported_tree (cxx_pp, t); 910 /* Fall through to error. */ 911 912 case ERROR_MARK: 913 pp_identifier (cxx_pp, "<declaration error>"); 914 break; 915 } 916} 917 918/* Dump a template declaration T under control of FLAGS. This means the 919 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ 920 921static void 922dump_template_decl (tree t, int flags) 923{ 924 tree orig_parms = DECL_TEMPLATE_PARMS (t); 925 tree parms; 926 int i; 927 928 if (flags & TFF_TEMPLATE_HEADER) 929 { 930 for (parms = orig_parms = nreverse (orig_parms); 931 parms; 932 parms = TREE_CHAIN (parms)) 933 { 934 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); 935 int len = TREE_VEC_LENGTH (inner_parms); 936 937 pp_cxx_identifier (cxx_pp, "template"); 938 pp_cxx_begin_template_argument_list (cxx_pp); 939 940 /* If we've shown the template prefix, we'd better show the 941 parameters' and decl's type too. */ 942 flags |= TFF_DECL_SPECIFIERS; 943 944 for (i = 0; i < len; i++) 945 { 946 if (i) 947 pp_separate_with_comma (cxx_pp); 948 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); 949 } 950 pp_cxx_end_template_argument_list (cxx_pp); 951 pp_cxx_whitespace (cxx_pp); 952 } 953 nreverse(orig_parms); 954 955 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 956 /* Say `template<arg> class TT' not just `template<arg> TT'. */ 957 pp_cxx_identifier (cxx_pp, "class"); 958 } 959 960 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) 961 dump_type (TREE_TYPE (t), 962 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 963 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); 964 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) 965 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); 966 else 967 { 968 gcc_assert (TREE_TYPE (t)); 969 switch (NEXT_CODE (t)) 970 { 971 case METHOD_TYPE: 972 case FUNCTION_TYPE: 973 dump_function_decl (t, flags | TFF_TEMPLATE_NAME); 974 break; 975 default: 976 /* This case can occur with some invalid code. */ 977 dump_type (TREE_TYPE (t), 978 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 979 | (flags & TFF_DECL_SPECIFIERS 980 ? TFF_CLASS_KEY_OR_ENUM : 0)); 981 } 982 } 983} 984 985/* Pretty print a function decl. There are several ways we want to print a 986 function declaration. The TFF_ bits in FLAGS tells us how to behave. 987 As error can only apply the '#' flag once to give 0 and 1 for V, there 988 is %D which doesn't print the throw specs, and %F which does. */ 989 990static void 991dump_function_decl (tree t, int flags) 992{ 993 tree fntype; 994 tree parmtypes; 995 tree cname = NULL_TREE; 996 tree template_args = NULL_TREE; 997 tree template_parms = NULL_TREE; 998 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; 999 1000 if (TREE_CODE (t) == TEMPLATE_DECL) 1001 t = DECL_TEMPLATE_RESULT (t); 1002 1003 /* Pretty print template instantiations only. */ 1004 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)) 1005 { 1006 tree tmpl; 1007 1008 template_args = DECL_TI_ARGS (t); 1009 tmpl = most_general_template (t); 1010 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) 1011 { 1012 template_parms = DECL_TEMPLATE_PARMS (tmpl); 1013 t = tmpl; 1014 } 1015 } 1016 1017 fntype = TREE_TYPE (t); 1018 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); 1019 1020 if (DECL_CLASS_SCOPE_P (t)) 1021 cname = DECL_CONTEXT (t); 1022 /* This is for partially instantiated template methods. */ 1023 else if (TREE_CODE (fntype) == METHOD_TYPE) 1024 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 1025 1026 if (!(flags & TFF_DECL_SPECIFIERS)) 1027 /* OK */; 1028 else if (DECL_STATIC_FUNCTION_P (t)) 1029 pp_cxx_identifier (cxx_pp, "static"); 1030 else if (DECL_VIRTUAL_P (t)) 1031 pp_cxx_identifier (cxx_pp, "virtual"); 1032 1033 /* Print the return type? */ 1034 if (show_return) 1035 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) 1036 && !DECL_DESTRUCTOR_P (t); 1037 if (show_return) 1038 dump_type_prefix (TREE_TYPE (fntype), flags); 1039 1040 /* Print the function name. */ 1041 if (cname) 1042 { 1043 dump_type (cname, flags); 1044 pp_cxx_colon_colon (cxx_pp); 1045 } 1046 else 1047 dump_scope (CP_DECL_CONTEXT (t), flags); 1048 1049 dump_function_name (t, flags); 1050 1051 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) 1052 { 1053 dump_parameters (parmtypes, flags); 1054 1055 if (TREE_CODE (fntype) == METHOD_TYPE) 1056 { 1057 pp_base (cxx_pp)->padding = pp_before; 1058 pp_cxx_cv_qualifier_seq 1059 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); 1060 } 1061 1062 if (flags & TFF_EXCEPTION_SPECIFICATION) 1063 { 1064 pp_base (cxx_pp)->padding = pp_before; 1065 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); 1066 } 1067 1068 if (show_return) 1069 dump_type_suffix (TREE_TYPE (fntype), flags); 1070 } 1071 1072 /* If T is a template instantiation, dump the parameter binding. */ 1073 if (template_parms != NULL_TREE && template_args != NULL_TREE) 1074 { 1075 pp_cxx_whitespace (cxx_pp); 1076 pp_cxx_left_bracket (cxx_pp); 1077 pp_cxx_identifier (cxx_pp, "with"); 1078 pp_cxx_whitespace (cxx_pp); 1079 dump_template_bindings (template_parms, template_args); 1080 pp_cxx_right_bracket (cxx_pp); 1081 } 1082} 1083 1084/* Print a parameter list. If this is for a member function, the 1085 member object ptr (and any other hidden args) should have 1086 already been removed. */ 1087 1088static void 1089dump_parameters (tree parmtypes, int flags) 1090{ 1091 int first; 1092 1093 pp_cxx_left_paren (cxx_pp); 1094 1095 for (first = 1; parmtypes != void_list_node; 1096 parmtypes = TREE_CHAIN (parmtypes)) 1097 { 1098 if (!first) 1099 pp_separate_with_comma (cxx_pp); 1100 first = 0; 1101 if (!parmtypes) 1102 { 1103 pp_cxx_identifier (cxx_pp, "..."); 1104 break; 1105 } 1106 dump_type (TREE_VALUE (parmtypes), flags); 1107 1108 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) 1109 { 1110 pp_cxx_whitespace (cxx_pp); 1111 pp_equal (cxx_pp); 1112 pp_cxx_whitespace (cxx_pp); 1113 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); 1114 } 1115 } 1116 1117 pp_cxx_right_paren (cxx_pp); 1118} 1119 1120/* Print an exception specification. T is the exception specification. */ 1121 1122static void 1123dump_exception_spec (tree t, int flags) 1124{ 1125 if (t) 1126 { 1127 pp_cxx_identifier (cxx_pp, "throw"); 1128 pp_cxx_whitespace (cxx_pp); 1129 pp_cxx_left_paren (cxx_pp); 1130 if (TREE_VALUE (t) != NULL_TREE) 1131 while (1) 1132 { 1133 dump_type (TREE_VALUE (t), flags); 1134 t = TREE_CHAIN (t); 1135 if (!t) 1136 break; 1137 pp_separate_with_comma (cxx_pp); 1138 } 1139 pp_cxx_right_paren (cxx_pp); 1140 } 1141} 1142 1143/* Handle the function name for a FUNCTION_DECL node, grokking operators 1144 and destructors properly. */ 1145 1146static void 1147dump_function_name (tree t, int flags) 1148{ 1149 tree name = DECL_NAME (t); 1150 1151 /* We can get here with a decl that was synthesized by language- 1152 independent machinery (e.g. coverage.c) in which case it won't 1153 have a lang_specific structure attached and DECL_CONSTRUCTOR_P 1154 will crash. In this case it is safe just to print out the 1155 literal name. */ 1156 if (!DECL_LANG_SPECIFIC (t)) 1157 { 1158 pp_cxx_tree_identifier (cxx_pp, name); 1159 return; 1160 } 1161 1162 if (TREE_CODE (t) == TEMPLATE_DECL) 1163 t = DECL_TEMPLATE_RESULT (t); 1164 1165 /* Don't let the user see __comp_ctor et al. */ 1166 if (DECL_CONSTRUCTOR_P (t) 1167 || DECL_DESTRUCTOR_P (t)) 1168 name = constructor_name (DECL_CONTEXT (t)); 1169 1170 if (DECL_DESTRUCTOR_P (t)) 1171 { 1172 pp_cxx_complement (cxx_pp); 1173 dump_decl (name, TFF_PLAIN_IDENTIFIER); 1174 } 1175 else if (DECL_CONV_FN_P (t)) 1176 { 1177 /* This cannot use the hack that the operator's return 1178 type is stashed off of its name because it may be 1179 used for error reporting. In the case of conflicting 1180 declarations, both will have the same name, yet 1181 the types will be different, hence the TREE_TYPE field 1182 of the first name will be clobbered by the second. */ 1183 pp_cxx_identifier (cxx_pp, "operator"); 1184 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1185 } 1186 else if (IDENTIFIER_OPNAME_P (name)) 1187 pp_cxx_tree_identifier (cxx_pp, name); 1188 else 1189 dump_decl (name, flags); 1190 1191 if (DECL_TEMPLATE_INFO (t) 1192 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) 1193 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1194 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1195 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags); 1196} 1197 1198/* Dump the template parameters from the template info INFO under control of 1199 FLAGS. PRIMARY indicates whether this is a primary template decl, or 1200 specialization (partial or complete). For partial specializations we show 1201 the specialized parameter values. For a primary template we show no 1202 decoration. */ 1203 1204static void 1205dump_template_parms (tree info, int primary, int flags) 1206{ 1207 tree args = info ? TI_ARGS (info) : NULL_TREE; 1208 1209 if (primary && flags & TFF_TEMPLATE_NAME) 1210 return; 1211 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); 1212 pp_cxx_begin_template_argument_list (cxx_pp); 1213 1214 /* Be careful only to print things when we have them, so as not 1215 to crash producing error messages. */ 1216 if (args && !primary) 1217 { 1218 int len, ix; 1219 1220 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) 1221 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); 1222 1223 len = TREE_VEC_LENGTH (args); 1224 1225 for (ix = 0; ix != len; ix++) 1226 { 1227 tree arg = TREE_VEC_ELT (args, ix); 1228 1229 if (ix) 1230 pp_separate_with_comma (cxx_pp); 1231 1232 if (!arg) 1233 pp_identifier (cxx_pp, "<template parameter error>"); 1234 else 1235 dump_template_argument (arg, flags); 1236 } 1237 } 1238 else if (primary) 1239 { 1240 tree tpl = TI_TEMPLATE (info); 1241 tree parms = DECL_TEMPLATE_PARMS (tpl); 1242 int len, ix; 1243 1244 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE; 1245 len = parms ? TREE_VEC_LENGTH (parms) : 0; 1246 1247 for (ix = 0; ix != len; ix++) 1248 { 1249 tree parm; 1250 1251 if (TREE_VEC_ELT (parms, ix) == error_mark_node) 1252 { 1253 pp_identifier (cxx_pp, "<template parameter error>"); 1254 continue; 1255 } 1256 1257 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix)); 1258 1259 if (ix) 1260 pp_separate_with_comma (cxx_pp); 1261 1262 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS); 1263 } 1264 } 1265 pp_cxx_end_template_argument_list (cxx_pp); 1266} 1267 1268/* Print out a list of initializers (subr of dump_expr). */ 1269 1270static void 1271dump_expr_list (tree l, int flags) 1272{ 1273 while (l) 1274 { 1275 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS); 1276 l = TREE_CHAIN (l); 1277 if (l) 1278 pp_separate_with_comma (cxx_pp); 1279 } 1280} 1281 1282/* Print out a vector of initializers (subr of dump_expr). */ 1283 1284static void 1285dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags) 1286{ 1287 unsigned HOST_WIDE_INT idx; 1288 tree value; 1289 1290 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1291 { 1292 dump_expr (value, flags | TFF_EXPR_IN_PARENS); 1293 if (idx != VEC_length (constructor_elt, v) - 1) 1294 pp_separate_with_comma (cxx_pp); 1295 } 1296} 1297 1298 1299/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual 1300 function. Resolve it to a close relative -- in the sense of static 1301 type -- variant being overridden. That is close to what was written in 1302 the source code. Subroutine of dump_expr. */ 1303 1304static tree 1305resolve_virtual_fun_from_obj_type_ref (tree ref) 1306{ 1307 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref)); 1308 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1); 1309 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type))); 1310 while (index) 1311 { 1312 fun = TREE_CHAIN (fun); 1313 index -= (TARGET_VTABLE_USES_DESCRIPTORS 1314 ? TARGET_VTABLE_USES_DESCRIPTORS : 1); 1315 } 1316 1317 return BV_FN (fun); 1318} 1319 1320/* Print out an expression E under control of FLAGS. */ 1321 1322static void 1323dump_expr (tree t, int flags) 1324{ 1325 if (t == 0) 1326 return; 1327 1328 switch (TREE_CODE (t)) 1329 { 1330 case VAR_DECL: 1331 case PARM_DECL: 1332 case FIELD_DECL: 1333 case CONST_DECL: 1334 case FUNCTION_DECL: 1335 case TEMPLATE_DECL: 1336 case NAMESPACE_DECL: 1337 case LABEL_DECL: 1338 case OVERLOAD: 1339 case IDENTIFIER_NODE: 1340 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS); 1341 break; 1342 1343 case INTEGER_CST: 1344 case REAL_CST: 1345 case STRING_CST: 1346 pp_constant (cxx_pp, t); 1347 break; 1348 1349 case THROW_EXPR: 1350 pp_cxx_identifier (cxx_pp, "throw"); 1351 dump_expr (TREE_OPERAND (t, 0), flags); 1352 break; 1353 1354 case PTRMEM_CST: 1355 pp_ampersand (cxx_pp); 1356 dump_type (PTRMEM_CST_CLASS (t), flags); 1357 pp_cxx_colon_colon (cxx_pp); 1358 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); 1359 break; 1360 1361 case COMPOUND_EXPR: 1362 pp_cxx_left_paren (cxx_pp); 1363 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1364 pp_separate_with_comma (cxx_pp); 1365 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1366 pp_cxx_right_paren (cxx_pp); 1367 break; 1368 1369 case COND_EXPR: 1370 pp_cxx_left_paren (cxx_pp); 1371 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1372 pp_string (cxx_pp, " ? "); 1373 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1374 pp_string (cxx_pp, " : "); 1375 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); 1376 pp_cxx_right_paren (cxx_pp); 1377 break; 1378 1379 case SAVE_EXPR: 1380 if (TREE_HAS_CONSTRUCTOR (t)) 1381 { 1382 pp_cxx_identifier (cxx_pp, "new"); 1383 pp_cxx_whitespace (cxx_pp); 1384 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1385 } 1386 else 1387 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1388 break; 1389 1390 case AGGR_INIT_EXPR: 1391 { 1392 tree fn = NULL_TREE; 1393 1394 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR) 1395 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0); 1396 1397 if (fn && TREE_CODE (fn) == FUNCTION_DECL) 1398 { 1399 if (DECL_CONSTRUCTOR_P (fn)) 1400 dump_type (DECL_CONTEXT (fn), flags); 1401 else 1402 dump_decl (fn, 0); 1403 } 1404 else 1405 dump_expr (TREE_OPERAND (t, 0), 0); 1406 } 1407 pp_cxx_left_paren (cxx_pp); 1408 if (TREE_OPERAND (t, 1)) 1409 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1410 pp_cxx_right_paren (cxx_pp); 1411 break; 1412 1413 case CALL_EXPR: 1414 { 1415 tree fn = TREE_OPERAND (t, 0); 1416 tree args = TREE_OPERAND (t, 1); 1417 1418 if (TREE_CODE (fn) == ADDR_EXPR) 1419 fn = TREE_OPERAND (fn, 0); 1420 1421 /* Nobody is interested in seeing the guts of vcalls. */ 1422 if (TREE_CODE (fn) == OBJ_TYPE_REF) 1423 fn = resolve_virtual_fun_from_obj_type_ref (fn); 1424 1425 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE) 1426 { 1427 tree ob = TREE_VALUE (args); 1428 if (TREE_CODE (ob) == ADDR_EXPR) 1429 { 1430 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1431 pp_cxx_dot (cxx_pp); 1432 } 1433 else if (TREE_CODE (ob) != PARM_DECL 1434 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1435 { 1436 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1437 pp_cxx_arrow (cxx_pp); 1438 } 1439 args = TREE_CHAIN (args); 1440 } 1441 dump_expr (fn, flags | TFF_EXPR_IN_PARENS); 1442 pp_cxx_left_paren (cxx_pp); 1443 dump_expr_list (args, flags); 1444 pp_cxx_right_paren (cxx_pp); 1445 } 1446 break; 1447 1448 case NEW_EXPR: 1449 { 1450 tree type = TREE_OPERAND (t, 1); 1451 tree init = TREE_OPERAND (t, 2); 1452 if (NEW_EXPR_USE_GLOBAL (t)) 1453 pp_cxx_colon_colon (cxx_pp); 1454 pp_cxx_identifier (cxx_pp, "new"); 1455 if (TREE_OPERAND (t, 0)) 1456 { 1457 pp_cxx_left_paren (cxx_pp); 1458 dump_expr_list (TREE_OPERAND (t, 0), flags); 1459 pp_cxx_right_paren (cxx_pp); 1460 pp_cxx_whitespace (cxx_pp); 1461 } 1462 if (TREE_CODE (type) == ARRAY_REF) 1463 type = build_cplus_array_type 1464 (TREE_OPERAND (type, 0), 1465 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node, 1466 TREE_OPERAND (type, 1), 1467 integer_one_node))); 1468 dump_type (type, flags); 1469 if (init) 1470 { 1471 pp_cxx_left_paren (cxx_pp); 1472 if (TREE_CODE (init) == TREE_LIST) 1473 dump_expr_list (init, flags); 1474 else if (init == void_zero_node) 1475 /* This representation indicates an empty initializer, 1476 e.g.: "new int()". */ 1477 ; 1478 else 1479 dump_expr (init, flags); 1480 pp_cxx_right_paren (cxx_pp); 1481 } 1482 } 1483 break; 1484 1485 case TARGET_EXPR: 1486 /* Note that this only works for G++ target exprs. If somebody 1487 builds a general TARGET_EXPR, there's no way to represent that 1488 it initializes anything other that the parameter slot for the 1489 default argument. Note we may have cleared out the first 1490 operand in expand_expr, so don't go killing ourselves. */ 1491 if (TREE_OPERAND (t, 1)) 1492 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1493 break; 1494 1495 case INIT_EXPR: 1496 case MODIFY_EXPR: 1497 case PLUS_EXPR: 1498 case MINUS_EXPR: 1499 case MULT_EXPR: 1500 case TRUNC_DIV_EXPR: 1501 case TRUNC_MOD_EXPR: 1502 case MIN_EXPR: 1503 case MAX_EXPR: 1504 case LSHIFT_EXPR: 1505 case RSHIFT_EXPR: 1506 case BIT_IOR_EXPR: 1507 case BIT_XOR_EXPR: 1508 case BIT_AND_EXPR: 1509 case TRUTH_ANDIF_EXPR: 1510 case TRUTH_ORIF_EXPR: 1511 case LT_EXPR: 1512 case LE_EXPR: 1513 case GT_EXPR: 1514 case GE_EXPR: 1515 case EQ_EXPR: 1516 case NE_EXPR: 1517 case EXACT_DIV_EXPR: 1518 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags); 1519 break; 1520 1521 case CEIL_DIV_EXPR: 1522 case FLOOR_DIV_EXPR: 1523 case ROUND_DIV_EXPR: 1524 case RDIV_EXPR: 1525 dump_binary_op ("/", t, flags); 1526 break; 1527 1528 case CEIL_MOD_EXPR: 1529 case FLOOR_MOD_EXPR: 1530 case ROUND_MOD_EXPR: 1531 dump_binary_op ("%", t, flags); 1532 break; 1533 1534 case COMPONENT_REF: 1535 { 1536 tree ob = TREE_OPERAND (t, 0); 1537 if (TREE_CODE (ob) == INDIRECT_REF) 1538 { 1539 ob = TREE_OPERAND (ob, 0); 1540 if (TREE_CODE (ob) != PARM_DECL 1541 || (DECL_NAME (ob) 1542 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))) 1543 { 1544 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1545 pp_cxx_arrow (cxx_pp); 1546 } 1547 } 1548 else 1549 { 1550 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1551 pp_cxx_dot (cxx_pp); 1552 } 1553 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); 1554 } 1555 break; 1556 1557 case ARRAY_REF: 1558 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1559 pp_cxx_left_bracket (cxx_pp); 1560 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1561 pp_cxx_right_bracket (cxx_pp); 1562 break; 1563 1564 case UNARY_PLUS_EXPR: 1565 dump_unary_op ("+", t, flags); 1566 break; 1567 1568 case ADDR_EXPR: 1569 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 1570 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST 1571 /* An ADDR_EXPR can have reference type. In that case, we 1572 shouldn't print the `&' doing so indicates to the user 1573 that the expression has pointer type. */ 1574 || (TREE_TYPE (t) 1575 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)) 1576 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1577 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL) 1578 dump_unary_op ("&&", t, flags); 1579 else 1580 dump_unary_op ("&", t, flags); 1581 break; 1582 1583 case INDIRECT_REF: 1584 if (TREE_HAS_CONSTRUCTOR (t)) 1585 { 1586 t = TREE_OPERAND (t, 0); 1587 gcc_assert (TREE_CODE (t) == CALL_EXPR); 1588 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1589 pp_cxx_left_paren (cxx_pp); 1590 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1591 pp_cxx_right_paren (cxx_pp); 1592 } 1593 else 1594 { 1595 if (TREE_OPERAND (t,0) != NULL_TREE 1596 && TREE_TYPE (TREE_OPERAND (t, 0)) 1597 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 1598 dump_expr (TREE_OPERAND (t, 0), flags); 1599 else 1600 dump_unary_op ("*", t, flags); 1601 } 1602 break; 1603 1604 case NEGATE_EXPR: 1605 case BIT_NOT_EXPR: 1606 case TRUTH_NOT_EXPR: 1607 case PREDECREMENT_EXPR: 1608 case PREINCREMENT_EXPR: 1609 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags); 1610 break; 1611 1612 case POSTDECREMENT_EXPR: 1613 case POSTINCREMENT_EXPR: 1614 pp_cxx_left_paren (cxx_pp); 1615 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1616 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); 1617 pp_cxx_right_paren (cxx_pp); 1618 break; 1619 1620 case NON_LVALUE_EXPR: 1621 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 1622 should be another level of INDIRECT_REF so that I don't have to do 1623 this. */ 1624 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 1625 { 1626 tree next = TREE_TYPE (TREE_TYPE (t)); 1627 1628 while (TREE_CODE (next) == POINTER_TYPE) 1629 next = TREE_TYPE (next); 1630 1631 if (TREE_CODE (next) == FUNCTION_TYPE) 1632 { 1633 if (flags & TFF_EXPR_IN_PARENS) 1634 pp_cxx_left_paren (cxx_pp); 1635 pp_cxx_star (cxx_pp); 1636 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1637 if (flags & TFF_EXPR_IN_PARENS) 1638 pp_cxx_right_paren (cxx_pp); 1639 break; 1640 } 1641 /* Else fall through. */ 1642 } 1643 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1644 break; 1645 1646 case NOP_EXPR: 1647 case CONVERT_EXPR: 1648 { 1649 tree op = TREE_OPERAND (t, 0); 1650 1651 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))) 1652 { 1653 /* It is a cast, but we cannot tell whether it is a 1654 reinterpret or static cast. Use the C style notation. */ 1655 if (flags & TFF_EXPR_IN_PARENS) 1656 pp_cxx_left_paren (cxx_pp); 1657 pp_cxx_left_paren (cxx_pp); 1658 dump_type (TREE_TYPE (t), flags); 1659 pp_cxx_right_paren (cxx_pp); 1660 dump_expr (op, flags | TFF_EXPR_IN_PARENS); 1661 if (flags & TFF_EXPR_IN_PARENS) 1662 pp_cxx_right_paren (cxx_pp); 1663 } 1664 else 1665 dump_expr (op, flags); 1666 break; 1667 } 1668 1669 case CONSTRUCTOR: 1670 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 1671 { 1672 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier); 1673 1674 if (integer_zerop (idx)) 1675 { 1676 /* A NULL pointer-to-member constant. */ 1677 pp_cxx_left_paren (cxx_pp); 1678 pp_cxx_left_paren (cxx_pp); 1679 dump_type (TREE_TYPE (t), flags); 1680 pp_cxx_right_paren (cxx_pp); 1681 pp_character (cxx_pp, '0'); 1682 pp_cxx_right_paren (cxx_pp); 1683 break; 1684 } 1685 else if (host_integerp (idx, 0)) 1686 { 1687 tree virtuals; 1688 unsigned HOST_WIDE_INT n; 1689 1690 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 1691 t = TYPE_METHOD_BASETYPE (t); 1692 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 1693 1694 n = tree_low_cst (idx, 0); 1695 1696 /* Map vtable index back one, to allow for the null pointer to 1697 member. */ 1698 --n; 1699 1700 while (n > 0 && virtuals) 1701 { 1702 --n; 1703 virtuals = TREE_CHAIN (virtuals); 1704 } 1705 if (virtuals) 1706 { 1707 dump_expr (BV_FN (virtuals), 1708 flags | TFF_EXPR_IN_PARENS); 1709 break; 1710 } 1711 } 1712 } 1713 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t)) 1714 { 1715 dump_type (TREE_TYPE (t), 0); 1716 pp_cxx_left_paren (cxx_pp); 1717 pp_cxx_right_paren (cxx_pp); 1718 } 1719 else 1720 { 1721 pp_cxx_left_brace (cxx_pp); 1722 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags); 1723 pp_cxx_right_brace (cxx_pp); 1724 } 1725 1726 break; 1727 1728 case OFFSET_REF: 1729 { 1730 tree ob = TREE_OPERAND (t, 0); 1731 if (is_dummy_object (ob)) 1732 { 1733 t = TREE_OPERAND (t, 1); 1734 if (TREE_CODE (t) == FUNCTION_DECL) 1735 /* A::f */ 1736 dump_expr (t, flags | TFF_EXPR_IN_PARENS); 1737 else if (BASELINK_P (t)) 1738 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 1739 flags | TFF_EXPR_IN_PARENS); 1740 else 1741 dump_decl (t, flags); 1742 } 1743 else 1744 { 1745 if (TREE_CODE (ob) == INDIRECT_REF) 1746 { 1747 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1748 pp_cxx_arrow (cxx_pp); 1749 pp_cxx_star (cxx_pp); 1750 } 1751 else 1752 { 1753 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1754 pp_cxx_dot (cxx_pp); 1755 pp_cxx_star (cxx_pp); 1756 } 1757 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1758 } 1759 break; 1760 } 1761 1762 case TEMPLATE_PARM_INDEX: 1763 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS); 1764 break; 1765 1766 case SCOPE_REF: 1767 pp_expression (cxx_pp, t); 1768 break; 1769 1770 case CAST_EXPR: 1771 if (TREE_OPERAND (t, 0) == NULL_TREE 1772 || TREE_CHAIN (TREE_OPERAND (t, 0))) 1773 { 1774 dump_type (TREE_TYPE (t), flags); 1775 pp_cxx_left_paren (cxx_pp); 1776 dump_expr_list (TREE_OPERAND (t, 0), flags); 1777 pp_cxx_right_paren (cxx_pp); 1778 } 1779 else 1780 { 1781 pp_cxx_left_paren (cxx_pp); 1782 dump_type (TREE_TYPE (t), flags); 1783 pp_cxx_right_paren (cxx_pp); 1784 pp_cxx_left_paren (cxx_pp); 1785 dump_expr_list (TREE_OPERAND (t, 0), flags); 1786 pp_cxx_right_paren (cxx_pp); 1787 } 1788 break; 1789 1790 case STATIC_CAST_EXPR: 1791 pp_cxx_identifier (cxx_pp, "static_cast"); 1792 goto cast; 1793 case REINTERPRET_CAST_EXPR: 1794 pp_cxx_identifier (cxx_pp, "reinterpret_cast"); 1795 goto cast; 1796 case CONST_CAST_EXPR: 1797 pp_cxx_identifier (cxx_pp, "const_cast"); 1798 goto cast; 1799 case DYNAMIC_CAST_EXPR: 1800 pp_cxx_identifier (cxx_pp, "dynamic_cast"); 1801 cast: 1802 pp_cxx_begin_template_argument_list (cxx_pp); 1803 dump_type (TREE_TYPE (t), flags); 1804 pp_cxx_end_template_argument_list (cxx_pp); 1805 pp_cxx_left_paren (cxx_pp); 1806 dump_expr (TREE_OPERAND (t, 0), flags); 1807 pp_cxx_right_paren (cxx_pp); 1808 break; 1809 1810 case ARROW_EXPR: 1811 dump_expr (TREE_OPERAND (t, 0), flags); 1812 pp_cxx_arrow (cxx_pp); 1813 break; 1814 1815 case SIZEOF_EXPR: 1816 case ALIGNOF_EXPR: 1817 if (TREE_CODE (t) == SIZEOF_EXPR) 1818 pp_cxx_identifier (cxx_pp, "sizeof"); 1819 else 1820 { 1821 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); 1822 pp_cxx_identifier (cxx_pp, "__alignof__"); 1823 } 1824 pp_cxx_whitespace (cxx_pp); 1825 pp_cxx_left_paren (cxx_pp); 1826 if (TYPE_P (TREE_OPERAND (t, 0))) 1827 dump_type (TREE_OPERAND (t, 0), flags); 1828 else 1829 dump_expr (TREE_OPERAND (t, 0), flags); 1830 pp_cxx_right_paren (cxx_pp); 1831 break; 1832 1833 case REALPART_EXPR: 1834 case IMAGPART_EXPR: 1835 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name); 1836 pp_cxx_whitespace (cxx_pp); 1837 dump_expr (TREE_OPERAND (t, 0), flags); 1838 break; 1839 1840 case DEFAULT_ARG: 1841 pp_identifier (cxx_pp, "<unparsed>"); 1842 break; 1843 1844 case TRY_CATCH_EXPR: 1845 case WITH_CLEANUP_EXPR: 1846 case CLEANUP_POINT_EXPR: 1847 dump_expr (TREE_OPERAND (t, 0), flags); 1848 break; 1849 1850 case PSEUDO_DTOR_EXPR: 1851 dump_expr (TREE_OPERAND (t, 2), flags); 1852 pp_cxx_dot (cxx_pp); 1853 dump_type (TREE_OPERAND (t, 0), flags); 1854 pp_cxx_colon_colon (cxx_pp); 1855 pp_cxx_complement (cxx_pp); 1856 dump_type (TREE_OPERAND (t, 1), flags); 1857 break; 1858 1859 case TEMPLATE_ID_EXPR: 1860 dump_decl (t, flags); 1861 break; 1862 1863 case BIND_EXPR: 1864 case STMT_EXPR: 1865 case STATEMENT_LIST: 1866 /* We don't yet have a way of dumping statements in a 1867 human-readable format. */ 1868 pp_string (cxx_pp, "({...})"); 1869 break; 1870 1871 case LOOP_EXPR: 1872 pp_string (cxx_pp, "while (1) { "); 1873 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1874 pp_cxx_right_brace (cxx_pp); 1875 break; 1876 1877 case EXIT_EXPR: 1878 pp_string (cxx_pp, "if ("); 1879 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1880 pp_string (cxx_pp, ") break; "); 1881 break; 1882 1883 case BASELINK: 1884 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS); 1885 break; 1886 1887 case EMPTY_CLASS_EXPR: 1888 dump_type (TREE_TYPE (t), flags); 1889 pp_cxx_left_paren (cxx_pp); 1890 pp_cxx_right_paren (cxx_pp); 1891 break; 1892 1893 case NON_DEPENDENT_EXPR: 1894 dump_expr (TREE_OPERAND (t, 0), flags); 1895 break; 1896 1897 /* This list is incomplete, but should suffice for now. 1898 It is very important that `sorry' does not call 1899 `report_error_function'. That could cause an infinite loop. */ 1900 default: 1901 pp_unsupported_tree (cxx_pp, t); 1902 /* fall through to ERROR_MARK... */ 1903 case ERROR_MARK: 1904 pp_identifier (cxx_pp, "<expression error>"); 1905 break; 1906 } 1907} 1908 1909static void 1910dump_binary_op (const char *opstring, tree t, int flags) 1911{ 1912 pp_cxx_left_paren (cxx_pp); 1913 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1914 pp_cxx_whitespace (cxx_pp); 1915 if (opstring) 1916 pp_cxx_identifier (cxx_pp, opstring); 1917 else 1918 pp_identifier (cxx_pp, "<unknown operator>"); 1919 pp_cxx_whitespace (cxx_pp); 1920 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1921 pp_cxx_right_paren (cxx_pp); 1922} 1923 1924static void 1925dump_unary_op (const char *opstring, tree t, int flags) 1926{ 1927 if (flags & TFF_EXPR_IN_PARENS) 1928 pp_cxx_left_paren (cxx_pp); 1929 pp_cxx_identifier (cxx_pp, opstring); 1930 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1931 if (flags & TFF_EXPR_IN_PARENS) 1932 pp_cxx_right_paren (cxx_pp); 1933} 1934 1935static void 1936reinit_cxx_pp (void) 1937{ 1938 pp_clear_output_area (cxx_pp); 1939 pp_base (cxx_pp)->padding = pp_none; 1940 pp_indentation (cxx_pp) = 0; 1941 pp_needs_newline (cxx_pp) = false; 1942 cxx_pp->enclosing_scope = 0; 1943} 1944 1945 1946/* Exported interface to stringifying types, exprs and decls under TFF_* 1947 control. */ 1948 1949const char * 1950type_as_string (tree typ, int flags) 1951{ 1952 reinit_cxx_pp (); 1953 dump_type (typ, flags); 1954 return pp_formatted_text (cxx_pp); 1955} 1956 1957const char * 1958expr_as_string (tree decl, int flags) 1959{ 1960 reinit_cxx_pp (); 1961 dump_expr (decl, flags); 1962 return pp_formatted_text (cxx_pp); 1963} 1964 1965const char * 1966decl_as_string (tree decl, int flags) 1967{ 1968 reinit_cxx_pp (); 1969 dump_decl (decl, flags); 1970 return pp_formatted_text (cxx_pp); 1971} 1972 1973/* Generate the three forms of printable names for cxx_printable_name. */ 1974 1975const char * 1976lang_decl_name (tree decl, int v) 1977{ 1978 if (v >= 2) 1979 return decl_as_string (decl, TFF_DECL_SPECIFIERS); 1980 1981 reinit_cxx_pp (); 1982 if (v == 1 && DECL_CLASS_SCOPE_P (decl)) 1983 { 1984 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); 1985 pp_cxx_colon_colon (cxx_pp); 1986 } 1987 1988 if (TREE_CODE (decl) == FUNCTION_DECL) 1989 dump_function_name (decl, TFF_PLAIN_IDENTIFIER); 1990 else 1991 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER); 1992 1993 return pp_formatted_text (cxx_pp); 1994} 1995 1996/* Return the location of a tree passed to %+ formats. */ 1997 1998static location_t 1999location_of (tree t) 2000{ 2001 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 2002 t = DECL_CONTEXT (t); 2003 else if (TYPE_P (t)) 2004 t = TYPE_MAIN_DECL (t); 2005 else if (TREE_CODE (t) == OVERLOAD) 2006 t = OVL_FUNCTION (t); 2007 2008 return DECL_SOURCE_LOCATION (t); 2009} 2010 2011/* Now the interfaces from error et al to dump_type et al. Each takes an 2012 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_ 2013 function. */ 2014 2015static const char * 2016decl_to_string (tree decl, int verbose) 2017{ 2018 int flags = 0; 2019 2020 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE 2021 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE) 2022 flags = TFF_CLASS_KEY_OR_ENUM; 2023 if (verbose) 2024 flags |= TFF_DECL_SPECIFIERS; 2025 else if (TREE_CODE (decl) == FUNCTION_DECL) 2026 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; 2027 flags |= TFF_TEMPLATE_HEADER; 2028 2029 reinit_cxx_pp (); 2030 dump_decl (decl, flags); 2031 return pp_formatted_text (cxx_pp); 2032} 2033 2034static const char * 2035expr_to_string (tree decl) 2036{ 2037 reinit_cxx_pp (); 2038 dump_expr (decl, 0); 2039 return pp_formatted_text (cxx_pp); 2040} 2041 2042static const char * 2043fndecl_to_string (tree fndecl, int verbose) 2044{ 2045 int flags; 2046 2047 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS 2048 | TFF_TEMPLATE_HEADER; 2049 if (verbose) 2050 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; 2051 reinit_cxx_pp (); 2052 dump_decl (fndecl, flags); 2053 return pp_formatted_text (cxx_pp); 2054} 2055 2056 2057static const char * 2058code_to_string (enum tree_code c) 2059{ 2060 return tree_code_name [c]; 2061} 2062 2063const char * 2064language_to_string (enum languages c) 2065{ 2066 switch (c) 2067 { 2068 case lang_c: 2069 return "C"; 2070 2071 case lang_cplusplus: 2072 return "C++"; 2073 2074 case lang_java: 2075 return "Java"; 2076 2077 default: 2078 gcc_unreachable (); 2079 } 2080 return NULL; 2081} 2082 2083/* Return the proper printed version of a parameter to a C++ function. */ 2084 2085static const char * 2086parm_to_string (int p) 2087{ 2088 reinit_cxx_pp (); 2089 if (p < 0) 2090 pp_string (cxx_pp, "'this'"); 2091 else 2092 pp_decimal_int (cxx_pp, p + 1); 2093 return pp_formatted_text (cxx_pp); 2094} 2095 2096static const char * 2097op_to_string (enum tree_code p) 2098{ 2099 tree id = operator_name_info[(int) p].identifier; 2100 return id ? IDENTIFIER_POINTER (id) : "<unknown>"; 2101} 2102 2103static const char * 2104type_to_string (tree typ, int verbose) 2105{ 2106 int flags = 0; 2107 if (verbose) 2108 flags |= TFF_CLASS_KEY_OR_ENUM; 2109 flags |= TFF_TEMPLATE_HEADER; 2110 2111 reinit_cxx_pp (); 2112 dump_type (typ, flags); 2113 return pp_formatted_text (cxx_pp); 2114} 2115 2116static const char * 2117assop_to_string (enum tree_code p) 2118{ 2119 tree id = assignment_operator_name_info[(int) p].identifier; 2120 return id ? IDENTIFIER_POINTER (id) : "{unknown}"; 2121} 2122 2123static const char * 2124args_to_string (tree p, int verbose) 2125{ 2126 int flags = 0; 2127 if (verbose) 2128 flags |= TFF_CLASS_KEY_OR_ENUM; 2129 2130 if (p == NULL_TREE) 2131 return ""; 2132 2133 if (TYPE_P (TREE_VALUE (p))) 2134 return type_as_string (p, flags); 2135 2136 reinit_cxx_pp (); 2137 for (; p; p = TREE_CHAIN (p)) 2138 { 2139 if (TREE_VALUE (p) == null_node) 2140 pp_cxx_identifier (cxx_pp, "NULL"); 2141 else 2142 dump_type (error_type (TREE_VALUE (p)), flags); 2143 if (TREE_CHAIN (p)) 2144 pp_separate_with_comma (cxx_pp); 2145 } 2146 return pp_formatted_text (cxx_pp); 2147} 2148 2149static const char * 2150cv_to_string (tree p, int v) 2151{ 2152 reinit_cxx_pp (); 2153 pp_base (cxx_pp)->padding = v ? pp_before : pp_none; 2154 pp_cxx_cv_qualifier_seq (cxx_pp, p); 2155 return pp_formatted_text (cxx_pp); 2156} 2157 2158/* Langhook for print_error_function. */ 2159void 2160cxx_print_error_function (diagnostic_context *context, const char *file) 2161{ 2162 lhd_print_error_function (context, file); 2163 pp_base_set_prefix (context->printer, file); 2164 maybe_print_instantiation_context (context); 2165} 2166 2167static void 2168cp_diagnostic_starter (diagnostic_context *context, 2169 diagnostic_info *diagnostic) 2170{ 2171 diagnostic_report_current_module (context); 2172 cp_print_error_function (context, diagnostic); 2173 maybe_print_instantiation_context (context); 2174 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic)); 2175} 2176 2177static void 2178cp_diagnostic_finalizer (diagnostic_context *context, 2179 diagnostic_info *diagnostic ATTRIBUTE_UNUSED) 2180{ 2181 pp_base_destroy_prefix (context->printer); 2182} 2183 2184/* Print current function onto BUFFER, in the process of reporting 2185 a diagnostic message. Called from cp_diagnostic_starter. */ 2186static void 2187cp_print_error_function (diagnostic_context *context, 2188 diagnostic_info *diagnostic) 2189{ 2190 if (diagnostic_last_function_changed (context)) 2191 { 2192 const char *old_prefix = context->printer->prefix; 2193 const char *file = LOCATION_FILE (diagnostic->location); 2194 char *new_prefix = file ? file_name_as_prefix (file) : NULL; 2195 2196 pp_base_set_prefix (context->printer, new_prefix); 2197 2198 if (current_function_decl == NULL) 2199 pp_base_string (context->printer, "At global scope:"); 2200 else 2201 pp_printf (context->printer, "In %s %qs:", 2202 function_category (current_function_decl), 2203 cxx_printable_name (current_function_decl, 2)); 2204 pp_base_newline (context->printer); 2205 2206 diagnostic_set_last_function (context); 2207 pp_base_destroy_prefix (context->printer); 2208 context->printer->prefix = old_prefix; 2209 } 2210} 2211 2212/* Returns a description of FUNCTION using standard terminology. */ 2213static const char * 2214function_category (tree fn) 2215{ 2216 if (DECL_FUNCTION_MEMBER_P (fn)) 2217 { 2218 if (DECL_STATIC_FUNCTION_P (fn)) 2219 return "static member function"; 2220 else if (DECL_COPY_CONSTRUCTOR_P (fn)) 2221 return "copy constructor"; 2222 else if (DECL_CONSTRUCTOR_P (fn)) 2223 return "constructor"; 2224 else if (DECL_DESTRUCTOR_P (fn)) 2225 return "destructor"; 2226 else 2227 return "member function"; 2228 } 2229 else 2230 return "function"; 2231} 2232 2233/* Report the full context of a current template instantiation, 2234 onto BUFFER. */ 2235static void 2236print_instantiation_full_context (diagnostic_context *context) 2237{ 2238 tree p = current_instantiation (); 2239 location_t location = input_location; 2240 2241 if (p) 2242 { 2243 if (current_function_decl != TINST_DECL (p) 2244 && current_function_decl != NULL_TREE) 2245 /* We can get here during the processing of some synthesized 2246 method. Then, TINST_DECL (p) will be the function that's causing 2247 the synthesis. */ 2248 ; 2249 else 2250 { 2251 if (current_function_decl == TINST_DECL (p)) 2252 /* Avoid redundancy with the "In function" line. */; 2253 else 2254 pp_verbatim (context->printer, 2255 "%s: In instantiation of %qs:\n", 2256 LOCATION_FILE (location), 2257 decl_as_string (TINST_DECL (p), 2258 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2259 2260 location = TINST_LOCATION (p); 2261 p = TREE_CHAIN (p); 2262 } 2263 } 2264 2265 print_instantiation_partial_context (context, p, location); 2266} 2267 2268/* Same as above but less verbose. */ 2269static void 2270print_instantiation_partial_context (diagnostic_context *context, 2271 tree t, location_t loc) 2272{ 2273 expanded_location xloc; 2274 for (; ; t = TREE_CHAIN (t)) 2275 { 2276 xloc = expand_location (loc); 2277 if (t == NULL_TREE) 2278 break; 2279 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n", 2280 xloc.file, xloc.line, 2281 decl_as_string (TINST_DECL (t), 2282 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2283 loc = TINST_LOCATION (t); 2284 } 2285 pp_verbatim (context->printer, "%s:%d: instantiated from here", 2286 xloc.file, xloc.line); 2287 pp_base_newline (context->printer); 2288} 2289 2290/* Called from cp_thing to print the template context for an error. */ 2291static void 2292maybe_print_instantiation_context (diagnostic_context *context) 2293{ 2294 if (!problematic_instantiation_changed () || current_instantiation () == 0) 2295 return; 2296 2297 record_last_problematic_instantiation (); 2298 print_instantiation_full_context (context); 2299} 2300 2301/* Report the bare minimum context of a template instantiation. */ 2302void 2303print_instantiation_context (void) 2304{ 2305 print_instantiation_partial_context 2306 (global_dc, current_instantiation (), input_location); 2307 diagnostic_flush_buffer (global_dc); 2308} 2309 2310/* Called from output_format -- during diagnostic message processing -- 2311 to handle C++ specific format specifier with the following meanings: 2312 %A function argument-list. 2313 %C tree code. 2314 %D declaration. 2315 %E expression. 2316 %F function declaration. 2317 %L language as used in extern "lang". 2318 %O binary operator. 2319 %P function parameter whose position is indicated by an integer. 2320 %Q assignment operator. 2321 %T type. 2322 %V cv-qualifier. */ 2323static bool 2324cp_printer (pretty_printer *pp, text_info *text, const char *spec, 2325 int precision, bool wide, bool set_locus, bool verbose) 2326{ 2327 const char *result; 2328 tree t = NULL; 2329#define next_tree (t = va_arg (*text->args_ptr, tree)) 2330#define next_tcode va_arg (*text->args_ptr, enum tree_code) 2331#define next_lang va_arg (*text->args_ptr, enum languages) 2332#define next_int va_arg (*text->args_ptr, int) 2333 2334 if (precision != 0 || wide) 2335 return false; 2336 2337 if (text->locus == NULL) 2338 set_locus = false; 2339 2340 switch (*spec) 2341 { 2342 case 'A': result = args_to_string (next_tree, verbose); break; 2343 case 'C': result = code_to_string (next_tcode); break; 2344 case 'D': 2345 { 2346 tree temp = next_tree; 2347 if (DECL_P (temp) 2348 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp)) 2349 { 2350 temp = DECL_DEBUG_EXPR (temp); 2351 if (!DECL_P (temp)) 2352 { 2353 result = expr_to_string (temp); 2354 break; 2355 } 2356 } 2357 result = decl_to_string (temp, verbose); 2358 } 2359 break; 2360 case 'E': result = expr_to_string (next_tree); break; 2361 case 'F': result = fndecl_to_string (next_tree, verbose); break; 2362 case 'L': result = language_to_string (next_lang); break; 2363 case 'O': result = op_to_string (next_tcode); break; 2364 case 'P': result = parm_to_string (next_int); break; 2365 case 'Q': result = assop_to_string (next_tcode); break; 2366 case 'T': result = type_to_string (next_tree, verbose); break; 2367 case 'V': result = cv_to_string (next_tree, verbose); break; 2368 2369 default: 2370 return false; 2371 } 2372 2373 pp_base_string (pp, result); 2374 if (set_locus && t != NULL) 2375 *text->locus = location_of (t); 2376 return true; 2377#undef next_tree 2378#undef next_tcode 2379#undef next_lang 2380#undef next_int 2381} 2382 2383/* Callback from cpp_error for PFILE to print diagnostics arising from 2384 interpreting strings. The diagnostic is of type LEVEL; MSG is the 2385 translated message and AP the arguments. */ 2386 2387void 2388cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, 2389 const char *msg, va_list *ap) 2390{ 2391 diagnostic_info diagnostic; 2392 diagnostic_t dlevel; 2393 switch (level) 2394 { 2395 case CPP_DL_WARNING: 2396 case CPP_DL_WARNING_SYSHDR: 2397 dlevel = DK_WARNING; 2398 break; 2399 case CPP_DL_PEDWARN: 2400 dlevel = pedantic_error_kind (); 2401 break; 2402 case CPP_DL_ERROR: 2403 dlevel = DK_ERROR; 2404 break; 2405 case CPP_DL_ICE: 2406 dlevel = DK_ICE; 2407 break; 2408 default: 2409 gcc_unreachable (); 2410 } 2411 diagnostic_set_info_translated (&diagnostic, msg, ap, 2412 input_location, dlevel); 2413 report_diagnostic (&diagnostic); 2414} 2415