error.c revision 1.7
1/* Call-backs for C++ error reporting. 2 This code is non-reentrant. 3 Copyright (C) 1993-2016 Free Software Foundation, Inc. 4 This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 3, or (at your option) 9any later version. 10 11GCC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING3. If not see 18<http://www.gnu.org/licenses/>. */ 19 20#include "config.h" 21#include "system.h" 22#include "coretypes.h" 23#include "cp-tree.h" 24#include "stringpool.h" 25#include "tree-diagnostic.h" 26#include "langhooks-def.h" 27#include "intl.h" 28#include "cxx-pretty-print.h" 29#include "tree-pretty-print.h" 30#include "c-family/c-objc.h" 31#include "ubsan.h" 32#include "internal-fn.h" 33 34#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',') 35#define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';') 36 37/* cxx_pp is a C++ front-end-specific pretty printer: this is where we 38 dump C++ ASTs as strings. It is mostly used only by the various 39 tree -> string functions that are occasionally called from the 40 debugger or by the front-end for things like 41 __PRETTY_FUNCTION__. */ 42static cxx_pretty_printer actual_pretty_printer; 43static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer; 44 45/* Translate if being used for diagnostics, but not for dump files or 46 __PRETTY_FUNCTION. */ 47#define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid)) 48 49# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) 50 51static const char *args_to_string (tree, int); 52static const char *assop_to_string (enum tree_code); 53static const char *code_to_string (enum tree_code); 54static const char *cv_to_string (tree, int); 55static const char *decl_to_string (tree, int); 56static const char *expr_to_string (tree); 57static const char *fndecl_to_string (tree, int); 58static const char *op_to_string (enum tree_code); 59static const char *parm_to_string (int); 60static const char *type_to_string (tree, int); 61 62static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int); 63static void dump_type (cxx_pretty_printer *, tree, int); 64static void dump_typename (cxx_pretty_printer *, tree, int); 65static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int); 66static void dump_decl (cxx_pretty_printer *, tree, int); 67static void dump_template_decl (cxx_pretty_printer *, tree, int); 68static void dump_function_decl (cxx_pretty_printer *, tree, int); 69static void dump_expr (cxx_pretty_printer *, tree, int); 70static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int); 71static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int); 72static void dump_aggr_type (cxx_pretty_printer *, tree, int); 73static void dump_type_prefix (cxx_pretty_printer *, tree, int); 74static void dump_type_suffix (cxx_pretty_printer *, tree, int); 75static void dump_function_name (cxx_pretty_printer *, tree, int); 76static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool); 77static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool); 78static void dump_expr_list (cxx_pretty_printer *, tree, int); 79static void dump_global_iord (cxx_pretty_printer *, tree); 80static void dump_parameters (cxx_pretty_printer *, tree, int); 81static void dump_ref_qualifier (cxx_pretty_printer *, tree, int); 82static void dump_exception_spec (cxx_pretty_printer *, tree, int); 83static void dump_template_argument (cxx_pretty_printer *, tree, int); 84static void dump_template_argument_list (cxx_pretty_printer *, tree, int); 85static void dump_template_parameter (cxx_pretty_printer *, tree, int); 86static void dump_template_bindings (cxx_pretty_printer *, tree, tree, 87 vec<tree, va_gc> *); 88static void dump_scope (cxx_pretty_printer *, tree, int); 89static void dump_template_parms (cxx_pretty_printer *, tree, int, int); 90static int get_non_default_template_args_count (tree, int); 91static const char *function_category (tree); 92static void maybe_print_constexpr_context (diagnostic_context *); 93static void maybe_print_instantiation_context (diagnostic_context *); 94static void print_instantiation_full_context (diagnostic_context *); 95static void print_instantiation_partial_context (diagnostic_context *, 96 struct tinst_level *, 97 location_t); 98static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); 99static void cp_print_error_function (diagnostic_context *, diagnostic_info *); 100 101static bool cp_printer (pretty_printer *, text_info *, const char *, 102 int, bool, bool, bool); 103 104/* CONTEXT->printer is a basic pretty printer that was constructed 105 presumably by diagnostic_initialize(), called early in the 106 compiler's initialization process (in general_init) Before the FE 107 is initialized. This (C++) FE-specific diagnostic initializer is 108 thus replacing the basic pretty printer with one that has C++-aware 109 capacities. */ 110 111void 112cxx_initialize_diagnostics (diagnostic_context *context) 113{ 114 pretty_printer *base = context->printer; 115 cxx_pretty_printer *pp = XNEW (cxx_pretty_printer); 116 context->printer = new (pp) cxx_pretty_printer (); 117 118 /* It is safe to free this object because it was previously XNEW()'d. */ 119 base->~pretty_printer (); 120 XDELETE (base); 121 122 c_common_diagnostics_set_defaults (context); 123 diagnostic_starter (context) = cp_diagnostic_starter; 124 /* diagnostic_finalizer is already c_diagnostic_finalizer. */ 125 diagnostic_format_decoder (context) = cp_printer; 126} 127 128/* Dump a scope, if deemed necessary. */ 129 130static void 131dump_scope (cxx_pretty_printer *pp, tree scope, int flags) 132{ 133 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF); 134 135 if (scope == NULL_TREE) 136 return; 137 138 if (TREE_CODE (scope) == NAMESPACE_DECL) 139 { 140 if (scope != global_namespace) 141 { 142 dump_decl (pp, scope, f); 143 pp_cxx_colon_colon (pp); 144 } 145 } 146 else if (AGGREGATE_TYPE_P (scope)) 147 { 148 dump_type (pp, scope, f); 149 pp_cxx_colon_colon (pp); 150 } 151 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) 152 { 153 dump_function_decl (pp, scope, f); 154 pp_cxx_colon_colon (pp); 155 } 156} 157 158/* Dump the template ARGument under control of FLAGS. */ 159 160static void 161dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags) 162{ 163 if (ARGUMENT_PACK_P (arg)) 164 dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg), 165 /* No default args in argument packs. */ 166 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS); 167 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) 168 dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM); 169 else 170 { 171 if (TREE_CODE (arg) == TREE_LIST) 172 arg = TREE_VALUE (arg); 173 174 dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); 175 } 176} 177 178/* Count the number of template arguments ARGS whose value does not 179 match the (optional) default template parameter in PARAMS */ 180 181static int 182get_non_default_template_args_count (tree args, int flags) 183{ 184 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args)); 185 186 if (/* We use this flag when generating debug information. We don't 187 want to expand templates at this point, for this may generate 188 new decls, which gets decl counts out of sync, which may in 189 turn cause codegen differences between compilations with and 190 without -g. */ 191 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0 192 || !flag_pretty_templates) 193 return n; 194 195 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args)); 196} 197 198/* Dump a template-argument-list ARGS (always a TREE_VEC) under control 199 of FLAGS. */ 200 201static void 202dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags) 203{ 204 int n = get_non_default_template_args_count (args, flags); 205 int need_comma = 0; 206 int i; 207 208 for (i = 0; i < n; ++i) 209 { 210 tree arg = TREE_VEC_ELT (args, i); 211 212 /* Only print a comma if we know there is an argument coming. In 213 the case of an empty template argument pack, no actual 214 argument will be printed. */ 215 if (need_comma 216 && (!ARGUMENT_PACK_P (arg) 217 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0)) 218 pp_separate_with_comma (pp); 219 220 dump_template_argument (pp, arg, flags); 221 need_comma = 1; 222 } 223} 224 225/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ 226 227static void 228dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags) 229{ 230 tree p; 231 tree a; 232 233 if (parm == error_mark_node) 234 return; 235 236 p = TREE_VALUE (parm); 237 a = TREE_PURPOSE (parm); 238 239 if (TREE_CODE (p) == TYPE_DECL) 240 { 241 if (flags & TFF_DECL_SPECIFIERS) 242 { 243 pp_cxx_ws_string (pp, "class"); 244 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p))) 245 pp_cxx_ws_string (pp, "..."); 246 if (DECL_NAME (p)) 247 pp_cxx_tree_identifier (pp, DECL_NAME (p)); 248 } 249 else if (DECL_NAME (p)) 250 pp_cxx_tree_identifier (pp, DECL_NAME (p)); 251 else 252 pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p)); 253 } 254 else 255 dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS); 256 257 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) 258 { 259 pp_cxx_whitespace (pp); 260 pp_equal (pp); 261 pp_cxx_whitespace (pp); 262 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) 263 dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF); 264 else 265 dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS); 266 } 267} 268 269/* Dump, under control of FLAGS, a template-parameter-list binding. 270 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a 271 TREE_VEC. */ 272 273static void 274dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args, 275 vec<tree, va_gc> *typenames) 276{ 277 bool need_semicolon = false; 278 int i; 279 tree t; 280 281 while (parms) 282 { 283 tree p = TREE_VALUE (parms); 284 int lvl = TMPL_PARMS_DEPTH (parms); 285 int arg_idx = 0; 286 int i; 287 tree lvl_args = NULL_TREE; 288 289 /* Don't crash if we had an invalid argument list. */ 290 if (TMPL_ARGS_DEPTH (args) >= lvl) 291 lvl_args = TMPL_ARGS_LEVEL (args, lvl); 292 293 for (i = 0; i < TREE_VEC_LENGTH (p); ++i) 294 { 295 tree arg = NULL_TREE; 296 297 /* Don't crash if we had an invalid argument list. */ 298 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx) 299 arg = TREE_VEC_ELT (lvl_args, arg_idx); 300 301 if (need_semicolon) 302 pp_separate_with_semicolon (pp); 303 dump_template_parameter (pp, TREE_VEC_ELT (p, i), 304 TFF_PLAIN_IDENTIFIER); 305 pp_cxx_whitespace (pp); 306 pp_equal (pp); 307 pp_cxx_whitespace (pp); 308 if (arg) 309 { 310 if (ARGUMENT_PACK_P (arg)) 311 pp_cxx_left_brace (pp); 312 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER); 313 if (ARGUMENT_PACK_P (arg)) 314 pp_cxx_right_brace (pp); 315 } 316 else 317 pp_string (pp, M_("<missing>")); 318 319 ++arg_idx; 320 need_semicolon = true; 321 } 322 323 parms = TREE_CHAIN (parms); 324 } 325 326 /* Don't bother with typenames for a partial instantiation. */ 327 if (vec_safe_is_empty (typenames) || uses_template_parms (args)) 328 return; 329 330 /* Don't try to print typenames when we're processing a clone. */ 331 if (current_function_decl 332 && !DECL_LANG_SPECIFIC (current_function_decl)) 333 return; 334 335 /* Don't try to do this once cgraph starts throwing away front-end 336 information. */ 337 if (at_eof >= 2) 338 return; 339 340 FOR_EACH_VEC_SAFE_ELT (typenames, i, t) 341 { 342 if (need_semicolon) 343 pp_separate_with_semicolon (pp); 344 dump_type (pp, t, TFF_PLAIN_IDENTIFIER); 345 pp_cxx_whitespace (pp); 346 pp_equal (pp); 347 pp_cxx_whitespace (pp); 348 push_deferring_access_checks (dk_no_check); 349 t = tsubst (t, args, tf_none, NULL_TREE); 350 pop_deferring_access_checks (); 351 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because 352 pp_simple_type_specifier doesn't know about it. */ 353 t = strip_typedefs (t); 354 dump_type (pp, t, TFF_PLAIN_IDENTIFIER); 355 } 356} 357 358/* Dump a human-readable equivalent of the alias template 359 specialization of T. */ 360 361static void 362dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags) 363{ 364 tree name; 365 366 gcc_assert (alias_template_specialization_p (t)); 367 368 if (!(flags & TFF_UNQUALIFIED_NAME)) 369 dump_scope (pp, CP_DECL_CONTEXT (TYPE_NAME (t)), flags); 370 name = TYPE_IDENTIFIER (t); 371 pp_cxx_tree_identifier (pp, name); 372 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t), 373 /*primary=*/false, 374 flags & ~TFF_TEMPLATE_HEADER); 375} 376 377/* Dump a human-readable equivalent of TYPE. FLAGS controls the 378 format. */ 379 380static void 381dump_type (cxx_pretty_printer *pp, tree t, int flags) 382{ 383 if (t == NULL_TREE) 384 return; 385 386 /* Don't print e.g. "struct mytypedef". */ 387 if (TYPE_P (t) && typedef_variant_p (t)) 388 { 389 tree decl = TYPE_NAME (t); 390 if ((flags & TFF_CHASE_TYPEDEF) 391 || DECL_SELF_REFERENCE_P (decl) 392 || (!flag_pretty_templates 393 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))) 394 t = strip_typedefs (t); 395 else if (alias_template_specialization_p (t)) 396 { 397 dump_alias_template_specialization (pp, t, flags); 398 return; 399 } 400 else if (same_type_p (t, TREE_TYPE (decl))) 401 t = decl; 402 else 403 { 404 pp_cxx_cv_qualifier_seq (pp, t); 405 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t)); 406 return; 407 } 408 } 409 410 if (TYPE_PTRMEMFUNC_P (t)) 411 goto offset_type; 412 413 switch (TREE_CODE (t)) 414 { 415 case LANG_TYPE: 416 if (t == init_list_type_node) 417 pp_string (pp, M_("<brace-enclosed initializer list>")); 418 else if (t == unknown_type_node) 419 pp_string (pp, M_("<unresolved overloaded function type>")); 420 else 421 { 422 pp_cxx_cv_qualifier_seq (pp, t); 423 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t)); 424 } 425 break; 426 427 case TREE_LIST: 428 /* A list of function parms. */ 429 dump_parameters (pp, t, flags); 430 break; 431 432 case IDENTIFIER_NODE: 433 pp_cxx_tree_identifier (pp, t); 434 break; 435 436 case TREE_BINFO: 437 dump_type (pp, BINFO_TYPE (t), flags); 438 break; 439 440 case RECORD_TYPE: 441 case UNION_TYPE: 442 case ENUMERAL_TYPE: 443 dump_aggr_type (pp, t, flags); 444 break; 445 446 case TYPE_DECL: 447 if (flags & TFF_CHASE_TYPEDEF) 448 { 449 dump_type (pp, DECL_ORIGINAL_TYPE (t) 450 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); 451 break; 452 } 453 /* Else fall through. */ 454 455 case TEMPLATE_DECL: 456 case NAMESPACE_DECL: 457 dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS); 458 break; 459 460 case INTEGER_TYPE: 461 case REAL_TYPE: 462 case VOID_TYPE: 463 case BOOLEAN_TYPE: 464 case COMPLEX_TYPE: 465 case VECTOR_TYPE: 466 case FIXED_POINT_TYPE: 467 pp_type_specifier_seq (pp, t); 468 break; 469 470 case TEMPLATE_TEMPLATE_PARM: 471 /* For parameters inside template signature. */ 472 if (TYPE_IDENTIFIER (t)) 473 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t)); 474 else 475 pp_cxx_canonical_template_parameter (pp, t); 476 break; 477 478 case BOUND_TEMPLATE_TEMPLATE_PARM: 479 { 480 tree args = TYPE_TI_ARGS (t); 481 pp_cxx_cv_qualifier_seq (pp, t); 482 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t)); 483 pp_cxx_begin_template_argument_list (pp); 484 dump_template_argument_list (pp, args, flags); 485 pp_cxx_end_template_argument_list (pp); 486 } 487 break; 488 489 case TEMPLATE_TYPE_PARM: 490 pp_cxx_cv_qualifier_seq (pp, t); 491 if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t)) 492 pp_cxx_constrained_type_spec (pp, c); 493 else if (TYPE_IDENTIFIER (t)) 494 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t)); 495 else 496 pp_cxx_canonical_template_parameter 497 (pp, TEMPLATE_TYPE_PARM_INDEX (t)); 498 break; 499 500 /* This is not always necessary for pointers and such, but doing this 501 reduces code size. */ 502 case ARRAY_TYPE: 503 case POINTER_TYPE: 504 case REFERENCE_TYPE: 505 case OFFSET_TYPE: 506 offset_type: 507 case FUNCTION_TYPE: 508 case METHOD_TYPE: 509 { 510 dump_type_prefix (pp, t, flags); 511 dump_type_suffix (pp, t, flags); 512 break; 513 } 514 case TYPENAME_TYPE: 515 if (! (flags & TFF_CHASE_TYPEDEF) 516 && DECL_ORIGINAL_TYPE (TYPE_NAME (t))) 517 { 518 dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER); 519 break; 520 } 521 pp_cxx_cv_qualifier_seq (pp, t); 522 pp_cxx_ws_string (pp, 523 TYPENAME_IS_ENUM_P (t) ? "enum" 524 : TYPENAME_IS_CLASS_P (t) ? "class" 525 : "typename"); 526 dump_typename (pp, t, flags); 527 break; 528 529 case UNBOUND_CLASS_TEMPLATE: 530 if (! (flags & TFF_UNQUALIFIED_NAME)) 531 { 532 dump_type (pp, TYPE_CONTEXT (t), flags); 533 pp_cxx_colon_colon (pp); 534 } 535 pp_cxx_ws_string (pp, "template"); 536 dump_type (pp, TYPE_IDENTIFIER (t), flags); 537 break; 538 539 case TYPEOF_TYPE: 540 pp_cxx_ws_string (pp, "__typeof__"); 541 pp_cxx_whitespace (pp); 542 pp_cxx_left_paren (pp); 543 dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 544 pp_cxx_right_paren (pp); 545 break; 546 547 case UNDERLYING_TYPE: 548 pp_cxx_ws_string (pp, "__underlying_type"); 549 pp_cxx_whitespace (pp); 550 pp_cxx_left_paren (pp); 551 dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS); 552 pp_cxx_right_paren (pp); 553 break; 554 555 case TYPE_PACK_EXPANSION: 556 dump_type (pp, PACK_EXPANSION_PATTERN (t), flags); 557 pp_cxx_ws_string (pp, "..."); 558 break; 559 560 case TYPE_ARGUMENT_PACK: 561 dump_template_argument (pp, t, flags); 562 break; 563 564 case DECLTYPE_TYPE: 565 pp_cxx_ws_string (pp, "decltype"); 566 pp_cxx_whitespace (pp); 567 pp_cxx_left_paren (pp); 568 dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 569 pp_cxx_right_paren (pp); 570 break; 571 572 case NULLPTR_TYPE: 573 pp_string (pp, "std::nullptr_t"); 574 break; 575 576 default: 577 pp_unsupported_tree (pp, t); 578 /* Fall through to error. */ 579 580 case ERROR_MARK: 581 pp_string (pp, M_("<type error>")); 582 break; 583 } 584} 585 586/* Dump a TYPENAME_TYPE. We need to notice when the context is itself 587 a TYPENAME_TYPE. */ 588 589static void 590dump_typename (cxx_pretty_printer *pp, tree t, int flags) 591{ 592 tree ctx = TYPE_CONTEXT (t); 593 594 if (TREE_CODE (ctx) == TYPENAME_TYPE) 595 dump_typename (pp, ctx, flags); 596 else 597 dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); 598 pp_cxx_colon_colon (pp); 599 dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags); 600} 601 602/* Return the name of the supplied aggregate, or enumeral type. */ 603 604const char * 605class_key_or_enum_as_string (tree t) 606{ 607 if (TREE_CODE (t) == ENUMERAL_TYPE) 608 { 609 if (SCOPED_ENUM_P (t)) 610 return "enum class"; 611 else 612 return "enum"; 613 } 614 else if (TREE_CODE (t) == UNION_TYPE) 615 return "union"; 616 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 617 return "class"; 618 else 619 return "struct"; 620} 621 622/* Print out a class declaration T under the control of FLAGS, 623 in the form `class foo'. */ 624 625static void 626dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) 627{ 628 tree name; 629 const char *variety = class_key_or_enum_as_string (t); 630 int typdef = 0; 631 int tmplate = 0; 632 633 pp_cxx_cv_qualifier_seq (pp, t); 634 635 if (flags & TFF_CLASS_KEY_OR_ENUM) 636 pp_cxx_ws_string (pp, variety); 637 638 name = TYPE_NAME (t); 639 640 if (name) 641 { 642 typdef = (!DECL_ARTIFICIAL (name) 643 /* An alias specialization is not considered to be a 644 typedef. */ 645 && !alias_template_specialization_p (t)); 646 647 if ((typdef 648 && ((flags & TFF_CHASE_TYPEDEF) 649 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name) 650 && DECL_TEMPLATE_INFO (name)))) 651 || DECL_SELF_REFERENCE_P (name)) 652 { 653 t = TYPE_MAIN_VARIANT (t); 654 name = TYPE_NAME (t); 655 typdef = 0; 656 } 657 658 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE 659 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t) 660 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL 661 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); 662 663 if (! (flags & TFF_UNQUALIFIED_NAME)) 664 dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE); 665 flags &= ~TFF_UNQUALIFIED_NAME; 666 if (tmplate) 667 { 668 /* Because the template names are mangled, we have to locate 669 the most general template, and use that name. */ 670 tree tpl = TYPE_TI_TEMPLATE (t); 671 672 while (DECL_TEMPLATE_INFO (tpl)) 673 tpl = DECL_TI_TEMPLATE (tpl); 674 name = tpl; 675 } 676 name = DECL_NAME (name); 677 } 678 679 if (name == 0 || anon_aggrname_p (name)) 680 { 681 if (flags & TFF_CLASS_KEY_OR_ENUM) 682 pp_string (pp, M_("<anonymous>")); 683 else 684 pp_printf (pp, M_("<anonymous %s>"), variety); 685 } 686 else if (LAMBDA_TYPE_P (t)) 687 { 688 /* A lambda's "type" is essentially its signature. */ 689 pp_string (pp, M_("<lambda")); 690 if (lambda_function (t)) 691 dump_parameters (pp, 692 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)), 693 flags); 694 pp_greater (pp); 695 } 696 else 697 pp_cxx_tree_identifier (pp, name); 698 if (tmplate) 699 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t), 700 !CLASSTYPE_USE_TEMPLATE (t), 701 flags & ~TFF_TEMPLATE_HEADER); 702} 703 704/* Dump into the obstack the initial part of the output for a given type. 705 This is necessary when dealing with things like functions returning 706 functions. Examples: 707 708 return type of `int (* fee ())()': pointer -> function -> int. Both 709 pointer (and reference and offset) and function (and member) types must 710 deal with prefix and suffix. 711 712 Arrays must also do this for DECL nodes, like int a[], and for things like 713 int *[]&. */ 714 715static void 716dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags) 717{ 718 if (TYPE_PTRMEMFUNC_P (t)) 719 { 720 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 721 goto offset_type; 722 } 723 724 switch (TREE_CODE (t)) 725 { 726 case POINTER_TYPE: 727 case REFERENCE_TYPE: 728 { 729 tree sub = TREE_TYPE (t); 730 731 dump_type_prefix (pp, sub, flags); 732 if (TREE_CODE (sub) == ARRAY_TYPE 733 || TREE_CODE (sub) == FUNCTION_TYPE) 734 { 735 pp_cxx_whitespace (pp); 736 pp_cxx_left_paren (pp); 737 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub)); 738 } 739 if (TYPE_PTR_P (t)) 740 pp_star (pp); 741 else if (TREE_CODE (t) == REFERENCE_TYPE) 742 { 743 if (TYPE_REF_IS_RVALUE (t)) 744 pp_ampersand_ampersand (pp); 745 else 746 pp_ampersand (pp); 747 } 748 pp->padding = pp_before; 749 pp_cxx_cv_qualifier_seq (pp, t); 750 } 751 break; 752 753 case OFFSET_TYPE: 754 offset_type: 755 dump_type_prefix (pp, TREE_TYPE (t), flags); 756 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ 757 { 758 pp_maybe_space (pp); 759 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 760 pp_cxx_left_paren (pp); 761 dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags); 762 pp_cxx_colon_colon (pp); 763 } 764 pp_cxx_star (pp); 765 pp_cxx_cv_qualifier_seq (pp, t); 766 pp->padding = pp_before; 767 break; 768 769 /* This can be reached without a pointer when dealing with 770 templates, e.g. std::is_function. */ 771 case FUNCTION_TYPE: 772 dump_type_prefix (pp, TREE_TYPE (t), flags); 773 break; 774 775 case METHOD_TYPE: 776 dump_type_prefix (pp, TREE_TYPE (t), flags); 777 pp_maybe_space (pp); 778 pp_cxx_left_paren (pp); 779 dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags); 780 pp_cxx_colon_colon (pp); 781 break; 782 783 case ARRAY_TYPE: 784 dump_type_prefix (pp, TREE_TYPE (t), flags); 785 break; 786 787 case ENUMERAL_TYPE: 788 case IDENTIFIER_NODE: 789 case INTEGER_TYPE: 790 case BOOLEAN_TYPE: 791 case REAL_TYPE: 792 case RECORD_TYPE: 793 case TEMPLATE_TYPE_PARM: 794 case TEMPLATE_TEMPLATE_PARM: 795 case BOUND_TEMPLATE_TEMPLATE_PARM: 796 case TREE_LIST: 797 case TYPE_DECL: 798 case TREE_VEC: 799 case UNION_TYPE: 800 case LANG_TYPE: 801 case VOID_TYPE: 802 case TYPENAME_TYPE: 803 case COMPLEX_TYPE: 804 case VECTOR_TYPE: 805 case TYPEOF_TYPE: 806 case UNDERLYING_TYPE: 807 case DECLTYPE_TYPE: 808 case TYPE_PACK_EXPANSION: 809 case FIXED_POINT_TYPE: 810 case NULLPTR_TYPE: 811 dump_type (pp, t, flags); 812 pp->padding = pp_before; 813 break; 814 815 default: 816 pp_unsupported_tree (pp, t); 817 /* fall through. */ 818 case ERROR_MARK: 819 pp_string (pp, M_("<typeprefixerror>")); 820 break; 821 } 822} 823 824/* Dump the suffix of type T, under control of FLAGS. This is the part 825 which appears after the identifier (or function parms). */ 826 827static void 828dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags) 829{ 830 if (TYPE_PTRMEMFUNC_P (t)) 831 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 832 833 switch (TREE_CODE (t)) 834 { 835 case POINTER_TYPE: 836 case REFERENCE_TYPE: 837 case OFFSET_TYPE: 838 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE 839 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) 840 pp_cxx_right_paren (pp); 841 if (TREE_CODE (t) == POINTER_TYPE) 842 flags |= TFF_POINTER; 843 dump_type_suffix (pp, TREE_TYPE (t), flags); 844 break; 845 846 case FUNCTION_TYPE: 847 case METHOD_TYPE: 848 { 849 tree arg; 850 if (TREE_CODE (t) == METHOD_TYPE) 851 /* Can only be reached through a pointer. */ 852 pp_cxx_right_paren (pp); 853 arg = TYPE_ARG_TYPES (t); 854 if (TREE_CODE (t) == METHOD_TYPE) 855 arg = TREE_CHAIN (arg); 856 857 /* Function pointers don't have default args. Not in standard C++, 858 anyway; they may in g++, but we'll just pretend otherwise. */ 859 dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); 860 861 pp->padding = pp_before; 862 pp_cxx_cv_qualifiers (pp, type_memfn_quals (t), 863 TREE_CODE (t) == FUNCTION_TYPE 864 && (flags & TFF_POINTER)); 865 dump_ref_qualifier (pp, t, flags); 866 if (tx_safe_fn_type_p (t)) 867 pp_cxx_ws_string (pp, "transaction_safe"); 868 dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags); 869 dump_type_suffix (pp, TREE_TYPE (t), flags); 870 break; 871 } 872 873 case ARRAY_TYPE: 874 pp_maybe_space (pp); 875 pp_cxx_left_bracket (pp); 876 if (tree dtype = TYPE_DOMAIN (t)) 877 { 878 tree max = TYPE_MAX_VALUE (dtype); 879 /* Zero-length arrays have an upper bound of SIZE_MAX. */ 880 if (integer_all_onesp (max)) 881 pp_character (pp, '0'); 882 else if (tree_fits_shwi_p (max)) 883 pp_wide_integer (pp, tree_to_shwi (max) + 1); 884 else 885 { 886 STRIP_NOPS (max); 887 if (TREE_CODE (max) == SAVE_EXPR) 888 max = TREE_OPERAND (max, 0); 889 if (TREE_CODE (max) == MINUS_EXPR 890 || TREE_CODE (max) == PLUS_EXPR) 891 { 892 max = TREE_OPERAND (max, 0); 893 while (CONVERT_EXPR_P (max)) 894 max = TREE_OPERAND (max, 0); 895 } 896 else 897 max = fold_build2_loc (input_location, 898 PLUS_EXPR, dtype, max, 899 build_int_cst (dtype, 1)); 900 dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS); 901 } 902 } 903 pp_cxx_right_bracket (pp); 904 dump_type_suffix (pp, TREE_TYPE (t), flags); 905 break; 906 907 case ENUMERAL_TYPE: 908 case IDENTIFIER_NODE: 909 case INTEGER_TYPE: 910 case BOOLEAN_TYPE: 911 case REAL_TYPE: 912 case RECORD_TYPE: 913 case TEMPLATE_TYPE_PARM: 914 case TEMPLATE_TEMPLATE_PARM: 915 case BOUND_TEMPLATE_TEMPLATE_PARM: 916 case TREE_LIST: 917 case TYPE_DECL: 918 case TREE_VEC: 919 case UNION_TYPE: 920 case LANG_TYPE: 921 case VOID_TYPE: 922 case TYPENAME_TYPE: 923 case COMPLEX_TYPE: 924 case VECTOR_TYPE: 925 case TYPEOF_TYPE: 926 case UNDERLYING_TYPE: 927 case DECLTYPE_TYPE: 928 case TYPE_PACK_EXPANSION: 929 case FIXED_POINT_TYPE: 930 case NULLPTR_TYPE: 931 break; 932 933 default: 934 pp_unsupported_tree (pp, t); 935 case ERROR_MARK: 936 /* Don't mark it here, we should have already done in 937 dump_type_prefix. */ 938 break; 939 } 940} 941 942static void 943dump_global_iord (cxx_pretty_printer *pp, tree t) 944{ 945 const char *p = NULL; 946 947 if (DECL_GLOBAL_CTOR_P (t)) 948 p = M_("(static initializers for %s)"); 949 else if (DECL_GLOBAL_DTOR_P (t)) 950 p = M_("(static destructors for %s)"); 951 else 952 gcc_unreachable (); 953 954 pp_printf (pp, p, DECL_SOURCE_FILE (t)); 955} 956 957static void 958dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags) 959{ 960 if (flags & TFF_DECL_SPECIFIERS) 961 { 962 if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t)) 963 { 964 if (DECL_LANG_SPECIFIC (t) && DECL_DECLARED_CONCEPT_P (t)) 965 pp_cxx_ws_string (pp, "concept"); 966 else 967 pp_cxx_ws_string (pp, "constexpr"); 968 } 969 dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME); 970 pp_maybe_space (pp); 971 } 972 if (! (flags & TFF_UNQUALIFIED_NAME) 973 && TREE_CODE (t) != PARM_DECL 974 && (!DECL_INITIAL (t) 975 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)) 976 dump_scope (pp, CP_DECL_CONTEXT (t), flags); 977 flags &= ~TFF_UNQUALIFIED_NAME; 978 if ((flags & TFF_DECL_SPECIFIERS) 979 && DECL_TEMPLATE_PARM_P (t) 980 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t))) 981 pp_string (pp, "..."); 982 if (DECL_NAME (t)) 983 { 984 if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t)) 985 { 986 pp_less (pp); 987 pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2); 988 pp_string (pp, " capture>"); 989 } 990 else 991 dump_decl (pp, DECL_NAME (t), flags); 992 } 993 else 994 pp_string (pp, M_("<anonymous>")); 995 if (flags & TFF_DECL_SPECIFIERS) 996 dump_type_suffix (pp, type, flags); 997} 998 999/* Dump a human readable string for the decl T under control of FLAGS. */ 1000 1001static void 1002dump_decl (cxx_pretty_printer *pp, tree t, int flags) 1003{ 1004 if (t == NULL_TREE) 1005 return; 1006 1007 /* If doing Objective-C++, give Objective-C a chance to demangle 1008 Objective-C method names. */ 1009 if (c_dialect_objc ()) 1010 { 1011 const char *demangled = objc_maybe_printable_name (t, flags); 1012 if (demangled) 1013 { 1014 pp_string (pp, demangled); 1015 return; 1016 } 1017 } 1018 1019 switch (TREE_CODE (t)) 1020 { 1021 case TYPE_DECL: 1022 /* Don't say 'typedef class A' */ 1023 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t)) 1024 { 1025 if ((flags & TFF_DECL_SPECIFIERS) 1026 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) 1027 { 1028 /* Say `class T' not just `T'. */ 1029 pp_cxx_ws_string (pp, "class"); 1030 1031 /* Emit the `...' for a parameter pack. */ 1032 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) 1033 pp_cxx_ws_string (pp, "..."); 1034 } 1035 1036 dump_type (pp, TREE_TYPE (t), flags); 1037 break; 1038 } 1039 if (TYPE_DECL_ALIAS_P (t) 1040 && (flags & TFF_DECL_SPECIFIERS 1041 || flags & TFF_CLASS_KEY_OR_ENUM)) 1042 { 1043 pp_cxx_ws_string (pp, "using"); 1044 dump_decl (pp, DECL_NAME (t), flags); 1045 pp_cxx_whitespace (pp); 1046 pp_cxx_ws_string (pp, "="); 1047 pp_cxx_whitespace (pp); 1048 dump_type (pp, DECL_ORIGINAL_TYPE (t), flags); 1049 break; 1050 } 1051 if ((flags & TFF_DECL_SPECIFIERS) 1052 && !DECL_SELF_REFERENCE_P (t)) 1053 pp_cxx_ws_string (pp, "typedef"); 1054 dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t) 1055 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), 1056 flags); 1057 break; 1058 1059 case VAR_DECL: 1060 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) 1061 { 1062 pp_string (pp, M_("vtable for ")); 1063 gcc_assert (TYPE_P (DECL_CONTEXT (t))); 1064 dump_type (pp, DECL_CONTEXT (t), flags); 1065 break; 1066 } 1067 /* Else fall through. */ 1068 case FIELD_DECL: 1069 case PARM_DECL: 1070 dump_simple_decl (pp, t, TREE_TYPE (t), flags); 1071 1072 /* Handle variable template specializations. */ 1073 if (VAR_P (t) 1074 && DECL_LANG_SPECIFIC (t) 1075 && DECL_TEMPLATE_INFO (t) 1076 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))) 1077 { 1078 pp_cxx_begin_template_argument_list (pp); 1079 tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t)); 1080 dump_template_argument_list (pp, args, flags); 1081 pp_cxx_end_template_argument_list (pp); 1082 } 1083 break; 1084 1085 case RESULT_DECL: 1086 pp_string (pp, M_("<return value> ")); 1087 dump_simple_decl (pp, t, TREE_TYPE (t), flags); 1088 break; 1089 1090 case NAMESPACE_DECL: 1091 if (flags & TFF_DECL_SPECIFIERS) 1092 pp->declaration (t); 1093 else 1094 { 1095 if (! (flags & TFF_UNQUALIFIED_NAME)) 1096 dump_scope (pp, CP_DECL_CONTEXT (t), flags); 1097 flags &= ~TFF_UNQUALIFIED_NAME; 1098 if (DECL_NAME (t) == NULL_TREE) 1099 { 1100 if (!(pp->flags & pp_c_flag_gnu_v3)) 1101 pp_cxx_ws_string (pp, M_("{anonymous}")); 1102 else 1103 pp_cxx_ws_string (pp, M_("(anonymous namespace)")); 1104 } 1105 else 1106 pp_cxx_tree_identifier (pp, DECL_NAME (t)); 1107 } 1108 break; 1109 1110 case SCOPE_REF: 1111 dump_type (pp, TREE_OPERAND (t, 0), flags); 1112 pp_colon_colon (pp); 1113 dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME); 1114 break; 1115 1116 case ARRAY_REF: 1117 dump_decl (pp, TREE_OPERAND (t, 0), flags); 1118 pp_cxx_left_bracket (pp); 1119 dump_decl (pp, TREE_OPERAND (t, 1), flags); 1120 pp_cxx_right_bracket (pp); 1121 break; 1122 1123 case ARRAY_NOTATION_REF: 1124 dump_decl (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS); 1125 pp_cxx_left_bracket (pp); 1126 dump_decl (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS); 1127 pp_colon (pp); 1128 dump_decl (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS); 1129 pp_colon (pp); 1130 dump_decl (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS); 1131 pp_cxx_right_bracket (pp); 1132 break; 1133 1134 /* So that we can do dump_decl on an aggr type. */ 1135 case RECORD_TYPE: 1136 case UNION_TYPE: 1137 case ENUMERAL_TYPE: 1138 dump_type (pp, t, flags); 1139 break; 1140 1141 case BIT_NOT_EXPR: 1142 /* This is a pseudo destructor call which has not been folded into 1143 a PSEUDO_DTOR_EXPR yet. */ 1144 pp_cxx_complement (pp); 1145 dump_type (pp, TREE_OPERAND (t, 0), flags); 1146 break; 1147 1148 case TYPE_EXPR: 1149 gcc_unreachable (); 1150 break; 1151 1152 /* These special cases are duplicated here so that other functions 1153 can feed identifiers to error and get them demangled properly. */ 1154 case IDENTIFIER_NODE: 1155 if (IDENTIFIER_TYPENAME_P (t)) 1156 { 1157 pp_cxx_ws_string (pp, "operator"); 1158 /* Not exactly IDENTIFIER_TYPE_VALUE. */ 1159 dump_type (pp, TREE_TYPE (t), flags); 1160 break; 1161 } 1162 else 1163 pp_cxx_tree_identifier (pp, t); 1164 break; 1165 1166 case OVERLOAD: 1167 if (OVL_CHAIN (t)) 1168 { 1169 t = OVL_CURRENT (t); 1170 if (DECL_CLASS_SCOPE_P (t)) 1171 { 1172 dump_type (pp, DECL_CONTEXT (t), flags); 1173 pp_cxx_colon_colon (pp); 1174 } 1175 else if (!DECL_FILE_SCOPE_P (t)) 1176 { 1177 dump_decl (pp, DECL_CONTEXT (t), flags); 1178 pp_cxx_colon_colon (pp); 1179 } 1180 dump_decl (pp, DECL_NAME (t), flags); 1181 break; 1182 } 1183 1184 /* If there's only one function, just treat it like an ordinary 1185 FUNCTION_DECL. */ 1186 t = OVL_CURRENT (t); 1187 /* Fall through. */ 1188 1189 case FUNCTION_DECL: 1190 if (! DECL_LANG_SPECIFIC (t)) 1191 { 1192 if (DECL_ABSTRACT_ORIGIN (t)) 1193 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags); 1194 else 1195 pp_string (pp, M_("<built-in>")); 1196 } 1197 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) 1198 dump_global_iord (pp, t); 1199 else 1200 dump_function_decl (pp, t, flags); 1201 break; 1202 1203 case TEMPLATE_DECL: 1204 dump_template_decl (pp, t, flags); 1205 break; 1206 1207 case TEMPLATE_ID_EXPR: 1208 { 1209 tree name = TREE_OPERAND (t, 0); 1210 tree args = TREE_OPERAND (t, 1); 1211 1212 if (is_overloaded_fn (name)) 1213 name = get_first_fn (name); 1214 if (DECL_P (name)) 1215 name = DECL_NAME (name); 1216 dump_decl (pp, name, flags); 1217 pp_cxx_begin_template_argument_list (pp); 1218 if (args == error_mark_node) 1219 pp_string (pp, M_("<template arguments error>")); 1220 else if (args) 1221 dump_template_argument_list 1222 (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS); 1223 pp_cxx_end_template_argument_list (pp); 1224 } 1225 break; 1226 1227 case LABEL_DECL: 1228 pp_cxx_tree_identifier (pp, DECL_NAME (t)); 1229 break; 1230 1231 case CONST_DECL: 1232 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) 1233 || (DECL_INITIAL (t) && 1234 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) 1235 dump_simple_decl (pp, t, TREE_TYPE (t), flags); 1236 else if (DECL_NAME (t)) 1237 dump_decl (pp, DECL_NAME (t), flags); 1238 else if (DECL_INITIAL (t)) 1239 dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); 1240 else 1241 pp_string (pp, M_("<enumerator>")); 1242 break; 1243 1244 case USING_DECL: 1245 pp_cxx_ws_string (pp, "using"); 1246 dump_type (pp, USING_DECL_SCOPE (t), flags); 1247 pp_cxx_colon_colon (pp); 1248 dump_decl (pp, DECL_NAME (t), flags); 1249 break; 1250 1251 case STATIC_ASSERT: 1252 pp->declaration (t); 1253 break; 1254 1255 case BASELINK: 1256 dump_decl (pp, BASELINK_FUNCTIONS (t), flags); 1257 break; 1258 1259 case NON_DEPENDENT_EXPR: 1260 dump_expr (pp, t, flags); 1261 break; 1262 1263 case TEMPLATE_TYPE_PARM: 1264 if (flags & TFF_DECL_SPECIFIERS) 1265 pp->declaration (t); 1266 else 1267 pp->type_id (t); 1268 break; 1269 1270 case UNBOUND_CLASS_TEMPLATE: 1271 case TYPE_PACK_EXPANSION: 1272 case TREE_BINFO: 1273 dump_type (pp, t, flags); 1274 break; 1275 1276 default: 1277 pp_unsupported_tree (pp, t); 1278 /* Fall through to error. */ 1279 1280 case ERROR_MARK: 1281 pp_string (pp, M_("<declaration error>")); 1282 break; 1283 } 1284} 1285 1286/* Dump a template declaration T under control of FLAGS. This means the 1287 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ 1288 1289static void 1290dump_template_decl (cxx_pretty_printer *pp, tree t, int flags) 1291{ 1292 tree orig_parms = DECL_TEMPLATE_PARMS (t); 1293 tree parms; 1294 int i; 1295 1296 if (flags & TFF_TEMPLATE_HEADER) 1297 { 1298 for (parms = orig_parms = nreverse (orig_parms); 1299 parms; 1300 parms = TREE_CHAIN (parms)) 1301 { 1302 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); 1303 int len = TREE_VEC_LENGTH (inner_parms); 1304 1305 if (len == 0) 1306 { 1307 /* Skip over the dummy template levels of a template template 1308 parm. */ 1309 gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM); 1310 continue; 1311 } 1312 1313 pp_cxx_ws_string (pp, "template"); 1314 pp_cxx_begin_template_argument_list (pp); 1315 1316 /* If we've shown the template prefix, we'd better show the 1317 parameters' and decl's type too. */ 1318 flags |= TFF_DECL_SPECIFIERS; 1319 1320 for (i = 0; i < len; i++) 1321 { 1322 if (i) 1323 pp_separate_with_comma (pp); 1324 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i), 1325 flags); 1326 } 1327 pp_cxx_end_template_argument_list (pp); 1328 pp_cxx_whitespace (pp); 1329 } 1330 nreverse(orig_parms); 1331 1332 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 1333 { 1334 /* Say `template<arg> class TT' not just `template<arg> TT'. */ 1335 pp_cxx_ws_string (pp, "class"); 1336 1337 /* If this is a parameter pack, print the ellipsis. */ 1338 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) 1339 pp_cxx_ws_string (pp, "..."); 1340 } 1341 1342 /* Only print the requirements if we're also printing 1343 the template header. */ 1344 if (flag_concepts) 1345 if (tree ci = get_constraints (t)) 1346 if (check_constraint_info (ci)) 1347 if (tree reqs = CI_TEMPLATE_REQS (ci)) 1348 { 1349 pp_cxx_requires_clause (pp, reqs); 1350 pp_cxx_whitespace (pp); 1351 } 1352 } 1353 1354 1355 if (DECL_CLASS_TEMPLATE_P (t)) 1356 dump_type (pp, TREE_TYPE (t), 1357 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 1358 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); 1359 else if (DECL_TEMPLATE_RESULT (t) 1360 && (VAR_P (DECL_TEMPLATE_RESULT (t)) 1361 /* Alias template. */ 1362 || DECL_TYPE_TEMPLATE_P (t))) 1363 dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); 1364 else 1365 { 1366 gcc_assert (TREE_TYPE (t)); 1367 switch (NEXT_CODE (t)) 1368 { 1369 case METHOD_TYPE: 1370 case FUNCTION_TYPE: 1371 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME); 1372 break; 1373 default: 1374 /* This case can occur with some invalid code. */ 1375 dump_type (pp, TREE_TYPE (t), 1376 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 1377 | (flags & TFF_DECL_SPECIFIERS 1378 ? TFF_CLASS_KEY_OR_ENUM : 0)); 1379 } 1380 } 1381} 1382 1383/* find_typenames looks through the type of the function template T 1384 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs 1385 it finds. */ 1386 1387struct find_typenames_t 1388{ 1389 hash_set<tree> *p_set; 1390 vec<tree, va_gc> *typenames; 1391}; 1392 1393static tree 1394find_typenames_r (tree *tp, int *walk_subtrees, void *data) 1395{ 1396 struct find_typenames_t *d = (struct find_typenames_t *)data; 1397 tree mv = NULL_TREE; 1398 1399 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp))) 1400 /* Add the type of the typedef without any additional cv-quals. */ 1401 mv = TREE_TYPE (TYPE_NAME (*tp)); 1402 else if (TREE_CODE (*tp) == TYPENAME_TYPE 1403 || TREE_CODE (*tp) == DECLTYPE_TYPE) 1404 /* Add the typename without any cv-qualifiers. */ 1405 mv = TYPE_MAIN_VARIANT (*tp); 1406 1407 if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION) 1408 { 1409 /* Don't mess with parameter packs since we don't remember 1410 the pack expansion context for a particular typename. */ 1411 *walk_subtrees = false; 1412 return NULL_TREE; 1413 } 1414 1415 if (mv && (mv == *tp || !d->p_set->add (mv))) 1416 vec_safe_push (d->typenames, mv); 1417 1418 /* Search into class template arguments, which cp_walk_subtrees 1419 doesn't do. */ 1420 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp)) 1421 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r, 1422 data, d->p_set); 1423 1424 return NULL_TREE; 1425} 1426 1427static vec<tree, va_gc> * 1428find_typenames (tree t) 1429{ 1430 struct find_typenames_t ft; 1431 ft.p_set = new hash_set<tree>; 1432 ft.typenames = NULL; 1433 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)), 1434 find_typenames_r, &ft, ft.p_set); 1435 delete ft.p_set; 1436 return ft.typenames; 1437} 1438 1439/* Output the "[with ...]" clause for a template instantiation T iff 1440 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if 1441 formatting a deduction/substitution diagnostic rather than an 1442 instantiation. */ 1443 1444static void 1445dump_substitution (cxx_pretty_printer *pp, 1446 tree t, tree template_parms, tree template_args, 1447 int flags) 1448{ 1449 if (template_parms != NULL_TREE && template_args != NULL_TREE 1450 && !(flags & TFF_NO_TEMPLATE_BINDINGS)) 1451 { 1452 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL; 1453 pp_cxx_whitespace (pp); 1454 pp_cxx_left_bracket (pp); 1455 pp->translate_string ("with"); 1456 pp_cxx_whitespace (pp); 1457 dump_template_bindings (pp, template_parms, template_args, typenames); 1458 pp_cxx_right_bracket (pp); 1459 } 1460} 1461 1462/* Dump the lambda function FN including its 'mutable' qualifier and any 1463 template bindings. */ 1464 1465static void 1466dump_lambda_function (cxx_pretty_printer *pp, 1467 tree fn, tree template_parms, tree template_args, 1468 int flags) 1469{ 1470 /* A lambda's signature is essentially its "type". */ 1471 dump_type (pp, DECL_CONTEXT (fn), flags); 1472 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST)) 1473 { 1474 pp->padding = pp_before; 1475 pp_c_ws_string (pp, "mutable"); 1476 } 1477 dump_substitution (pp, fn, template_parms, template_args, flags); 1478} 1479 1480/* Pretty print a function decl. There are several ways we want to print a 1481 function declaration. The TFF_ bits in FLAGS tells us how to behave. 1482 As error can only apply the '#' flag once to give 0 and 1 for V, there 1483 is %D which doesn't print the throw specs, and %F which does. */ 1484 1485static void 1486dump_function_decl (cxx_pretty_printer *pp, tree t, int flags) 1487{ 1488 tree fntype; 1489 tree parmtypes; 1490 tree cname = NULL_TREE; 1491 tree template_args = NULL_TREE; 1492 tree template_parms = NULL_TREE; 1493 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; 1494 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME); 1495 tree exceptions; 1496 1497 flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME); 1498 if (TREE_CODE (t) == TEMPLATE_DECL) 1499 t = DECL_TEMPLATE_RESULT (t); 1500 1501 /* Save the exceptions, in case t is a specialization and we are 1502 emitting an error about incompatible specifications. */ 1503 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t)); 1504 1505 /* Pretty print template instantiations only. */ 1506 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t) 1507 && flag_pretty_templates) 1508 { 1509 tree tmpl; 1510 1511 template_args = DECL_TI_ARGS (t); 1512 tmpl = most_general_template (t); 1513 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) 1514 { 1515 template_parms = DECL_TEMPLATE_PARMS (tmpl); 1516 t = tmpl; 1517 } 1518 } 1519 1520 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t)) 1521 return dump_lambda_function (pp, t, template_parms, template_args, flags); 1522 1523 fntype = TREE_TYPE (t); 1524 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); 1525 1526 if (DECL_CLASS_SCOPE_P (t)) 1527 cname = DECL_CONTEXT (t); 1528 /* This is for partially instantiated template methods. */ 1529 else if (TREE_CODE (fntype) == METHOD_TYPE) 1530 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 1531 1532 if (flags & TFF_DECL_SPECIFIERS) 1533 { 1534 if (DECL_STATIC_FUNCTION_P (t)) 1535 pp_cxx_ws_string (pp, "static"); 1536 else if (DECL_VIRTUAL_P (t)) 1537 pp_cxx_ws_string (pp, "virtual"); 1538 1539 if (DECL_DECLARED_CONSTEXPR_P (t)) 1540 { 1541 if (DECL_DECLARED_CONCEPT_P (t)) 1542 pp_cxx_ws_string (pp, "concept"); 1543 else 1544 pp_cxx_ws_string (pp, "constexpr"); 1545 } 1546 } 1547 1548 /* Print the return type? */ 1549 if (show_return) 1550 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) 1551 && !DECL_DESTRUCTOR_P (t); 1552 if (show_return) 1553 { 1554 tree ret = fndecl_declared_return_type (t); 1555 dump_type_prefix (pp, ret, flags); 1556 } 1557 1558 /* Print the function name. */ 1559 if (!do_outer_scope) 1560 /* Nothing. */; 1561 else if (cname) 1562 { 1563 dump_type (pp, cname, flags); 1564 pp_cxx_colon_colon (pp); 1565 } 1566 else 1567 dump_scope (pp, CP_DECL_CONTEXT (t), flags); 1568 1569 dump_function_name (pp, t, flags); 1570 1571 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) 1572 { 1573 dump_parameters (pp, parmtypes, flags); 1574 1575 if (TREE_CODE (fntype) == METHOD_TYPE) 1576 { 1577 pp->padding = pp_before; 1578 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype)); 1579 dump_ref_qualifier (pp, fntype, flags); 1580 } 1581 1582 if (tx_safe_fn_type_p (fntype)) 1583 { 1584 pp->padding = pp_before; 1585 pp_cxx_ws_string (pp, "transaction_safe"); 1586 } 1587 1588 if (flags & TFF_EXCEPTION_SPECIFICATION) 1589 { 1590 pp->padding = pp_before; 1591 dump_exception_spec (pp, exceptions, flags); 1592 } 1593 1594 if (show_return) 1595 dump_type_suffix (pp, TREE_TYPE (fntype), flags); 1596 1597 if (flag_concepts) 1598 if (tree ci = get_constraints (t)) 1599 if (tree reqs = CI_DECLARATOR_REQS (ci)) 1600 pp_cxx_requires_clause (pp, reqs); 1601 1602 dump_substitution (pp, t, template_parms, template_args, flags); 1603 } 1604 else if (template_args) 1605 { 1606 bool need_comma = false; 1607 int i; 1608 pp_cxx_begin_template_argument_list (pp); 1609 template_args = INNERMOST_TEMPLATE_ARGS (template_args); 1610 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i) 1611 { 1612 tree arg = TREE_VEC_ELT (template_args, i); 1613 if (need_comma) 1614 pp_separate_with_comma (pp); 1615 if (ARGUMENT_PACK_P (arg)) 1616 pp_cxx_left_brace (pp); 1617 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER); 1618 if (ARGUMENT_PACK_P (arg)) 1619 pp_cxx_right_brace (pp); 1620 need_comma = true; 1621 } 1622 pp_cxx_end_template_argument_list (pp); 1623 } 1624} 1625 1626/* Print a parameter list. If this is for a member function, the 1627 member object ptr (and any other hidden args) should have 1628 already been removed. */ 1629 1630static void 1631dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags) 1632{ 1633 int first = 1; 1634 flags &= ~TFF_SCOPE; 1635 pp_cxx_left_paren (pp); 1636 1637 for (first = 1; parmtypes != void_list_node; 1638 parmtypes = TREE_CHAIN (parmtypes)) 1639 { 1640 if (!first) 1641 pp_separate_with_comma (pp); 1642 first = 0; 1643 if (!parmtypes) 1644 { 1645 pp_cxx_ws_string (pp, "..."); 1646 break; 1647 } 1648 1649 dump_type (pp, TREE_VALUE (parmtypes), flags); 1650 1651 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) 1652 { 1653 pp_cxx_whitespace (pp); 1654 pp_equal (pp); 1655 pp_cxx_whitespace (pp); 1656 dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); 1657 } 1658 } 1659 1660 pp_cxx_right_paren (pp); 1661} 1662 1663/* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */ 1664 1665static void 1666dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED) 1667{ 1668 if (FUNCTION_REF_QUALIFIED (t)) 1669 { 1670 pp->padding = pp_before; 1671 if (FUNCTION_RVALUE_QUALIFIED (t)) 1672 pp_cxx_ws_string (pp, "&&"); 1673 else 1674 pp_cxx_ws_string (pp, "&"); 1675 } 1676} 1677 1678/* Print an exception specification. T is the exception specification. */ 1679 1680static void 1681dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags) 1682{ 1683 if (t && TREE_PURPOSE (t)) 1684 { 1685 pp_cxx_ws_string (pp, "noexcept"); 1686 if (!integer_onep (TREE_PURPOSE (t))) 1687 { 1688 pp_cxx_whitespace (pp); 1689 pp_cxx_left_paren (pp); 1690 if (DEFERRED_NOEXCEPT_SPEC_P (t)) 1691 pp_cxx_ws_string (pp, "<uninstantiated>"); 1692 else 1693 dump_expr (pp, TREE_PURPOSE (t), flags); 1694 pp_cxx_right_paren (pp); 1695 } 1696 } 1697 else if (t) 1698 { 1699 pp_cxx_ws_string (pp, "throw"); 1700 pp_cxx_whitespace (pp); 1701 pp_cxx_left_paren (pp); 1702 if (TREE_VALUE (t) != NULL_TREE) 1703 while (1) 1704 { 1705 dump_type (pp, TREE_VALUE (t), flags); 1706 t = TREE_CHAIN (t); 1707 if (!t) 1708 break; 1709 pp_separate_with_comma (pp); 1710 } 1711 pp_cxx_right_paren (pp); 1712 } 1713} 1714 1715/* Handle the function name for a FUNCTION_DECL node, grokking operators 1716 and destructors properly. */ 1717 1718static void 1719dump_function_name (cxx_pretty_printer *pp, tree t, int flags) 1720{ 1721 tree name = DECL_NAME (t); 1722 1723 /* We can get here with a decl that was synthesized by language- 1724 independent machinery (e.g. coverage.c) in which case it won't 1725 have a lang_specific structure attached and DECL_CONSTRUCTOR_P 1726 will crash. In this case it is safe just to print out the 1727 literal name. */ 1728 if (!DECL_LANG_SPECIFIC (t)) 1729 { 1730 pp_cxx_tree_identifier (pp, name); 1731 return; 1732 } 1733 1734 if (TREE_CODE (t) == TEMPLATE_DECL) 1735 t = DECL_TEMPLATE_RESULT (t); 1736 1737 /* Don't let the user see __comp_ctor et al. */ 1738 if (DECL_CONSTRUCTOR_P (t) 1739 || DECL_DESTRUCTOR_P (t)) 1740 { 1741 if (LAMBDA_TYPE_P (DECL_CONTEXT (t))) 1742 name = get_identifier ("<lambda>"); 1743 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t))) 1744 name = get_identifier ("<constructor>"); 1745 else 1746 name = constructor_name (DECL_CONTEXT (t)); 1747 } 1748 1749 if (DECL_DESTRUCTOR_P (t)) 1750 { 1751 pp_cxx_complement (pp); 1752 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER); 1753 } 1754 else if (DECL_CONV_FN_P (t)) 1755 { 1756 /* This cannot use the hack that the operator's return 1757 type is stashed off of its name because it may be 1758 used for error reporting. In the case of conflicting 1759 declarations, both will have the same name, yet 1760 the types will be different, hence the TREE_TYPE field 1761 of the first name will be clobbered by the second. */ 1762 pp_cxx_ws_string (pp, "operator"); 1763 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags); 1764 } 1765 else if (name && IDENTIFIER_OPNAME_P (name)) 1766 pp_cxx_tree_identifier (pp, name); 1767 else if (name && UDLIT_OPER_P (name)) 1768 pp_cxx_tree_identifier (pp, name); 1769 else 1770 dump_decl (pp, name, flags); 1771 1772 if (DECL_TEMPLATE_INFO (t) 1773 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) 1774 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1775 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1776 dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), 1777 flags); 1778} 1779 1780/* Dump the template parameters from the template info INFO under control of 1781 FLAGS. PRIMARY indicates whether this is a primary template decl, or 1782 specialization (partial or complete). For partial specializations we show 1783 the specialized parameter values. For a primary template we show no 1784 decoration. */ 1785 1786static void 1787dump_template_parms (cxx_pretty_printer *pp, tree info, 1788 int primary, int flags) 1789{ 1790 tree args = info ? TI_ARGS (info) : NULL_TREE; 1791 1792 if (primary && flags & TFF_TEMPLATE_NAME) 1793 return; 1794 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); 1795 pp_cxx_begin_template_argument_list (pp); 1796 1797 /* Be careful only to print things when we have them, so as not 1798 to crash producing error messages. */ 1799 if (args && !primary) 1800 { 1801 int len, ix; 1802 len = get_non_default_template_args_count (args, flags); 1803 1804 args = INNERMOST_TEMPLATE_ARGS (args); 1805 for (ix = 0; ix != len; ix++) 1806 { 1807 tree arg = TREE_VEC_ELT (args, ix); 1808 1809 /* Only print a comma if we know there is an argument coming. In 1810 the case of an empty template argument pack, no actual 1811 argument will be printed. */ 1812 if (ix 1813 && (!ARGUMENT_PACK_P (arg) 1814 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0)) 1815 pp_separate_with_comma (pp); 1816 1817 if (!arg) 1818 pp_string (pp, M_("<template parameter error>")); 1819 else 1820 dump_template_argument (pp, arg, flags); 1821 } 1822 } 1823 else if (primary) 1824 { 1825 tree tpl = TI_TEMPLATE (info); 1826 tree parms = DECL_TEMPLATE_PARMS (tpl); 1827 int len, ix; 1828 1829 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE; 1830 len = parms ? TREE_VEC_LENGTH (parms) : 0; 1831 1832 for (ix = 0; ix != len; ix++) 1833 { 1834 tree parm; 1835 1836 if (TREE_VEC_ELT (parms, ix) == error_mark_node) 1837 { 1838 pp_string (pp, M_("<template parameter error>")); 1839 continue; 1840 } 1841 1842 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix)); 1843 1844 if (ix) 1845 pp_separate_with_comma (pp); 1846 1847 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS); 1848 } 1849 } 1850 pp_cxx_end_template_argument_list (pp); 1851} 1852 1853/* Print out the arguments of CALL_EXPR T as a parenthesized list using 1854 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */ 1855 1856static void 1857dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst) 1858{ 1859 tree arg; 1860 call_expr_arg_iterator iter; 1861 1862 pp_cxx_left_paren (pp); 1863 FOR_EACH_CALL_EXPR_ARG (arg, iter, t) 1864 { 1865 if (skipfirst) 1866 skipfirst = false; 1867 else 1868 { 1869 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS); 1870 if (more_call_expr_args_p (&iter)) 1871 pp_separate_with_comma (pp); 1872 } 1873 } 1874 pp_cxx_right_paren (pp); 1875} 1876 1877/* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list 1878 using flags FLAGS. Skip over the first argument if SKIPFIRST is 1879 true. */ 1880 1881static void 1882dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags, 1883 bool skipfirst) 1884{ 1885 tree arg; 1886 aggr_init_expr_arg_iterator iter; 1887 1888 pp_cxx_left_paren (pp); 1889 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) 1890 { 1891 if (skipfirst) 1892 skipfirst = false; 1893 else 1894 { 1895 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS); 1896 if (more_aggr_init_expr_args_p (&iter)) 1897 pp_separate_with_comma (pp); 1898 } 1899 } 1900 pp_cxx_right_paren (pp); 1901} 1902 1903/* Print out a list of initializers (subr of dump_expr). */ 1904 1905static void 1906dump_expr_list (cxx_pretty_printer *pp, tree l, int flags) 1907{ 1908 while (l) 1909 { 1910 dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS); 1911 l = TREE_CHAIN (l); 1912 if (l) 1913 pp_separate_with_comma (pp); 1914 } 1915} 1916 1917/* Print out a vector of initializers (subr of dump_expr). */ 1918 1919static void 1920dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v, 1921 int flags) 1922{ 1923 unsigned HOST_WIDE_INT idx; 1924 tree value; 1925 1926 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1927 { 1928 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS); 1929 if (idx != v->length () - 1) 1930 pp_separate_with_comma (pp); 1931 } 1932} 1933 1934 1935/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual 1936 function. Resolve it to a close relative -- in the sense of static 1937 type -- variant being overridden. That is close to what was written in 1938 the source code. Subroutine of dump_expr. */ 1939 1940static tree 1941resolve_virtual_fun_from_obj_type_ref (tree ref) 1942{ 1943 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref)); 1944 HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref)); 1945 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type))); 1946 while (index) 1947 { 1948 fun = TREE_CHAIN (fun); 1949 index -= (TARGET_VTABLE_USES_DESCRIPTORS 1950 ? TARGET_VTABLE_USES_DESCRIPTORS : 1); 1951 } 1952 1953 return BV_FN (fun); 1954} 1955 1956/* Print out an expression E under control of FLAGS. */ 1957 1958static void 1959dump_expr (cxx_pretty_printer *pp, tree t, int flags) 1960{ 1961 tree op; 1962 1963 if (t == 0) 1964 return; 1965 1966 if (STATEMENT_CLASS_P (t)) 1967 { 1968 pp_cxx_ws_string (pp, M_("<statement>")); 1969 return; 1970 } 1971 1972 switch (TREE_CODE (t)) 1973 { 1974 case VAR_DECL: 1975 case PARM_DECL: 1976 case FIELD_DECL: 1977 case CONST_DECL: 1978 case FUNCTION_DECL: 1979 case TEMPLATE_DECL: 1980 case NAMESPACE_DECL: 1981 case LABEL_DECL: 1982 case OVERLOAD: 1983 case TYPE_DECL: 1984 case IDENTIFIER_NODE: 1985 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE 1986 |TFF_TEMPLATE_HEADER)) 1987 | TFF_NO_FUNCTION_ARGUMENTS)); 1988 break; 1989 1990 case SSA_NAME: 1991 if (SSA_NAME_VAR (t) 1992 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t))) 1993 dump_expr (pp, SSA_NAME_VAR (t), flags); 1994 else 1995 pp_cxx_ws_string (pp, M_("<unknown>")); 1996 break; 1997 1998 case VOID_CST: 1999 case INTEGER_CST: 2000 case REAL_CST: 2001 case STRING_CST: 2002 case COMPLEX_CST: 2003 pp->constant (t); 2004 break; 2005 2006 case USERDEF_LITERAL: 2007 pp_cxx_userdef_literal (pp, t); 2008 break; 2009 2010 case THROW_EXPR: 2011 /* While waiting for caret diagnostics, avoid printing 2012 __cxa_allocate_exception, __cxa_throw, and the like. */ 2013 pp_cxx_ws_string (pp, M_("<throw-expression>")); 2014 break; 2015 2016 case PTRMEM_CST: 2017 pp_ampersand (pp); 2018 dump_type (pp, PTRMEM_CST_CLASS (t), flags); 2019 pp_cxx_colon_colon (pp); 2020 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); 2021 break; 2022 2023 case COMPOUND_EXPR: 2024 pp_cxx_left_paren (pp); 2025 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2026 pp_separate_with_comma (pp); 2027 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2028 pp_cxx_right_paren (pp); 2029 break; 2030 2031 case COND_EXPR: 2032 case VEC_COND_EXPR: 2033 pp_cxx_left_paren (pp); 2034 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2035 pp_string (pp, " ? "); 2036 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2037 pp_string (pp, " : "); 2038 dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); 2039 pp_cxx_right_paren (pp); 2040 break; 2041 2042 case SAVE_EXPR: 2043 if (TREE_HAS_CONSTRUCTOR (t)) 2044 { 2045 pp_cxx_ws_string (pp, "new"); 2046 pp_cxx_whitespace (pp); 2047 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags); 2048 } 2049 else 2050 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2051 break; 2052 2053 case AGGR_INIT_EXPR: 2054 { 2055 tree fn = NULL_TREE; 2056 2057 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR) 2058 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0); 2059 2060 if (fn && TREE_CODE (fn) == FUNCTION_DECL) 2061 { 2062 if (DECL_CONSTRUCTOR_P (fn)) 2063 dump_type (pp, DECL_CONTEXT (fn), flags); 2064 else 2065 dump_decl (pp, fn, 0); 2066 } 2067 else 2068 dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0); 2069 } 2070 dump_aggr_init_expr_args (pp, t, flags, true); 2071 break; 2072 2073 case CALL_EXPR: 2074 { 2075 tree fn = CALL_EXPR_FN (t); 2076 bool skipfirst = false; 2077 2078 /* Deal with internal functions. */ 2079 if (fn == NULL_TREE) 2080 { 2081 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t))); 2082 dump_call_expr_args (pp, t, flags, skipfirst); 2083 break; 2084 } 2085 2086 if (TREE_CODE (fn) == ADDR_EXPR) 2087 fn = TREE_OPERAND (fn, 0); 2088 2089 /* Nobody is interested in seeing the guts of vcalls. */ 2090 if (TREE_CODE (fn) == OBJ_TYPE_REF) 2091 fn = resolve_virtual_fun_from_obj_type_ref (fn); 2092 2093 if (TREE_TYPE (fn) != NULL_TREE 2094 && NEXT_CODE (fn) == METHOD_TYPE 2095 && call_expr_nargs (t)) 2096 { 2097 tree ob = CALL_EXPR_ARG (t, 0); 2098 if (TREE_CODE (ob) == ADDR_EXPR) 2099 { 2100 dump_expr (pp, TREE_OPERAND (ob, 0), 2101 flags | TFF_EXPR_IN_PARENS); 2102 pp_cxx_dot (pp); 2103 } 2104 else if (TREE_CODE (ob) != PARM_DECL 2105 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 2106 { 2107 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS); 2108 pp_cxx_arrow (pp); 2109 } 2110 skipfirst = true; 2111 } 2112 if (flag_sanitize & SANITIZE_UNDEFINED 2113 && is_ubsan_builtin_p (fn)) 2114 { 2115 pp_string (cxx_pp, M_("<ubsan routine call>")); 2116 break; 2117 } 2118 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS); 2119 dump_call_expr_args (pp, t, flags, skipfirst); 2120 } 2121 break; 2122 2123 case TARGET_EXPR: 2124 /* Note that this only works for G++ target exprs. If somebody 2125 builds a general TARGET_EXPR, there's no way to represent that 2126 it initializes anything other that the parameter slot for the 2127 default argument. Note we may have cleared out the first 2128 operand in expand_expr, so don't go killing ourselves. */ 2129 if (TREE_OPERAND (t, 1)) 2130 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2131 break; 2132 2133 case POINTER_PLUS_EXPR: 2134 dump_binary_op (pp, "+", t, flags); 2135 break; 2136 2137 case INIT_EXPR: 2138 case MODIFY_EXPR: 2139 dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name, 2140 t, flags); 2141 break; 2142 2143 case PLUS_EXPR: 2144 case MINUS_EXPR: 2145 case MULT_EXPR: 2146 case TRUNC_DIV_EXPR: 2147 case TRUNC_MOD_EXPR: 2148 case MIN_EXPR: 2149 case MAX_EXPR: 2150 case LSHIFT_EXPR: 2151 case RSHIFT_EXPR: 2152 case BIT_IOR_EXPR: 2153 case BIT_XOR_EXPR: 2154 case BIT_AND_EXPR: 2155 case TRUTH_ANDIF_EXPR: 2156 case TRUTH_ORIF_EXPR: 2157 case LT_EXPR: 2158 case LE_EXPR: 2159 case GT_EXPR: 2160 case GE_EXPR: 2161 case EQ_EXPR: 2162 case NE_EXPR: 2163 case EXACT_DIV_EXPR: 2164 dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags); 2165 break; 2166 2167 case CEIL_DIV_EXPR: 2168 case FLOOR_DIV_EXPR: 2169 case ROUND_DIV_EXPR: 2170 case RDIV_EXPR: 2171 dump_binary_op (pp, "/", t, flags); 2172 break; 2173 2174 case CEIL_MOD_EXPR: 2175 case FLOOR_MOD_EXPR: 2176 case ROUND_MOD_EXPR: 2177 dump_binary_op (pp, "%", t, flags); 2178 break; 2179 2180 case COMPONENT_REF: 2181 { 2182 tree ob = TREE_OPERAND (t, 0); 2183 if (INDIRECT_REF_P (ob)) 2184 { 2185 ob = TREE_OPERAND (ob, 0); 2186 if (TREE_CODE (ob) != PARM_DECL 2187 || (DECL_NAME (ob) 2188 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))) 2189 { 2190 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS); 2191 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE) 2192 pp_cxx_dot (pp); 2193 else 2194 pp_cxx_arrow (pp); 2195 } 2196 } 2197 else 2198 { 2199 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS); 2200 pp_cxx_dot (pp); 2201 } 2202 dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); 2203 } 2204 break; 2205 2206 case ARRAY_REF: 2207 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2208 pp_cxx_left_bracket (pp); 2209 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2210 pp_cxx_right_bracket (pp); 2211 break; 2212 2213 case ARRAY_NOTATION_REF: 2214 dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS); 2215 pp_cxx_left_bracket (pp); 2216 dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS); 2217 pp_colon (pp); 2218 dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS); 2219 pp_colon (pp); 2220 dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS); 2221 pp_cxx_right_bracket (pp); 2222 break; 2223 2224 case UNARY_PLUS_EXPR: 2225 dump_unary_op (pp, "+", t, flags); 2226 break; 2227 2228 case ADDR_EXPR: 2229 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 2230 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST 2231 /* An ADDR_EXPR can have reference type. In that case, we 2232 shouldn't print the `&' doing so indicates to the user 2233 that the expression has pointer type. */ 2234 || (TREE_TYPE (t) 2235 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)) 2236 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2237 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL) 2238 dump_unary_op (pp, "&&", t, flags); 2239 else 2240 dump_unary_op (pp, "&", t, flags); 2241 break; 2242 2243 case INDIRECT_REF: 2244 if (TREE_HAS_CONSTRUCTOR (t)) 2245 { 2246 t = TREE_OPERAND (t, 0); 2247 gcc_assert (TREE_CODE (t) == CALL_EXPR); 2248 dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS); 2249 dump_call_expr_args (pp, t, flags, true); 2250 } 2251 else 2252 { 2253 if (TREE_OPERAND (t,0) != NULL_TREE 2254 && TREE_TYPE (TREE_OPERAND (t, 0)) 2255 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 2256 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2257 else 2258 dump_unary_op (pp, "*", t, flags); 2259 } 2260 break; 2261 2262 case MEM_REF: 2263 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR 2264 && integer_zerop (TREE_OPERAND (t, 1))) 2265 dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags); 2266 else 2267 { 2268 pp_cxx_star (pp); 2269 if (!integer_zerop (TREE_OPERAND (t, 1))) 2270 { 2271 pp_cxx_left_paren (pp); 2272 if (!integer_onep (TYPE_SIZE_UNIT 2273 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)))))) 2274 { 2275 pp_cxx_left_paren (pp); 2276 dump_type (pp, ptr_type_node, flags); 2277 pp_cxx_right_paren (pp); 2278 } 2279 } 2280 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2281 if (!integer_zerop (TREE_OPERAND (t, 1))) 2282 { 2283 pp_cxx_ws_string (pp, "+"); 2284 dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)), 2285 flags); 2286 pp_cxx_right_paren (pp); 2287 } 2288 } 2289 break; 2290 2291 case NEGATE_EXPR: 2292 case BIT_NOT_EXPR: 2293 case TRUTH_NOT_EXPR: 2294 case PREDECREMENT_EXPR: 2295 case PREINCREMENT_EXPR: 2296 dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags); 2297 break; 2298 2299 case POSTDECREMENT_EXPR: 2300 case POSTINCREMENT_EXPR: 2301 pp_cxx_left_paren (pp); 2302 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2303 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name); 2304 pp_cxx_right_paren (pp); 2305 break; 2306 2307 case NON_LVALUE_EXPR: 2308 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 2309 should be another level of INDIRECT_REF so that I don't have to do 2310 this. */ 2311 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 2312 { 2313 tree next = TREE_TYPE (TREE_TYPE (t)); 2314 2315 while (TYPE_PTR_P (next)) 2316 next = TREE_TYPE (next); 2317 2318 if (TREE_CODE (next) == FUNCTION_TYPE) 2319 { 2320 if (flags & TFF_EXPR_IN_PARENS) 2321 pp_cxx_left_paren (pp); 2322 pp_cxx_star (pp); 2323 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2324 if (flags & TFF_EXPR_IN_PARENS) 2325 pp_cxx_right_paren (pp); 2326 break; 2327 } 2328 /* Else fall through. */ 2329 } 2330 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2331 break; 2332 2333 CASE_CONVERT: 2334 case IMPLICIT_CONV_EXPR: 2335 case VIEW_CONVERT_EXPR: 2336 { 2337 tree op = TREE_OPERAND (t, 0); 2338 tree ttype = TREE_TYPE (t); 2339 tree optype = TREE_TYPE (op); 2340 2341 if (TREE_CODE (ttype) != TREE_CODE (optype) 2342 && POINTER_TYPE_P (ttype) 2343 && POINTER_TYPE_P (optype) 2344 && same_type_p (TREE_TYPE (optype), 2345 TREE_TYPE (ttype))) 2346 { 2347 if (TREE_CODE (ttype) == REFERENCE_TYPE) 2348 { 2349 STRIP_NOPS (op); 2350 if (TREE_CODE (op) == ADDR_EXPR) 2351 dump_expr (pp, TREE_OPERAND (op, 0), flags); 2352 else 2353 dump_unary_op (pp, "*", t, flags); 2354 } 2355 else 2356 dump_unary_op (pp, "&", t, flags); 2357 } 2358 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))) 2359 { 2360 /* It is a cast, but we cannot tell whether it is a 2361 reinterpret or static cast. Use the C style notation. */ 2362 if (flags & TFF_EXPR_IN_PARENS) 2363 pp_cxx_left_paren (pp); 2364 pp_cxx_left_paren (pp); 2365 dump_type (pp, TREE_TYPE (t), flags); 2366 pp_cxx_right_paren (pp); 2367 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS); 2368 if (flags & TFF_EXPR_IN_PARENS) 2369 pp_cxx_right_paren (pp); 2370 } 2371 else 2372 dump_expr (pp, op, flags); 2373 break; 2374 } 2375 2376 case CONSTRUCTOR: 2377 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 2378 { 2379 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier); 2380 2381 if (integer_zerop (idx)) 2382 { 2383 /* A NULL pointer-to-member constant. */ 2384 pp_cxx_left_paren (pp); 2385 pp_cxx_left_paren (pp); 2386 dump_type (pp, TREE_TYPE (t), flags); 2387 pp_cxx_right_paren (pp); 2388 pp_character (pp, '0'); 2389 pp_cxx_right_paren (pp); 2390 break; 2391 } 2392 else if (tree_fits_shwi_p (idx)) 2393 { 2394 tree virtuals; 2395 unsigned HOST_WIDE_INT n; 2396 2397 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 2398 t = TYPE_METHOD_BASETYPE (t); 2399 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 2400 2401 n = tree_to_shwi (idx); 2402 2403 /* Map vtable index back one, to allow for the null pointer to 2404 member. */ 2405 --n; 2406 2407 while (n > 0 && virtuals) 2408 { 2409 --n; 2410 virtuals = TREE_CHAIN (virtuals); 2411 } 2412 if (virtuals) 2413 { 2414 dump_expr (pp, BV_FN (virtuals), 2415 flags | TFF_EXPR_IN_PARENS); 2416 break; 2417 } 2418 } 2419 } 2420 if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t))) 2421 pp_string (pp, "<lambda closure object>"); 2422 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t)) 2423 { 2424 dump_type (pp, TREE_TYPE (t), 0); 2425 pp_cxx_left_paren (pp); 2426 pp_cxx_right_paren (pp); 2427 } 2428 else 2429 { 2430 if (!BRACE_ENCLOSED_INITIALIZER_P (t)) 2431 dump_type (pp, TREE_TYPE (t), 0); 2432 pp_cxx_left_brace (pp); 2433 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags); 2434 pp_cxx_right_brace (pp); 2435 } 2436 2437 break; 2438 2439 case OFFSET_REF: 2440 { 2441 tree ob = TREE_OPERAND (t, 0); 2442 if (is_dummy_object (ob)) 2443 { 2444 t = TREE_OPERAND (t, 1); 2445 if (TREE_CODE (t) == FUNCTION_DECL) 2446 /* A::f */ 2447 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS); 2448 else if (BASELINK_P (t)) 2449 dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)), 2450 flags | TFF_EXPR_IN_PARENS); 2451 else 2452 dump_decl (pp, t, flags); 2453 } 2454 else 2455 { 2456 if (INDIRECT_REF_P (ob)) 2457 { 2458 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 2459 pp_cxx_arrow (pp); 2460 pp_cxx_star (pp); 2461 } 2462 else 2463 { 2464 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS); 2465 pp_cxx_dot (pp); 2466 pp_cxx_star (pp); 2467 } 2468 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2469 } 2470 break; 2471 } 2472 2473 case TEMPLATE_PARM_INDEX: 2474 dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS); 2475 break; 2476 2477 case CAST_EXPR: 2478 if (TREE_OPERAND (t, 0) == NULL_TREE 2479 || TREE_CHAIN (TREE_OPERAND (t, 0))) 2480 { 2481 dump_type (pp, TREE_TYPE (t), flags); 2482 pp_cxx_left_paren (pp); 2483 dump_expr_list (pp, TREE_OPERAND (t, 0), flags); 2484 pp_cxx_right_paren (pp); 2485 } 2486 else 2487 { 2488 pp_cxx_left_paren (pp); 2489 dump_type (pp, TREE_TYPE (t), flags); 2490 pp_cxx_right_paren (pp); 2491 pp_cxx_left_paren (pp); 2492 dump_expr_list (pp, TREE_OPERAND (t, 0), flags); 2493 pp_cxx_right_paren (pp); 2494 } 2495 break; 2496 2497 case STATIC_CAST_EXPR: 2498 pp_cxx_ws_string (pp, "static_cast"); 2499 goto cast; 2500 case REINTERPRET_CAST_EXPR: 2501 pp_cxx_ws_string (pp, "reinterpret_cast"); 2502 goto cast; 2503 case CONST_CAST_EXPR: 2504 pp_cxx_ws_string (pp, "const_cast"); 2505 goto cast; 2506 case DYNAMIC_CAST_EXPR: 2507 pp_cxx_ws_string (pp, "dynamic_cast"); 2508 cast: 2509 pp_cxx_begin_template_argument_list (pp); 2510 dump_type (pp, TREE_TYPE (t), flags); 2511 pp_cxx_end_template_argument_list (pp); 2512 pp_cxx_left_paren (pp); 2513 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2514 pp_cxx_right_paren (pp); 2515 break; 2516 2517 case ARROW_EXPR: 2518 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2519 pp_cxx_arrow (pp); 2520 break; 2521 2522 case SIZEOF_EXPR: 2523 case ALIGNOF_EXPR: 2524 if (TREE_CODE (t) == SIZEOF_EXPR) 2525 pp_cxx_ws_string (pp, "sizeof"); 2526 else 2527 { 2528 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); 2529 pp_cxx_ws_string (pp, "__alignof__"); 2530 } 2531 op = TREE_OPERAND (t, 0); 2532 if (PACK_EXPANSION_P (op)) 2533 { 2534 pp_string (pp, "..."); 2535 op = PACK_EXPANSION_PATTERN (op); 2536 } 2537 pp_cxx_whitespace (pp); 2538 pp_cxx_left_paren (pp); 2539 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t)) 2540 dump_type (pp, TREE_TYPE (op), flags); 2541 else if (TYPE_P (TREE_OPERAND (t, 0))) 2542 dump_type (pp, op, flags); 2543 else 2544 dump_expr (pp, op, flags); 2545 pp_cxx_right_paren (pp); 2546 break; 2547 2548 case AT_ENCODE_EXPR: 2549 pp_cxx_ws_string (pp, "@encode"); 2550 pp_cxx_whitespace (pp); 2551 pp_cxx_left_paren (pp); 2552 dump_type (pp, TREE_OPERAND (t, 0), flags); 2553 pp_cxx_right_paren (pp); 2554 break; 2555 2556 case NOEXCEPT_EXPR: 2557 pp_cxx_ws_string (pp, "noexcept"); 2558 pp_cxx_whitespace (pp); 2559 pp_cxx_left_paren (pp); 2560 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2561 pp_cxx_right_paren (pp); 2562 break; 2563 2564 case REALPART_EXPR: 2565 case IMAGPART_EXPR: 2566 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name); 2567 pp_cxx_whitespace (pp); 2568 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2569 break; 2570 2571 case DEFAULT_ARG: 2572 pp_string (pp, M_("<unparsed>")); 2573 break; 2574 2575 case TRY_CATCH_EXPR: 2576 case WITH_CLEANUP_EXPR: 2577 case CLEANUP_POINT_EXPR: 2578 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2579 break; 2580 2581 case PSEUDO_DTOR_EXPR: 2582 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2583 pp_cxx_dot (pp); 2584 if (TREE_OPERAND (t, 1)) 2585 { 2586 dump_type (pp, TREE_OPERAND (t, 1), flags); 2587 pp_cxx_colon_colon (pp); 2588 } 2589 pp_cxx_complement (pp); 2590 dump_type (pp, TREE_OPERAND (t, 2), flags); 2591 break; 2592 2593 case TEMPLATE_ID_EXPR: 2594 dump_decl (pp, t, flags); 2595 break; 2596 2597 case BIND_EXPR: 2598 case STMT_EXPR: 2599 case EXPR_STMT: 2600 case STATEMENT_LIST: 2601 /* We don't yet have a way of dumping statements in a 2602 human-readable format. */ 2603 pp_string (pp, "({...})"); 2604 break; 2605 2606 case LOOP_EXPR: 2607 pp_string (pp, "while (1) { "); 2608 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2609 pp_cxx_right_brace (pp); 2610 break; 2611 2612 case EXIT_EXPR: 2613 pp_string (pp, "if ("); 2614 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2615 pp_string (pp, ") break; "); 2616 break; 2617 2618 case BASELINK: 2619 dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS); 2620 break; 2621 2622 case EMPTY_CLASS_EXPR: 2623 dump_type (pp, TREE_TYPE (t), flags); 2624 pp_cxx_left_paren (pp); 2625 pp_cxx_right_paren (pp); 2626 break; 2627 2628 case NON_DEPENDENT_EXPR: 2629 dump_expr (pp, TREE_OPERAND (t, 0), flags); 2630 break; 2631 2632 case ARGUMENT_PACK_SELECT: 2633 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags); 2634 break; 2635 2636 case RECORD_TYPE: 2637 case UNION_TYPE: 2638 case ENUMERAL_TYPE: 2639 case REAL_TYPE: 2640 case VOID_TYPE: 2641 case BOOLEAN_TYPE: 2642 case INTEGER_TYPE: 2643 case COMPLEX_TYPE: 2644 case VECTOR_TYPE: 2645 pp_type_specifier_seq (pp, t); 2646 break; 2647 2648 case TYPENAME_TYPE: 2649 /* We get here when we want to print a dependent type as an 2650 id-expression, without any disambiguator decoration. */ 2651 pp->id_expression (t); 2652 break; 2653 2654 case TEMPLATE_TYPE_PARM: 2655 case TEMPLATE_TEMPLATE_PARM: 2656 case BOUND_TEMPLATE_TEMPLATE_PARM: 2657 dump_type (pp, t, flags); 2658 break; 2659 2660 case TRAIT_EXPR: 2661 pp_cxx_trait_expression (pp, t); 2662 break; 2663 2664 case VA_ARG_EXPR: 2665 pp_cxx_va_arg_expression (pp, t); 2666 break; 2667 2668 case OFFSETOF_EXPR: 2669 pp_cxx_offsetof_expression (pp, t); 2670 break; 2671 2672 case SCOPE_REF: 2673 dump_decl (pp, t, flags); 2674 break; 2675 2676 case EXPR_PACK_EXPANSION: 2677 case UNARY_LEFT_FOLD_EXPR: 2678 case UNARY_RIGHT_FOLD_EXPR: 2679 case BINARY_LEFT_FOLD_EXPR: 2680 case BINARY_RIGHT_FOLD_EXPR: 2681 case TYPEID_EXPR: 2682 case MEMBER_REF: 2683 case DOTSTAR_EXPR: 2684 case NEW_EXPR: 2685 case VEC_NEW_EXPR: 2686 case DELETE_EXPR: 2687 case VEC_DELETE_EXPR: 2688 case MODOP_EXPR: 2689 case ABS_EXPR: 2690 case CONJ_EXPR: 2691 case VECTOR_CST: 2692 case FIXED_CST: 2693 case UNORDERED_EXPR: 2694 case ORDERED_EXPR: 2695 case UNLT_EXPR: 2696 case UNLE_EXPR: 2697 case UNGT_EXPR: 2698 case UNGE_EXPR: 2699 case UNEQ_EXPR: 2700 case LTGT_EXPR: 2701 case COMPLEX_EXPR: 2702 case BIT_FIELD_REF: 2703 case FIX_TRUNC_EXPR: 2704 case FLOAT_EXPR: 2705 pp->expression (t); 2706 break; 2707 2708 case TRUTH_AND_EXPR: 2709 case TRUTH_OR_EXPR: 2710 case TRUTH_XOR_EXPR: 2711 if (flags & TFF_EXPR_IN_PARENS) 2712 pp_cxx_left_paren (pp); 2713 pp->expression (t); 2714 if (flags & TFF_EXPR_IN_PARENS) 2715 pp_cxx_right_paren (pp); 2716 break; 2717 2718 case OBJ_TYPE_REF: 2719 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags); 2720 break; 2721 2722 case LAMBDA_EXPR: 2723 pp_string (pp, M_("<lambda>")); 2724 break; 2725 2726 case PAREN_EXPR: 2727 pp_cxx_left_paren (pp); 2728 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2729 pp_cxx_right_paren (pp); 2730 break; 2731 2732 case REQUIRES_EXPR: 2733 pp_cxx_requires_expr (cxx_pp, t); 2734 break; 2735 2736 case SIMPLE_REQ: 2737 pp_cxx_simple_requirement (cxx_pp, t); 2738 break; 2739 2740 case TYPE_REQ: 2741 pp_cxx_type_requirement (cxx_pp, t); 2742 break; 2743 2744 case COMPOUND_REQ: 2745 pp_cxx_compound_requirement (cxx_pp, t); 2746 break; 2747 2748 case NESTED_REQ: 2749 pp_cxx_nested_requirement (cxx_pp, t); 2750 break; 2751 2752 case PRED_CONSTR: 2753 case CHECK_CONSTR: 2754 case EXPR_CONSTR: 2755 case TYPE_CONSTR: 2756 case ICONV_CONSTR: 2757 case DEDUCT_CONSTR: 2758 case EXCEPT_CONSTR: 2759 case PARM_CONSTR: 2760 case CONJ_CONSTR: 2761 case DISJ_CONSTR: 2762 pp_cxx_constraint (cxx_pp, t); 2763 break; 2764 2765 case PLACEHOLDER_EXPR: 2766 pp_string (pp, M_("*this")); 2767 break; 2768 2769 case TREE_LIST: 2770 dump_expr_list (pp, t, flags); 2771 break; 2772 2773 /* This list is incomplete, but should suffice for now. 2774 It is very important that `sorry' does not call 2775 `report_error_function'. That could cause an infinite loop. */ 2776 default: 2777 pp_unsupported_tree (pp, t); 2778 /* fall through to ERROR_MARK... */ 2779 case ERROR_MARK: 2780 pp_string (pp, M_("<expression error>")); 2781 break; 2782 } 2783} 2784 2785static void 2786dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t, 2787 int flags) 2788{ 2789 pp_cxx_left_paren (pp); 2790 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2791 pp_cxx_whitespace (pp); 2792 if (opstring) 2793 pp_cxx_ws_string (pp, opstring); 2794 else 2795 pp_string (pp, M_("<unknown operator>")); 2796 pp_cxx_whitespace (pp); 2797 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2798 pp_cxx_right_paren (pp); 2799} 2800 2801static void 2802dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags) 2803{ 2804 if (flags & TFF_EXPR_IN_PARENS) 2805 pp_cxx_left_paren (pp); 2806 pp_cxx_ws_string (pp, opstring); 2807 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2808 if (flags & TFF_EXPR_IN_PARENS) 2809 pp_cxx_right_paren (pp); 2810} 2811 2812static void 2813reinit_cxx_pp (void) 2814{ 2815 pp_clear_output_area (cxx_pp); 2816 cxx_pp->padding = pp_none; 2817 pp_indentation (cxx_pp) = 0; 2818 pp_needs_newline (cxx_pp) = false; 2819 cxx_pp->enclosing_scope = current_function_decl; 2820} 2821 2822/* Same as pp_formatted_text, except the return string is a separate 2823 copy and has a GGC storage duration, e.g. an indefinite lifetime. */ 2824 2825inline const char * 2826pp_ggc_formatted_text (pretty_printer *pp) 2827{ 2828 return ggc_strdup (pp_formatted_text (pp)); 2829} 2830 2831/* Exported interface to stringifying types, exprs and decls under TFF_* 2832 control. */ 2833 2834const char * 2835type_as_string (tree typ, int flags) 2836{ 2837 reinit_cxx_pp (); 2838 pp_translate_identifiers (cxx_pp) = false; 2839 dump_type (cxx_pp, typ, flags); 2840 return pp_ggc_formatted_text (cxx_pp); 2841} 2842 2843const char * 2844type_as_string_translate (tree typ, int flags) 2845{ 2846 reinit_cxx_pp (); 2847 dump_type (cxx_pp, typ, flags); 2848 return pp_ggc_formatted_text (cxx_pp); 2849} 2850 2851const char * 2852expr_as_string (tree decl, int flags) 2853{ 2854 reinit_cxx_pp (); 2855 pp_translate_identifiers (cxx_pp) = false; 2856 dump_expr (cxx_pp, decl, flags); 2857 return pp_ggc_formatted_text (cxx_pp); 2858} 2859 2860/* Wrap decl_as_string with options appropriate for dwarf. */ 2861 2862const char * 2863decl_as_dwarf_string (tree decl, int flags) 2864{ 2865 const char *name; 2866 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag 2867 here will be adequate to get the desired behavior. */ 2868 cxx_pp->flags |= pp_c_flag_gnu_v3; 2869 name = decl_as_string (decl, flags); 2870 /* Subsequent calls to the pretty printer shouldn't use this style. */ 2871 cxx_pp->flags &= ~pp_c_flag_gnu_v3; 2872 return name; 2873} 2874 2875const char * 2876decl_as_string (tree decl, int flags) 2877{ 2878 reinit_cxx_pp (); 2879 pp_translate_identifiers (cxx_pp) = false; 2880 dump_decl (cxx_pp, decl, flags); 2881 return pp_ggc_formatted_text (cxx_pp); 2882} 2883 2884const char * 2885decl_as_string_translate (tree decl, int flags) 2886{ 2887 reinit_cxx_pp (); 2888 dump_decl (cxx_pp, decl, flags); 2889 return pp_ggc_formatted_text (cxx_pp); 2890} 2891 2892/* Wrap lang_decl_name with options appropriate for dwarf. */ 2893 2894const char * 2895lang_decl_dwarf_name (tree decl, int v, bool translate) 2896{ 2897 const char *name; 2898 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag 2899 here will be adequate to get the desired behavior. */ 2900 cxx_pp->flags |= pp_c_flag_gnu_v3; 2901 name = lang_decl_name (decl, v, translate); 2902 /* Subsequent calls to the pretty printer shouldn't use this style. */ 2903 cxx_pp->flags &= ~pp_c_flag_gnu_v3; 2904 return name; 2905} 2906 2907/* Generate the three forms of printable names for cxx_printable_name. */ 2908 2909const char * 2910lang_decl_name (tree decl, int v, bool translate) 2911{ 2912 if (v >= 2) 2913 return (translate 2914 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS) 2915 : decl_as_string (decl, TFF_DECL_SPECIFIERS)); 2916 2917 reinit_cxx_pp (); 2918 pp_translate_identifiers (cxx_pp) = translate; 2919 if (v == 1 2920 && (DECL_CLASS_SCOPE_P (decl) 2921 || (DECL_NAMESPACE_SCOPE_P (decl) 2922 && CP_DECL_CONTEXT (decl) != global_namespace))) 2923 { 2924 dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); 2925 pp_cxx_colon_colon (cxx_pp); 2926 } 2927 2928 if (TREE_CODE (decl) == FUNCTION_DECL) 2929 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER); 2930 else if ((DECL_NAME (decl) == NULL_TREE) 2931 && TREE_CODE (decl) == NAMESPACE_DECL) 2932 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME); 2933 else 2934 dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER); 2935 2936 return pp_ggc_formatted_text (cxx_pp); 2937} 2938 2939/* Return the location of a tree passed to %+ formats. */ 2940 2941location_t 2942location_of (tree t) 2943{ 2944 if (TYPE_P (t)) 2945 { 2946 t = TYPE_MAIN_DECL (t); 2947 if (t == NULL_TREE) 2948 return input_location; 2949 } 2950 else if (TREE_CODE (t) == OVERLOAD) 2951 t = OVL_FUNCTION (t); 2952 2953 if (DECL_P (t)) 2954 return DECL_SOURCE_LOCATION (t); 2955 return EXPR_LOC_OR_LOC (t, input_location); 2956} 2957 2958/* Now the interfaces from error et al to dump_type et al. Each takes an 2959 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_ 2960 function. */ 2961 2962static const char * 2963decl_to_string (tree decl, int verbose) 2964{ 2965 int flags = 0; 2966 2967 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE 2968 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE) 2969 flags = TFF_CLASS_KEY_OR_ENUM; 2970 if (verbose) 2971 flags |= TFF_DECL_SPECIFIERS; 2972 else if (TREE_CODE (decl) == FUNCTION_DECL) 2973 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; 2974 flags |= TFF_TEMPLATE_HEADER; 2975 2976 reinit_cxx_pp (); 2977 dump_decl (cxx_pp, decl, flags); 2978 return pp_ggc_formatted_text (cxx_pp); 2979} 2980 2981static const char * 2982expr_to_string (tree decl) 2983{ 2984 reinit_cxx_pp (); 2985 dump_expr (cxx_pp, decl, 0); 2986 return pp_ggc_formatted_text (cxx_pp); 2987} 2988 2989static const char * 2990fndecl_to_string (tree fndecl, int verbose) 2991{ 2992 int flags; 2993 2994 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS 2995 | TFF_TEMPLATE_HEADER; 2996 if (verbose) 2997 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; 2998 reinit_cxx_pp (); 2999 dump_decl (cxx_pp, fndecl, flags); 3000 return pp_ggc_formatted_text (cxx_pp); 3001} 3002 3003 3004static const char * 3005code_to_string (enum tree_code c) 3006{ 3007 return get_tree_code_name (c); 3008} 3009 3010const char * 3011language_to_string (enum languages c) 3012{ 3013 switch (c) 3014 { 3015 case lang_c: 3016 return "C"; 3017 3018 case lang_cplusplus: 3019 return "C++"; 3020 3021 case lang_java: 3022 return "Java"; 3023 3024 default: 3025 gcc_unreachable (); 3026 } 3027 return NULL; 3028} 3029 3030/* Return the proper printed version of a parameter to a C++ function. */ 3031 3032static const char * 3033parm_to_string (int p) 3034{ 3035 reinit_cxx_pp (); 3036 if (p < 0) 3037 pp_string (cxx_pp, "'this'"); 3038 else 3039 pp_decimal_int (cxx_pp, p + 1); 3040 return pp_ggc_formatted_text (cxx_pp); 3041} 3042 3043static const char * 3044op_to_string (enum tree_code p) 3045{ 3046 tree id = operator_name_info[p].identifier; 3047 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>"); 3048} 3049 3050static const char * 3051type_to_string (tree typ, int verbose) 3052{ 3053 int flags = 0; 3054 if (verbose) 3055 flags |= TFF_CLASS_KEY_OR_ENUM; 3056 flags |= TFF_TEMPLATE_HEADER; 3057 3058 reinit_cxx_pp (); 3059 dump_type (cxx_pp, typ, flags); 3060 /* If we're printing a type that involves typedefs, also print the 3061 stripped version. But sometimes the stripped version looks 3062 exactly the same, so we don't want it after all. To avoid printing 3063 it in that case, we play ugly obstack games. */ 3064 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ) 3065 && !uses_template_parms (typ)) 3066 { 3067 int aka_start, aka_len; char *p; 3068 struct obstack *ob = pp_buffer (cxx_pp)->obstack; 3069 /* Remember the end of the initial dump. */ 3070 int len = obstack_object_size (ob); 3071 tree aka = strip_typedefs (typ); 3072 pp_string (cxx_pp, " {aka"); 3073 pp_cxx_whitespace (cxx_pp); 3074 /* And remember the start of the aka dump. */ 3075 aka_start = obstack_object_size (ob); 3076 dump_type (cxx_pp, aka, flags); 3077 aka_len = obstack_object_size (ob) - aka_start; 3078 pp_right_brace (cxx_pp); 3079 p = (char*)obstack_base (ob); 3080 /* If they are identical, cut off the aka with a NUL. */ 3081 if (len == aka_len && memcmp (p, p+aka_start, len) == 0) 3082 p[len] = '\0'; 3083 } 3084 return pp_ggc_formatted_text (cxx_pp); 3085} 3086 3087static const char * 3088assop_to_string (enum tree_code p) 3089{ 3090 tree id = assignment_operator_name_info[(int) p].identifier; 3091 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}"); 3092} 3093 3094static const char * 3095args_to_string (tree p, int verbose) 3096{ 3097 int flags = 0; 3098 if (verbose) 3099 flags |= TFF_CLASS_KEY_OR_ENUM; 3100 3101 if (p == NULL_TREE) 3102 return ""; 3103 3104 if (TYPE_P (TREE_VALUE (p))) 3105 return type_as_string_translate (p, flags); 3106 3107 reinit_cxx_pp (); 3108 for (; p; p = TREE_CHAIN (p)) 3109 { 3110 if (TREE_VALUE (p) == null_node) 3111 pp_cxx_ws_string (cxx_pp, "NULL"); 3112 else 3113 dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags); 3114 if (TREE_CHAIN (p)) 3115 pp_separate_with_comma (cxx_pp); 3116 } 3117 return pp_ggc_formatted_text (cxx_pp); 3118} 3119 3120/* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P 3121 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template 3122 arguments. */ 3123 3124static const char * 3125subst_to_string (tree p) 3126{ 3127 tree decl = TREE_PURPOSE (p); 3128 tree targs = TREE_VALUE (p); 3129 tree tparms = DECL_TEMPLATE_PARMS (decl); 3130 int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER 3131 |TFF_NO_TEMPLATE_BINDINGS); 3132 3133 if (p == NULL_TREE) 3134 return ""; 3135 3136 reinit_cxx_pp (); 3137 dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags); 3138 dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0); 3139 return pp_ggc_formatted_text (cxx_pp); 3140} 3141 3142static const char * 3143cv_to_string (tree p, int v) 3144{ 3145 reinit_cxx_pp (); 3146 cxx_pp->padding = v ? pp_before : pp_none; 3147 pp_cxx_cv_qualifier_seq (cxx_pp, p); 3148 return pp_ggc_formatted_text (cxx_pp); 3149} 3150 3151static const char * 3152eh_spec_to_string (tree p, int /*v*/) 3153{ 3154 int flags = 0; 3155 reinit_cxx_pp (); 3156 dump_exception_spec (cxx_pp, p, flags); 3157 return pp_ggc_formatted_text (cxx_pp); 3158} 3159 3160/* Langhook for print_error_function. */ 3161void 3162cxx_print_error_function (diagnostic_context *context, const char *file, 3163 diagnostic_info *diagnostic) 3164{ 3165 lhd_print_error_function (context, file, diagnostic); 3166 pp_set_prefix (context->printer, file); 3167 maybe_print_instantiation_context (context); 3168} 3169 3170static void 3171cp_diagnostic_starter (diagnostic_context *context, 3172 diagnostic_info *diagnostic) 3173{ 3174 diagnostic_report_current_module (context, diagnostic_location (diagnostic)); 3175 cp_print_error_function (context, diagnostic); 3176 maybe_print_instantiation_context (context); 3177 maybe_print_constexpr_context (context); 3178 pp_set_prefix (context->printer, diagnostic_build_prefix (context, 3179 diagnostic)); 3180} 3181 3182/* Print current function onto BUFFER, in the process of reporting 3183 a diagnostic message. Called from cp_diagnostic_starter. */ 3184static void 3185cp_print_error_function (diagnostic_context *context, 3186 diagnostic_info *diagnostic) 3187{ 3188 /* If we are in an instantiation context, current_function_decl is likely 3189 to be wrong, so just rely on print_instantiation_full_context. */ 3190 if (current_instantiation ()) 3191 return; 3192 if (diagnostic_last_function_changed (context, diagnostic)) 3193 { 3194 const char *old_prefix = context->printer->prefix; 3195 const char *file = LOCATION_FILE (diagnostic_location (diagnostic)); 3196 tree abstract_origin = diagnostic_abstract_origin (diagnostic); 3197 char *new_prefix = (file && abstract_origin == NULL) 3198 ? file_name_as_prefix (context, file) : NULL; 3199 3200 pp_set_prefix (context->printer, new_prefix); 3201 3202 if (current_function_decl == NULL) 3203 pp_string (context->printer, _("At global scope:")); 3204 else 3205 { 3206 tree fndecl, ao; 3207 3208 if (abstract_origin) 3209 { 3210 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); 3211 while (TREE_CODE (ao) == BLOCK 3212 && BLOCK_ABSTRACT_ORIGIN (ao) 3213 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 3214 ao = BLOCK_ABSTRACT_ORIGIN (ao); 3215 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); 3216 fndecl = ao; 3217 } 3218 else 3219 fndecl = current_function_decl; 3220 3221 pp_printf (context->printer, function_category (fndecl), 3222 cxx_printable_name_translate (fndecl, 2)); 3223 3224 while (abstract_origin) 3225 { 3226 location_t *locus; 3227 tree block = abstract_origin; 3228 3229 locus = &BLOCK_SOURCE_LOCATION (block); 3230 fndecl = NULL; 3231 block = BLOCK_SUPERCONTEXT (block); 3232 while (block && TREE_CODE (block) == BLOCK 3233 && BLOCK_ABSTRACT_ORIGIN (block)) 3234 { 3235 ao = BLOCK_ABSTRACT_ORIGIN (block); 3236 3237 while (TREE_CODE (ao) == BLOCK 3238 && BLOCK_ABSTRACT_ORIGIN (ao) 3239 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 3240 ao = BLOCK_ABSTRACT_ORIGIN (ao); 3241 3242 if (TREE_CODE (ao) == FUNCTION_DECL) 3243 { 3244 fndecl = ao; 3245 break; 3246 } 3247 else if (TREE_CODE (ao) != BLOCK) 3248 break; 3249 3250 block = BLOCK_SUPERCONTEXT (block); 3251 } 3252 if (fndecl) 3253 abstract_origin = block; 3254 else 3255 { 3256 while (block && TREE_CODE (block) == BLOCK) 3257 block = BLOCK_SUPERCONTEXT (block); 3258 3259 if (block && TREE_CODE (block) == FUNCTION_DECL) 3260 fndecl = block; 3261 abstract_origin = NULL; 3262 } 3263 if (fndecl) 3264 { 3265 expanded_location s = expand_location (*locus); 3266 pp_character (context->printer, ','); 3267 pp_newline (context->printer); 3268 if (s.file != NULL) 3269 { 3270 if (context->show_column && s.column != 0) 3271 pp_printf (context->printer, 3272 _(" inlined from %qs at %r%s:%d:%d%R"), 3273 cxx_printable_name_translate (fndecl, 2), 3274 "locus", s.file, s.line, s.column); 3275 else 3276 pp_printf (context->printer, 3277 _(" inlined from %qs at %r%s:%d%R"), 3278 cxx_printable_name_translate (fndecl, 2), 3279 "locus", s.file, s.line); 3280 3281 } 3282 else 3283 pp_printf (context->printer, _(" inlined from %qs"), 3284 cxx_printable_name_translate (fndecl, 2)); 3285 } 3286 } 3287 pp_character (context->printer, ':'); 3288 } 3289 pp_newline (context->printer); 3290 3291 diagnostic_set_last_function (context, diagnostic); 3292 pp_destroy_prefix (context->printer); 3293 context->printer->prefix = old_prefix; 3294 } 3295} 3296 3297/* Returns a description of FUNCTION using standard terminology. The 3298 result is a format string of the form "In CATEGORY %qs". */ 3299static const char * 3300function_category (tree fn) 3301{ 3302 /* We can get called from the middle-end for diagnostics of function 3303 clones. Make sure we have language specific information before 3304 dereferencing it. */ 3305 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn)) 3306 && DECL_FUNCTION_MEMBER_P (fn)) 3307 { 3308 if (DECL_STATIC_FUNCTION_P (fn)) 3309 return _("In static member function %qs"); 3310 else if (DECL_COPY_CONSTRUCTOR_P (fn)) 3311 return _("In copy constructor %qs"); 3312 else if (DECL_CONSTRUCTOR_P (fn)) 3313 return _("In constructor %qs"); 3314 else if (DECL_DESTRUCTOR_P (fn)) 3315 return _("In destructor %qs"); 3316 else if (LAMBDA_FUNCTION_P (fn)) 3317 return _("In lambda function"); 3318 else 3319 return _("In member function %qs"); 3320 } 3321 else 3322 return _("In function %qs"); 3323} 3324 3325/* Report the full context of a current template instantiation, 3326 onto BUFFER. */ 3327static void 3328print_instantiation_full_context (diagnostic_context *context) 3329{ 3330 struct tinst_level *p = current_instantiation (); 3331 location_t location = input_location; 3332 3333 if (p) 3334 { 3335 pp_verbatim (context->printer, 3336 TREE_CODE (p->decl) == TREE_LIST 3337 ? _("%s: In substitution of %qS:\n") 3338 : _("%s: In instantiation of %q#D:\n"), 3339 LOCATION_FILE (location), 3340 p->decl); 3341 3342 location = p->locus; 3343 p = p->next; 3344 } 3345 3346 print_instantiation_partial_context (context, p, location); 3347} 3348 3349/* Helper function of print_instantiation_partial_context() that 3350 prints a single line of instantiation context. */ 3351 3352static void 3353print_instantiation_partial_context_line (diagnostic_context *context, 3354 const struct tinst_level *t, 3355 location_t loc, bool recursive_p) 3356{ 3357 if (loc == UNKNOWN_LOCATION) 3358 return; 3359 3360 expanded_location xloc = expand_location (loc); 3361 3362 if (context->show_column) 3363 pp_verbatim (context->printer, _("%r%s:%d:%d:%R "), 3364 "locus", xloc.file, xloc.line, xloc.column); 3365 else 3366 pp_verbatim (context->printer, _("%r%s:%d:%R "), 3367 "locus", xloc.file, xloc.line); 3368 3369 if (t != NULL) 3370 { 3371 if (TREE_CODE (t->decl) == TREE_LIST) 3372 pp_verbatim (context->printer, 3373 recursive_p 3374 ? _("recursively required by substitution of %qS\n") 3375 : _("required by substitution of %qS\n"), 3376 t->decl); 3377 else 3378 pp_verbatim (context->printer, 3379 recursive_p 3380 ? _("recursively required from %q#D\n") 3381 : _("required from %q#D\n"), 3382 t->decl); 3383 } 3384 else 3385 { 3386 pp_verbatim (context->printer, 3387 recursive_p 3388 ? _("recursively required from here\n") 3389 : _("required from here\n")); 3390 } 3391} 3392 3393/* Same as print_instantiation_full_context but less verbose. */ 3394 3395static void 3396print_instantiation_partial_context (diagnostic_context *context, 3397 struct tinst_level *t0, location_t loc) 3398{ 3399 struct tinst_level *t; 3400 int n_total = 0; 3401 int n; 3402 location_t prev_loc = loc; 3403 3404 for (t = t0; t != NULL; t = t->next) 3405 if (prev_loc != t->locus) 3406 { 3407 prev_loc = t->locus; 3408 n_total++; 3409 } 3410 3411 t = t0; 3412 3413 if (template_backtrace_limit 3414 && n_total > template_backtrace_limit) 3415 { 3416 int skip = n_total - template_backtrace_limit; 3417 int head = template_backtrace_limit / 2; 3418 3419 /* Avoid skipping just 1. If so, skip 2. */ 3420 if (skip == 1) 3421 { 3422 skip = 2; 3423 head = (template_backtrace_limit - 1) / 2; 3424 } 3425 3426 for (n = 0; n < head; n++) 3427 { 3428 gcc_assert (t != NULL); 3429 if (loc != t->locus) 3430 print_instantiation_partial_context_line (context, t, loc, 3431 /*recursive_p=*/false); 3432 loc = t->locus; 3433 t = t->next; 3434 } 3435 if (t != NULL && skip > 0) 3436 { 3437 expanded_location xloc; 3438 xloc = expand_location (loc); 3439 if (context->show_column) 3440 pp_verbatim (context->printer, 3441 _("%r%s:%d:%d:%R [ skipping %d instantiation " 3442 "contexts, use -ftemplate-backtrace-limit=0 to " 3443 "disable ]\n"), 3444 "locus", xloc.file, xloc.line, xloc.column, skip); 3445 else 3446 pp_verbatim (context->printer, 3447 _("%r%s:%d:%R [ skipping %d instantiation " 3448 "contexts, use -ftemplate-backtrace-limit=0 to " 3449 "disable ]\n"), 3450 "locus", xloc.file, xloc.line, skip); 3451 3452 do { 3453 loc = t->locus; 3454 t = t->next; 3455 } while (t != NULL && --skip > 0); 3456 } 3457 } 3458 3459 while (t != NULL) 3460 { 3461 while (t->next != NULL && t->locus == t->next->locus) 3462 { 3463 loc = t->locus; 3464 t = t->next; 3465 } 3466 print_instantiation_partial_context_line (context, t, loc, 3467 t->locus == loc); 3468 loc = t->locus; 3469 t = t->next; 3470 } 3471 print_instantiation_partial_context_line (context, NULL, loc, 3472 /*recursive_p=*/false); 3473} 3474 3475/* Called from cp_thing to print the template context for an error. */ 3476static void 3477maybe_print_instantiation_context (diagnostic_context *context) 3478{ 3479 if (!problematic_instantiation_changed () || current_instantiation () == 0) 3480 return; 3481 3482 record_last_problematic_instantiation (); 3483 print_instantiation_full_context (context); 3484} 3485 3486/* Report what constexpr call(s) we're trying to expand, if any. */ 3487 3488void 3489maybe_print_constexpr_context (diagnostic_context *context) 3490{ 3491 vec<tree> call_stack = cx_error_context (); 3492 unsigned ix; 3493 tree t; 3494 3495 FOR_EACH_VEC_ELT (call_stack, ix, t) 3496 { 3497 expanded_location xloc = expand_location (EXPR_LOCATION (t)); 3498 const char *s = expr_as_string (t, 0); 3499 if (context->show_column) 3500 pp_verbatim (context->printer, 3501 _("%r%s:%d:%d:%R in constexpr expansion of %qs"), 3502 "locus", xloc.file, xloc.line, xloc.column, s); 3503 else 3504 pp_verbatim (context->printer, 3505 _("%r%s:%d:%R in constexpr expansion of %qs"), 3506 "locus", xloc.file, xloc.line, s); 3507 pp_newline (context->printer); 3508 } 3509} 3510 3511/* Called from output_format -- during diagnostic message processing -- 3512 to handle C++ specific format specifier with the following meanings: 3513 %A function argument-list. 3514 %C tree code. 3515 %D declaration. 3516 %E expression. 3517 %F function declaration. 3518 %L language as used in extern "lang". 3519 %O binary operator. 3520 %P function parameter whose position is indicated by an integer. 3521 %Q assignment operator. 3522 %S substitution (template + args) 3523 %T type. 3524 %V cv-qualifier. 3525 %X exception-specification. */ 3526static bool 3527cp_printer (pretty_printer *pp, text_info *text, const char *spec, 3528 int precision, bool wide, bool set_locus, bool verbose) 3529{ 3530 const char *result; 3531 tree t = NULL; 3532#define next_tree (t = va_arg (*text->args_ptr, tree)) 3533#define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int)) 3534#define next_lang ((enum languages) va_arg (*text->args_ptr, int)) 3535#define next_int va_arg (*text->args_ptr, int) 3536 3537 if (precision != 0 || wide) 3538 return false; 3539 3540 switch (*spec) 3541 { 3542 case 'A': result = args_to_string (next_tree, verbose); break; 3543 case 'C': result = code_to_string (next_tcode); break; 3544 case 'D': 3545 { 3546 tree temp = next_tree; 3547 if (VAR_P (temp) 3548 && DECL_HAS_DEBUG_EXPR_P (temp)) 3549 { 3550 temp = DECL_DEBUG_EXPR (temp); 3551 if (!DECL_P (temp)) 3552 { 3553 result = expr_to_string (temp); 3554 break; 3555 } 3556 } 3557 result = decl_to_string (temp, verbose); 3558 } 3559 break; 3560 case 'E': result = expr_to_string (next_tree); break; 3561 case 'F': result = fndecl_to_string (next_tree, verbose); break; 3562 case 'L': result = language_to_string (next_lang); break; 3563 case 'O': result = op_to_string (next_tcode); break; 3564 case 'P': result = parm_to_string (next_int); break; 3565 case 'Q': result = assop_to_string (next_tcode); break; 3566 case 'S': result = subst_to_string (next_tree); break; 3567 case 'T': result = type_to_string (next_tree, verbose); break; 3568 case 'V': result = cv_to_string (next_tree, verbose); break; 3569 case 'X': result = eh_spec_to_string (next_tree, verbose); break; 3570 3571 case 'K': 3572 percent_K_format (text); 3573 return true; 3574 3575 default: 3576 return false; 3577 } 3578 3579 pp_string (pp, result); 3580 if (set_locus && t != NULL) 3581 text->set_location (0, location_of (t), true); 3582 return true; 3583#undef next_tree 3584#undef next_tcode 3585#undef next_lang 3586#undef next_int 3587} 3588 3589/* Warn about the use of C++0x features when appropriate. */ 3590void 3591maybe_warn_cpp0x (cpp0x_warn_str str) 3592{ 3593 if ((cxx_dialect == cxx98) && !in_system_header_at (input_location)) 3594 /* We really want to suppress this warning in system headers, 3595 because libstdc++ uses variadic templates even when we aren't 3596 in C++0x mode. */ 3597 switch (str) 3598 { 3599 case CPP0X_INITIALIZER_LISTS: 3600 pedwarn (input_location, 0, 3601 "extended initializer lists " 3602 "only available with -std=c++11 or -std=gnu++11"); 3603 break; 3604 case CPP0X_EXPLICIT_CONVERSION: 3605 pedwarn (input_location, 0, 3606 "explicit conversion operators " 3607 "only available with -std=c++11 or -std=gnu++11"); 3608 break; 3609 case CPP0X_VARIADIC_TEMPLATES: 3610 pedwarn (input_location, 0, 3611 "variadic templates " 3612 "only available with -std=c++11 or -std=gnu++11"); 3613 break; 3614 case CPP0X_LAMBDA_EXPR: 3615 pedwarn (input_location, 0, 3616 "lambda expressions " 3617 "only available with -std=c++11 or -std=gnu++11"); 3618 break; 3619 case CPP0X_AUTO: 3620 pedwarn (input_location, 0, 3621 "C++11 auto only available with -std=c++11 or -std=gnu++11"); 3622 break; 3623 case CPP0X_SCOPED_ENUMS: 3624 pedwarn (input_location, 0, 3625 "scoped enums only available with -std=c++11 or -std=gnu++11"); 3626 break; 3627 case CPP0X_DEFAULTED_DELETED: 3628 pedwarn (input_location, 0, 3629 "defaulted and deleted functions " 3630 "only available with -std=c++11 or -std=gnu++11"); 3631 break; 3632 case CPP0X_INLINE_NAMESPACES: 3633 pedwarn (input_location, OPT_Wpedantic, 3634 "inline namespaces " 3635 "only available with -std=c++11 or -std=gnu++11"); 3636 break; 3637 case CPP0X_OVERRIDE_CONTROLS: 3638 pedwarn (input_location, 0, 3639 "override controls (override/final) " 3640 "only available with -std=c++11 or -std=gnu++11"); 3641 break; 3642 case CPP0X_NSDMI: 3643 pedwarn (input_location, 0, 3644 "non-static data member initializers " 3645 "only available with -std=c++11 or -std=gnu++11"); 3646 break; 3647 case CPP0X_USER_DEFINED_LITERALS: 3648 pedwarn (input_location, 0, 3649 "user-defined literals " 3650 "only available with -std=c++11 or -std=gnu++11"); 3651 break; 3652 case CPP0X_DELEGATING_CTORS: 3653 pedwarn (input_location, 0, 3654 "delegating constructors " 3655 "only available with -std=c++11 or -std=gnu++11"); 3656 break; 3657 case CPP0X_INHERITING_CTORS: 3658 pedwarn (input_location, 0, 3659 "inheriting constructors " 3660 "only available with -std=c++11 or -std=gnu++11"); 3661 break; 3662 case CPP0X_ATTRIBUTES: 3663 pedwarn (input_location, 0, 3664 "c++11 attributes " 3665 "only available with -std=c++11 or -std=gnu++11"); 3666 break; 3667 case CPP0X_REF_QUALIFIER: 3668 pedwarn (input_location, 0, 3669 "ref-qualifiers " 3670 "only available with -std=c++11 or -std=gnu++11"); 3671 break; 3672 default: 3673 gcc_unreachable (); 3674 } 3675} 3676 3677/* Warn about the use of variadic templates when appropriate. */ 3678void 3679maybe_warn_variadic_templates (void) 3680{ 3681 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES); 3682} 3683 3684 3685/* Issue an ISO C++98 pedantic warning at LOCATION, conditional on 3686 option OPT with text GMSGID. Use this function to report 3687 diagnostics for constructs that are invalid C++98, but valid 3688 C++0x. */ 3689bool 3690pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...) 3691{ 3692 diagnostic_info diagnostic; 3693 va_list ap; 3694 bool ret; 3695 rich_location richloc (line_table, location); 3696 3697 va_start (ap, gmsgid); 3698 diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, 3699 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING); 3700 diagnostic.option_index = opt; 3701 ret = report_diagnostic (&diagnostic); 3702 va_end (ap); 3703 return ret; 3704} 3705 3706/* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what 3707 we found when we tried to do the lookup. LOCATION is the location of 3708 the NAME identifier. */ 3709 3710void 3711qualified_name_lookup_error (tree scope, tree name, 3712 tree decl, location_t location) 3713{ 3714 if (scope == error_mark_node) 3715 ; /* We already complained. */ 3716 else if (TYPE_P (scope)) 3717 { 3718 if (!COMPLETE_TYPE_P (scope)) 3719 error_at (location, "incomplete type %qT used in nested name specifier", 3720 scope); 3721 else if (TREE_CODE (decl) == TREE_LIST) 3722 { 3723 error_at (location, "reference to %<%T::%D%> is ambiguous", 3724 scope, name); 3725 print_candidates (decl); 3726 } 3727 else 3728 error_at (location, "%qD is not a member of %qT", name, scope); 3729 } 3730 else if (scope != global_namespace) 3731 { 3732 error_at (location, "%qD is not a member of %qD", name, scope); 3733 suggest_alternatives_for (location, name); 3734 } 3735 else 3736 { 3737 error_at (location, "%<::%D%> has not been declared", name); 3738 suggest_alternatives_for (location, name); 3739 } 3740} 3741