typeck2.c revision 122180
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 Free Software Foundation, Inc. 5 Hacked by Michael Tiemann (tiemann@cygnus.com) 6 7This file is part of GNU CC. 8 9GNU CC is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2, or (at your option) 12any later version. 13 14GNU CC is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with GNU CC; see the file COPYING. If not, write to 21the Free Software Foundation, 59 Temple Place - Suite 330, 22Boston, MA 02111-1307, USA. */ 23 24 25/* This file is part of the C++ front end. 26 It contains routines to build C++ expressions given their operands, 27 including computing the types of the result, C and C++ specific error 28 checks, and some optimization. 29 30 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes, 31 and to process initializations in declarations (since they work 32 like a strange sort of assignment). */ 33 34#include "config.h" 35#include "system.h" 36#include "tree.h" 37#include "cp-tree.h" 38#include "flags.h" 39#include "toplev.h" 40#include "output.h" 41#include "diagnostic.h" 42 43static tree process_init_constructor PARAMS ((tree, tree, tree *)); 44 45/* Print an error message stemming from an attempt to use 46 BASETYPE as a base class for TYPE. */ 47 48tree 49error_not_base_type (basetype, type) 50 tree basetype, type; 51{ 52 if (TREE_CODE (basetype) == FUNCTION_DECL) 53 basetype = DECL_CONTEXT (basetype); 54 error ("type `%T' is not a base type for type `%T'", basetype, type); 55 return error_mark_node; 56} 57 58tree 59binfo_or_else (base, type) 60 tree base, type; 61{ 62 tree binfo = lookup_base (type, base, ba_ignore, NULL); 63 64 if (binfo == error_mark_node) 65 return NULL_TREE; 66 else if (!binfo) 67 error_not_base_type (base, type); 68 return binfo; 69} 70 71/* According to ARM $7.1.6, "A `const' object may be initialized, but its 72 value may not be changed thereafter. Thus, we emit hard errors for these, 73 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For 74 example, conversions to references.) */ 75 76void 77readonly_error (arg, string, soft) 78 tree arg; 79 const char *string; 80 int soft; 81{ 82 const char *fmt; 83 void (*fn) PARAMS ((const char *, ...)); 84 85 if (soft) 86 fn = pedwarn; 87 else 88 fn = error; 89 90 if (TREE_CODE (arg) == COMPONENT_REF) 91 { 92 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 93 fmt = "%s of data-member `%D' in read-only structure"; 94 else 95 fmt = "%s of read-only data-member `%D'"; 96 (*fn) (fmt, string, TREE_OPERAND (arg, 1)); 97 } 98 else if (TREE_CODE (arg) == VAR_DECL) 99 { 100 if (DECL_LANG_SPECIFIC (arg) 101 && DECL_IN_AGGR_P (arg) 102 && !TREE_STATIC (arg)) 103 fmt = "%s of constant field `%D'"; 104 else 105 fmt = "%s of read-only variable `%D'"; 106 (*fn) (fmt, string, arg); 107 } 108 else if (TREE_CODE (arg) == PARM_DECL) 109 (*fn) ("%s of read-only parameter `%D'", string, arg); 110 else if (TREE_CODE (arg) == INDIRECT_REF 111 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE 112 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL 113 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) 114 (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0)); 115 else if (TREE_CODE (arg) == RESULT_DECL) 116 (*fn) ("%s of read-only named return value `%D'", string, arg); 117 else if (TREE_CODE (arg) == FUNCTION_DECL) 118 (*fn) ("%s of function `%D'", string, arg); 119 else 120 (*fn) ("%s of read-only location", string); 121} 122 123/* If TYPE has abstract virtual functions, issue an error about trying 124 to create an object of that type. DECL is the object declared, or 125 NULL_TREE if the declaration is unavailable. Returns 1 if an error 126 occurred; zero if all was well. */ 127 128int 129abstract_virtuals_error (decl, type) 130 tree decl; 131 tree type; 132{ 133 tree u; 134 tree tu; 135 136 if (processing_template_decl) 137 /* If we are processing a template, TYPE may be a template 138 class where CLASSTYPE_PURE_VIRTUALS always contains 139 inline friends. */ 140 return 0; 141 142 if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type)) 143 return 0; 144 145 if (!TYPE_SIZE (type)) 146 /* TYPE is being defined, and during that time 147 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */ 148 return 0; 149 150 u = CLASSTYPE_PURE_VIRTUALS (type); 151 if (decl) 152 { 153 if (TREE_CODE (decl) == RESULT_DECL) 154 return 0; 155 156 if (TREE_CODE (decl) == VAR_DECL) 157 error ("cannot declare variable `%D' to be of type `%T'", 158 decl, type); 159 else if (TREE_CODE (decl) == PARM_DECL) 160 error ("cannot declare parameter `%D' to be of type `%T'", 161 decl, type); 162 else if (TREE_CODE (decl) == FIELD_DECL) 163 error ("cannot declare field `%D' to be of type `%T'", 164 decl, type); 165 else if (TREE_CODE (decl) == FUNCTION_DECL 166 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) 167 error ("invalid return type for member function `%#D'", decl); 168 else if (TREE_CODE (decl) == FUNCTION_DECL) 169 error ("invalid return type for function `%#D'", decl); 170 } 171 else 172 error ("cannot allocate an object of type `%T'", type); 173 174 /* Only go through this once. */ 175 if (TREE_PURPOSE (u) == NULL_TREE) 176 { 177 TREE_PURPOSE (u) = error_mark_node; 178 179 error (" because the following virtual functions are abstract:"); 180 for (tu = u; tu; tu = TREE_CHAIN (tu)) 181 cp_error_at ("\t%#D", TREE_VALUE (tu)); 182 } 183 else 184 error (" since type `%T' has abstract virtual functions", type); 185 186 return 1; 187} 188 189/* Print an error message for invalid use of an incomplete type. 190 VALUE is the expression that was used (or 0 if that isn't known) 191 and TYPE is the type that was invalid. DIAG_TYPE indicates the 192 type of diagnostic: 0 for an error, 1 for a warning, 2 for a 193 pedwarn. */ 194 195void 196cxx_incomplete_type_diagnostic (value, type, diag_type) 197 tree value; 198 tree type; 199 int diag_type; 200{ 201 int decl = 0; 202 void (*p_msg) PARAMS ((const char *, ...)); 203 void (*p_msg_at) PARAMS ((const char *, ...)); 204 205 if (diag_type == 1) 206 { 207 p_msg = warning; 208 p_msg_at = cp_warning_at; 209 } 210 else if (diag_type == 2) 211 { 212 p_msg = pedwarn; 213 p_msg_at = cp_pedwarn_at; 214 } 215 else 216 { 217 p_msg = error; 218 p_msg_at = cp_error_at; 219 } 220 221 /* Avoid duplicate error message. */ 222 if (TREE_CODE (type) == ERROR_MARK) 223 return; 224 225 if (value != 0 && (TREE_CODE (value) == VAR_DECL 226 || TREE_CODE (value) == PARM_DECL 227 || TREE_CODE (value) == FIELD_DECL)) 228 { 229 (*p_msg_at) ("`%D' has incomplete type", value); 230 decl = 1; 231 } 232retry: 233 /* We must print an error message. Be clever about what it says. */ 234 235 switch (TREE_CODE (type)) 236 { 237 case RECORD_TYPE: 238 case UNION_TYPE: 239 case ENUMERAL_TYPE: 240 if (!decl) 241 (*p_msg) ("invalid use of undefined type `%#T'", type); 242 if (!TYPE_TEMPLATE_INFO (type)) 243 (*p_msg_at) ("forward declaration of `%#T'", type); 244 else 245 (*p_msg_at) ("declaration of `%#T'", type); 246 break; 247 248 case VOID_TYPE: 249 (*p_msg) ("invalid use of `%T'", type); 250 break; 251 252 case ARRAY_TYPE: 253 if (TYPE_DOMAIN (type)) 254 { 255 type = TREE_TYPE (type); 256 goto retry; 257 } 258 (*p_msg) ("invalid use of array with unspecified bounds"); 259 break; 260 261 case OFFSET_TYPE: 262 bad_member: 263 (*p_msg) ("invalid use of member (did you forget the `&' ?)"); 264 break; 265 266 case TEMPLATE_TYPE_PARM: 267 (*p_msg) ("invalid use of template type parameter"); 268 break; 269 270 case UNKNOWN_TYPE: 271 if (value && TREE_CODE (value) == COMPONENT_REF) 272 goto bad_member; 273 else if (value && TREE_CODE (value) == ADDR_EXPR) 274 (*p_msg) ("address of overloaded function with no contextual type information"); 275 else if (value && TREE_CODE (value) == OVERLOAD) 276 (*p_msg) ("overloaded function with no contextual type information"); 277 else 278 (*p_msg) ("insufficient contextual information to determine type"); 279 break; 280 281 default: 282 (*p_msg) ("invalid use of incomplete type"); 283 break; 284 } 285} 286 287/* Backward-compatibility interface to incomplete_type_diagnostic; 288 required by ../tree.c. */ 289#undef cxx_incomplete_type_error 290void 291cxx_incomplete_type_error (value, type) 292 tree value; 293 tree type; 294{ 295 cxx_incomplete_type_diagnostic (value, type, 0); 296} 297 298 299/* Perform appropriate conversions on the initial value of a variable, 300 store it in the declaration DECL, 301 and print any error messages that are appropriate. 302 If the init is invalid, store an ERROR_MARK. 303 304 C++: Note that INIT might be a TREE_LIST, which would mean that it is 305 a base class initializer for some aggregate type, hopefully compatible 306 with DECL. If INIT is a single element, and DECL is an aggregate 307 type, we silently convert INIT into a TREE_LIST, allowing a constructor 308 to be called. 309 310 If INIT is a TREE_LIST and there is no constructor, turn INIT 311 into a CONSTRUCTOR and use standard initialization techniques. 312 Perhaps a warning should be generated? 313 314 Returns value of initializer if initialization could not be 315 performed for static variable. In that case, caller must do 316 the storing. */ 317 318tree 319store_init_value (decl, init) 320 tree decl, init; 321{ 322 register tree value, type; 323 324 /* If variable's type was invalidly declared, just ignore it. */ 325 326 type = TREE_TYPE (decl); 327 if (TREE_CODE (type) == ERROR_MARK) 328 return NULL_TREE; 329 330 if (IS_AGGR_TYPE (type)) 331 { 332 if (! TYPE_HAS_TRIVIAL_INIT_REF (type) 333 && TREE_CODE (init) != CONSTRUCTOR) 334 abort (); 335 336 if (TREE_CODE (init) == TREE_LIST) 337 { 338 error ("constructor syntax used, but no constructor declared for type `%T'", type); 339 init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init)); 340 } 341 } 342 else if (TREE_CODE (init) == TREE_LIST 343 && TREE_TYPE (init) != unknown_type_node) 344 { 345 if (TREE_CODE (decl) == RESULT_DECL) 346 { 347 if (TREE_CHAIN (init)) 348 { 349 warning ("comma expression used to initialize return value"); 350 init = build_compound_expr (init); 351 } 352 else 353 init = TREE_VALUE (init); 354 } 355 else if (TREE_CODE (init) == TREE_LIST 356 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 357 { 358 error ("cannot initialize arrays using this syntax"); 359 return NULL_TREE; 360 } 361 else 362 { 363 /* We get here with code like `int a (2);' */ 364 365 if (TREE_CHAIN (init) != NULL_TREE) 366 { 367 pedwarn ("initializer list being treated as compound expression"); 368 init = build_compound_expr (init); 369 } 370 else 371 init = TREE_VALUE (init); 372 } 373 } 374 375 /* End of special C++ code. */ 376 377 /* Digest the specified initializer into an expression. */ 378 value = digest_init (type, init, (tree *) 0); 379 380 /* Store the expression if valid; else report error. */ 381 382 if (TREE_CODE (value) == ERROR_MARK) 383 ; 384 /* Other code expects that initializers for objects of types that need 385 constructing never make it into DECL_INITIAL, and passes 'init' to 386 build_aggr_init without checking DECL_INITIAL. So just return. */ 387 else if (TYPE_NEEDS_CONSTRUCTING (type)) 388 return value; 389 else if (TREE_STATIC (decl) 390 && (! TREE_CONSTANT (value) 391 || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) 392 return value; 393 394 /* Store the VALUE in DECL_INITIAL. If we're building a 395 statement-tree we will actually expand the initialization later 396 when we output this function. */ 397 DECL_INITIAL (decl) = value; 398 return NULL_TREE; 399} 400 401 402/* Digest the parser output INIT as an initializer for type TYPE. 403 Return a C expression of type TYPE to represent the initial value. 404 405 If TAIL is nonzero, it points to a variable holding a list of elements 406 of which INIT is the first. We update the list stored there by 407 removing from the head all the elements that we use. 408 Normally this is only one; we use more than one element only if 409 TYPE is an aggregate and INIT is not a constructor. */ 410 411tree 412digest_init (type, init, tail) 413 tree type, init, *tail; 414{ 415 enum tree_code code = TREE_CODE (type); 416 tree element = NULL_TREE; 417 tree old_tail_contents = NULL_TREE; 418 /* Nonzero if INIT is a braced grouping. */ 419 int raw_constructor; 420 421 /* By default, assume we use one element from a list. 422 We correct this later in the sole case where it is not true. */ 423 424 if (tail) 425 { 426 old_tail_contents = *tail; 427 *tail = TREE_CHAIN (*tail); 428 } 429 430 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST 431 && TREE_VALUE (init) == error_mark_node)) 432 return error_mark_node; 433 434 if (TREE_CODE (init) == ERROR_MARK) 435 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside 436 a template function. This gets substituted during instantiation. */ 437 return init; 438 439 /* We must strip the outermost array type when completing the type, 440 because the its bounds might be incomplete at the moment. */ 441 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE 442 ? TREE_TYPE (type) : type, NULL_TREE)) 443 return error_mark_node; 444 445 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 446 if (TREE_CODE (init) == NON_LVALUE_EXPR) 447 init = TREE_OPERAND (init, 0); 448 449 raw_constructor = (TREE_CODE (init) == CONSTRUCTOR 450 && TREE_HAS_CONSTRUCTOR (init)); 451 452 if (raw_constructor 453 && CONSTRUCTOR_ELTS (init) != 0 454 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0) 455 { 456 element = TREE_VALUE (CONSTRUCTOR_ELTS (init)); 457 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 458 if (element && TREE_CODE (element) == NON_LVALUE_EXPR) 459 element = TREE_OPERAND (element, 0); 460 if (element == error_mark_node) 461 return element; 462 } 463 464 /* Initialization of an array of chars from a string constant 465 optionally enclosed in braces. */ 466 467 if (code == ARRAY_TYPE) 468 { 469 tree typ1; 470 471 if (TREE_CODE (init) == TREE_LIST) 472 { 473 error ("initializing array with parameter list"); 474 return error_mark_node; 475 } 476 477 typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 478 if (char_type_p (typ1) 479 && ((init && TREE_CODE (init) == STRING_CST) 480 || (element && TREE_CODE (element) == STRING_CST))) 481 { 482 tree string = element ? element : init; 483 484 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) 485 != char_type_node) 486 && TYPE_PRECISION (typ1) == BITS_PER_UNIT) 487 { 488 error ("char-array initialized from wide string"); 489 return error_mark_node; 490 } 491 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) 492 == char_type_node) 493 && TYPE_PRECISION (typ1) != BITS_PER_UNIT) 494 { 495 error ("int-array initialized from non-wide string"); 496 return error_mark_node; 497 } 498 499 TREE_TYPE (string) = type; 500 if (TYPE_DOMAIN (type) != 0 501 && TREE_CONSTANT (TYPE_SIZE (type))) 502 { 503 register int size 504 = TREE_INT_CST_LOW (TYPE_SIZE (type)); 505 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; 506 /* In C it is ok to subtract 1 from the length of the string 507 because it's ok to ignore the terminating null char that is 508 counted in the length of the constant, but in C++ this would 509 be invalid. */ 510 if (size < TREE_STRING_LENGTH (string)) 511 pedwarn ("initializer-string for array of chars is too long"); 512 } 513 return string; 514 } 515 } 516 517 /* Handle scalar types, including conversions, 518 and signature pointers and references. */ 519 520 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 521 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE 522 || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 523 || TYPE_PTRMEMFUNC_P (type)) 524 { 525 if (raw_constructor) 526 { 527 if (element == 0) 528 { 529 error ("initializer for scalar variable requires one element"); 530 return error_mark_node; 531 } 532 init = element; 533 } 534 while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init)) 535 { 536 pedwarn ("braces around scalar initializer for `%T'", type); 537 init = CONSTRUCTOR_ELTS (init); 538 if (TREE_CHAIN (init)) 539 pedwarn ("ignoring extra initializers for `%T'", type); 540 init = TREE_VALUE (init); 541 } 542 543 return convert_for_initialization (0, type, init, LOOKUP_NORMAL, 544 "initialization", NULL_TREE, 0); 545 } 546 547 /* Come here only for records and arrays (and unions with constructors). */ 548 549 if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type))) 550 { 551 error ("variable-sized object of type `%T' may not be initialized", 552 type); 553 return error_mark_node; 554 } 555 556 if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code)) 557 { 558 if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type) 559 && TREE_HAS_CONSTRUCTOR (init)) 560 { 561 error ("subobject of type `%T' must be initialized by constructor, not by `%E'", 562 type, init); 563 return error_mark_node; 564 } 565 else if (raw_constructor) 566 return process_init_constructor (type, init, (tree *)0); 567 else if (can_convert_arg (type, TREE_TYPE (init), init) 568 || TYPE_NON_AGGREGATE_CLASS (type)) 569 /* These are never initialized from multiple constructor elements. */; 570 else if (tail != 0) 571 { 572 *tail = old_tail_contents; 573 return process_init_constructor (type, 0, tail); 574 } 575 576 if (code != ARRAY_TYPE) 577 { 578 int flags = LOOKUP_NORMAL; 579 /* Initialization from { } is copy-initialization. */ 580 if (tail) 581 flags |= LOOKUP_ONLYCONVERTING; 582 583 return convert_for_initialization (NULL_TREE, type, init, flags, 584 "initialization", NULL_TREE, 0); 585 } 586 } 587 588 error ("invalid initializer"); 589 return error_mark_node; 590} 591 592/* Process a constructor for a variable of type TYPE. 593 The constructor elements may be specified either with INIT or with ELTS, 594 only one of which should be non-null. 595 596 If INIT is specified, it is a CONSTRUCTOR node which is specifically 597 and solely for initializing this datum. 598 599 If ELTS is specified, it is the address of a variable containing 600 a list of expressions. We take as many elements as we need 601 from the head of the list and update the list. 602 603 In the resulting constructor, TREE_CONSTANT is set if all elts are 604 constant, and TREE_STATIC is set if, in addition, all elts are simple enough 605 constants that the assembler and linker can compute them. */ 606 607static tree 608process_init_constructor (type, init, elts) 609 tree type, init, *elts; 610{ 611 register tree tail; 612 /* List of the elements of the result constructor, 613 in reverse order. */ 614 register tree members = NULL; 615 register tree next1; 616 tree result; 617 int allconstant = 1; 618 int allsimple = 1; 619 int erroneous = 0; 620 621 /* Make TAIL be the list of elements to use for the initialization, 622 no matter how the data was given to us. */ 623 624 if (elts) 625 { 626 if (warn_missing_braces) 627 warning ("aggregate has a partly bracketed initializer"); 628 tail = *elts; 629 } 630 else 631 tail = CONSTRUCTOR_ELTS (init); 632 633 /* Gobble as many elements as needed, and make a constructor or initial value 634 for each element of this aggregate. Chain them together in result. 635 If there are too few, use 0 for each scalar ultimate component. */ 636 637 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) 638 { 639 register long len; 640 register int i; 641 642 if (TREE_CODE (type) == ARRAY_TYPE) 643 { 644 tree domain = TYPE_DOMAIN (type); 645 if (domain) 646 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) 647 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) 648 + 1); 649 else 650 len = -1; /* Take as many as there are */ 651 } 652 else 653 { 654 /* Vectors are like simple fixed-size arrays. */ 655 len = TYPE_VECTOR_SUBPARTS (type); 656 } 657 658 for (i = 0; len < 0 || i < len; i++) 659 { 660 if (tail) 661 { 662 if (TREE_PURPOSE (tail) 663 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST 664 || compare_tree_int (TREE_PURPOSE (tail), i) != 0)) 665 sorry ("non-trivial labeled initializers"); 666 667 if (TREE_VALUE (tail) != 0) 668 { 669 tree tail1 = tail; 670 next1 = digest_init (TREE_TYPE (type), 671 TREE_VALUE (tail), &tail1); 672 if (next1 == error_mark_node) 673 return next1; 674 my_friendly_assert 675 (same_type_ignoring_top_level_qualifiers_p 676 (TREE_TYPE (type), TREE_TYPE (next1)), 677 981123); 678 my_friendly_assert (tail1 == 0 679 || TREE_CODE (tail1) == TREE_LIST, 319); 680 if (tail == tail1 && len < 0) 681 { 682 error ("non-empty initializer for array of empty elements"); 683 /* Just ignore what we were supposed to use. */ 684 tail1 = NULL_TREE; 685 } 686 tail = tail1; 687 } 688 else 689 { 690 next1 = error_mark_node; 691 tail = TREE_CHAIN (tail); 692 } 693 } 694 else if (len < 0) 695 /* We're done. */ 696 break; 697 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) 698 { 699 /* If this type needs constructors run for 700 default-initialization, we can't rely on the backend to do it 701 for us, so build up TARGET_EXPRs. If the type in question is 702 a class, just build one up; if it's an array, recurse. */ 703 704 if (IS_AGGR_TYPE (TREE_TYPE (type))) 705 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE); 706 else 707 next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, NULL_TREE); 708 next1 = digest_init (TREE_TYPE (type), next1, 0); 709 } 710 else if (! zero_init_p (TREE_TYPE (type))) 711 next1 = build_zero_init (TREE_TYPE (type), 712 /*nelts=*/NULL_TREE, 713 /*static_storage_p=*/false); 714 else 715 /* The default zero-initialization is fine for us; don't 716 add anything to the CONSTRUCTOR. */ 717 break; 718 719 if (next1 == error_mark_node) 720 erroneous = 1; 721 else if (!TREE_CONSTANT (next1)) 722 allconstant = 0; 723 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) 724 allsimple = 0; 725 members = tree_cons (size_int (i), next1, members); 726 } 727 } 728 else if (TREE_CODE (type) == RECORD_TYPE) 729 { 730 register tree field; 731 732 if (tail) 733 { 734 if (TYPE_USES_VIRTUAL_BASECLASSES (type)) 735 { 736 sorry ("initializer list for object of class with virtual base classes"); 737 return error_mark_node; 738 } 739 740 if (TYPE_BINFO_BASETYPES (type)) 741 { 742 sorry ("initializer list for object of class with base classes"); 743 return error_mark_node; 744 } 745 746 if (TYPE_POLYMORPHIC_P (type)) 747 { 748 sorry ("initializer list for object using virtual functions"); 749 return error_mark_node; 750 } 751 } 752 753 for (field = TYPE_FIELDS (type); field; 754 field = TREE_CHAIN (field)) 755 { 756 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field)) 757 { 758 members = tree_cons (field, integer_zero_node, members); 759 continue; 760 } 761 762 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 763 continue; 764 765 if (tail) 766 { 767 if (TREE_PURPOSE (tail) 768 && TREE_PURPOSE (tail) != field 769 && TREE_PURPOSE (tail) != DECL_NAME (field)) 770 sorry ("non-trivial labeled initializers"); 771 772 if (TREE_VALUE (tail) != 0) 773 { 774 tree tail1 = tail; 775 776 next1 = digest_init (TREE_TYPE (field), 777 TREE_VALUE (tail), &tail1); 778 my_friendly_assert (tail1 == 0 779 || TREE_CODE (tail1) == TREE_LIST, 320); 780 tail = tail1; 781 } 782 else 783 { 784 next1 = error_mark_node; 785 tail = TREE_CHAIN (tail); 786 } 787 } 788 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) 789 { 790 /* If this type needs constructors run for 791 default-initialization, we can't rely on the backend to do it 792 for us, so build up TARGET_EXPRs. If the type in question is 793 a class, just build one up; if it's an array, recurse. */ 794 795 if (IS_AGGR_TYPE (TREE_TYPE (field))) 796 next1 = build_functional_cast (TREE_TYPE (field), 797 NULL_TREE); 798 else 799 { 800 next1 = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, 801 NULL_TREE); 802 if (init) 803 TREE_HAS_CONSTRUCTOR (next1) 804 = TREE_HAS_CONSTRUCTOR (init); 805 } 806 next1 = digest_init (TREE_TYPE (field), next1, 0); 807 808 /* Warn when some struct elements are implicitly initialized. */ 809 if (extra_warnings 810 && (!init || TREE_HAS_CONSTRUCTOR (init))) 811 warning ("missing initializer for member `%D'", field); 812 } 813 else 814 { 815 if (TREE_READONLY (field)) 816 error ("uninitialized const member `%D'", field); 817 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) 818 error ("member `%D' with uninitialized const fields", 819 field); 820 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) 821 error ("member `%D' is uninitialized reference", field); 822 823 /* Warn when some struct elements are implicitly initialized 824 to zero. */ 825 if (extra_warnings 826 && (!init || TREE_HAS_CONSTRUCTOR (init))) 827 warning ("missing initializer for member `%D'", field); 828 829 if (! zero_init_p (TREE_TYPE (field))) 830 next1 = build_zero_init (TREE_TYPE (field), 831 /*nelts=*/NULL_TREE, 832 /*static_storage_p=*/false); 833 else 834 /* The default zero-initialization is fine for us; don't 835 add anything to the CONSTRUCTOR. */ 836 continue; 837 } 838 839 if (next1 == error_mark_node) 840 erroneous = 1; 841 else if (!TREE_CONSTANT (next1)) 842 allconstant = 0; 843 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) 844 allsimple = 0; 845 members = tree_cons (field, next1, members); 846 } 847 } 848 else if (TREE_CODE (type) == UNION_TYPE 849 /* If the initializer was empty, use default zero initialization. */ 850 && tail) 851 { 852 register tree field = TYPE_FIELDS (type); 853 854 /* Find the first named field. ANSI decided in September 1990 855 that only named fields count here. */ 856 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL)) 857 field = TREE_CHAIN (field); 858 859 /* If this element specifies a field, initialize via that field. */ 860 if (TREE_PURPOSE (tail) != NULL_TREE) 861 { 862 int win = 0; 863 864 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL) 865 /* Handle the case of a call by build_c_cast. */ 866 field = TREE_PURPOSE (tail), win = 1; 867 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE) 868 error ("index value instead of field name in union initializer"); 869 else 870 { 871 tree temp; 872 for (temp = TYPE_FIELDS (type); 873 temp; 874 temp = TREE_CHAIN (temp)) 875 if (DECL_NAME (temp) == TREE_PURPOSE (tail)) 876 break; 877 if (temp) 878 field = temp, win = 1; 879 else 880 error ("no field `%D' in union being initialized", 881 TREE_PURPOSE (tail)); 882 } 883 if (!win) 884 TREE_VALUE (tail) = error_mark_node; 885 } 886 else if (field == 0) 887 { 888 error ("union `%T' with no named members cannot be initialized", 889 type); 890 TREE_VALUE (tail) = error_mark_node; 891 } 892 893 if (TREE_VALUE (tail) != 0) 894 { 895 tree tail1 = tail; 896 897 next1 = digest_init (TREE_TYPE (field), 898 TREE_VALUE (tail), &tail1); 899 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST) 900 abort (); 901 tail = tail1; 902 } 903 else 904 { 905 next1 = error_mark_node; 906 tail = TREE_CHAIN (tail); 907 } 908 909 if (next1 == error_mark_node) 910 erroneous = 1; 911 else if (!TREE_CONSTANT (next1)) 912 allconstant = 0; 913 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0) 914 allsimple = 0; 915 members = tree_cons (field, next1, members); 916 } 917 918 /* If arguments were specified as a list, just remove the ones we used. */ 919 if (elts) 920 *elts = tail; 921 /* If arguments were specified as a constructor, 922 complain unless we used all the elements of the constructor. */ 923 else if (tail) 924 pedwarn ("excess elements in aggregate initializer"); 925 926 if (erroneous) 927 return error_mark_node; 928 929 result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members)); 930 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE) 931 complete_array_type (type, result, /*do_default=*/0); 932 if (init) 933 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init); 934 if (allconstant) TREE_CONSTANT (result) = 1; 935 if (allconstant && allsimple) TREE_STATIC (result) = 1; 936 return result; 937} 938 939/* Given a structure or union value DATUM, construct and return 940 the structure or union component which results from narrowing 941 that value to the base specified in BASETYPE. For example, given the 942 hierarchy 943 944 class L { int ii; }; 945 class A : L { ... }; 946 class B : L { ... }; 947 class C : A, B { ... }; 948 949 and the declaration 950 951 C x; 952 953 then the expression 954 955 x.A::ii refers to the ii member of the L part of 956 the A part of the C object named by X. In this case, 957 DATUM would be x, and BASETYPE would be A. 958 959 I used to think that this was nonconformant, that the standard specified 960 that first we look up ii in A, then convert x to an L& and pull out the 961 ii part. But in fact, it does say that we convert x to an A&; A here 962 is known as the "naming class". (jason 2000-12-19) 963 964 BINFO_P points to a variable initialized either to NULL_TREE or to the 965 binfo for the specific base subobject we want to convert to. */ 966 967tree 968build_scoped_ref (datum, basetype, binfo_p) 969 tree datum; 970 tree basetype; 971 tree *binfo_p; 972{ 973 tree binfo; 974 975 if (datum == error_mark_node) 976 return error_mark_node; 977 if (*binfo_p) 978 binfo = *binfo_p; 979 else 980 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL); 981 982 if (!binfo || binfo == error_mark_node) 983 { 984 *binfo_p = NULL_TREE; 985 if (!binfo) 986 error_not_base_type (basetype, TREE_TYPE (datum)); 987 return error_mark_node; 988 } 989 990 *binfo_p = binfo; 991 return build_base_path (PLUS_EXPR, datum, binfo, 1); 992} 993 994/* Build a reference to an object specified by the C++ `->' operator. 995 Usually this just involves dereferencing the object, but if the 996 `->' operator is overloaded, then such overloads must be 997 performed until an object which does not have the `->' operator 998 overloaded is found. An error is reported when circular pointer 999 delegation is detected. */ 1000 1001tree 1002build_x_arrow (datum) 1003 tree datum; 1004{ 1005 tree types_memoized = NULL_TREE; 1006 register tree rval = datum; 1007 tree type = TREE_TYPE (rval); 1008 tree last_rval = NULL_TREE; 1009 1010 if (type == error_mark_node) 1011 return error_mark_node; 1012 1013 if (processing_template_decl) 1014 return build_min_nt (ARROW_EXPR, rval); 1015 1016 if (TREE_CODE (rval) == OFFSET_REF) 1017 { 1018 rval = resolve_offset_ref (datum); 1019 type = TREE_TYPE (rval); 1020 } 1021 1022 if (TREE_CODE (type) == REFERENCE_TYPE) 1023 { 1024 rval = convert_from_reference (rval); 1025 type = TREE_TYPE (rval); 1026 } 1027 1028 if (IS_AGGR_TYPE (type)) 1029 { 1030 while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, 1031 NULL_TREE, NULL_TREE))) 1032 { 1033 if (rval == error_mark_node) 1034 return error_mark_node; 1035 1036 if (value_member (TREE_TYPE (rval), types_memoized)) 1037 { 1038 error ("circular pointer delegation detected"); 1039 return error_mark_node; 1040 } 1041 else 1042 { 1043 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval), 1044 types_memoized); 1045 } 1046 last_rval = rval; 1047 } 1048 1049 if (last_rval == NULL_TREE) 1050 { 1051 error ("base operand of `->' has non-pointer type `%T'", type); 1052 return error_mark_node; 1053 } 1054 1055 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE) 1056 last_rval = convert_from_reference (last_rval); 1057 } 1058 else 1059 last_rval = default_conversion (rval); 1060 1061 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE) 1062 return build_indirect_ref (last_rval, NULL); 1063 1064 if (types_memoized) 1065 error ("result of `operator->()' yields non-pointer result"); 1066 else 1067 error ("base operand of `->' is not a pointer"); 1068 return error_mark_node; 1069} 1070 1071/* Make an expression to refer to the COMPONENT field of 1072 structure or union value DATUM. COMPONENT is an arbitrary 1073 expression. DATUM has not already been checked out to be of 1074 aggregate type. 1075 1076 For C++, COMPONENT may be a TREE_LIST. This happens when we must 1077 return an object of member type to a method of the current class, 1078 but there is not yet enough typing information to know which one. 1079 As a special case, if there is only one method by that name, 1080 it is returned. Otherwise we return an expression which other 1081 routines will have to know how to deal with later. */ 1082 1083tree 1084build_m_component_ref (datum, component) 1085 tree datum, component; 1086{ 1087 tree type; 1088 tree objtype; 1089 tree field_type; 1090 int type_quals; 1091 tree binfo; 1092 1093 if (processing_template_decl) 1094 return build_min_nt (DOTSTAR_EXPR, datum, component); 1095 1096 datum = decay_conversion (datum); 1097 1098 if (datum == error_mark_node || component == error_mark_node) 1099 return error_mark_node; 1100 1101 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); 1102 1103 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component))) 1104 { 1105 type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component))); 1106 field_type = type; 1107 } 1108 else if (TYPE_PTRMEM_P (TREE_TYPE (component))) 1109 { 1110 type = TREE_TYPE (TREE_TYPE (component)); 1111 field_type = TREE_TYPE (type); 1112 1113 /* Compute the type of the field, as described in [expr.ref]. */ 1114 type_quals = TYPE_UNQUALIFIED; 1115 if (TREE_CODE (field_type) == REFERENCE_TYPE) 1116 /* The standard says that the type of the result should be the 1117 type referred to by the reference. But for now, at least, 1118 we do the conversion from reference type later. */ 1119 ; 1120 else 1121 { 1122 type_quals = (cp_type_quals (field_type) 1123 | cp_type_quals (TREE_TYPE (datum))); 1124 1125 /* There's no such thing as a mutable pointer-to-member, so 1126 things are not as complex as they are for references to 1127 non-static data members. */ 1128 field_type = cp_build_qualified_type (field_type, type_quals); 1129 } 1130 } 1131 else 1132 { 1133 error ("`%E' cannot be used as a member pointer, since it is of type `%T'", 1134 component, TREE_TYPE (component)); 1135 return error_mark_node; 1136 } 1137 1138 if (! IS_AGGR_TYPE (objtype)) 1139 { 1140 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'", 1141 component, datum, objtype); 1142 return error_mark_node; 1143 } 1144 1145 binfo = lookup_base (objtype, TYPE_METHOD_BASETYPE (type), 1146 ba_check, NULL); 1147 if (!binfo) 1148 { 1149 error ("member type `%T::' incompatible with object type `%T'", 1150 TYPE_METHOD_BASETYPE (type), objtype); 1151 return error_mark_node; 1152 } 1153 else if (binfo == error_mark_node) 1154 return error_mark_node; 1155 1156 component = build (OFFSET_REF, field_type, datum, component); 1157 if (TREE_CODE (type) == OFFSET_TYPE) 1158 component = resolve_offset_ref (component); 1159 return component; 1160} 1161 1162/* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ 1163 1164tree 1165build_functional_cast (exp, parms) 1166 tree exp; 1167 tree parms; 1168{ 1169 /* This is either a call to a constructor, 1170 or a C cast in C++'s `functional' notation. */ 1171 tree type; 1172 1173 if (exp == error_mark_node || parms == error_mark_node) 1174 return error_mark_node; 1175 1176 if (TREE_CODE (exp) == IDENTIFIER_NODE) 1177 { 1178 if (IDENTIFIER_HAS_TYPE_VALUE (exp)) 1179 /* Either an enum or an aggregate type. */ 1180 type = IDENTIFIER_TYPE_VALUE (exp); 1181 else 1182 { 1183 type = lookup_name (exp, 1); 1184 if (!type || TREE_CODE (type) != TYPE_DECL) 1185 { 1186 error ("`%T' fails to be a typedef or built-in type", exp); 1187 return error_mark_node; 1188 } 1189 type = TREE_TYPE (type); 1190 } 1191 } 1192 else if (TREE_CODE (exp) == TYPE_DECL) 1193 type = TREE_TYPE (exp); 1194 else 1195 type = exp; 1196 1197 if (processing_template_decl) 1198 return build_min (CAST_EXPR, type, parms); 1199 1200 if (! IS_AGGR_TYPE (type)) 1201 { 1202 /* this must build a C cast */ 1203 if (parms == NULL_TREE) 1204 parms = integer_zero_node; 1205 else 1206 { 1207 if (TREE_CHAIN (parms) != NULL_TREE) 1208 pedwarn ("initializer list being treated as compound expression"); 1209 parms = build_compound_expr (parms); 1210 } 1211 1212 return build_c_cast (type, parms); 1213 } 1214 1215 /* Prepare to evaluate as a call to a constructor. If this expression 1216 is actually used, for example, 1217 1218 return X (arg1, arg2, ...); 1219 1220 then the slot being initialized will be filled in. */ 1221 1222 if (!complete_type_or_else (type, NULL_TREE)) 1223 return error_mark_node; 1224 if (abstract_virtuals_error (NULL_TREE, type)) 1225 return error_mark_node; 1226 1227 if (parms && TREE_CHAIN (parms) == NULL_TREE) 1228 return build_c_cast (type, TREE_VALUE (parms)); 1229 1230 /* We need to zero-initialize POD types. Let's do that for everything 1231 that doesn't need a constructor. */ 1232 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type) 1233 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 1234 { 1235 exp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE); 1236 return get_target_expr (exp); 1237 } 1238 1239 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms, 1240 TYPE_BINFO (type), LOOKUP_NORMAL); 1241 1242 if (exp == error_mark_node) 1243 return error_mark_node; 1244 1245 return build_cplus_new (type, exp); 1246} 1247 1248 1249/* Complain about defining new types in inappropriate places. We give an 1250 exception for C-style casts, to accommodate GNU C stylings. */ 1251 1252void 1253check_for_new_type (string, inptree) 1254 const char *string; 1255 flagged_type_tree inptree; 1256{ 1257 if (inptree.new_type_flag 1258 && (pedantic || strcmp (string, "cast") != 0)) 1259 pedwarn ("ISO C++ forbids defining types within %s", string); 1260} 1261 1262/* Add new exception specifier SPEC, to the LIST we currently have. 1263 If it's already in LIST then do nothing. 1264 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we 1265 know what we're doing. */ 1266 1267tree 1268add_exception_specifier (list, spec, complain) 1269 tree list, spec; 1270 int complain; 1271{ 1272 int ok; 1273 tree core = spec; 1274 int is_ptr; 1275 int diag_type = -1; /* none */ 1276 1277 if (spec == error_mark_node) 1278 return list; 1279 1280 my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317); 1281 1282 /* [except.spec] 1, type in an exception specifier shall not be 1283 incomplete, or pointer or ref to incomplete other than pointer 1284 to cv void. */ 1285 is_ptr = TREE_CODE (core) == POINTER_TYPE; 1286 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE) 1287 core = TREE_TYPE (core); 1288 if (complain < 0) 1289 ok = 1; 1290 else if (VOID_TYPE_P (core)) 1291 ok = is_ptr; 1292 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM) 1293 ok = 1; 1294 else if (processing_template_decl) 1295 ok = 1; 1296 else 1297 { 1298 ok = 1; 1299 /* 15.4/1 says that types in an exception specifier must be complete, 1300 but it seems more reasonable to only require this on definitions 1301 and calls. So just give a pedwarn at this point; we will give an 1302 error later if we hit one of those two cases. */ 1303 if (!COMPLETE_TYPE_P (complete_type (core))) 1304 diag_type = 2; /* pedwarn */ 1305 } 1306 1307 if (ok) 1308 { 1309 tree probe; 1310 1311 for (probe = list; probe; probe = TREE_CHAIN (probe)) 1312 if (same_type_p (TREE_VALUE (probe), spec)) 1313 break; 1314 if (!probe) 1315 list = tree_cons (NULL_TREE, spec, list); 1316 } 1317 else 1318 diag_type = 0; /* error */ 1319 1320 if (diag_type >= 0 && complain) 1321 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); 1322 1323 return list; 1324} 1325 1326/* Combine the two exceptions specifier lists LIST and ADD, and return 1327 their union. */ 1328 1329tree 1330merge_exception_specifiers (list, add) 1331 tree list, add; 1332{ 1333 if (!list || !add) 1334 return NULL_TREE; 1335 else if (!TREE_VALUE (list)) 1336 return add; 1337 else if (!TREE_VALUE (add)) 1338 return list; 1339 else 1340 { 1341 tree orig_list = list; 1342 1343 for (; add; add = TREE_CHAIN (add)) 1344 { 1345 tree spec = TREE_VALUE (add); 1346 tree probe; 1347 1348 for (probe = orig_list; probe; probe = TREE_CHAIN (probe)) 1349 if (same_type_p (TREE_VALUE (probe), spec)) 1350 break; 1351 if (!probe) 1352 { 1353 spec = build_tree_list (NULL_TREE, spec); 1354 TREE_CHAIN (spec) = list; 1355 list = spec; 1356 } 1357 } 1358 } 1359 return list; 1360} 1361 1362/* Subroutine of build_call. Ensure that each of the types in the 1363 exception specification is complete. Technically, 15.4/1 says that 1364 they need to be complete when we see a declaration of the function, 1365 but we should be able to get away with only requiring this when the 1366 function is defined or called. See also add_exception_specifier. */ 1367 1368void 1369require_complete_eh_spec_types (fntype, decl) 1370 tree fntype, decl; 1371{ 1372 tree raises; 1373 /* Don't complain about calls to op new. */ 1374 if (decl && DECL_ARTIFICIAL (decl)) 1375 return; 1376 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises; 1377 raises = TREE_CHAIN (raises)) 1378 { 1379 tree type = TREE_VALUE (raises); 1380 if (type && !COMPLETE_TYPE_P (type)) 1381 { 1382 if (decl) 1383 error 1384 ("call to function `%D' which throws incomplete type `%#T'", 1385 decl, type); 1386 else 1387 error ("call to function which throws incomplete type `%#T'", 1388 decl); 1389 } 1390 } 1391} 1392