error.c revision 261188
1207753Smm/* Call-backs for C++ error reporting. 2207753Smm This code is non-reentrant. 3207753Smm Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 4207753Smm 2003, 2004, 2005 Free Software Foundation, Inc. 5207753Smm This file is part of GCC. 6207753Smm 7207753SmmGCC is free software; you can redistribute it and/or modify 8207753Smmit under the terms of the GNU General Public License as published by 9207753Smmthe Free Software Foundation; either version 2, or (at your option) 10207753Smmany later version. 11207753Smm 12207753SmmGCC is distributed in the hope that it will be useful, 13207753Smmbut WITHOUT ANY WARRANTY; without even the implied warranty of 14207753SmmMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15207753SmmGNU General Public License for more details. 16207753Smm 17207753SmmYou should have received a copy of the GNU General Public License 18207753Smmalong with GCC; see the file COPYING. If not, write to 19312518Sdelphijthe Free Software Foundation, 51 Franklin Street, Fifth Floor, 20207753SmmBoston, MA 02110-1301, USA. */ 21207753Smm 22207753Smm#include "config.h" 23244601Smm#include "system.h" 24207753Smm#include "coretypes.h" 25207753Smm#include "tm.h" 26207753Smm#include "tree.h" 27207753Smm#include "cp-tree.h" 28207753Smm#include "real.h" 29207753Smm#include "toplev.h" 30207753Smm#include "flags.h" 31207753Smm#include "diagnostic.h" 32207753Smm#include "langhooks-def.h" 33207753Smm#include "cxx-pretty-print.h" 34312518Sdelphij 35207753Smm#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',') 36207753Smm 37207753Smm/* The global buffer where we dump everything. It is there only for 38207753Smm transitional purpose. It is expected, in the near future, to be 39312518Sdelphij completely removed. */ 40207753Smmstatic cxx_pretty_printer scratch_pretty_printer; 41207753Smm#define cxx_pp (&scratch_pretty_printer) 42207753Smm 43207753Smm# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T))) 44207753Smm 45207753Smmstatic const char *args_to_string (tree, int); 46207753Smmstatic const char *assop_to_string (enum tree_code); 47207753Smmstatic const char *code_to_string (enum tree_code); 48207753Smmstatic const char *cv_to_string (tree, int); 49207753Smmstatic const char *decl_to_string (tree, int); 50207753Smmstatic const char *expr_to_string (tree); 51207753Smmstatic const char *fndecl_to_string (tree, int); 52207753Smmstatic const char *op_to_string (enum tree_code); 53207753Smmstatic const char *parm_to_string (int); 54207753Smmstatic const char *type_to_string (tree, int); 55207753Smm 56207753Smmstatic void dump_type (tree, int); 57207753Smmstatic void dump_typename (tree, int); 58207753Smmstatic void dump_simple_decl (tree, tree, int); 59207753Smmstatic void dump_decl (tree, int); 60207753Smmstatic void dump_template_decl (tree, int); 61207753Smmstatic void dump_function_decl (tree, int); 62207753Smmstatic void dump_expr (tree, int); 63312518Sdelphijstatic void dump_unary_op (const char *, tree, int); 64207753Smmstatic void dump_binary_op (const char *, tree, int); 65207753Smmstatic void dump_aggr_type (tree, int); 66207753Smmstatic void dump_type_prefix (tree, int); 67292588Sdelphijstatic void dump_type_suffix (tree, int); 68292588Sdelphijstatic void dump_function_name (tree, int); 69312518Sdelphijstatic void dump_expr_list (tree, int); 70207753Smmstatic void dump_global_iord (tree); 71207753Smmstatic void dump_parameters (tree, int); 72207753Smmstatic void dump_exception_spec (tree, int); 73207753Smmstatic void dump_template_argument (tree, int); 74207753Smmstatic void dump_template_argument_list (tree, int); 75static void dump_template_parameter (tree, int); 76static void dump_template_bindings (tree, tree); 77static void dump_scope (tree, int); 78static void dump_template_parms (tree, int, int); 79 80static const char *function_category (tree); 81static void maybe_print_instantiation_context (diagnostic_context *); 82static void print_instantiation_full_context (diagnostic_context *); 83static void print_instantiation_partial_context (diagnostic_context *, 84 tree, location_t); 85static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *); 86static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); 87static void cp_print_error_function (diagnostic_context *, diagnostic_info *); 88 89static bool cp_printer (pretty_printer *, text_info *, const char *, 90 int, bool, bool, bool); 91static location_t location_of (tree); 92 93void 94init_error (void) 95{ 96 diagnostic_starter (global_dc) = cp_diagnostic_starter; 97 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer; 98 diagnostic_format_decoder (global_dc) = cp_printer; 99 100 pp_construct (pp_base (cxx_pp), NULL, 0); 101 pp_cxx_pretty_printer_init (cxx_pp); 102} 103 104/* Dump a scope, if deemed necessary. */ 105 106static void 107dump_scope (tree scope, int flags) 108{ 109 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF)); 110 111 if (scope == NULL_TREE) 112 return; 113 114 if (TREE_CODE (scope) == NAMESPACE_DECL) 115 { 116 if (scope != global_namespace) 117 { 118 dump_decl (scope, f); 119 pp_cxx_colon_colon (cxx_pp); 120 } 121 } 122 else if (AGGREGATE_TYPE_P (scope)) 123 { 124 dump_type (scope, f); 125 pp_cxx_colon_colon (cxx_pp); 126 } 127 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL) 128 { 129 dump_function_decl (scope, f); 130 pp_cxx_colon_colon (cxx_pp); 131 } 132} 133 134/* Dump the template ARGument under control of FLAGS. */ 135 136static void 137dump_template_argument (tree arg, int flags) 138{ 139 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL) 140 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM); 141 else 142 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM); 143} 144 145/* Dump a template-argument-list ARGS (always a TREE_VEC) under control 146 of FLAGS. */ 147 148static void 149dump_template_argument_list (tree args, int flags) 150{ 151 int n = TREE_VEC_LENGTH (args); 152 int need_comma = 0; 153 int i; 154 155 for (i = 0; i< n; ++i) 156 { 157 if (need_comma) 158 pp_separate_with_comma (cxx_pp); 159 dump_template_argument (TREE_VEC_ELT (args, i), flags); 160 need_comma = 1; 161 } 162} 163 164/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */ 165 166static void 167dump_template_parameter (tree parm, int flags) 168{ 169 tree p; 170 tree a; 171 172 if (parm == error_mark_node) 173 return; 174 175 p = TREE_VALUE (parm); 176 a = TREE_PURPOSE (parm); 177 178 if (TREE_CODE (p) == TYPE_DECL) 179 { 180 if (flags & TFF_DECL_SPECIFIERS) 181 { 182 pp_cxx_identifier (cxx_pp, "class"); 183 if (DECL_NAME (p)) 184 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 185 } 186 else if (DECL_NAME (p)) 187 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p)); 188 else 189 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p)); 190 } 191 else 192 dump_decl (p, flags | TFF_DECL_SPECIFIERS); 193 194 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE) 195 { 196 pp_cxx_whitespace (cxx_pp); 197 pp_equal (cxx_pp); 198 pp_cxx_whitespace (cxx_pp); 199 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) 200 dump_type (a, flags & ~TFF_CHASE_TYPEDEF); 201 else 202 dump_expr (a, flags | TFF_EXPR_IN_PARENS); 203 } 204} 205 206/* Dump, under control of FLAGS, a template-parameter-list binding. 207 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a 208 TREE_VEC. */ 209 210static void 211dump_template_bindings (tree parms, tree args) 212{ 213 int need_comma = 0; 214 215 while (parms) 216 { 217 tree p = TREE_VALUE (parms); 218 int lvl = TMPL_PARMS_DEPTH (parms); 219 int arg_idx = 0; 220 int i; 221 222 for (i = 0; i < TREE_VEC_LENGTH (p); ++i) 223 { 224 tree arg = NULL_TREE; 225 226 /* Don't crash if we had an invalid argument list. */ 227 if (TMPL_ARGS_DEPTH (args) >= lvl) 228 { 229 tree lvl_args = TMPL_ARGS_LEVEL (args, lvl); 230 if (NUM_TMPL_ARGS (lvl_args) > arg_idx) 231 arg = TREE_VEC_ELT (lvl_args, arg_idx); 232 } 233 234 if (need_comma) 235 pp_separate_with_comma (cxx_pp); 236 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER); 237 pp_cxx_whitespace (cxx_pp); 238 pp_equal (cxx_pp); 239 pp_cxx_whitespace (cxx_pp); 240 if (arg) 241 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER); 242 else 243 pp_identifier (cxx_pp, "<missing>"); 244 245 ++arg_idx; 246 need_comma = 1; 247 } 248 249 parms = TREE_CHAIN (parms); 250 } 251} 252 253/* Dump a human-readable equivalent of TYPE. FLAGS controls the 254 format. */ 255 256static void 257dump_type (tree t, int flags) 258{ 259 if (t == NULL_TREE) 260 return; 261 262 if (TYPE_PTRMEMFUNC_P (t)) 263 goto offset_type; 264 265 switch (TREE_CODE (t)) 266 { 267 case UNKNOWN_TYPE: 268 pp_identifier (cxx_pp, "<unresolved overloaded function type>"); 269 break; 270 271 case TREE_LIST: 272 /* A list of function parms. */ 273 dump_parameters (t, flags); 274 break; 275 276 case IDENTIFIER_NODE: 277 pp_cxx_tree_identifier (cxx_pp, t); 278 break; 279 280 case TREE_BINFO: 281 dump_type (BINFO_TYPE (t), flags); 282 break; 283 284 case RECORD_TYPE: 285 case UNION_TYPE: 286 case ENUMERAL_TYPE: 287 dump_aggr_type (t, flags); 288 break; 289 290 case TYPE_DECL: 291 if (flags & TFF_CHASE_TYPEDEF) 292 { 293 dump_type (DECL_ORIGINAL_TYPE (t) 294 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags); 295 break; 296 } 297 /* Else fall through. */ 298 299 case TEMPLATE_DECL: 300 case NAMESPACE_DECL: 301 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS); 302 break; 303 304 case INTEGER_TYPE: 305 case REAL_TYPE: 306 case VOID_TYPE: 307 case BOOLEAN_TYPE: 308 case COMPLEX_TYPE: 309 case VECTOR_TYPE: 310 pp_type_specifier_seq (cxx_pp, t); 311 break; 312 313 case TEMPLATE_TEMPLATE_PARM: 314 /* For parameters inside template signature. */ 315 if (TYPE_IDENTIFIER (t)) 316 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 317 else 318 pp_cxx_canonical_template_parameter (cxx_pp, t); 319 break; 320 321 case BOUND_TEMPLATE_TEMPLATE_PARM: 322 { 323 tree args = TYPE_TI_ARGS (t); 324 pp_cxx_cv_qualifier_seq (cxx_pp, t); 325 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 326 pp_cxx_begin_template_argument_list (cxx_pp); 327 dump_template_argument_list (args, flags); 328 pp_cxx_end_template_argument_list (cxx_pp); 329 } 330 break; 331 332 case TEMPLATE_TYPE_PARM: 333 pp_cxx_cv_qualifier_seq (cxx_pp, t); 334 if (TYPE_IDENTIFIER (t)) 335 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t)); 336 else 337 pp_cxx_canonical_template_parameter 338 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t)); 339 break; 340 341 /* This is not always necessary for pointers and such, but doing this 342 reduces code size. */ 343 case ARRAY_TYPE: 344 case POINTER_TYPE: 345 /* APPLE LOCAL blocks 6040305 */ 346 case BLOCK_POINTER_TYPE: 347 case REFERENCE_TYPE: 348 case OFFSET_TYPE: 349 offset_type: 350 case FUNCTION_TYPE: 351 case METHOD_TYPE: 352 { 353 dump_type_prefix (t, flags); 354 dump_type_suffix (t, flags); 355 break; 356 } 357 case TYPENAME_TYPE: 358 pp_cxx_cv_qualifier_seq (cxx_pp, t); 359 pp_cxx_identifier (cxx_pp, 360 TYPENAME_IS_ENUM_P (t) ? "enum" 361 : TYPENAME_IS_CLASS_P (t) ? "class" 362 : "typename"); 363 dump_typename (t, flags); 364 break; 365 366 case UNBOUND_CLASS_TEMPLATE: 367 dump_type (TYPE_CONTEXT (t), flags); 368 pp_cxx_colon_colon (cxx_pp); 369 pp_cxx_identifier (cxx_pp, "template"); 370 dump_type (DECL_NAME (TYPE_NAME (t)), flags); 371 break; 372 373 case TYPEOF_TYPE: 374 pp_cxx_identifier (cxx_pp, "__typeof__"); 375 pp_cxx_whitespace (cxx_pp); 376 pp_cxx_left_paren (cxx_pp); 377 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS); 378 pp_cxx_right_paren (cxx_pp); 379 break; 380 381 default: 382 pp_unsupported_tree (cxx_pp, t); 383 /* Fall through to error. */ 384 385 case ERROR_MARK: 386 pp_identifier (cxx_pp, "<type error>"); 387 break; 388 } 389} 390 391/* Dump a TYPENAME_TYPE. We need to notice when the context is itself 392 a TYPENAME_TYPE. */ 393 394static void 395dump_typename (tree t, int flags) 396{ 397 tree ctx = TYPE_CONTEXT (t); 398 399 if (TREE_CODE (ctx) == TYPENAME_TYPE) 400 dump_typename (ctx, flags); 401 else 402 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM); 403 pp_cxx_colon_colon (cxx_pp); 404 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags); 405} 406 407/* Return the name of the supplied aggregate, or enumeral type. */ 408 409const char * 410class_key_or_enum_as_string (tree t) 411{ 412 if (TREE_CODE (t) == ENUMERAL_TYPE) 413 return "enum"; 414 else if (TREE_CODE (t) == UNION_TYPE) 415 return "union"; 416 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 417 return "class"; 418 else 419 return "struct"; 420} 421 422/* Print out a class declaration T under the control of FLAGS, 423 in the form `class foo'. */ 424 425static void 426dump_aggr_type (tree t, int flags) 427{ 428 tree name; 429 const char *variety = class_key_or_enum_as_string (t); 430 int typdef = 0; 431 int tmplate = 0; 432 433 pp_cxx_cv_qualifier_seq (cxx_pp, t); 434 435 if (flags & TFF_CLASS_KEY_OR_ENUM) 436 pp_cxx_identifier (cxx_pp, variety); 437 438 if (flags & TFF_CHASE_TYPEDEF) 439 t = TYPE_MAIN_VARIANT (t); 440 441 name = TYPE_NAME (t); 442 443 if (name) 444 { 445 typdef = !DECL_ARTIFICIAL (name); 446 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE 447 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t) 448 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL 449 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); 450 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE); 451 if (tmplate) 452 { 453 /* Because the template names are mangled, we have to locate 454 the most general template, and use that name. */ 455 tree tpl = CLASSTYPE_TI_TEMPLATE (t); 456 457 while (DECL_TEMPLATE_INFO (tpl)) 458 tpl = DECL_TI_TEMPLATE (tpl); 459 name = tpl; 460 } 461 name = DECL_NAME (name); 462 } 463 464 if (name == 0 || ANON_AGGRNAME_P (name)) 465 { 466 if (flags & TFF_CLASS_KEY_OR_ENUM) 467 pp_identifier (cxx_pp, "<anonymous>"); 468 else 469 pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety); 470 } 471 else 472 pp_cxx_tree_identifier (cxx_pp, name); 473 if (tmplate) 474 dump_template_parms (TYPE_TEMPLATE_INFO (t), 475 !CLASSTYPE_USE_TEMPLATE (t), 476 flags & ~TFF_TEMPLATE_HEADER); 477} 478 479/* Dump into the obstack the initial part of the output for a given type. 480 This is necessary when dealing with things like functions returning 481 functions. Examples: 482 483 return type of `int (* fee ())()': pointer -> function -> int. Both 484 pointer (and reference and offset) and function (and member) types must 485 deal with prefix and suffix. 486 487 Arrays must also do this for DECL nodes, like int a[], and for things like 488 int *[]&. */ 489 490static void 491dump_type_prefix (tree t, int flags) 492{ 493 if (TYPE_PTRMEMFUNC_P (t)) 494 { 495 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 496 goto offset_type; 497 } 498 499 switch (TREE_CODE (t)) 500 { 501 case POINTER_TYPE: 502 /* APPLE LOCAL blocks 6040305 */ 503 case BLOCK_POINTER_TYPE: 504 case REFERENCE_TYPE: 505 { 506 tree sub = TREE_TYPE (t); 507 508 dump_type_prefix (sub, flags); 509 if (TREE_CODE (sub) == ARRAY_TYPE) 510 { 511 pp_cxx_whitespace (cxx_pp); 512 pp_cxx_left_paren (cxx_pp); 513 } 514 /* APPLE LOCAL begin blocks 6040305 */ 515 pp_character (cxx_pp, "&*^"[(TREE_CODE (t) == POINTER_TYPE) 516 + (TREE_CODE (t) == BLOCK_POINTER_TYPE)*2]); 517 /* APPLE LOCAL end blocks 6040305 */ 518 pp_base (cxx_pp)->padding = pp_before; 519 pp_cxx_cv_qualifier_seq (cxx_pp, t); 520 } 521 break; 522 523 case OFFSET_TYPE: 524 offset_type: 525 dump_type_prefix (TREE_TYPE (t), flags); 526 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ 527 { 528 pp_maybe_space (cxx_pp); 529 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 530 pp_cxx_left_paren (cxx_pp); 531 dump_type (TYPE_OFFSET_BASETYPE (t), flags); 532 pp_cxx_colon_colon (cxx_pp); 533 } 534 pp_cxx_star (cxx_pp); 535 pp_cxx_cv_qualifier_seq (cxx_pp, t); 536 pp_base (cxx_pp)->padding = pp_before; 537 break; 538 539 /* Can only be reached through function pointer -- this would not be 540 correct if FUNCTION_DECLs used it. */ 541 case FUNCTION_TYPE: 542 dump_type_prefix (TREE_TYPE (t), flags); 543 pp_maybe_space (cxx_pp); 544 pp_cxx_left_paren (cxx_pp); 545 break; 546 547 case METHOD_TYPE: 548 dump_type_prefix (TREE_TYPE (t), flags); 549 pp_maybe_space (cxx_pp); 550 pp_cxx_left_paren (cxx_pp); 551 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags); 552 pp_cxx_colon_colon (cxx_pp); 553 break; 554 555 case ARRAY_TYPE: 556 dump_type_prefix (TREE_TYPE (t), flags); 557 break; 558 559 case ENUMERAL_TYPE: 560 case IDENTIFIER_NODE: 561 case INTEGER_TYPE: 562 case BOOLEAN_TYPE: 563 case REAL_TYPE: 564 case RECORD_TYPE: 565 case TEMPLATE_TYPE_PARM: 566 case TEMPLATE_TEMPLATE_PARM: 567 case BOUND_TEMPLATE_TEMPLATE_PARM: 568 case TREE_LIST: 569 case TYPE_DECL: 570 case TREE_VEC: 571 case UNION_TYPE: 572 case UNKNOWN_TYPE: 573 case VOID_TYPE: 574 case TYPENAME_TYPE: 575 case COMPLEX_TYPE: 576 case VECTOR_TYPE: 577 case TYPEOF_TYPE: 578 dump_type (t, flags); 579 pp_base (cxx_pp)->padding = pp_before; 580 break; 581 582 default: 583 pp_unsupported_tree (cxx_pp, t); 584 /* fall through. */ 585 case ERROR_MARK: 586 pp_identifier (cxx_pp, "<typeprefixerror>"); 587 break; 588 } 589} 590 591/* Dump the suffix of type T, under control of FLAGS. This is the part 592 which appears after the identifier (or function parms). */ 593 594static void 595dump_type_suffix (tree t, int flags) 596{ 597 if (TYPE_PTRMEMFUNC_P (t)) 598 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 599 600 switch (TREE_CODE (t)) 601 { 602 case POINTER_TYPE: 603 /* APPLE LOCAL blocks 6040305 */ 604 case BLOCK_POINTER_TYPE: 605 case REFERENCE_TYPE: 606 case OFFSET_TYPE: 607 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 608 pp_cxx_right_paren (cxx_pp); 609 dump_type_suffix (TREE_TYPE (t), flags); 610 break; 611 612 /* Can only be reached through function pointer. */ 613 case FUNCTION_TYPE: 614 case METHOD_TYPE: 615 { 616 tree arg; 617 pp_cxx_right_paren (cxx_pp); 618 arg = TYPE_ARG_TYPES (t); 619 if (TREE_CODE (t) == METHOD_TYPE) 620 arg = TREE_CHAIN (arg); 621 622 /* Function pointers don't have default args. Not in standard C++, 623 anyway; they may in g++, but we'll just pretend otherwise. */ 624 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS); 625 626 if (TREE_CODE (t) == METHOD_TYPE) 627 pp_cxx_cv_qualifier_seq 628 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t)))); 629 else 630 pp_cxx_cv_qualifier_seq(cxx_pp, t); 631 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags); 632 dump_type_suffix (TREE_TYPE (t), flags); 633 break; 634 } 635 636 case ARRAY_TYPE: 637 pp_maybe_space (cxx_pp); 638 pp_cxx_left_bracket (cxx_pp); 639 if (TYPE_DOMAIN (t)) 640 { 641 if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0)) 642 pp_wide_integer 643 (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1); 644 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR) 645 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), 646 flags & ~TFF_EXPR_IN_PARENS); 647 else 648 dump_expr (fold (cp_build_binary_op 649 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 650 integer_one_node)), 651 flags & ~TFF_EXPR_IN_PARENS); 652 } 653 pp_cxx_right_bracket (cxx_pp); 654 dump_type_suffix (TREE_TYPE (t), flags); 655 break; 656 657 case ENUMERAL_TYPE: 658 case IDENTIFIER_NODE: 659 case INTEGER_TYPE: 660 case BOOLEAN_TYPE: 661 case REAL_TYPE: 662 case RECORD_TYPE: 663 case TEMPLATE_TYPE_PARM: 664 case TEMPLATE_TEMPLATE_PARM: 665 case BOUND_TEMPLATE_TEMPLATE_PARM: 666 case TREE_LIST: 667 case TYPE_DECL: 668 case TREE_VEC: 669 case UNION_TYPE: 670 case UNKNOWN_TYPE: 671 case VOID_TYPE: 672 case TYPENAME_TYPE: 673 case COMPLEX_TYPE: 674 case VECTOR_TYPE: 675 case TYPEOF_TYPE: 676 break; 677 678 default: 679 pp_unsupported_tree (cxx_pp, t); 680 case ERROR_MARK: 681 /* Don't mark it here, we should have already done in 682 dump_type_prefix. */ 683 break; 684 } 685} 686 687static void 688dump_global_iord (tree t) 689{ 690 const char *p = NULL; 691 692 if (DECL_GLOBAL_CTOR_P (t)) 693 p = "initializers"; 694 else if (DECL_GLOBAL_DTOR_P (t)) 695 p = "destructors"; 696 else 697 gcc_unreachable (); 698 699 pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename); 700} 701 702static void 703dump_simple_decl (tree t, tree type, int flags) 704{ 705 if (flags & TFF_DECL_SPECIFIERS) 706 { 707 dump_type_prefix (type, flags); 708 pp_maybe_space (cxx_pp); 709 } 710 if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX) 711 dump_scope (CP_DECL_CONTEXT (t), flags); 712 if (DECL_NAME (t)) 713 dump_decl (DECL_NAME (t), flags); 714 else 715 pp_identifier (cxx_pp, "<anonymous>"); 716 if (flags & TFF_DECL_SPECIFIERS) 717 dump_type_suffix (type, flags); 718} 719 720/* Dump a human readable string for the decl T under control of FLAGS. */ 721 722static void 723dump_decl (tree t, int flags) 724{ 725 if (t == NULL_TREE) 726 return; 727 728 switch (TREE_CODE (t)) 729 { 730 case TYPE_DECL: 731 /* Don't say 'typedef class A' */ 732 if (DECL_ARTIFICIAL (t)) 733 { 734 if ((flags & TFF_DECL_SPECIFIERS) 735 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) 736 /* Say `class T' not just `T'. */ 737 pp_cxx_identifier (cxx_pp, "class"); 738 739 dump_type (TREE_TYPE (t), flags); 740 break; 741 } 742 if (flags & TFF_DECL_SPECIFIERS) 743 pp_cxx_identifier (cxx_pp, "typedef"); 744 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) 745 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), 746 flags); 747 break; 748 749 case VAR_DECL: 750 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) 751 { 752 pp_string (cxx_pp, "vtable for "); 753 gcc_assert (TYPE_P (DECL_CONTEXT (t))); 754 dump_type (DECL_CONTEXT (t), flags); 755 break; 756 } 757 /* Else fall through. */ 758 case FIELD_DECL: 759 case PARM_DECL: 760 dump_simple_decl (t, TREE_TYPE (t), flags); 761 break; 762 763 case RESULT_DECL: 764 pp_string (cxx_pp, "<return value> "); 765 dump_simple_decl (t, TREE_TYPE (t), flags); 766 break; 767 768 case NAMESPACE_DECL: 769 if (flags & TFF_DECL_SPECIFIERS) 770 pp_cxx_declaration (cxx_pp, t); 771 else 772 { 773 dump_scope (CP_DECL_CONTEXT (t), flags); 774 if (DECL_NAME (t) == NULL_TREE) 775 pp_identifier (cxx_pp, "<unnamed>"); 776 else 777 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 778 } 779 break; 780 781 case SCOPE_REF: 782 pp_expression (cxx_pp, t); 783 break; 784 785 case ARRAY_REF: 786 dump_decl (TREE_OPERAND (t, 0), flags); 787 pp_cxx_left_bracket (cxx_pp); 788 dump_decl (TREE_OPERAND (t, 1), flags); 789 pp_cxx_right_bracket (cxx_pp); 790 break; 791 792 /* So that we can do dump_decl on an aggr type. */ 793 case RECORD_TYPE: 794 case UNION_TYPE: 795 case ENUMERAL_TYPE: 796 dump_type (t, flags); 797 break; 798 799 case BIT_NOT_EXPR: 800 /* This is a pseudo destructor call which has not been folded into 801 a PSEUDO_DTOR_EXPR yet. */ 802 pp_cxx_complement (cxx_pp); 803 dump_type (TREE_OPERAND (t, 0), flags); 804 break; 805 806 case TYPE_EXPR: 807 gcc_unreachable (); 808 break; 809 810 /* These special cases are duplicated here so that other functions 811 can feed identifiers to error and get them demangled properly. */ 812 case IDENTIFIER_NODE: 813 if (IDENTIFIER_TYPENAME_P (t)) 814 { 815 pp_cxx_identifier (cxx_pp, "operator"); 816 /* Not exactly IDENTIFIER_TYPE_VALUE. */ 817 dump_type (TREE_TYPE (t), flags); 818 break; 819 } 820 else 821 pp_cxx_tree_identifier (cxx_pp, t); 822 break; 823 824 case OVERLOAD: 825 if (OVL_CHAIN (t)) 826 { 827 t = OVL_CURRENT (t); 828 if (DECL_CLASS_SCOPE_P (t)) 829 { 830 dump_type (DECL_CONTEXT (t), flags); 831 pp_cxx_colon_colon (cxx_pp); 832 } 833 else if (DECL_CONTEXT (t)) 834 { 835 dump_decl (DECL_CONTEXT (t), flags); 836 pp_cxx_colon_colon (cxx_pp); 837 } 838 dump_decl (DECL_NAME (t), flags); 839 break; 840 } 841 842 /* If there's only one function, just treat it like an ordinary 843 FUNCTION_DECL. */ 844 t = OVL_CURRENT (t); 845 /* Fall through. */ 846 847 case FUNCTION_DECL: 848 if (! DECL_LANG_SPECIFIC (t)) 849 pp_identifier (cxx_pp, "<built-in>"); 850 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) 851 dump_global_iord (t); 852 else 853 dump_function_decl (t, flags); 854 break; 855 856 case TEMPLATE_DECL: 857 dump_template_decl (t, flags); 858 break; 859 860 case TEMPLATE_ID_EXPR: 861 { 862 tree name = TREE_OPERAND (t, 0); 863 864 if (is_overloaded_fn (name)) 865 name = DECL_NAME (get_first_fn (name)); 866 dump_decl (name, flags); 867 pp_cxx_begin_template_argument_list (cxx_pp); 868 if (TREE_OPERAND (t, 1)) 869 dump_template_argument_list (TREE_OPERAND (t, 1), flags); 870 pp_cxx_end_template_argument_list (cxx_pp); 871 } 872 break; 873 874 case LABEL_DECL: 875 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t)); 876 break; 877 878 case CONST_DECL: 879 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) 880 || (DECL_INITIAL (t) && 881 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) 882 dump_simple_decl (t, TREE_TYPE (t), flags); 883 else if (DECL_NAME (t)) 884 dump_decl (DECL_NAME (t), flags); 885 else if (DECL_INITIAL (t)) 886 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS); 887 else 888 pp_identifier (cxx_pp, "<enumerator>"); 889 break; 890 891 case USING_DECL: 892 pp_cxx_identifier (cxx_pp, "using"); 893 dump_type (USING_DECL_SCOPE (t), flags); 894 pp_cxx_colon_colon (cxx_pp); 895 dump_decl (DECL_NAME (t), flags); 896 break; 897 898 case BASELINK: 899 dump_decl (BASELINK_FUNCTIONS (t), flags); 900 break; 901 902 case NON_DEPENDENT_EXPR: 903 dump_expr (t, flags); 904 break; 905 906 case TEMPLATE_TYPE_PARM: 907 if (flags & TFF_DECL_SPECIFIERS) 908 pp_cxx_declaration (cxx_pp, t); 909 else 910 pp_type_id (cxx_pp, t); 911 break; 912 913 case UNBOUND_CLASS_TEMPLATE: 914 dump_type (t, flags); 915 break; 916 917 default: 918 pp_unsupported_tree (cxx_pp, t); 919 /* Fall through to error. */ 920 921 case ERROR_MARK: 922 pp_identifier (cxx_pp, "<declaration error>"); 923 break; 924 } 925} 926 927/* Dump a template declaration T under control of FLAGS. This means the 928 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */ 929 930static void 931dump_template_decl (tree t, int flags) 932{ 933 tree orig_parms = DECL_TEMPLATE_PARMS (t); 934 tree parms; 935 int i; 936 937 if (flags & TFF_TEMPLATE_HEADER) 938 { 939 for (parms = orig_parms = nreverse (orig_parms); 940 parms; 941 parms = TREE_CHAIN (parms)) 942 { 943 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms); 944 int len = TREE_VEC_LENGTH (inner_parms); 945 946 pp_cxx_identifier (cxx_pp, "template"); 947 pp_cxx_begin_template_argument_list (cxx_pp); 948 949 /* If we've shown the template prefix, we'd better show the 950 parameters' and decl's type too. */ 951 flags |= TFF_DECL_SPECIFIERS; 952 953 for (i = 0; i < len; i++) 954 { 955 if (i) 956 pp_separate_with_comma (cxx_pp); 957 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags); 958 } 959 pp_cxx_end_template_argument_list (cxx_pp); 960 pp_cxx_whitespace (cxx_pp); 961 } 962 nreverse(orig_parms); 963 964 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 965 /* Say `template<arg> class TT' not just `template<arg> TT'. */ 966 pp_cxx_identifier (cxx_pp, "class"); 967 } 968 969 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) 970 dump_type (TREE_TYPE (t), 971 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 972 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0))); 973 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) 974 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME); 975 else 976 { 977 gcc_assert (TREE_TYPE (t)); 978 switch (NEXT_CODE (t)) 979 { 980 case METHOD_TYPE: 981 case FUNCTION_TYPE: 982 dump_function_decl (t, flags | TFF_TEMPLATE_NAME); 983 break; 984 default: 985 /* This case can occur with some invalid code. */ 986 dump_type (TREE_TYPE (t), 987 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME 988 | (flags & TFF_DECL_SPECIFIERS 989 ? TFF_CLASS_KEY_OR_ENUM : 0)); 990 } 991 } 992} 993 994/* Pretty print a function decl. There are several ways we want to print a 995 function declaration. The TFF_ bits in FLAGS tells us how to behave. 996 As error can only apply the '#' flag once to give 0 and 1 for V, there 997 is %D which doesn't print the throw specs, and %F which does. */ 998 999static void 1000dump_function_decl (tree t, int flags) 1001{ 1002 tree fntype; 1003 tree parmtypes; 1004 tree cname = NULL_TREE; 1005 tree template_args = NULL_TREE; 1006 tree template_parms = NULL_TREE; 1007 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS; 1008 1009 if (TREE_CODE (t) == TEMPLATE_DECL) 1010 t = DECL_TEMPLATE_RESULT (t); 1011 1012 /* Pretty print template instantiations only. */ 1013 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)) 1014 { 1015 tree tmpl; 1016 1017 template_args = DECL_TI_ARGS (t); 1018 tmpl = most_general_template (t); 1019 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL) 1020 { 1021 template_parms = DECL_TEMPLATE_PARMS (tmpl); 1022 t = tmpl; 1023 } 1024 } 1025 1026 fntype = TREE_TYPE (t); 1027 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t); 1028 1029 if (DECL_CLASS_SCOPE_P (t)) 1030 cname = DECL_CONTEXT (t); 1031 /* This is for partially instantiated template methods. */ 1032 else if (TREE_CODE (fntype) == METHOD_TYPE) 1033 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 1034 1035 if (!(flags & TFF_DECL_SPECIFIERS)) 1036 /* OK */; 1037 else if (DECL_STATIC_FUNCTION_P (t)) 1038 pp_cxx_identifier (cxx_pp, "static"); 1039 else if (DECL_VIRTUAL_P (t)) 1040 pp_cxx_identifier (cxx_pp, "virtual"); 1041 1042 /* Print the return type? */ 1043 if (show_return) 1044 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t) 1045 && !DECL_DESTRUCTOR_P (t); 1046 if (show_return) 1047 dump_type_prefix (TREE_TYPE (fntype), flags); 1048 1049 /* Print the function name. */ 1050 if (cname) 1051 { 1052 dump_type (cname, flags); 1053 pp_cxx_colon_colon (cxx_pp); 1054 } 1055 else 1056 dump_scope (CP_DECL_CONTEXT (t), flags); 1057 1058 dump_function_name (t, flags); 1059 1060 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS)) 1061 { 1062 dump_parameters (parmtypes, flags); 1063 1064 if (TREE_CODE (fntype) == METHOD_TYPE) 1065 { 1066 pp_base (cxx_pp)->padding = pp_before; 1067 pp_cxx_cv_qualifier_seq 1068 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); 1069 } 1070 1071 if (flags & TFF_EXCEPTION_SPECIFICATION) 1072 { 1073 pp_base (cxx_pp)->padding = pp_before; 1074 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags); 1075 } 1076 1077 if (show_return) 1078 dump_type_suffix (TREE_TYPE (fntype), flags); 1079 } 1080 1081 /* If T is a template instantiation, dump the parameter binding. */ 1082 if (template_parms != NULL_TREE && template_args != NULL_TREE) 1083 { 1084 pp_cxx_whitespace (cxx_pp); 1085 pp_cxx_left_bracket (cxx_pp); 1086 pp_cxx_identifier (cxx_pp, "with"); 1087 pp_cxx_whitespace (cxx_pp); 1088 dump_template_bindings (template_parms, template_args); 1089 pp_cxx_right_bracket (cxx_pp); 1090 } 1091} 1092 1093/* Print a parameter list. If this is for a member function, the 1094 member object ptr (and any other hidden args) should have 1095 already been removed. */ 1096 1097static void 1098dump_parameters (tree parmtypes, int flags) 1099{ 1100 int first; 1101 1102 pp_cxx_left_paren (cxx_pp); 1103 1104 for (first = 1; parmtypes != void_list_node; 1105 parmtypes = TREE_CHAIN (parmtypes)) 1106 { 1107 if (!first) 1108 pp_separate_with_comma (cxx_pp); 1109 first = 0; 1110 if (!parmtypes) 1111 { 1112 pp_cxx_identifier (cxx_pp, "..."); 1113 break; 1114 } 1115 dump_type (TREE_VALUE (parmtypes), flags); 1116 1117 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes)) 1118 { 1119 pp_cxx_whitespace (cxx_pp); 1120 pp_equal (cxx_pp); 1121 pp_cxx_whitespace (cxx_pp); 1122 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS); 1123 } 1124 } 1125 1126 pp_cxx_right_paren (cxx_pp); 1127} 1128 1129/* Print an exception specification. T is the exception specification. */ 1130 1131static void 1132dump_exception_spec (tree t, int flags) 1133{ 1134 if (t) 1135 { 1136 pp_cxx_identifier (cxx_pp, "throw"); 1137 pp_cxx_whitespace (cxx_pp); 1138 pp_cxx_left_paren (cxx_pp); 1139 if (TREE_VALUE (t) != NULL_TREE) 1140 while (1) 1141 { 1142 dump_type (TREE_VALUE (t), flags); 1143 t = TREE_CHAIN (t); 1144 if (!t) 1145 break; 1146 pp_separate_with_comma (cxx_pp); 1147 } 1148 pp_cxx_right_paren (cxx_pp); 1149 } 1150} 1151 1152/* Handle the function name for a FUNCTION_DECL node, grokking operators 1153 and destructors properly. */ 1154 1155static void 1156dump_function_name (tree t, int flags) 1157{ 1158 tree name = DECL_NAME (t); 1159 1160 /* We can get here with a decl that was synthesized by language- 1161 independent machinery (e.g. coverage.c) in which case it won't 1162 have a lang_specific structure attached and DECL_CONSTRUCTOR_P 1163 will crash. In this case it is safe just to print out the 1164 literal name. */ 1165 if (!DECL_LANG_SPECIFIC (t)) 1166 { 1167 pp_cxx_tree_identifier (cxx_pp, name); 1168 return; 1169 } 1170 1171 if (TREE_CODE (t) == TEMPLATE_DECL) 1172 t = DECL_TEMPLATE_RESULT (t); 1173 1174 /* Don't let the user see __comp_ctor et al. */ 1175 if (DECL_CONSTRUCTOR_P (t) 1176 || DECL_DESTRUCTOR_P (t)) 1177 name = constructor_name (DECL_CONTEXT (t)); 1178 1179 if (DECL_DESTRUCTOR_P (t)) 1180 { 1181 pp_cxx_complement (cxx_pp); 1182 dump_decl (name, TFF_PLAIN_IDENTIFIER); 1183 } 1184 else if (DECL_CONV_FN_P (t)) 1185 { 1186 /* This cannot use the hack that the operator's return 1187 type is stashed off of its name because it may be 1188 used for error reporting. In the case of conflicting 1189 declarations, both will have the same name, yet 1190 the types will be different, hence the TREE_TYPE field 1191 of the first name will be clobbered by the second. */ 1192 pp_cxx_identifier (cxx_pp, "operator"); 1193 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1194 } 1195 else if (IDENTIFIER_OPNAME_P (name)) 1196 pp_cxx_tree_identifier (cxx_pp, name); 1197 else 1198 dump_decl (name, flags); 1199 1200 if (DECL_TEMPLATE_INFO (t) 1201 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t) 1202 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1203 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1204 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags); 1205} 1206 1207/* Dump the template parameters from the template info INFO under control of 1208 FLAGS. PRIMARY indicates whether this is a primary template decl, or 1209 specialization (partial or complete). For partial specializations we show 1210 the specialized parameter values. For a primary template we show no 1211 decoration. */ 1212 1213static void 1214dump_template_parms (tree info, int primary, int flags) 1215{ 1216 tree args = info ? TI_ARGS (info) : NULL_TREE; 1217 1218 if (primary && flags & TFF_TEMPLATE_NAME) 1219 return; 1220 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME); 1221 pp_cxx_begin_template_argument_list (cxx_pp); 1222 1223 /* Be careful only to print things when we have them, so as not 1224 to crash producing error messages. */ 1225 if (args && !primary) 1226 { 1227 int len, ix; 1228 1229 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) 1230 args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1); 1231 1232 len = TREE_VEC_LENGTH (args); 1233 1234 for (ix = 0; ix != len; ix++) 1235 { 1236 tree arg = TREE_VEC_ELT (args, ix); 1237 1238 if (ix) 1239 pp_separate_with_comma (cxx_pp); 1240 1241 if (!arg) 1242 pp_identifier (cxx_pp, "<template parameter error>"); 1243 else 1244 dump_template_argument (arg, flags); 1245 } 1246 } 1247 else if (primary) 1248 { 1249 tree tpl = TI_TEMPLATE (info); 1250 tree parms = DECL_TEMPLATE_PARMS (tpl); 1251 int len, ix; 1252 1253 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE; 1254 len = parms ? TREE_VEC_LENGTH (parms) : 0; 1255 1256 for (ix = 0; ix != len; ix++) 1257 { 1258 tree parm; 1259 1260 if (TREE_VEC_ELT (parms, ix) == error_mark_node) 1261 { 1262 pp_identifier (cxx_pp, "<template parameter error>"); 1263 continue; 1264 } 1265 1266 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix)); 1267 1268 if (ix) 1269 pp_separate_with_comma (cxx_pp); 1270 1271 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS); 1272 } 1273 } 1274 pp_cxx_end_template_argument_list (cxx_pp); 1275} 1276 1277/* Print out a list of initializers (subr of dump_expr). */ 1278 1279static void 1280dump_expr_list (tree l, int flags) 1281{ 1282 while (l) 1283 { 1284 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS); 1285 l = TREE_CHAIN (l); 1286 if (l) 1287 pp_separate_with_comma (cxx_pp); 1288 } 1289} 1290 1291/* Print out a vector of initializers (subr of dump_expr). */ 1292 1293static void 1294dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags) 1295{ 1296 unsigned HOST_WIDE_INT idx; 1297 tree value; 1298 1299 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1300 { 1301 dump_expr (value, flags | TFF_EXPR_IN_PARENS); 1302 if (idx != VEC_length (constructor_elt, v) - 1) 1303 pp_separate_with_comma (cxx_pp); 1304 } 1305} 1306 1307 1308/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual 1309 function. Resolve it to a close relative -- in the sense of static 1310 type -- variant being overridden. That is close to what was written in 1311 the source code. Subroutine of dump_expr. */ 1312 1313static tree 1314resolve_virtual_fun_from_obj_type_ref (tree ref) 1315{ 1316 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref)); 1317 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1); 1318 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type))); 1319 while (index) 1320 { 1321 fun = TREE_CHAIN (fun); 1322 index -= (TARGET_VTABLE_USES_DESCRIPTORS 1323 ? TARGET_VTABLE_USES_DESCRIPTORS : 1); 1324 } 1325 1326 return BV_FN (fun); 1327} 1328 1329/* Print out an expression E under control of FLAGS. */ 1330 1331static void 1332dump_expr (tree t, int flags) 1333{ 1334 if (t == 0) 1335 return; 1336 1337 switch (TREE_CODE (t)) 1338 { 1339 case VAR_DECL: 1340 case PARM_DECL: 1341 case FIELD_DECL: 1342 case CONST_DECL: 1343 case FUNCTION_DECL: 1344 case TEMPLATE_DECL: 1345 case NAMESPACE_DECL: 1346 case LABEL_DECL: 1347 case OVERLOAD: 1348 case IDENTIFIER_NODE: 1349 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS); 1350 break; 1351 1352 case INTEGER_CST: 1353 case REAL_CST: 1354 case STRING_CST: 1355 pp_constant (cxx_pp, t); 1356 break; 1357 1358 case THROW_EXPR: 1359 pp_cxx_identifier (cxx_pp, "throw"); 1360 dump_expr (TREE_OPERAND (t, 0), flags); 1361 break; 1362 1363 case PTRMEM_CST: 1364 pp_ampersand (cxx_pp); 1365 dump_type (PTRMEM_CST_CLASS (t), flags); 1366 pp_cxx_colon_colon (cxx_pp); 1367 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); 1368 break; 1369 1370 case COMPOUND_EXPR: 1371 pp_cxx_left_paren (cxx_pp); 1372 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1373 pp_separate_with_comma (cxx_pp); 1374 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1375 pp_cxx_right_paren (cxx_pp); 1376 break; 1377 1378 case COND_EXPR: 1379 pp_cxx_left_paren (cxx_pp); 1380 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1381 pp_string (cxx_pp, " ? "); 1382 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1383 pp_string (cxx_pp, " : "); 1384 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS); 1385 pp_cxx_right_paren (cxx_pp); 1386 break; 1387 1388 case SAVE_EXPR: 1389 if (TREE_HAS_CONSTRUCTOR (t)) 1390 { 1391 pp_cxx_identifier (cxx_pp, "new"); 1392 pp_cxx_whitespace (cxx_pp); 1393 dump_type (TREE_TYPE (TREE_TYPE (t)), flags); 1394 } 1395 else 1396 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1397 break; 1398 1399 case AGGR_INIT_EXPR: 1400 { 1401 tree fn = NULL_TREE; 1402 1403 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR) 1404 fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0); 1405 1406 if (fn && TREE_CODE (fn) == FUNCTION_DECL) 1407 { 1408 if (DECL_CONSTRUCTOR_P (fn)) 1409 dump_type (DECL_CONTEXT (fn), flags); 1410 else 1411 dump_decl (fn, 0); 1412 } 1413 else 1414 dump_expr (TREE_OPERAND (t, 0), 0); 1415 } 1416 pp_cxx_left_paren (cxx_pp); 1417 if (TREE_OPERAND (t, 1)) 1418 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1419 pp_cxx_right_paren (cxx_pp); 1420 break; 1421 1422 case CALL_EXPR: 1423 { 1424 tree fn = TREE_OPERAND (t, 0); 1425 tree args = TREE_OPERAND (t, 1); 1426 1427 if (TREE_CODE (fn) == ADDR_EXPR) 1428 fn = TREE_OPERAND (fn, 0); 1429 1430 /* Nobody is interested in seeing the guts of vcalls. */ 1431 if (TREE_CODE (fn) == OBJ_TYPE_REF) 1432 fn = resolve_virtual_fun_from_obj_type_ref (fn); 1433 1434 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE) 1435 { 1436 tree ob = TREE_VALUE (args); 1437 if (TREE_CODE (ob) == ADDR_EXPR) 1438 { 1439 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1440 pp_cxx_dot (cxx_pp); 1441 } 1442 else if (TREE_CODE (ob) != PARM_DECL 1443 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1444 { 1445 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1446 pp_cxx_arrow (cxx_pp); 1447 } 1448 args = TREE_CHAIN (args); 1449 } 1450 dump_expr (fn, flags | TFF_EXPR_IN_PARENS); 1451 pp_cxx_left_paren (cxx_pp); 1452 dump_expr_list (args, flags); 1453 pp_cxx_right_paren (cxx_pp); 1454 } 1455 break; 1456 1457 case NEW_EXPR: 1458 { 1459 tree type = TREE_OPERAND (t, 1); 1460 tree init = TREE_OPERAND (t, 2); 1461 if (NEW_EXPR_USE_GLOBAL (t)) 1462 pp_cxx_colon_colon (cxx_pp); 1463 pp_cxx_identifier (cxx_pp, "new"); 1464 if (TREE_OPERAND (t, 0)) 1465 { 1466 pp_cxx_left_paren (cxx_pp); 1467 dump_expr_list (TREE_OPERAND (t, 0), flags); 1468 pp_cxx_right_paren (cxx_pp); 1469 pp_cxx_whitespace (cxx_pp); 1470 } 1471 if (TREE_CODE (type) == ARRAY_REF) 1472 type = build_cplus_array_type 1473 (TREE_OPERAND (type, 0), 1474 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node, 1475 TREE_OPERAND (type, 1), 1476 integer_one_node))); 1477 dump_type (type, flags); 1478 if (init) 1479 { 1480 pp_cxx_left_paren (cxx_pp); 1481 if (TREE_CODE (init) == TREE_LIST) 1482 dump_expr_list (init, flags); 1483 else if (init == void_zero_node) 1484 /* This representation indicates an empty initializer, 1485 e.g.: "new int()". */ 1486 ; 1487 else 1488 dump_expr (init, flags); 1489 pp_cxx_right_paren (cxx_pp); 1490 } 1491 } 1492 break; 1493 1494 case TARGET_EXPR: 1495 /* Note that this only works for G++ target exprs. If somebody 1496 builds a general TARGET_EXPR, there's no way to represent that 1497 it initializes anything other that the parameter slot for the 1498 default argument. Note we may have cleared out the first 1499 operand in expand_expr, so don't go killing ourselves. */ 1500 if (TREE_OPERAND (t, 1)) 1501 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1502 break; 1503 1504 case INIT_EXPR: 1505 case MODIFY_EXPR: 1506 case PLUS_EXPR: 1507 case MINUS_EXPR: 1508 case MULT_EXPR: 1509 case TRUNC_DIV_EXPR: 1510 case TRUNC_MOD_EXPR: 1511 case MIN_EXPR: 1512 case MAX_EXPR: 1513 case LSHIFT_EXPR: 1514 case RSHIFT_EXPR: 1515 case BIT_IOR_EXPR: 1516 case BIT_XOR_EXPR: 1517 case BIT_AND_EXPR: 1518 case TRUTH_ANDIF_EXPR: 1519 case TRUTH_ORIF_EXPR: 1520 case LT_EXPR: 1521 case LE_EXPR: 1522 case GT_EXPR: 1523 case GE_EXPR: 1524 case EQ_EXPR: 1525 case NE_EXPR: 1526 case EXACT_DIV_EXPR: 1527 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags); 1528 break; 1529 1530 case CEIL_DIV_EXPR: 1531 case FLOOR_DIV_EXPR: 1532 case ROUND_DIV_EXPR: 1533 case RDIV_EXPR: 1534 dump_binary_op ("/", t, flags); 1535 break; 1536 1537 case CEIL_MOD_EXPR: 1538 case FLOOR_MOD_EXPR: 1539 case ROUND_MOD_EXPR: 1540 dump_binary_op ("%", t, flags); 1541 break; 1542 1543 case COMPONENT_REF: 1544 { 1545 tree ob = TREE_OPERAND (t, 0); 1546 if (TREE_CODE (ob) == INDIRECT_REF) 1547 { 1548 ob = TREE_OPERAND (ob, 0); 1549 if (TREE_CODE (ob) != PARM_DECL 1550 || (DECL_NAME (ob) 1551 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))) 1552 { 1553 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1554 pp_cxx_arrow (cxx_pp); 1555 } 1556 } 1557 else 1558 { 1559 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1560 pp_cxx_dot (cxx_pp); 1561 } 1562 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS); 1563 } 1564 break; 1565 1566 case ARRAY_REF: 1567 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1568 pp_cxx_left_bracket (cxx_pp); 1569 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1570 pp_cxx_right_bracket (cxx_pp); 1571 break; 1572 1573 case UNARY_PLUS_EXPR: 1574 dump_unary_op ("+", t, flags); 1575 break; 1576 1577 case ADDR_EXPR: 1578 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 1579 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST 1580 /* An ADDR_EXPR can have reference type. In that case, we 1581 shouldn't print the `&' doing so indicates to the user 1582 that the expression has pointer type. */ 1583 || (TREE_TYPE (t) 1584 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)) 1585 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1586 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL) 1587 dump_unary_op ("&&", t, flags); 1588 else 1589 dump_unary_op ("&", t, flags); 1590 break; 1591 1592 case INDIRECT_REF: 1593 if (TREE_HAS_CONSTRUCTOR (t)) 1594 { 1595 t = TREE_OPERAND (t, 0); 1596 gcc_assert (TREE_CODE (t) == CALL_EXPR); 1597 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1598 pp_cxx_left_paren (cxx_pp); 1599 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags); 1600 pp_cxx_right_paren (cxx_pp); 1601 } 1602 else 1603 { 1604 if (TREE_OPERAND (t,0) != NULL_TREE 1605 && TREE_TYPE (TREE_OPERAND (t, 0)) 1606 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 1607 dump_expr (TREE_OPERAND (t, 0), flags); 1608 else 1609 dump_unary_op ("*", t, flags); 1610 } 1611 break; 1612 1613 case NEGATE_EXPR: 1614 case BIT_NOT_EXPR: 1615 case TRUTH_NOT_EXPR: 1616 case PREDECREMENT_EXPR: 1617 case PREINCREMENT_EXPR: 1618 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags); 1619 break; 1620 1621 case POSTDECREMENT_EXPR: 1622 case POSTINCREMENT_EXPR: 1623 pp_cxx_left_paren (cxx_pp); 1624 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1625 pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name); 1626 pp_cxx_right_paren (cxx_pp); 1627 break; 1628 1629 case NON_LVALUE_EXPR: 1630 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 1631 should be another level of INDIRECT_REF so that I don't have to do 1632 this. */ 1633 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 1634 { 1635 tree next = TREE_TYPE (TREE_TYPE (t)); 1636 1637 while (TREE_CODE (next) == POINTER_TYPE) 1638 next = TREE_TYPE (next); 1639 1640 if (TREE_CODE (next) == FUNCTION_TYPE) 1641 { 1642 if (flags & TFF_EXPR_IN_PARENS) 1643 pp_cxx_left_paren (cxx_pp); 1644 pp_cxx_star (cxx_pp); 1645 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1646 if (flags & TFF_EXPR_IN_PARENS) 1647 pp_cxx_right_paren (cxx_pp); 1648 break; 1649 } 1650 /* Else fall through. */ 1651 } 1652 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1653 break; 1654 1655 case NOP_EXPR: 1656 case CONVERT_EXPR: 1657 { 1658 tree op = TREE_OPERAND (t, 0); 1659 1660 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))) 1661 { 1662 /* It is a cast, but we cannot tell whether it is a 1663 reinterpret or static cast. Use the C style notation. */ 1664 if (flags & TFF_EXPR_IN_PARENS) 1665 pp_cxx_left_paren (cxx_pp); 1666 pp_cxx_left_paren (cxx_pp); 1667 dump_type (TREE_TYPE (t), flags); 1668 pp_cxx_right_paren (cxx_pp); 1669 dump_expr (op, flags | TFF_EXPR_IN_PARENS); 1670 if (flags & TFF_EXPR_IN_PARENS) 1671 pp_cxx_right_paren (cxx_pp); 1672 } 1673 else 1674 dump_expr (op, flags); 1675 break; 1676 } 1677 1678 case CONSTRUCTOR: 1679 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 1680 { 1681 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier); 1682 1683 if (integer_zerop (idx)) 1684 { 1685 /* A NULL pointer-to-member constant. */ 1686 pp_cxx_left_paren (cxx_pp); 1687 pp_cxx_left_paren (cxx_pp); 1688 dump_type (TREE_TYPE (t), flags); 1689 pp_cxx_right_paren (cxx_pp); 1690 pp_character (cxx_pp, '0'); 1691 pp_cxx_right_paren (cxx_pp); 1692 break; 1693 } 1694 else if (host_integerp (idx, 0)) 1695 { 1696 tree virtuals; 1697 unsigned HOST_WIDE_INT n; 1698 1699 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 1700 t = TYPE_METHOD_BASETYPE (t); 1701 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 1702 1703 n = tree_low_cst (idx, 0); 1704 1705 /* Map vtable index back one, to allow for the null pointer to 1706 member. */ 1707 --n; 1708 1709 while (n > 0 && virtuals) 1710 { 1711 --n; 1712 virtuals = TREE_CHAIN (virtuals); 1713 } 1714 if (virtuals) 1715 { 1716 dump_expr (BV_FN (virtuals), 1717 flags | TFF_EXPR_IN_PARENS); 1718 break; 1719 } 1720 } 1721 } 1722 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t)) 1723 { 1724 dump_type (TREE_TYPE (t), 0); 1725 pp_cxx_left_paren (cxx_pp); 1726 pp_cxx_right_paren (cxx_pp); 1727 } 1728 else 1729 { 1730 pp_cxx_left_brace (cxx_pp); 1731 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags); 1732 pp_cxx_right_brace (cxx_pp); 1733 } 1734 1735 break; 1736 1737 case OFFSET_REF: 1738 { 1739 tree ob = TREE_OPERAND (t, 0); 1740 if (is_dummy_object (ob)) 1741 { 1742 t = TREE_OPERAND (t, 1); 1743 if (TREE_CODE (t) == FUNCTION_DECL) 1744 /* A::f */ 1745 dump_expr (t, flags | TFF_EXPR_IN_PARENS); 1746 else if (BASELINK_P (t)) 1747 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)), 1748 flags | TFF_EXPR_IN_PARENS); 1749 else 1750 dump_decl (t, flags); 1751 } 1752 else 1753 { 1754 if (TREE_CODE (ob) == INDIRECT_REF) 1755 { 1756 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS); 1757 pp_cxx_arrow (cxx_pp); 1758 pp_cxx_star (cxx_pp); 1759 } 1760 else 1761 { 1762 dump_expr (ob, flags | TFF_EXPR_IN_PARENS); 1763 pp_cxx_dot (cxx_pp); 1764 pp_cxx_star (cxx_pp); 1765 } 1766 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1767 } 1768 break; 1769 } 1770 1771 case TEMPLATE_PARM_INDEX: 1772 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS); 1773 break; 1774 1775 case SCOPE_REF: 1776 pp_expression (cxx_pp, t); 1777 break; 1778 1779 case CAST_EXPR: 1780 if (TREE_OPERAND (t, 0) == NULL_TREE 1781 || TREE_CHAIN (TREE_OPERAND (t, 0))) 1782 { 1783 dump_type (TREE_TYPE (t), flags); 1784 pp_cxx_left_paren (cxx_pp); 1785 dump_expr_list (TREE_OPERAND (t, 0), flags); 1786 pp_cxx_right_paren (cxx_pp); 1787 } 1788 else 1789 { 1790 pp_cxx_left_paren (cxx_pp); 1791 dump_type (TREE_TYPE (t), flags); 1792 pp_cxx_right_paren (cxx_pp); 1793 pp_cxx_left_paren (cxx_pp); 1794 dump_expr_list (TREE_OPERAND (t, 0), flags); 1795 pp_cxx_right_paren (cxx_pp); 1796 } 1797 break; 1798 1799 case STATIC_CAST_EXPR: 1800 pp_cxx_identifier (cxx_pp, "static_cast"); 1801 goto cast; 1802 case REINTERPRET_CAST_EXPR: 1803 pp_cxx_identifier (cxx_pp, "reinterpret_cast"); 1804 goto cast; 1805 case CONST_CAST_EXPR: 1806 pp_cxx_identifier (cxx_pp, "const_cast"); 1807 goto cast; 1808 case DYNAMIC_CAST_EXPR: 1809 pp_cxx_identifier (cxx_pp, "dynamic_cast"); 1810 cast: 1811 pp_cxx_begin_template_argument_list (cxx_pp); 1812 dump_type (TREE_TYPE (t), flags); 1813 pp_cxx_end_template_argument_list (cxx_pp); 1814 pp_cxx_left_paren (cxx_pp); 1815 dump_expr (TREE_OPERAND (t, 0), flags); 1816 pp_cxx_right_paren (cxx_pp); 1817 break; 1818 1819 case ARROW_EXPR: 1820 dump_expr (TREE_OPERAND (t, 0), flags); 1821 pp_cxx_arrow (cxx_pp); 1822 break; 1823 1824 case SIZEOF_EXPR: 1825 case ALIGNOF_EXPR: 1826 if (TREE_CODE (t) == SIZEOF_EXPR) 1827 pp_cxx_identifier (cxx_pp, "sizeof"); 1828 else 1829 { 1830 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); 1831 pp_cxx_identifier (cxx_pp, "__alignof__"); 1832 } 1833 pp_cxx_whitespace (cxx_pp); 1834 pp_cxx_left_paren (cxx_pp); 1835 if (TYPE_P (TREE_OPERAND (t, 0))) 1836 dump_type (TREE_OPERAND (t, 0), flags); 1837 else 1838 dump_expr (TREE_OPERAND (t, 0), flags); 1839 pp_cxx_right_paren (cxx_pp); 1840 break; 1841 1842 case REALPART_EXPR: 1843 case IMAGPART_EXPR: 1844 pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name); 1845 pp_cxx_whitespace (cxx_pp); 1846 dump_expr (TREE_OPERAND (t, 0), flags); 1847 break; 1848 1849 case DEFAULT_ARG: 1850 pp_identifier (cxx_pp, "<unparsed>"); 1851 break; 1852 1853 case TRY_CATCH_EXPR: 1854 case WITH_CLEANUP_EXPR: 1855 case CLEANUP_POINT_EXPR: 1856 dump_expr (TREE_OPERAND (t, 0), flags); 1857 break; 1858 1859 case PSEUDO_DTOR_EXPR: 1860 dump_expr (TREE_OPERAND (t, 2), flags); 1861 pp_cxx_dot (cxx_pp); 1862 dump_type (TREE_OPERAND (t, 0), flags); 1863 pp_cxx_colon_colon (cxx_pp); 1864 pp_cxx_complement (cxx_pp); 1865 dump_type (TREE_OPERAND (t, 1), flags); 1866 break; 1867 1868 case TEMPLATE_ID_EXPR: 1869 dump_decl (t, flags); 1870 break; 1871 1872 case BIND_EXPR: 1873 case STMT_EXPR: 1874 case STATEMENT_LIST: 1875 /* We don't yet have a way of dumping statements in a 1876 human-readable format. */ 1877 pp_string (cxx_pp, "({...})"); 1878 break; 1879 1880 case LOOP_EXPR: 1881 pp_string (cxx_pp, "while (1) { "); 1882 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1883 pp_cxx_right_brace (cxx_pp); 1884 break; 1885 1886 case EXIT_EXPR: 1887 pp_string (cxx_pp, "if ("); 1888 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1889 pp_string (cxx_pp, ") break; "); 1890 break; 1891 1892 case BASELINK: 1893 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS); 1894 break; 1895 1896 case EMPTY_CLASS_EXPR: 1897 dump_type (TREE_TYPE (t), flags); 1898 pp_cxx_left_paren (cxx_pp); 1899 pp_cxx_right_paren (cxx_pp); 1900 break; 1901 1902 case NON_DEPENDENT_EXPR: 1903 dump_expr (TREE_OPERAND (t, 0), flags); 1904 break; 1905 1906 /* This list is incomplete, but should suffice for now. 1907 It is very important that `sorry' does not call 1908 `report_error_function'. That could cause an infinite loop. */ 1909 default: 1910 pp_unsupported_tree (cxx_pp, t); 1911 /* fall through to ERROR_MARK... */ 1912 case ERROR_MARK: 1913 pp_identifier (cxx_pp, "<expression error>"); 1914 break; 1915 } 1916} 1917 1918static void 1919dump_binary_op (const char *opstring, tree t, int flags) 1920{ 1921 pp_cxx_left_paren (cxx_pp); 1922 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); 1923 pp_cxx_whitespace (cxx_pp); 1924 if (opstring) 1925 pp_cxx_identifier (cxx_pp, opstring); 1926 else 1927 pp_identifier (cxx_pp, "<unknown operator>"); 1928 pp_cxx_whitespace (cxx_pp); 1929 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS); 1930 pp_cxx_right_paren (cxx_pp); 1931} 1932 1933static void 1934dump_unary_op (const char *opstring, tree t, int flags) 1935{ 1936 if (flags & TFF_EXPR_IN_PARENS) 1937 pp_cxx_left_paren (cxx_pp); 1938 pp_cxx_identifier (cxx_pp, opstring); 1939 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS); 1940 if (flags & TFF_EXPR_IN_PARENS) 1941 pp_cxx_right_paren (cxx_pp); 1942} 1943 1944static void 1945reinit_cxx_pp (void) 1946{ 1947 pp_clear_output_area (cxx_pp); 1948 pp_base (cxx_pp)->padding = pp_none; 1949 pp_indentation (cxx_pp) = 0; 1950 pp_needs_newline (cxx_pp) = false; 1951 cxx_pp->enclosing_scope = 0; 1952} 1953 1954 1955/* Exported interface to stringifying types, exprs and decls under TFF_* 1956 control. */ 1957 1958const char * 1959type_as_string (tree typ, int flags) 1960{ 1961 reinit_cxx_pp (); 1962 dump_type (typ, flags); 1963 return pp_formatted_text (cxx_pp); 1964} 1965 1966const char * 1967expr_as_string (tree decl, int flags) 1968{ 1969 reinit_cxx_pp (); 1970 dump_expr (decl, flags); 1971 return pp_formatted_text (cxx_pp); 1972} 1973 1974const char * 1975decl_as_string (tree decl, int flags) 1976{ 1977 reinit_cxx_pp (); 1978 dump_decl (decl, flags); 1979 return pp_formatted_text (cxx_pp); 1980} 1981 1982/* Generate the three forms of printable names for cxx_printable_name. */ 1983 1984const char * 1985lang_decl_name (tree decl, int v) 1986{ 1987 if (v >= 2) 1988 return decl_as_string (decl, TFF_DECL_SPECIFIERS); 1989 1990 reinit_cxx_pp (); 1991 if (v == 1 && DECL_CLASS_SCOPE_P (decl)) 1992 { 1993 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER); 1994 pp_cxx_colon_colon (cxx_pp); 1995 } 1996 1997 if (TREE_CODE (decl) == FUNCTION_DECL) 1998 dump_function_name (decl, TFF_PLAIN_IDENTIFIER); 1999 else 2000 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER); 2001 2002 return pp_formatted_text (cxx_pp); 2003} 2004 2005/* Return the location of a tree passed to %+ formats. */ 2006 2007static location_t 2008location_of (tree t) 2009{ 2010 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 2011 t = DECL_CONTEXT (t); 2012 else if (TYPE_P (t)) 2013 t = TYPE_MAIN_DECL (t); 2014 else if (TREE_CODE (t) == OVERLOAD) 2015 t = OVL_FUNCTION (t); 2016 2017 return DECL_SOURCE_LOCATION (t); 2018} 2019 2020/* Now the interfaces from error et al to dump_type et al. Each takes an 2021 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_ 2022 function. */ 2023 2024static const char * 2025decl_to_string (tree decl, int verbose) 2026{ 2027 int flags = 0; 2028 2029 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE 2030 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE) 2031 flags = TFF_CLASS_KEY_OR_ENUM; 2032 if (verbose) 2033 flags |= TFF_DECL_SPECIFIERS; 2034 else if (TREE_CODE (decl) == FUNCTION_DECL) 2035 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE; 2036 flags |= TFF_TEMPLATE_HEADER; 2037 2038 reinit_cxx_pp (); 2039 dump_decl (decl, flags); 2040 return pp_formatted_text (cxx_pp); 2041} 2042 2043static const char * 2044expr_to_string (tree decl) 2045{ 2046 reinit_cxx_pp (); 2047 dump_expr (decl, 0); 2048 return pp_formatted_text (cxx_pp); 2049} 2050 2051static const char * 2052fndecl_to_string (tree fndecl, int verbose) 2053{ 2054 int flags; 2055 2056 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS 2057 | TFF_TEMPLATE_HEADER; 2058 if (verbose) 2059 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS; 2060 reinit_cxx_pp (); 2061 dump_decl (fndecl, flags); 2062 return pp_formatted_text (cxx_pp); 2063} 2064 2065 2066static const char * 2067code_to_string (enum tree_code c) 2068{ 2069 return tree_code_name [c]; 2070} 2071 2072const char * 2073language_to_string (enum languages c) 2074{ 2075 switch (c) 2076 { 2077 case lang_c: 2078 return "C"; 2079 2080 case lang_cplusplus: 2081 return "C++"; 2082 2083 case lang_java: 2084 return "Java"; 2085 2086 default: 2087 gcc_unreachable (); 2088 } 2089 return NULL; 2090} 2091 2092/* Return the proper printed version of a parameter to a C++ function. */ 2093 2094static const char * 2095parm_to_string (int p) 2096{ 2097 reinit_cxx_pp (); 2098 if (p < 0) 2099 pp_string (cxx_pp, "'this'"); 2100 else 2101 pp_decimal_int (cxx_pp, p + 1); 2102 return pp_formatted_text (cxx_pp); 2103} 2104 2105static const char * 2106op_to_string (enum tree_code p) 2107{ 2108 tree id = operator_name_info[(int) p].identifier; 2109 return id ? IDENTIFIER_POINTER (id) : "<unknown>"; 2110} 2111 2112static const char * 2113type_to_string (tree typ, int verbose) 2114{ 2115 int flags = 0; 2116 if (verbose) 2117 flags |= TFF_CLASS_KEY_OR_ENUM; 2118 flags |= TFF_TEMPLATE_HEADER; 2119 2120 reinit_cxx_pp (); 2121 dump_type (typ, flags); 2122 return pp_formatted_text (cxx_pp); 2123} 2124 2125static const char * 2126assop_to_string (enum tree_code p) 2127{ 2128 tree id = assignment_operator_name_info[(int) p].identifier; 2129 return id ? IDENTIFIER_POINTER (id) : "{unknown}"; 2130} 2131 2132static const char * 2133args_to_string (tree p, int verbose) 2134{ 2135 int flags = 0; 2136 if (verbose) 2137 flags |= TFF_CLASS_KEY_OR_ENUM; 2138 2139 if (p == NULL_TREE) 2140 return ""; 2141 2142 if (TYPE_P (TREE_VALUE (p))) 2143 return type_as_string (p, flags); 2144 2145 reinit_cxx_pp (); 2146 for (; p; p = TREE_CHAIN (p)) 2147 { 2148 if (TREE_VALUE (p) == null_node) 2149 pp_cxx_identifier (cxx_pp, "NULL"); 2150 else 2151 dump_type (error_type (TREE_VALUE (p)), flags); 2152 if (TREE_CHAIN (p)) 2153 pp_separate_with_comma (cxx_pp); 2154 } 2155 return pp_formatted_text (cxx_pp); 2156} 2157 2158static const char * 2159cv_to_string (tree p, int v) 2160{ 2161 reinit_cxx_pp (); 2162 pp_base (cxx_pp)->padding = v ? pp_before : pp_none; 2163 pp_cxx_cv_qualifier_seq (cxx_pp, p); 2164 return pp_formatted_text (cxx_pp); 2165} 2166 2167/* Langhook for print_error_function. */ 2168void 2169cxx_print_error_function (diagnostic_context *context, const char *file) 2170{ 2171 lhd_print_error_function (context, file); 2172 pp_base_set_prefix (context->printer, file); 2173 maybe_print_instantiation_context (context); 2174} 2175 2176static void 2177cp_diagnostic_starter (diagnostic_context *context, 2178 diagnostic_info *diagnostic) 2179{ 2180 diagnostic_report_current_module (context); 2181 cp_print_error_function (context, diagnostic); 2182 maybe_print_instantiation_context (context); 2183 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic)); 2184} 2185 2186static void 2187cp_diagnostic_finalizer (diagnostic_context *context, 2188 diagnostic_info *diagnostic ATTRIBUTE_UNUSED) 2189{ 2190 pp_base_destroy_prefix (context->printer); 2191} 2192 2193/* Print current function onto BUFFER, in the process of reporting 2194 a diagnostic message. Called from cp_diagnostic_starter. */ 2195static void 2196cp_print_error_function (diagnostic_context *context, 2197 diagnostic_info *diagnostic) 2198{ 2199 if (diagnostic_last_function_changed (context)) 2200 { 2201 const char *old_prefix = context->printer->prefix; 2202 const char *file = LOCATION_FILE (diagnostic->location); 2203 char *new_prefix = file ? file_name_as_prefix (file) : NULL; 2204 2205 pp_base_set_prefix (context->printer, new_prefix); 2206 2207 if (current_function_decl == NULL) 2208 pp_base_string (context->printer, "At global scope:"); 2209 else 2210 pp_printf (context->printer, "In %s %qs:", 2211 function_category (current_function_decl), 2212 cxx_printable_name (current_function_decl, 2)); 2213 pp_base_newline (context->printer); 2214 2215 diagnostic_set_last_function (context); 2216 pp_base_destroy_prefix (context->printer); 2217 context->printer->prefix = old_prefix; 2218 } 2219} 2220 2221/* Returns a description of FUNCTION using standard terminology. */ 2222static const char * 2223function_category (tree fn) 2224{ 2225 if (DECL_FUNCTION_MEMBER_P (fn)) 2226 { 2227 if (DECL_STATIC_FUNCTION_P (fn)) 2228 return "static member function"; 2229 else if (DECL_COPY_CONSTRUCTOR_P (fn)) 2230 return "copy constructor"; 2231 else if (DECL_CONSTRUCTOR_P (fn)) 2232 return "constructor"; 2233 else if (DECL_DESTRUCTOR_P (fn)) 2234 return "destructor"; 2235 else 2236 return "member function"; 2237 } 2238 else 2239 return "function"; 2240} 2241 2242/* Report the full context of a current template instantiation, 2243 onto BUFFER. */ 2244static void 2245print_instantiation_full_context (diagnostic_context *context) 2246{ 2247 tree p = current_instantiation (); 2248 location_t location = input_location; 2249 2250 if (p) 2251 { 2252 if (current_function_decl != TINST_DECL (p) 2253 && current_function_decl != NULL_TREE) 2254 /* We can get here during the processing of some synthesized 2255 method. Then, TINST_DECL (p) will be the function that's causing 2256 the synthesis. */ 2257 ; 2258 else 2259 { 2260 if (current_function_decl == TINST_DECL (p)) 2261 /* Avoid redundancy with the "In function" line. */; 2262 else 2263 pp_verbatim (context->printer, 2264 "%s: In instantiation of %qs:\n", 2265 LOCATION_FILE (location), 2266 decl_as_string (TINST_DECL (p), 2267 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2268 2269 location = TINST_LOCATION (p); 2270 p = TREE_CHAIN (p); 2271 } 2272 } 2273 2274 print_instantiation_partial_context (context, p, location); 2275} 2276 2277/* Same as above but less verbose. */ 2278static void 2279print_instantiation_partial_context (diagnostic_context *context, 2280 tree t, location_t loc) 2281{ 2282 expanded_location xloc; 2283 for (; ; t = TREE_CHAIN (t)) 2284 { 2285 xloc = expand_location (loc); 2286 if (t == NULL_TREE) 2287 break; 2288 pp_verbatim (context->printer, "%s:%d: instantiated from %qs\n", 2289 xloc.file, xloc.line, 2290 decl_as_string (TINST_DECL (t), 2291 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE)); 2292 loc = TINST_LOCATION (t); 2293 } 2294 pp_verbatim (context->printer, "%s:%d: instantiated from here", 2295 xloc.file, xloc.line); 2296 pp_base_newline (context->printer); 2297} 2298 2299/* Called from cp_thing to print the template context for an error. */ 2300static void 2301maybe_print_instantiation_context (diagnostic_context *context) 2302{ 2303 if (!problematic_instantiation_changed () || current_instantiation () == 0) 2304 return; 2305 2306 record_last_problematic_instantiation (); 2307 print_instantiation_full_context (context); 2308} 2309 2310/* Report the bare minimum context of a template instantiation. */ 2311void 2312print_instantiation_context (void) 2313{ 2314 print_instantiation_partial_context 2315 (global_dc, current_instantiation (), input_location); 2316 diagnostic_flush_buffer (global_dc); 2317} 2318 2319/* Called from output_format -- during diagnostic message processing -- 2320 to handle C++ specific format specifier with the following meanings: 2321 %A function argument-list. 2322 %C tree code. 2323 %D declaration. 2324 %E expression. 2325 %F function declaration. 2326 %L language as used in extern "lang". 2327 %O binary operator. 2328 %P function parameter whose position is indicated by an integer. 2329 %Q assignment operator. 2330 %T type. 2331 %V cv-qualifier. */ 2332static bool 2333cp_printer (pretty_printer *pp, text_info *text, const char *spec, 2334 int precision, bool wide, bool set_locus, bool verbose) 2335{ 2336 const char *result; 2337 tree t = NULL; 2338#define next_tree (t = va_arg (*text->args_ptr, tree)) 2339#define next_tcode va_arg (*text->args_ptr, enum tree_code) 2340#define next_lang va_arg (*text->args_ptr, enum languages) 2341#define next_int va_arg (*text->args_ptr, int) 2342 2343 if (precision != 0 || wide) 2344 return false; 2345 2346 if (text->locus == NULL) 2347 set_locus = false; 2348 2349 switch (*spec) 2350 { 2351 case 'A': result = args_to_string (next_tree, verbose); break; 2352 case 'C': result = code_to_string (next_tcode); break; 2353 case 'D': 2354 { 2355 tree temp = next_tree; 2356 if (DECL_P (temp) 2357 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp)) 2358 { 2359 temp = DECL_DEBUG_EXPR (temp); 2360 if (!DECL_P (temp)) 2361 { 2362 result = expr_to_string (temp); 2363 break; 2364 } 2365 } 2366 result = decl_to_string (temp, verbose); 2367 } 2368 break; 2369 case 'E': result = expr_to_string (next_tree); break; 2370 case 'F': result = fndecl_to_string (next_tree, verbose); break; 2371 case 'L': result = language_to_string (next_lang); break; 2372 case 'O': result = op_to_string (next_tcode); break; 2373 case 'P': result = parm_to_string (next_int); break; 2374 case 'Q': result = assop_to_string (next_tcode); break; 2375 case 'T': result = type_to_string (next_tree, verbose); break; 2376 case 'V': result = cv_to_string (next_tree, verbose); break; 2377 2378 default: 2379 return false; 2380 } 2381 2382 pp_base_string (pp, result); 2383 if (set_locus && t != NULL) 2384 *text->locus = location_of (t); 2385 return true; 2386#undef next_tree 2387#undef next_tcode 2388#undef next_lang 2389#undef next_int 2390} 2391 2392/* Callback from cpp_error for PFILE to print diagnostics arising from 2393 interpreting strings. The diagnostic is of type LEVEL; MSG is the 2394 translated message and AP the arguments. */ 2395 2396void 2397cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, 2398 const char *msg, va_list *ap) 2399{ 2400 diagnostic_info diagnostic; 2401 diagnostic_t dlevel; 2402 switch (level) 2403 { 2404 case CPP_DL_WARNING: 2405 case CPP_DL_WARNING_SYSHDR: 2406 dlevel = DK_WARNING; 2407 break; 2408 case CPP_DL_PEDWARN: 2409 dlevel = pedantic_error_kind (); 2410 break; 2411 case CPP_DL_ERROR: 2412 dlevel = DK_ERROR; 2413 break; 2414 case CPP_DL_ICE: 2415 dlevel = DK_ICE; 2416 break; 2417 default: 2418 gcc_unreachable (); 2419 } 2420 diagnostic_set_info_translated (&diagnostic, msg, ap, 2421 input_location, dlevel); 2422 report_diagnostic (&diagnostic); 2423} 2424