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
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 GTY((chain_next ("%h.next"))) pending_abstract_type {
116 /* Declaration which we are checking for abstractness. It is either
117 a DECL node, or an IDENTIFIER_NODE if we do not have a full
118 declaration available. */
121 /* Type which will be checked for abstractness. */
124 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
125 because DECLs already carry locus information. */
128 /* Link to the next element in list. */
129 struct pending_abstract_type* next;
133 /* Compute the hash value of the node VAL. This function is used by the
134 hash table abstract_pending_vars. */
137 pat_calc_hash (const void* val)
139 const struct pending_abstract_type *pat =
140 (const struct pending_abstract_type *) val;
141 return (hashval_t) TYPE_UID (pat->type);
145 /* Compare node VAL1 with the type VAL2. This function is used by the
146 hash table abstract_pending_vars. */
149 pat_compare (const void* val1, const void* val2)
151 const struct pending_abstract_type *const pat1 =
152 (const struct pending_abstract_type *) val1;
153 const_tree const type2 = (const_tree)val2;
155 return (pat1->type == type2);
158 /* Hash table that maintains pending_abstract_type nodes, for which we still
159 need to check for type abstractness. The key of the table is the type
160 of the declaration. */
161 static GTY ((param_is (struct pending_abstract_type)))
162 htab_t abstract_pending_vars = NULL;
165 /* This function is called after TYPE is completed, and will check if there
166 are pending declarations for which we still need to verify the abstractness
167 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
168 turned out to be incomplete. */
171 complete_type_check_abstract (tree type)
174 struct pending_abstract_type *pat;
175 location_t cur_loc = input_location;
177 gcc_assert (COMPLETE_TYPE_P (type));
179 if (!abstract_pending_vars)
182 /* Retrieve the list of pending declarations for this type. */
183 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
184 (hashval_t)TYPE_UID (type), NO_INSERT);
187 pat = (struct pending_abstract_type*)*slot;
190 /* If the type is not abstract, do not do anything. */
191 if (CLASSTYPE_PURE_VIRTUALS (type))
193 struct pending_abstract_type *prev = 0, *next;
195 /* Reverse the list to emit the errors in top-down order. */
196 for (; pat; pat = next)
204 /* Go through the list, and call abstract_virtuals_error for each
205 element: it will issue a diagnostic if the type is abstract. */
208 gcc_assert (type == pat->type);
210 /* Tweak input_location so that the diagnostic appears at the correct
211 location. Notice that this is only needed if the decl is an
213 input_location = pat->locus;
214 abstract_virtuals_error (pat->decl, pat->type);
219 htab_clear_slot (abstract_pending_vars, slot);
221 input_location = cur_loc;
225 /* If TYPE has abstract virtual functions, issue an error about trying
226 to create an object of that type. DECL is the object declared, or
227 NULL_TREE if the declaration is unavailable. Returns 1 if an error
228 occurred; zero if all was well. */
231 abstract_virtuals_error (tree decl, tree type)
235 /* This function applies only to classes. Any other entity can never
237 if (!CLASS_TYPE_P (type))
240 /* If the type is incomplete, we register it within a hash table,
241 so that we can check again once it is completed. This makes sense
242 only for objects for which we have a declaration or at least a
244 if (!COMPLETE_TYPE_P (type))
247 struct pending_abstract_type *pat;
249 gcc_assert (!decl || DECL_P (decl)
250 || TREE_CODE (decl) == IDENTIFIER_NODE);
252 if (!abstract_pending_vars)
253 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
256 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
257 (hashval_t)TYPE_UID (type), INSERT);
259 pat = GGC_NEW (struct pending_abstract_type);
262 pat->locus = ((decl && DECL_P (decl))
263 ? DECL_SOURCE_LOCATION (decl)
266 pat->next = (struct pending_abstract_type *) *slot;
272 if (!TYPE_SIZE (type))
273 /* TYPE is being defined, and during that time
274 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
277 pure = CLASSTYPE_PURE_VIRTUALS (type);
283 if (TREE_CODE (decl) == RESULT_DECL)
286 if (TREE_CODE (decl) == VAR_DECL)
287 error ("cannot declare variable %q+D to be of abstract "
288 "type %qT", decl, type);
289 else if (TREE_CODE (decl) == PARM_DECL)
290 error ("cannot declare parameter %q+D to be of abstract type %qT",
292 else if (TREE_CODE (decl) == FIELD_DECL)
293 error ("cannot declare field %q+D to be of abstract type %qT",
295 else if (TREE_CODE (decl) == FUNCTION_DECL
296 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
297 error ("invalid abstract return type for member function %q+#D", decl);
298 else if (TREE_CODE (decl) == FUNCTION_DECL)
299 error ("invalid abstract return type for function %q+#D", decl);
300 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
301 /* Here we do not have location information. */
302 error ("invalid abstract type %qT for %qE", type, decl);
304 error ("invalid abstract type for %q+D", decl);
307 error ("cannot allocate an object of abstract type %qT", type);
309 /* Only go through this once. */
310 if (VEC_length (tree, pure))
315 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
316 " because the following virtual functions are pure within %qT:",
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 (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
328 " since type %qT has pure virtual functions",
334 /* Print an error message for invalid use of an incomplete type.
335 VALUE is the expression that was used (or 0 if that isn't known)
336 and TYPE is the type that was invalid. DIAG_KIND indicates the
337 type of diagnostic (see diagnostic.def). */
340 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
341 diagnostic_t diag_kind)
345 gcc_assert (diag_kind == DK_WARNING
346 || diag_kind == DK_PEDWARN
347 || diag_kind == DK_ERROR);
349 /* Avoid duplicate error message. */
350 if (TREE_CODE (type) == ERROR_MARK)
353 if (value != 0 && (TREE_CODE (value) == VAR_DECL
354 || TREE_CODE (value) == PARM_DECL
355 || TREE_CODE (value) == FIELD_DECL))
357 emit_diagnostic (diag_kind, input_location, 0,
358 "%q+D has incomplete type", value);
362 /* We must print an error message. Be clever about what it says. */
364 switch (TREE_CODE (type))
370 emit_diagnostic (diag_kind, input_location, 0,
371 "invalid use of incomplete type %q#T", type);
372 if (!TYPE_TEMPLATE_INFO (type))
373 emit_diagnostic (diag_kind, input_location, 0,
374 "forward declaration of %q+#T", type);
376 emit_diagnostic (diag_kind, input_location, 0,
377 "declaration of %q+#T", type);
381 emit_diagnostic (diag_kind, input_location, 0,
382 "invalid use of %qT", type);
386 if (TYPE_DOMAIN (type))
388 type = TREE_TYPE (type);
391 emit_diagnostic (diag_kind, input_location, 0,
392 "invalid use of array with unspecified bounds");
397 emit_diagnostic (diag_kind, input_location, 0,
398 "invalid use of member (did you forget the %<&%> ?)");
401 case TEMPLATE_TYPE_PARM:
403 emit_diagnostic (diag_kind, input_location, 0,
404 "invalid use of %<auto%>");
406 emit_diagnostic (diag_kind, input_location, 0,
407 "invalid use of template type parameter %qT", type);
410 case BOUND_TEMPLATE_TEMPLATE_PARM:
411 emit_diagnostic (diag_kind, input_location, 0,
412 "invalid use of template template parameter %qT",
417 emit_diagnostic (diag_kind, input_location, 0,
418 "invalid use of dependent type %qT", type);
422 if (value && TREE_CODE (value) == COMPONENT_REF)
424 else if (value && TREE_CODE (value) == ADDR_EXPR)
425 emit_diagnostic (diag_kind, input_location, 0,
426 "address of overloaded function with no contextual "
428 else if (value && TREE_CODE (value) == OVERLOAD)
429 emit_diagnostic (diag_kind, input_location, 0,
430 "overloaded function with no contextual type information");
432 emit_diagnostic (diag_kind, input_location, 0,
433 "insufficient contextual information to determine type");
441 /* Backward-compatibility interface to incomplete_type_diagnostic;
442 required by ../tree.c. */
443 #undef cxx_incomplete_type_error
445 cxx_incomplete_type_error (const_tree value, const_tree type)
447 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
451 /* The recursive part of split_nonconstant_init. DEST is an lvalue
452 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
455 split_nonconstant_init_1 (tree dest, tree init)
457 unsigned HOST_WIDE_INT idx;
458 tree field_index, value;
459 tree type = TREE_TYPE (dest);
460 tree inner_type = NULL;
461 bool array_type_p = false;
463 switch (TREE_CODE (type))
466 inner_type = TREE_TYPE (type);
472 case QUAL_UNION_TYPE:
473 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
476 /* The current implementation of this algorithm assumes that
477 the field was set for all the elements. This is usually done
478 by process_init_constructor. */
479 gcc_assert (field_index);
482 inner_type = TREE_TYPE (field_index);
484 if (TREE_CODE (value) == CONSTRUCTOR)
489 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
490 NULL_TREE, NULL_TREE);
492 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
495 split_nonconstant_init_1 (sub, value);
497 else if (!initializer_constant_valid_p (value, inner_type))
502 /* FIXME: Ordered removal is O(1) so the whole function is
503 worst-case quadratic. This could be fixed using an aside
504 bitmap to record which elements must be removed and remove
505 them all at the same time. Or by merging
506 split_non_constant_init into process_init_constructor_array,
507 that is separating constants from non-constants while building
509 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
514 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
515 NULL_TREE, NULL_TREE);
517 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
520 code = build2 (INIT_EXPR, inner_type, sub, value);
521 code = build_stmt (input_location, EXPR_STMT, code);
529 if (!initializer_constant_valid_p (init, type))
532 tree cons = copy_node (init);
533 CONSTRUCTOR_ELTS (init) = NULL;
534 code = build2 (MODIFY_EXPR, type, dest, cons);
535 code = build_stmt (input_location, EXPR_STMT, code);
544 /* The rest of the initializer is now a constant. */
545 TREE_CONSTANT (init) = 1;
548 /* A subroutine of store_init_value. Splits non-constant static
549 initializer INIT into a constant part and generates code to
550 perform the non-constant part of the initialization to DEST.
551 Returns the code for the runtime init. */
554 split_nonconstant_init (tree dest, tree init)
558 if (TREE_CODE (init) == CONSTRUCTOR)
560 code = push_stmt_list ();
561 split_nonconstant_init_1 (dest, init);
562 code = pop_stmt_list (code);
563 DECL_INITIAL (dest) = init;
564 TREE_READONLY (dest) = 0;
567 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
572 /* Perform appropriate conversions on the initial value of a variable,
573 store it in the declaration DECL,
574 and print any error messages that are appropriate.
575 If the init is invalid, store an ERROR_MARK.
577 C++: Note that INIT might be a TREE_LIST, which would mean that it is
578 a base class initializer for some aggregate type, hopefully compatible
579 with DECL. If INIT is a single element, and DECL is an aggregate
580 type, we silently convert INIT into a TREE_LIST, allowing a constructor
583 If INIT is a TREE_LIST and there is no constructor, turn INIT
584 into a CONSTRUCTOR and use standard initialization techniques.
585 Perhaps a warning should be generated?
587 Returns code to be executed if initialization could not be performed
588 for static variable. In that case, caller must emit the code. */
591 store_init_value (tree decl, tree init, int flags)
595 /* If variable's type was invalidly declared, just ignore it. */
597 type = TREE_TYPE (decl);
598 if (TREE_CODE (type) == ERROR_MARK)
601 if (MAYBE_CLASS_TYPE_P (type))
603 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
604 || TREE_CODE (init) == CONSTRUCTOR);
606 if (TREE_CODE (init) == TREE_LIST)
608 error ("constructor syntax used, but no constructor declared "
609 "for type %qT", type);
610 init = build_constructor_from_list (init_list_type_node, nreverse (init));
613 else if (TREE_CODE (init) == TREE_LIST
614 && TREE_TYPE (init) != unknown_type_node)
616 if (TREE_CODE (decl) == RESULT_DECL)
617 init = build_x_compound_expr_from_list (init,
618 "return value initializer");
619 else if (TREE_CODE (init) == TREE_LIST
620 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
622 error ("cannot initialize arrays using this syntax");
626 /* We get here with code like `int a (2);' */
627 init = build_x_compound_expr_from_list (init, "initializer");
630 /* End of special C++ code. */
632 /* Digest the specified initializer into an expression. */
633 value = digest_init_flags (type, init, flags);
634 /* If the initializer is not a constant, fill in DECL_INITIAL with
635 the bits that are constant, and then return an expression that
636 will perform the dynamic initialization. */
637 if (value != error_mark_node
638 && (TREE_SIDE_EFFECTS (value)
639 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
640 return split_nonconstant_init (decl, value);
641 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
642 is an automatic variable, the middle end will turn this into a
643 dynamic initialization later. */
644 DECL_INITIAL (decl) = value;
649 /* Give errors about narrowing conversions within { }. */
652 check_narrowing (tree type, tree init)
654 tree ftype = unlowered_expr_type (init);
657 bool was_decl = false;
662 init = decl_constant_value (init);
665 if (TREE_CODE (type) == INTEGER_TYPE
666 && TREE_CODE (ftype) == REAL_TYPE)
668 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
669 && CP_INTEGRAL_TYPE_P (type))
671 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
672 && (TREE_CODE (init) != INTEGER_CST
673 || !int_fits_type_p (init, type)))
676 else if (TREE_CODE (ftype) == REAL_TYPE
677 && TREE_CODE (type) == REAL_TYPE)
679 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
681 if (TREE_CODE (init) == REAL_CST)
683 /* Issue 703: Loss of precision is OK as long as the value is
684 within the representable range of the new type. */
686 d = TREE_REAL_CST (init);
687 real_convert (&r, TYPE_MODE (type), &d);
695 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
696 && TREE_CODE (type) == REAL_TYPE)
699 if (TREE_CODE (init) == INTEGER_CST)
701 d = real_value_from_int_cst (0, init);
702 if (exact_real_truncate (TYPE_MODE (type), &d))
708 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
712 /* Process the initializer INIT for a variable of type TYPE, emitting
713 diagnostics for invalid initializers and converting the initializer as
716 For aggregate types, it assumes that reshape_init has already run, thus the
717 initializer will have the right shape (brace elision has been undone).
719 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
722 digest_init_r (tree type, tree init, bool nested, int flags)
724 enum tree_code code = TREE_CODE (type);
726 if (init == error_mark_node)
727 return error_mark_node;
731 /* We must strip the outermost array type when completing the type,
732 because the its bounds might be incomplete at the moment. */
733 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
734 ? TREE_TYPE (type) : type, NULL_TREE))
735 return error_mark_node;
737 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
738 (g++.old-deja/g++.law/casts2.C). */
739 if (TREE_CODE (init) == NON_LVALUE_EXPR)
740 init = TREE_OPERAND (init, 0);
742 /* Initialization of an array of chars from a string constant. The initializer
743 can be optionally enclosed in braces, but reshape_init has already removed
744 them if they were present. */
745 if (code == ARRAY_TYPE)
747 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
748 if (char_type_p (typ1)
750 && TREE_CODE (init) == STRING_CST)
752 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
754 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
756 if (char_type != char_type_node)
758 error ("char-array initialized from wide string");
759 return error_mark_node;
764 if (char_type == char_type_node)
766 error ("int-array initialized from non-wide string");
767 return error_mark_node;
769 else if (char_type != typ1)
771 error ("int-array initialized from incompatible wide string");
772 return error_mark_node;
776 TREE_TYPE (init) = type;
777 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
779 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
780 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
781 /* In C it is ok to subtract 1 from the length of the string
782 because it's ok to ignore the terminating null char that is
783 counted in the length of the constant, but in C++ this would
785 if (size < TREE_STRING_LENGTH (init))
786 permerror (input_location, "initializer-string for array of chars is too long");
792 /* Handle scalar types (including conversions) and references. */
793 if ((TREE_CODE (type) != COMPLEX_TYPE
794 || BRACE_ENCLOSED_INITIALIZER_P (init))
795 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
799 if (cxx_dialect != cxx98 && nested)
800 check_narrowing (type, init);
801 init = convert_for_initialization (0, type, init, flags,
802 "initialization", NULL_TREE, 0,
803 tf_warning_or_error);
806 /* Skip any conversions since we'll be outputting the underlying
808 while (CONVERT_EXPR_P (*exp)
809 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
810 exp = &TREE_OPERAND (*exp, 0);
812 *exp = cplus_expand_constant (*exp);
817 /* Come here only for aggregates: records, arrays, unions, complex numbers
819 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
820 || TREE_CODE (type) == VECTOR_TYPE
821 || TREE_CODE (type) == RECORD_TYPE
822 || TREE_CODE (type) == UNION_TYPE
823 || TREE_CODE (type) == COMPLEX_TYPE);
825 if (BRACE_ENCLOSED_INITIALIZER_P (init)
826 && !TYPE_NON_AGGREGATE_CLASS (type))
827 return process_init_constructor (type, init);
830 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
832 error ("cannot initialize aggregate of type %qT with "
833 "a compound literal", type);
835 return error_mark_node;
838 if (TREE_CODE (type) == ARRAY_TYPE
839 && TREE_CODE (init) != CONSTRUCTOR)
841 /* Allow the result of build_array_copy. */
842 if (TREE_CODE (init) == TARGET_EXPR
843 && (same_type_ignoring_top_level_qualifiers_p
844 (type, TREE_TYPE (init))))
847 error ("array must be initialized with a brace-enclosed"
849 return error_mark_node;
852 return convert_for_initialization (NULL_TREE, type, init,
854 "initialization", NULL_TREE, 0,
855 tf_warning_or_error);
860 digest_init (tree type, tree init)
862 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
866 digest_init_flags (tree type, tree init, int flags)
868 return digest_init_r (type, init, false, flags);
871 /* Set of flags used within process_init_constructor to describe the
873 #define PICFLAG_ERRONEOUS 1
874 #define PICFLAG_NOT_ALL_CONSTANT 2
875 #define PICFLAG_NOT_ALL_SIMPLE 4
877 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
881 picflag_from_initializer (tree init)
883 if (init == error_mark_node)
884 return PICFLAG_ERRONEOUS;
885 else if (!TREE_CONSTANT (init))
886 return PICFLAG_NOT_ALL_CONSTANT;
887 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
888 return PICFLAG_NOT_ALL_SIMPLE;
892 /* Subroutine of process_init_constructor, which will process an initializer
893 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
894 which describe the initializers. */
897 process_init_constructor_array (tree type, tree init)
899 unsigned HOST_WIDE_INT i, len = 0;
901 bool unbounded = false;
903 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
905 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
906 || TREE_CODE (type) == VECTOR_TYPE);
908 if (TREE_CODE (type) == ARRAY_TYPE)
910 tree domain = TYPE_DOMAIN (type);
912 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
913 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
916 unbounded = true; /* Take as many as there are. */
919 /* Vectors are like simple fixed-size arrays. */
920 len = TYPE_VECTOR_SUBPARTS (type);
922 /* There must not be more initializers than needed. */
923 if (!unbounded && VEC_length (constructor_elt, v) > len)
924 error ("too many initializers for %qT", type);
926 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
930 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
931 if (compare_tree_int (ce->index, i) != 0)
933 ce->value = error_mark_node;
934 sorry ("non-trivial designated initializers not supported");
938 ce->index = size_int (i);
939 gcc_assert (ce->value);
940 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
942 if (ce->value != error_mark_node)
943 gcc_assert (same_type_ignoring_top_level_qualifiers_p
944 (TREE_TYPE (type), TREE_TYPE (ce->value)));
946 flags |= picflag_from_initializer (ce->value);
949 /* No more initializers. If the array is unbounded, we are done. Otherwise,
950 we must add initializers ourselves. */
956 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
958 /* If this type needs constructors run for default-initialization,
959 we can't rely on the back end to do it for us, so build up
960 TARGET_EXPRs. If the type in question is a class, just build
961 one up; if it's an array, recurse. */
962 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
963 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
964 tf_warning_or_error);
966 next = build_constructor (init_list_type_node, NULL);
967 next = digest_init (TREE_TYPE (type), next);
969 else if (!zero_init_p (TREE_TYPE (type)))
970 next = build_zero_init (TREE_TYPE (type),
972 /*static_storage_p=*/false);
974 /* The default zero-initialization is fine for us; don't
975 add anything to the CONSTRUCTOR. */
978 flags |= picflag_from_initializer (next);
979 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
982 CONSTRUCTOR_ELTS (init) = v;
986 /* Subroutine of process_init_constructor, which will process an initializer
987 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
991 process_init_constructor_record (tree type, tree init)
993 VEC(constructor_elt,gc) *v = NULL;
996 unsigned HOST_WIDE_INT idx = 0;
998 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
999 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1000 gcc_assert (!TYPE_BINFO (type)
1001 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1002 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1004 /* Generally, we will always have an index for each initializer (which is
1005 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1006 reshape_init. So we need to handle both cases. */
1007 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1012 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1014 flags |= picflag_from_initializer (integer_zero_node);
1015 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1019 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1022 /* If this is a bitfield, first convert to the declared type. */
1023 type = TREE_TYPE (field);
1024 if (DECL_BIT_FIELD_TYPE (field))
1025 type = DECL_BIT_FIELD_TYPE (field);
1027 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1029 constructor_elt *ce = VEC_index (constructor_elt,
1030 CONSTRUCTOR_ELTS (init), idx);
1033 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1034 latter case can happen in templates where lookup has to be
1036 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1037 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1038 if (ce->index != field
1039 && ce->index != DECL_NAME (field))
1041 ce->value = error_mark_node;
1042 sorry ("non-trivial designated initializers not supported");
1046 gcc_assert (ce->value);
1047 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1050 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1052 /* If this type needs constructors run for
1053 default-initialization, we can't rely on the back end to do it
1054 for us, so build up TARGET_EXPRs. If the type in question is
1055 a class, just build one up; if it's an array, recurse. */
1056 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1057 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1058 tf_warning_or_error);
1060 next = build_constructor (init_list_type_node, NULL);
1062 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1064 /* Warn when some struct elements are implicitly initialized. */
1065 warning (OPT_Wmissing_field_initializers,
1066 "missing initializer for member %qD", field);
1070 if (TREE_READONLY (field))
1071 error ("uninitialized const member %qD", field);
1072 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1073 error ("member %qD with uninitialized const fields", field);
1074 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1075 error ("member %qD is uninitialized reference", field);
1077 /* Warn when some struct elements are implicitly initialized
1079 warning (OPT_Wmissing_field_initializers,
1080 "missing initializer for member %qD", field);
1082 if (!zero_init_p (TREE_TYPE (field)))
1083 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1084 /*static_storage_p=*/false);
1086 /* The default zero-initialization is fine for us; don't
1087 add anything to the CONSTRUCTOR. */
1091 /* If this is a bitfield, now convert to the lowered type. */
1092 if (type != TREE_TYPE (field))
1093 next = cp_convert_and_check (TREE_TYPE (field), next);
1094 flags |= picflag_from_initializer (next);
1095 CONSTRUCTOR_APPEND_ELT (v, field, next);
1098 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1099 error ("too many initializers for %qT", type);
1101 CONSTRUCTOR_ELTS (init) = v;
1105 /* Subroutine of process_init_constructor, which will process a single
1106 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1107 which describe the initializer. */
1110 process_init_constructor_union (tree type, tree init)
1112 constructor_elt *ce;
1115 /* If the initializer was empty, use default zero initialization. */
1116 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1119 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1122 error ("too many initializers for %qT", type);
1123 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1126 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1128 /* If this element specifies a field, initialize via that field. */
1131 if (TREE_CODE (ce->index) == FIELD_DECL)
1133 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1135 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1136 tree name = ce->index;
1138 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1139 if (DECL_NAME (field) == name)
1143 error ("no field %qD found in union being initialized", field);
1144 ce->value = error_mark_node;
1150 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1151 || TREE_CODE (ce->index) == RANGE_EXPR);
1152 error ("index value instead of field name in union initializer");
1153 ce->value = error_mark_node;
1158 /* Find the first named field. ANSI decided in September 1990
1159 that only named fields count here. */
1160 tree field = TYPE_FIELDS (type);
1161 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1162 field = TREE_CHAIN (field);
1163 if (field == NULL_TREE)
1165 error ("too many initializers for %qT", type);
1166 ce->value = error_mark_node;
1171 if (ce->value && ce->value != error_mark_node)
1172 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1174 return picflag_from_initializer (ce->value);
1177 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1178 constructor is a brace-enclosed initializer, and will be modified in-place.
1180 Each element is converted to the right type through digest_init, and
1181 missing initializers are added following the language rules (zero-padding,
1184 After the execution, the initializer will have TREE_CONSTANT if all elts are
1185 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1186 constants that the assembler and linker can compute them.
1188 The function returns the initializer itself, or error_mark_node in case
1192 process_init_constructor (tree type, tree init)
1196 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1198 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1199 flags = process_init_constructor_array (type, init);
1200 else if (TREE_CODE (type) == RECORD_TYPE)
1201 flags = process_init_constructor_record (type, init);
1202 else if (TREE_CODE (type) == UNION_TYPE)
1203 flags = process_init_constructor_union (type, init);
1207 if (flags & PICFLAG_ERRONEOUS)
1208 return error_mark_node;
1210 TREE_TYPE (init) = type;
1211 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1212 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1213 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1215 TREE_CONSTANT (init) = 1;
1216 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1217 TREE_STATIC (init) = 1;
1222 /* Given a structure or union value DATUM, construct and return
1223 the structure or union component which results from narrowing
1224 that value to the base specified in BASETYPE. For example, given the
1227 class L { int ii; };
1228 class A : L { ... };
1229 class B : L { ... };
1230 class C : A, B { ... };
1238 x.A::ii refers to the ii member of the L part of
1239 the A part of the C object named by X. In this case,
1240 DATUM would be x, and BASETYPE would be A.
1242 I used to think that this was nonconformant, that the standard specified
1243 that first we look up ii in A, then convert x to an L& and pull out the
1244 ii part. But in fact, it does say that we convert x to an A&; A here
1245 is known as the "naming class". (jason 2000-12-19)
1247 BINFO_P points to a variable initialized either to NULL_TREE or to the
1248 binfo for the specific base subobject we want to convert to. */
1251 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1255 if (datum == error_mark_node)
1256 return error_mark_node;
1260 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1262 if (!binfo || binfo == error_mark_node)
1264 *binfo_p = NULL_TREE;
1266 error_not_base_type (basetype, TREE_TYPE (datum));
1267 return error_mark_node;
1271 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1274 /* Build a reference to an object specified by the C++ `->' operator.
1275 Usually this just involves dereferencing the object, but if the
1276 `->' operator is overloaded, then such overloads must be
1277 performed until an object which does not have the `->' operator
1278 overloaded is found. An error is reported when circular pointer
1279 delegation is detected. */
1282 build_x_arrow (tree expr)
1284 tree orig_expr = expr;
1285 tree types_memoized = NULL_TREE;
1286 tree type = TREE_TYPE (expr);
1287 tree last_rval = NULL_TREE;
1289 if (type == error_mark_node)
1290 return error_mark_node;
1292 if (processing_template_decl)
1294 if (type_dependent_expression_p (expr))
1295 return build_min_nt (ARROW_EXPR, expr);
1296 expr = build_non_dependent_expr (expr);
1299 if (MAYBE_CLASS_TYPE_P (type))
1301 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1302 NULL_TREE, NULL_TREE,
1303 /*overloaded_p=*/NULL,
1304 tf_warning_or_error)))
1306 if (expr == error_mark_node)
1307 return error_mark_node;
1309 if (value_member (TREE_TYPE (expr), types_memoized))
1311 error ("circular pointer delegation detected");
1312 return error_mark_node;
1316 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1322 if (last_rval == NULL_TREE)
1324 error ("base operand of %<->%> has non-pointer type %qT", type);
1325 return error_mark_node;
1328 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1329 last_rval = convert_from_reference (last_rval);
1332 last_rval = decay_conversion (expr);
1334 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1336 if (processing_template_decl)
1338 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1339 /* It will be dereferenced. */
1340 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1344 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1348 error ("result of %<operator->()%> yields non-pointer result");
1350 error ("base operand of %<->%> is not a pointer");
1351 return error_mark_node;
1354 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1355 already been checked out to be of aggregate type. */
1358 build_m_component_ref (tree datum, tree component)
1366 if (error_operand_p (datum) || error_operand_p (component))
1367 return error_mark_node;
1369 ptrmem_type = TREE_TYPE (component);
1370 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1372 error ("%qE cannot be used as a member pointer, since it is of "
1374 component, ptrmem_type);
1375 return error_mark_node;
1378 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1379 if (! MAYBE_CLASS_TYPE_P (objtype))
1381 error ("cannot apply member pointer %qE to %qE, which is of "
1382 "non-class type %qT",
1383 component, datum, objtype);
1384 return error_mark_node;
1387 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1388 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1390 if (!COMPLETE_TYPE_P (ctype))
1392 if (!same_type_p (ctype, objtype))
1398 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1403 error ("pointer to member type %qT incompatible with object "
1406 return error_mark_node;
1408 else if (binfo == error_mark_node)
1409 return error_mark_node;
1412 if (TYPE_PTRMEM_P (ptrmem_type))
1416 /* Compute the type of the field, as described in [expr.ref].
1417 There's no such thing as a mutable pointer-to-member, so
1418 things are not as complex as they are for references to
1419 non-static data members. */
1420 type = cp_build_qualified_type (type,
1421 (cp_type_quals (type)
1422 | cp_type_quals (TREE_TYPE (datum))));
1424 datum = build_address (datum);
1426 /* Convert object to the correct base. */
1428 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1430 /* Build an expression for "object + offset" where offset is the
1431 value stored in the pointer-to-data-member. */
1432 ptype = build_pointer_type (type);
1433 datum = build2 (POINTER_PLUS_EXPR, ptype,
1434 fold_convert (ptype, datum),
1435 build_nop (sizetype, component));
1436 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1439 return build2 (OFFSET_REF, type, datum, component);
1442 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1445 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1447 /* This is either a call to a constructor,
1448 or a C cast in C++'s `functional' notation. */
1450 /* The type to which we are casting. */
1452 VEC(tree,gc) *parmvec;
1454 if (exp == error_mark_node || parms == error_mark_node)
1455 return error_mark_node;
1457 if (TREE_CODE (exp) == TYPE_DECL)
1458 type = TREE_TYPE (exp);
1462 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1464 error ("invalid value-initialization of reference types");
1465 return error_mark_node;
1468 if (processing_template_decl)
1470 tree t = build_min (CAST_EXPR, type, parms);
1471 /* We don't know if it will or will not have side effects. */
1472 TREE_SIDE_EFFECTS (t) = 1;
1476 if (! MAYBE_CLASS_TYPE_P (type))
1478 if (parms == NULL_TREE)
1479 return cp_convert (type, integer_zero_node);
1481 /* This must build a C cast. */
1482 parms = build_x_compound_expr_from_list (parms, "functional cast");
1483 return cp_build_c_cast (type, parms, complain);
1486 /* Prepare to evaluate as a call to a constructor. If this expression
1487 is actually used, for example,
1489 return X (arg1, arg2, ...);
1491 then the slot being initialized will be filled in. */
1493 if (!complete_type_or_else (type, NULL_TREE))
1494 return error_mark_node;
1495 if (abstract_virtuals_error (NULL_TREE, type))
1496 return error_mark_node;
1500 If the expression list is a single-expression, the type
1501 conversion is equivalent (in definedness, and if defined in
1502 meaning) to the corresponding cast expression. */
1503 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1504 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1508 The expression T(), where T is a simple-type-specifier for a
1509 non-array complete object type or the (possibly cv-qualified)
1510 void type, creates an rvalue of the specified type, which is
1511 value-initialized. */
1513 if (parms == NULL_TREE
1514 /* If there's a user-defined constructor, value-initialization is
1515 just calling the constructor, so fall through. */
1516 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1518 exp = build_value_init (type);
1519 return get_target_expr (exp);
1522 /* Call the constructor. */
1523 parmvec = make_tree_vector ();
1524 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1525 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1526 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1527 &parmvec, type, LOOKUP_NORMAL, complain);
1528 release_tree_vector (parmvec);
1530 if (exp == error_mark_node)
1531 return error_mark_node;
1533 return build_cplus_new (type, exp);
1537 /* Add new exception specifier SPEC, to the LIST we currently have.
1538 If it's already in LIST then do nothing.
1539 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1540 know what we're doing. */
1543 add_exception_specifier (tree list, tree spec, int complain)
1548 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1550 if (spec == error_mark_node)
1553 gcc_assert (spec && (!list || TREE_VALUE (list)));
1555 /* [except.spec] 1, type in an exception specifier shall not be
1556 incomplete, or pointer or ref to incomplete other than pointer
1558 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1559 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1560 core = TREE_TYPE (core);
1563 else if (VOID_TYPE_P (core))
1565 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1567 else if (processing_template_decl)
1572 /* 15.4/1 says that types in an exception specifier must be complete,
1573 but it seems more reasonable to only require this on definitions
1574 and calls. So just give a pedwarn at this point; we will give an
1575 error later if we hit one of those two cases. */
1576 if (!COMPLETE_TYPE_P (complete_type (core)))
1577 diag_type = DK_PEDWARN; /* pedwarn */
1584 for (probe = list; probe; probe = TREE_CHAIN (probe))
1585 if (same_type_p (TREE_VALUE (probe), spec))
1588 list = tree_cons (NULL_TREE, spec, list);
1591 diag_type = DK_ERROR; /* error */
1593 if (diag_type != DK_UNSPECIFIED && complain)
1594 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1599 /* Combine the two exceptions specifier lists LIST and ADD, and return
1603 merge_exception_specifiers (tree list, tree add)
1607 else if (!TREE_VALUE (list))
1609 else if (!TREE_VALUE (add))
1613 tree orig_list = list;
1615 for (; add; add = TREE_CHAIN (add))
1617 tree spec = TREE_VALUE (add);
1620 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1621 if (same_type_p (TREE_VALUE (probe), spec))
1625 spec = build_tree_list (NULL_TREE, spec);
1626 TREE_CHAIN (spec) = list;
1634 /* Subroutine of build_call. Ensure that each of the types in the
1635 exception specification is complete. Technically, 15.4/1 says that
1636 they need to be complete when we see a declaration of the function,
1637 but we should be able to get away with only requiring this when the
1638 function is defined or called. See also add_exception_specifier. */
1641 require_complete_eh_spec_types (tree fntype, tree decl)
1644 /* Don't complain about calls to op new. */
1645 if (decl && DECL_ARTIFICIAL (decl))
1647 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1648 raises = TREE_CHAIN (raises))
1650 tree type = TREE_VALUE (raises);
1651 if (type && !COMPLETE_TYPE_P (type))
1655 ("call to function %qD which throws incomplete type %q#T",
1658 error ("call to function which throws incomplete type %q#T",
1665 #include "gt-cp-typeck2.h"