typeck2.c revision 169689
1/* Report error messages, build initializers, and perform 2 some front-end optimizations for C++ compiler. 3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2004, 2005, 2006 5 Free Software Foundation, Inc. 6 Hacked by Michael Tiemann (tiemann@cygnus.com) 7 8This file is part of GCC. 9 10GCC is free software; you can redistribute it and/or modify 11it under the terms of the GNU General Public License as published by 12the Free Software Foundation; either version 2, or (at your option) 13any later version. 14 15GCC is distributed in the hope that it will be useful, 16but WITHOUT ANY WARRANTY; without even the implied warranty of 17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18GNU General Public License for more details. 19 20You should have received a copy of the GNU General Public License 21along with GCC; see the file COPYING. If not, write to 22the Free Software Foundation, 51 Franklin Street, Fifth Floor, 23Boston, MA 02110-1301, USA. */ 24 25 26/* This file is part of the C++ front end. 27 It contains routines to build C++ expressions given their operands, 28 including computing the types of the result, C and C++ specific error 29 checks, and some optimization. */ 30 31#include "config.h" 32#include "system.h" 33#include "coretypes.h" 34#include "tm.h" 35#include "tree.h" 36#include "cp-tree.h" 37#include "flags.h" 38#include "toplev.h" 39#include "output.h" 40#include "diagnostic.h" 41 42static tree 43process_init_constructor (tree type, tree init); 44 45 46/* Print an error message stemming from an attempt to use 47 BASETYPE as a base class for TYPE. */ 48 49tree 50error_not_base_type (tree basetype, tree type) 51{ 52 if (TREE_CODE (basetype) == FUNCTION_DECL) 53 basetype = DECL_CONTEXT (basetype); 54 error ("type %qT is not a base type for type %qT", basetype, type); 55 return error_mark_node; 56} 57 58tree 59binfo_or_else (tree base, tree type) 60{ 61 tree binfo = lookup_base (type, base, ba_unique, NULL); 62 63 if (binfo == error_mark_node) 64 return NULL_TREE; 65 else if (!binfo) 66 error_not_base_type (base, type); 67 return binfo; 68} 69 70/* According to ARM $7.1.6, "A `const' object may be initialized, but its 71 value may not be changed thereafter. Thus, we emit hard errors for these, 72 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For 73 example, conversions to references.) */ 74 75void 76readonly_error (tree arg, const char* string, int soft) 77{ 78 const char *fmt; 79 void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); 80 81 if (soft) 82 fn = pedwarn; 83 else 84 fn = error; 85 86 if (TREE_CODE (arg) == COMPONENT_REF) 87 { 88 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 89 fmt = "%s of data-member %qD in read-only structure"; 90 else 91 fmt = "%s of read-only data-member %qD"; 92 (*fn) (fmt, string, TREE_OPERAND (arg, 1)); 93 } 94 else if (TREE_CODE (arg) == VAR_DECL) 95 { 96 if (DECL_LANG_SPECIFIC (arg) 97 && DECL_IN_AGGR_P (arg) 98 && !TREE_STATIC (arg)) 99 fmt = "%s of constant field %qD"; 100 else 101 fmt = "%s of read-only variable %qD"; 102 (*fn) (fmt, string, arg); 103 } 104 else if (TREE_CODE (arg) == PARM_DECL) 105 (*fn) ("%s of read-only parameter %qD", string, arg); 106 else if (TREE_CODE (arg) == INDIRECT_REF 107 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE 108 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL 109 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) 110 (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0)); 111 else if (TREE_CODE (arg) == RESULT_DECL) 112 (*fn) ("%s of read-only named return value %qD", string, arg); 113 else if (TREE_CODE (arg) == FUNCTION_DECL) 114 (*fn) ("%s of function %qD", string, arg); 115 else 116 (*fn) ("%s of read-only location", string); 117} 118 119 120/* Structure that holds information about declarations whose type was 121 incomplete and we could not check whether it was abstract or not. */ 122 123struct pending_abstract_type GTY((chain_next ("%h.next"))) 124{ 125 /* Declaration which we are checking for abstractness. It is either 126 a DECL node, or an IDENTIFIER_NODE if we do not have a full 127 declaration available. */ 128 tree decl; 129 130 /* Type which will be checked for abstractness. */ 131 tree type; 132 133 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs, 134 because DECLs already carry locus information. */ 135 location_t locus; 136 137 /* Link to the next element in list. */ 138 struct pending_abstract_type* next; 139}; 140 141 142/* Compute the hash value of the node VAL. This function is used by the 143 hash table abstract_pending_vars. */ 144 145static hashval_t 146pat_calc_hash (const void* val) 147{ 148 const struct pending_abstract_type *pat = 149 (const struct pending_abstract_type *) val; 150 return (hashval_t) TYPE_UID (pat->type); 151} 152 153 154/* Compare node VAL1 with the type VAL2. This function is used by the 155 hash table abstract_pending_vars. */ 156 157static int 158pat_compare (const void* val1, const void* val2) 159{ 160 const struct pending_abstract_type *pat1 = 161 (const struct pending_abstract_type *) val1; 162 tree type2 = (tree)val2; 163 164 return (pat1->type == type2); 165} 166 167/* Hash table that maintains pending_abstract_type nodes, for which we still 168 need to check for type abstractness. The key of the table is the type 169 of the declaration. */ 170static GTY ((param_is (struct pending_abstract_type))) 171htab_t abstract_pending_vars = NULL; 172 173 174/* This function is called after TYPE is completed, and will check if there 175 are pending declarations for which we still need to verify the abstractness 176 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE 177 turned out to be incomplete. */ 178 179void 180complete_type_check_abstract (tree type) 181{ 182 void **slot; 183 struct pending_abstract_type *pat; 184 location_t cur_loc = input_location; 185 186 gcc_assert (COMPLETE_TYPE_P (type)); 187 188 if (!abstract_pending_vars) 189 return; 190 191 /* Retrieve the list of pending declarations for this type. */ 192 slot = htab_find_slot_with_hash (abstract_pending_vars, type, 193 (hashval_t)TYPE_UID (type), NO_INSERT); 194 if (!slot) 195 return; 196 pat = (struct pending_abstract_type*)*slot; 197 gcc_assert (pat); 198 199 /* If the type is not abstract, do not do anything. */ 200 if (CLASSTYPE_PURE_VIRTUALS (type)) 201 { 202 struct pending_abstract_type *prev = 0, *next; 203 204 /* Reverse the list to emit the errors in top-down order. */ 205 for (; pat; pat = next) 206 { 207 next = pat->next; 208 pat->next = prev; 209 prev = pat; 210 } 211 pat = prev; 212 213 /* Go through the list, and call abstract_virtuals_error for each 214 element: it will issue a diagnostic if the type is abstract. */ 215 while (pat) 216 { 217 gcc_assert (type == pat->type); 218 219 /* Tweak input_location so that the diagnostic appears at the correct 220 location. Notice that this is only needed if the decl is an 221 IDENTIFIER_NODE. */ 222 input_location = pat->locus; 223 abstract_virtuals_error (pat->decl, pat->type); 224 pat = pat->next; 225 } 226 } 227 228 htab_clear_slot (abstract_pending_vars, slot); 229 230 input_location = cur_loc; 231} 232 233 234/* If TYPE has abstract virtual functions, issue an error about trying 235 to create an object of that type. DECL is the object declared, or 236 NULL_TREE if the declaration is unavailable. Returns 1 if an error 237 occurred; zero if all was well. */ 238 239int 240abstract_virtuals_error (tree decl, tree type) 241{ 242 VEC(tree,gc) *pure; 243 244 /* This function applies only to classes. Any other entity can never 245 be abstract. */ 246 if (!CLASS_TYPE_P (type)) 247 return 0; 248 249 /* If the type is incomplete, we register it within a hash table, 250 so that we can check again once it is completed. This makes sense 251 only for objects for which we have a declaration or at least a 252 name. */ 253 if (!COMPLETE_TYPE_P (type)) 254 { 255 void **slot; 256 struct pending_abstract_type *pat; 257 258 gcc_assert (!decl || DECL_P (decl) 259 || TREE_CODE (decl) == IDENTIFIER_NODE); 260 261 if (!abstract_pending_vars) 262 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash, 263 &pat_compare, NULL); 264 265 slot = htab_find_slot_with_hash (abstract_pending_vars, type, 266 (hashval_t)TYPE_UID (type), INSERT); 267 268 pat = GGC_NEW (struct pending_abstract_type); 269 pat->type = type; 270 pat->decl = decl; 271 pat->locus = ((decl && DECL_P (decl)) 272 ? DECL_SOURCE_LOCATION (decl) 273 : input_location); 274 275 pat->next = (struct pending_abstract_type *) *slot; 276 *slot = pat; 277 278 return 0; 279 } 280 281 if (!TYPE_SIZE (type)) 282 /* TYPE is being defined, and during that time 283 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */ 284 return 0; 285 286 pure = CLASSTYPE_PURE_VIRTUALS (type); 287 if (!pure) 288 return 0; 289 290 if (decl) 291 { 292 if (TREE_CODE (decl) == RESULT_DECL) 293 return 0; 294 295 if (TREE_CODE (decl) == VAR_DECL) 296 error ("cannot declare variable %q+D to be of abstract " 297 "type %qT", decl, type); 298 else if (TREE_CODE (decl) == PARM_DECL) 299 error ("cannot declare parameter %q+D to be of abstract type %qT", 300 decl, type); 301 else if (TREE_CODE (decl) == FIELD_DECL) 302 error ("cannot declare field %q+D to be of abstract type %qT", 303 decl, type); 304 else if (TREE_CODE (decl) == FUNCTION_DECL 305 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) 306 error ("invalid abstract return type for member function %q+#D", decl); 307 else if (TREE_CODE (decl) == FUNCTION_DECL) 308 error ("invalid abstract return type for function %q+#D", decl); 309 else if (TREE_CODE (decl) == IDENTIFIER_NODE) 310 /* Here we do not have location information. */ 311 error ("invalid abstract type %qT for %qE", type, decl); 312 else 313 error ("invalid abstract type for %q+D", decl); 314 } 315 else 316 error ("cannot allocate an object of abstract type %qT", type); 317 318 /* Only go through this once. */ 319 if (VEC_length (tree, pure)) 320 { 321 unsigned ix; 322 tree fn; 323 324 inform ("%J because the following virtual functions are pure " 325 "within %qT:", TYPE_MAIN_DECL (type), type); 326 327 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++) 328 inform ("\t%+#D", fn); 329 /* Now truncate the vector. This leaves it non-null, so we know 330 there are pure virtuals, but empty so we don't list them out 331 again. */ 332 VEC_truncate (tree, pure, 0); 333 } 334 else 335 inform ("%J since type %qT has pure virtual functions", 336 TYPE_MAIN_DECL (type), type); 337 338 return 1; 339} 340 341/* Print an error message for invalid use of an incomplete type. 342 VALUE is the expression that was used (or 0 if that isn't known) 343 and TYPE is the type that was invalid. DIAG_TYPE indicates the 344 type of diagnostic: 0 for an error, 1 for a warning, 2 for a 345 pedwarn. */ 346 347void 348cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type) 349{ 350 int decl = 0; 351 void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); 352 353 if (diag_type == 1) 354 p_msg = warning0; 355 else if (diag_type == 2) 356 p_msg = pedwarn; 357 else 358 p_msg = error; 359 360 /* Avoid duplicate error message. */ 361 if (TREE_CODE (type) == ERROR_MARK) 362 return; 363 364 if (value != 0 && (TREE_CODE (value) == VAR_DECL 365 || TREE_CODE (value) == PARM_DECL 366 || TREE_CODE (value) == FIELD_DECL)) 367 { 368 p_msg ("%q+D has incomplete type", value); 369 decl = 1; 370 } 371 retry: 372 /* We must print an error message. Be clever about what it says. */ 373 374 switch (TREE_CODE (type)) 375 { 376 case RECORD_TYPE: 377 case UNION_TYPE: 378 case ENUMERAL_TYPE: 379 if (!decl) 380 p_msg ("invalid use of incomplete type %q#T", type); 381 if (!TYPE_TEMPLATE_INFO (type)) 382 p_msg ("forward declaration of %q+#T", type); 383 else 384 p_msg ("declaration of %q+#T", type); 385 break; 386 387 case VOID_TYPE: 388 p_msg ("invalid use of %qT", type); 389 break; 390 391 case ARRAY_TYPE: 392 if (TYPE_DOMAIN (type)) 393 { 394 type = TREE_TYPE (type); 395 goto retry; 396 } 397 p_msg ("invalid use of array with unspecified bounds"); 398 break; 399 400 case OFFSET_TYPE: 401 bad_member: 402 p_msg ("invalid use of member (did you forget the %<&%> ?)"); 403 break; 404 405 case TEMPLATE_TYPE_PARM: 406 p_msg ("invalid use of template type parameter %qT", type); 407 break; 408 409 case BOUND_TEMPLATE_TEMPLATE_PARM: 410 p_msg ("invalid use of template template parameter %qT", 411 TYPE_NAME (type)); 412 break; 413 414 case TYPENAME_TYPE: 415 p_msg ("invalid use of dependent type %qT", type); 416 break; 417 418 case UNKNOWN_TYPE: 419 if (value && TREE_CODE (value) == COMPONENT_REF) 420 goto bad_member; 421 else if (value && TREE_CODE (value) == ADDR_EXPR) 422 p_msg ("address of overloaded function with no contextual " 423 "type information"); 424 else if (value && TREE_CODE (value) == OVERLOAD) 425 p_msg ("overloaded function with no contextual type information"); 426 else 427 p_msg ("insufficient contextual information to determine type"); 428 break; 429 430 default: 431 gcc_unreachable (); 432 } 433} 434 435/* Backward-compatibility interface to incomplete_type_diagnostic; 436 required by ../tree.c. */ 437#undef cxx_incomplete_type_error 438void 439cxx_incomplete_type_error (tree value, tree type) 440{ 441 cxx_incomplete_type_diagnostic (value, type, 0); 442} 443 444 445/* The recursive part of split_nonconstant_init. DEST is an lvalue 446 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */ 447 448static void 449split_nonconstant_init_1 (tree dest, tree init) 450{ 451 unsigned HOST_WIDE_INT idx; 452 tree field_index, value; 453 tree type = TREE_TYPE (dest); 454 tree inner_type = NULL; 455 bool array_type_p = false; 456 457 switch (TREE_CODE (type)) 458 { 459 case ARRAY_TYPE: 460 inner_type = TREE_TYPE (type); 461 array_type_p = true; 462 /* FALLTHRU */ 463 464 case RECORD_TYPE: 465 case UNION_TYPE: 466 case QUAL_UNION_TYPE: 467 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, 468 field_index, value) 469 { 470 /* The current implementation of this algorithm assumes that 471 the field was set for all the elements. This is usually done 472 by process_init_constructor. */ 473 gcc_assert (field_index); 474 475 if (!array_type_p) 476 inner_type = TREE_TYPE (field_index); 477 478 if (TREE_CODE (value) == CONSTRUCTOR) 479 { 480 tree sub; 481 482 if (array_type_p) 483 sub = build4 (ARRAY_REF, inner_type, dest, field_index, 484 NULL_TREE, NULL_TREE); 485 else 486 sub = build3 (COMPONENT_REF, inner_type, dest, field_index, 487 NULL_TREE); 488 489 split_nonconstant_init_1 (sub, value); 490 } 491 else if (!initializer_constant_valid_p (value, inner_type)) 492 { 493 tree code; 494 tree sub; 495 496 /* FIXME: Ordered removal is O(1) so the whole function is 497 worst-case quadratic. This could be fixed using an aside 498 bitmap to record which elements must be removed and remove 499 them all at the same time. Or by merging 500 split_non_constant_init into process_init_constructor_array, 501 that is separating constants from non-constants while building 502 the vector. */ 503 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 504 idx); 505 --idx; 506 507 if (array_type_p) 508 sub = build4 (ARRAY_REF, inner_type, dest, field_index, 509 NULL_TREE, NULL_TREE); 510 else 511 sub = build3 (COMPONENT_REF, inner_type, dest, field_index, 512 NULL_TREE); 513 514 code = build2 (INIT_EXPR, inner_type, sub, value); 515 code = build_stmt (EXPR_STMT, code); 516 add_stmt (code); 517 continue; 518 } 519 } 520 break; 521 522 case VECTOR_TYPE: 523 if (!initializer_constant_valid_p (init, type)) 524 { 525 tree code; 526 tree cons = copy_node (init); 527 CONSTRUCTOR_ELTS (init) = NULL; 528 code = build2 (MODIFY_EXPR, type, dest, cons); 529 code = build_stmt (EXPR_STMT, code); 530 add_stmt (code); 531 } 532 break; 533 534 default: 535 gcc_unreachable (); 536 } 537 538 /* The rest of the initializer is now a constant. */ 539 TREE_CONSTANT (init) = 1; 540} 541 542/* A subroutine of store_init_value. Splits non-constant static 543 initializer INIT into a constant part and generates code to 544 perform the non-constant part of the initialization to DEST. 545 Returns the code for the runtime init. */ 546 547static tree 548split_nonconstant_init (tree dest, tree init) 549{ 550 tree code; 551 552 if (TREE_CODE (init) == CONSTRUCTOR) 553 { 554 code = push_stmt_list (); 555 split_nonconstant_init_1 (dest, init); 556 code = pop_stmt_list (code); 557 DECL_INITIAL (dest) = init; 558 TREE_READONLY (dest) = 0; 559 } 560 else 561 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init); 562 563 return code; 564} 565 566/* Perform appropriate conversions on the initial value of a variable, 567 store it in the declaration DECL, 568 and print any error messages that are appropriate. 569 If the init is invalid, store an ERROR_MARK. 570 571 C++: Note that INIT might be a TREE_LIST, which would mean that it is 572 a base class initializer for some aggregate type, hopefully compatible 573 with DECL. If INIT is a single element, and DECL is an aggregate 574 type, we silently convert INIT into a TREE_LIST, allowing a constructor 575 to be called. 576 577 If INIT is a TREE_LIST and there is no constructor, turn INIT 578 into a CONSTRUCTOR and use standard initialization techniques. 579 Perhaps a warning should be generated? 580 581 Returns code to be executed if initialization could not be performed 582 for static variable. In that case, caller must emit the code. */ 583 584tree 585store_init_value (tree decl, tree init) 586{ 587 tree value, type; 588 589 /* If variable's type was invalidly declared, just ignore it. */ 590 591 type = TREE_TYPE (decl); 592 if (TREE_CODE (type) == ERROR_MARK) 593 return NULL_TREE; 594 595 if (IS_AGGR_TYPE (type)) 596 { 597 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type) 598 || TREE_CODE (init) == CONSTRUCTOR); 599 600 if (TREE_CODE (init) == TREE_LIST) 601 { 602 error ("constructor syntax used, but no constructor declared " 603 "for type %qT", type); 604 init = build_constructor_from_list (NULL_TREE, nreverse (init)); 605 } 606 } 607 else if (TREE_CODE (init) == TREE_LIST 608 && TREE_TYPE (init) != unknown_type_node) 609 { 610 if (TREE_CODE (decl) == RESULT_DECL) 611 init = build_x_compound_expr_from_list (init, 612 "return value initializer"); 613 else if (TREE_CODE (init) == TREE_LIST 614 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 615 { 616 error ("cannot initialize arrays using this syntax"); 617 return NULL_TREE; 618 } 619 else 620 /* We get here with code like `int a (2);' */ 621 init = build_x_compound_expr_from_list (init, "initializer"); 622 } 623 624 /* End of special C++ code. */ 625 626 /* Digest the specified initializer into an expression. */ 627 value = digest_init (type, init); 628 /* If the initializer is not a constant, fill in DECL_INITIAL with 629 the bits that are constant, and then return an expression that 630 will perform the dynamic initialization. */ 631 if (value != error_mark_node 632 && (TREE_SIDE_EFFECTS (value) 633 || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) 634 return split_nonconstant_init (decl, value); 635 /* If the value is a constant, just put it in DECL_INITIAL. If DECL 636 is an automatic variable, the middle end will turn this into a 637 dynamic initialization later. */ 638 DECL_INITIAL (decl) = value; 639 return NULL_TREE; 640} 641 642 643/* Process the initializer INIT for a variable of type TYPE, emitting 644 diagnostics for invalid initializers and converting the initializer as 645 appropriate. 646 647 For aggregate types, it assumes that reshape_init has already run, thus the 648 initializer will have the right shape (brace elision has been undone). */ 649 650tree 651digest_init (tree type, tree init) 652{ 653 enum tree_code code = TREE_CODE (type); 654 655 if (init == error_mark_node) 656 return error_mark_node; 657 658 gcc_assert (init); 659 660 /* We must strip the outermost array type when completing the type, 661 because the its bounds might be incomplete at the moment. */ 662 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE 663 ? TREE_TYPE (type) : type, NULL_TREE)) 664 return error_mark_node; 665 666 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue 667 (g++.old-deja/g++.law/casts2.C). */ 668 if (TREE_CODE (init) == NON_LVALUE_EXPR) 669 init = TREE_OPERAND (init, 0); 670 671 /* Initialization of an array of chars from a string constant. The initializer 672 can be optionally enclosed in braces, but reshape_init has already removed 673 them if they were present. */ 674 if (code == ARRAY_TYPE) 675 { 676 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 677 if (char_type_p (typ1) 678 /*&& init */ 679 && TREE_CODE (init) == STRING_CST) 680 { 681 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init))); 682 683 if (char_type != char_type_node 684 && TYPE_PRECISION (typ1) == BITS_PER_UNIT) 685 { 686 error ("char-array initialized from wide string"); 687 return error_mark_node; 688 } 689 if (char_type == char_type_node 690 && TYPE_PRECISION (typ1) != BITS_PER_UNIT) 691 { 692 error ("int-array initialized from non-wide string"); 693 return error_mark_node; 694 } 695 696 TREE_TYPE (init) = type; 697 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type))) 698 { 699 int size = TREE_INT_CST_LOW (TYPE_SIZE (type)); 700 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; 701 /* In C it is ok to subtract 1 from the length of the string 702 because it's ok to ignore the terminating null char that is 703 counted in the length of the constant, but in C++ this would 704 be invalid. */ 705 if (size < TREE_STRING_LENGTH (init)) 706 pedwarn ("initializer-string for array of chars is too long"); 707 } 708 return init; 709 } 710 } 711 712 /* Handle scalar types (including conversions) and references. */ 713 if (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE) 714 return convert_for_initialization (0, type, init, LOOKUP_NORMAL, 715 "initialization", NULL_TREE, 0); 716 717 /* Come here only for aggregates: records, arrays, unions, complex numbers 718 and vectors. */ 719 gcc_assert (TREE_CODE (type) == ARRAY_TYPE 720 || TREE_CODE (type) == VECTOR_TYPE 721 || TREE_CODE (type) == RECORD_TYPE 722 || TREE_CODE (type) == UNION_TYPE 723 || TREE_CODE (type) == COMPLEX_TYPE); 724 725 if (BRACE_ENCLOSED_INITIALIZER_P (init)) 726 return process_init_constructor (type, init); 727 else 728 { 729 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE) 730 { 731 error ("cannot initialize aggregate of type %qT with " 732 "a compound literal", type); 733 734 return error_mark_node; 735 } 736 737 if (TREE_CODE (type) == ARRAY_TYPE 738 && TREE_CODE (init) != CONSTRUCTOR) 739 { 740 error ("array must be initialized with a brace-enclosed" 741 " initializer"); 742 return error_mark_node; 743 } 744 745 return convert_for_initialization (NULL_TREE, type, init, 746 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING, 747 "initialization", NULL_TREE, 0); 748 } 749} 750 751 752/* Set of flags used within process_init_constructor to describe the 753 initializers. */ 754#define PICFLAG_ERRONEOUS 1 755#define PICFLAG_NOT_ALL_CONSTANT 2 756#define PICFLAG_NOT_ALL_SIMPLE 4 757 758/* Given an initializer INIT, return the flag (PICFLAG_*) which better 759 describe it. */ 760 761static int 762picflag_from_initializer (tree init) 763{ 764 if (init == error_mark_node) 765 return PICFLAG_ERRONEOUS; 766 else if (!TREE_CONSTANT (init)) 767 return PICFLAG_NOT_ALL_CONSTANT; 768 else if (!initializer_constant_valid_p (init, TREE_TYPE (init))) 769 return PICFLAG_NOT_ALL_SIMPLE; 770 return 0; 771} 772 773/* Subroutine of process_init_constructor, which will process an initializer 774 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which 775 describe the initializers. */ 776 777static int 778process_init_constructor_array (tree type, tree init) 779{ 780 unsigned HOST_WIDE_INT i, len = 0; 781 int flags = 0; 782 bool unbounded = false; 783 constructor_elt *ce; 784 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init); 785 786 gcc_assert (TREE_CODE (type) == ARRAY_TYPE 787 || TREE_CODE (type) == VECTOR_TYPE); 788 789 if (TREE_CODE (type) == ARRAY_TYPE) 790 { 791 tree domain = TYPE_DOMAIN (type); 792 if (domain) 793 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) 794 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) 795 + 1); 796 else 797 unbounded = true; /* Take as many as there are. */ 798 } 799 else 800 /* Vectors are like simple fixed-size arrays. */ 801 len = TYPE_VECTOR_SUBPARTS (type); 802 803 /* There cannot be more initializers than needed as otherwise 804 reshape_init would have already rejected the initializer. */ 805 if (!unbounded) 806 gcc_assert (VEC_length (constructor_elt, v) <= len); 807 808 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i) 809 { 810 if (ce->index) 811 { 812 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST); 813 if (compare_tree_int (ce->index, i) != 0) 814 { 815 ce->value = error_mark_node; 816 sorry ("non-trivial designated initializers not supported"); 817 } 818 } 819 else 820 ce->index = size_int (i); 821 gcc_assert (ce->value); 822 ce->value = digest_init (TREE_TYPE (type), ce->value); 823 824 if (ce->value != error_mark_node) 825 gcc_assert (same_type_ignoring_top_level_qualifiers_p 826 (TREE_TYPE (type), TREE_TYPE (ce->value))); 827 828 flags |= picflag_from_initializer (ce->value); 829 } 830 831 /* No more initializers. If the array is unbounded, we are done. Otherwise, 832 we must add initializers ourselves. */ 833 if (!unbounded) 834 for (; i < len; ++i) 835 { 836 tree next; 837 838 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) 839 { 840 /* If this type needs constructors run for default-initialization, 841 we can't rely on the backend to do it for us, so build up 842 TARGET_EXPRs. If the type in question is a class, just build 843 one up; if it's an array, recurse. */ 844 if (IS_AGGR_TYPE (TREE_TYPE (type))) 845 next = build_functional_cast (TREE_TYPE (type), NULL_TREE); 846 else 847 next = build_constructor (NULL_TREE, NULL); 848 next = digest_init (TREE_TYPE (type), next); 849 } 850 else if (!zero_init_p (TREE_TYPE (type))) 851 next = build_zero_init (TREE_TYPE (type), 852 /*nelts=*/NULL_TREE, 853 /*static_storage_p=*/false); 854 else 855 /* The default zero-initialization is fine for us; don't 856 add anything to the CONSTRUCTOR. */ 857 break; 858 859 flags |= picflag_from_initializer (next); 860 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next); 861 } 862 863 CONSTRUCTOR_ELTS (init) = v; 864 return flags; 865} 866 867/* Subroutine of process_init_constructor, which will process an initializer 868 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe 869 the initializers. */ 870 871static int 872process_init_constructor_record (tree type, tree init) 873{ 874 VEC(constructor_elt,gc) *v = NULL; 875 int flags = 0; 876 tree field; 877 unsigned HOST_WIDE_INT idx = 0; 878 879 gcc_assert (TREE_CODE (type) == RECORD_TYPE); 880 gcc_assert (!CLASSTYPE_VBASECLASSES (type)); 881 gcc_assert (!TYPE_BINFO (type) 882 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type))); 883 gcc_assert (!TYPE_POLYMORPHIC_P (type)); 884 885 /* Generally, we will always have an index for each initializer (which is 886 a FIELD_DECL, put by reshape_init), but compound literals don't go trough 887 reshape_init. So we need to handle both cases. */ 888 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 889 { 890 tree next; 891 892 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field)) 893 { 894 flags |= picflag_from_initializer (integer_zero_node); 895 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node); 896 continue; 897 } 898 899 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 900 continue; 901 902 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) 903 { 904 constructor_elt *ce = VEC_index (constructor_elt, 905 CONSTRUCTOR_ELTS (init), idx); 906 if (ce->index) 907 { 908 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The 909 latter case can happen in templates where lookup has to be 910 deferred. */ 911 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL 912 || TREE_CODE (ce->index) == IDENTIFIER_NODE); 913 if (ce->index != field 914 && ce->index != DECL_NAME (field)) 915 { 916 ce->value = error_mark_node; 917 sorry ("non-trivial designated initializers not supported"); 918 } 919 } 920 921 gcc_assert (ce->value); 922 next = digest_init (TREE_TYPE (field), ce->value); 923 ++idx; 924 } 925 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) 926 { 927 /* If this type needs constructors run for 928 default-initialization, we can't rely on the backend to do it 929 for us, so build up TARGET_EXPRs. If the type in question is 930 a class, just build one up; if it's an array, recurse. */ 931 if (IS_AGGR_TYPE (TREE_TYPE (field))) 932 next = build_functional_cast (TREE_TYPE (field), NULL_TREE); 933 else 934 next = build_constructor (NULL_TREE, NULL); 935 936 next = digest_init (TREE_TYPE (field), next); 937 938 /* Warn when some struct elements are implicitly initialized. */ 939 warning (OPT_Wmissing_field_initializers, 940 "missing initializer for member %qD", field); 941 } 942 else 943 { 944 if (TREE_READONLY (field)) 945 error ("uninitialized const member %qD", field); 946 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) 947 error ("member %qD with uninitialized const fields", field); 948 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) 949 error ("member %qD is uninitialized reference", field); 950 951 /* Warn when some struct elements are implicitly initialized 952 to zero. */ 953 warning (OPT_Wmissing_field_initializers, 954 "missing initializer for member %qD", field); 955 956 if (!zero_init_p (TREE_TYPE (field))) 957 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE, 958 /*static_storage_p=*/false); 959 else 960 /* The default zero-initialization is fine for us; don't 961 add anything to the CONSTRUCTOR. */ 962 continue; 963 } 964 965 flags |= picflag_from_initializer (next); 966 CONSTRUCTOR_APPEND_ELT (v, field, next); 967 } 968 969 CONSTRUCTOR_ELTS (init) = v; 970 return flags; 971} 972 973/* Subroutine of process_init_constructor, which will process a single 974 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*) 975 which describe the initializer. */ 976 977static int 978process_init_constructor_union (tree type, tree init) 979{ 980 constructor_elt *ce; 981 982 /* If the initializer was empty, use default zero initialization. */ 983 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))) 984 return 0; 985 986 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1); 987 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); 988 989 /* If this element specifies a field, initialize via that field. */ 990 if (ce->index) 991 { 992 if (TREE_CODE (ce->index) == FIELD_DECL) 993 ; 994 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE) 995 { 996 /* This can happen within a cast, see g++.dg/opt/cse2.C. */ 997 tree name = ce->index; 998 tree field; 999 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1000 if (DECL_NAME (field) == name) 1001 break; 1002 if (!field) 1003 { 1004 error ("no field %qD found in union being initialized", field); 1005 ce->value = error_mark_node; 1006 } 1007 ce->index = field; 1008 } 1009 else 1010 { 1011 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST 1012 || TREE_CODE (ce->index) == RANGE_EXPR); 1013 error ("index value instead of field name in union initializer"); 1014 ce->value = error_mark_node; 1015 } 1016 } 1017 else 1018 { 1019 /* Find the first named field. ANSI decided in September 1990 1020 that only named fields count here. */ 1021 tree field = TYPE_FIELDS (type); 1022 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL)) 1023 field = TREE_CHAIN (field); 1024 gcc_assert (field); 1025 ce->index = field; 1026 } 1027 1028 if (ce->value && ce->value != error_mark_node) 1029 ce->value = digest_init (TREE_TYPE (ce->index), ce->value); 1030 1031 return picflag_from_initializer (ce->value); 1032} 1033 1034/* Process INIT, a constructor for a variable of aggregate type TYPE. The 1035 constructor is a brace-enclosed initializer, and will be modified in-place. 1036 1037 Each element is converted to the right type through digest_init, and 1038 missing initializers are added following the language rules (zero-padding, 1039 etc.). 1040 1041 After the execution, the initializer will have TREE_CONSTANT if all elts are 1042 constant, and TREE_STATIC set if, in addition, all elts are simple enough 1043 constants that the assembler and linker can compute them. 1044 1045 The function returns the initializer itself, or error_mark_node in case 1046 of error. */ 1047 1048static tree 1049process_init_constructor (tree type, tree init) 1050{ 1051 int flags; 1052 1053 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 1054 1055 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) 1056 flags = process_init_constructor_array (type, init); 1057 else if (TREE_CODE (type) == RECORD_TYPE) 1058 flags = process_init_constructor_record (type, init); 1059 else if (TREE_CODE (type) == UNION_TYPE) 1060 flags = process_init_constructor_union (type, init); 1061 else 1062 gcc_unreachable (); 1063 1064 if (flags & PICFLAG_ERRONEOUS) 1065 return error_mark_node; 1066 1067 TREE_TYPE (init) = type; 1068 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE) 1069 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0); 1070 if (!(flags & PICFLAG_NOT_ALL_CONSTANT)) 1071 { 1072 TREE_CONSTANT (init) = 1; 1073 TREE_INVARIANT (init) = 1; 1074 if (!(flags & PICFLAG_NOT_ALL_SIMPLE)) 1075 TREE_STATIC (init) = 1; 1076 } 1077 return init; 1078} 1079 1080/* Given a structure or union value DATUM, construct and return 1081 the structure or union component which results from narrowing 1082 that value to the base specified in BASETYPE. For example, given the 1083 hierarchy 1084 1085 class L { int ii; }; 1086 class A : L { ... }; 1087 class B : L { ... }; 1088 class C : A, B { ... }; 1089 1090 and the declaration 1091 1092 C x; 1093 1094 then the expression 1095 1096 x.A::ii refers to the ii member of the L part of 1097 the A part of the C object named by X. In this case, 1098 DATUM would be x, and BASETYPE would be A. 1099 1100 I used to think that this was nonconformant, that the standard specified 1101 that first we look up ii in A, then convert x to an L& and pull out the 1102 ii part. But in fact, it does say that we convert x to an A&; A here 1103 is known as the "naming class". (jason 2000-12-19) 1104 1105 BINFO_P points to a variable initialized either to NULL_TREE or to the 1106 binfo for the specific base subobject we want to convert to. */ 1107 1108tree 1109build_scoped_ref (tree datum, tree basetype, tree* binfo_p) 1110{ 1111 tree binfo; 1112 1113 if (datum == error_mark_node) 1114 return error_mark_node; 1115 if (*binfo_p) 1116 binfo = *binfo_p; 1117 else 1118 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL); 1119 1120 if (!binfo || binfo == error_mark_node) 1121 { 1122 *binfo_p = NULL_TREE; 1123 if (!binfo) 1124 error_not_base_type (basetype, TREE_TYPE (datum)); 1125 return error_mark_node; 1126 } 1127 1128 *binfo_p = binfo; 1129 return build_base_path (PLUS_EXPR, datum, binfo, 1); 1130} 1131 1132/* Build a reference to an object specified by the C++ `->' operator. 1133 Usually this just involves dereferencing the object, but if the 1134 `->' operator is overloaded, then such overloads must be 1135 performed until an object which does not have the `->' operator 1136 overloaded is found. An error is reported when circular pointer 1137 delegation is detected. */ 1138 1139tree 1140build_x_arrow (tree expr) 1141{ 1142 tree orig_expr = expr; 1143 tree types_memoized = NULL_TREE; 1144 tree type = TREE_TYPE (expr); 1145 tree last_rval = NULL_TREE; 1146 1147 if (type == error_mark_node) 1148 return error_mark_node; 1149 1150 if (processing_template_decl) 1151 { 1152 if (type_dependent_expression_p (expr)) 1153 return build_min_nt (ARROW_EXPR, expr); 1154 expr = build_non_dependent_expr (expr); 1155 } 1156 1157 if (IS_AGGR_TYPE (type)) 1158 { 1159 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr, 1160 NULL_TREE, NULL_TREE, 1161 /*overloaded_p=*/NULL))) 1162 { 1163 if (expr == error_mark_node) 1164 return error_mark_node; 1165 1166 if (value_member (TREE_TYPE (expr), types_memoized)) 1167 { 1168 error ("circular pointer delegation detected"); 1169 return error_mark_node; 1170 } 1171 else 1172 { 1173 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr), 1174 types_memoized); 1175 } 1176 last_rval = expr; 1177 } 1178 1179 if (last_rval == NULL_TREE) 1180 { 1181 error ("base operand of %<->%> has non-pointer type %qT", type); 1182 return error_mark_node; 1183 } 1184 1185 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE) 1186 last_rval = convert_from_reference (last_rval); 1187 } 1188 else 1189 last_rval = decay_conversion (expr); 1190 1191 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE) 1192 { 1193 if (processing_template_decl) 1194 { 1195 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr); 1196 /* It will be dereferenced. */ 1197 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval)); 1198 return expr; 1199 } 1200 1201 return build_indirect_ref (last_rval, NULL); 1202 } 1203 1204 if (types_memoized) 1205 error ("result of %<operator->()%> yields non-pointer result"); 1206 else 1207 error ("base operand of %<->%> is not a pointer"); 1208 return error_mark_node; 1209} 1210 1211/* Return an expression for "DATUM .* COMPONENT". DATUM has not 1212 already been checked out to be of aggregate type. */ 1213 1214tree 1215build_m_component_ref (tree datum, tree component) 1216{ 1217 tree ptrmem_type; 1218 tree objtype; 1219 tree type; 1220 tree binfo; 1221 tree ctype; 1222 1223 if (error_operand_p (datum) || error_operand_p (component)) 1224 return error_mark_node; 1225 1226 ptrmem_type = TREE_TYPE (component); 1227 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type)) 1228 { 1229 error ("%qE cannot be used as a member pointer, since it is of " 1230 "type %qT", 1231 component, ptrmem_type); 1232 return error_mark_node; 1233 } 1234 1235 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); 1236 if (! IS_AGGR_TYPE (objtype)) 1237 { 1238 error ("cannot apply member pointer %qE to %qE, which is of " 1239 "non-class type %qT", 1240 component, datum, objtype); 1241 return error_mark_node; 1242 } 1243 1244 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type); 1245 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type)); 1246 1247 if (!COMPLETE_TYPE_P (ctype)) 1248 { 1249 if (!same_type_p (ctype, objtype)) 1250 goto mismatch; 1251 binfo = NULL; 1252 } 1253 else 1254 { 1255 binfo = lookup_base (objtype, ctype, ba_check, NULL); 1256 1257 if (!binfo) 1258 { 1259 mismatch: 1260 error ("pointer to member type %qT incompatible with object " 1261 "type %qT", 1262 type, objtype); 1263 return error_mark_node; 1264 } 1265 else if (binfo == error_mark_node) 1266 return error_mark_node; 1267 } 1268 1269 if (TYPE_PTRMEM_P (ptrmem_type)) 1270 { 1271 /* Compute the type of the field, as described in [expr.ref]. 1272 There's no such thing as a mutable pointer-to-member, so 1273 things are not as complex as they are for references to 1274 non-static data members. */ 1275 type = cp_build_qualified_type (type, 1276 (cp_type_quals (type) 1277 | cp_type_quals (TREE_TYPE (datum)))); 1278 1279 datum = build_address (datum); 1280 1281 /* Convert object to the correct base. */ 1282 if (binfo) 1283 datum = build_base_path (PLUS_EXPR, datum, binfo, 1); 1284 1285 /* Build an expression for "object + offset" where offset is the 1286 value stored in the pointer-to-data-member. */ 1287 datum = build2 (PLUS_EXPR, build_pointer_type (type), 1288 datum, build_nop (ptrdiff_type_node, component)); 1289 return build_indirect_ref (datum, 0); 1290 } 1291 else 1292 return build2 (OFFSET_REF, type, datum, component); 1293} 1294 1295/* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ 1296 1297tree 1298build_functional_cast (tree exp, tree parms) 1299{ 1300 /* This is either a call to a constructor, 1301 or a C cast in C++'s `functional' notation. */ 1302 tree type; 1303 1304 if (exp == error_mark_node || parms == error_mark_node) 1305 return error_mark_node; 1306 1307 if (TREE_CODE (exp) == TYPE_DECL) 1308 type = TREE_TYPE (exp); 1309 else 1310 type = exp; 1311 1312 if (processing_template_decl) 1313 { 1314 tree t = build_min (CAST_EXPR, type, parms); 1315 /* We don't know if it will or will not have side effects. */ 1316 TREE_SIDE_EFFECTS (t) = 1; 1317 return t; 1318 } 1319 1320 if (! IS_AGGR_TYPE (type)) 1321 { 1322 if (parms == NULL_TREE) 1323 return cp_convert (type, integer_zero_node); 1324 1325 /* This must build a C cast. */ 1326 parms = build_x_compound_expr_from_list (parms, "functional cast"); 1327 return build_c_cast (type, parms); 1328 } 1329 1330 /* Prepare to evaluate as a call to a constructor. If this expression 1331 is actually used, for example, 1332 1333 return X (arg1, arg2, ...); 1334 1335 then the slot being initialized will be filled in. */ 1336 1337 if (!complete_type_or_else (type, NULL_TREE)) 1338 return error_mark_node; 1339 if (abstract_virtuals_error (NULL_TREE, type)) 1340 return error_mark_node; 1341 1342 if (parms && TREE_CHAIN (parms) == NULL_TREE) 1343 return build_c_cast (type, TREE_VALUE (parms)); 1344 1345 /* We need to zero-initialize POD types. */ 1346 if (parms == NULL_TREE 1347 && !CLASSTYPE_NON_POD_P (type) 1348 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 1349 { 1350 exp = build_constructor (type, NULL); 1351 return get_target_expr (exp); 1352 } 1353 1354 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms, 1355 type, LOOKUP_NORMAL); 1356 1357 if (exp == error_mark_node) 1358 return error_mark_node; 1359 1360 return build_cplus_new (type, exp); 1361} 1362 1363 1364/* Add new exception specifier SPEC, to the LIST we currently have. 1365 If it's already in LIST then do nothing. 1366 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we 1367 know what we're doing. */ 1368 1369tree 1370add_exception_specifier (tree list, tree spec, int complain) 1371{ 1372 bool ok; 1373 tree core = spec; 1374 bool is_ptr; 1375 int diag_type = -1; /* none */ 1376 1377 if (spec == error_mark_node) 1378 return list; 1379 1380 gcc_assert (spec && (!list || TREE_VALUE (list))); 1381 1382 /* [except.spec] 1, type in an exception specifier shall not be 1383 incomplete, or pointer or ref to incomplete other than pointer 1384 to cv void. */ 1385 is_ptr = TREE_CODE (core) == POINTER_TYPE; 1386 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE) 1387 core = TREE_TYPE (core); 1388 if (complain < 0) 1389 ok = true; 1390 else if (VOID_TYPE_P (core)) 1391 ok = is_ptr; 1392 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM) 1393 ok = true; 1394 else if (processing_template_decl) 1395 ok = true; 1396 else 1397 { 1398 ok = true; 1399 /* 15.4/1 says that types in an exception specifier must be complete, 1400 but it seems more reasonable to only require this on definitions 1401 and calls. So just give a pedwarn at this point; we will give an 1402 error later if we hit one of those two cases. */ 1403 if (!COMPLETE_TYPE_P (complete_type (core))) 1404 diag_type = 2; /* pedwarn */ 1405 } 1406 1407 if (ok) 1408 { 1409 tree probe; 1410 1411 for (probe = list; probe; probe = TREE_CHAIN (probe)) 1412 if (same_type_p (TREE_VALUE (probe), spec)) 1413 break; 1414 if (!probe) 1415 list = tree_cons (NULL_TREE, spec, list); 1416 } 1417 else 1418 diag_type = 0; /* error */ 1419 1420 if (diag_type >= 0 && complain) 1421 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); 1422 1423 return list; 1424} 1425 1426/* Combine the two exceptions specifier lists LIST and ADD, and return 1427 their union. */ 1428 1429tree 1430merge_exception_specifiers (tree list, tree add) 1431{ 1432 if (!list || !add) 1433 return NULL_TREE; 1434 else if (!TREE_VALUE (list)) 1435 return add; 1436 else if (!TREE_VALUE (add)) 1437 return list; 1438 else 1439 { 1440 tree orig_list = list; 1441 1442 for (; add; add = TREE_CHAIN (add)) 1443 { 1444 tree spec = TREE_VALUE (add); 1445 tree probe; 1446 1447 for (probe = orig_list; probe; probe = TREE_CHAIN (probe)) 1448 if (same_type_p (TREE_VALUE (probe), spec)) 1449 break; 1450 if (!probe) 1451 { 1452 spec = build_tree_list (NULL_TREE, spec); 1453 TREE_CHAIN (spec) = list; 1454 list = spec; 1455 } 1456 } 1457 } 1458 return list; 1459} 1460 1461/* Subroutine of build_call. Ensure that each of the types in the 1462 exception specification is complete. Technically, 15.4/1 says that 1463 they need to be complete when we see a declaration of the function, 1464 but we should be able to get away with only requiring this when the 1465 function is defined or called. See also add_exception_specifier. */ 1466 1467void 1468require_complete_eh_spec_types (tree fntype, tree decl) 1469{ 1470 tree raises; 1471 /* Don't complain about calls to op new. */ 1472 if (decl && DECL_ARTIFICIAL (decl)) 1473 return; 1474 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises; 1475 raises = TREE_CHAIN (raises)) 1476 { 1477 tree type = TREE_VALUE (raises); 1478 if (type && !COMPLETE_TYPE_P (type)) 1479 { 1480 if (decl) 1481 error 1482 ("call to function %qD which throws incomplete type %q#T", 1483 decl, type); 1484 else 1485 error ("call to function which throws incomplete type %q#T", 1486 decl); 1487 } 1488 } 1489} 1490 1491 1492#include "gt-cp-typeck2.h" 1493