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