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