1 /* Call-backs for C++ error reporting. 2 This code is non-reentrant. 3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 4 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tm.h" 25 #include "tree.h" 26 #include "cp-tree.h" 27 #include "real.h" 28 #include "toplev.h" 29 #include "flags.h" 30 #include "diagnostic.h" 31 #include "langhooks-def.h" 32 #include "intl.h" 33 #include "cxx-pretty-print.h" 34 #include "pointer-set.h" 35 36 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',') 37 38 /* The global buffer where we dump everything. It is there only for 39 transitional purpose. It is expected, in the near future, to be 40 completely removed. */ 41 static cxx_pretty_printer scratch_pretty_printer; 42 #define cxx_pp (&scratch_pretty_printer) 43 44 /* Translate if being used for diagnostics, but not for dump files or 45 __PRETTY_FUNCTION. */ 46 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid)) 47 48 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) 49 50 static const char *args_to_string (tree, int); 51 static const char *assop_to_string (enum tree_code); 52 static const char *code_to_string (enum tree_code); 53 static const char *cv_to_string (tree, int); 54 static const char *decl_to_string (tree, int); 55 static const char *expr_to_string (tree); 56 static const char *fndecl_to_string (tree, int); 57 static const char *op_to_string (enum tree_code); 58 static const char *parm_to_string (int); 59 static const char *type_to_string (tree, int); 60 61 static void dump_type (tree, int); 62 static void dump_typename (tree, int); 63 static void dump_simple_decl (tree, tree, int); 64 static void dump_decl (tree, int); 65 static void dump_template_decl (tree, int); 66 static void dump_function_decl (tree, int); 67 static void dump_expr (tree, int); 68 static void dump_unary_op (const char *, tree, int); 69 static void dump_binary_op (const char *, tree, int); 70 static void dump_aggr_type (tree, int); 71 static void dump_type_prefix (tree, int); 72 static void dump_type_suffix (tree, int); 73 static void dump_function_name (tree, int); 74 static void dump_call_expr_args (tree, int, bool); 75 static void dump_aggr_init_expr_args (tree, int, bool); 76 static void dump_expr_list (tree, int); 77 static void dump_global_iord (tree); 78 static void dump_parameters (tree, int); 79 static void dump_exception_spec (tree, int); 80 static void dump_template_argument (tree, int); 81 static void dump_template_argument_list (tree, int); 82 static void dump_template_parameter (tree, int); 83 static void dump_template_bindings (tree, tree, VEC(tree,gc) *); 84 static void dump_scope (tree, int); 85 static void dump_template_parms (tree, int, int); 86 static int get_non_default_template_args_count (tree, int); 87 static const char *function_category (tree); 88 static void maybe_print_instantiation_context (diagnostic_context *); 89 static void print_instantiation_full_context (diagnostic_context *); 90 static void print_instantiation_partial_context (diagnostic_context *, 91 struct tinst_level *, 92 location_t); 93 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); 94 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); 95 static void cp_print_error_function (diagnostic_context *, diagnostic_info *); 96 97 static bool cp_printer (pretty_printer *, text_info *, const char *, 98 int, bool, bool, bool); 99 static location_t location_of (tree); 100 101 void 102 init_error (void) 103 { 104 diagnostic_starter (global_dc) = cp_diagnostic_starter; 105 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer; 106 diagnostic_format_decoder (global_dc) = cp_printer; 107 108 pp_construct (pp_base (cxx_pp), NULL, 0); 109 pp_cxx_pretty_printer_init (cxx_pp); 110 } 111 112 /* Dump a scope, if deemed necessary. */ 113 114 static void 115 dump_scope (tree scope, int flags) 116 { 117 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF)); 118 119 if (scope == NULL_TREE) 120 return; 121 122 if (TREE_CODE (scope) == NAMESPACE_DECL) 123 { 124 if (scope != global_namespace) 125 { 126 dump_decl (scope, f); 127 pp_cxx_colon_colon (cxx_pp); 128 } 129 } 130 else if (AGGREGATE_TYPE_P (scope)) 131 { 132 dump_type (scope, f); 133 pp_cxx_colon_colon (cxx_pp); 134 } 135 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) 136 { 137 dump_function_decl (scope, f); 138 pp_cxx_colon_colon (cxx_pp); 139 } 140 } 141 142 /* Dump the template ARGument under control of FLAGS. */ 143 144 static void 145 dump_template_argument (tree arg, int flags) 146 { 147 if (ARGUMENT_PACK_P (arg)) 148 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags); 149 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) 150 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); 151 else 152 { 153 if (TREE_CODE (arg) == TREE_LIST) 154 arg = TREE_VALUE (arg); 155 156 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); 157 } 158 } 159 160 /* Count the number of template arguments ARGS whose value does not 161 match the (optional) default template parameter in PARAMS */ 162 163 static int 164 get_non_default_template_args_count (tree args, int flags) 165 { 166 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args)); 167 168 if (/* We use this flag when generating debug information. We don't 169 want to expand templates at this point, for this may generate 170 new decls, which gets decl counts out of sync, which may in 171 turn cause codegen differences between compilations with and 172 without -g. */ 173 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0 174 || !flag_pretty_templates) 175 return n; 176 177 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args)); 178 } 179 180 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control 181 of FLAGS. */ 182 183 static void 184 dump_template_argument_list (tree args, int flags) 185 { 186 int n = get_non_default_template_args_count (args, flags); 187 int need_comma = 0; 188 int i; 189 190 for (i = 0; i < n; ++i) 191 { 192 tree arg = TREE_VEC_ELT (args, i); 193 194 /* Only print a comma if we know there is an argument coming. In 195 the case of an empty template argument pack, no actual 196 argument will be printed. */ 197 if (need_comma 198 && (!ARGUMENT_PACK_P (arg) 199 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0)) 200 pp_separate_with_comma (cxx_pp); 201 202 dump_template_argument (arg, flags); 203 need_comma = 1; 204 } 205 } 206 207 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ 208 209 static void 210 dump_template_parameter (tree parm, int flags) 211 { 212 tree p; 213 tree a; 214 215 if (parm == error_mark_node) 216 return; 217 218 p = TREE_VALUE (parm); 219 a = TREE_PURPOSE (parm); 220 221 if (TREE_CODE (p) == TYPE_DECL) 222 { 223 if (flags & TFF_DECL_SPECIFIERS) 224 { 225 pp_cxx_ws_string (cxx_pp, "class"); 226 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p))) 227 pp_cxx_ws_string (cxx_pp, "..."); 228 if (DECL_NAME (p)) 229 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 230 } 231 else if (DECL_NAME (p)) 232 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 233 else 234 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p)); 235 } 236 else 237 dump_decl (p, flags | TFF_DECL_SPECIFIERS); 238 239 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) 240 { 241 pp_cxx_whitespace (cxx_pp); 242 pp_equal (cxx_pp); 243 pp_cxx_whitespace (cxx_pp); 244 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) 245 dump_type (a, flags & ~TFF_CHASE_TYPEDEF); 246 else 247 dump_expr (a, flags | TFF_EXPR_IN_PARENS); 248 } 249 } 250 251 /* Dump, under control of FLAGS, a template-parameter-list binding. 252 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a 253 TREE_VEC. */ 254 255 static void 256 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames) 257 { 258 int need_comma = 0; 259 int i; 260 tree t; 261 262 while (parms) 263 { 264 tree p = TREE_VALUE (parms); 265 int lvl = TMPL_PARMS_DEPTH (parms); 266 int arg_idx = 0; 267 int i; 268 tree lvl_args = NULL_TREE; 269 270 /* Don't crash if we had an invalid argument list. */ 271 if (TMPL_ARGS_DEPTH (args) >= lvl) 272 lvl_args = TMPL_ARGS_LEVEL (args, lvl); 273 274 for (i = 0; i < TREE_VEC_LENGTH (p); ++i) 275 { 276 tree arg = NULL_TREE; 277 278 /* Don't crash if we had an invalid argument list. */ 279 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx) 280 arg = TREE_VEC_ELT (lvl_args, arg_idx); 281 282 if (need_comma) 283 pp_separate_with_comma (cxx_pp); 284 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); 285 pp_cxx_whitespace (cxx_pp); 286 pp_equal (cxx_pp); 287 pp_cxx_whitespace (cxx_pp); 288 if (arg) 289 { 290 if (ARGUMENT_PACK_P (arg)) 291 pp_cxx_left_brace (cxx_pp); 292 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); 293 if (ARGUMENT_PACK_P (arg)) 294 pp_cxx_right_brace (cxx_pp); 295 } 296 else 297 pp_string (cxx_pp, M_("<missing>")); 298 299 ++arg_idx; 300 need_comma = 1; 301 } 302 303 parms = TREE_CHAIN (parms); 304 } 305 306 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i) 307 { 308 if (need_comma) 309 pp_separate_with_comma (cxx_pp); 310 dump_type (t, TFF_PLAIN_IDENTIFIER); 311 pp_cxx_whitespace (cxx_pp); 312 pp_equal (cxx_pp); 313 pp_cxx_whitespace (cxx_pp); 314 t = tsubst (t, args, tf_none, NULL_TREE); 315 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because 316 pp_simple_type_specifier doesn't know about it. */ 317 t = strip_typedefs (t); 318 dump_type (t, TFF_PLAIN_IDENTIFIER); 319 } 320 } 321 322 /* Dump a human-readable equivalent of TYPE. FLAGS controls the 323 format. */ 324 325 static void 326 dump_type (tree t, int flags) 327 { 328 if (t == NULL_TREE) 329 return; 330 331 if (TYPE_PTRMEMFUNC_P (t)) 332 goto offset_type; 333 334 switch (TREE_CODE (t)) 335 { 336 case UNKNOWN_TYPE: 337 if (t == init_list_type_node) 338 pp_string (cxx_pp, M_("<brace-enclosed initializer list>")); 339 else 340 pp_string (cxx_pp, M_("<unresolved overloaded function type>")); 341 break; 342 343 case TREE_LIST: 344 /* A list of function parms. */ 345 dump_parameters (t, flags); 346 break; 347 348 case IDENTIFIER_NODE: 349 pp_cxx_tree_identifier (cxx_pp, t); 350 break; 351 352 case TREE_BINFO: 353 dump_type (BINFO_TYPE (t), flags); 354 break; 355 356 case RECORD_TYPE: 357 case UNION_TYPE: 358 case ENUMERAL_TYPE: 359 dump_aggr_type (t, flags); 360 break; 361 362 case TYPE_DECL: 363 if (flags & TFF_CHASE_TYPEDEF) 364 { 365 dump_type (DECL_ORIGINAL_TYPE (t) 366 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); 367 break; 368 } 369 /* Else fall through. */ 370 371 case TEMPLATE_DECL: 372 case NAMESPACE_DECL: 373 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS); 374 break; 375 376 case INTEGER_TYPE: 377 case REAL_TYPE: 378 case VOID_TYPE: 379 case BOOLEAN_TYPE: 380 case COMPLEX_TYPE: 381 case VECTOR_TYPE: 382 case FIXED_POINT_TYPE: 383 pp_type_specifier_seq (cxx_pp, t); 384 break; 385 386 case TEMPLATE_TEMPLATE_PARM: 387 /* For parameters inside template signature. */ 388 if (TYPE_IDENTIFIER (t)) 389 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 390 else 391 pp_cxx_canonical_template_parameter (cxx_pp, t); 392 break; 393 394 case BOUND_TEMPLATE_TEMPLATE_PARM: 395 { 396 tree args = TYPE_TI_ARGS (t); 397 pp_cxx_cv_qualifier_seq (cxx_pp, t); 398 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 399 pp_cxx_begin_template_argument_list (cxx_pp); 400 dump_template_argument_list (args, flags); 401 pp_cxx_end_template_argument_list (cxx_pp); 402 } 403 break; 404 405 case TEMPLATE_TYPE_PARM: 406 pp_cxx_cv_qualifier_seq (cxx_pp, t); 407 if (TYPE_IDENTIFIER (t)) 408 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 409 else 410 pp_cxx_canonical_template_parameter 411 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t)); 412 break; 413 414 /* This is not always necessary for pointers and such, but doing this 415 reduces code size. */ 416 case ARRAY_TYPE: 417 case POINTER_TYPE: 418 case REFERENCE_TYPE: 419 case OFFSET_TYPE: 420 offset_type: 421 case FUNCTION_TYPE: 422 case METHOD_TYPE: 423 { 424 dump_type_prefix (t, flags); 425 dump_type_suffix (t, flags); 426 break; 427 } 428 case TYPENAME_TYPE: 429 if (! (flags & TFF_CHASE_TYPEDEF) 430 && DECL_ORIGINAL_TYPE (TYPE_NAME (t))) 431 { 432 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER); 433 break; 434 } 435 pp_cxx_cv_qualifier_seq (cxx_pp, t); 436 pp_cxx_ws_string (cxx_pp, 437 TYPENAME_IS_ENUM_P (t) ? "enum" 438 : TYPENAME_IS_CLASS_P (t) ? "class" 439 : "typename"); 440 dump_typename (t, flags); 441 break; 442 443 case UNBOUND_CLASS_TEMPLATE: 444 if (! (flags & TFF_UNQUALIFIED_NAME)) 445 { 446 dump_type (TYPE_CONTEXT (t), flags); 447 pp_cxx_colon_colon (cxx_pp); 448 } 449 pp_cxx_ws_string (cxx_pp, "template"); 450 dump_type (DECL_NAME (TYPE_NAME (t)), flags); 451 break; 452 453 case TYPEOF_TYPE: 454 pp_cxx_ws_string (cxx_pp, "__typeof__"); 455 pp_cxx_whitespace (cxx_pp); 456 pp_cxx_left_paren (cxx_pp); 457 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 458 pp_cxx_right_paren (cxx_pp); 459 break; 460 461 case TYPE_PACK_EXPANSION: 462 dump_type (PACK_EXPANSION_PATTERN (t), flags); 463 pp_cxx_ws_string (cxx_pp, "..."); 464 break; 465 466 case TYPE_ARGUMENT_PACK: 467 dump_template_argument (t, flags); 468 break; 469 470 case DECLTYPE_TYPE: 471 pp_cxx_ws_string (cxx_pp, "decltype"); 472 pp_cxx_whitespace (cxx_pp); 473 pp_cxx_left_paren (cxx_pp); 474 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 475 pp_cxx_right_paren (cxx_pp); 476 break; 477 478 default: 479 pp_unsupported_tree (cxx_pp, t); 480 /* Fall through to error. */ 481 482 case ERROR_MARK: 483 pp_string (cxx_pp, M_("<type error>")); 484 break; 485 } 486 } 487 488 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself 489 a TYPENAME_TYPE. */ 490 491 static void 492 dump_typename (tree t, int flags) 493 { 494 tree ctx = TYPE_CONTEXT (t); 495 496 if (TREE_CODE (ctx) == TYPENAME_TYPE) 497 dump_typename (ctx, flags); 498 else 499 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); 500 pp_cxx_colon_colon (cxx_pp); 501 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); 502 } 503 504 /* Return the name of the supplied aggregate, or enumeral type. */ 505 506 const char * 507 class_key_or_enum_as_string (tree t) 508 { 509 if (TREE_CODE (t) == ENUMERAL_TYPE) 510 { 511 if (SCOPED_ENUM_P (t)) 512 return "enum class"; 513 else 514 return "enum"; 515 } 516 else if (TREE_CODE (t) == UNION_TYPE) 517 return "union"; 518 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 519 return "class"; 520 else 521 return "struct"; 522 } 523 524 /* Print out a class declaration T under the control of FLAGS, 525 in the form `class foo'. */ 526 527 static void 528 dump_aggr_type (tree t, int flags) 529 { 530 tree name; 531 const char *variety = class_key_or_enum_as_string (t); 532 int typdef = 0; 533 int tmplate = 0; 534 535 pp_cxx_cv_qualifier_seq (cxx_pp, t); 536 537 if (flags & TFF_CLASS_KEY_OR_ENUM) 538 pp_cxx_ws_string (cxx_pp, variety); 539 540 name = TYPE_NAME (t); 541 542 if (name) 543 { 544 typdef = !DECL_ARTIFICIAL (name); 545 546 if ((typdef 547 && ((flags & TFF_CHASE_TYPEDEF) 548 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name) 549 && DECL_TEMPLATE_INFO (name)))) 550 || DECL_SELF_REFERENCE_P (name)) 551 { 552 t = TYPE_MAIN_VARIANT (t); 553 name = TYPE_NAME (t); 554 typdef = 0; 555 } 556 557 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE 558 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t) 559 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL 560 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); 561 562 if (! (flags & TFF_UNQUALIFIED_NAME)) 563 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE); 564 flags &= ~TFF_UNQUALIFIED_NAME; 565 if (tmplate) 566 { 567 /* Because the template names are mangled, we have to locate 568 the most general template, and use that name. */ 569 tree tpl = CLASSTYPE_TI_TEMPLATE (t); 570 571 while (DECL_TEMPLATE_INFO (tpl)) 572 tpl = DECL_TI_TEMPLATE (tpl); 573 name = tpl; 574 } 575 name = DECL_NAME (name); 576 } 577 578 if (name == 0 || ANON_AGGRNAME_P (name)) 579 { 580 if (flags & TFF_CLASS_KEY_OR_ENUM) 581 pp_string (cxx_pp, M_("<anonymous>")); 582 else 583 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety); 584 } 585 else if (LAMBDANAME_P (name)) 586 { 587 /* A lambda's "type" is essentially its signature. */ 588 pp_string (cxx_pp, M_("<lambda")); 589 if (lambda_function (t)) 590 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)), 591 flags); 592 pp_character(cxx_pp, '>'); 593 } 594 else 595 pp_cxx_tree_identifier (cxx_pp, name); 596 if (tmplate) 597 dump_template_parms (TYPE_TEMPLATE_INFO (t), 598 !CLASSTYPE_USE_TEMPLATE (t), 599 flags & ~TFF_TEMPLATE_HEADER); 600 } 601 602 /* Dump into the obstack the initial part of the output for a given type. 603 This is necessary when dealing with things like functions returning 604 functions. Examples: 605 606 return type of `int (* fee ())()': pointer -> function -> int. Both 607 pointer (and reference and offset) and function (and member) types must 608 deal with prefix and suffix. 609 610 Arrays must also do this for DECL nodes, like int a[], and for things like 611 int *[]&. */ 612 613 static void 614 dump_type_prefix (tree t, int flags) 615 { 616 if (TYPE_PTRMEMFUNC_P (t)) 617 { 618 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 619 goto offset_type; 620 } 621 622 switch (TREE_CODE (t)) 623 { 624 case POINTER_TYPE: 625 case REFERENCE_TYPE: 626 { 627 tree sub = TREE_TYPE (t); 628 629 dump_type_prefix (sub, flags); 630 if (TREE_CODE (sub) == ARRAY_TYPE 631 || TREE_CODE (sub) == FUNCTION_TYPE) 632 { 633 pp_cxx_whitespace (cxx_pp); 634 pp_cxx_left_paren (cxx_pp); 635 } 636 if (TREE_CODE (t) == POINTER_TYPE) 637 pp_character(cxx_pp, '*'); 638 else if (TREE_CODE (t) == REFERENCE_TYPE) 639 { 640 if (TYPE_REF_IS_RVALUE (t)) 641 pp_string (cxx_pp, "&&"); 642 else 643 pp_character (cxx_pp, '&'); 644 } 645 pp_base (cxx_pp)->padding = pp_before; 646 pp_cxx_cv_qualifier_seq (cxx_pp, t); 647 } 648 break; 649 650 case OFFSET_TYPE: 651 offset_type: 652 dump_type_prefix (TREE_TYPE (t), flags); 653 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ 654 { 655 pp_maybe_space (cxx_pp); 656 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 657 pp_cxx_left_paren (cxx_pp); 658 dump_type (TYPE_OFFSET_BASETYPE (t), flags); 659 pp_cxx_colon_colon (cxx_pp); 660 } 661 pp_cxx_star (cxx_pp); 662 pp_cxx_cv_qualifier_seq (cxx_pp, t); 663 pp_base (cxx_pp)->padding = pp_before; 664 break; 665 666 /* This can be reached without a pointer when dealing with 667 templates, e.g. std::is_function. */ 668 case FUNCTION_TYPE: 669 dump_type_prefix (TREE_TYPE (t), flags); 670 break; 671 672 case METHOD_TYPE: 673 dump_type_prefix (TREE_TYPE (t), flags); 674 pp_maybe_space (cxx_pp); 675 pp_cxx_left_paren (cxx_pp); 676 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); 677 pp_cxx_colon_colon (cxx_pp); 678 break; 679 680 case ARRAY_TYPE: 681 dump_type_prefix (TREE_TYPE (t), flags); 682 break; 683 684 case ENUMERAL_TYPE: 685 case IDENTIFIER_NODE: 686 case INTEGER_TYPE: 687 case BOOLEAN_TYPE: 688 case REAL_TYPE: 689 case RECORD_TYPE: 690 case TEMPLATE_TYPE_PARM: 691 case TEMPLATE_TEMPLATE_PARM: 692 case BOUND_TEMPLATE_TEMPLATE_PARM: 693 case TREE_LIST: 694 case TYPE_DECL: 695 case TREE_VEC: 696 case UNION_TYPE: 697 case UNKNOWN_TYPE: 698 case VOID_TYPE: 699 case TYPENAME_TYPE: 700 case COMPLEX_TYPE: 701 case VECTOR_TYPE: 702 case TYPEOF_TYPE: 703 case DECLTYPE_TYPE: 704 case TYPE_PACK_EXPANSION: 705 case FIXED_POINT_TYPE: 706 dump_type (t, flags); 707 pp_base (cxx_pp)->padding = pp_before; 708 break; 709 710 default: 711 pp_unsupported_tree (cxx_pp, t); 712 /* fall through. */ 713 case ERROR_MARK: 714 pp_string (cxx_pp, M_("<typeprefixerror>")); 715 break; 716 } 717 } 718 719 /* Dump the suffix of type T, under control of FLAGS. This is the part 720 which appears after the identifier (or function parms). */ 721 722 static void 723 dump_type_suffix (tree t, int flags) 724 { 725 if (TYPE_PTRMEMFUNC_P (t)) 726 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 727 728 switch (TREE_CODE (t)) 729 { 730 case POINTER_TYPE: 731 case REFERENCE_TYPE: 732 case OFFSET_TYPE: 733 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE 734 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) 735 pp_cxx_right_paren (cxx_pp); 736 dump_type_suffix (TREE_TYPE (t), flags); 737 break; 738 739 case FUNCTION_TYPE: 740 case METHOD_TYPE: 741 { 742 tree arg; 743 if (TREE_CODE (t) == METHOD_TYPE) 744 /* Can only be reached through a pointer. */ 745 pp_cxx_right_paren (cxx_pp); 746 arg = TYPE_ARG_TYPES (t); 747 if (TREE_CODE (t) == METHOD_TYPE) 748 arg = TREE_CHAIN (arg); 749 750 /* Function pointers don't have default args. Not in standard C++, 751 anyway; they may in g++, but we'll just pretend otherwise. */ 752 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); 753 754 if (TREE_CODE (t) == METHOD_TYPE) 755 pp_cxx_cv_qualifier_seq 756 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t)))); 757 else 758 pp_cxx_cv_qualifier_seq (cxx_pp, t); 759 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags); 760 dump_type_suffix (TREE_TYPE (t), flags); 761 break; 762 } 763 764 case ARRAY_TYPE: 765 pp_maybe_space (cxx_pp); 766 pp_cxx_left_bracket (cxx_pp); 767 if (TYPE_DOMAIN (t)) 768 { 769 tree dtype = TYPE_DOMAIN (t); 770 tree max = TYPE_MAX_VALUE (dtype); 771 if (host_integerp (max, 0)) 772 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1); 773 else if (TREE_CODE (max) == MINUS_EXPR) 774 dump_expr (TREE_OPERAND (max, 0), 775 flags & ~TFF_EXPR_IN_PARENS); 776 else 777 dump_expr (fold_build2_loc (input_location, 778 PLUS_EXPR, dtype, max, 779 build_int_cst (dtype, 1)), 780 flags & ~TFF_EXPR_IN_PARENS); 781 } 782 pp_cxx_right_bracket (cxx_pp); 783 dump_type_suffix (TREE_TYPE (t), flags); 784 break; 785 786 case ENUMERAL_TYPE: 787 case IDENTIFIER_NODE: 788 case INTEGER_TYPE: 789 case BOOLEAN_TYPE: 790 case REAL_TYPE: 791 case RECORD_TYPE: 792 case TEMPLATE_TYPE_PARM: 793 case TEMPLATE_TEMPLATE_PARM: 794 case BOUND_TEMPLATE_TEMPLATE_PARM: 795 case TREE_LIST: 796 case TYPE_DECL: 797 case TREE_VEC: 798 case UNION_TYPE: 799 case UNKNOWN_TYPE: 800 case VOID_TYPE: 801 case TYPENAME_TYPE: 802 case COMPLEX_TYPE: 803 case VECTOR_TYPE: 804 case TYPEOF_TYPE: 805 case DECLTYPE_TYPE: 806 case TYPE_PACK_EXPANSION: 807 case FIXED_POINT_TYPE: 808 break; 809 810 default: 811 pp_unsupported_tree (cxx_pp, t); 812 case ERROR_MARK: 813 /* Don't mark it here, we should have already done in 814 dump_type_prefix. */ 815 break; 816 } 817 } 818 819 static void 820 dump_global_iord (tree t) 821 { 822 const char *p = NULL; 823 824 if (DECL_GLOBAL_CTOR_P (t)) 825 p = M_("(static initializers for %s)"); 826 else if (DECL_GLOBAL_DTOR_P (t)) 827 p = M_("(static destructors for %s)"); 828 else 829 gcc_unreachable (); 830 831 pp_printf (pp_base (cxx_pp), p, input_filename); 832 } 833 834 static void 835 dump_simple_decl (tree t, tree type, int flags) 836 { 837 if (flags & TFF_DECL_SPECIFIERS) 838 { 839 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME); 840 pp_maybe_space (cxx_pp); 841 } 842 if (! (flags & TFF_UNQUALIFIED_NAME) 843 && TREE_CODE (t) != PARM_DECL 844 && (!DECL_INITIAL (t) 845 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)) 846 dump_scope (CP_DECL_CONTEXT (t), flags); 847 flags &= ~TFF_UNQUALIFIED_NAME; 848 if ((flags & TFF_DECL_SPECIFIERS) 849 && DECL_TEMPLATE_PARM_P (t) 850 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t))) 851 pp_string (cxx_pp, "..."); 852 if (DECL_NAME (t)) 853 dump_decl (DECL_NAME (t), flags); 854 else 855 pp_string (cxx_pp, M_("<anonymous>")); 856 if (flags & TFF_DECL_SPECIFIERS) 857 dump_type_suffix (type, flags); 858 } 859 860 /* Dump a human readable string for the decl T under control of FLAGS. */ 861 862 static void 863 dump_decl (tree t, int flags) 864 { 865 if (t == NULL_TREE) 866 return; 867 868 switch (TREE_CODE (t)) 869 { 870 case TYPE_DECL: 871 /* Don't say 'typedef class A' */ 872 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t)) 873 { 874 if ((flags & TFF_DECL_SPECIFIERS) 875 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) 876 { 877 /* Say `class T' not just `T'. */ 878 pp_cxx_ws_string (cxx_pp, "class"); 879 880 /* Emit the `...' for a parameter pack. */ 881 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) 882 pp_cxx_ws_string (cxx_pp, "..."); 883 } 884 885 dump_type (TREE_TYPE (t), flags); 886 break; 887 } 888 if ((flags & TFF_DECL_SPECIFIERS) 889 && !DECL_SELF_REFERENCE_P (t)) 890 pp_cxx_ws_string (cxx_pp, "typedef"); 891 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) 892 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), 893 flags); 894 break; 895 896 case VAR_DECL: 897 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) 898 { 899 pp_string (cxx_pp, M_("vtable for ")); 900 gcc_assert (TYPE_P (DECL_CONTEXT (t))); 901 dump_type (DECL_CONTEXT (t), flags); 902 break; 903 } 904 /* Else fall through. */ 905 case FIELD_DECL: 906 case PARM_DECL: 907 dump_simple_decl (t, TREE_TYPE (t), flags); 908 break; 909 910 case RESULT_DECL: 911 pp_string (cxx_pp, M_("<return value> ")); 912 dump_simple_decl (t, TREE_TYPE (t), flags); 913 break; 914 915 case NAMESPACE_DECL: 916 if (flags & TFF_DECL_SPECIFIERS) 917 pp_cxx_declaration (cxx_pp, t); 918 else 919 { 920 if (! (flags & TFF_UNQUALIFIED_NAME)) 921 dump_scope (CP_DECL_CONTEXT (t), flags); 922 flags &= ~TFF_UNQUALIFIED_NAME; 923 if (DECL_NAME (t) == NULL_TREE) 924 pp_string (cxx_pp, M_("<unnamed>")); 925 else 926 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 927 } 928 break; 929 930 case SCOPE_REF: 931 dump_type (TREE_OPERAND (t, 0), flags); 932 pp_string (cxx_pp, "::"); 933 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME); 934 break; 935 936 case ARRAY_REF: 937 dump_decl (TREE_OPERAND (t, 0), flags); 938 pp_cxx_left_bracket (cxx_pp); 939 dump_decl (TREE_OPERAND (t, 1), flags); 940 pp_cxx_right_bracket (cxx_pp); 941 break; 942 943 /* So that we can do dump_decl on an aggr type. */ 944 case RECORD_TYPE: 945 case UNION_TYPE: 946 case ENUMERAL_TYPE: 947 dump_type (t, flags); 948 break; 949 950 case BIT_NOT_EXPR: 951 /* This is a pseudo destructor call which has not been folded into 952 a PSEUDO_DTOR_EXPR yet. */ 953 pp_cxx_complement (cxx_pp); 954 dump_type (TREE_OPERAND (t, 0), flags); 955 break; 956 957 case TYPE_EXPR: 958 gcc_unreachable (); 959 break; 960 961 /* These special cases are duplicated here so that other functions 962 can feed identifiers to error and get them demangled properly. */ 963 case IDENTIFIER_NODE: 964 if (IDENTIFIER_TYPENAME_P (t)) 965 { 966 pp_cxx_ws_string (cxx_pp, "operator"); 967 /* Not exactly IDENTIFIER_TYPE_VALUE. */ 968 dump_type (TREE_TYPE (t), flags); 969 break; 970 } 971 else 972 pp_cxx_tree_identifier (cxx_pp, t); 973 break; 974 975 case OVERLOAD: 976 if (OVL_CHAIN (t)) 977 { 978 t = OVL_CURRENT (t); 979 if (DECL_CLASS_SCOPE_P (t)) 980 { 981 dump_type (DECL_CONTEXT (t), flags); 982 pp_cxx_colon_colon (cxx_pp); 983 } 984 else if (DECL_CONTEXT (t)) 985 { 986 dump_decl (DECL_CONTEXT (t), flags); 987 pp_cxx_colon_colon (cxx_pp); 988 } 989 dump_decl (DECL_NAME (t), flags); 990 break; 991 } 992 993 /* If there's only one function, just treat it like an ordinary 994 FUNCTION_DECL. */ 995 t = OVL_CURRENT (t); 996 /* Fall through. */ 997 998 case FUNCTION_DECL: 999 if (! DECL_LANG_SPECIFIC (t)) 1000 pp_string (cxx_pp, M_("<built-in>")); 1001 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) 1002 dump_global_iord (t); 1003 else 1004 dump_function_decl (t, flags); 1005 break; 1006 1007 case TEMPLATE_DECL: 1008 dump_template_decl (t, flags); 1009 break; 1010 1011 case TEMPLATE_ID_EXPR: 1012 { 1013 tree name = TREE_OPERAND (t, 0); 1014 1015 if (is_overloaded_fn (name)) 1016 name = DECL_NAME (get_first_fn (name)); 1017 dump_decl (name, flags); 1018 pp_cxx_begin_template_argument_list (cxx_pp); 1019 if (TREE_OPERAND (t, 1)) 1020 dump_template_argument_list (TREE_OPERAND (t, 1), flags); 1021 pp_cxx_end_template_argument_list (cxx_pp); 1022 } 1023 break; 1024 1025 case LABEL_DECL: 1026 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 1027 break; 1028 1029 case CONST_DECL: 1030 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) 1031 || (DECL_INITIAL (t) && 1032 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) 1033 dump_simple_decl (t, TREE_TYPE (t), flags); 1034 else if (DECL_NAME (t)) 1035 dump_decl (DECL_NAME (t), flags); 1036 else if (DECL_INITIAL (t)) 1037 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); 1038 else 1039 pp_string (cxx_pp, M_("<enumerator>")); 1040 break; 1041 1042 case USING_DECL: 1043 pp_cxx_ws_string (cxx_pp, "using"); 1044 dump_type (USING_DECL_SCOPE (t), flags); 1045 pp_cxx_colon_colon (cxx_pp); 1046 dump_decl (DECL_NAME (t), flags); 1047 break; 1048 1049 case STATIC_ASSERT: 1050 pp_cxx_declaration (cxx_pp, t); 1051 break; 1052 1053 case BASELINK: 1054 dump_decl (BASELINK_FUNCTIONS (t), flags); 1055 break; 1056 1057 case NON_DEPENDENT_EXPR: 1058 dump_expr (t, flags); 1059 break; 1060 1061 case TEMPLATE_TYPE_PARM: 1062 if (flags & TFF_DECL_SPECIFIERS) 1063 pp_cxx_declaration (cxx_pp, t); 1064 else 1065 pp_type_id (cxx_pp, t); 1066 break; 1067 1068 case UNBOUND_CLASS_TEMPLATE: 1069 case TYPE_PACK_EXPANSION: 1070 case TREE_BINFO: 1071 dump_type (t, flags); 1072 break; 1073 1074 default: 1075 pp_unsupported_tree (cxx_pp, t); 1076 /* Fall through to error. */ 1077 1078 case ERROR_MARK: 1079 pp_string (cxx_pp, M_("<declaration error>")); 1080 break; 1081 } 1082 } 1083 1084 /* Dump a template declaration T under control of FLAGS. This means the 1085 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ 1086 1087 static void 1088 dump_template_decl (tree t, int flags) 1089 { 1090 tree orig_parms = DECL_TEMPLATE_PARMS (t); 1091 tree parms; 1092 int i; 1093 1094 if (flags & TFF_TEMPLATE_HEADER) 1095 { 1096 for (parms = orig_parms = nreverse (orig_parms); 1097 parms; 1098 parms = TREE_CHAIN (parms)) 1099 { 1100 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); 1101 int len = TREE_VEC_LENGTH (inner_parms); 1102 1103 pp_cxx_ws_string (cxx_pp, "template"); 1104 pp_cxx_begin_template_argument_list (cxx_pp); 1105 1106 /* If we've shown the template prefix, we'd better show the 1107 parameters' and decl's type too. */ 1108 flags |= TFF_DECL_SPECIFIERS; 1109 1110 for (i = 0; i < len; i++) 1111 { 1112 if (i) 1113 pp_separate_with_comma (cxx_pp); 1114 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); 1115 } 1116 pp_cxx_end_template_argument_list (cxx_pp); 1117 pp_cxx_whitespace (cxx_pp); 1118 } 1119 nreverse(orig_parms); 1120 1121 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 1122 { 1123 /* Say `template<arg> class TT' not just `template<arg> TT'. */ 1124 pp_cxx_ws_string (cxx_pp, "class"); 1125 1126 /* If this is a parameter pack, print the ellipsis. */ 1127 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) 1128 pp_cxx_ws_string (cxx_pp, "..."); 1129 } 1130 } 1131 1132 if (DECL_TEMPLATE_RESULT (t) 1133 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) 1134 dump_type (TREE_TYPE (t), 1135 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 1136 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); 1137 else if (DECL_TEMPLATE_RESULT (t) 1138 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) 1139 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); 1140 else 1141 { 1142 gcc_assert (TREE_TYPE (t)); 1143 switch (NEXT_CODE (t)) 1144 { 1145 case METHOD_TYPE: 1146 case FUNCTION_TYPE: 1147 dump_function_decl (t, flags | TFF_TEMPLATE_NAME); 1148 break; 1149 default: 1150 /* This case can occur with some invalid code. */ 1151 dump_type (TREE_TYPE (t), 1152 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 1153 | (flags & TFF_DECL_SPECIFIERS 1154 ? TFF_CLASS_KEY_OR_ENUM : 0)); 1155 } 1156 } 1157 } 1158 1159 /* find_typenames looks through the type of the function template T 1160 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs 1161 it finds. */ 1162 1163 struct find_typenames_t 1164 { 1165 struct pointer_set_t *p_set; 1166 VEC (tree,gc) *typenames; 1167 }; 1168 1169 static tree 1170 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data) 1171 { 1172 struct find_typenames_t *d = (struct find_typenames_t *)data; 1173 tree mv = NULL_TREE; 1174 1175 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp))) 1176 /* Add the type of the typedef without any additional cv-quals. */ 1177 mv = TREE_TYPE (TYPE_NAME (*tp)); 1178 else if (TREE_CODE (*tp) == TYPENAME_TYPE 1179 || TREE_CODE (*tp) == DECLTYPE_TYPE) 1180 /* Add the typename without any cv-qualifiers. */ 1181 mv = TYPE_MAIN_VARIANT (*tp); 1182 1183 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv))) 1184 VEC_safe_push (tree, gc, d->typenames, mv); 1185 1186 /* Search into class template arguments, which cp_walk_subtrees 1187 doesn't do. */ 1188 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp)) 1189 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r, 1190 data, d->p_set); 1191 1192 return NULL_TREE; 1193 } 1194 1195 static VEC(tree,gc) * 1196 find_typenames (tree t) 1197 { 1198 struct find_typenames_t ft; 1199 ft.p_set = pointer_set_create (); 1200 ft.typenames = NULL; 1201 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)), 1202 find_typenames_r, &ft, ft.p_set); 1203 pointer_set_destroy (ft.p_set); 1204 return ft.typenames; 1205 } 1206 1207 /* Pretty print a function decl. There are several ways we want to print a 1208 function declaration. The TFF_ bits in FLAGS tells us how to behave. 1209 As error can only apply the '#' flag once to give 0 and 1 for V, there 1210 is %D which doesn't print the throw specs, and %F which does. */ 1211 1212 static void 1213 dump_function_decl (tree t, int flags) 1214 { 1215 tree fntype; 1216 tree parmtypes; 1217 tree cname = NULL_TREE; 1218 tree template_args = NULL_TREE; 1219 tree template_parms = NULL_TREE; 1220 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; 1221 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME); 1222 tree exceptions; 1223 VEC(tree,gc) *typenames = NULL; 1224 1225 if (LAMBDA_FUNCTION_P (t)) 1226 { 1227 /* A lambda's signature is essentially its "type", so defer. */ 1228 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t))); 1229 dump_type (DECL_CONTEXT (t), flags); 1230 return; 1231 } 1232 1233 flags &= ~TFF_UNQUALIFIED_NAME; 1234 if (TREE_CODE (t) == TEMPLATE_DECL) 1235 t = DECL_TEMPLATE_RESULT (t); 1236 1237 /* Save the exceptions, in case t is a specialization and we are 1238 emitting an error about incompatible specifications. */ 1239 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t)); 1240 1241 /* Pretty print template instantiations only. */ 1242 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t) 1243 && flag_pretty_templates) 1244 { 1245 tree tmpl; 1246 1247 template_args = DECL_TI_ARGS (t); 1248 tmpl = most_general_template (t); 1249 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) 1250 { 1251 template_parms = DECL_TEMPLATE_PARMS (tmpl); 1252 t = tmpl; 1253 typenames = find_typenames (t); 1254 } 1255 } 1256 1257 fntype = TREE_TYPE (t); 1258 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); 1259 1260 if (DECL_CLASS_SCOPE_P (t)) 1261 cname = DECL_CONTEXT (t); 1262 /* This is for partially instantiated template methods. */ 1263 else if (TREE_CODE (fntype) == METHOD_TYPE) 1264 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 1265 1266 if (!(flags & TFF_DECL_SPECIFIERS)) 1267 /* OK */; 1268 else if (DECL_STATIC_FUNCTION_P (t)) 1269 pp_cxx_ws_string (cxx_pp, "static"); 1270 else if (DECL_VIRTUAL_P (t)) 1271 pp_cxx_ws_string (cxx_pp, "virtual"); 1272 1273 /* Print the return type? */ 1274 if (show_return) 1275 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) 1276 && !DECL_DESTRUCTOR_P (t); 1277 if (show_return) 1278 dump_type_prefix (TREE_TYPE (fntype), flags); 1279 1280 /* Print the function name. */ 1281 if (!do_outer_scope) 1282 /* Nothing. */; 1283 else if (cname) 1284 { 1285 dump_type (cname, flags); 1286 pp_cxx_colon_colon (cxx_pp); 1287 } 1288 else 1289 dump_scope (CP_DECL_CONTEXT (t), flags); 1290 1291 dump_function_name (t, flags); 1292 1293 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) 1294 { 1295 dump_parameters (parmtypes, flags); 1296 1297 if (TREE_CODE (fntype) == METHOD_TYPE) 1298 { 1299 pp_base (cxx_pp)->padding = pp_before; 1300 pp_cxx_cv_qualifier_seq 1301 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); 1302 } 1303 1304 if (flags & TFF_EXCEPTION_SPECIFICATION) 1305 { 1306 pp_base (cxx_pp)->padding = pp_before; 1307 dump_exception_spec (exceptions, flags); 1308 } 1309 1310 if (show_return) 1311 dump_type_suffix (TREE_TYPE (fntype), flags); 1312 } 1313 1314 /* If T is a template instantiation, dump the parameter binding. */ 1315 if (template_parms != NULL_TREE && template_args != NULL_TREE) 1316 { 1317 pp_cxx_whitespace (cxx_pp); 1318 pp_cxx_left_bracket (cxx_pp); 1319 pp_cxx_ws_string (cxx_pp, M_("with")); 1320 pp_cxx_whitespace (cxx_pp); 1321 dump_template_bindings (template_parms, template_args, typenames); 1322 pp_cxx_right_bracket (cxx_pp); 1323 } 1324 } 1325 1326 /* Print a parameter list. If this is for a member function, the 1327 member object ptr (and any other hidden args) should have 1328 already been removed. */ 1329 1330 static void 1331 dump_parameters (tree parmtypes, int flags) 1332 { 1333 int first = 1; 1334 pp_cxx_left_paren (cxx_pp); 1335 1336 for (first = 1; parmtypes != void_list_node; 1337 parmtypes = TREE_CHAIN (parmtypes)) 1338 { 1339 if (!first) 1340 pp_separate_with_comma (cxx_pp); 1341 first = 0; 1342 if (!parmtypes) 1343 { 1344 pp_cxx_ws_string (cxx_pp, "..."); 1345 break; 1346 } 1347 1348 dump_type (TREE_VALUE (parmtypes), flags); 1349 1350 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) 1351 { 1352 pp_cxx_whitespace (cxx_pp); 1353 pp_equal (cxx_pp); 1354 pp_cxx_whitespace (cxx_pp); 1355 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); 1356 } 1357 } 1358 1359 pp_cxx_right_paren (cxx_pp); 1360 } 1361 1362 /* Print an exception specification. T is the exception specification. */ 1363 1364 static void 1365 dump_exception_spec (tree t, int flags) 1366 { 1367 if (t) 1368 { 1369 pp_cxx_ws_string (cxx_pp, "throw"); 1370 pp_cxx_whitespace (cxx_pp); 1371 pp_cxx_left_paren (cxx_pp); 1372 if (TREE_VALUE (t) != NULL_TREE) 1373 while (1) 1374 { 1375 dump_type (TREE_VALUE (t), flags); 1376 t = TREE_CHAIN (t); 1377 if (!t) 1378 break; 1379 pp_separate_with_comma (cxx_pp); 1380 } 1381 pp_cxx_right_paren (cxx_pp); 1382 } 1383 } 1384 1385 /* Handle the function name for a FUNCTION_DECL node, grokking operators 1386 and destructors properly. */ 1387 1388 static void 1389 dump_function_name (tree t, int flags) 1390 { 1391 tree name = DECL_NAME (t); 1392 1393 /* We can get here with a decl that was synthesized by language- 1394 independent machinery (e.g. coverage.c) in which case it won't 1395 have a lang_specific structure attached and DECL_CONSTRUCTOR_P 1396 will crash. In this case it is safe just to print out the 1397 literal name. */ 1398 if (!DECL_LANG_SPECIFIC (t)) 1399 { 1400 pp_cxx_tree_identifier (cxx_pp, name); 1401 return; 1402 } 1403 1404 if (TREE_CODE (t) == TEMPLATE_DECL) 1405 t = DECL_TEMPLATE_RESULT (t); 1406 1407 /* Don't let the user see __comp_ctor et al. */ 1408 if (DECL_CONSTRUCTOR_P (t) 1409 || DECL_DESTRUCTOR_P (t)) 1410 { 1411 if (LAMBDA_TYPE_P (DECL_CONTEXT (t))) 1412 name = get_identifier ("<lambda>"); 1413 else 1414 name = constructor_name (DECL_CONTEXT (t)); 1415 } 1416 1417 if (DECL_DESTRUCTOR_P (t)) 1418 { 1419 pp_cxx_complement (cxx_pp); 1420 dump_decl (name, TFF_PLAIN_IDENTIFIER); 1421 } 1422 else if (DECL_CONV_FN_P (t)) 1423 { 1424 /* This cannot use the hack that the operator's return 1425 type is stashed off of its name because it may be 1426 used for error reporting. In the case of conflicting 1427 declarations, both will have the same name, yet 1428 the types will be different, hence the TREE_TYPE field 1429 of the first name will be clobbered by the second. */ 1430 pp_cxx_ws_string (cxx_pp, "operator"); 1431 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1432 } 1433 else if (name && IDENTIFIER_OPNAME_P (name)) 1434 pp_cxx_tree_identifier (cxx_pp, name); 1435 else 1436 dump_decl (name, flags); 1437 1438 if (DECL_TEMPLATE_INFO (t) 1439 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) 1440 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1441 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1442 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags); 1443 } 1444 1445 /* Dump the template parameters from the template info INFO under control of 1446 FLAGS. PRIMARY indicates whether this is a primary template decl, or 1447 specialization (partial or complete). For partial specializations we show 1448 the specialized parameter values. For a primary template we show no 1449 decoration. */ 1450 1451 static void 1452 dump_template_parms (tree info, int primary, int flags) 1453 { 1454 tree args = info ? TI_ARGS (info) : NULL_TREE; 1455 1456 if (primary && flags & TFF_TEMPLATE_NAME) 1457 return; 1458 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); 1459 pp_cxx_begin_template_argument_list (cxx_pp); 1460 1461 /* Be careful only to print things when we have them, so as not 1462 to crash producing error messages. */ 1463 if (args && !primary) 1464 { 1465 int len, ix; 1466 len = get_non_default_template_args_count (args, flags); 1467 1468 args = INNERMOST_TEMPLATE_ARGS (args); 1469 for (ix = 0; ix != len; ix++) 1470 { 1471 tree arg = TREE_VEC_ELT (args, ix); 1472 1473 /* Only print a comma if we know there is an argument coming. In 1474 the case of an empty template argument pack, no actual 1475 argument will be printed. */ 1476 if (ix 1477 && (!ARGUMENT_PACK_P (arg) 1478 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0)) 1479 pp_separate_with_comma (cxx_pp); 1480 1481 if (!arg) 1482 pp_string (cxx_pp, M_("<template parameter error>")); 1483 else 1484 dump_template_argument (arg, flags); 1485 } 1486 } 1487 else if (primary) 1488 { 1489 tree tpl = TI_TEMPLATE (info); 1490 tree parms = DECL_TEMPLATE_PARMS (tpl); 1491 int len, ix; 1492 1493 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE; 1494 len = parms ? TREE_VEC_LENGTH (parms) : 0; 1495 1496 for (ix = 0; ix != len; ix++) 1497 { 1498 tree parm; 1499 1500 if (TREE_VEC_ELT (parms, ix) == error_mark_node) 1501 { 1502 pp_string (cxx_pp, M_("<template parameter error>")); 1503 continue; 1504 } 1505 1506 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix)); 1507 1508 if (ix) 1509 pp_separate_with_comma (cxx_pp); 1510 1511 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS); 1512 } 1513 } 1514 pp_cxx_end_template_argument_list (cxx_pp); 1515 } 1516 1517 /* Print out the arguments of CALL_EXPR T as a parenthesized list using 1518 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */ 1519 1520 static void 1521 dump_call_expr_args (tree t, int flags, bool skipfirst) 1522 { 1523 tree arg; 1524 call_expr_arg_iterator iter; 1525 1526 pp_cxx_left_paren (cxx_pp); 1527 FOR_EACH_CALL_EXPR_ARG (arg, iter, t) 1528 { 1529 if (skipfirst) 1530 skipfirst = false; 1531 else 1532 { 1533 dump_expr (arg, flags | TFF_EXPR_IN_PARENS); 1534 if (more_call_expr_args_p (&iter)) 1535 pp_separate_with_comma (cxx_pp); 1536 } 1537 } 1538 pp_cxx_right_paren (cxx_pp); 1539 } 1540 1541 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list 1542 using flags FLAGS. Skip over the first argument if SKIPFIRST is 1543 true. */ 1544 1545 static void 1546 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst) 1547 { 1548 tree arg; 1549 aggr_init_expr_arg_iterator iter; 1550 1551 pp_cxx_left_paren (cxx_pp); 1552 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) 1553 { 1554 if (skipfirst) 1555 skipfirst = false; 1556 else 1557 { 1558 dump_expr (arg, flags | TFF_EXPR_IN_PARENS); 1559 if (more_aggr_init_expr_args_p (&iter)) 1560 pp_separate_with_comma (cxx_pp); 1561 } 1562 } 1563 pp_cxx_right_paren (cxx_pp); 1564 } 1565 1566 /* Print out a list of initializers (subr of dump_expr). */ 1567 1568 static void 1569 dump_expr_list (tree l, int flags) 1570 { 1571 while (l) 1572 { 1573 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS); 1574 l = TREE_CHAIN (l); 1575 if (l) 1576 pp_separate_with_comma (cxx_pp); 1577 } 1578 } 1579 1580 /* Print out a vector of initializers (subr of dump_expr). */ 1581 1582 static void 1583 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags) 1584 { 1585 unsigned HOST_WIDE_INT idx; 1586 tree value; 1587 1588 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1589 { 1590 dump_expr (value, flags | TFF_EXPR_IN_PARENS); 1591 if (idx != VEC_length (constructor_elt, v) - 1) 1592 pp_separate_with_comma (cxx_pp); 1593 } 1594 } 1595 1596 1597 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual 1598 function. Resolve it to a close relative -- in the sense of static 1599 type -- variant being overridden. That is close to what was written in 1600 the source code. Subroutine of dump_expr. */ 1601 1602 static tree 1603 resolve_virtual_fun_from_obj_type_ref (tree ref) 1604 { 1605 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref)); 1606 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1); 1607 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type))); 1608 while (index) 1609 { 1610 fun = TREE_CHAIN (fun); 1611 index -= (TARGET_VTABLE_USES_DESCRIPTORS 1612 ? TARGET_VTABLE_USES_DESCRIPTORS : 1); 1613 } 1614 1615 return BV_FN (fun); 1616 } 1617 1618 /* Print out an expression E under control of FLAGS. */ 1619 1620 static void 1621 dump_expr (tree t, int flags) 1622 { 1623 if (t == 0) 1624 return; 1625 1626 if (STATEMENT_CLASS_P (t)) 1627 { 1628 pp_cxx_ws_string (cxx_pp, M_("<statement>")); 1629 return; 1630 } 1631 1632 switch (TREE_CODE (t)) 1633 { 1634 case VAR_DECL: 1635 case PARM_DECL: 1636 case FIELD_DECL: 1637 case CONST_DECL: 1638 case FUNCTION_DECL: 1639 case TEMPLATE_DECL: 1640 case NAMESPACE_DECL: 1641 case LABEL_DECL: 1642 case OVERLOAD: 1643 case IDENTIFIER_NODE: 1644 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS); 1645 break; 1646 1647 case INTEGER_CST: 1648 case REAL_CST: 1649 case STRING_CST: 1650 case COMPLEX_CST: 1651 pp_constant (cxx_pp, t); 1652 break; 1653 1654 case THROW_EXPR: 1655 /* While waiting for caret diagnostics, avoid printing 1656 __cxa_allocate_exception, __cxa_throw, and the like. */ 1657 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>")); 1658 break; 1659 1660 case PTRMEM_CST: 1661 pp_ampersand (cxx_pp); 1662 dump_type (PTRMEM_CST_CLASS (t), flags); 1663 pp_cxx_colon_colon (cxx_pp); 1664 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); 1665 break; 1666 1667 case COMPOUND_EXPR: 1668 pp_cxx_left_paren (cxx_pp); 1669 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1670 pp_separate_with_comma (cxx_pp); 1671 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1672 pp_cxx_right_paren (cxx_pp); 1673 break; 1674 1675 case COND_EXPR: 1676 pp_cxx_left_paren (cxx_pp); 1677 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1678 pp_string (cxx_pp, " ? "); 1679 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1680 pp_string (cxx_pp, " : "); 1681 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); 1682 pp_cxx_right_paren (cxx_pp); 1683 break; 1684 1685 case SAVE_EXPR: 1686 if (TREE_HAS_CONSTRUCTOR (t)) 1687 { 1688 pp_cxx_ws_string (cxx_pp, "new"); 1689 pp_cxx_whitespace (cxx_pp); 1690 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1691 } 1692 else 1693 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1694 break; 1695 1696 case AGGR_INIT_EXPR: 1697 { 1698 tree fn = NULL_TREE; 1699 1700 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR) 1701 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0); 1702 1703 if (fn && TREE_CODE (fn) == FUNCTION_DECL) 1704 { 1705 if (DECL_CONSTRUCTOR_P (fn)) 1706 dump_type (DECL_CONTEXT (fn), flags); 1707 else 1708 dump_decl (fn, 0); 1709 } 1710 else 1711 dump_expr (AGGR_INIT_EXPR_FN (t), 0); 1712 } 1713 dump_aggr_init_expr_args (t, flags, true); 1714 break; 1715 1716 case CALL_EXPR: 1717 { 1718 tree fn = CALL_EXPR_FN (t); 1719 bool skipfirst = false; 1720 1721 if (TREE_CODE (fn) == ADDR_EXPR) 1722 fn = TREE_OPERAND (fn, 0); 1723 1724 /* Nobody is interested in seeing the guts of vcalls. */ 1725 if (TREE_CODE (fn) == OBJ_TYPE_REF) 1726 fn = resolve_virtual_fun_from_obj_type_ref (fn); 1727 1728 if (TREE_TYPE (fn) != NULL_TREE 1729 && NEXT_CODE (fn) == METHOD_TYPE 1730 && call_expr_nargs (t)) 1731 { 1732 tree ob = CALL_EXPR_ARG (t, 0); 1733 if (TREE_CODE (ob) == ADDR_EXPR) 1734 { 1735 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1736 pp_cxx_dot (cxx_pp); 1737 } 1738 else if (TREE_CODE (ob) != PARM_DECL 1739 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1740 { 1741 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1742 pp_cxx_arrow (cxx_pp); 1743 } 1744 skipfirst = true; 1745 } 1746 dump_expr (fn, flags | TFF_EXPR_IN_PARENS); 1747 dump_call_expr_args (t, flags, skipfirst); 1748 } 1749 break; 1750 1751 case TARGET_EXPR: 1752 /* Note that this only works for G++ target exprs. If somebody 1753 builds a general TARGET_EXPR, there's no way to represent that 1754 it initializes anything other that the parameter slot for the 1755 default argument. Note we may have cleared out the first 1756 operand in expand_expr, so don't go killing ourselves. */ 1757 if (TREE_OPERAND (t, 1)) 1758 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1759 break; 1760 1761 case POINTER_PLUS_EXPR: 1762 dump_binary_op ("+", t, flags); 1763 break; 1764 1765 case INIT_EXPR: 1766 case MODIFY_EXPR: 1767 case PLUS_EXPR: 1768 case MINUS_EXPR: 1769 case MULT_EXPR: 1770 case TRUNC_DIV_EXPR: 1771 case TRUNC_MOD_EXPR: 1772 case MIN_EXPR: 1773 case MAX_EXPR: 1774 case LSHIFT_EXPR: 1775 case RSHIFT_EXPR: 1776 case BIT_IOR_EXPR: 1777 case BIT_XOR_EXPR: 1778 case BIT_AND_EXPR: 1779 case TRUTH_ANDIF_EXPR: 1780 case TRUTH_ORIF_EXPR: 1781 case LT_EXPR: 1782 case LE_EXPR: 1783 case GT_EXPR: 1784 case GE_EXPR: 1785 case EQ_EXPR: 1786 case NE_EXPR: 1787 case EXACT_DIV_EXPR: 1788 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags); 1789 break; 1790 1791 case CEIL_DIV_EXPR: 1792 case FLOOR_DIV_EXPR: 1793 case ROUND_DIV_EXPR: 1794 case RDIV_EXPR: 1795 dump_binary_op ("/", t, flags); 1796 break; 1797 1798 case CEIL_MOD_EXPR: 1799 case FLOOR_MOD_EXPR: 1800 case ROUND_MOD_EXPR: 1801 dump_binary_op ("%", t, flags); 1802 break; 1803 1804 case COMPONENT_REF: 1805 { 1806 tree ob = TREE_OPERAND (t, 0); 1807 if (TREE_CODE (ob) == INDIRECT_REF) 1808 { 1809 ob = TREE_OPERAND (ob, 0); 1810 if (TREE_CODE (ob) != PARM_DECL 1811 || (DECL_NAME (ob) 1812 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))) 1813 { 1814 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1815 pp_cxx_arrow (cxx_pp); 1816 } 1817 } 1818 else 1819 { 1820 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1821 pp_cxx_dot (cxx_pp); 1822 } 1823 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); 1824 } 1825 break; 1826 1827 case ARRAY_REF: 1828 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1829 pp_cxx_left_bracket (cxx_pp); 1830 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1831 pp_cxx_right_bracket (cxx_pp); 1832 break; 1833 1834 case UNARY_PLUS_EXPR: 1835 dump_unary_op ("+", t, flags); 1836 break; 1837 1838 case ADDR_EXPR: 1839 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 1840 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST 1841 /* An ADDR_EXPR can have reference type. In that case, we 1842 shouldn't print the `&' doing so indicates to the user 1843 that the expression has pointer type. */ 1844 || (TREE_TYPE (t) 1845 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)) 1846 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1847 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL) 1848 dump_unary_op ("&&", t, flags); 1849 else 1850 dump_unary_op ("&", t, flags); 1851 break; 1852 1853 case INDIRECT_REF: 1854 if (TREE_HAS_CONSTRUCTOR (t)) 1855 { 1856 t = TREE_OPERAND (t, 0); 1857 gcc_assert (TREE_CODE (t) == CALL_EXPR); 1858 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS); 1859 dump_call_expr_args (t, flags, true); 1860 } 1861 else 1862 { 1863 if (TREE_OPERAND (t,0) != NULL_TREE 1864 && TREE_TYPE (TREE_OPERAND (t, 0)) 1865 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 1866 dump_expr (TREE_OPERAND (t, 0), flags); 1867 else 1868 dump_unary_op ("*", t, flags); 1869 } 1870 break; 1871 1872 case NEGATE_EXPR: 1873 case BIT_NOT_EXPR: 1874 case TRUTH_NOT_EXPR: 1875 case PREDECREMENT_EXPR: 1876 case PREINCREMENT_EXPR: 1877 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags); 1878 break; 1879 1880 case POSTDECREMENT_EXPR: 1881 case POSTINCREMENT_EXPR: 1882 pp_cxx_left_paren (cxx_pp); 1883 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1884 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); 1885 pp_cxx_right_paren (cxx_pp); 1886 break; 1887 1888 case NON_LVALUE_EXPR: 1889 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 1890 should be another level of INDIRECT_REF so that I don't have to do 1891 this. */ 1892 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 1893 { 1894 tree next = TREE_TYPE (TREE_TYPE (t)); 1895 1896 while (TREE_CODE (next) == POINTER_TYPE) 1897 next = TREE_TYPE (next); 1898 1899 if (TREE_CODE (next) == FUNCTION_TYPE) 1900 { 1901 if (flags & TFF_EXPR_IN_PARENS) 1902 pp_cxx_left_paren (cxx_pp); 1903 pp_cxx_star (cxx_pp); 1904 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1905 if (flags & TFF_EXPR_IN_PARENS) 1906 pp_cxx_right_paren (cxx_pp); 1907 break; 1908 } 1909 /* Else fall through. */ 1910 } 1911 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1912 break; 1913 1914 CASE_CONVERT: 1915 case VIEW_CONVERT_EXPR: 1916 { 1917 tree op = TREE_OPERAND (t, 0); 1918 1919 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))) 1920 { 1921 /* It is a cast, but we cannot tell whether it is a 1922 reinterpret or static cast. Use the C style notation. */ 1923 if (flags & TFF_EXPR_IN_PARENS) 1924 pp_cxx_left_paren (cxx_pp); 1925 pp_cxx_left_paren (cxx_pp); 1926 dump_type (TREE_TYPE (t), flags); 1927 pp_cxx_right_paren (cxx_pp); 1928 dump_expr (op, flags | TFF_EXPR_IN_PARENS); 1929 if (flags & TFF_EXPR_IN_PARENS) 1930 pp_cxx_right_paren (cxx_pp); 1931 } 1932 else 1933 dump_expr (op, flags); 1934 break; 1935 } 1936 1937 case CONSTRUCTOR: 1938 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 1939 { 1940 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier); 1941 1942 if (integer_zerop (idx)) 1943 { 1944 /* A NULL pointer-to-member constant. */ 1945 pp_cxx_left_paren (cxx_pp); 1946 pp_cxx_left_paren (cxx_pp); 1947 dump_type (TREE_TYPE (t), flags); 1948 pp_cxx_right_paren (cxx_pp); 1949 pp_character (cxx_pp, '0'); 1950 pp_cxx_right_paren (cxx_pp); 1951 break; 1952 } 1953 else if (host_integerp (idx, 0)) 1954 { 1955 tree virtuals; 1956 unsigned HOST_WIDE_INT n; 1957 1958 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 1959 t = TYPE_METHOD_BASETYPE (t); 1960 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 1961 1962 n = tree_low_cst (idx, 0); 1963 1964 /* Map vtable index back one, to allow for the null pointer to 1965 member. */ 1966 --n; 1967 1968 while (n > 0 && virtuals) 1969 { 1970 --n; 1971 virtuals = TREE_CHAIN (virtuals); 1972 } 1973 if (virtuals) 1974 { 1975 dump_expr (BV_FN (virtuals), 1976 flags | TFF_EXPR_IN_PARENS); 1977 break; 1978 } 1979 } 1980 } 1981 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t)) 1982 { 1983 dump_type (TREE_TYPE (t), 0); 1984 pp_cxx_left_paren (cxx_pp); 1985 pp_cxx_right_paren (cxx_pp); 1986 } 1987 else 1988 { 1989 pp_cxx_left_brace (cxx_pp); 1990 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags); 1991 pp_cxx_right_brace (cxx_pp); 1992 } 1993 1994 break; 1995 1996 case OFFSET_REF: 1997 { 1998 tree ob = TREE_OPERAND (t, 0); 1999 if (is_dummy_object (ob)) 2000 { 2001 t = TREE_OPERAND (t, 1); 2002 if (TREE_CODE (t) == FUNCTION_DECL) 2003 /* A::f */ 2004 dump_expr (t, flags | TFF_EXPR_IN_PARENS); 2005 else if (BASELINK_P (t)) 2006 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 2007 flags | TFF_EXPR_IN_PARENS); 2008 else 2009 dump_decl (t, flags); 2010 } 2011 else 2012 { 2013 if (TREE_CODE (ob) == INDIRECT_REF) 2014 { 2015 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 2016 pp_cxx_arrow (cxx_pp); 2017 pp_cxx_star (cxx_pp); 2018 } 2019 else 2020 { 2021 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 2022 pp_cxx_dot (cxx_pp); 2023 pp_cxx_star (cxx_pp); 2024 } 2025 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2026 } 2027 break; 2028 } 2029 2030 case TEMPLATE_PARM_INDEX: 2031 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS); 2032 break; 2033 2034 case CAST_EXPR: 2035 if (TREE_OPERAND (t, 0) == NULL_TREE 2036 || TREE_CHAIN (TREE_OPERAND (t, 0))) 2037 { 2038 dump_type (TREE_TYPE (t), flags); 2039 pp_cxx_left_paren (cxx_pp); 2040 dump_expr_list (TREE_OPERAND (t, 0), flags); 2041 pp_cxx_right_paren (cxx_pp); 2042 } 2043 else 2044 { 2045 pp_cxx_left_paren (cxx_pp); 2046 dump_type (TREE_TYPE (t), flags); 2047 pp_cxx_right_paren (cxx_pp); 2048 pp_cxx_left_paren (cxx_pp); 2049 dump_expr_list (TREE_OPERAND (t, 0), flags); 2050 pp_cxx_right_paren (cxx_pp); 2051 } 2052 break; 2053 2054 case STATIC_CAST_EXPR: 2055 pp_cxx_ws_string (cxx_pp, "static_cast"); 2056 goto cast; 2057 case REINTERPRET_CAST_EXPR: 2058 pp_cxx_ws_string (cxx_pp, "reinterpret_cast"); 2059 goto cast; 2060 case CONST_CAST_EXPR: 2061 pp_cxx_ws_string (cxx_pp, "const_cast"); 2062 goto cast; 2063 case DYNAMIC_CAST_EXPR: 2064 pp_cxx_ws_string (cxx_pp, "dynamic_cast"); 2065 cast: 2066 pp_cxx_begin_template_argument_list (cxx_pp); 2067 dump_type (TREE_TYPE (t), flags); 2068 pp_cxx_end_template_argument_list (cxx_pp); 2069 pp_cxx_left_paren (cxx_pp); 2070 dump_expr (TREE_OPERAND (t, 0), flags); 2071 pp_cxx_right_paren (cxx_pp); 2072 break; 2073 2074 case ARROW_EXPR: 2075 dump_expr (TREE_OPERAND (t, 0), flags); 2076 pp_cxx_arrow (cxx_pp); 2077 break; 2078 2079 case SIZEOF_EXPR: 2080 case ALIGNOF_EXPR: 2081 if (TREE_CODE (t) == SIZEOF_EXPR) 2082 pp_cxx_ws_string (cxx_pp, "sizeof"); 2083 else 2084 { 2085 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); 2086 pp_cxx_ws_string (cxx_pp, "__alignof__"); 2087 } 2088 pp_cxx_whitespace (cxx_pp); 2089 pp_cxx_left_paren (cxx_pp); 2090 if (TYPE_P (TREE_OPERAND (t, 0))) 2091 dump_type (TREE_OPERAND (t, 0), flags); 2092 else 2093 dump_expr (TREE_OPERAND (t, 0), flags); 2094 pp_cxx_right_paren (cxx_pp); 2095 break; 2096 2097 case REALPART_EXPR: 2098 case IMAGPART_EXPR: 2099 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name); 2100 pp_cxx_whitespace (cxx_pp); 2101 dump_expr (TREE_OPERAND (t, 0), flags); 2102 break; 2103 2104 case DEFAULT_ARG: 2105 pp_string (cxx_pp, M_("<unparsed>")); 2106 break; 2107 2108 case TRY_CATCH_EXPR: 2109 case WITH_CLEANUP_EXPR: 2110 case CLEANUP_POINT_EXPR: 2111 dump_expr (TREE_OPERAND (t, 0), flags); 2112 break; 2113 2114 case PSEUDO_DTOR_EXPR: 2115 dump_expr (TREE_OPERAND (t, 2), flags); 2116 pp_cxx_dot (cxx_pp); 2117 dump_type (TREE_OPERAND (t, 0), flags); 2118 pp_cxx_colon_colon (cxx_pp); 2119 pp_cxx_complement (cxx_pp); 2120 dump_type (TREE_OPERAND (t, 1), flags); 2121 break; 2122 2123 case TEMPLATE_ID_EXPR: 2124 dump_decl (t, flags); 2125 break; 2126 2127 case BIND_EXPR: 2128 case STMT_EXPR: 2129 case EXPR_STMT: 2130 case STATEMENT_LIST: 2131 /* We don't yet have a way of dumping statements in a 2132 human-readable format. */ 2133 pp_string (cxx_pp, "({...})"); 2134 break; 2135 2136 case LOOP_EXPR: 2137 pp_string (cxx_pp, "while (1) { "); 2138 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2139 pp_cxx_right_brace (cxx_pp); 2140 break; 2141 2142 case EXIT_EXPR: 2143 pp_string (cxx_pp, "if ("); 2144 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2145 pp_string (cxx_pp, ") break; "); 2146 break; 2147 2148 case BASELINK: 2149 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS); 2150 break; 2151 2152 case EMPTY_CLASS_EXPR: 2153 dump_type (TREE_TYPE (t), flags); 2154 pp_cxx_left_paren (cxx_pp); 2155 pp_cxx_right_paren (cxx_pp); 2156 break; 2157 2158 case NON_DEPENDENT_EXPR: 2159 dump_expr (TREE_OPERAND (t, 0), flags); 2160 break; 2161 2162 case ARGUMENT_PACK_SELECT: 2163 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags); 2164 break; 2165 2166 case RECORD_TYPE: 2167 case UNION_TYPE: 2168 case ENUMERAL_TYPE: 2169 case REAL_TYPE: 2170 case VOID_TYPE: 2171 case BOOLEAN_TYPE: 2172 case INTEGER_TYPE: 2173 case COMPLEX_TYPE: 2174 case VECTOR_TYPE: 2175 pp_type_specifier_seq (cxx_pp, t); 2176 break; 2177 2178 case TYPENAME_TYPE: 2179 /* We get here when we want to print a dependent type as an 2180 id-expression, without any disambiguator decoration. */ 2181 pp_id_expression (cxx_pp, t); 2182 break; 2183 2184 case TEMPLATE_TYPE_PARM: 2185 case BOUND_TEMPLATE_TEMPLATE_PARM: 2186 dump_type (t, flags); 2187 break; 2188 2189 case TRAIT_EXPR: 2190 pp_cxx_trait_expression (cxx_pp, t); 2191 break; 2192 2193 case VA_ARG_EXPR: 2194 pp_cxx_va_arg_expression (cxx_pp, t); 2195 break; 2196 2197 case OFFSETOF_EXPR: 2198 pp_cxx_offsetof_expression (cxx_pp, t); 2199 break; 2200 2201 case SCOPE_REF: 2202 dump_decl (t, flags); 2203 break; 2204 2205 case EXPR_PACK_EXPANSION: 2206 case TYPEID_EXPR: 2207 case MEMBER_REF: 2208 case DOTSTAR_EXPR: 2209 case NEW_EXPR: 2210 case VEC_NEW_EXPR: 2211 case DELETE_EXPR: 2212 case VEC_DELETE_EXPR: 2213 case MODOP_EXPR: 2214 case ABS_EXPR: 2215 case CONJ_EXPR: 2216 case VECTOR_CST: 2217 case FIXED_CST: 2218 case UNORDERED_EXPR: 2219 case ORDERED_EXPR: 2220 case UNLT_EXPR: 2221 case UNLE_EXPR: 2222 case UNGT_EXPR: 2223 case UNGE_EXPR: 2224 case UNEQ_EXPR: 2225 case LTGT_EXPR: 2226 case COMPLEX_EXPR: 2227 case BIT_FIELD_REF: 2228 case FIX_TRUNC_EXPR: 2229 case FLOAT_EXPR: 2230 pp_expression (cxx_pp, t); 2231 break; 2232 2233 case TRUTH_AND_EXPR: 2234 case TRUTH_OR_EXPR: 2235 case TRUTH_XOR_EXPR: 2236 if (flags & TFF_EXPR_IN_PARENS) 2237 pp_cxx_left_paren (cxx_pp); 2238 pp_expression (cxx_pp, t); 2239 if (flags & TFF_EXPR_IN_PARENS) 2240 pp_cxx_right_paren (cxx_pp); 2241 break; 2242 2243 case OBJ_TYPE_REF: 2244 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags); 2245 break; 2246 2247 /* This list is incomplete, but should suffice for now. 2248 It is very important that `sorry' does not call 2249 `report_error_function'. That could cause an infinite loop. */ 2250 default: 2251 pp_unsupported_tree (cxx_pp, t); 2252 /* fall through to ERROR_MARK... */ 2253 case ERROR_MARK: 2254 pp_string (cxx_pp, M_("<expression error>")); 2255 break; 2256 } 2257 } 2258 2259 static void 2260 dump_binary_op (const char *opstring, tree t, int flags) 2261 { 2262 pp_cxx_left_paren (cxx_pp); 2263 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 2264 pp_cxx_whitespace (cxx_pp); 2265 if (opstring) 2266 pp_cxx_ws_string (cxx_pp, opstring); 2267 else 2268 pp_string (cxx_pp, M_("<unknown operator>")); 2269 pp_cxx_whitespace (cxx_pp); 2270 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 2271 pp_cxx_right_paren (cxx_pp); 2272 } 2273 2274 static void 2275 dump_unary_op (const char *opstring, tree t, int flags) 2276 { 2277 if (flags & TFF_EXPR_IN_PARENS) 2278 pp_cxx_left_paren (cxx_pp); 2279 pp_cxx_ws_string (cxx_pp, opstring); 2280 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 2281 if (flags & TFF_EXPR_IN_PARENS) 2282 pp_cxx_right_paren (cxx_pp); 2283 } 2284 2285 static void 2286 reinit_cxx_pp (void) 2287 { 2288 pp_clear_output_area (cxx_pp); 2289 pp_base (cxx_pp)->padding = pp_none; 2290 pp_indentation (cxx_pp) = 0; 2291 pp_needs_newline (cxx_pp) = false; 2292 cxx_pp->enclosing_scope = current_function_decl; 2293 } 2294 2295 2296 /* Exported interface to stringifying types, exprs and decls under TFF_* 2297 control. */ 2298 2299 const char * 2300 type_as_string (tree typ, int flags) 2301 { 2302 reinit_cxx_pp (); 2303 pp_translate_identifiers (cxx_pp) = false; 2304 dump_type (typ, flags); 2305 return pp_formatted_text (cxx_pp); 2306 } 2307 2308 const char * 2309 type_as_string_translate (tree typ, int flags) 2310 { 2311 reinit_cxx_pp (); 2312 dump_type (typ, flags); 2313 return pp_formatted_text (cxx_pp); 2314 } 2315 2316 const char * 2317 expr_as_string (tree decl, int flags) 2318 { 2319 reinit_cxx_pp (); 2320 pp_translate_identifiers (cxx_pp) = false; 2321 dump_expr (decl, flags); 2322 return pp_formatted_text (cxx_pp); 2323 } 2324 2325 const char * 2326 decl_as_string (tree decl, int flags) 2327 { 2328 reinit_cxx_pp (); 2329 pp_translate_identifiers (cxx_pp) = false; 2330 dump_decl (decl, flags); 2331 return pp_formatted_text (cxx_pp); 2332 } 2333 2334 const char * 2335 decl_as_string_translate (tree decl, int flags) 2336 { 2337 reinit_cxx_pp (); 2338 dump_decl (decl, flags); 2339 return pp_formatted_text (cxx_pp); 2340 } 2341 2342 /* Generate the three forms of printable names for cxx_printable_name. */ 2343 2344 const char * 2345 lang_decl_name (tree decl, int v, bool translate) 2346 { 2347 if (v >= 2) 2348 return (translate 2349 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS) 2350 : decl_as_string (decl, TFF_DECL_SPECIFIERS)); 2351 2352 reinit_cxx_pp (); 2353 pp_translate_identifiers (cxx_pp) = translate; 2354 if (v == 1 2355 && (DECL_CLASS_SCOPE_P (decl) 2356 || (DECL_NAMESPACE_SCOPE_P (decl) 2357 && CP_DECL_CONTEXT (decl) != global_namespace))) 2358 { 2359 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); 2360 pp_cxx_colon_colon (cxx_pp); 2361 } 2362 2363 if (TREE_CODE (decl) == FUNCTION_DECL) 2364 dump_function_name (decl, TFF_PLAIN_IDENTIFIER); 2365 else 2366 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER); 2367 2368 return pp_formatted_text (cxx_pp); 2369 } 2370 2371 /* Return the location of a tree passed to %+ formats. */ 2372 2373 static location_t 2374 location_of (tree t) 2375 { 2376 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 2377 t = DECL_CONTEXT (t); 2378 else if (TYPE_P (t)) 2379 t = TYPE_MAIN_DECL (t); 2380 else if (TREE_CODE (t) == OVERLOAD) 2381 t = OVL_FUNCTION (t); 2382 2383 return DECL_SOURCE_LOCATION (t); 2384 } 2385 2386 /* Now the interfaces from error et al to dump_type et al. Each takes an 2387 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_ 2388 function. */ 2389 2390 static const char * 2391 decl_to_string (tree decl, int verbose) 2392 { 2393 int flags = 0; 2394 2395 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE 2396 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE) 2397 flags = TFF_CLASS_KEY_OR_ENUM; 2398 if (verbose) 2399 flags |= TFF_DECL_SPECIFIERS; 2400 else if (TREE_CODE (decl) == FUNCTION_DECL) 2401 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; 2402 flags |= TFF_TEMPLATE_HEADER; 2403 2404 reinit_cxx_pp (); 2405 dump_decl (decl, flags); 2406 return pp_formatted_text (cxx_pp); 2407 } 2408 2409 static const char * 2410 expr_to_string (tree decl) 2411 { 2412 reinit_cxx_pp (); 2413 dump_expr (decl, 0); 2414 return pp_formatted_text (cxx_pp); 2415 } 2416 2417 static const char * 2418 fndecl_to_string (tree fndecl, int verbose) 2419 { 2420 int flags; 2421 2422 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS 2423 | TFF_TEMPLATE_HEADER; 2424 if (verbose) 2425 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; 2426 reinit_cxx_pp (); 2427 dump_decl (fndecl, flags); 2428 return pp_formatted_text (cxx_pp); 2429 } 2430 2431 2432 static const char * 2433 code_to_string (enum tree_code c) 2434 { 2435 return tree_code_name [c]; 2436 } 2437 2438 const char * 2439 language_to_string (enum languages c) 2440 { 2441 switch (c) 2442 { 2443 case lang_c: 2444 return "C"; 2445 2446 case lang_cplusplus: 2447 return "C++"; 2448 2449 case lang_java: 2450 return "Java"; 2451 2452 default: 2453 gcc_unreachable (); 2454 } 2455 return NULL; 2456 } 2457 2458 /* Return the proper printed version of a parameter to a C++ function. */ 2459 2460 static const char * 2461 parm_to_string (int p) 2462 { 2463 reinit_cxx_pp (); 2464 if (p < 0) 2465 pp_string (cxx_pp, "'this'"); 2466 else 2467 pp_decimal_int (cxx_pp, p + 1); 2468 return pp_formatted_text (cxx_pp); 2469 } 2470 2471 static const char * 2472 op_to_string (enum tree_code p) 2473 { 2474 tree id = operator_name_info[(int) p].identifier; 2475 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>"); 2476 } 2477 2478 static const char * 2479 type_to_string (tree typ, int verbose) 2480 { 2481 int flags = 0; 2482 if (verbose) 2483 flags |= TFF_CLASS_KEY_OR_ENUM; 2484 flags |= TFF_TEMPLATE_HEADER; 2485 2486 reinit_cxx_pp (); 2487 dump_type (typ, flags); 2488 return pp_formatted_text (cxx_pp); 2489 } 2490 2491 static const char * 2492 assop_to_string (enum tree_code p) 2493 { 2494 tree id = assignment_operator_name_info[(int) p].identifier; 2495 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}"); 2496 } 2497 2498 static const char * 2499 args_to_string (tree p, int verbose) 2500 { 2501 int flags = 0; 2502 if (verbose) 2503 flags |= TFF_CLASS_KEY_OR_ENUM; 2504 2505 if (p == NULL_TREE) 2506 return ""; 2507 2508 if (TYPE_P (TREE_VALUE (p))) 2509 return type_as_string_translate (p, flags); 2510 2511 reinit_cxx_pp (); 2512 for (; p; p = TREE_CHAIN (p)) 2513 { 2514 if (TREE_VALUE (p) == null_node) 2515 pp_cxx_ws_string (cxx_pp, "NULL"); 2516 else 2517 dump_type (error_type (TREE_VALUE (p)), flags); 2518 if (TREE_CHAIN (p)) 2519 pp_separate_with_comma (cxx_pp); 2520 } 2521 return pp_formatted_text (cxx_pp); 2522 } 2523 2524 static const char * 2525 cv_to_string (tree p, int v) 2526 { 2527 reinit_cxx_pp (); 2528 pp_base (cxx_pp)->padding = v ? pp_before : pp_none; 2529 pp_cxx_cv_qualifier_seq (cxx_pp, p); 2530 return pp_formatted_text (cxx_pp); 2531 } 2532 2533 /* Langhook for print_error_function. */ 2534 void 2535 cxx_print_error_function (diagnostic_context *context, const char *file, 2536 diagnostic_info *diagnostic) 2537 { 2538 lhd_print_error_function (context, file, diagnostic); 2539 pp_base_set_prefix (context->printer, file); 2540 maybe_print_instantiation_context (context); 2541 } 2542 2543 static void 2544 cp_diagnostic_starter (diagnostic_context *context, 2545 diagnostic_info *diagnostic) 2546 { 2547 diagnostic_report_current_module (context); 2548 cp_print_error_function (context, diagnostic); 2549 maybe_print_instantiation_context (context); 2550 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic)); 2551 } 2552 2553 static void 2554 cp_diagnostic_finalizer (diagnostic_context *context, 2555 diagnostic_info *diagnostic ATTRIBUTE_UNUSED) 2556 { 2557 pp_base_destroy_prefix (context->printer); 2558 } 2559 2560 /* Print current function onto BUFFER, in the process of reporting 2561 a diagnostic message. Called from cp_diagnostic_starter. */ 2562 static void 2563 cp_print_error_function (diagnostic_context *context, 2564 diagnostic_info *diagnostic) 2565 { 2566 if (diagnostic_last_function_changed (context, diagnostic)) 2567 { 2568 const char *old_prefix = context->printer->prefix; 2569 const char *file = LOCATION_FILE (diagnostic->location); 2570 tree abstract_origin = diagnostic->abstract_origin; 2571 char *new_prefix = (file && abstract_origin == NULL) 2572 ? file_name_as_prefix (file) : NULL; 2573 2574 pp_base_set_prefix (context->printer, new_prefix); 2575 2576 if (current_function_decl == NULL) 2577 pp_base_string (context->printer, _("At global scope:")); 2578 else 2579 { 2580 tree fndecl, ao; 2581 2582 if (abstract_origin) 2583 { 2584 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); 2585 while (TREE_CODE (ao) == BLOCK 2586 && BLOCK_ABSTRACT_ORIGIN (ao) 2587 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 2588 ao = BLOCK_ABSTRACT_ORIGIN (ao); 2589 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); 2590 fndecl = ao; 2591 } 2592 else 2593 fndecl = current_function_decl; 2594 2595 pp_printf (context->printer, function_category (fndecl), 2596 cxx_printable_name_translate (fndecl, 2)); 2597 2598 while (abstract_origin) 2599 { 2600 location_t *locus; 2601 tree block = abstract_origin; 2602 2603 locus = &BLOCK_SOURCE_LOCATION (block); 2604 fndecl = NULL; 2605 block = BLOCK_SUPERCONTEXT (block); 2606 while (block && TREE_CODE (block) == BLOCK 2607 && BLOCK_ABSTRACT_ORIGIN (block)) 2608 { 2609 ao = BLOCK_ABSTRACT_ORIGIN (block); 2610 2611 while (TREE_CODE (ao) == BLOCK 2612 && BLOCK_ABSTRACT_ORIGIN (ao) 2613 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 2614 ao = BLOCK_ABSTRACT_ORIGIN (ao); 2615 2616 if (TREE_CODE (ao) == FUNCTION_DECL) 2617 { 2618 fndecl = ao; 2619 break; 2620 } 2621 else if (TREE_CODE (ao) != BLOCK) 2622 break; 2623 2624 block = BLOCK_SUPERCONTEXT (block); 2625 } 2626 if (fndecl) 2627 abstract_origin = block; 2628 else 2629 { 2630 while (block && TREE_CODE (block) == BLOCK) 2631 block = BLOCK_SUPERCONTEXT (block); 2632 2633 if (block && TREE_CODE (block) == FUNCTION_DECL) 2634 fndecl = block; 2635 abstract_origin = NULL; 2636 } 2637 if (fndecl) 2638 { 2639 expanded_location s = expand_location (*locus); 2640 pp_base_character (context->printer, ','); 2641 pp_base_newline (context->printer); 2642 if (s.file != NULL) 2643 { 2644 if (flag_show_column && s.column != 0) 2645 pp_printf (context->printer, 2646 _(" inlined from %qs at %s:%d:%d"), 2647 cxx_printable_name_translate (fndecl, 2), 2648 s.file, s.line, s.column); 2649 else 2650 pp_printf (context->printer, 2651 _(" inlined from %qs at %s:%d"), 2652 cxx_printable_name_translate (fndecl, 2), 2653 s.file, s.line); 2654 2655 } 2656 else 2657 pp_printf (context->printer, _(" inlined from %qs"), 2658 cxx_printable_name_translate (fndecl, 2)); 2659 } 2660 } 2661 pp_base_character (context->printer, ':'); 2662 } 2663 pp_base_newline (context->printer); 2664 2665 diagnostic_set_last_function (context, diagnostic); 2666 pp_base_destroy_prefix (context->printer); 2667 context->printer->prefix = old_prefix; 2668 } 2669 } 2670 2671 /* Returns a description of FUNCTION using standard terminology. The 2672 result is a format string of the form "In CATEGORY %qs". */ 2673 static const char * 2674 function_category (tree fn) 2675 { 2676 /* We can get called from the middle-end for diagnostics of function 2677 clones. Make sure we have language specific information before 2678 dereferencing it. */ 2679 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn)) 2680 && DECL_FUNCTION_MEMBER_P (fn)) 2681 { 2682 if (DECL_STATIC_FUNCTION_P (fn)) 2683 return _("In static member function %qs"); 2684 else if (DECL_COPY_CONSTRUCTOR_P (fn)) 2685 return _("In copy constructor %qs"); 2686 else if (DECL_CONSTRUCTOR_P (fn)) 2687 return _("In constructor %qs"); 2688 else if (DECL_DESTRUCTOR_P (fn)) 2689 return _("In destructor %qs"); 2690 else if (LAMBDA_FUNCTION_P (fn)) 2691 return _("In lambda function"); 2692 else 2693 return _("In member function %qs"); 2694 } 2695 else 2696 return _("In function %qs"); 2697 } 2698 2699 /* Report the full context of a current template instantiation, 2700 onto BUFFER. */ 2701 static void 2702 print_instantiation_full_context (diagnostic_context *context) 2703 { 2704 struct tinst_level *p = current_instantiation (); 2705 location_t location = input_location; 2706 2707 if (p) 2708 { 2709 if (current_function_decl != p->decl 2710 && current_function_decl != NULL_TREE) 2711 /* We can get here during the processing of some synthesized 2712 method. Then, P->DECL will be the function that's causing 2713 the synthesis. */ 2714 ; 2715 else 2716 { 2717 if (current_function_decl == p->decl) 2718 /* Avoid redundancy with the "In function" line. */; 2719 else 2720 pp_verbatim (context->printer, 2721 _("%s: In instantiation of %qs:\n"), 2722 LOCATION_FILE (location), 2723 decl_as_string_translate (p->decl, 2724 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2725 2726 location = p->locus; 2727 p = p->next; 2728 } 2729 } 2730 2731 print_instantiation_partial_context (context, p, location); 2732 } 2733 2734 /* Helper function of print_instantiation_partial_context() that 2735 prints a single line of instantiation context. */ 2736 2737 static void 2738 print_instantiation_partial_context_line (diagnostic_context *context, 2739 const struct tinst_level *t, location_t loc) 2740 { 2741 expanded_location xloc; 2742 xloc = expand_location (loc); 2743 2744 if (t != NULL) { 2745 const char *str; 2746 str = decl_as_string_translate (t->decl, 2747 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE); 2748 if (flag_show_column) 2749 pp_verbatim (context->printer, 2750 _("%s:%d:%d: instantiated from %qs\n"), 2751 xloc.file, xloc.line, xloc.column, str); 2752 else 2753 pp_verbatim (context->printer, 2754 _("%s:%d: instantiated from %qs\n"), 2755 xloc.file, xloc.line, str); 2756 } else { 2757 if (flag_show_column) 2758 pp_verbatim (context->printer, _("%s:%d:%d: instantiated from here"), 2759 xloc.file, xloc.line, xloc.column); 2760 else 2761 pp_verbatim (context->printer, _("%s:%d: instantiated from here"), 2762 xloc.file, xloc.line); 2763 } 2764 } 2765 2766 /* Same as print_instantiation_full_context but less verbose. */ 2767 2768 static void 2769 print_instantiation_partial_context (diagnostic_context *context, 2770 struct tinst_level *t0, location_t loc) 2771 { 2772 struct tinst_level *t; 2773 int n_total = 0; 2774 int n; 2775 2776 for (t = t0; t != NULL; t = t->next) 2777 n_total++; 2778 2779 t = t0; 2780 2781 if (n_total >= 12) 2782 { 2783 int skip = n_total - 10; 2784 for (n = 0; n < 5; n++) 2785 { 2786 gcc_assert (t != NULL); 2787 print_instantiation_partial_context_line (context, t, loc); 2788 loc = t->locus; 2789 t = t->next; 2790 } 2791 if (skip > 1) 2792 { 2793 expanded_location xloc; 2794 xloc = expand_location (loc); 2795 if (flag_show_column) 2796 pp_verbatim (context->printer, 2797 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"), 2798 xloc.file, xloc.line, xloc.column, skip); 2799 else 2800 pp_verbatim (context->printer, 2801 _("%s:%d: [ skipping %d instantiation contexts ]\n"), 2802 xloc.file, xloc.line, skip); 2803 2804 do { 2805 loc = t->locus; 2806 t = t->next; 2807 } while (--skip > 0); 2808 } 2809 } 2810 2811 for (; t != NULL; t = t->next) 2812 { 2813 print_instantiation_partial_context_line (context, t, loc); 2814 loc = t->locus; 2815 } 2816 print_instantiation_partial_context_line (context, NULL, loc); 2817 pp_base_newline (context->printer); 2818 } 2819 2820 /* Called from cp_thing to print the template context for an error. */ 2821 static void 2822 maybe_print_instantiation_context (diagnostic_context *context) 2823 { 2824 if (!problematic_instantiation_changed () || current_instantiation () == 0) 2825 return; 2826 2827 record_last_problematic_instantiation (); 2828 print_instantiation_full_context (context); 2829 } 2830 2831 /* Report the bare minimum context of a template instantiation. */ 2832 void 2833 print_instantiation_context (void) 2834 { 2835 print_instantiation_partial_context 2836 (global_dc, current_instantiation (), input_location); 2837 diagnostic_flush_buffer (global_dc); 2838 } 2839 2840 /* Called from output_format -- during diagnostic message processing -- 2841 to handle C++ specific format specifier with the following meanings: 2842 %A function argument-list. 2843 %C tree code. 2844 %D declaration. 2845 %E expression. 2846 %F function declaration. 2847 %L language as used in extern "lang". 2848 %O binary operator. 2849 %P function parameter whose position is indicated by an integer. 2850 %Q assignment operator. 2851 %T type. 2852 %V cv-qualifier. */ 2853 static bool 2854 cp_printer (pretty_printer *pp, text_info *text, const char *spec, 2855 int precision, bool wide, bool set_locus, bool verbose) 2856 { 2857 const char *result; 2858 tree t = NULL; 2859 #define next_tree (t = va_arg (*text->args_ptr, tree)) 2860 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int)) 2861 #define next_lang ((enum languages) va_arg (*text->args_ptr, int)) 2862 #define next_int va_arg (*text->args_ptr, int) 2863 2864 if (precision != 0 || wide) 2865 return false; 2866 2867 if (text->locus == NULL) 2868 set_locus = false; 2869 2870 switch (*spec) 2871 { 2872 case 'A': result = args_to_string (next_tree, verbose); break; 2873 case 'C': result = code_to_string (next_tcode); break; 2874 case 'D': 2875 { 2876 tree temp = next_tree; 2877 if (DECL_P (temp) 2878 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp)) 2879 { 2880 temp = DECL_DEBUG_EXPR (temp); 2881 if (!DECL_P (temp)) 2882 { 2883 result = expr_to_string (temp); 2884 break; 2885 } 2886 } 2887 result = decl_to_string (temp, verbose); 2888 } 2889 break; 2890 case 'E': result = expr_to_string (next_tree); break; 2891 case 'F': result = fndecl_to_string (next_tree, verbose); break; 2892 case 'L': result = language_to_string (next_lang); break; 2893 case 'O': result = op_to_string (next_tcode); break; 2894 case 'P': result = parm_to_string (next_int); break; 2895 case 'Q': result = assop_to_string (next_tcode); break; 2896 case 'T': result = type_to_string (next_tree, verbose); break; 2897 case 'V': result = cv_to_string (next_tree, verbose); break; 2898 2899 default: 2900 return false; 2901 } 2902 2903 pp_base_string (pp, result); 2904 if (set_locus && t != NULL) 2905 *text->locus = location_of (t); 2906 return true; 2907 #undef next_tree 2908 #undef next_tcode 2909 #undef next_lang 2910 #undef next_int 2911 } 2912 2913 /* Warn about the use of C++0x features when appropriate. */ 2914 void 2915 maybe_warn_cpp0x (cpp0x_warn_str str) 2916 { 2917 if ((cxx_dialect == cxx98) && !in_system_header) 2918 /* We really want to suppress this warning in system headers, 2919 because libstdc++ uses variadic templates even when we aren't 2920 in C++0x mode. */ 2921 switch (str) 2922 { 2923 case CPP0X_INITIALIZER_LISTS: 2924 pedwarn (input_location, 0, 2925 "extended initializer lists " 2926 "only available with -std=c++0x or -std=gnu++0x"); 2927 break; 2928 case CPP0X_EXPLICIT_CONVERSION: 2929 pedwarn (input_location, 0, 2930 "explicit conversion operators " 2931 "only available with -std=c++0x or -std=gnu++0x"); 2932 break; 2933 case CPP0X_VARIADIC_TEMPLATES: 2934 pedwarn (input_location, 0, 2935 "variadic templates " 2936 "only available with -std=c++0x or -std=gnu++0x"); 2937 break; 2938 case CPP0X_LAMBDA_EXPR: 2939 pedwarn (input_location, 0, 2940 "lambda expressions " 2941 "only available with -std=c++0x or -std=gnu++0x"); 2942 break; 2943 case CPP0X_AUTO: 2944 pedwarn (input_location, 0, 2945 "C++0x auto only available with -std=c++0x or -std=gnu++0x"); 2946 break; 2947 case CPP0X_SCOPED_ENUMS: 2948 pedwarn (input_location, 0, 2949 "scoped enums only available with -std=c++0x or -std=gnu++0x"); 2950 break; 2951 case CPP0X_DEFAULTED_DELETED: 2952 pedwarn (input_location, 0, 2953 "defaulted and deleted functions " 2954 "only available with -std=c++0x or -std=gnu++0x"); 2955 break; 2956 default: 2957 gcc_unreachable(); 2958 } 2959 } 2960 2961 /* Warn about the use of variadic templates when appropriate. */ 2962 void 2963 maybe_warn_variadic_templates (void) 2964 { 2965 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES); 2966 } 2967 2968 2969 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on 2970 option OPT with text GMSGID. Use this function to report 2971 diagnostics for constructs that are invalid C++98, but valid 2972 C++0x. */ 2973 bool 2974 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...) 2975 { 2976 diagnostic_info diagnostic; 2977 va_list ap; 2978 2979 va_start (ap, gmsgid); 2980 diagnostic_set_info (&diagnostic, gmsgid, &ap, location, 2981 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING); 2982 diagnostic.option_index = opt; 2983 va_end (ap); 2984 return report_diagnostic (&diagnostic); 2985 } 2986