error.c revision 52284
1/* Call-backs for C++ error reporting. 2 This code is non-reentrant. 3 Copyright (C) 1993, 94-97, 1998, 1999 Free Software Foundation, Inc. 4 5 This file is part of GNU CC. 6 7GNU CC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "tree.h" 25#include "cp-tree.h" 26#include "obstack.h" 27#include "toplev.h" 28 29typedef char* cp_printer (); 30 31#define A args_as_string 32#define C code_as_string 33#define D decl_as_string 34#define E expr_as_string 35#define F fndecl_as_string 36#define L language_as_string 37#define O op_as_string 38#define P parm_as_string 39#define Q assop_as_string 40#define T type_as_string 41#define V cv_as_string 42 43#define o (cp_printer *) 0 44cp_printer * cp_printers[256] = 45{ 46/*0 1 2 3 4 5 6 7 8 9 A B C D E F */ 47 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x00 */ 48 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x10 */ 49 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x20 */ 50 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x30 */ 51 o, A, o, C, D, E, F, o, o, o, o, o, L, o, o, O, /* 0x40 */ 52 P, Q, o, o, T, o, V, o, o, o, o, o, o, o, o, o, /* 0x50 */ 53 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x60 */ 54 o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, o, /* 0x70 */ 55}; 56#undef C 57#undef D 58#undef E 59#undef F 60#undef L 61#undef O 62#undef P 63#undef Q 64#undef T 65#undef V 66#undef o 67 68#define obstack_chunk_alloc xmalloc 69#define obstack_chunk_free free 70 71/* Obstack where we build text strings for overloading, etc. */ 72static struct obstack scratch_obstack; 73static char *scratch_firstobj; 74 75# define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0) 76# define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C))) 77# define OB_PUTC2(C1,C2) \ 78 (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2))) 79# define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1)) 80# define OB_PUTID(ID) \ 81 (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \ 82 IDENTIFIER_LENGTH (ID))) 83# define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S))) 84# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0')) 85# define OB_PUTI(CST) do { sprintf (digit_buffer, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)(CST)); \ 86 OB_PUTCP (digit_buffer); } while (0) 87# define OB_UNPUT(N) obstack_blank (&scratch_obstack, - (N)); 88 89# define OB_END_TEMPLATE_ID() \ 90 ((obstack_next_free (&scratch_obstack) != obstack_base (&scratch_obstack) \ 91 && obstack_next_free (&scratch_obstack)[-1] == '>') \ 92 ? OB_PUTC2 (' ', '>') : OB_PUTC ('>')) 93 94# define NEXT_CODE(t) (TREE_CODE (TREE_TYPE (t))) 95 96enum pad { none, before, after }; 97 98static void dump_type PROTO((tree, int)); 99static void dump_type_real PROTO((tree, int, int)); 100static void dump_simple_decl PROTO((tree, tree, int)); 101static void dump_decl PROTO((tree, int)); 102static void dump_function_decl PROTO((tree, int)); 103static void dump_expr PROTO((tree, int)); 104static void dump_unary_op PROTO((char *, tree, int)); 105static void dump_binary_op PROTO((char *, tree)); 106static void dump_aggr_type PROTO((tree, int, int)); 107static void dump_type_prefix PROTO((tree, int, int)); 108static void dump_type_suffix PROTO((tree, int, int)); 109static void dump_function_name PROTO((tree)); 110static void dump_expr_list PROTO((tree)); 111static void dump_global_iord PROTO((tree)); 112static void dump_qualifiers PROTO((tree, enum pad)); 113static void dump_char PROTO((int)); 114static void dump_parameters PROTO((tree, int, int)); 115static void dump_exception_spec PROTO((tree, int)); 116static char *aggr_variety PROTO((tree)); 117static tree ident_fndecl PROTO((tree)); 118static int interesting_scope_p PROTO((tree)); 119 120void 121init_error () 122{ 123 gcc_obstack_init (&scratch_obstack); 124 scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0); 125} 126 127/* Returns nonzero if SCOPE is something we want to print for random decls. */ 128 129static int 130interesting_scope_p (scope) 131 tree scope; 132{ 133 if (scope == NULL_TREE 134 || scope == global_namespace) 135 return 0; 136 137 return (TREE_CODE (scope) == NAMESPACE_DECL 138 || AGGREGATE_TYPE_P (scope)); 139} 140 141static void 142dump_qualifiers (t, p) 143 tree t; 144 enum pad p; 145{ 146 if (TYPE_QUALS (t)) 147 { 148 if (p == before) OB_PUTC (' '); 149 switch (TYPE_QUALS (t)) 150 { 151 case TYPE_QUAL_CONST: 152 OB_PUTS ("const"); 153 break; 154 155 case TYPE_QUAL_VOLATILE: 156 OB_PUTS ("volatile"); 157 break; 158 159 case TYPE_QUAL_RESTRICT: 160 OB_PUTS ("__restrict"); 161 break; 162 163 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE: 164 OB_PUTS ("const volatile"); 165 break; 166 167 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT: 168 OB_PUTS ("const __restrict"); 169 break; 170 171 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT: 172 OB_PUTS ("volatile __restrict"); 173 break; 174 175 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT: 176 OB_PUTS ("const volatile __restrict"); 177 break; 178 179 default: 180 my_friendly_abort (0); 181 } 182 if (p == after) OB_PUTC (' '); 183 } 184} 185 186/* This must be large enough to hold any printed integer or floating-point 187 value. */ 188static char digit_buffer[128]; 189 190/* Dump into the obstack a human-readable equivalent of TYPE. */ 191 192static void 193dump_type_real (t, v, canonical_name) 194 tree t; 195 int v; /* verbose? */ 196 int canonical_name; 197{ 198 if (t == NULL_TREE) 199 return; 200 201 if (TYPE_PTRMEMFUNC_P (t)) 202 goto offset_type; 203 204 switch (TREE_CODE (t)) 205 { 206 case ERROR_MARK: 207 OB_PUTS ("{error}"); 208 break; 209 210 case UNKNOWN_TYPE: 211 OB_PUTS ("{unknown type}"); 212 break; 213 214 case TREE_LIST: 215 /* A list of function parms. */ 216 dump_parameters (t, 0, canonical_name); 217 break; 218 219 case IDENTIFIER_NODE: 220 OB_PUTID (t); 221 break; 222 223 case TREE_VEC: 224 dump_type_real (BINFO_TYPE (t), v, canonical_name); 225 break; 226 227 case RECORD_TYPE: 228 case UNION_TYPE: 229 case ENUMERAL_TYPE: 230 if (TYPE_LANG_SPECIFIC (t) 231 && (IS_SIGNATURE_POINTER (t) || IS_SIGNATURE_REFERENCE (t))) 232 { 233 dump_qualifiers (t, after); 234 dump_type_real (SIGNATURE_TYPE (t), v, canonical_name); 235 if (IS_SIGNATURE_POINTER (t)) 236 OB_PUTC ('*'); 237 else 238 OB_PUTC ('&'); 239 } 240 else 241 dump_aggr_type (t, v, canonical_name); 242 break; 243 244 case TYPE_DECL: 245 case TEMPLATE_DECL: 246 case NAMESPACE_DECL: 247 dump_decl (t, v); 248 break; 249 250 case COMPLEX_TYPE: 251 OB_PUTS ("complex "); 252 dump_type_real (TREE_TYPE (t), v, canonical_name); 253 break; 254 255 case INTEGER_TYPE: 256 if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t)) 257 OB_PUTS ("unsigned "); 258 else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t)) 259 OB_PUTS ("signed "); 260 261 /* fall through. */ 262 case REAL_TYPE: 263 case VOID_TYPE: 264 case BOOLEAN_TYPE: 265 { 266 tree type; 267 dump_qualifiers (t, after); 268 type = canonical_name ? TYPE_MAIN_VARIANT (t) : t; 269 if (TYPE_NAME (type) && TYPE_IDENTIFIER (type)) 270 OB_PUTID (TYPE_IDENTIFIER (type)); 271 else 272 /* Types like intQI_type_node and friends have no names. 273 These don't come up in user error messages, but it's nice 274 to be able to print them from the debugger. */ 275 OB_PUTS ("{anonymous}"); 276 } 277 break; 278 279 case TEMPLATE_TEMPLATE_PARM: 280 if (!TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) 281 { 282 /* For parameters inside template signature. */ 283 if (TYPE_IDENTIFIER (t)) 284 OB_PUTID (TYPE_IDENTIFIER (t)); 285 else 286 OB_PUTS ("{anonymous template template parm}"); 287 } 288 else 289 { 290 int i; 291 tree args = TYPE_TI_ARGS (t); 292 OB_PUTID (TYPE_IDENTIFIER (t)); 293 OB_PUTC ('<'); 294 for (i = 0; i < TREE_VEC_LENGTH (args); i++) 295 { 296 tree arg = TREE_VEC_ELT (args, i); 297 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 't' 298 || TREE_CODE (arg) == TEMPLATE_DECL) 299 dump_type_real (arg, 0, canonical_name); 300 else 301 dump_expr (arg, 0); 302 if (i < TREE_VEC_LENGTH (args)-1) 303 OB_PUTC2 (',', ' '); 304 } 305 OB_END_TEMPLATE_ID (); 306 } 307 break; 308 309 case TEMPLATE_TYPE_PARM: 310 dump_qualifiers (t, after); 311 if (TYPE_IDENTIFIER (t)) 312 OB_PUTID (TYPE_IDENTIFIER (t)); 313 else 314 OB_PUTS ("{anonymous template type parm}"); 315 break; 316 317 /* This is not always necessary for pointers and such, but doing this 318 reduces code size. */ 319 case ARRAY_TYPE: 320 case POINTER_TYPE: 321 case REFERENCE_TYPE: 322 case OFFSET_TYPE: 323 offset_type: 324 case FUNCTION_TYPE: 325 case METHOD_TYPE: 326 dump_type_prefix (t, v, canonical_name); 327 dump_type_suffix (t, v, canonical_name); 328 break; 329 330 case TYPENAME_TYPE: 331 OB_PUTS ("typename "); 332 dump_type_real (TYPE_CONTEXT (t), 0, canonical_name); 333 OB_PUTS ("::"); 334 dump_decl (TYPENAME_TYPE_FULLNAME (t), v); 335 break; 336 337 case TYPEOF_TYPE: 338 OB_PUTS ("__typeof ("); 339 dump_expr (TYPE_FIELDS (t), 1); 340 OB_PUTC (')'); 341 break; 342 343 default: 344 sorry ("`%s' not supported by dump_type", 345 tree_code_name[(int) TREE_CODE (t)]); 346 } 347} 348 349static char * 350aggr_variety (t) 351 tree t; 352{ 353 if (TREE_CODE (t) == ENUMERAL_TYPE) 354 return "enum"; 355 else if (TREE_CODE (t) == UNION_TYPE) 356 return "union"; 357 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 358 return "class"; 359 else if (TYPE_LANG_SPECIFIC (t) && IS_SIGNATURE (t)) 360 return "signature"; 361 else 362 return "struct"; 363} 364 365static void 366dump_type (t, v) 367 tree t; 368 int v; /* verbose? */ 369{ 370 dump_type_real (t, v, 0); 371} 372 373/* Print out a class declaration, in the form `class foo'. */ 374 375static void 376dump_aggr_type (t, v, canonical_name) 377 tree t; 378 int v; /* verbose? */ 379 int canonical_name; 380{ 381 tree name; 382 char *variety = aggr_variety (t); 383 384 dump_qualifiers (t, after); 385 386 if (v > 0) 387 { 388 OB_PUTCP (variety); 389 OB_PUTC (' '); 390 } 391 392 name = TYPE_NAME (canonical_name ? TYPE_MAIN_VARIANT (t) : t); 393 394 if (name && CP_DECL_CONTEXT (name) != global_namespace) 395 { 396 /* FUNCTION_DECL or RECORD_TYPE */ 397 dump_decl (DECL_CONTEXT (name), 0); 398 OB_PUTC2 (':', ':'); 399 } 400 401 /* kludge around weird behavior on g++.brendan/line1.C */ 402 if (name && TREE_CODE (name) != IDENTIFIER_NODE) 403 name = DECL_NAME (name); 404 405 if (name == 0 || ANON_AGGRNAME_P (name)) 406 { 407 OB_PUTS ("{anonymous"); 408 if (!v) 409 { 410 OB_PUTC (' '); 411 OB_PUTCP (variety); 412 } 413 OB_PUTC ('}'); 414 } 415 else 416 OB_PUTID (name); 417} 418 419/* Dump into the obstack the initial part of the output for a given type. 420 This is necessary when dealing with things like functions returning 421 functions. Examples: 422 423 return type of `int (* fee ())()': pointer -> function -> int. Both 424 pointer (and reference and offset) and function (and member) types must 425 deal with prefix and suffix. 426 427 Arrays must also do this for DECL nodes, like int a[], and for things like 428 int *[]&. */ 429 430static void 431dump_type_prefix (t, v, canonical_name) 432 tree t; 433 int v; /* verbosity */ 434 int canonical_name; 435{ 436 if (TYPE_PTRMEMFUNC_P (t)) 437 { 438 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 439 goto offset_type; 440 } 441 442 switch (TREE_CODE (t)) 443 { 444 case POINTER_TYPE: 445 case REFERENCE_TYPE: 446 { 447 tree sub = TREE_TYPE (t); 448 449 dump_type_prefix (sub, v, canonical_name); 450 /* A tree for a member pointer looks like pointer to offset, 451 so let the OFFSET_TYPE case handle it. */ 452 if (!TYPE_PTRMEM_P (t)) 453 { 454 switch (TREE_CODE (sub)) 455 { 456 /* We don't want int ( *)() */ 457 case FUNCTION_TYPE: 458 case METHOD_TYPE: 459 break; 460 461 case ARRAY_TYPE: 462 OB_PUTC2 (' ', '('); 463 break; 464 465 case POINTER_TYPE: 466 /* We don't want "char * *" */ 467 if (TYPE_QUALS (sub) == TYPE_UNQUALIFIED) 468 break; 469 /* But we do want "char *const *" */ 470 471 default: 472 OB_PUTC (' '); 473 } 474 if (TREE_CODE (t) == POINTER_TYPE) 475 OB_PUTC ('*'); 476 else 477 OB_PUTC ('&'); 478 dump_qualifiers (t, none); 479 } 480 } 481 break; 482 483 case OFFSET_TYPE: 484 offset_type: 485 dump_type_prefix (TREE_TYPE (t), v, canonical_name); 486 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */ 487 { 488 OB_PUTC (' '); 489 dump_type_real (TYPE_OFFSET_BASETYPE (t), 0, canonical_name); 490 OB_PUTC2 (':', ':'); 491 } 492 OB_PUTC ('*'); 493 dump_qualifiers (t, none); 494 break; 495 496 /* Can only be reached through function pointer -- this would not be 497 correct if FUNCTION_DECLs used it. */ 498 case FUNCTION_TYPE: 499 dump_type_prefix (TREE_TYPE (t), v, canonical_name); 500 OB_PUTC2 (' ', '('); 501 break; 502 503 case METHOD_TYPE: 504 dump_type_prefix (TREE_TYPE (t), v, canonical_name); 505 OB_PUTC2 (' ', '('); 506 dump_aggr_type (TYPE_METHOD_BASETYPE (t), 0, canonical_name); 507 OB_PUTC2 (':', ':'); 508 break; 509 510 case ARRAY_TYPE: 511 dump_type_prefix (TREE_TYPE (t), v, canonical_name); 512 break; 513 514 case ENUMERAL_TYPE: 515 case ERROR_MARK: 516 case IDENTIFIER_NODE: 517 case INTEGER_TYPE: 518 case BOOLEAN_TYPE: 519 case REAL_TYPE: 520 case RECORD_TYPE: 521 case TEMPLATE_TYPE_PARM: 522 case TEMPLATE_TEMPLATE_PARM: 523 case TREE_LIST: 524 case TYPE_DECL: 525 case TREE_VEC: 526 case UNION_TYPE: 527 case UNKNOWN_TYPE: 528 case VOID_TYPE: 529 case TYPENAME_TYPE: 530 case COMPLEX_TYPE: 531 dump_type_real (t, v, canonical_name); 532 break; 533 534 default: 535 sorry ("`%s' not supported by dump_type_prefix", 536 tree_code_name[(int) TREE_CODE (t)]); 537 } 538} 539 540static void 541dump_type_suffix (t, v, canonical_name) 542 tree t; 543 int v; /* verbose? */ 544 int canonical_name; 545{ 546 if (TYPE_PTRMEMFUNC_P (t)) 547 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 548 549 switch (TREE_CODE (t)) 550 { 551 case POINTER_TYPE: 552 case REFERENCE_TYPE: 553 case OFFSET_TYPE: 554 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 555 OB_PUTC (')'); 556 dump_type_suffix (TREE_TYPE (t), v, canonical_name); 557 break; 558 559 /* Can only be reached through function pointer */ 560 case FUNCTION_TYPE: 561 case METHOD_TYPE: 562 { 563 tree arg; 564 OB_PUTC (')'); 565 arg = TYPE_ARG_TYPES (t); 566 if (TREE_CODE (t) == METHOD_TYPE) 567 arg = TREE_CHAIN (arg); 568 569 /* Function pointers don't have default args. Not in standard C++, 570 anyway; they may in g++, but we'll just pretend otherwise. */ 571 dump_parameters (arg, 0, canonical_name); 572 573 if (TREE_CODE (t) == METHOD_TYPE) 574 dump_qualifiers 575 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before); 576 dump_type_suffix (TREE_TYPE (t), v, canonical_name); 577 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), canonical_name); 578 break; 579 } 580 581 case ARRAY_TYPE: 582 OB_PUTC ('['); 583 if (TYPE_DOMAIN (t)) 584 { 585 if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == INTEGER_CST) 586 OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1); 587 else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR) 588 dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), 0); 589 else 590 dump_expr (fold (build_binary_op 591 (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 592 integer_one_node)), 0); 593 } 594 OB_PUTC (']'); 595 dump_type_suffix (TREE_TYPE (t), v, canonical_name); 596 break; 597 598 case ENUMERAL_TYPE: 599 case ERROR_MARK: 600 case IDENTIFIER_NODE: 601 case INTEGER_TYPE: 602 case BOOLEAN_TYPE: 603 case REAL_TYPE: 604 case RECORD_TYPE: 605 case TEMPLATE_TYPE_PARM: 606 case TEMPLATE_TEMPLATE_PARM: 607 case TREE_LIST: 608 case TYPE_DECL: 609 case TREE_VEC: 610 case UNION_TYPE: 611 case UNKNOWN_TYPE: 612 case VOID_TYPE: 613 case TYPENAME_TYPE: 614 case COMPLEX_TYPE: 615 break; 616 617 default: 618 sorry ("`%s' not supported by dump_type_suffix", 619 tree_code_name[(int) TREE_CODE (t)]); 620 } 621} 622 623/* Return a function declaration which corresponds to the IDENTIFIER_NODE 624 argument. */ 625 626static tree 627ident_fndecl (t) 628 tree t; 629{ 630 tree n = lookup_name (t, 0); 631 632 if (n == NULL_TREE) 633 return NULL_TREE; 634 635 if (TREE_CODE (n) == FUNCTION_DECL) 636 return n; 637 else if (TREE_CODE (n) == TREE_LIST 638 && TREE_CODE (TREE_VALUE (n)) == FUNCTION_DECL) 639 return TREE_VALUE (n); 640 641 my_friendly_abort (66); 642 return NULL_TREE; 643} 644 645#ifndef NO_DOLLAR_IN_LABEL 646# define GLOBAL_THING "_GLOBAL_$" 647#else 648# ifndef NO_DOT_IN_LABEL 649# define GLOBAL_THING "_GLOBAL_." 650# else 651# define GLOBAL_THING "_GLOBAL__" 652# endif 653#endif 654 655#define GLOBAL_IORD_P(NODE) \ 656 ! strncmp (IDENTIFIER_POINTER(NODE), GLOBAL_THING, sizeof (GLOBAL_THING) - 1) 657 658static void 659dump_global_iord (t) 660 tree t; 661{ 662 char *name = IDENTIFIER_POINTER (t); 663 664 OB_PUTS ("(static "); 665 if (name [sizeof (GLOBAL_THING) - 1] == 'I') 666 OB_PUTS ("initializers"); 667 else if (name [sizeof (GLOBAL_THING) - 1] == 'D') 668 OB_PUTS ("destructors"); 669 else 670 my_friendly_abort (352); 671 672 OB_PUTS (" for "); 673 OB_PUTCP (input_filename); 674 OB_PUTC (')'); 675} 676 677static void 678dump_simple_decl (t, type, v) 679 tree t; 680 tree type; 681 int v; 682{ 683 if (v > 0) 684 { 685 dump_type_prefix (type, v, 0); 686 OB_PUTC (' '); 687 } 688 if (interesting_scope_p (DECL_CONTEXT (t))) 689 { 690 dump_decl (DECL_CONTEXT (t), 0); 691 OB_PUTC2 (':',':'); 692 } 693 if (DECL_NAME (t)) 694 dump_decl (DECL_NAME (t), v); 695 else 696 OB_PUTS ("{anon}"); 697 if (v > 0) 698 dump_type_suffix (type, v, 0); 699} 700 701static void 702dump_decl (t, v) 703 tree t; 704 int v; /* verbosity */ 705{ 706 if (t == NULL_TREE) 707 return; 708 709 switch (TREE_CODE (t)) 710 { 711 case ERROR_MARK: 712 OB_PUTS (" /* decl error */ "); 713 break; 714 715 case TYPE_DECL: 716 { 717 /* Don't say 'typedef class A' */ 718 if (DECL_ARTIFICIAL (t)) 719 { 720 if (v > 0 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) 721 /* Say `class T' not just `T'. */ 722 OB_PUTS ("class "); 723 724 dump_type (TREE_TYPE (t), v); 725 break; 726 } 727 } 728 if (v > 0) 729 OB_PUTS ("typedef "); 730 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t) 731 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), v); 732 break; 733 734 case VAR_DECL: 735 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t))) 736 { 737 OB_PUTS ("vtable for "); 738 if (TYPE_P (DECL_CONTEXT (t))) 739 dump_type (DECL_CONTEXT (t), v); 740 else 741 /* This case can arise with -fno-vtable-thunks. See 742 expand_upcast_fixups. It's not clear what to print 743 here. */ 744 OB_PUTS ("{unknown type}"); 745 break; 746 } 747 /* else fall through */ 748 case FIELD_DECL: 749 case PARM_DECL: 750 dump_simple_decl (t, TREE_TYPE (t), v); 751 break; 752 753 case NAMESPACE_DECL: 754 if (CP_DECL_CONTEXT (t) != global_namespace) 755 { 756 dump_decl (DECL_CONTEXT (t), v); 757 OB_PUTC2 (':',':'); 758 } 759 if (DECL_NAME (t) == anonymous_namespace_name) 760 OB_PUTS ("{anonymous}"); 761 else 762 OB_PUTID (DECL_NAME (t)); 763 break; 764 765 case SCOPE_REF: 766 dump_decl (TREE_OPERAND (t, 0), 0); 767 OB_PUTS ("::"); 768 dump_decl (TREE_OPERAND (t, 1), 0); 769 break; 770 771 case ARRAY_REF: 772 dump_decl (TREE_OPERAND (t, 0), v); 773 OB_PUTC ('['); 774 dump_decl (TREE_OPERAND (t, 1), v); 775 OB_PUTC (']'); 776 break; 777 778 /* So that we can do dump_decl in dump_aggr_type and have it work for 779 both class and function scope. */ 780 case RECORD_TYPE: 781 case UNION_TYPE: 782 case ENUMERAL_TYPE: 783 dump_type (t, v); 784 break; 785 786 case TYPE_EXPR: 787 my_friendly_abort (69); 788 break; 789 790 /* These special cases are duplicated here so that other functions 791 can feed identifiers to cp_error and get them demangled properly. */ 792 case IDENTIFIER_NODE: 793 { tree f; 794 if (DESTRUCTOR_NAME_P (t) 795 && (f = ident_fndecl (t)) 796 && DECL_LANGUAGE (f) == lang_cplusplus) 797 { 798 OB_PUTC ('~'); 799 dump_decl (DECL_NAME (f), 0); 800 } 801 else if (IDENTIFIER_TYPENAME_P (t)) 802 { 803 OB_PUTS ("operator "); 804 /* Not exactly IDENTIFIER_TYPE_VALUE. */ 805 dump_type (TREE_TYPE (t), 0); 806 break; 807 } 808 else if (IDENTIFIER_OPNAME_P (t)) 809 { 810 char *name_string = operator_name_string (t); 811 OB_PUTS ("operator "); 812 OB_PUTCP (name_string); 813 } 814 else 815 OB_PUTID (t); 816 } 817 break; 818 819 case OVERLOAD: 820 t = OVL_CURRENT (t); 821 /* Fall through. */ 822 823 case FUNCTION_DECL: 824 if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t))) 825 dump_global_iord (DECL_ASSEMBLER_NAME (t)); 826 else if (! DECL_LANG_SPECIFIC (t)) 827 OB_PUTS ("{internal}"); 828 else 829 dump_function_decl (t, v); 830 break; 831 832 case TEMPLATE_DECL: 833 { 834 tree orig_args = DECL_TEMPLATE_PARMS (t); 835 tree args; 836 int i; 837 for (args = orig_args = nreverse (orig_args); 838 args; 839 args = TREE_CHAIN (args)) 840 { 841 int len = TREE_VEC_LENGTH (TREE_VALUE (args)); 842 843 OB_PUTS ("template <"); 844 for (i = 0; i < len; i++) 845 { 846 tree arg = TREE_VEC_ELT (TREE_VALUE (args), i); 847 tree defval = TREE_PURPOSE (arg); 848 arg = TREE_VALUE (arg); 849 if (TREE_CODE (arg) == TYPE_DECL) 850 { 851 if (DECL_NAME (arg)) 852 { 853 OB_PUTS ("class "); 854 OB_PUTID (DECL_NAME (arg)); 855 } 856 else 857 OB_PUTS ("class"); 858 } 859 else 860 dump_decl (arg, 1); 861 862 if (defval) 863 { 864 OB_PUTS (" = "); 865 if (TREE_CODE (arg) == TYPE_DECL 866 || TREE_CODE (arg) == TEMPLATE_DECL) 867 dump_type (defval, 1); 868 else 869 dump_expr (defval, 1); 870 } 871 872 OB_PUTC2 (',', ' '); 873 } 874 if (len != 0) 875 OB_UNPUT (2); 876 OB_END_TEMPLATE_ID (); 877 OB_PUTC (' '); 878 } 879 nreverse(orig_args); 880 881 if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL) 882 dump_type (TREE_TYPE (t), v); 883 else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL) 884 dump_decl (DECL_TEMPLATE_RESULT (t), v); 885 else if (TREE_TYPE (t) == NULL_TREE) 886 my_friendly_abort (353); 887 else switch (NEXT_CODE (t)) 888 { 889 case METHOD_TYPE: 890 case FUNCTION_TYPE: 891 dump_function_decl (t, v); 892 break; 893 894 default: 895 /* This case can occur with some illegal code. */ 896 dump_type (TREE_TYPE (t), v); 897 } 898 } 899 break; 900 901 case TEMPLATE_ID_EXPR: 902 { 903 tree args; 904 tree name = TREE_OPERAND (t, 0); 905 if (is_overloaded_fn (name)) 906 name = DECL_NAME (get_first_fn (name)); 907 dump_decl (name, v); 908 OB_PUTC ('<'); 909 for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args)) 910 { 911 if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (args))) == 't' 912 || TREE_CODE (TREE_VALUE (args)) == TEMPLATE_DECL) 913 dump_type (TREE_VALUE (args), 0); 914 else 915 dump_expr (TREE_VALUE (args), 0); 916 if (TREE_CHAIN (args)) 917 OB_PUTC2 (',', ' '); 918 } 919 OB_END_TEMPLATE_ID (); 920 } 921 break; 922 923 case LOOKUP_EXPR: 924 dump_decl (TREE_OPERAND (t, 0), v); 925 break; 926 927 case LABEL_DECL: 928 OB_PUTID (DECL_NAME (t)); 929 break; 930 931 case CONST_DECL: 932 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE) 933 || (DECL_INITIAL (t) && 934 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX)) 935 dump_simple_decl (t, TREE_TYPE (t), v); 936 else if (DECL_NAME (t)) 937 dump_decl (DECL_NAME (t), v); 938 else if (DECL_INITIAL (t)) 939 dump_expr (DECL_INITIAL (t), 0); 940 else 941 OB_PUTS ("enumerator"); 942 break; 943 944 case USING_DECL: 945 OB_PUTS ("using "); 946 dump_type (DECL_INITIAL (t), 0); 947 OB_PUTS ("::"); 948 OB_PUTID (DECL_NAME (t)); 949 break; 950 951 default: 952 sorry ("`%s' not supported by dump_decl", 953 tree_code_name[(int) TREE_CODE (t)]); 954 } 955} 956 957/* Pretty print a function decl. There are several ways we want to print a 958 function declaration. We use V to tell us what. 959 V - 01 23 960 args - ++ ++ 961 retval - -+ ++ 962 default- -+ -+ 963 throw - -- ++ 964 As cp_error can only apply the '#' flag once to give 0 and 1 for V, there 965 is %D which doesn't print the throw specs, and %F which does. */ 966 967static void 968dump_function_decl (t, v) 969 tree t; 970 int v; 971{ 972 tree name; 973 tree fntype; 974 tree parmtypes; 975 tree cname = NULL_TREE; 976 977 if (TREE_CODE (t) == TEMPLATE_DECL) 978 t = DECL_TEMPLATE_RESULT (t); 979 980 name = DECL_ASSEMBLER_NAME (t); 981 fntype = TREE_TYPE (t); 982 parmtypes = TYPE_ARG_TYPES (fntype); 983 984 /* Friends have DECL_CLASS_CONTEXT set, but not DECL_CONTEXT. */ 985 if (DECL_CLASS_SCOPE_P (t)) 986 cname = DECL_CLASS_CONTEXT (t); 987 /* this is for partially instantiated template methods */ 988 else if (TREE_CODE (fntype) == METHOD_TYPE) 989 cname = TREE_TYPE (TREE_VALUE (parmtypes)); 990 991 /* Print the return type. */ 992 if (v > 0) 993 { 994 if (DECL_STATIC_FUNCTION_P (t)) 995 OB_PUTS ("static "); 996 997 if (! DECL_CONV_FN_P (t) 998 && ! DECL_CONSTRUCTOR_P (t) 999 && ! DECL_DESTRUCTOR_P (t)) 1000 { 1001 dump_type_prefix (TREE_TYPE (fntype), 1, 0); 1002 OB_PUTC (' '); 1003 } 1004 } 1005 1006 /* Print the function name. */ 1007 if (cname) 1008 { 1009 dump_type (cname, 0); 1010 OB_PUTC2 (':', ':'); 1011 if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes) 1012 parmtypes = TREE_CHAIN (parmtypes); 1013 if (DECL_CONSTRUCTOR_FOR_VBASE_P (t)) 1014 /* Skip past "in_charge" identifier. */ 1015 parmtypes = TREE_CHAIN (parmtypes); 1016 } 1017 else if (CP_DECL_CONTEXT (t) != global_namespace) 1018 { 1019 dump_decl (DECL_CONTEXT (t), 0); 1020 OB_PUTC2 (':',':'); 1021 } 1022 1023 if (DESTRUCTOR_NAME_P (name) && DECL_LANGUAGE (t) == lang_cplusplus) 1024 parmtypes = TREE_CHAIN (parmtypes); 1025 1026 dump_function_name (t); 1027 1028 /* If V is negative, we don't print the argument types. */ 1029 if (v < 0) 1030 return; 1031 1032 dump_parameters (parmtypes, v & 1, 0); 1033 1034 if (v && ! DECL_CONV_FN_P (t)) 1035 dump_type_suffix (TREE_TYPE (fntype), 1, 0); 1036 1037 if (TREE_CODE (fntype) == METHOD_TYPE) 1038 { 1039 if (IS_SIGNATURE (cname)) 1040 /* We look at the type pointed to by the `optr' field of `this.' */ 1041 dump_qualifiers 1042 (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (TYPE_ARG_TYPES (fntype))))), before); 1043 else 1044 dump_qualifiers 1045 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), before); 1046 } 1047 1048 if (v >= 2) 1049 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), 0); 1050} 1051 1052/* Print a parameter list. V indicates if we show default values or not. If 1053 these are for a member function, the member object ptr 1054 (and any other hidden args) should have already been removed. */ 1055 1056static void 1057dump_parameters (parmtypes, v, canonical_name) 1058 tree parmtypes; 1059 int v; 1060 int canonical_name; 1061{ 1062 int first; 1063 OB_PUTC ('('); 1064 1065 for (first = 1; parmtypes != void_list_node; 1066 parmtypes = TREE_CHAIN (parmtypes)) 1067 { 1068 if (!first) 1069 OB_PUTC2 (',', ' '); 1070 first = 0; 1071 if (!parmtypes) 1072 { 1073 OB_PUTS ("..."); 1074 break; 1075 } 1076 dump_type_real (TREE_VALUE (parmtypes), 0, canonical_name); 1077 1078 if (TREE_PURPOSE (parmtypes) && v) 1079 { 1080 OB_PUTS (" = "); 1081 dump_expr (TREE_PURPOSE (parmtypes), 0); 1082 } 1083 } 1084 1085 OB_PUTC (')'); 1086} 1087 1088/* Print an exception specification. T is the exception specification. */ 1089 1090static void 1091dump_exception_spec (t, canonical_name) 1092 tree t; 1093 int canonical_name; 1094{ 1095 if (t) 1096 { 1097 OB_PUTS (" throw ("); 1098 if (TREE_VALUE (t) != NULL_TREE) 1099 while (1) 1100 { 1101 dump_type_real (TREE_VALUE (t), 0, canonical_name); 1102 t = TREE_CHAIN (t); 1103 if (!t) 1104 break; 1105 OB_PUTC2 (',', ' '); 1106 } 1107 OB_PUTC (')'); 1108 } 1109} 1110 1111/* Handle the function name for a FUNCTION_DECL node, grokking operators 1112 and destructors properly. */ 1113 1114static void 1115dump_function_name (t) 1116 tree t; 1117{ 1118 tree name = DECL_NAME (t); 1119 1120 if (DECL_DESTRUCTOR_P (t)) 1121 { 1122 OB_PUTC ('~'); 1123 dump_decl (name, 0); 1124 } 1125 else if (DECL_CONV_FN_P (t)) 1126 { 1127 /* This cannot use the hack that the operator's return 1128 type is stashed off of its name because it may be 1129 used for error reporting. In the case of conflicting 1130 declarations, both will have the same name, yet 1131 the types will be different, hence the TREE_TYPE field 1132 of the first name will be clobbered by the second. */ 1133 OB_PUTS ("operator "); 1134 dump_type (TREE_TYPE (TREE_TYPE (t)), 0); 1135 } 1136 else if (IDENTIFIER_OPNAME_P (name)) 1137 { 1138 char *name_string = operator_name_string (name); 1139 OB_PUTS ("operator "); 1140 OB_PUTCP (name_string); 1141 } 1142 else 1143 dump_decl (name, 0); 1144 1145 if (DECL_LANG_SPECIFIC (t) && DECL_USE_TEMPLATE (t) 1146 && DECL_TEMPLATE_INFO (t) 1147 && (DECL_TEMPLATE_SPECIALIZATION (t) 1148 || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL 1149 || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t)) 1150 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))) 1151 { 1152 tree args = DECL_TEMPLATE_INFO (t) ? DECL_TI_ARGS (t) : NULL_TREE; 1153 OB_PUTC ('<'); 1154 1155 /* Be careful only to print things when we have them, so as not 1156 to crash producing error messages. */ 1157 if (args) 1158 { 1159 if (TREE_CODE (args) == TREE_LIST) 1160 { 1161 tree arg; 1162 int need_comma = 0; 1163 1164 for (arg = args; arg; arg = TREE_CHAIN (arg)) 1165 { 1166 tree a = TREE_VALUE (arg); 1167 1168 if (need_comma) 1169 OB_PUTS (", "); 1170 1171 if (a) 1172 { 1173 if (TREE_CODE_CLASS (TREE_CODE (a)) == 't' 1174 || TREE_CODE (a) == TEMPLATE_DECL) 1175 dump_type (a, 0); 1176 else 1177 dump_expr (a, 0); 1178 } 1179 1180 need_comma = 1; 1181 } 1182 } 1183 else if (TREE_CODE (args) == TREE_VEC) 1184 { 1185 int i; 1186 int need_comma = 0; 1187 1188 if (TREE_VEC_LENGTH (args) > 0 1189 && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC) 1190 args = TREE_VEC_ELT (args, 1191 TREE_VEC_LENGTH (args) - 1); 1192 1193 for (i = 0; i < TREE_VEC_LENGTH (args); i++) 1194 { 1195 tree a = TREE_VEC_ELT (args, i); 1196 1197 if (need_comma) 1198 OB_PUTS (", "); 1199 1200 if (a) 1201 { 1202 if (TREE_CODE_CLASS (TREE_CODE (a)) == 't' 1203 || TREE_CODE (a) == TEMPLATE_DECL) 1204 dump_type (a, 0); 1205 else 1206 dump_expr (a, 0); 1207 } 1208 1209 need_comma = 1; 1210 } 1211 } 1212 } 1213 OB_END_TEMPLATE_ID (); 1214 } 1215} 1216 1217static void 1218dump_char (c) 1219 int c; 1220{ 1221 switch (c) 1222 { 1223 case TARGET_NEWLINE: 1224 OB_PUTS ("\\n"); 1225 break; 1226 case TARGET_TAB: 1227 OB_PUTS ("\\t"); 1228 break; 1229 case TARGET_VT: 1230 OB_PUTS ("\\v"); 1231 break; 1232 case TARGET_BS: 1233 OB_PUTS ("\\b"); 1234 break; 1235 case TARGET_CR: 1236 OB_PUTS ("\\r"); 1237 break; 1238 case TARGET_FF: 1239 OB_PUTS ("\\f"); 1240 break; 1241 case TARGET_BELL: 1242 OB_PUTS ("\\a"); 1243 break; 1244 case '\\': 1245 OB_PUTS ("\\\\"); 1246 break; 1247 case '\'': 1248 OB_PUTS ("\\'"); 1249 break; 1250 case '\"': 1251 OB_PUTS ("\\\""); 1252 break; 1253 default: 1254 if (ISPRINT (c)) 1255 OB_PUTC (c); 1256 else 1257 { 1258 sprintf (digit_buffer, "\\%03o", (int) c); 1259 OB_PUTCP (digit_buffer); 1260 } 1261 } 1262} 1263 1264/* Print out a list of initializers (subr of dump_expr) */ 1265 1266static void 1267dump_expr_list (l) 1268 tree l; 1269{ 1270 while (l) 1271 { 1272 dump_expr (TREE_VALUE (l), 0); 1273 if (TREE_CHAIN (l)) 1274 OB_PUTC2 (',', ' '); 1275 l = TREE_CHAIN (l); 1276 } 1277} 1278 1279/* Print out an expression */ 1280 1281static void 1282dump_expr (t, nop) 1283 tree t; 1284 int nop; /* suppress parens */ 1285{ 1286 switch (TREE_CODE (t)) 1287 { 1288 case VAR_DECL: 1289 case PARM_DECL: 1290 case FIELD_DECL: 1291 case CONST_DECL: 1292 case FUNCTION_DECL: 1293 case TEMPLATE_DECL: 1294 case NAMESPACE_DECL: 1295 dump_decl (t, -1); 1296 break; 1297 1298 case INTEGER_CST: 1299 { 1300 tree type = TREE_TYPE (t); 1301 my_friendly_assert (type != 0, 81); 1302 1303 /* If it's an enum, output its tag, rather than its value. */ 1304 if (TREE_CODE (type) == ENUMERAL_TYPE) 1305 { 1306 char *p = enum_name_string (t, type); 1307 OB_PUTCP (p); 1308 } 1309 else if (type == boolean_type_node) 1310 { 1311 if (t == boolean_false_node 1312 || (TREE_INT_CST_LOW (t) == 0 1313 && TREE_INT_CST_HIGH (t) == 0)) 1314 OB_PUTS ("false"); 1315 else if (t == boolean_true_node) 1316 OB_PUTS ("true"); 1317 } 1318 else if (type == char_type_node) 1319 { 1320 OB_PUTC ('\''); 1321 dump_char (TREE_INT_CST_LOW (t)); 1322 OB_PUTC ('\''); 1323 } 1324 else if (TREE_INT_CST_HIGH (t) 1325 != (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1))) 1326 { 1327 tree val = t; 1328 if (TREE_INT_CST_HIGH (val) < 0) 1329 { 1330 OB_PUTC ('-'); 1331 val = build_int_2 (~TREE_INT_CST_LOW (val), 1332 -TREE_INT_CST_HIGH (val)); 1333 } 1334 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all 1335 systems? */ 1336 { 1337 static char format[10]; /* "%x%09999x\0" */ 1338 if (!format[0]) 1339 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4); 1340 sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val), 1341 TREE_INT_CST_LOW (val)); 1342 OB_PUTCP (digit_buffer); 1343 } 1344 } 1345 else 1346 OB_PUTI (TREE_INT_CST_LOW (t)); 1347 } 1348 break; 1349 1350 case REAL_CST: 1351#ifndef REAL_IS_NOT_DOUBLE 1352 sprintf (digit_buffer, "%g", TREE_REAL_CST (t)); 1353#else 1354 { 1355 unsigned char *p = (unsigned char *) &TREE_REAL_CST (t); 1356 size_t i; 1357 strcpy (digit_buffer, "0x"); 1358 for (i = 0; i < sizeof TREE_REAL_CST (t); i++) 1359 sprintf (digit_buffer + 2 + 2*i, "%02x", *p++); 1360 } 1361#endif 1362 OB_PUTCP (digit_buffer); 1363 break; 1364 1365 case PTRMEM_CST: 1366 OB_PUTC ('&'); 1367 dump_type (PTRMEM_CST_CLASS (t), 0); 1368 OB_PUTS ("::"); 1369 OB_PUTID (DECL_NAME (PTRMEM_CST_MEMBER (t))); 1370 break; 1371 1372 case STRING_CST: 1373 { 1374 char *p = TREE_STRING_POINTER (t); 1375 int len = TREE_STRING_LENGTH (t) - 1; 1376 int i; 1377 1378 OB_PUTC ('\"'); 1379 for (i = 0; i < len; i++) 1380 dump_char (p[i]); 1381 OB_PUTC ('\"'); 1382 } 1383 break; 1384 1385 case COMPOUND_EXPR: 1386 dump_binary_op (",", t); 1387 break; 1388 1389 case COND_EXPR: 1390 OB_PUTC ('('); 1391 dump_expr (TREE_OPERAND (t, 0), 0); 1392 OB_PUTS (" ? "); 1393 dump_expr (TREE_OPERAND (t, 1), 0); 1394 OB_PUTS (" : "); 1395 dump_expr (TREE_OPERAND (t, 2), 0); 1396 OB_PUTC (')'); 1397 break; 1398 1399 case SAVE_EXPR: 1400 if (TREE_HAS_CONSTRUCTOR (t)) 1401 { 1402 OB_PUTS ("new "); 1403 dump_type (TREE_TYPE (TREE_TYPE (t)), 0); 1404 } 1405 else 1406 { 1407 dump_expr (TREE_OPERAND (t, 0), 0); 1408 } 1409 break; 1410 1411 case AGGR_INIT_EXPR: 1412 OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t))); 1413 OB_PUTC ('('); 1414 if (TREE_OPERAND (t, 1)) 1415 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1))); 1416 OB_PUTC (')'); 1417 break; 1418 1419 case CALL_EXPR: 1420 { 1421 tree fn = TREE_OPERAND (t, 0); 1422 tree args = TREE_OPERAND (t, 1); 1423 1424 if (TREE_CODE (fn) == ADDR_EXPR) 1425 fn = TREE_OPERAND (fn, 0); 1426 1427 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE) 1428 { 1429 tree ob = TREE_VALUE (args); 1430 if (TREE_CODE (ob) == ADDR_EXPR) 1431 { 1432 dump_expr (TREE_OPERAND (ob, 0), 0); 1433 OB_PUTC ('.'); 1434 } 1435 else if (TREE_CODE (ob) != PARM_DECL 1436 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1437 { 1438 dump_expr (ob, 0); 1439 OB_PUTC2 ('-', '>'); 1440 } 1441 args = TREE_CHAIN (args); 1442 } 1443 dump_expr (fn, 0); 1444 OB_PUTC ('('); 1445 dump_expr_list (args); 1446 OB_PUTC (')'); 1447 } 1448 break; 1449 1450 case NEW_EXPR: 1451 { 1452 tree type = TREE_OPERAND (t, 1); 1453 if (NEW_EXPR_USE_GLOBAL (t)) 1454 OB_PUTS ("::"); 1455 OB_PUTS ("new "); 1456 if (TREE_OPERAND (t, 0)) 1457 { 1458 OB_PUTC ('('); 1459 dump_expr_list (TREE_OPERAND (t, 0)); 1460 OB_PUTS (") "); 1461 } 1462 if (TREE_CODE (type) == ARRAY_REF) 1463 type = build_cplus_array_type 1464 (TREE_OPERAND (type, 0), 1465 build_index_type (size_binop (MINUS_EXPR, TREE_OPERAND (type, 1), 1466 integer_one_node))); 1467 dump_type (type, 0); 1468 if (TREE_OPERAND (t, 2)) 1469 { 1470 OB_PUTC ('('); 1471 dump_expr_list (TREE_OPERAND (t, 2)); 1472 OB_PUTC (')'); 1473 } 1474 } 1475 break; 1476 1477 case TARGET_EXPR: 1478 /* Note that this only works for G++ target exprs. If somebody 1479 builds a general TARGET_EXPR, there's no way to represent that 1480 it initializes anything other that the parameter slot for the 1481 default argument. Note we may have cleared out the first 1482 operand in expand_expr, so don't go killing ourselves. */ 1483 if (TREE_OPERAND (t, 1)) 1484 dump_expr (TREE_OPERAND (t, 1), 0); 1485 break; 1486 1487 case MODIFY_EXPR: 1488 case PLUS_EXPR: 1489 case MINUS_EXPR: 1490 case MULT_EXPR: 1491 case TRUNC_DIV_EXPR: 1492 case TRUNC_MOD_EXPR: 1493 case MIN_EXPR: 1494 case MAX_EXPR: 1495 case LSHIFT_EXPR: 1496 case RSHIFT_EXPR: 1497 case BIT_IOR_EXPR: 1498 case BIT_XOR_EXPR: 1499 case BIT_AND_EXPR: 1500 case BIT_ANDTC_EXPR: 1501 case TRUTH_ANDIF_EXPR: 1502 case TRUTH_ORIF_EXPR: 1503 case LT_EXPR: 1504 case LE_EXPR: 1505 case GT_EXPR: 1506 case GE_EXPR: 1507 case EQ_EXPR: 1508 case NE_EXPR: 1509 dump_binary_op (opname_tab[(int) TREE_CODE (t)], t); 1510 break; 1511 1512 case CEIL_DIV_EXPR: 1513 case FLOOR_DIV_EXPR: 1514 case ROUND_DIV_EXPR: 1515 dump_binary_op ("/", t); 1516 break; 1517 1518 case CEIL_MOD_EXPR: 1519 case FLOOR_MOD_EXPR: 1520 case ROUND_MOD_EXPR: 1521 dump_binary_op ("%", t); 1522 break; 1523 1524 case COMPONENT_REF: 1525 { 1526 tree ob = TREE_OPERAND (t, 0); 1527 if (TREE_CODE (ob) == INDIRECT_REF) 1528 { 1529 ob = TREE_OPERAND (ob, 0); 1530 if (TREE_CODE (ob) != PARM_DECL 1531 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")) 1532 { 1533 dump_expr (ob, 0); 1534 OB_PUTC2 ('-', '>'); 1535 } 1536 } 1537 else 1538 { 1539 dump_expr (ob, 0); 1540 OB_PUTC ('.'); 1541 } 1542 dump_expr (TREE_OPERAND (t, 1), 1); 1543 } 1544 break; 1545 1546 case ARRAY_REF: 1547 dump_expr (TREE_OPERAND (t, 0), 0); 1548 OB_PUTC ('['); 1549 dump_expr (TREE_OPERAND (t, 1), 0); 1550 OB_PUTC (']'); 1551 break; 1552 1553 case CONVERT_EXPR: 1554 dump_unary_op ("+", t, nop); 1555 break; 1556 1557 case ADDR_EXPR: 1558 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 1559 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST) 1560 dump_expr (TREE_OPERAND (t, 0), 0); 1561 else 1562 dump_unary_op ("&", t, nop); 1563 break; 1564 1565 case INDIRECT_REF: 1566 if (TREE_HAS_CONSTRUCTOR (t)) 1567 { 1568 t = TREE_OPERAND (t, 0); 1569 my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237); 1570 dump_expr (TREE_OPERAND (t, 0), 0); 1571 OB_PUTC ('('); 1572 dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1))); 1573 OB_PUTC (')'); 1574 } 1575 else 1576 { 1577 if (TREE_OPERAND (t,0) != NULL_TREE 1578 && TREE_TYPE (TREE_OPERAND (t, 0)) 1579 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE) 1580 dump_expr (TREE_OPERAND (t, 0), nop); 1581 else 1582 dump_unary_op ("*", t, nop); 1583 } 1584 break; 1585 1586 case NEGATE_EXPR: 1587 case BIT_NOT_EXPR: 1588 case TRUTH_NOT_EXPR: 1589 case PREDECREMENT_EXPR: 1590 case PREINCREMENT_EXPR: 1591 dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, nop); 1592 break; 1593 1594 case POSTDECREMENT_EXPR: 1595 case POSTINCREMENT_EXPR: 1596 OB_PUTC ('('); 1597 dump_expr (TREE_OPERAND (t, 0), 0); 1598 OB_PUTCP (opname_tab[(int)TREE_CODE (t)]); 1599 OB_PUTC (')'); 1600 break; 1601 1602 case NON_LVALUE_EXPR: 1603 /* FIXME: This is a KLUDGE workaround for a parsing problem. There 1604 should be another level of INDIRECT_REF so that I don't have to do 1605 this. */ 1606 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE) 1607 { 1608 tree next = TREE_TYPE (TREE_TYPE (t)); 1609 1610 while (TREE_CODE (next) == POINTER_TYPE) 1611 next = TREE_TYPE (next); 1612 1613 if (TREE_CODE (next) == FUNCTION_TYPE) 1614 { 1615 if (!nop) OB_PUTC ('('); 1616 OB_PUTC ('*'); 1617 dump_expr (TREE_OPERAND (t, 0), 1); 1618 if (!nop) OB_PUTC (')'); 1619 break; 1620 } 1621 /* else FALLTHRU */ 1622 } 1623 dump_expr (TREE_OPERAND (t, 0), 0); 1624 break; 1625 1626 case NOP_EXPR: 1627 dump_expr (TREE_OPERAND (t, 0), nop); 1628 break; 1629 1630 case CONSTRUCTOR: 1631 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 1632 { 1633 tree idx = build_component_ref (t, index_identifier, NULL_TREE, 0); 1634 1635 if (integer_all_onesp (idx)) 1636 { 1637 tree pfn = PFN_FROM_PTRMEMFUNC (t); 1638 dump_unary_op ("&", pfn, 0); 1639 break; 1640 } 1641 else if (TREE_CODE (idx) == INTEGER_CST 1642 && tree_int_cst_equal (idx, integer_zero_node)) 1643 { 1644 /* A NULL pointer-to-member constant. */ 1645 OB_PUTS ("(("); 1646 dump_type (TREE_TYPE (t), 0); 1647 OB_PUTS (") 0)"); 1648 break; 1649 } 1650 else if (TREE_CODE (idx) == INTEGER_CST 1651 && TREE_INT_CST_HIGH (idx) == 0) 1652 { 1653 tree virtuals; 1654 unsigned HOST_WIDE_INT n; 1655 1656 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t))); 1657 t = TYPE_METHOD_BASETYPE (t); 1658 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t))); 1659 1660 n = TREE_INT_CST_LOW (idx); 1661 1662 /* Map vtable index back one, to allow for the null pointer to 1663 member. */ 1664 --n; 1665 1666 while (n > 0 && virtuals) 1667 { 1668 --n; 1669 virtuals = TREE_CHAIN (virtuals); 1670 } 1671 if (virtuals) 1672 { 1673 dump_expr (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0); 1674 break; 1675 } 1676 } 1677 } 1678 OB_PUTC ('{'); 1679 dump_expr_list (CONSTRUCTOR_ELTS (t)); 1680 OB_PUTC ('}'); 1681 break; 1682 1683 case OFFSET_REF: 1684 { 1685 tree ob = TREE_OPERAND (t, 0); 1686 if (is_dummy_object (ob)) 1687 { 1688 t = TREE_OPERAND (t, 1); 1689 if (TREE_CODE (t) == FUNCTION_DECL) 1690 /* A::f */ 1691 dump_expr (t, 0); 1692 else if (BASELINK_P (t)) 1693 dump_expr (OVL_CURRENT (TREE_VALUE (t)), 0); 1694 else 1695 dump_decl (t, 0); 1696 } 1697 else 1698 { 1699 if (TREE_CODE (ob) == INDIRECT_REF) 1700 { 1701 dump_expr (TREE_OPERAND (ob, 0), 0); 1702 OB_PUTS (" ->* "); 1703 } 1704 else 1705 { 1706 dump_expr (ob, 0); 1707 OB_PUTS (" .* "); 1708 } 1709 dump_expr (TREE_OPERAND (t, 1), 0); 1710 } 1711 break; 1712 } 1713 1714 case TEMPLATE_PARM_INDEX: 1715 dump_decl (TEMPLATE_PARM_DECL (t), -1); 1716 break; 1717 1718 case IDENTIFIER_NODE: 1719 OB_PUTID (t); 1720 break; 1721 1722 case SCOPE_REF: 1723 dump_type (TREE_OPERAND (t, 0), 0); 1724 OB_PUTS ("::"); 1725 dump_expr (TREE_OPERAND (t, 1), 0); 1726 break; 1727 1728 case CAST_EXPR: 1729 if (TREE_OPERAND (t, 0) == NULL_TREE 1730 || TREE_CHAIN (TREE_OPERAND (t, 0))) 1731 { 1732 dump_type (TREE_TYPE (t), 0); 1733 OB_PUTC ('('); 1734 dump_expr_list (TREE_OPERAND (t, 0)); 1735 OB_PUTC (')'); 1736 } 1737 else 1738 { 1739 OB_PUTC ('('); 1740 dump_type (TREE_TYPE (t), 0); 1741 OB_PUTC (')'); 1742 OB_PUTC ('('); 1743 dump_expr_list (TREE_OPERAND (t, 0)); 1744 OB_PUTC (')'); 1745 } 1746 break; 1747 1748 case LOOKUP_EXPR: 1749 OB_PUTID (TREE_OPERAND (t, 0)); 1750 break; 1751 1752 case ARROW_EXPR: 1753 dump_expr (TREE_OPERAND (t, 0), nop); 1754 OB_PUTS ("->"); 1755 break; 1756 1757 case SIZEOF_EXPR: 1758 case ALIGNOF_EXPR: 1759 if (TREE_CODE (t) == SIZEOF_EXPR) 1760 OB_PUTS ("sizeof ("); 1761 else 1762 { 1763 my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0); 1764 OB_PUTS ("__alignof__ ("); 1765 } 1766 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't') 1767 dump_type (TREE_OPERAND (t, 0), 0); 1768 else 1769 dump_unary_op ("*", t, 0); 1770 OB_PUTC (')'); 1771 break; 1772 1773 case DEFAULT_ARG: 1774 OB_PUTS ("{unparsed}"); 1775 break; 1776 1777 case TRY_CATCH_EXPR: 1778 case WITH_CLEANUP_EXPR: 1779 case CLEANUP_POINT_EXPR: 1780 dump_expr (TREE_OPERAND (t, 0), nop); 1781 break; 1782 1783 case TEMPLATE_ID_EXPR: 1784 dump_decl (t, 0); 1785 break; 1786 1787 case TREE_LIST: 1788 if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL) 1789 { 1790 OB_PUTID (DECL_NAME (TREE_VALUE (t))); 1791 break; 1792 } 1793 /* else fall through */ 1794 1795 /* This list is incomplete, but should suffice for now. 1796 It is very important that `sorry' does not call 1797 `report_error_function'. That could cause an infinite loop. */ 1798 default: 1799 sorry ("`%s' not supported by dump_expr", 1800 tree_code_name[(int) TREE_CODE (t)]); 1801 1802 /* fall through to ERROR_MARK... */ 1803 case ERROR_MARK: 1804 OB_PUTCP ("{error}"); 1805 break; 1806 } 1807} 1808 1809static void 1810dump_binary_op (opstring, t) 1811 char *opstring; 1812 tree t; 1813{ 1814 OB_PUTC ('('); 1815 dump_expr (TREE_OPERAND (t, 0), 1); 1816 OB_PUTC (' '); 1817 OB_PUTCP (opstring); 1818 OB_PUTC (' '); 1819 dump_expr (TREE_OPERAND (t, 1), 1); 1820 OB_PUTC (')'); 1821} 1822 1823static void 1824dump_unary_op (opstring, t, nop) 1825 char *opstring; 1826 tree t; 1827 int nop; 1828{ 1829 if (!nop) OB_PUTC ('('); 1830 OB_PUTCP (opstring); 1831 dump_expr (TREE_OPERAND (t, 0), 1); 1832 if (!nop) OB_PUTC (')'); 1833} 1834 1835/* Print a function decl with exception specification included. */ 1836 1837char * 1838fndecl_as_string (fndecl, print_default_args_p) 1839 tree fndecl; 1840 int print_default_args_p; 1841{ 1842 OB_INIT (); 1843 1844 dump_function_decl (fndecl, 2 + print_default_args_p); 1845 1846 OB_FINISH (); 1847 1848 return (char *)obstack_base (&scratch_obstack); 1849} 1850 1851/* Same, but handle a _TYPE. 1852 Called from convert_to_reference, mangle_class_name_for_template, 1853 build_unary_op, and GNU_xref_decl. If CANONICAL_NAME is non-zero, 1854 when describing a typedef, we use the name of the type described, 1855 rather than the name of the typedef. */ 1856 1857char * 1858type_as_string_real (typ, v, canonical_name) 1859 tree typ; 1860 int v; 1861 int canonical_name; 1862{ 1863 OB_INIT (); 1864 1865 dump_type_real (typ, v, canonical_name); 1866 1867 OB_FINISH (); 1868 1869 return (char *)obstack_base (&scratch_obstack); 1870} 1871 1872 1873char * 1874type_as_string (typ, v) 1875 tree typ; 1876 int v; 1877{ 1878 return type_as_string_real (typ, v, 0); 1879} 1880 1881char * 1882expr_as_string (decl, v) 1883 tree decl; 1884 int v ATTRIBUTE_UNUSED; 1885{ 1886 OB_INIT (); 1887 1888 dump_expr (decl, 1); 1889 1890 OB_FINISH (); 1891 1892 return (char *)obstack_base (&scratch_obstack); 1893} 1894 1895/* A cross between type_as_string and fndecl_as_string. 1896 Only called from substitute_nice_name. */ 1897 1898char * 1899decl_as_string (decl, v) 1900 tree decl; 1901 int v; 1902{ 1903 OB_INIT (); 1904 1905 dump_decl (decl, v); 1906 1907 OB_FINISH (); 1908 1909 return (char *)obstack_base (&scratch_obstack); 1910} 1911 1912/* Generate the three forms of printable names for lang_printable_name. */ 1913 1914char * 1915lang_decl_name (decl, v) 1916 tree decl; 1917 int v; 1918{ 1919 if (v >= 2) 1920 return decl_as_string (decl, 1); 1921 1922 OB_INIT (); 1923 1924 if (v == 1 && DECL_CLASS_SCOPE_P (decl)) 1925 { 1926 tree cname; 1927 if (TREE_CODE (decl) == FUNCTION_DECL) 1928 cname = DECL_CLASS_CONTEXT (decl); 1929 else 1930 cname = DECL_CONTEXT (decl); 1931 dump_type (cname, 0); 1932 OB_PUTC2 (':', ':'); 1933 } 1934 1935 if (TREE_CODE (decl) == FUNCTION_DECL) 1936 dump_function_name (decl); 1937 else 1938 dump_decl (DECL_NAME (decl), 0); 1939 1940 OB_FINISH (); 1941 1942 return (char *)obstack_base (&scratch_obstack); 1943} 1944 1945 1946char * 1947cp_file_of (t) 1948 tree t; 1949{ 1950 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 1951 return DECL_SOURCE_FILE (DECL_CONTEXT (t)); 1952 else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 1953 return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t)); 1954 else if (TREE_CODE (t) == OVERLOAD) 1955 return DECL_SOURCE_FILE (OVL_FUNCTION (t)); 1956 else 1957 return DECL_SOURCE_FILE (t); 1958} 1959 1960int 1961cp_line_of (t) 1962 tree t; 1963{ 1964 int line = 0; 1965 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t)) 1966 line = DECL_SOURCE_LINE (DECL_CONTEXT (t)); 1967 if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t) 1968 && TYPE_MAIN_DECL (TREE_TYPE (t))) 1969 t = TREE_TYPE (t); 1970 1971 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 1972 line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t)); 1973 else if (TREE_CODE (t) == OVERLOAD) 1974 line = DECL_SOURCE_LINE (OVL_FUNCTION (t)); 1975 else 1976 line = DECL_SOURCE_LINE (t); 1977 1978 if (line == 0) 1979 return lineno; 1980 1981 return line; 1982} 1983 1984char * 1985code_as_string (c, v) 1986 enum tree_code c; 1987 int v ATTRIBUTE_UNUSED; 1988{ 1989 return tree_code_name [c]; 1990} 1991 1992char * 1993language_as_string (c, v) 1994 enum languages c; 1995 int v ATTRIBUTE_UNUSED; 1996{ 1997 switch (c) 1998 { 1999 case lang_c: 2000 return "C"; 2001 2002 case lang_cplusplus: 2003 return "C++"; 2004 2005 case lang_java: 2006 return "Java"; 2007 2008 default: 2009 my_friendly_abort (355); 2010 return 0; 2011 } 2012} 2013 2014/* Return the proper printed version of a parameter to a C++ function. */ 2015 2016char * 2017parm_as_string (p, v) 2018 int p; 2019 int v ATTRIBUTE_UNUSED; 2020{ 2021 if (p < 0) 2022 return "`this'"; 2023 2024 sprintf (digit_buffer, "%d", p+1); 2025 return digit_buffer; 2026} 2027 2028char * 2029op_as_string (p, v) 2030 enum tree_code p; 2031 int v ATTRIBUTE_UNUSED; 2032{ 2033 static char buf[] = "operator "; 2034 2035 if (p == 0) 2036 return "{unknown}"; 2037 2038 strcpy (buf + 9, opname_tab [p]); 2039 return buf; 2040} 2041 2042char * 2043assop_as_string (p, v) 2044 enum tree_code p; 2045 int v ATTRIBUTE_UNUSED; 2046{ 2047 static char buf[] = "operator "; 2048 2049 if (p == 0) 2050 return "{unknown}"; 2051 2052 strcpy (buf + 9, assignop_tab [p]); 2053 return buf; 2054} 2055 2056char * 2057args_as_string (p, v) 2058 tree p; 2059 int v; 2060{ 2061 if (p == NULL_TREE) 2062 return ""; 2063 2064 if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (p))) == 't') 2065 return type_as_string (p, v); 2066 2067 OB_INIT (); 2068 for (; p; p = TREE_CHAIN (p)) 2069 { 2070 if (TREE_VALUE (p) == null_node) 2071 OB_PUTS ("NULL"); 2072 else 2073 dump_type (error_type (TREE_VALUE (p)), v); 2074 if (TREE_CHAIN (p)) 2075 OB_PUTS (", "); 2076 } 2077 OB_FINISH (); 2078 return (char *)obstack_base (&scratch_obstack); 2079} 2080 2081char * 2082cv_as_string (p, v) 2083 tree p; 2084 int v ATTRIBUTE_UNUSED; 2085{ 2086 OB_INIT (); 2087 2088 dump_qualifiers (p, before); 2089 2090 OB_FINISH (); 2091 2092 return (char *)obstack_base (&scratch_obstack); 2093} 2094