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:
401 emit_diagnostic (diag_kind, input_location, 0,
402 "invalid use of template type parameter %qT", type);
405 case BOUND_TEMPLATE_TEMPLATE_PARM:
406 emit_diagnostic (diag_kind, input_location, 0,
407 "invalid use of template template parameter %qT",
412 emit_diagnostic (diag_kind, input_location, 0,
413 "invalid use of dependent type %qT", type);
417 if (value && TREE_CODE (value) == COMPONENT_REF)
419 else if (value && TREE_CODE (value) == ADDR_EXPR)
420 emit_diagnostic (diag_kind, input_location, 0,
421 "address of overloaded function with no contextual "
423 else if (value && TREE_CODE (value) == OVERLOAD)
424 emit_diagnostic (diag_kind, input_location, 0,
425 "overloaded function with no contextual type information");
427 emit_diagnostic (diag_kind, input_location, 0,
428 "insufficient contextual information to determine type");
436 /* Backward-compatibility interface to incomplete_type_diagnostic;
437 required by ../tree.c. */
438 #undef cxx_incomplete_type_error
440 cxx_incomplete_type_error (const_tree value, const_tree type)
442 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
446 /* The recursive part of split_nonconstant_init. DEST is an lvalue
447 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
450 split_nonconstant_init_1 (tree dest, tree init)
452 unsigned HOST_WIDE_INT idx;
453 tree field_index, value;
454 tree type = TREE_TYPE (dest);
455 tree inner_type = NULL;
456 bool array_type_p = false;
458 switch (TREE_CODE (type))
461 inner_type = TREE_TYPE (type);
467 case QUAL_UNION_TYPE:
468 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
471 /* The current implementation of this algorithm assumes that
472 the field was set for all the elements. This is usually done
473 by process_init_constructor. */
474 gcc_assert (field_index);
477 inner_type = TREE_TYPE (field_index);
479 if (TREE_CODE (value) == CONSTRUCTOR)
484 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
485 NULL_TREE, NULL_TREE);
487 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
490 split_nonconstant_init_1 (sub, value);
492 else if (!initializer_constant_valid_p (value, inner_type))
497 /* FIXME: Ordered removal is O(1) so the whole function is
498 worst-case quadratic. This could be fixed using an aside
499 bitmap to record which elements must be removed and remove
500 them all at the same time. Or by merging
501 split_non_constant_init into process_init_constructor_array,
502 that is separating constants from non-constants while building
504 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
509 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
510 NULL_TREE, NULL_TREE);
512 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
515 code = build2 (INIT_EXPR, inner_type, sub, value);
516 code = build_stmt (EXPR_STMT, code);
524 if (!initializer_constant_valid_p (init, type))
527 tree cons = copy_node (init);
528 CONSTRUCTOR_ELTS (init) = NULL;
529 code = build2 (MODIFY_EXPR, type, dest, cons);
530 code = build_stmt (EXPR_STMT, code);
539 /* The rest of the initializer is now a constant. */
540 TREE_CONSTANT (init) = 1;
543 /* A subroutine of store_init_value. Splits non-constant static
544 initializer INIT into a constant part and generates code to
545 perform the non-constant part of the initialization to DEST.
546 Returns the code for the runtime init. */
549 split_nonconstant_init (tree dest, tree init)
553 if (TREE_CODE (init) == CONSTRUCTOR)
555 code = push_stmt_list ();
556 split_nonconstant_init_1 (dest, init);
557 code = pop_stmt_list (code);
558 DECL_INITIAL (dest) = init;
559 TREE_READONLY (dest) = 0;
562 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
567 /* Perform appropriate conversions on the initial value of a variable,
568 store it in the declaration DECL,
569 and print any error messages that are appropriate.
570 If the init is invalid, store an ERROR_MARK.
572 C++: Note that INIT might be a TREE_LIST, which would mean that it is
573 a base class initializer for some aggregate type, hopefully compatible
574 with DECL. If INIT is a single element, and DECL is an aggregate
575 type, we silently convert INIT into a TREE_LIST, allowing a constructor
578 If INIT is a TREE_LIST and there is no constructor, turn INIT
579 into a CONSTRUCTOR and use standard initialization techniques.
580 Perhaps a warning should be generated?
582 Returns code to be executed if initialization could not be performed
583 for static variable. In that case, caller must emit the code. */
586 store_init_value (tree decl, tree init)
590 /* If variable's type was invalidly declared, just ignore it. */
592 type = TREE_TYPE (decl);
593 if (TREE_CODE (type) == ERROR_MARK)
596 if (MAYBE_CLASS_TYPE_P (type))
598 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
599 || TREE_CODE (init) == CONSTRUCTOR);
601 if (TREE_CODE (init) == TREE_LIST)
603 error ("constructor syntax used, but no constructor declared "
604 "for type %qT", type);
605 init = build_constructor_from_list (init_list_type_node, nreverse (init));
608 else if (TREE_CODE (init) == TREE_LIST
609 && TREE_TYPE (init) != unknown_type_node)
611 if (TREE_CODE (decl) == RESULT_DECL)
612 init = build_x_compound_expr_from_list (init,
613 "return value initializer");
614 else if (TREE_CODE (init) == TREE_LIST
615 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
617 error ("cannot initialize arrays using this syntax");
621 /* We get here with code like `int a (2);' */
622 init = build_x_compound_expr_from_list (init, "initializer");
625 /* End of special C++ code. */
627 /* Digest the specified initializer into an expression. */
628 value = digest_init (type, init);
629 /* If the initializer is not a constant, fill in DECL_INITIAL with
630 the bits that are constant, and then return an expression that
631 will perform the dynamic initialization. */
632 if (value != error_mark_node
633 && (TREE_SIDE_EFFECTS (value)
634 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
635 return split_nonconstant_init (decl, value);
636 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
637 is an automatic variable, the middle end will turn this into a
638 dynamic initialization later. */
639 DECL_INITIAL (decl) = value;
644 /* Give errors about narrowing conversions within { }. */
647 check_narrowing (tree type, tree init)
649 tree ftype = TREE_TYPE (init);
652 bool was_decl = false;
657 init = decl_constant_value (init);
660 if (TREE_CODE (type) == INTEGER_TYPE
661 && TREE_CODE (ftype) == REAL_TYPE)
663 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
664 && CP_INTEGRAL_TYPE_P (type))
666 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
667 && (TREE_CODE (init) != INTEGER_CST
668 || !int_fits_type_p (init, type)))
671 else if (TREE_CODE (ftype) == REAL_TYPE
672 && TREE_CODE (type) == REAL_TYPE)
674 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
677 if (TREE_CODE (init) == REAL_CST)
679 d = TREE_REAL_CST (init);
680 if (exact_real_truncate (TYPE_MODE (type), &d)
681 /* FIXME: As a temporary workaround for PR 36963, don't
682 complain about narrowing from a floating
683 literal. Hopefully this will be resolved at the
684 September 2008 C++ meeting. */
690 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
691 && TREE_CODE (type) == REAL_TYPE)
694 if (TREE_CODE (init) == INTEGER_CST)
696 d = real_value_from_int_cst (0, init);
697 if (exact_real_truncate (TYPE_MODE (type), &d))
703 error ("narrowing conversion of %qE to %qT inside { }", init, type);
706 /* Process the initializer INIT for a variable of type TYPE, emitting
707 diagnostics for invalid initializers and converting the initializer as
710 For aggregate types, it assumes that reshape_init has already run, thus the
711 initializer will have the right shape (brace elision has been undone).
713 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
716 digest_init_r (tree type, tree init, bool nested)
718 enum tree_code code = TREE_CODE (type);
720 if (init == error_mark_node)
721 return error_mark_node;
725 /* We must strip the outermost array type when completing the type,
726 because the its bounds might be incomplete at the moment. */
727 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
728 ? TREE_TYPE (type) : type, NULL_TREE))
729 return error_mark_node;
731 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
732 (g++.old-deja/g++.law/casts2.C). */
733 if (TREE_CODE (init) == NON_LVALUE_EXPR)
734 init = TREE_OPERAND (init, 0);
736 /* Initialization of an array of chars from a string constant. The initializer
737 can be optionally enclosed in braces, but reshape_init has already removed
738 them if they were present. */
739 if (code == ARRAY_TYPE)
741 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
742 if (char_type_p (typ1)
744 && TREE_CODE (init) == STRING_CST)
746 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
748 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
750 if (char_type != char_type_node)
752 error ("char-array initialized from wide string");
753 return error_mark_node;
758 if (char_type == char_type_node)
760 error ("int-array initialized from non-wide string");
761 return error_mark_node;
763 else if (char_type != typ1)
765 error ("int-array initialized from incompatible wide string");
766 return error_mark_node;
770 TREE_TYPE (init) = type;
771 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
773 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
774 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
775 /* In C it is ok to subtract 1 from the length of the string
776 because it's ok to ignore the terminating null char that is
777 counted in the length of the constant, but in C++ this would
779 if (size < TREE_STRING_LENGTH (init))
780 permerror (input_location, "initializer-string for array of chars is too long");
786 /* Handle scalar types (including conversions) and references. */
787 if (TREE_CODE (type) != COMPLEX_TYPE
788 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
792 if (cxx_dialect != cxx98 && nested)
793 check_narrowing (type, init);
794 init = convert_for_initialization (0, type, init, LOOKUP_NORMAL,
795 "initialization", NULL_TREE, 0,
796 tf_warning_or_error);
799 /* Skip any conversions since we'll be outputting the underlying
801 while (CONVERT_EXPR_P (*exp)
802 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
803 exp = &TREE_OPERAND (*exp, 0);
805 *exp = cplus_expand_constant (*exp);
810 /* Come here only for aggregates: records, arrays, unions, complex numbers
812 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
813 || TREE_CODE (type) == VECTOR_TYPE
814 || TREE_CODE (type) == RECORD_TYPE
815 || TREE_CODE (type) == UNION_TYPE
816 || TREE_CODE (type) == COMPLEX_TYPE);
818 if (BRACE_ENCLOSED_INITIALIZER_P (init))
819 return process_init_constructor (type, init);
822 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
824 error ("cannot initialize aggregate of type %qT with "
825 "a compound literal", type);
827 return error_mark_node;
830 if (TREE_CODE (type) == ARRAY_TYPE
831 && TREE_CODE (init) != CONSTRUCTOR)
833 error ("array must be initialized with a brace-enclosed"
835 return error_mark_node;
838 return convert_for_initialization (NULL_TREE, type, init,
839 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING,
840 "initialization", NULL_TREE, 0,
841 tf_warning_or_error);
846 digest_init (tree type, tree init)
848 return digest_init_r (type, init, false);
851 /* Set of flags used within process_init_constructor to describe the
853 #define PICFLAG_ERRONEOUS 1
854 #define PICFLAG_NOT_ALL_CONSTANT 2
855 #define PICFLAG_NOT_ALL_SIMPLE 4
857 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
861 picflag_from_initializer (tree init)
863 if (init == error_mark_node)
864 return PICFLAG_ERRONEOUS;
865 else if (!TREE_CONSTANT (init))
866 return PICFLAG_NOT_ALL_CONSTANT;
867 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
868 return PICFLAG_NOT_ALL_SIMPLE;
872 /* Subroutine of process_init_constructor, which will process an initializer
873 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
874 which describe the initializers. */
877 process_init_constructor_array (tree type, tree init)
879 unsigned HOST_WIDE_INT i, len = 0;
881 bool unbounded = false;
883 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
885 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
886 || TREE_CODE (type) == VECTOR_TYPE);
888 if (TREE_CODE (type) == ARRAY_TYPE)
890 tree domain = TYPE_DOMAIN (type);
892 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
893 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
896 unbounded = true; /* Take as many as there are. */
899 /* Vectors are like simple fixed-size arrays. */
900 len = TYPE_VECTOR_SUBPARTS (type);
902 /* There cannot be more initializers than needed as otherwise
903 reshape_init would have already rejected the initializer. */
905 gcc_assert (VEC_length (constructor_elt, v) <= len);
907 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
911 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
912 if (compare_tree_int (ce->index, i) != 0)
914 ce->value = error_mark_node;
915 sorry ("non-trivial designated initializers not supported");
919 ce->index = size_int (i);
920 gcc_assert (ce->value);
921 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true);
923 if (ce->value != error_mark_node)
924 gcc_assert (same_type_ignoring_top_level_qualifiers_p
925 (TREE_TYPE (type), TREE_TYPE (ce->value)));
927 flags |= picflag_from_initializer (ce->value);
930 /* No more initializers. If the array is unbounded, we are done. Otherwise,
931 we must add initializers ourselves. */
937 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
939 /* If this type needs constructors run for default-initialization,
940 we can't rely on the back end to do it for us, so build up
941 TARGET_EXPRs. If the type in question is a class, just build
942 one up; if it's an array, recurse. */
943 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
944 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
945 tf_warning_or_error);
947 next = build_constructor (init_list_type_node, NULL);
948 next = digest_init (TREE_TYPE (type), next);
950 else if (!zero_init_p (TREE_TYPE (type)))
951 next = build_zero_init (TREE_TYPE (type),
953 /*static_storage_p=*/false);
955 /* The default zero-initialization is fine for us; don't
956 add anything to the CONSTRUCTOR. */
959 flags |= picflag_from_initializer (next);
960 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
963 CONSTRUCTOR_ELTS (init) = v;
967 /* Subroutine of process_init_constructor, which will process an initializer
968 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
972 process_init_constructor_record (tree type, tree init)
974 VEC(constructor_elt,gc) *v = NULL;
977 unsigned HOST_WIDE_INT idx = 0;
979 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
980 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
981 gcc_assert (!TYPE_BINFO (type)
982 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
983 gcc_assert (!TYPE_POLYMORPHIC_P (type));
985 /* Generally, we will always have an index for each initializer (which is
986 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
987 reshape_init. So we need to handle both cases. */
988 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
992 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
994 flags |= picflag_from_initializer (integer_zero_node);
995 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
999 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1002 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1004 constructor_elt *ce = VEC_index (constructor_elt,
1005 CONSTRUCTOR_ELTS (init), idx);
1008 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1009 latter case can happen in templates where lookup has to be
1011 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1012 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1013 if (ce->index != field
1014 && ce->index != DECL_NAME (field))
1016 ce->value = error_mark_node;
1017 sorry ("non-trivial designated initializers not supported");
1021 gcc_assert (ce->value);
1022 next = digest_init_r (TREE_TYPE (field), ce->value, true);
1025 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1027 /* If this type needs constructors run for
1028 default-initialization, we can't rely on the back end to do it
1029 for us, so build up TARGET_EXPRs. If the type in question is
1030 a class, just build one up; if it's an array, recurse. */
1031 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1032 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1033 tf_warning_or_error);
1035 next = build_constructor (init_list_type_node, NULL);
1037 next = digest_init_r (TREE_TYPE (field), next, true);
1039 /* Warn when some struct elements are implicitly initialized. */
1040 warning (OPT_Wmissing_field_initializers,
1041 "missing initializer for member %qD", field);
1045 if (TREE_READONLY (field))
1046 error ("uninitialized const member %qD", field);
1047 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1048 error ("member %qD with uninitialized const fields", field);
1049 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1050 error ("member %qD is uninitialized reference", field);
1052 /* Warn when some struct elements are implicitly initialized
1054 warning (OPT_Wmissing_field_initializers,
1055 "missing initializer for member %qD", field);
1057 if (!zero_init_p (TREE_TYPE (field)))
1058 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1059 /*static_storage_p=*/false);
1061 /* The default zero-initialization is fine for us; don't
1062 add anything to the CONSTRUCTOR. */
1066 flags |= picflag_from_initializer (next);
1067 CONSTRUCTOR_APPEND_ELT (v, field, next);
1070 CONSTRUCTOR_ELTS (init) = v;
1074 /* Subroutine of process_init_constructor, which will process a single
1075 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1076 which describe the initializer. */
1079 process_init_constructor_union (tree type, tree init)
1081 constructor_elt *ce;
1083 /* If the initializer was empty, use default zero initialization. */
1084 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1087 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1);
1088 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1090 /* If this element specifies a field, initialize via that field. */
1093 if (TREE_CODE (ce->index) == FIELD_DECL)
1095 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1097 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1098 tree name = ce->index;
1100 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1101 if (DECL_NAME (field) == name)
1105 error ("no field %qD found in union being initialized", field);
1106 ce->value = error_mark_node;
1112 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1113 || TREE_CODE (ce->index) == RANGE_EXPR);
1114 error ("index value instead of field name in union initializer");
1115 ce->value = error_mark_node;
1120 /* Find the first named field. ANSI decided in September 1990
1121 that only named fields count here. */
1122 tree field = TYPE_FIELDS (type);
1123 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1124 field = TREE_CHAIN (field);
1129 if (ce->value && ce->value != error_mark_node)
1130 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true);
1132 return picflag_from_initializer (ce->value);
1135 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1136 constructor is a brace-enclosed initializer, and will be modified in-place.
1138 Each element is converted to the right type through digest_init, and
1139 missing initializers are added following the language rules (zero-padding,
1142 After the execution, the initializer will have TREE_CONSTANT if all elts are
1143 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1144 constants that the assembler and linker can compute them.
1146 The function returns the initializer itself, or error_mark_node in case
1150 process_init_constructor (tree type, tree init)
1154 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1156 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1157 flags = process_init_constructor_array (type, init);
1158 else if (TREE_CODE (type) == RECORD_TYPE)
1159 flags = process_init_constructor_record (type, init);
1160 else if (TREE_CODE (type) == UNION_TYPE)
1161 flags = process_init_constructor_union (type, init);
1165 if (flags & PICFLAG_ERRONEOUS)
1166 return error_mark_node;
1168 TREE_TYPE (init) = type;
1169 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1170 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1171 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1173 TREE_CONSTANT (init) = 1;
1174 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1175 TREE_STATIC (init) = 1;
1180 /* Given a structure or union value DATUM, construct and return
1181 the structure or union component which results from narrowing
1182 that value to the base specified in BASETYPE. For example, given the
1185 class L { int ii; };
1186 class A : L { ... };
1187 class B : L { ... };
1188 class C : A, B { ... };
1196 x.A::ii refers to the ii member of the L part of
1197 the A part of the C object named by X. In this case,
1198 DATUM would be x, and BASETYPE would be A.
1200 I used to think that this was nonconformant, that the standard specified
1201 that first we look up ii in A, then convert x to an L& and pull out the
1202 ii part. But in fact, it does say that we convert x to an A&; A here
1203 is known as the "naming class". (jason 2000-12-19)
1205 BINFO_P points to a variable initialized either to NULL_TREE or to the
1206 binfo for the specific base subobject we want to convert to. */
1209 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1213 if (datum == error_mark_node)
1214 return error_mark_node;
1218 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1220 if (!binfo || binfo == error_mark_node)
1222 *binfo_p = NULL_TREE;
1224 error_not_base_type (basetype, TREE_TYPE (datum));
1225 return error_mark_node;
1229 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1232 /* Build a reference to an object specified by the C++ `->' operator.
1233 Usually this just involves dereferencing the object, but if the
1234 `->' operator is overloaded, then such overloads must be
1235 performed until an object which does not have the `->' operator
1236 overloaded is found. An error is reported when circular pointer
1237 delegation is detected. */
1240 build_x_arrow (tree expr)
1242 tree orig_expr = expr;
1243 tree types_memoized = NULL_TREE;
1244 tree type = TREE_TYPE (expr);
1245 tree last_rval = NULL_TREE;
1247 if (type == error_mark_node)
1248 return error_mark_node;
1250 if (processing_template_decl)
1252 if (type_dependent_expression_p (expr))
1253 return build_min_nt (ARROW_EXPR, expr);
1254 expr = build_non_dependent_expr (expr);
1257 if (MAYBE_CLASS_TYPE_P (type))
1259 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1260 NULL_TREE, NULL_TREE,
1261 /*overloaded_p=*/NULL,
1262 tf_warning_or_error)))
1264 if (expr == error_mark_node)
1265 return error_mark_node;
1267 if (value_member (TREE_TYPE (expr), types_memoized))
1269 error ("circular pointer delegation detected");
1270 return error_mark_node;
1274 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1280 if (last_rval == NULL_TREE)
1282 error ("base operand of %<->%> has non-pointer type %qT", type);
1283 return error_mark_node;
1286 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1287 last_rval = convert_from_reference (last_rval);
1290 last_rval = decay_conversion (expr);
1292 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1294 if (processing_template_decl)
1296 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1297 /* It will be dereferenced. */
1298 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1302 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1306 error ("result of %<operator->()%> yields non-pointer result");
1308 error ("base operand of %<->%> is not a pointer");
1309 return error_mark_node;
1312 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1313 already been checked out to be of aggregate type. */
1316 build_m_component_ref (tree datum, tree component)
1324 if (error_operand_p (datum) || error_operand_p (component))
1325 return error_mark_node;
1327 ptrmem_type = TREE_TYPE (component);
1328 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1330 error ("%qE cannot be used as a member pointer, since it is of "
1332 component, ptrmem_type);
1333 return error_mark_node;
1336 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1337 if (! MAYBE_CLASS_TYPE_P (objtype))
1339 error ("cannot apply member pointer %qE to %qE, which is of "
1340 "non-class type %qT",
1341 component, datum, objtype);
1342 return error_mark_node;
1345 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1346 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1348 if (!COMPLETE_TYPE_P (ctype))
1350 if (!same_type_p (ctype, objtype))
1356 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1361 error ("pointer to member type %qT incompatible with object "
1364 return error_mark_node;
1366 else if (binfo == error_mark_node)
1367 return error_mark_node;
1370 if (TYPE_PTRMEM_P (ptrmem_type))
1374 /* Compute the type of the field, as described in [expr.ref].
1375 There's no such thing as a mutable pointer-to-member, so
1376 things are not as complex as they are for references to
1377 non-static data members. */
1378 type = cp_build_qualified_type (type,
1379 (cp_type_quals (type)
1380 | cp_type_quals (TREE_TYPE (datum))));
1382 datum = build_address (datum);
1384 /* Convert object to the correct base. */
1386 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1388 /* Build an expression for "object + offset" where offset is the
1389 value stored in the pointer-to-data-member. */
1390 ptype = build_pointer_type (type);
1391 datum = build2 (POINTER_PLUS_EXPR, ptype,
1392 fold_convert (ptype, datum),
1393 build_nop (sizetype, component));
1394 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1397 return build2 (OFFSET_REF, type, datum, component);
1400 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1403 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1405 /* This is either a call to a constructor,
1406 or a C cast in C++'s `functional' notation. */
1408 /* The type to which we are casting. */
1411 if (exp == error_mark_node || parms == error_mark_node)
1412 return error_mark_node;
1414 if (TREE_CODE (exp) == TYPE_DECL)
1415 type = TREE_TYPE (exp);
1419 if (processing_template_decl)
1421 tree t = build_min (CAST_EXPR, type, parms);
1422 /* We don't know if it will or will not have side effects. */
1423 TREE_SIDE_EFFECTS (t) = 1;
1427 if (! MAYBE_CLASS_TYPE_P (type))
1429 if (parms == NULL_TREE)
1430 return cp_convert (type, integer_zero_node);
1432 /* This must build a C cast. */
1433 parms = build_x_compound_expr_from_list (parms, "functional cast");
1434 return cp_build_c_cast (type, parms, complain);
1437 /* Prepare to evaluate as a call to a constructor. If this expression
1438 is actually used, for example,
1440 return X (arg1, arg2, ...);
1442 then the slot being initialized will be filled in. */
1444 if (!complete_type_or_else (type, NULL_TREE))
1445 return error_mark_node;
1446 if (abstract_virtuals_error (NULL_TREE, type))
1447 return error_mark_node;
1451 If the expression list is a single-expression, the type
1452 conversion is equivalent (in definedness, and if defined in
1453 meaning) to the corresponding cast expression. */
1454 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1455 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1459 The expression T(), where T is a simple-type-specifier for a
1460 non-array complete object type or the (possibly cv-qualified)
1461 void type, creates an rvalue of the specified type, which is
1462 value-initialized. */
1464 if (parms == NULL_TREE
1465 /* If there's a user-defined constructor, value-initialization is
1466 just calling the constructor, so fall through. */
1467 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1469 exp = build_value_init (type);
1470 return get_target_expr (exp);
1473 /* Call the constructor. */
1474 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1475 type, LOOKUP_NORMAL, complain);
1477 if (exp == error_mark_node)
1478 return error_mark_node;
1480 return build_cplus_new (type, exp);
1484 /* Add new exception specifier SPEC, to the LIST we currently have.
1485 If it's already in LIST then do nothing.
1486 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1487 know what we're doing. */
1490 add_exception_specifier (tree list, tree spec, int complain)
1495 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1497 if (spec == error_mark_node)
1500 gcc_assert (spec && (!list || TREE_VALUE (list)));
1502 /* [except.spec] 1, type in an exception specifier shall not be
1503 incomplete, or pointer or ref to incomplete other than pointer
1505 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1506 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1507 core = TREE_TYPE (core);
1510 else if (VOID_TYPE_P (core))
1512 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1514 else if (processing_template_decl)
1519 /* 15.4/1 says that types in an exception specifier must be complete,
1520 but it seems more reasonable to only require this on definitions
1521 and calls. So just give a pedwarn at this point; we will give an
1522 error later if we hit one of those two cases. */
1523 if (!COMPLETE_TYPE_P (complete_type (core)))
1524 diag_type = DK_PEDWARN; /* pedwarn */
1531 for (probe = list; probe; probe = TREE_CHAIN (probe))
1532 if (same_type_p (TREE_VALUE (probe), spec))
1535 list = tree_cons (NULL_TREE, spec, list);
1538 diag_type = DK_ERROR; /* error */
1540 if (diag_type != DK_UNSPECIFIED && complain)
1541 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1546 /* Combine the two exceptions specifier lists LIST and ADD, and return
1550 merge_exception_specifiers (tree list, tree add)
1554 else if (!TREE_VALUE (list))
1556 else if (!TREE_VALUE (add))
1560 tree orig_list = list;
1562 for (; add; add = TREE_CHAIN (add))
1564 tree spec = TREE_VALUE (add);
1567 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1568 if (same_type_p (TREE_VALUE (probe), spec))
1572 spec = build_tree_list (NULL_TREE, spec);
1573 TREE_CHAIN (spec) = list;
1581 /* Subroutine of build_call. Ensure that each of the types in the
1582 exception specification is complete. Technically, 15.4/1 says that
1583 they need to be complete when we see a declaration of the function,
1584 but we should be able to get away with only requiring this when the
1585 function is defined or called. See also add_exception_specifier. */
1588 require_complete_eh_spec_types (tree fntype, tree decl)
1591 /* Don't complain about calls to op new. */
1592 if (decl && DECL_ARTIFICIAL (decl))
1594 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1595 raises = TREE_CHAIN (raises))
1597 tree type = TREE_VALUE (raises);
1598 if (type && !COMPLETE_TYPE_P (type))
1602 ("call to function %qD which throws incomplete type %q#T",
1605 error ("call to function which throws incomplete type %q#T",
1612 #include "gt-cp-typeck2.h"