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