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