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
5 Free Software Foundation, Inc.
6 Hacked by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
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)
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.
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/>. */
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. */
32 #include "coretypes.h"
39 #include "diagnostic.h"
43 process_init_constructor (tree type, tree init);
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
50 error_not_base_type (tree basetype, tree type)
52 if (TREE_CODE (basetype) == FUNCTION_DECL)
53 basetype = DECL_CONTEXT (basetype);
54 error ("type %qT is not a base type for type %qT", basetype, type);
55 return error_mark_node;
59 binfo_or_else (tree base, tree type)
61 tree binfo = lookup_base (type, base, ba_unique, NULL);
63 if (binfo == error_mark_node)
66 error_not_base_type (base, type);
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. */
74 readonly_error (tree arg, const char* string)
78 if (TREE_CODE (arg) == COMPONENT_REF)
80 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
81 fmt = "%s of data-member %qD in read-only structure";
83 fmt = "%s of read-only data-member %qD";
84 error (fmt, string, TREE_OPERAND (arg, 1));
86 else if (TREE_CODE (arg) == VAR_DECL)
88 if (DECL_LANG_SPECIFIC (arg)
89 && DECL_IN_AGGR_P (arg)
90 && !TREE_STATIC (arg))
91 fmt = "%s of constant field %qD";
93 fmt = "%s of read-only variable %qD";
94 error (fmt, string, arg);
96 else if (TREE_CODE (arg) == PARM_DECL)
97 error ("%s of read-only parameter %qD", string, arg);
98 else if (TREE_CODE (arg) == INDIRECT_REF
99 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
100 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
101 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
102 error ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
103 else if (TREE_CODE (arg) == RESULT_DECL)
104 error ("%s of read-only named return value %qD", string, arg);
105 else if (TREE_CODE (arg) == FUNCTION_DECL)
106 error ("%s of function %qD", string, arg);
108 error ("%s of read-only location %qE", string, arg);
112 /* Structure that holds information about declarations whose type was
113 incomplete and we could not check whether it was abstract or not. */
115 struct pending_abstract_type GTY((chain_next ("%h.next")))
117 /* Declaration which we are checking for abstractness. It is either
118 a DECL node, or an IDENTIFIER_NODE if we do not have a full
119 declaration available. */
122 /* Type which will be checked for abstractness. */
125 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
126 because DECLs already carry locus information. */
129 /* Link to the next element in list. */
130 struct pending_abstract_type* next;
134 /* Compute the hash value of the node VAL. This function is used by the
135 hash table abstract_pending_vars. */
138 pat_calc_hash (const void* val)
140 const struct pending_abstract_type *pat =
141 (const struct pending_abstract_type *) val;
142 return (hashval_t) TYPE_UID (pat->type);
146 /* Compare node VAL1 with the type VAL2. This function is used by the
147 hash table abstract_pending_vars. */
150 pat_compare (const void* val1, const void* val2)
152 const struct pending_abstract_type *const pat1 =
153 (const struct pending_abstract_type *) val1;
154 const_tree const type2 = (const_tree)val2;
156 return (pat1->type == type2);
159 /* Hash table that maintains pending_abstract_type nodes, for which we still
160 need to check for type abstractness. The key of the table is the type
161 of the declaration. */
162 static GTY ((param_is (struct pending_abstract_type)))
163 htab_t abstract_pending_vars = NULL;
166 /* This function is called after TYPE is completed, and will check if there
167 are pending declarations for which we still need to verify the abstractness
168 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
169 turned out to be incomplete. */
172 complete_type_check_abstract (tree type)
175 struct pending_abstract_type *pat;
176 location_t cur_loc = input_location;
178 gcc_assert (COMPLETE_TYPE_P (type));
180 if (!abstract_pending_vars)
183 /* Retrieve the list of pending declarations for this type. */
184 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
185 (hashval_t)TYPE_UID (type), NO_INSERT);
188 pat = (struct pending_abstract_type*)*slot;
191 /* If the type is not abstract, do not do anything. */
192 if (CLASSTYPE_PURE_VIRTUALS (type))
194 struct pending_abstract_type *prev = 0, *next;
196 /* Reverse the list to emit the errors in top-down order. */
197 for (; pat; pat = next)
205 /* Go through the list, and call abstract_virtuals_error for each
206 element: it will issue a diagnostic if the type is abstract. */
209 gcc_assert (type == pat->type);
211 /* Tweak input_location so that the diagnostic appears at the correct
212 location. Notice that this is only needed if the decl is an
214 input_location = pat->locus;
215 abstract_virtuals_error (pat->decl, pat->type);
220 htab_clear_slot (abstract_pending_vars, slot);
222 input_location = cur_loc;
226 /* If TYPE has abstract virtual functions, issue an error about trying
227 to create an object of that type. DECL is the object declared, or
228 NULL_TREE if the declaration is unavailable. Returns 1 if an error
229 occurred; zero if all was well. */
232 abstract_virtuals_error (tree decl, tree type)
236 /* This function applies only to classes. Any other entity can never
238 if (!CLASS_TYPE_P (type))
241 /* If the type is incomplete, we register it within a hash table,
242 so that we can check again once it is completed. This makes sense
243 only for objects for which we have a declaration or at least a
245 if (!COMPLETE_TYPE_P (type))
248 struct pending_abstract_type *pat;
250 gcc_assert (!decl || DECL_P (decl)
251 || TREE_CODE (decl) == IDENTIFIER_NODE);
253 if (!abstract_pending_vars)
254 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
257 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
258 (hashval_t)TYPE_UID (type), INSERT);
260 pat = GGC_NEW (struct pending_abstract_type);
263 pat->locus = ((decl && DECL_P (decl))
264 ? DECL_SOURCE_LOCATION (decl)
267 pat->next = (struct pending_abstract_type *) *slot;
273 if (!TYPE_SIZE (type))
274 /* TYPE is being defined, and during that time
275 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
278 pure = CLASSTYPE_PURE_VIRTUALS (type);
284 if (TREE_CODE (decl) == RESULT_DECL)
287 if (TREE_CODE (decl) == VAR_DECL)
288 error ("cannot declare variable %q+D to be of abstract "
289 "type %qT", decl, type);
290 else if (TREE_CODE (decl) == PARM_DECL)
291 error ("cannot declare parameter %q+D to be of abstract type %qT",
293 else if (TREE_CODE (decl) == FIELD_DECL)
294 error ("cannot declare field %q+D to be of abstract type %qT",
296 else if (TREE_CODE (decl) == FUNCTION_DECL
297 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
298 error ("invalid abstract return type for member function %q+#D", decl);
299 else if (TREE_CODE (decl) == FUNCTION_DECL)
300 error ("invalid abstract return type for function %q+#D", decl);
301 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
302 /* Here we do not have location information. */
303 error ("invalid abstract type %qT for %qE", type, decl);
305 error ("invalid abstract type for %q+D", decl);
308 error ("cannot allocate an object of abstract type %qT", type);
310 /* Only go through this once. */
311 if (VEC_length (tree, pure))
316 inform (input_location, "%J because the following virtual functions are pure "
317 "within %qT:", TYPE_MAIN_DECL (type), type);
319 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
320 inform (input_location, "\t%+#D", fn);
321 /* Now truncate the vector. This leaves it non-null, so we know
322 there are pure virtuals, but empty so we don't list them out
324 VEC_truncate (tree, pure, 0);
327 inform (input_location, "%J since type %qT has pure virtual functions",
328 TYPE_MAIN_DECL (type), type);
333 /* Print an error message for invalid use of an incomplete type.
334 VALUE is the expression that was used (or 0 if that isn't known)
335 and TYPE is the type that was invalid. DIAG_KIND indicates the
336 type of diagnostic (see diagnostic.def). */
339 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
340 diagnostic_t diag_kind)
344 gcc_assert (diag_kind == DK_WARNING
345 || diag_kind == DK_PEDWARN
346 || diag_kind == DK_ERROR);
348 /* Avoid duplicate error message. */
349 if (TREE_CODE (type) == ERROR_MARK)
352 if (value != 0 && (TREE_CODE (value) == VAR_DECL
353 || TREE_CODE (value) == PARM_DECL
354 || TREE_CODE (value) == FIELD_DECL))
356 emit_diagnostic (diag_kind, input_location, 0,
357 "%q+D has incomplete type", value);
361 /* We must print an error message. Be clever about what it says. */
363 switch (TREE_CODE (type))
369 emit_diagnostic (diag_kind, input_location, 0,
370 "invalid use of incomplete type %q#T", type);
371 if (!TYPE_TEMPLATE_INFO (type))
372 emit_diagnostic (diag_kind, input_location, 0,
373 "forward declaration of %q+#T", type);
375 emit_diagnostic (diag_kind, input_location, 0,
376 "declaration of %q+#T", type);
380 emit_diagnostic (diag_kind, input_location, 0,
381 "invalid use of %qT", type);
385 if (TYPE_DOMAIN (type))
387 type = TREE_TYPE (type);
390 emit_diagnostic (diag_kind, input_location, 0,
391 "invalid use of array with unspecified bounds");
396 emit_diagnostic (diag_kind, input_location, 0,
397 "invalid use of member (did you forget the %<&%> ?)");
400 case TEMPLATE_TYPE_PARM:
402 emit_diagnostic (diag_kind, input_location, 0,
403 "invalid use of %<auto%>");
405 emit_diagnostic (diag_kind, input_location, 0,
406 "invalid use of template type parameter %qT", type);
409 case BOUND_TEMPLATE_TEMPLATE_PARM:
410 emit_diagnostic (diag_kind, input_location, 0,
411 "invalid use of template template parameter %qT",
416 emit_diagnostic (diag_kind, input_location, 0,
417 "invalid use of dependent type %qT", type);
421 if (value && TREE_CODE (value) == COMPONENT_REF)
423 else if (value && TREE_CODE (value) == ADDR_EXPR)
424 emit_diagnostic (diag_kind, input_location, 0,
425 "address of overloaded function with no contextual "
427 else if (value && TREE_CODE (value) == OVERLOAD)
428 emit_diagnostic (diag_kind, input_location, 0,
429 "overloaded function with no contextual type information");
431 emit_diagnostic (diag_kind, input_location, 0,
432 "insufficient contextual information to determine type");
440 /* Backward-compatibility interface to incomplete_type_diagnostic;
441 required by ../tree.c. */
442 #undef cxx_incomplete_type_error
444 cxx_incomplete_type_error (const_tree value, const_tree type)
446 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
450 /* The recursive part of split_nonconstant_init. DEST is an lvalue
451 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
454 split_nonconstant_init_1 (tree dest, tree init)
456 unsigned HOST_WIDE_INT idx;
457 tree field_index, value;
458 tree type = TREE_TYPE (dest);
459 tree inner_type = NULL;
460 bool array_type_p = false;
462 switch (TREE_CODE (type))
465 inner_type = TREE_TYPE (type);
471 case QUAL_UNION_TYPE:
472 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
475 /* The current implementation of this algorithm assumes that
476 the field was set for all the elements. This is usually done
477 by process_init_constructor. */
478 gcc_assert (field_index);
481 inner_type = TREE_TYPE (field_index);
483 if (TREE_CODE (value) == CONSTRUCTOR)
488 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
489 NULL_TREE, NULL_TREE);
491 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
494 split_nonconstant_init_1 (sub, value);
496 else if (!initializer_constant_valid_p (value, inner_type))
501 /* FIXME: Ordered removal is O(1) so the whole function is
502 worst-case quadratic. This could be fixed using an aside
503 bitmap to record which elements must be removed and remove
504 them all at the same time. Or by merging
505 split_non_constant_init into process_init_constructor_array,
506 that is separating constants from non-constants while building
508 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
513 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
514 NULL_TREE, NULL_TREE);
516 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
519 code = build2 (INIT_EXPR, inner_type, sub, value);
520 code = build_stmt (EXPR_STMT, code);
528 if (!initializer_constant_valid_p (init, type))
531 tree cons = copy_node (init);
532 CONSTRUCTOR_ELTS (init) = NULL;
533 code = build2 (MODIFY_EXPR, type, dest, cons);
534 code = build_stmt (EXPR_STMT, code);
543 /* The rest of the initializer is now a constant. */
544 TREE_CONSTANT (init) = 1;
547 /* A subroutine of store_init_value. Splits non-constant static
548 initializer INIT into a constant part and generates code to
549 perform the non-constant part of the initialization to DEST.
550 Returns the code for the runtime init. */
553 split_nonconstant_init (tree dest, tree init)
557 if (TREE_CODE (init) == CONSTRUCTOR)
559 code = push_stmt_list ();
560 split_nonconstant_init_1 (dest, init);
561 code = pop_stmt_list (code);
562 DECL_INITIAL (dest) = init;
563 TREE_READONLY (dest) = 0;
566 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
571 /* Perform appropriate conversions on the initial value of a variable,
572 store it in the declaration DECL,
573 and print any error messages that are appropriate.
574 If the init is invalid, store an ERROR_MARK.
576 C++: Note that INIT might be a TREE_LIST, which would mean that it is
577 a base class initializer for some aggregate type, hopefully compatible
578 with DECL. If INIT is a single element, and DECL is an aggregate
579 type, we silently convert INIT into a TREE_LIST, allowing a constructor
582 If INIT is a TREE_LIST and there is no constructor, turn INIT
583 into a CONSTRUCTOR and use standard initialization techniques.
584 Perhaps a warning should be generated?
586 Returns code to be executed if initialization could not be performed
587 for static variable. In that case, caller must emit the code. */
590 store_init_value (tree decl, tree init)
594 /* If variable's type was invalidly declared, just ignore it. */
596 type = TREE_TYPE (decl);
597 if (TREE_CODE (type) == ERROR_MARK)
600 if (MAYBE_CLASS_TYPE_P (type))
602 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
603 || TREE_CODE (init) == CONSTRUCTOR);
605 if (TREE_CODE (init) == TREE_LIST)
607 error ("constructor syntax used, but no constructor declared "
608 "for type %qT", type);
609 init = build_constructor_from_list (init_list_type_node, nreverse (init));
612 else if (TREE_CODE (init) == TREE_LIST
613 && TREE_TYPE (init) != unknown_type_node)
615 if (TREE_CODE (decl) == RESULT_DECL)
616 init = build_x_compound_expr_from_list (init,
617 "return value initializer");
618 else if (TREE_CODE (init) == TREE_LIST
619 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
621 error ("cannot initialize arrays using this syntax");
625 /* We get here with code like `int a (2);' */
626 init = build_x_compound_expr_from_list (init, "initializer");
629 /* End of special C++ code. */
631 /* Digest the specified initializer into an expression. */
632 value = digest_init (type, init);
633 /* If the initializer is not a constant, fill in DECL_INITIAL with
634 the bits that are constant, and then return an expression that
635 will perform the dynamic initialization. */
636 if (value != error_mark_node
637 && (TREE_SIDE_EFFECTS (value)
638 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
639 return split_nonconstant_init (decl, value);
640 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
641 is an automatic variable, the middle end will turn this into a
642 dynamic initialization later. */
643 DECL_INITIAL (decl) = value;
648 /* Give errors about narrowing conversions within { }. */
651 check_narrowing (tree type, tree init)
653 tree ftype = unlowered_expr_type (init);
656 bool was_decl = false;
661 init = decl_constant_value (init);
664 if (TREE_CODE (type) == INTEGER_TYPE
665 && TREE_CODE (ftype) == REAL_TYPE)
667 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
668 && CP_INTEGRAL_TYPE_P (type))
670 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
671 && (TREE_CODE (init) != INTEGER_CST
672 || !int_fits_type_p (init, type)))
675 else if (TREE_CODE (ftype) == REAL_TYPE
676 && TREE_CODE (type) == REAL_TYPE)
678 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
681 if (TREE_CODE (init) == REAL_CST)
683 d = TREE_REAL_CST (init);
684 if (exact_real_truncate (TYPE_MODE (type), &d)
685 /* FIXME: As a temporary workaround for PR 36963, don't
686 complain about narrowing from a floating
687 literal. Hopefully this will be resolved at the
688 September 2008 C++ meeting. */
694 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
695 && TREE_CODE (type) == REAL_TYPE)
698 if (TREE_CODE (init) == INTEGER_CST)
700 d = real_value_from_int_cst (0, init);
701 if (exact_real_truncate (TYPE_MODE (type), &d))
707 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
711 /* Process the initializer INIT for a variable of type TYPE, emitting
712 diagnostics for invalid initializers and converting the initializer as
715 For aggregate types, it assumes that reshape_init has already run, thus the
716 initializer will have the right shape (brace elision has been undone).
718 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
721 digest_init_r (tree type, tree init, bool nested)
723 enum tree_code code = TREE_CODE (type);
725 if (init == error_mark_node)
726 return error_mark_node;
730 /* We must strip the outermost array type when completing the type,
731 because the its bounds might be incomplete at the moment. */
732 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
733 ? TREE_TYPE (type) : type, NULL_TREE))
734 return error_mark_node;
736 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
737 (g++.old-deja/g++.law/casts2.C). */
738 if (TREE_CODE (init) == NON_LVALUE_EXPR)
739 init = TREE_OPERAND (init, 0);
741 /* Initialization of an array of chars from a string constant. The initializer
742 can be optionally enclosed in braces, but reshape_init has already removed
743 them if they were present. */
744 if (code == ARRAY_TYPE)
746 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
747 if (char_type_p (typ1)
749 && TREE_CODE (init) == STRING_CST)
751 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
753 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
755 if (char_type != char_type_node)
757 error ("char-array initialized from wide string");
758 return error_mark_node;
763 if (char_type == char_type_node)
765 error ("int-array initialized from non-wide string");
766 return error_mark_node;
768 else if (char_type != typ1)
770 error ("int-array initialized from incompatible wide string");
771 return error_mark_node;
775 TREE_TYPE (init) = type;
776 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
778 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
779 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
780 /* In C it is ok to subtract 1 from the length of the string
781 because it's ok to ignore the terminating null char that is
782 counted in the length of the constant, but in C++ this would
784 if (size < TREE_STRING_LENGTH (init))
785 permerror (input_location, "initializer-string for array of chars is too long");
791 /* Handle scalar types (including conversions) and references. */
792 if (TREE_CODE (type) != COMPLEX_TYPE
793 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
797 if (cxx_dialect != cxx98 && nested)
798 check_narrowing (type, init);
799 init = convert_for_initialization (0, type, init, LOOKUP_NORMAL,
800 "initialization", NULL_TREE, 0,
801 tf_warning_or_error);
804 /* Skip any conversions since we'll be outputting the underlying
806 while (CONVERT_EXPR_P (*exp)
807 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
808 exp = &TREE_OPERAND (*exp, 0);
810 *exp = cplus_expand_constant (*exp);
815 /* Come here only for aggregates: records, arrays, unions, complex numbers
817 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
818 || TREE_CODE (type) == VECTOR_TYPE
819 || TREE_CODE (type) == RECORD_TYPE
820 || TREE_CODE (type) == UNION_TYPE
821 || TREE_CODE (type) == COMPLEX_TYPE);
823 if (BRACE_ENCLOSED_INITIALIZER_P (init))
824 return process_init_constructor (type, init);
827 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
829 error ("cannot initialize aggregate of type %qT with "
830 "a compound literal", type);
832 return error_mark_node;
835 if (TREE_CODE (type) == ARRAY_TYPE
836 && TREE_CODE (init) != CONSTRUCTOR)
838 error ("array must be initialized with a brace-enclosed"
840 return error_mark_node;
843 return convert_for_initialization (NULL_TREE, type, init,
844 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING,
845 "initialization", NULL_TREE, 0,
846 tf_warning_or_error);
851 digest_init (tree type, tree init)
853 return digest_init_r (type, init, false);
856 /* Set of flags used within process_init_constructor to describe the
858 #define PICFLAG_ERRONEOUS 1
859 #define PICFLAG_NOT_ALL_CONSTANT 2
860 #define PICFLAG_NOT_ALL_SIMPLE 4
862 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
866 picflag_from_initializer (tree init)
868 if (init == error_mark_node)
869 return PICFLAG_ERRONEOUS;
870 else if (!TREE_CONSTANT (init))
871 return PICFLAG_NOT_ALL_CONSTANT;
872 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
873 return PICFLAG_NOT_ALL_SIMPLE;
877 /* Subroutine of process_init_constructor, which will process an initializer
878 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
879 which describe the initializers. */
882 process_init_constructor_array (tree type, tree init)
884 unsigned HOST_WIDE_INT i, len = 0;
886 bool unbounded = false;
888 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
890 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
891 || TREE_CODE (type) == VECTOR_TYPE);
893 if (TREE_CODE (type) == ARRAY_TYPE)
895 tree domain = TYPE_DOMAIN (type);
897 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
898 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
901 unbounded = true; /* Take as many as there are. */
904 /* Vectors are like simple fixed-size arrays. */
905 len = TYPE_VECTOR_SUBPARTS (type);
907 /* There cannot be more initializers than needed as otherwise
908 reshape_init would have already rejected the initializer. */
910 gcc_assert (VEC_length (constructor_elt, v) <= len);
912 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
916 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
917 if (compare_tree_int (ce->index, i) != 0)
919 ce->value = error_mark_node;
920 sorry ("non-trivial designated initializers not supported");
924 ce->index = size_int (i);
925 gcc_assert (ce->value);
926 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true);
928 if (ce->value != error_mark_node)
929 gcc_assert (same_type_ignoring_top_level_qualifiers_p
930 (TREE_TYPE (type), TREE_TYPE (ce->value)));
932 flags |= picflag_from_initializer (ce->value);
935 /* No more initializers. If the array is unbounded, we are done. Otherwise,
936 we must add initializers ourselves. */
942 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
944 /* If this type needs constructors run for default-initialization,
945 we can't rely on the back end to do it for us, so build up
946 TARGET_EXPRs. If the type in question is a class, just build
947 one up; if it's an array, recurse. */
948 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
949 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
950 tf_warning_or_error);
952 next = build_constructor (init_list_type_node, NULL);
953 next = digest_init (TREE_TYPE (type), next);
955 else if (!zero_init_p (TREE_TYPE (type)))
956 next = build_zero_init (TREE_TYPE (type),
958 /*static_storage_p=*/false);
960 /* The default zero-initialization is fine for us; don't
961 add anything to the CONSTRUCTOR. */
964 flags |= picflag_from_initializer (next);
965 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
968 CONSTRUCTOR_ELTS (init) = v;
972 /* Subroutine of process_init_constructor, which will process an initializer
973 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
977 process_init_constructor_record (tree type, tree init)
979 VEC(constructor_elt,gc) *v = NULL;
982 unsigned HOST_WIDE_INT idx = 0;
984 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
985 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
986 gcc_assert (!TYPE_BINFO (type)
987 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
988 gcc_assert (!TYPE_POLYMORPHIC_P (type));
990 /* Generally, we will always have an index for each initializer (which is
991 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
992 reshape_init. So we need to handle both cases. */
993 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
998 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1000 flags |= picflag_from_initializer (integer_zero_node);
1001 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1005 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1008 /* If this is a bitfield, first convert to the declared type. */
1009 type = TREE_TYPE (field);
1010 if (DECL_BIT_FIELD_TYPE (field))
1011 type = DECL_BIT_FIELD_TYPE (field);
1013 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1015 constructor_elt *ce = VEC_index (constructor_elt,
1016 CONSTRUCTOR_ELTS (init), idx);
1019 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1020 latter case can happen in templates where lookup has to be
1022 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1023 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1024 if (ce->index != field
1025 && ce->index != DECL_NAME (field))
1027 ce->value = error_mark_node;
1028 sorry ("non-trivial designated initializers not supported");
1032 gcc_assert (ce->value);
1033 next = digest_init_r (type, ce->value, true);
1036 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1038 /* If this type needs constructors run for
1039 default-initialization, we can't rely on the back end to do it
1040 for us, so build up TARGET_EXPRs. If the type in question is
1041 a class, just build one up; if it's an array, recurse. */
1042 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1043 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1044 tf_warning_or_error);
1046 next = build_constructor (init_list_type_node, NULL);
1048 next = digest_init_r (TREE_TYPE (field), next, true);
1050 /* Warn when some struct elements are implicitly initialized. */
1051 warning (OPT_Wmissing_field_initializers,
1052 "missing initializer for member %qD", field);
1056 if (TREE_READONLY (field))
1057 error ("uninitialized const member %qD", field);
1058 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1059 error ("member %qD with uninitialized const fields", field);
1060 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1061 error ("member %qD is uninitialized reference", field);
1063 /* Warn when some struct elements are implicitly initialized
1065 warning (OPT_Wmissing_field_initializers,
1066 "missing initializer for member %qD", field);
1068 if (!zero_init_p (TREE_TYPE (field)))
1069 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1070 /*static_storage_p=*/false);
1072 /* The default zero-initialization is fine for us; don't
1073 add anything to the CONSTRUCTOR. */
1077 /* If this is a bitfield, now convert to the lowered type. */
1078 if (type != TREE_TYPE (field))
1079 next = cp_convert_and_check (TREE_TYPE (field), next);
1080 flags |= picflag_from_initializer (next);
1081 CONSTRUCTOR_APPEND_ELT (v, field, next);
1084 CONSTRUCTOR_ELTS (init) = v;
1088 /* Subroutine of process_init_constructor, which will process a single
1089 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1090 which describe the initializer. */
1093 process_init_constructor_union (tree type, tree init)
1095 constructor_elt *ce;
1097 /* If the initializer was empty, use default zero initialization. */
1098 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1101 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1);
1102 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1104 /* If this element specifies a field, initialize via that field. */
1107 if (TREE_CODE (ce->index) == FIELD_DECL)
1109 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1111 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1112 tree name = ce->index;
1114 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1115 if (DECL_NAME (field) == name)
1119 error ("no field %qD found in union being initialized", field);
1120 ce->value = error_mark_node;
1126 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1127 || TREE_CODE (ce->index) == RANGE_EXPR);
1128 error ("index value instead of field name in union initializer");
1129 ce->value = error_mark_node;
1134 /* Find the first named field. ANSI decided in September 1990
1135 that only named fields count here. */
1136 tree field = TYPE_FIELDS (type);
1137 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1138 field = TREE_CHAIN (field);
1143 if (ce->value && ce->value != error_mark_node)
1144 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true);
1146 return picflag_from_initializer (ce->value);
1149 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1150 constructor is a brace-enclosed initializer, and will be modified in-place.
1152 Each element is converted to the right type through digest_init, and
1153 missing initializers are added following the language rules (zero-padding,
1156 After the execution, the initializer will have TREE_CONSTANT if all elts are
1157 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1158 constants that the assembler and linker can compute them.
1160 The function returns the initializer itself, or error_mark_node in case
1164 process_init_constructor (tree type, tree init)
1168 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1170 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1171 flags = process_init_constructor_array (type, init);
1172 else if (TREE_CODE (type) == RECORD_TYPE)
1173 flags = process_init_constructor_record (type, init);
1174 else if (TREE_CODE (type) == UNION_TYPE)
1175 flags = process_init_constructor_union (type, init);
1179 if (flags & PICFLAG_ERRONEOUS)
1180 return error_mark_node;
1182 TREE_TYPE (init) = type;
1183 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1184 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1185 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1187 TREE_CONSTANT (init) = 1;
1188 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1189 TREE_STATIC (init) = 1;
1194 /* Given a structure or union value DATUM, construct and return
1195 the structure or union component which results from narrowing
1196 that value to the base specified in BASETYPE. For example, given the
1199 class L { int ii; };
1200 class A : L { ... };
1201 class B : L { ... };
1202 class C : A, B { ... };
1210 x.A::ii refers to the ii member of the L part of
1211 the A part of the C object named by X. In this case,
1212 DATUM would be x, and BASETYPE would be A.
1214 I used to think that this was nonconformant, that the standard specified
1215 that first we look up ii in A, then convert x to an L& and pull out the
1216 ii part. But in fact, it does say that we convert x to an A&; A here
1217 is known as the "naming class". (jason 2000-12-19)
1219 BINFO_P points to a variable initialized either to NULL_TREE or to the
1220 binfo for the specific base subobject we want to convert to. */
1223 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1227 if (datum == error_mark_node)
1228 return error_mark_node;
1232 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1234 if (!binfo || binfo == error_mark_node)
1236 *binfo_p = NULL_TREE;
1238 error_not_base_type (basetype, TREE_TYPE (datum));
1239 return error_mark_node;
1243 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1246 /* Build a reference to an object specified by the C++ `->' operator.
1247 Usually this just involves dereferencing the object, but if the
1248 `->' operator is overloaded, then such overloads must be
1249 performed until an object which does not have the `->' operator
1250 overloaded is found. An error is reported when circular pointer
1251 delegation is detected. */
1254 build_x_arrow (tree expr)
1256 tree orig_expr = expr;
1257 tree types_memoized = NULL_TREE;
1258 tree type = TREE_TYPE (expr);
1259 tree last_rval = NULL_TREE;
1261 if (type == error_mark_node)
1262 return error_mark_node;
1264 if (processing_template_decl)
1266 if (type_dependent_expression_p (expr))
1267 return build_min_nt (ARROW_EXPR, expr);
1268 expr = build_non_dependent_expr (expr);
1271 if (MAYBE_CLASS_TYPE_P (type))
1273 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1274 NULL_TREE, NULL_TREE,
1275 /*overloaded_p=*/NULL,
1276 tf_warning_or_error)))
1278 if (expr == error_mark_node)
1279 return error_mark_node;
1281 if (value_member (TREE_TYPE (expr), types_memoized))
1283 error ("circular pointer delegation detected");
1284 return error_mark_node;
1288 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1294 if (last_rval == NULL_TREE)
1296 error ("base operand of %<->%> has non-pointer type %qT", type);
1297 return error_mark_node;
1300 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1301 last_rval = convert_from_reference (last_rval);
1304 last_rval = decay_conversion (expr);
1306 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1308 if (processing_template_decl)
1310 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1311 /* It will be dereferenced. */
1312 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1316 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1320 error ("result of %<operator->()%> yields non-pointer result");
1322 error ("base operand of %<->%> is not a pointer");
1323 return error_mark_node;
1326 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1327 already been checked out to be of aggregate type. */
1330 build_m_component_ref (tree datum, tree component)
1338 if (error_operand_p (datum) || error_operand_p (component))
1339 return error_mark_node;
1341 ptrmem_type = TREE_TYPE (component);
1342 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1344 error ("%qE cannot be used as a member pointer, since it is of "
1346 component, ptrmem_type);
1347 return error_mark_node;
1350 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1351 if (! MAYBE_CLASS_TYPE_P (objtype))
1353 error ("cannot apply member pointer %qE to %qE, which is of "
1354 "non-class type %qT",
1355 component, datum, objtype);
1356 return error_mark_node;
1359 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1360 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1362 if (!COMPLETE_TYPE_P (ctype))
1364 if (!same_type_p (ctype, objtype))
1370 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1375 error ("pointer to member type %qT incompatible with object "
1378 return error_mark_node;
1380 else if (binfo == error_mark_node)
1381 return error_mark_node;
1384 if (TYPE_PTRMEM_P (ptrmem_type))
1388 /* Compute the type of the field, as described in [expr.ref].
1389 There's no such thing as a mutable pointer-to-member, so
1390 things are not as complex as they are for references to
1391 non-static data members. */
1392 type = cp_build_qualified_type (type,
1393 (cp_type_quals (type)
1394 | cp_type_quals (TREE_TYPE (datum))));
1396 datum = build_address (datum);
1398 /* Convert object to the correct base. */
1400 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1402 /* Build an expression for "object + offset" where offset is the
1403 value stored in the pointer-to-data-member. */
1404 ptype = build_pointer_type (type);
1405 datum = build2 (POINTER_PLUS_EXPR, ptype,
1406 fold_convert (ptype, datum),
1407 build_nop (sizetype, component));
1408 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1411 return build2 (OFFSET_REF, type, datum, component);
1414 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1417 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1419 /* This is either a call to a constructor,
1420 or a C cast in C++'s `functional' notation. */
1422 /* The type to which we are casting. */
1425 if (exp == error_mark_node || parms == error_mark_node)
1426 return error_mark_node;
1428 if (TREE_CODE (exp) == TYPE_DECL)
1429 type = TREE_TYPE (exp);
1433 if (processing_template_decl)
1435 tree t = build_min (CAST_EXPR, type, parms);
1436 /* We don't know if it will or will not have side effects. */
1437 TREE_SIDE_EFFECTS (t) = 1;
1441 if (! MAYBE_CLASS_TYPE_P (type))
1443 if (parms == NULL_TREE)
1444 return cp_convert (type, integer_zero_node);
1446 /* This must build a C cast. */
1447 parms = build_x_compound_expr_from_list (parms, "functional cast");
1448 return cp_build_c_cast (type, parms, complain);
1451 /* Prepare to evaluate as a call to a constructor. If this expression
1452 is actually used, for example,
1454 return X (arg1, arg2, ...);
1456 then the slot being initialized will be filled in. */
1458 if (!complete_type_or_else (type, NULL_TREE))
1459 return error_mark_node;
1460 if (abstract_virtuals_error (NULL_TREE, type))
1461 return error_mark_node;
1465 If the expression list is a single-expression, the type
1466 conversion is equivalent (in definedness, and if defined in
1467 meaning) to the corresponding cast expression. */
1468 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1469 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1473 The expression T(), where T is a simple-type-specifier for a
1474 non-array complete object type or the (possibly cv-qualified)
1475 void type, creates an rvalue of the specified type, which is
1476 value-initialized. */
1478 if (parms == NULL_TREE
1479 /* If there's a user-defined constructor, value-initialization is
1480 just calling the constructor, so fall through. */
1481 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1483 exp = build_value_init (type);
1484 return get_target_expr (exp);
1487 /* Call the constructor. */
1488 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1489 type, LOOKUP_NORMAL, complain);
1491 if (exp == error_mark_node)
1492 return error_mark_node;
1494 return build_cplus_new (type, exp);
1498 /* Add new exception specifier SPEC, to the LIST we currently have.
1499 If it's already in LIST then do nothing.
1500 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1501 know what we're doing. */
1504 add_exception_specifier (tree list, tree spec, int complain)
1509 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1511 if (spec == error_mark_node)
1514 gcc_assert (spec && (!list || TREE_VALUE (list)));
1516 /* [except.spec] 1, type in an exception specifier shall not be
1517 incomplete, or pointer or ref to incomplete other than pointer
1519 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1520 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1521 core = TREE_TYPE (core);
1524 else if (VOID_TYPE_P (core))
1526 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1528 else if (processing_template_decl)
1533 /* 15.4/1 says that types in an exception specifier must be complete,
1534 but it seems more reasonable to only require this on definitions
1535 and calls. So just give a pedwarn at this point; we will give an
1536 error later if we hit one of those two cases. */
1537 if (!COMPLETE_TYPE_P (complete_type (core)))
1538 diag_type = DK_PEDWARN; /* pedwarn */
1545 for (probe = list; probe; probe = TREE_CHAIN (probe))
1546 if (same_type_p (TREE_VALUE (probe), spec))
1549 list = tree_cons (NULL_TREE, spec, list);
1552 diag_type = DK_ERROR; /* error */
1554 if (diag_type != DK_UNSPECIFIED && complain)
1555 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1560 /* Combine the two exceptions specifier lists LIST and ADD, and return
1564 merge_exception_specifiers (tree list, tree add)
1568 else if (!TREE_VALUE (list))
1570 else if (!TREE_VALUE (add))
1574 tree orig_list = list;
1576 for (; add; add = TREE_CHAIN (add))
1578 tree spec = TREE_VALUE (add);
1581 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1582 if (same_type_p (TREE_VALUE (probe), spec))
1586 spec = build_tree_list (NULL_TREE, spec);
1587 TREE_CHAIN (spec) = list;
1595 /* Subroutine of build_call. Ensure that each of the types in the
1596 exception specification is complete. Technically, 15.4/1 says that
1597 they need to be complete when we see a declaration of the function,
1598 but we should be able to get away with only requiring this when the
1599 function is defined or called. See also add_exception_specifier. */
1602 require_complete_eh_spec_types (tree fntype, tree decl)
1605 /* Don't complain about calls to op new. */
1606 if (decl && DECL_ARTIFICIAL (decl))
1608 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1609 raises = TREE_CHAIN (raises))
1611 tree type = TREE_VALUE (raises);
1612 if (type && !COMPLETE_TYPE_P (type))
1616 ("call to function %qD which throws incomplete type %q#T",
1619 error ("call to function which throws incomplete type %q#T",
1626 #include "gt-cp-typeck2.h"