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, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 Hacked by Michael Tiemann (tiemann@cygnus.com) 7 8 This file is part of GCC. 9 10 GCC is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3, or (at your option) 13 any later version. 14 15 GCC is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with GCC; see the file COPYING3. If not see 22 <http://www.gnu.org/licenses/>. */ 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 #include "config.h" 31 #include "system.h" 32 #include "coretypes.h" 33 #include "tm.h" 34 #include "tree.h" 35 #include "intl.h" 36 #include "cp-tree.h" 37 #include "flags.h" 38 #include "output.h" 39 #include "diagnostic-core.h" 40 41 static tree 42 process_init_constructor (tree type, tree init, tsubst_flags_t complain); 43 44 45 /* Print an error message stemming from an attempt to use 46 BASETYPE as a base class for TYPE. */ 47 48 tree 49 error_not_base_type (tree basetype, tree type) 50 { 51 if (TREE_CODE (basetype) == FUNCTION_DECL) 52 basetype = DECL_CONTEXT (basetype); 53 error ("type %qT is not a base type for type %qT", basetype, type); 54 return error_mark_node; 55 } 56 57 tree 58 binfo_or_else (tree base, tree type) 59 { 60 tree binfo = lookup_base (type, base, ba_unique, NULL); 61 62 if (binfo == error_mark_node) 63 return NULL_TREE; 64 else if (!binfo) 65 error_not_base_type (base, type); 66 return binfo; 67 } 68 69 /* According to ARM $7.1.6, "A `const' object may be initialized, but its 70 value may not be changed thereafter. */ 71 72 void 73 cxx_readonly_error (tree arg, enum lvalue_use errstring) 74 { 75 76 /* This macro is used to emit diagnostics to ensure that all format 77 strings are complete sentences, visible to gettext and checked at 78 compile time. */ 79 80 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \ 81 do { \ 82 switch (errstring) \ 83 { \ 84 case lv_assign: \ 85 error(AS, ARG); \ 86 break; \ 87 case lv_asm: \ 88 error(ASM, ARG); \ 89 break; \ 90 case lv_increment: \ 91 error (IN, ARG); \ 92 break; \ 93 case lv_decrement: \ 94 error (DE, ARG); \ 95 break; \ 96 default: \ 97 gcc_unreachable (); \ 98 } \ 99 } while (0) 100 101 /* Handle C++-specific things first. */ 102 103 if (TREE_CODE (arg) == VAR_DECL 104 && DECL_LANG_SPECIFIC (arg) 105 && DECL_IN_AGGR_P (arg) 106 && !TREE_STATIC (arg)) 107 ERROR_FOR_ASSIGNMENT (G_("assignment of " 108 "constant field %qD"), 109 G_("constant field %qD " 110 "used as %<asm%> output"), 111 G_("increment of " 112 "constant field %qD"), 113 G_("decrement of " 114 "constant field %qD"), 115 arg); 116 else if (TREE_CODE (arg) == INDIRECT_REF 117 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE 118 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL 119 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) 120 ERROR_FOR_ASSIGNMENT (G_("assignment of " 121 "read-only reference %qD"), 122 G_("read-only reference %qD " 123 "used as %<asm%> output"), 124 G_("increment of " 125 "read-only reference %qD"), 126 G_("decrement of " 127 "read-only reference %qD"), 128 TREE_OPERAND (arg, 0)); 129 else 130 readonly_error (arg, errstring); 131 } 132 133 134 /* Structure that holds information about declarations whose type was 135 incomplete and we could not check whether it was abstract or not. */ 136 137 struct GTY((chain_next ("%h.next"))) pending_abstract_type { 138 /* Declaration which we are checking for abstractness. It is either 139 a DECL node, or an IDENTIFIER_NODE if we do not have a full 140 declaration available. */ 141 tree decl; 142 143 /* Type which will be checked for abstractness. */ 144 tree type; 145 146 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs, 147 because DECLs already carry locus information. */ 148 location_t locus; 149 150 /* Link to the next element in list. */ 151 struct pending_abstract_type* next; 152 }; 153 154 155 /* Compute the hash value of the node VAL. This function is used by the 156 hash table abstract_pending_vars. */ 157 158 static hashval_t 159 pat_calc_hash (const void* val) 160 { 161 const struct pending_abstract_type *pat = 162 (const struct pending_abstract_type *) val; 163 return (hashval_t) TYPE_UID (pat->type); 164 } 165 166 167 /* Compare node VAL1 with the type VAL2. This function is used by the 168 hash table abstract_pending_vars. */ 169 170 static int 171 pat_compare (const void* val1, const void* val2) 172 { 173 const struct pending_abstract_type *const pat1 = 174 (const struct pending_abstract_type *) val1; 175 const_tree const type2 = (const_tree)val2; 176 177 return (pat1->type == type2); 178 } 179 180 /* Hash table that maintains pending_abstract_type nodes, for which we still 181 need to check for type abstractness. The key of the table is the type 182 of the declaration. */ 183 static GTY ((param_is (struct pending_abstract_type))) 184 htab_t abstract_pending_vars = NULL; 185 186 187 /* This function is called after TYPE is completed, and will check if there 188 are pending declarations for which we still need to verify the abstractness 189 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE 190 turned out to be incomplete. */ 191 192 void 193 complete_type_check_abstract (tree type) 194 { 195 void **slot; 196 struct pending_abstract_type *pat; 197 location_t cur_loc = input_location; 198 199 gcc_assert (COMPLETE_TYPE_P (type)); 200 201 if (!abstract_pending_vars) 202 return; 203 204 /* Retrieve the list of pending declarations for this type. */ 205 slot = htab_find_slot_with_hash (abstract_pending_vars, type, 206 (hashval_t)TYPE_UID (type), NO_INSERT); 207 if (!slot) 208 return; 209 pat = (struct pending_abstract_type*)*slot; 210 gcc_assert (pat); 211 212 /* If the type is not abstract, do not do anything. */ 213 if (CLASSTYPE_PURE_VIRTUALS (type)) 214 { 215 struct pending_abstract_type *prev = 0, *next; 216 217 /* Reverse the list to emit the errors in top-down order. */ 218 for (; pat; pat = next) 219 { 220 next = pat->next; 221 pat->next = prev; 222 prev = pat; 223 } 224 pat = prev; 225 226 /* Go through the list, and call abstract_virtuals_error for each 227 element: it will issue a diagnostic if the type is abstract. */ 228 while (pat) 229 { 230 gcc_assert (type == pat->type); 231 232 /* Tweak input_location so that the diagnostic appears at the correct 233 location. Notice that this is only needed if the decl is an 234 IDENTIFIER_NODE. */ 235 input_location = pat->locus; 236 abstract_virtuals_error (pat->decl, pat->type); 237 pat = pat->next; 238 } 239 } 240 241 htab_clear_slot (abstract_pending_vars, slot); 242 243 input_location = cur_loc; 244 } 245 246 247 /* If TYPE has abstract virtual functions, issue an error about trying 248 to create an object of that type. DECL is the object declared, or 249 NULL_TREE if the declaration is unavailable. Returns 1 if an error 250 occurred; zero if all was well. */ 251 252 int 253 abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) 254 { 255 VEC(tree,gc) *pure; 256 257 /* This function applies only to classes. Any other entity can never 258 be abstract. */ 259 if (!CLASS_TYPE_P (type)) 260 return 0; 261 type = TYPE_MAIN_VARIANT (type); 262 263 /* If the type is incomplete, we register it within a hash table, 264 so that we can check again once it is completed. This makes sense 265 only for objects for which we have a declaration or at least a 266 name. */ 267 if (!COMPLETE_TYPE_P (type)) 268 { 269 void **slot; 270 struct pending_abstract_type *pat; 271 272 gcc_assert (!decl || DECL_P (decl) 273 || TREE_CODE (decl) == IDENTIFIER_NODE); 274 275 if (!abstract_pending_vars) 276 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash, 277 &pat_compare, NULL); 278 279 slot = htab_find_slot_with_hash (abstract_pending_vars, type, 280 (hashval_t)TYPE_UID (type), INSERT); 281 282 pat = ggc_alloc_pending_abstract_type (); 283 pat->type = type; 284 pat->decl = decl; 285 pat->locus = ((decl && DECL_P (decl)) 286 ? DECL_SOURCE_LOCATION (decl) 287 : input_location); 288 289 pat->next = (struct pending_abstract_type *) *slot; 290 *slot = pat; 291 292 return 0; 293 } 294 295 if (!TYPE_SIZE (type)) 296 /* TYPE is being defined, and during that time 297 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */ 298 return 0; 299 300 pure = CLASSTYPE_PURE_VIRTUALS (type); 301 if (!pure) 302 return 0; 303 304 if (!(complain & tf_error)) 305 return 1; 306 307 if (decl) 308 { 309 if (TREE_CODE (decl) == VAR_DECL) 310 error ("cannot declare variable %q+D to be of abstract " 311 "type %qT", decl, type); 312 else if (TREE_CODE (decl) == PARM_DECL) 313 error ("cannot declare parameter %q+D to be of abstract type %qT", 314 decl, type); 315 else if (TREE_CODE (decl) == FIELD_DECL) 316 error ("cannot declare field %q+D to be of abstract type %qT", 317 decl, type); 318 else if (TREE_CODE (decl) == FUNCTION_DECL 319 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) 320 error ("invalid abstract return type for member function %q+#D", decl); 321 else if (TREE_CODE (decl) == FUNCTION_DECL) 322 error ("invalid abstract return type for function %q+#D", decl); 323 else if (TREE_CODE (decl) == IDENTIFIER_NODE) 324 /* Here we do not have location information. */ 325 error ("invalid abstract type %qT for %qE", type, decl); 326 else 327 error ("invalid abstract type for %q+D", decl); 328 } 329 else 330 error ("cannot allocate an object of abstract type %qT", type); 331 332 /* Only go through this once. */ 333 if (VEC_length (tree, pure)) 334 { 335 unsigned ix; 336 tree fn; 337 338 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), 339 " because the following virtual functions are pure within %qT:", 340 type); 341 342 FOR_EACH_VEC_ELT (tree, pure, ix, fn) 343 if (! DECL_CLONED_FUNCTION_P (fn) 344 || DECL_COMPLETE_DESTRUCTOR_P (fn)) 345 inform (input_location, "\t%+#D", fn); 346 347 /* Now truncate the vector. This leaves it non-null, so we know 348 there are pure virtuals, but empty so we don't list them out 349 again. */ 350 VEC_truncate (tree, pure, 0); 351 } 352 else 353 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), 354 " since type %qT has pure virtual functions", 355 type); 356 357 return 1; 358 } 359 360 /* Wrapper for the above function in the common case of wanting errors. */ 361 362 int 363 abstract_virtuals_error (tree decl, tree type) 364 { 365 return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error); 366 } 367 368 /* Print an error message for invalid use of an incomplete type. 369 VALUE is the expression that was used (or 0 if that isn't known) 370 and TYPE is the type that was invalid. DIAG_KIND indicates the 371 type of diagnostic (see diagnostic.def). */ 372 373 void 374 cxx_incomplete_type_diagnostic (const_tree value, const_tree type, 375 diagnostic_t diag_kind) 376 { 377 int decl = 0; 378 379 gcc_assert (diag_kind == DK_WARNING 380 || diag_kind == DK_PEDWARN 381 || diag_kind == DK_ERROR); 382 383 /* Avoid duplicate error message. */ 384 if (TREE_CODE (type) == ERROR_MARK) 385 return; 386 387 if (value != 0 && (TREE_CODE (value) == VAR_DECL 388 || TREE_CODE (value) == PARM_DECL 389 || TREE_CODE (value) == FIELD_DECL)) 390 { 391 emit_diagnostic (diag_kind, input_location, 0, 392 "%q+D has incomplete type", value); 393 decl = 1; 394 } 395 retry: 396 /* We must print an error message. Be clever about what it says. */ 397 398 switch (TREE_CODE (type)) 399 { 400 case RECORD_TYPE: 401 case UNION_TYPE: 402 case ENUMERAL_TYPE: 403 if (!decl) 404 emit_diagnostic (diag_kind, input_location, 0, 405 "invalid use of incomplete type %q#T", type); 406 if (!TYPE_TEMPLATE_INFO (type)) 407 emit_diagnostic (diag_kind, input_location, 0, 408 "forward declaration of %q+#T", type); 409 else 410 emit_diagnostic (diag_kind, input_location, 0, 411 "declaration of %q+#T", type); 412 break; 413 414 case VOID_TYPE: 415 emit_diagnostic (diag_kind, input_location, 0, 416 "invalid use of %qT", type); 417 break; 418 419 case ARRAY_TYPE: 420 if (TYPE_DOMAIN (type)) 421 { 422 type = TREE_TYPE (type); 423 goto retry; 424 } 425 emit_diagnostic (diag_kind, input_location, 0, 426 "invalid use of array with unspecified bounds"); 427 break; 428 429 case OFFSET_TYPE: 430 bad_member: 431 { 432 tree member = TREE_OPERAND (value, 1); 433 if (is_overloaded_fn (member)) 434 member = get_first_fn (member); 435 if (DECL_FUNCTION_MEMBER_P (member) 436 && ! flag_ms_extensions) 437 emit_diagnostic (diag_kind, input_location, 0, 438 "invalid use of member function " 439 "(did you forget the %<()%> ?)"); 440 else 441 emit_diagnostic (diag_kind, input_location, 0, 442 "invalid use of member " 443 "(did you forget the %<&%> ?)"); 444 } 445 break; 446 447 case TEMPLATE_TYPE_PARM: 448 if (is_auto (type)) 449 emit_diagnostic (diag_kind, input_location, 0, 450 "invalid use of %<auto%>"); 451 else 452 emit_diagnostic (diag_kind, input_location, 0, 453 "invalid use of template type parameter %qT", type); 454 break; 455 456 case BOUND_TEMPLATE_TEMPLATE_PARM: 457 emit_diagnostic (diag_kind, input_location, 0, 458 "invalid use of template template parameter %qT", 459 TYPE_NAME (type)); 460 break; 461 462 case TYPENAME_TYPE: 463 emit_diagnostic (diag_kind, input_location, 0, 464 "invalid use of dependent type %qT", type); 465 break; 466 467 case LANG_TYPE: 468 if (type == init_list_type_node) 469 { 470 emit_diagnostic (diag_kind, input_location, 0, 471 "invalid use of brace-enclosed initializer list"); 472 break; 473 } 474 gcc_assert (type == unknown_type_node); 475 if (value && TREE_CODE (value) == COMPONENT_REF) 476 goto bad_member; 477 else if (value && TREE_CODE (value) == ADDR_EXPR) 478 emit_diagnostic (diag_kind, input_location, 0, 479 "address of overloaded function with no contextual " 480 "type information"); 481 else if (value && TREE_CODE (value) == OVERLOAD) 482 emit_diagnostic (diag_kind, input_location, 0, 483 "overloaded function with no contextual type information"); 484 else 485 emit_diagnostic (diag_kind, input_location, 0, 486 "insufficient contextual information to determine type"); 487 break; 488 489 default: 490 gcc_unreachable (); 491 } 492 } 493 494 /* Backward-compatibility interface to incomplete_type_diagnostic; 495 required by ../tree.c. */ 496 #undef cxx_incomplete_type_error 497 void 498 cxx_incomplete_type_error (const_tree value, const_tree type) 499 { 500 cxx_incomplete_type_diagnostic (value, type, DK_ERROR); 501 } 502 503 504 /* The recursive part of split_nonconstant_init. DEST is an lvalue 505 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. 506 Return true if the whole of the value was initialized by the 507 generated statements. */ 508 509 static bool 510 split_nonconstant_init_1 (tree dest, tree init) 511 { 512 unsigned HOST_WIDE_INT idx; 513 tree field_index, value; 514 tree type = TREE_TYPE (dest); 515 tree inner_type = NULL; 516 bool array_type_p = false; 517 bool complete_p = true; 518 HOST_WIDE_INT num_split_elts = 0; 519 520 switch (TREE_CODE (type)) 521 { 522 case ARRAY_TYPE: 523 inner_type = TREE_TYPE (type); 524 array_type_p = true; 525 /* FALLTHRU */ 526 527 case RECORD_TYPE: 528 case UNION_TYPE: 529 case QUAL_UNION_TYPE: 530 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, 531 field_index, value) 532 { 533 /* The current implementation of this algorithm assumes that 534 the field was set for all the elements. This is usually done 535 by process_init_constructor. */ 536 gcc_assert (field_index); 537 538 if (!array_type_p) 539 inner_type = TREE_TYPE (field_index); 540 541 if (TREE_CODE (value) == CONSTRUCTOR) 542 { 543 tree sub; 544 545 if (array_type_p) 546 sub = build4 (ARRAY_REF, inner_type, dest, field_index, 547 NULL_TREE, NULL_TREE); 548 else 549 sub = build3 (COMPONENT_REF, inner_type, dest, field_index, 550 NULL_TREE); 551 552 if (!split_nonconstant_init_1 (sub, value)) 553 complete_p = false; 554 num_split_elts++; 555 } 556 else if (!initializer_constant_valid_p (value, inner_type)) 557 { 558 tree code; 559 tree sub; 560 561 /* FIXME: Ordered removal is O(1) so the whole function is 562 worst-case quadratic. This could be fixed using an aside 563 bitmap to record which elements must be removed and remove 564 them all at the same time. Or by merging 565 split_non_constant_init into process_init_constructor_array, 566 that is separating constants from non-constants while building 567 the vector. */ 568 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 569 idx); 570 --idx; 571 572 if (array_type_p) 573 sub = build4 (ARRAY_REF, inner_type, dest, field_index, 574 NULL_TREE, NULL_TREE); 575 else 576 sub = build3 (COMPONENT_REF, inner_type, dest, field_index, 577 NULL_TREE); 578 579 code = build2 (INIT_EXPR, inner_type, sub, value); 580 code = build_stmt (input_location, EXPR_STMT, code); 581 code = maybe_cleanup_point_expr_void (code); 582 add_stmt (code); 583 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type)) 584 { 585 code = (build_special_member_call 586 (sub, complete_dtor_identifier, NULL, inner_type, 587 LOOKUP_NORMAL, tf_warning_or_error)); 588 finish_eh_cleanup (code); 589 } 590 591 num_split_elts++; 592 } 593 } 594 break; 595 596 case VECTOR_TYPE: 597 if (!initializer_constant_valid_p (init, type)) 598 { 599 tree code; 600 tree cons = copy_node (init); 601 CONSTRUCTOR_ELTS (init) = NULL; 602 code = build2 (MODIFY_EXPR, type, dest, cons); 603 code = build_stmt (input_location, EXPR_STMT, code); 604 add_stmt (code); 605 num_split_elts += CONSTRUCTOR_NELTS (init); 606 } 607 break; 608 609 default: 610 gcc_unreachable (); 611 } 612 613 /* The rest of the initializer is now a constant. */ 614 TREE_CONSTANT (init) = 1; 615 return complete_p && complete_ctor_at_level_p (TREE_TYPE (init), 616 num_split_elts, inner_type); 617 } 618 619 /* A subroutine of store_init_value. Splits non-constant static 620 initializer INIT into a constant part and generates code to 621 perform the non-constant part of the initialization to DEST. 622 Returns the code for the runtime init. */ 623 624 static tree 625 split_nonconstant_init (tree dest, tree init) 626 { 627 tree code; 628 629 if (TREE_CODE (init) == CONSTRUCTOR) 630 { 631 code = push_stmt_list (); 632 if (split_nonconstant_init_1 (dest, init)) 633 init = NULL_TREE; 634 code = pop_stmt_list (code); 635 DECL_INITIAL (dest) = init; 636 TREE_READONLY (dest) = 0; 637 } 638 else 639 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init); 640 641 return code; 642 } 643 644 /* Perform appropriate conversions on the initial value of a variable, 645 store it in the declaration DECL, 646 and print any error messages that are appropriate. 647 If the init is invalid, store an ERROR_MARK. 648 649 C++: Note that INIT might be a TREE_LIST, which would mean that it is 650 a base class initializer for some aggregate type, hopefully compatible 651 with DECL. If INIT is a single element, and DECL is an aggregate 652 type, we silently convert INIT into a TREE_LIST, allowing a constructor 653 to be called. 654 655 If INIT is a TREE_LIST and there is no constructor, turn INIT 656 into a CONSTRUCTOR and use standard initialization techniques. 657 Perhaps a warning should be generated? 658 659 Returns code to be executed if initialization could not be performed 660 for static variable. In that case, caller must emit the code. */ 661 662 tree 663 store_init_value (tree decl, tree init, VEC(tree,gc)** cleanups, int flags) 664 { 665 tree value, type; 666 667 /* If variable's type was invalidly declared, just ignore it. */ 668 669 type = TREE_TYPE (decl); 670 if (TREE_CODE (type) == ERROR_MARK) 671 return NULL_TREE; 672 673 if (MAYBE_CLASS_TYPE_P (type)) 674 { 675 if (TREE_CODE (init) == TREE_LIST) 676 { 677 error ("constructor syntax used, but no constructor declared " 678 "for type %qT", type); 679 init = build_constructor_from_list (init_list_type_node, nreverse (init)); 680 } 681 } 682 else if (TREE_CODE (init) == TREE_LIST 683 && TREE_TYPE (init) != unknown_type_node) 684 { 685 gcc_assert (TREE_CODE (decl) != RESULT_DECL); 686 687 if (TREE_CODE (init) == TREE_LIST 688 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 689 { 690 error ("cannot initialize arrays using this syntax"); 691 return NULL_TREE; 692 } 693 else 694 /* We get here with code like `int a (2);' */ 695 init = build_x_compound_expr_from_list (init, ELK_INIT, 696 tf_warning_or_error); 697 } 698 699 /* End of special C++ code. */ 700 701 if (flags & LOOKUP_ALREADY_DIGESTED) 702 value = init; 703 else 704 /* Digest the specified initializer into an expression. */ 705 value = digest_init_flags (type, init, flags); 706 707 value = extend_ref_init_temps (decl, value, cleanups); 708 709 /* In C++0x constant expression is a semantic, not syntactic, property. 710 In C++98, make sure that what we thought was a constant expression at 711 template definition time is still constant. */ 712 if ((cxx_dialect >= cxx0x 713 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) 714 && (decl_maybe_constant_var_p (decl) 715 || TREE_STATIC (decl))) 716 { 717 bool const_init; 718 value = fold_non_dependent_expr (value); 719 value = maybe_constant_init (value); 720 if (DECL_DECLARED_CONSTEXPR_P (decl)) 721 { 722 /* Diagnose a non-constant initializer for constexpr. */ 723 if (processing_template_decl 724 && !require_potential_constant_expression (value)) 725 value = error_mark_node; 726 else 727 value = cxx_constant_value (value); 728 } 729 const_init = (reduced_constant_expression_p (value) 730 || error_operand_p (value)); 731 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init; 732 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl); 733 } 734 735 /* If the initializer is not a constant, fill in DECL_INITIAL with 736 the bits that are constant, and then return an expression that 737 will perform the dynamic initialization. */ 738 if (value != error_mark_node 739 && (TREE_SIDE_EFFECTS (value) 740 || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) 741 { 742 if (TREE_CODE (type) == ARRAY_TYPE 743 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type))) 744 /* For an array, we only need/want a single cleanup region rather 745 than one per element. */ 746 return build_vec_init (decl, NULL_TREE, value, false, 1, 747 tf_warning_or_error); 748 else 749 return split_nonconstant_init (decl, value); 750 } 751 /* If the value is a constant, just put it in DECL_INITIAL. If DECL 752 is an automatic variable, the middle end will turn this into a 753 dynamic initialization later. */ 754 DECL_INITIAL (decl) = value; 755 return NULL_TREE; 756 } 757 758 759 /* Give errors about narrowing conversions within { }. */ 760 761 void 762 check_narrowing (tree type, tree init) 763 { 764 tree ftype = unlowered_expr_type (init); 765 bool ok = true; 766 REAL_VALUE_TYPE d; 767 768 if (!warn_narrowing || !ARITHMETIC_TYPE_P (type)) 769 return; 770 771 if (BRACE_ENCLOSED_INITIALIZER_P (init) 772 && TREE_CODE (type) == COMPLEX_TYPE) 773 { 774 tree elttype = TREE_TYPE (type); 775 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value); 776 if (CONSTRUCTOR_NELTS (init) > 1) 777 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value); 778 return; 779 } 780 781 init = maybe_constant_value (init); 782 783 if (TREE_CODE (type) == INTEGER_TYPE 784 && TREE_CODE (ftype) == REAL_TYPE) 785 ok = false; 786 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype) 787 && CP_INTEGRAL_TYPE_P (type)) 788 { 789 if (TREE_CODE (ftype) == ENUMERAL_TYPE) 790 /* Check for narrowing based on the values of the enumeration. */ 791 ftype = ENUM_UNDERLYING_TYPE (ftype); 792 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type), 793 TYPE_MAX_VALUE (ftype)) 794 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype), 795 TYPE_MIN_VALUE (type))) 796 && (TREE_CODE (init) != INTEGER_CST 797 || !int_fits_type_p (init, type))) 798 ok = false; 799 } 800 else if (TREE_CODE (ftype) == REAL_TYPE 801 && TREE_CODE (type) == REAL_TYPE) 802 { 803 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)) 804 { 805 if (TREE_CODE (init) == REAL_CST) 806 { 807 /* Issue 703: Loss of precision is OK as long as the value is 808 within the representable range of the new type. */ 809 REAL_VALUE_TYPE r; 810 d = TREE_REAL_CST (init); 811 real_convert (&r, TYPE_MODE (type), &d); 812 if (real_isinf (&r)) 813 ok = false; 814 } 815 else 816 ok = false; 817 } 818 } 819 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype) 820 && TREE_CODE (type) == REAL_TYPE) 821 { 822 ok = false; 823 if (TREE_CODE (init) == INTEGER_CST) 824 { 825 d = real_value_from_int_cst (0, init); 826 if (exact_real_truncate (TYPE_MODE (type), &d)) 827 ok = true; 828 } 829 } 830 831 if (!ok) 832 { 833 if (cxx_dialect >= cxx0x) 834 pedwarn (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing, 835 "narrowing conversion of %qE from %qT to %qT inside { }", 836 init, ftype, type); 837 else 838 warning_at (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing, 839 "narrowing conversion of %qE from %qT to %qT inside { } " 840 "is ill-formed in C++11", init, ftype, type); 841 } 842 } 843 844 /* Process the initializer INIT for a variable of type TYPE, emitting 845 diagnostics for invalid initializers and converting the initializer as 846 appropriate. 847 848 For aggregate types, it assumes that reshape_init has already run, thus the 849 initializer will have the right shape (brace elision has been undone). 850 851 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */ 852 853 static tree 854 digest_init_r (tree type, tree init, bool nested, int flags, 855 tsubst_flags_t complain) 856 { 857 enum tree_code code = TREE_CODE (type); 858 859 if (error_operand_p (init)) 860 return error_mark_node; 861 862 gcc_assert (init); 863 864 /* We must strip the outermost array type when completing the type, 865 because the its bounds might be incomplete at the moment. */ 866 if (!complete_type_or_maybe_complain (TREE_CODE (type) == ARRAY_TYPE 867 ? TREE_TYPE (type) : type, NULL_TREE, 868 complain)) 869 return error_mark_node; 870 871 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue 872 (g++.old-deja/g++.law/casts2.C). */ 873 if (TREE_CODE (init) == NON_LVALUE_EXPR) 874 init = TREE_OPERAND (init, 0); 875 876 /* Initialization of an array of chars from a string constant. The initializer 877 can be optionally enclosed in braces, but reshape_init has already removed 878 them if they were present. */ 879 if (code == ARRAY_TYPE) 880 { 881 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 882 if (char_type_p (typ1) 883 /*&& init */ 884 && TREE_CODE (init) == STRING_CST) 885 { 886 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init))); 887 888 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT) 889 { 890 if (char_type != char_type_node) 891 { 892 if (complain & tf_error) 893 error ("char-array initialized from wide string"); 894 return error_mark_node; 895 } 896 } 897 else 898 { 899 if (char_type == char_type_node) 900 { 901 if (complain & tf_error) 902 error ("int-array initialized from non-wide string"); 903 return error_mark_node; 904 } 905 else if (char_type != typ1) 906 { 907 if (complain & tf_error) 908 error ("int-array initialized from incompatible " 909 "wide string"); 910 return error_mark_node; 911 } 912 } 913 914 if (type != TREE_TYPE (init)) 915 { 916 init = copy_node (init); 917 TREE_TYPE (init) = type; 918 } 919 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type))) 920 { 921 int size = TREE_INT_CST_LOW (TYPE_SIZE (type)); 922 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; 923 /* In C it is ok to subtract 1 from the length of the string 924 because it's ok to ignore the terminating null char that is 925 counted in the length of the constant, but in C++ this would 926 be invalid. */ 927 if (size < TREE_STRING_LENGTH (init)) 928 permerror (input_location, "initializer-string for array " 929 "of chars is too long"); 930 } 931 return init; 932 } 933 } 934 935 /* Handle scalar types (including conversions) and references. */ 936 if ((TREE_CODE (type) != COMPLEX_TYPE 937 || BRACE_ENCLOSED_INITIALIZER_P (init)) 938 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE)) 939 { 940 tree *exp; 941 942 if (nested) 943 check_narrowing (type, init); 944 init = convert_for_initialization (0, type, init, flags, 945 ICR_INIT, NULL_TREE, 0, 946 complain); 947 exp = &init; 948 949 /* Skip any conversions since we'll be outputting the underlying 950 constant. */ 951 while (CONVERT_EXPR_P (*exp) 952 || TREE_CODE (*exp) == NON_LVALUE_EXPR) 953 exp = &TREE_OPERAND (*exp, 0); 954 955 *exp = cplus_expand_constant (*exp); 956 957 return init; 958 } 959 960 /* Come here only for aggregates: records, arrays, unions, complex numbers 961 and vectors. */ 962 gcc_assert (TREE_CODE (type) == ARRAY_TYPE 963 || TREE_CODE (type) == VECTOR_TYPE 964 || TREE_CODE (type) == RECORD_TYPE 965 || TREE_CODE (type) == UNION_TYPE 966 || TREE_CODE (type) == COMPLEX_TYPE); 967 968 if (BRACE_ENCLOSED_INITIALIZER_P (init) 969 && !TYPE_NON_AGGREGATE_CLASS (type)) 970 return process_init_constructor (type, init, complain); 971 else 972 { 973 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE) 974 { 975 if (complain & tf_error) 976 error ("cannot initialize aggregate of type %qT with " 977 "a compound literal", type); 978 979 return error_mark_node; 980 } 981 982 if (TREE_CODE (type) == ARRAY_TYPE 983 && !BRACE_ENCLOSED_INITIALIZER_P (init)) 984 { 985 /* Allow the result of build_array_copy and of 986 build_value_init_noctor. */ 987 if ((TREE_CODE (init) == VEC_INIT_EXPR 988 || TREE_CODE (init) == CONSTRUCTOR) 989 && (same_type_ignoring_top_level_qualifiers_p 990 (type, TREE_TYPE (init)))) 991 return init; 992 993 if (complain & tf_error) 994 error ("array must be initialized with a brace-enclosed" 995 " initializer"); 996 return error_mark_node; 997 } 998 999 return convert_for_initialization (NULL_TREE, type, init, 1000 flags, 1001 ICR_INIT, NULL_TREE, 0, 1002 complain); 1003 } 1004 } 1005 1006 tree 1007 digest_init (tree type, tree init, tsubst_flags_t complain) 1008 { 1009 return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain); 1010 } 1011 1012 tree 1013 digest_init_flags (tree type, tree init, int flags) 1014 { 1015 return digest_init_r (type, init, false, flags, tf_warning_or_error); 1016 } 1017 1018 /* Set of flags used within process_init_constructor to describe the 1019 initializers. */ 1020 #define PICFLAG_ERRONEOUS 1 1021 #define PICFLAG_NOT_ALL_CONSTANT 2 1022 #define PICFLAG_NOT_ALL_SIMPLE 4 1023 1024 /* Given an initializer INIT, return the flag (PICFLAG_*) which better 1025 describe it. */ 1026 1027 static int 1028 picflag_from_initializer (tree init) 1029 { 1030 if (init == error_mark_node) 1031 return PICFLAG_ERRONEOUS; 1032 else if (!TREE_CONSTANT (init)) 1033 return PICFLAG_NOT_ALL_CONSTANT; 1034 else if (!initializer_constant_valid_p (init, TREE_TYPE (init))) 1035 return PICFLAG_NOT_ALL_SIMPLE; 1036 return 0; 1037 } 1038 1039 /* Subroutine of process_init_constructor, which will process an initializer 1040 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*) 1041 which describe the initializers. */ 1042 1043 static int 1044 process_init_constructor_array (tree type, tree init, 1045 tsubst_flags_t complain) 1046 { 1047 unsigned HOST_WIDE_INT i, len = 0; 1048 int flags = 0; 1049 bool unbounded = false; 1050 constructor_elt *ce; 1051 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init); 1052 1053 gcc_assert (TREE_CODE (type) == ARRAY_TYPE 1054 || TREE_CODE (type) == VECTOR_TYPE); 1055 1056 if (TREE_CODE (type) == ARRAY_TYPE) 1057 { 1058 tree domain = TYPE_DOMAIN (type); 1059 if (domain) 1060 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) 1061 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) 1062 + 1); 1063 else 1064 unbounded = true; /* Take as many as there are. */ 1065 } 1066 else 1067 /* Vectors are like simple fixed-size arrays. */ 1068 len = TYPE_VECTOR_SUBPARTS (type); 1069 1070 /* There must not be more initializers than needed. */ 1071 if (!unbounded && VEC_length (constructor_elt, v) > len) 1072 { 1073 if (complain & tf_error) 1074 error ("too many initializers for %qT", type); 1075 else 1076 return PICFLAG_ERRONEOUS; 1077 } 1078 1079 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce) 1080 { 1081 if (ce->index) 1082 { 1083 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST); 1084 if (compare_tree_int (ce->index, i) != 0) 1085 { 1086 ce->value = error_mark_node; 1087 sorry ("non-trivial designated initializers not supported"); 1088 } 1089 } 1090 else 1091 ce->index = size_int (i); 1092 gcc_assert (ce->value); 1093 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, 1094 LOOKUP_IMPLICIT, complain); 1095 1096 if (ce->value != error_mark_node) 1097 gcc_assert (same_type_ignoring_top_level_qualifiers_p 1098 (TREE_TYPE (type), TREE_TYPE (ce->value))); 1099 1100 flags |= picflag_from_initializer (ce->value); 1101 } 1102 1103 /* No more initializers. If the array is unbounded, we are done. Otherwise, 1104 we must add initializers ourselves. */ 1105 if (!unbounded) 1106 for (; i < len; ++i) 1107 { 1108 tree next; 1109 1110 if (type_build_ctor_call (TREE_TYPE (type))) 1111 { 1112 /* If this type needs constructors run for default-initialization, 1113 we can't rely on the back end to do it for us, so make the 1114 initialization explicit by list-initializing from {}. */ 1115 next = build_constructor (init_list_type_node, NULL); 1116 next = digest_init (TREE_TYPE (type), next, complain); 1117 } 1118 else if (!zero_init_p (TREE_TYPE (type))) 1119 next = build_zero_init (TREE_TYPE (type), 1120 /*nelts=*/NULL_TREE, 1121 /*static_storage_p=*/false); 1122 else 1123 /* The default zero-initialization is fine for us; don't 1124 add anything to the CONSTRUCTOR. */ 1125 break; 1126 1127 flags |= picflag_from_initializer (next); 1128 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next); 1129 } 1130 1131 CONSTRUCTOR_ELTS (init) = v; 1132 return flags; 1133 } 1134 1135 /* Subroutine of process_init_constructor, which will process an initializer 1136 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe 1137 the initializers. */ 1138 1139 static int 1140 process_init_constructor_record (tree type, tree init, 1141 tsubst_flags_t complain) 1142 { 1143 VEC(constructor_elt,gc) *v = NULL; 1144 int flags = 0; 1145 tree field; 1146 unsigned HOST_WIDE_INT idx = 0; 1147 1148 gcc_assert (TREE_CODE (type) == RECORD_TYPE); 1149 gcc_assert (!CLASSTYPE_VBASECLASSES (type)); 1150 gcc_assert (!TYPE_BINFO (type) 1151 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type))); 1152 gcc_assert (!TYPE_POLYMORPHIC_P (type)); 1153 1154 /* Generally, we will always have an index for each initializer (which is 1155 a FIELD_DECL, put by reshape_init), but compound literals don't go trough 1156 reshape_init. So we need to handle both cases. */ 1157 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 1158 { 1159 tree next; 1160 tree type; 1161 1162 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field)) 1163 { 1164 flags |= picflag_from_initializer (integer_zero_node); 1165 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node); 1166 continue; 1167 } 1168 1169 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 1170 continue; 1171 1172 /* If this is a bitfield, first convert to the declared type. */ 1173 type = TREE_TYPE (field); 1174 if (DECL_BIT_FIELD_TYPE (field)) 1175 type = DECL_BIT_FIELD_TYPE (field); 1176 1177 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) 1178 { 1179 constructor_elt *ce = VEC_index (constructor_elt, 1180 CONSTRUCTOR_ELTS (init), idx); 1181 if (ce->index) 1182 { 1183 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The 1184 latter case can happen in templates where lookup has to be 1185 deferred. */ 1186 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL 1187 || TREE_CODE (ce->index) == IDENTIFIER_NODE); 1188 if (ce->index != field 1189 && ce->index != DECL_NAME (field)) 1190 { 1191 ce->value = error_mark_node; 1192 sorry ("non-trivial designated initializers not supported"); 1193 } 1194 } 1195 1196 gcc_assert (ce->value); 1197 next = digest_init_r (type, ce->value, true, 1198 LOOKUP_IMPLICIT, complain); 1199 ++idx; 1200 } 1201 else if (type_build_ctor_call (TREE_TYPE (field))) 1202 { 1203 /* If this type needs constructors run for 1204 default-initialization, we can't rely on the back end to do it 1205 for us, so build up TARGET_EXPRs. If the type in question is 1206 a class, just build one up; if it's an array, recurse. */ 1207 next = build_constructor (init_list_type_node, NULL); 1208 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field))) 1209 { 1210 next = finish_compound_literal (TREE_TYPE (field), next, 1211 complain); 1212 /* direct-initialize the target. No temporary is going 1213 to be involved. */ 1214 if (TREE_CODE (next) == TARGET_EXPR) 1215 TARGET_EXPR_DIRECT_INIT_P (next) = true; 1216 } 1217 1218 next = digest_init_r (TREE_TYPE (field), next, true, 1219 LOOKUP_IMPLICIT, complain); 1220 1221 /* Warn when some struct elements are implicitly initialized. */ 1222 warning (OPT_Wmissing_field_initializers, 1223 "missing initializer for member %qD", field); 1224 } 1225 else 1226 { 1227 if (TREE_READONLY (field)) 1228 { 1229 if (complain & tf_error) 1230 error ("uninitialized const member %qD", field); 1231 else 1232 return PICFLAG_ERRONEOUS; 1233 } 1234 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) 1235 { 1236 if (complain & tf_error) 1237 error ("member %qD with uninitialized const fields", field); 1238 else 1239 return PICFLAG_ERRONEOUS; 1240 } 1241 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) 1242 { 1243 if (complain & tf_error) 1244 error ("member %qD is uninitialized reference", field); 1245 else 1246 return PICFLAG_ERRONEOUS; 1247 } 1248 1249 /* Warn when some struct elements are implicitly initialized 1250 to zero. */ 1251 warning (OPT_Wmissing_field_initializers, 1252 "missing initializer for member %qD", field); 1253 1254 if (!zero_init_p (TREE_TYPE (field))) 1255 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE, 1256 /*static_storage_p=*/false); 1257 else 1258 /* The default zero-initialization is fine for us; don't 1259 add anything to the CONSTRUCTOR. */ 1260 continue; 1261 } 1262 1263 /* If this is a bitfield, now convert to the lowered type. */ 1264 if (type != TREE_TYPE (field)) 1265 next = cp_convert_and_check (TREE_TYPE (field), next); 1266 flags |= picflag_from_initializer (next); 1267 CONSTRUCTOR_APPEND_ELT (v, field, next); 1268 } 1269 1270 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) 1271 { 1272 if (complain & tf_error) 1273 error ("too many initializers for %qT", type); 1274 else 1275 return PICFLAG_ERRONEOUS; 1276 } 1277 1278 CONSTRUCTOR_ELTS (init) = v; 1279 return flags; 1280 } 1281 1282 /* Subroutine of process_init_constructor, which will process a single 1283 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*) 1284 which describe the initializer. */ 1285 1286 static int 1287 process_init_constructor_union (tree type, tree init, 1288 tsubst_flags_t complain) 1289 { 1290 constructor_elt *ce; 1291 int len; 1292 1293 /* If the initializer was empty, use default zero initialization. */ 1294 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))) 1295 return 0; 1296 1297 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)); 1298 if (len > 1) 1299 { 1300 if (!(complain & tf_error)) 1301 return PICFLAG_ERRONEOUS; 1302 error ("too many initializers for %qT", type); 1303 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1); 1304 } 1305 1306 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); 1307 1308 /* If this element specifies a field, initialize via that field. */ 1309 if (ce->index) 1310 { 1311 if (TREE_CODE (ce->index) == FIELD_DECL) 1312 ; 1313 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE) 1314 { 1315 /* This can happen within a cast, see g++.dg/opt/cse2.C. */ 1316 tree name = ce->index; 1317 tree field; 1318 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1319 if (DECL_NAME (field) == name) 1320 break; 1321 if (!field) 1322 { 1323 if (complain & tf_error) 1324 error ("no field %qD found in union being initialized", 1325 field); 1326 ce->value = error_mark_node; 1327 } 1328 ce->index = field; 1329 } 1330 else 1331 { 1332 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST 1333 || TREE_CODE (ce->index) == RANGE_EXPR); 1334 if (complain & tf_error) 1335 error ("index value instead of field name in union initializer"); 1336 ce->value = error_mark_node; 1337 } 1338 } 1339 else 1340 { 1341 /* Find the first named field. ANSI decided in September 1990 1342 that only named fields count here. */ 1343 tree field = TYPE_FIELDS (type); 1344 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL)) 1345 field = TREE_CHAIN (field); 1346 if (field == NULL_TREE) 1347 { 1348 if (complain & tf_error) 1349 error ("too many initializers for %qT", type); 1350 ce->value = error_mark_node; 1351 } 1352 ce->index = field; 1353 } 1354 1355 if (ce->value && ce->value != error_mark_node) 1356 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, 1357 true, LOOKUP_IMPLICIT, complain); 1358 1359 return picflag_from_initializer (ce->value); 1360 } 1361 1362 /* Process INIT, a constructor for a variable of aggregate type TYPE. The 1363 constructor is a brace-enclosed initializer, and will be modified in-place. 1364 1365 Each element is converted to the right type through digest_init, and 1366 missing initializers are added following the language rules (zero-padding, 1367 etc.). 1368 1369 After the execution, the initializer will have TREE_CONSTANT if all elts are 1370 constant, and TREE_STATIC set if, in addition, all elts are simple enough 1371 constants that the assembler and linker can compute them. 1372 1373 The function returns the initializer itself, or error_mark_node in case 1374 of error. */ 1375 1376 static tree 1377 process_init_constructor (tree type, tree init, tsubst_flags_t complain) 1378 { 1379 int flags; 1380 1381 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 1382 1383 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) 1384 flags = process_init_constructor_array (type, init, complain); 1385 else if (TREE_CODE (type) == RECORD_TYPE) 1386 flags = process_init_constructor_record (type, init, complain); 1387 else if (TREE_CODE (type) == UNION_TYPE) 1388 flags = process_init_constructor_union (type, init, complain); 1389 else 1390 gcc_unreachable (); 1391 1392 if (flags & PICFLAG_ERRONEOUS) 1393 return error_mark_node; 1394 1395 TREE_TYPE (init) = type; 1396 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE) 1397 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0); 1398 if (!(flags & PICFLAG_NOT_ALL_CONSTANT)) 1399 { 1400 TREE_CONSTANT (init) = 1; 1401 if (!(flags & PICFLAG_NOT_ALL_SIMPLE)) 1402 TREE_STATIC (init) = 1; 1403 } 1404 return init; 1405 } 1406 1407 /* Given a structure or union value DATUM, construct and return 1408 the structure or union component which results from narrowing 1409 that value to the base specified in BASETYPE. For example, given the 1410 hierarchy 1411 1412 class L { int ii; }; 1413 class A : L { ... }; 1414 class B : L { ... }; 1415 class C : A, B { ... }; 1416 1417 and the declaration 1418 1419 C x; 1420 1421 then the expression 1422 1423 x.A::ii refers to the ii member of the L part of 1424 the A part of the C object named by X. In this case, 1425 DATUM would be x, and BASETYPE would be A. 1426 1427 I used to think that this was nonconformant, that the standard specified 1428 that first we look up ii in A, then convert x to an L& and pull out the 1429 ii part. But in fact, it does say that we convert x to an A&; A here 1430 is known as the "naming class". (jason 2000-12-19) 1431 1432 BINFO_P points to a variable initialized either to NULL_TREE or to the 1433 binfo for the specific base subobject we want to convert to. */ 1434 1435 tree 1436 build_scoped_ref (tree datum, tree basetype, tree* binfo_p) 1437 { 1438 tree binfo; 1439 1440 if (datum == error_mark_node) 1441 return error_mark_node; 1442 if (*binfo_p) 1443 binfo = *binfo_p; 1444 else 1445 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL); 1446 1447 if (!binfo || binfo == error_mark_node) 1448 { 1449 *binfo_p = NULL_TREE; 1450 if (!binfo) 1451 error_not_base_type (basetype, TREE_TYPE (datum)); 1452 return error_mark_node; 1453 } 1454 1455 *binfo_p = binfo; 1456 return build_base_path (PLUS_EXPR, datum, binfo, 1, 1457 tf_warning_or_error); 1458 } 1459 1460 /* Build a reference to an object specified by the C++ `->' operator. 1461 Usually this just involves dereferencing the object, but if the 1462 `->' operator is overloaded, then such overloads must be 1463 performed until an object which does not have the `->' operator 1464 overloaded is found. An error is reported when circular pointer 1465 delegation is detected. */ 1466 1467 tree 1468 build_x_arrow (tree expr) 1469 { 1470 tree orig_expr = expr; 1471 tree type = TREE_TYPE (expr); 1472 tree last_rval = NULL_TREE; 1473 VEC(tree,gc) *types_memoized = NULL; 1474 1475 if (type == error_mark_node) 1476 return error_mark_node; 1477 1478 if (processing_template_decl) 1479 { 1480 if (type_dependent_expression_p (expr)) 1481 return build_min_nt (ARROW_EXPR, expr); 1482 expr = build_non_dependent_expr (expr); 1483 } 1484 1485 if (MAYBE_CLASS_TYPE_P (type)) 1486 { 1487 struct tinst_level *actual_inst = current_instantiation (); 1488 tree fn = NULL; 1489 1490 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr, 1491 NULL_TREE, NULL_TREE, 1492 &fn, tf_warning_or_error))) 1493 { 1494 if (expr == error_mark_node) 1495 return error_mark_node; 1496 1497 if (fn && DECL_USE_TEMPLATE (fn)) 1498 push_tinst_level (fn); 1499 fn = NULL; 1500 1501 if (vec_member (TREE_TYPE (expr), types_memoized)) 1502 { 1503 error ("circular pointer delegation detected"); 1504 return error_mark_node; 1505 } 1506 1507 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr)); 1508 last_rval = expr; 1509 } 1510 1511 while (current_instantiation () != actual_inst) 1512 pop_tinst_level (); 1513 1514 if (last_rval == NULL_TREE) 1515 { 1516 error ("base operand of %<->%> has non-pointer type %qT", type); 1517 return error_mark_node; 1518 } 1519 1520 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE) 1521 last_rval = convert_from_reference (last_rval); 1522 } 1523 else 1524 last_rval = decay_conversion (expr); 1525 1526 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE) 1527 { 1528 if (processing_template_decl) 1529 { 1530 expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)), 1531 orig_expr); 1532 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval); 1533 return expr; 1534 } 1535 1536 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error); 1537 } 1538 1539 if (types_memoized) 1540 error ("result of %<operator->()%> yields non-pointer result"); 1541 else 1542 error ("base operand of %<->%> is not a pointer"); 1543 return error_mark_node; 1544 } 1545 1546 /* Return an expression for "DATUM .* COMPONENT". DATUM has not 1547 already been checked out to be of aggregate type. */ 1548 1549 tree 1550 build_m_component_ref (tree datum, tree component) 1551 { 1552 tree ptrmem_type; 1553 tree objtype; 1554 tree type; 1555 tree binfo; 1556 tree ctype; 1557 1558 if (error_operand_p (datum) || error_operand_p (component)) 1559 return error_mark_node; 1560 1561 datum = mark_lvalue_use (datum); 1562 component = mark_rvalue_use (component); 1563 1564 ptrmem_type = TREE_TYPE (component); 1565 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type)) 1566 { 1567 error ("%qE cannot be used as a member pointer, since it is of " 1568 "type %qT", 1569 component, ptrmem_type); 1570 return error_mark_node; 1571 } 1572 1573 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); 1574 if (! MAYBE_CLASS_TYPE_P (objtype)) 1575 { 1576 error ("cannot apply member pointer %qE to %qE, which is of " 1577 "non-class type %qT", 1578 component, datum, objtype); 1579 return error_mark_node; 1580 } 1581 1582 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type); 1583 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type)); 1584 1585 if (!COMPLETE_TYPE_P (ctype)) 1586 { 1587 if (!same_type_p (ctype, objtype)) 1588 goto mismatch; 1589 binfo = NULL; 1590 } 1591 else 1592 { 1593 binfo = lookup_base (objtype, ctype, ba_check, NULL); 1594 1595 if (!binfo) 1596 { 1597 mismatch: 1598 error ("pointer to member type %qT incompatible with object " 1599 "type %qT", 1600 type, objtype); 1601 return error_mark_node; 1602 } 1603 else if (binfo == error_mark_node) 1604 return error_mark_node; 1605 } 1606 1607 if (TYPE_PTRMEM_P (ptrmem_type)) 1608 { 1609 bool is_lval = real_lvalue_p (datum); 1610 tree ptype; 1611 1612 /* Compute the type of the field, as described in [expr.ref]. 1613 There's no such thing as a mutable pointer-to-member, so 1614 things are not as complex as they are for references to 1615 non-static data members. */ 1616 type = cp_build_qualified_type (type, 1617 (cp_type_quals (type) 1618 | cp_type_quals (TREE_TYPE (datum)))); 1619 1620 datum = build_address (datum); 1621 1622 /* Convert object to the correct base. */ 1623 if (binfo) 1624 datum = build_base_path (PLUS_EXPR, datum, binfo, 1, 1625 tf_warning_or_error); 1626 1627 /* Build an expression for "object + offset" where offset is the 1628 value stored in the pointer-to-data-member. */ 1629 ptype = build_pointer_type (type); 1630 datum = fold_build_pointer_plus (fold_convert (ptype, datum), component); 1631 datum = cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error); 1632 /* If the object expression was an rvalue, return an rvalue. */ 1633 if (!is_lval) 1634 datum = move (datum); 1635 return datum; 1636 } 1637 else 1638 return build2 (OFFSET_REF, type, datum, component); 1639 } 1640 1641 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ 1642 1643 tree 1644 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain) 1645 { 1646 /* This is either a call to a constructor, 1647 or a C cast in C++'s `functional' notation. */ 1648 1649 /* The type to which we are casting. */ 1650 tree type; 1651 VEC(tree,gc) *parmvec; 1652 1653 if (exp == error_mark_node || parms == error_mark_node) 1654 return error_mark_node; 1655 1656 if (TREE_CODE (exp) == TYPE_DECL) 1657 type = TREE_TYPE (exp); 1658 else 1659 type = exp; 1660 1661 /* We need to check this explicitly, since value-initialization of 1662 arrays is allowed in other situations. */ 1663 if (TREE_CODE (type) == ARRAY_TYPE) 1664 { 1665 if (complain & tf_error) 1666 error ("functional cast to array type %qT", type); 1667 return error_mark_node; 1668 } 1669 1670 if (type_uses_auto (type)) 1671 { 1672 if (complain & tf_error) 1673 error ("invalid use of %<auto%>"); 1674 return error_mark_node; 1675 } 1676 1677 if (processing_template_decl) 1678 { 1679 tree t; 1680 1681 /* Diagnose this even in a template. We could also try harder 1682 to give all the usual errors when the type and args are 1683 non-dependent... */ 1684 if (TREE_CODE (type) == REFERENCE_TYPE && !parms) 1685 { 1686 if (complain & tf_error) 1687 error ("invalid value-initialization of reference type"); 1688 return error_mark_node; 1689 } 1690 1691 t = build_min (CAST_EXPR, type, parms); 1692 /* We don't know if it will or will not have side effects. */ 1693 TREE_SIDE_EFFECTS (t) = 1; 1694 return t; 1695 } 1696 1697 if (! MAYBE_CLASS_TYPE_P (type)) 1698 { 1699 if (parms == NULL_TREE) 1700 { 1701 if (VOID_TYPE_P (type)) 1702 return void_zero_node; 1703 return build_value_init (cv_unqualified (type), complain); 1704 } 1705 1706 /* This must build a C cast. */ 1707 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain); 1708 return cp_build_c_cast (type, parms, complain); 1709 } 1710 1711 /* Prepare to evaluate as a call to a constructor. If this expression 1712 is actually used, for example, 1713 1714 return X (arg1, arg2, ...); 1715 1716 then the slot being initialized will be filled in. */ 1717 1718 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)) 1719 return error_mark_node; 1720 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain)) 1721 return error_mark_node; 1722 1723 /* [expr.type.conv] 1724 1725 If the expression list is a single-expression, the type 1726 conversion is equivalent (in definedness, and if defined in 1727 meaning) to the corresponding cast expression. */ 1728 if (parms && TREE_CHAIN (parms) == NULL_TREE) 1729 return cp_build_c_cast (type, TREE_VALUE (parms), complain); 1730 1731 /* [expr.type.conv] 1732 1733 The expression T(), where T is a simple-type-specifier for a 1734 non-array complete object type or the (possibly cv-qualified) 1735 void type, creates an rvalue of the specified type, which is 1736 value-initialized. */ 1737 1738 if (parms == NULL_TREE) 1739 { 1740 exp = build_value_init (type, complain); 1741 exp = get_target_expr_sfinae (exp, complain); 1742 return exp; 1743 } 1744 1745 /* Call the constructor. */ 1746 parmvec = make_tree_vector (); 1747 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms)) 1748 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms)); 1749 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, 1750 &parmvec, type, LOOKUP_NORMAL, complain); 1751 release_tree_vector (parmvec); 1752 1753 if (exp == error_mark_node) 1754 return error_mark_node; 1755 1756 return build_cplus_new (type, exp, complain); 1757 } 1758 1759 1760 /* Add new exception specifier SPEC, to the LIST we currently have. 1761 If it's already in LIST then do nothing. 1762 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we 1763 know what we're doing. */ 1764 1765 tree 1766 add_exception_specifier (tree list, tree spec, int complain) 1767 { 1768 bool ok; 1769 tree core = spec; 1770 bool is_ptr; 1771 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */ 1772 1773 if (spec == error_mark_node) 1774 return list; 1775 1776 gcc_assert (spec && (!list || TREE_VALUE (list))); 1777 1778 /* [except.spec] 1, type in an exception specifier shall not be 1779 incomplete, or pointer or ref to incomplete other than pointer 1780 to cv void. */ 1781 is_ptr = TREE_CODE (core) == POINTER_TYPE; 1782 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE) 1783 core = TREE_TYPE (core); 1784 if (complain < 0) 1785 ok = true; 1786 else if (VOID_TYPE_P (core)) 1787 ok = is_ptr; 1788 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM) 1789 ok = true; 1790 else if (processing_template_decl) 1791 ok = true; 1792 else 1793 { 1794 ok = true; 1795 /* 15.4/1 says that types in an exception specifier must be complete, 1796 but it seems more reasonable to only require this on definitions 1797 and calls. So just give a pedwarn at this point; we will give an 1798 error later if we hit one of those two cases. */ 1799 if (!COMPLETE_TYPE_P (complete_type (core))) 1800 diag_type = DK_PEDWARN; /* pedwarn */ 1801 } 1802 1803 if (ok) 1804 { 1805 tree probe; 1806 1807 for (probe = list; probe; probe = TREE_CHAIN (probe)) 1808 if (same_type_p (TREE_VALUE (probe), spec)) 1809 break; 1810 if (!probe) 1811 list = tree_cons (NULL_TREE, spec, list); 1812 } 1813 else 1814 diag_type = DK_ERROR; /* error */ 1815 1816 if (diag_type != DK_UNSPECIFIED && complain) 1817 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); 1818 1819 return list; 1820 } 1821 1822 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */ 1823 1824 static bool 1825 nothrow_spec_p_uninst (const_tree spec) 1826 { 1827 if (DEFERRED_NOEXCEPT_SPEC_P (spec)) 1828 return false; 1829 return nothrow_spec_p (spec); 1830 } 1831 1832 /* Combine the two exceptions specifier lists LIST and ADD, and return 1833 their union. If FN is non-null, it's the source of ADD. */ 1834 1835 tree 1836 merge_exception_specifiers (tree list, tree add, tree fn) 1837 { 1838 tree noex, orig_list; 1839 1840 /* No exception-specifier or noexcept(false) are less strict than 1841 anything else. Prefer the newer variant (LIST). */ 1842 if (!list || list == noexcept_false_spec) 1843 return list; 1844 else if (!add || add == noexcept_false_spec) 1845 return add; 1846 1847 /* noexcept(true) and throw() are stricter than anything else. 1848 As above, prefer the more recent one (LIST). */ 1849 if (nothrow_spec_p_uninst (add)) 1850 return list; 1851 1852 noex = TREE_PURPOSE (list); 1853 if (DEFERRED_NOEXCEPT_SPEC_P (add)) 1854 { 1855 /* If ADD is a deferred noexcept, we must have been called from 1856 process_subob_fn. For implicitly declared functions, we build up 1857 a list of functions to consider at instantiation time. */ 1858 if (noex && operand_equal_p (noex, boolean_true_node, 0)) 1859 noex = NULL_TREE; 1860 gcc_assert (fn && (!noex || is_overloaded_fn (noex))); 1861 noex = build_overload (fn, noex); 1862 } 1863 else if (nothrow_spec_p_uninst (list)) 1864 return add; 1865 else 1866 gcc_checking_assert (!TREE_PURPOSE (add) 1867 || cp_tree_equal (noex, TREE_PURPOSE (add))); 1868 1869 /* Combine the dynamic-exception-specifiers, if any. */ 1870 orig_list = list; 1871 for (; add && TREE_VALUE (add); add = TREE_CHAIN (add)) 1872 { 1873 tree spec = TREE_VALUE (add); 1874 tree probe; 1875 1876 for (probe = orig_list; probe && TREE_VALUE (probe); 1877 probe = TREE_CHAIN (probe)) 1878 if (same_type_p (TREE_VALUE (probe), spec)) 1879 break; 1880 if (!probe) 1881 { 1882 spec = build_tree_list (NULL_TREE, spec); 1883 TREE_CHAIN (spec) = list; 1884 list = spec; 1885 } 1886 } 1887 1888 /* Keep the noexcept-specifier at the beginning of the list. */ 1889 if (noex != TREE_PURPOSE (list)) 1890 list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list)); 1891 1892 return list; 1893 } 1894 1895 /* Subroutine of build_call. Ensure that each of the types in the 1896 exception specification is complete. Technically, 15.4/1 says that 1897 they need to be complete when we see a declaration of the function, 1898 but we should be able to get away with only requiring this when the 1899 function is defined or called. See also add_exception_specifier. */ 1900 1901 void 1902 require_complete_eh_spec_types (tree fntype, tree decl) 1903 { 1904 tree raises; 1905 /* Don't complain about calls to op new. */ 1906 if (decl && DECL_ARTIFICIAL (decl)) 1907 return; 1908 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises; 1909 raises = TREE_CHAIN (raises)) 1910 { 1911 tree type = TREE_VALUE (raises); 1912 if (type && !COMPLETE_TYPE_P (type)) 1913 { 1914 if (decl) 1915 error 1916 ("call to function %qD which throws incomplete type %q#T", 1917 decl, type); 1918 else 1919 error ("call to function which throws incomplete type %q#T", 1920 decl); 1921 } 1922 } 1923 } 1924 1925 1926 #include "gt-cp-typeck2.h" 1927