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"
40 #include "diagnostic.h"
44 process_init_constructor (tree type, tree init);
47 /* Print an error message stemming from an attempt to use
48 BASETYPE as a base class for TYPE. */
51 error_not_base_type (tree basetype, tree type)
53 if (TREE_CODE (basetype) == FUNCTION_DECL)
54 basetype = DECL_CONTEXT (basetype);
55 error ("type %qT is not a base type for type %qT", basetype, type);
56 return error_mark_node;
60 binfo_or_else (tree base, tree type)
62 tree binfo = lookup_base (type, base, ba_unique, NULL);
64 if (binfo == error_mark_node)
67 error_not_base_type (base, type);
71 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
72 value may not be changed thereafter. */
75 readonly_error (tree arg, readonly_error_kind errstring)
78 /* This macro is used to emit diagnostics to ensure that all format
79 strings are complete sentences, visible to gettext and checked at
82 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
86 case REK_ASSIGNMENT: \
89 case REK_ASSIGNMENT_ASM: \
103 if (TREE_CODE (arg) == COMPONENT_REF)
105 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
106 ERROR_FOR_ASSIGNMENT (G_("assignment of "
107 "data-member %qD in read-only structure"),
108 G_("assignment (via 'asm' output) of "
109 "data-member %qD in read-only structure"),
111 "data-member %qD in read-only structure"),
113 "data-member %qD in read-only structure"),
114 TREE_OPERAND (arg, 1));
116 ERROR_FOR_ASSIGNMENT (G_("assignment of "
117 "read-only data-member %qD"),
118 G_("assignment (via 'asm' output) of "
119 "read-only data-member %qD"),
121 "read-only data-member %qD"),
123 "read-only data-member %qD"),
124 TREE_OPERAND (arg, 1));
126 else if (TREE_CODE (arg) == VAR_DECL)
128 if (DECL_LANG_SPECIFIC (arg)
129 && DECL_IN_AGGR_P (arg)
130 && !TREE_STATIC (arg))
131 ERROR_FOR_ASSIGNMENT (G_("assignment of "
132 "constant field %qD"),
133 G_("assignment (via 'asm' output) of "
134 "constant field %qD"),
136 "constant field %qD"),
138 "constant field %qD"),
141 ERROR_FOR_ASSIGNMENT (G_("assignment of "
142 "read-only variable %qD"),
143 G_("assignment (via 'asm' output) of "
144 "read-only variable %qD"),
146 "read-only variable %qD"),
148 "read-only variable %qD"),
152 else if (TREE_CODE (arg) == PARM_DECL)
153 ERROR_FOR_ASSIGNMENT (G_("assignment of "
154 "read-only parameter %qD"),
155 G_("assignment (via 'asm' output) of "
156 "read-only parameter %qD"),
158 "read-only parameter %qD"),
160 "read-only parameter %qD"),
162 else if (TREE_CODE (arg) == INDIRECT_REF
163 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
164 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
165 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
166 ERROR_FOR_ASSIGNMENT (G_("assignment of "
167 "read-only reference %qD"),
168 G_("assignment (via 'asm' output) of "
169 "read-only reference %qD"),
171 "read-only reference %qD"),
173 "read-only reference %qD"),
174 TREE_OPERAND (arg, 0));
175 else if (TREE_CODE (arg) == RESULT_DECL)
176 ERROR_FOR_ASSIGNMENT (G_("assignment of "
177 "read-only named return value %qD"),
178 G_("assignment (via 'asm' output) of "
179 "read-only named return value %qD"),
181 "read-only named return value %qD"),
183 "read-only named return value %qD"),
185 else if (TREE_CODE (arg) == FUNCTION_DECL)
186 ERROR_FOR_ASSIGNMENT (G_("assignment of "
188 G_("assignment (via 'asm' output) of "
196 ERROR_FOR_ASSIGNMENT (G_("assignment of "
197 "read-only location %qE"),
198 G_("assignment (via 'asm' output) of "
199 "read-only location %qE"),
201 "read-only location %qE"),
203 "read-only location %qE"),
208 /* Structure that holds information about declarations whose type was
209 incomplete and we could not check whether it was abstract or not. */
211 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
212 /* Declaration which we are checking for abstractness. It is either
213 a DECL node, or an IDENTIFIER_NODE if we do not have a full
214 declaration available. */
217 /* Type which will be checked for abstractness. */
220 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
221 because DECLs already carry locus information. */
224 /* Link to the next element in list. */
225 struct pending_abstract_type* next;
229 /* Compute the hash value of the node VAL. This function is used by the
230 hash table abstract_pending_vars. */
233 pat_calc_hash (const void* val)
235 const struct pending_abstract_type *pat =
236 (const struct pending_abstract_type *) val;
237 return (hashval_t) TYPE_UID (pat->type);
241 /* Compare node VAL1 with the type VAL2. This function is used by the
242 hash table abstract_pending_vars. */
245 pat_compare (const void* val1, const void* val2)
247 const struct pending_abstract_type *const pat1 =
248 (const struct pending_abstract_type *) val1;
249 const_tree const type2 = (const_tree)val2;
251 return (pat1->type == type2);
254 /* Hash table that maintains pending_abstract_type nodes, for which we still
255 need to check for type abstractness. The key of the table is the type
256 of the declaration. */
257 static GTY ((param_is (struct pending_abstract_type)))
258 htab_t abstract_pending_vars = NULL;
261 /* This function is called after TYPE is completed, and will check if there
262 are pending declarations for which we still need to verify the abstractness
263 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
264 turned out to be incomplete. */
267 complete_type_check_abstract (tree type)
270 struct pending_abstract_type *pat;
271 location_t cur_loc = input_location;
273 gcc_assert (COMPLETE_TYPE_P (type));
275 if (!abstract_pending_vars)
278 /* Retrieve the list of pending declarations for this type. */
279 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
280 (hashval_t)TYPE_UID (type), NO_INSERT);
283 pat = (struct pending_abstract_type*)*slot;
286 /* If the type is not abstract, do not do anything. */
287 if (CLASSTYPE_PURE_VIRTUALS (type))
289 struct pending_abstract_type *prev = 0, *next;
291 /* Reverse the list to emit the errors in top-down order. */
292 for (; pat; pat = next)
300 /* Go through the list, and call abstract_virtuals_error for each
301 element: it will issue a diagnostic if the type is abstract. */
304 gcc_assert (type == pat->type);
306 /* Tweak input_location so that the diagnostic appears at the correct
307 location. Notice that this is only needed if the decl is an
309 input_location = pat->locus;
310 abstract_virtuals_error (pat->decl, pat->type);
315 htab_clear_slot (abstract_pending_vars, slot);
317 input_location = cur_loc;
321 /* If TYPE has abstract virtual functions, issue an error about trying
322 to create an object of that type. DECL is the object declared, or
323 NULL_TREE if the declaration is unavailable. Returns 1 if an error
324 occurred; zero if all was well. */
327 abstract_virtuals_error (tree decl, tree type)
331 /* This function applies only to classes. Any other entity can never
333 if (!CLASS_TYPE_P (type))
335 type = TYPE_MAIN_VARIANT (type);
337 /* If the type is incomplete, we register it within a hash table,
338 so that we can check again once it is completed. This makes sense
339 only for objects for which we have a declaration or at least a
341 if (!COMPLETE_TYPE_P (type))
344 struct pending_abstract_type *pat;
346 gcc_assert (!decl || DECL_P (decl)
347 || TREE_CODE (decl) == IDENTIFIER_NODE);
349 if (!abstract_pending_vars)
350 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
353 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
354 (hashval_t)TYPE_UID (type), INSERT);
356 pat = GGC_NEW (struct pending_abstract_type);
359 pat->locus = ((decl && DECL_P (decl))
360 ? DECL_SOURCE_LOCATION (decl)
363 pat->next = (struct pending_abstract_type *) *slot;
369 if (!TYPE_SIZE (type))
370 /* TYPE is being defined, and during that time
371 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
374 pure = CLASSTYPE_PURE_VIRTUALS (type);
380 if (TREE_CODE (decl) == RESULT_DECL)
383 if (TREE_CODE (decl) == VAR_DECL)
384 error ("cannot declare variable %q+D to be of abstract "
385 "type %qT", decl, type);
386 else if (TREE_CODE (decl) == PARM_DECL)
387 error ("cannot declare parameter %q+D to be of abstract type %qT",
389 else if (TREE_CODE (decl) == FIELD_DECL)
390 error ("cannot declare field %q+D to be of abstract type %qT",
392 else if (TREE_CODE (decl) == FUNCTION_DECL
393 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
394 error ("invalid abstract return type for member function %q+#D", decl);
395 else if (TREE_CODE (decl) == FUNCTION_DECL)
396 error ("invalid abstract return type for function %q+#D", decl);
397 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
398 /* Here we do not have location information. */
399 error ("invalid abstract type %qT for %qE", type, decl);
401 error ("invalid abstract type for %q+D", decl);
404 error ("cannot allocate an object of abstract type %qT", type);
406 /* Only go through this once. */
407 if (VEC_length (tree, pure))
412 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
413 " because the following virtual functions are pure within %qT:",
416 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
417 inform (input_location, "\t%+#D", fn);
418 /* Now truncate the vector. This leaves it non-null, so we know
419 there are pure virtuals, but empty so we don't list them out
421 VEC_truncate (tree, pure, 0);
424 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
425 " since type %qT has pure virtual functions",
431 /* Print an error message for invalid use of an incomplete type.
432 VALUE is the expression that was used (or 0 if that isn't known)
433 and TYPE is the type that was invalid. DIAG_KIND indicates the
434 type of diagnostic (see diagnostic.def). */
437 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
438 diagnostic_t diag_kind)
442 gcc_assert (diag_kind == DK_WARNING
443 || diag_kind == DK_PEDWARN
444 || diag_kind == DK_ERROR);
446 /* Avoid duplicate error message. */
447 if (TREE_CODE (type) == ERROR_MARK)
450 if (value != 0 && (TREE_CODE (value) == VAR_DECL
451 || TREE_CODE (value) == PARM_DECL
452 || TREE_CODE (value) == FIELD_DECL))
454 emit_diagnostic (diag_kind, input_location, 0,
455 "%q+D has incomplete type", value);
459 /* We must print an error message. Be clever about what it says. */
461 switch (TREE_CODE (type))
467 emit_diagnostic (diag_kind, input_location, 0,
468 "invalid use of incomplete type %q#T", type);
469 if (!TYPE_TEMPLATE_INFO (type))
470 emit_diagnostic (diag_kind, input_location, 0,
471 "forward declaration of %q+#T", type);
473 emit_diagnostic (diag_kind, input_location, 0,
474 "declaration of %q+#T", type);
478 emit_diagnostic (diag_kind, input_location, 0,
479 "invalid use of %qT", type);
483 if (TYPE_DOMAIN (type))
485 type = TREE_TYPE (type);
488 emit_diagnostic (diag_kind, input_location, 0,
489 "invalid use of array with unspecified bounds");
494 emit_diagnostic (diag_kind, input_location, 0,
495 "invalid use of member (did you forget the %<&%> ?)");
498 case TEMPLATE_TYPE_PARM:
500 emit_diagnostic (diag_kind, input_location, 0,
501 "invalid use of %<auto%>");
503 emit_diagnostic (diag_kind, input_location, 0,
504 "invalid use of template type parameter %qT", type);
507 case BOUND_TEMPLATE_TEMPLATE_PARM:
508 emit_diagnostic (diag_kind, input_location, 0,
509 "invalid use of template template parameter %qT",
514 emit_diagnostic (diag_kind, input_location, 0,
515 "invalid use of dependent type %qT", type);
519 if (value && TREE_CODE (value) == COMPONENT_REF)
521 else if (value && TREE_CODE (value) == ADDR_EXPR)
522 emit_diagnostic (diag_kind, input_location, 0,
523 "address of overloaded function with no contextual "
525 else if (value && TREE_CODE (value) == OVERLOAD)
526 emit_diagnostic (diag_kind, input_location, 0,
527 "overloaded function with no contextual type information");
529 emit_diagnostic (diag_kind, input_location, 0,
530 "insufficient contextual information to determine type");
538 /* Backward-compatibility interface to incomplete_type_diagnostic;
539 required by ../tree.c. */
540 #undef cxx_incomplete_type_error
542 cxx_incomplete_type_error (const_tree value, const_tree type)
544 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
548 /* The recursive part of split_nonconstant_init. DEST is an lvalue
549 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
552 split_nonconstant_init_1 (tree dest, tree init)
554 unsigned HOST_WIDE_INT idx;
555 tree field_index, value;
556 tree type = TREE_TYPE (dest);
557 tree inner_type = NULL;
558 bool array_type_p = false;
560 switch (TREE_CODE (type))
563 inner_type = TREE_TYPE (type);
569 case QUAL_UNION_TYPE:
570 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
573 /* The current implementation of this algorithm assumes that
574 the field was set for all the elements. This is usually done
575 by process_init_constructor. */
576 gcc_assert (field_index);
579 inner_type = TREE_TYPE (field_index);
581 if (TREE_CODE (value) == CONSTRUCTOR)
586 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
587 NULL_TREE, NULL_TREE);
589 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
592 split_nonconstant_init_1 (sub, value);
594 else if (!initializer_constant_valid_p (value, inner_type))
599 /* FIXME: Ordered removal is O(1) so the whole function is
600 worst-case quadratic. This could be fixed using an aside
601 bitmap to record which elements must be removed and remove
602 them all at the same time. Or by merging
603 split_non_constant_init into process_init_constructor_array,
604 that is separating constants from non-constants while building
606 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
611 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
612 NULL_TREE, NULL_TREE);
614 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
617 code = build2 (INIT_EXPR, inner_type, sub, value);
618 code = build_stmt (input_location, EXPR_STMT, code);
626 if (!initializer_constant_valid_p (init, type))
629 tree cons = copy_node (init);
630 CONSTRUCTOR_ELTS (init) = NULL;
631 code = build2 (MODIFY_EXPR, type, dest, cons);
632 code = build_stmt (input_location, EXPR_STMT, code);
641 /* The rest of the initializer is now a constant. */
642 TREE_CONSTANT (init) = 1;
645 /* A subroutine of store_init_value. Splits non-constant static
646 initializer INIT into a constant part and generates code to
647 perform the non-constant part of the initialization to DEST.
648 Returns the code for the runtime init. */
651 split_nonconstant_init (tree dest, tree init)
655 if (TREE_CODE (init) == CONSTRUCTOR)
657 code = push_stmt_list ();
658 split_nonconstant_init_1 (dest, init);
659 code = pop_stmt_list (code);
660 DECL_INITIAL (dest) = init;
661 TREE_READONLY (dest) = 0;
664 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
669 /* Perform appropriate conversions on the initial value of a variable,
670 store it in the declaration DECL,
671 and print any error messages that are appropriate.
672 If the init is invalid, store an ERROR_MARK.
674 C++: Note that INIT might be a TREE_LIST, which would mean that it is
675 a base class initializer for some aggregate type, hopefully compatible
676 with DECL. If INIT is a single element, and DECL is an aggregate
677 type, we silently convert INIT into a TREE_LIST, allowing a constructor
680 If INIT is a TREE_LIST and there is no constructor, turn INIT
681 into a CONSTRUCTOR and use standard initialization techniques.
682 Perhaps a warning should be generated?
684 Returns code to be executed if initialization could not be performed
685 for static variable. In that case, caller must emit the code. */
688 store_init_value (tree decl, tree init, int flags)
692 /* If variable's type was invalidly declared, just ignore it. */
694 type = TREE_TYPE (decl);
695 if (TREE_CODE (type) == ERROR_MARK)
698 if (MAYBE_CLASS_TYPE_P (type))
700 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
701 || TREE_CODE (init) == CONSTRUCTOR);
703 if (TREE_CODE (init) == TREE_LIST)
705 error ("constructor syntax used, but no constructor declared "
706 "for type %qT", type);
707 init = build_constructor_from_list (init_list_type_node, nreverse (init));
710 else if (TREE_CODE (init) == TREE_LIST
711 && TREE_TYPE (init) != unknown_type_node)
713 if (TREE_CODE (decl) == RESULT_DECL)
714 init = build_x_compound_expr_from_list (init,
715 "return value initializer");
716 else if (TREE_CODE (init) == TREE_LIST
717 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
719 error ("cannot initialize arrays using this syntax");
723 /* We get here with code like `int a (2);' */
724 init = build_x_compound_expr_from_list (init, "initializer");
727 /* End of special C++ code. */
729 /* Digest the specified initializer into an expression. */
730 value = digest_init_flags (type, init, flags);
731 /* If the initializer is not a constant, fill in DECL_INITIAL with
732 the bits that are constant, and then return an expression that
733 will perform the dynamic initialization. */
734 if (value != error_mark_node
735 && (TREE_SIDE_EFFECTS (value)
736 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
737 return split_nonconstant_init (decl, value);
738 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
739 is an automatic variable, the middle end will turn this into a
740 dynamic initialization later. */
741 DECL_INITIAL (decl) = value;
746 /* Give errors about narrowing conversions within { }. */
749 check_narrowing (tree type, tree init)
751 tree ftype = unlowered_expr_type (init);
756 init = decl_constant_value (init);
758 if (TREE_CODE (type) == INTEGER_TYPE
759 && TREE_CODE (ftype) == REAL_TYPE)
761 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
762 && CP_INTEGRAL_TYPE_P (type))
764 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
765 && (TREE_CODE (init) != INTEGER_CST
766 || !int_fits_type_p (init, type)))
769 else if (TREE_CODE (ftype) == REAL_TYPE
770 && TREE_CODE (type) == REAL_TYPE)
772 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
774 if (TREE_CODE (init) == REAL_CST)
776 /* Issue 703: Loss of precision is OK as long as the value is
777 within the representable range of the new type. */
779 d = TREE_REAL_CST (init);
780 real_convert (&r, TYPE_MODE (type), &d);
788 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
789 && TREE_CODE (type) == REAL_TYPE)
792 if (TREE_CODE (init) == INTEGER_CST)
794 d = real_value_from_int_cst (0, init);
795 if (exact_real_truncate (TYPE_MODE (type), &d))
801 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
805 /* Process the initializer INIT for a variable of type TYPE, emitting
806 diagnostics for invalid initializers and converting the initializer as
809 For aggregate types, it assumes that reshape_init has already run, thus the
810 initializer will have the right shape (brace elision has been undone).
812 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
815 digest_init_r (tree type, tree init, bool nested, int flags)
817 enum tree_code code = TREE_CODE (type);
819 if (error_operand_p (init))
820 return error_mark_node;
824 /* We must strip the outermost array type when completing the type,
825 because the its bounds might be incomplete at the moment. */
826 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
827 ? TREE_TYPE (type) : type, NULL_TREE))
828 return error_mark_node;
830 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
831 (g++.old-deja/g++.law/casts2.C). */
832 if (TREE_CODE (init) == NON_LVALUE_EXPR)
833 init = TREE_OPERAND (init, 0);
835 /* Initialization of an array of chars from a string constant. The initializer
836 can be optionally enclosed in braces, but reshape_init has already removed
837 them if they were present. */
838 if (code == ARRAY_TYPE)
840 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
841 if (char_type_p (typ1)
843 && TREE_CODE (init) == STRING_CST)
845 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
847 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
849 if (char_type != char_type_node)
851 error ("char-array initialized from wide string");
852 return error_mark_node;
857 if (char_type == char_type_node)
859 error ("int-array initialized from non-wide string");
860 return error_mark_node;
862 else if (char_type != typ1)
864 error ("int-array initialized from incompatible wide string");
865 return error_mark_node;
869 TREE_TYPE (init) = type;
870 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
872 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
873 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
874 /* In C it is ok to subtract 1 from the length of the string
875 because it's ok to ignore the terminating null char that is
876 counted in the length of the constant, but in C++ this would
878 if (size < TREE_STRING_LENGTH (init))
879 permerror (input_location, "initializer-string for array of chars is too long");
885 /* Handle scalar types (including conversions) and references. */
886 if ((TREE_CODE (type) != COMPLEX_TYPE
887 || BRACE_ENCLOSED_INITIALIZER_P (init))
888 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
892 if (cxx_dialect != cxx98 && nested)
893 check_narrowing (type, init);
894 init = convert_for_initialization (0, type, init, flags,
895 "initialization", NULL_TREE, 0,
896 tf_warning_or_error);
899 /* Skip any conversions since we'll be outputting the underlying
901 while (CONVERT_EXPR_P (*exp)
902 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
903 exp = &TREE_OPERAND (*exp, 0);
905 *exp = cplus_expand_constant (*exp);
910 /* Come here only for aggregates: records, arrays, unions, complex numbers
912 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
913 || TREE_CODE (type) == VECTOR_TYPE
914 || TREE_CODE (type) == RECORD_TYPE
915 || TREE_CODE (type) == UNION_TYPE
916 || TREE_CODE (type) == COMPLEX_TYPE);
918 if (BRACE_ENCLOSED_INITIALIZER_P (init)
919 && !TYPE_NON_AGGREGATE_CLASS (type))
920 return process_init_constructor (type, init);
923 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
925 error ("cannot initialize aggregate of type %qT with "
926 "a compound literal", type);
928 return error_mark_node;
931 if (TREE_CODE (type) == ARRAY_TYPE
932 && !BRACE_ENCLOSED_INITIALIZER_P (init))
934 /* Allow the result of build_array_copy and of
935 build_value_init_noctor. */
936 if ((TREE_CODE (init) == TARGET_EXPR
937 || TREE_CODE (init) == CONSTRUCTOR)
938 && (same_type_ignoring_top_level_qualifiers_p
939 (type, TREE_TYPE (init))))
942 error ("array must be initialized with a brace-enclosed"
944 return error_mark_node;
947 return convert_for_initialization (NULL_TREE, type, init,
949 "initialization", NULL_TREE, 0,
950 tf_warning_or_error);
955 digest_init (tree type, tree init)
957 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
961 digest_init_flags (tree type, tree init, int flags)
963 return digest_init_r (type, init, false, flags);
966 /* Set of flags used within process_init_constructor to describe the
968 #define PICFLAG_ERRONEOUS 1
969 #define PICFLAG_NOT_ALL_CONSTANT 2
970 #define PICFLAG_NOT_ALL_SIMPLE 4
972 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
976 picflag_from_initializer (tree init)
978 if (init == error_mark_node)
979 return PICFLAG_ERRONEOUS;
980 else if (!TREE_CONSTANT (init))
981 return PICFLAG_NOT_ALL_CONSTANT;
982 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
983 return PICFLAG_NOT_ALL_SIMPLE;
987 /* Subroutine of process_init_constructor, which will process an initializer
988 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
989 which describe the initializers. */
992 process_init_constructor_array (tree type, tree init)
994 unsigned HOST_WIDE_INT i, len = 0;
996 bool unbounded = false;
998 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1000 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1001 || TREE_CODE (type) == VECTOR_TYPE);
1003 if (TREE_CODE (type) == ARRAY_TYPE)
1005 tree domain = TYPE_DOMAIN (type);
1007 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1008 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1011 unbounded = true; /* Take as many as there are. */
1014 /* Vectors are like simple fixed-size arrays. */
1015 len = TYPE_VECTOR_SUBPARTS (type);
1017 /* There must not be more initializers than needed. */
1018 if (!unbounded && VEC_length (constructor_elt, v) > len)
1019 error ("too many initializers for %qT", type);
1021 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
1025 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1026 if (compare_tree_int (ce->index, i) != 0)
1028 ce->value = error_mark_node;
1029 sorry ("non-trivial designated initializers not supported");
1033 ce->index = size_int (i);
1034 gcc_assert (ce->value);
1035 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
1037 if (ce->value != error_mark_node)
1038 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1039 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1041 flags |= picflag_from_initializer (ce->value);
1044 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1045 we must add initializers ourselves. */
1047 for (; i < len; ++i)
1051 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
1053 /* If this type needs constructors run for default-initialization,
1054 we can't rely on the back end to do it for us, so build up
1055 TARGET_EXPRs. If the type in question is a class, just build
1056 one up; if it's an array, recurse. */
1057 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
1058 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
1059 tf_warning_or_error);
1061 next = build_constructor (init_list_type_node, NULL);
1062 next = digest_init (TREE_TYPE (type), next);
1064 else if (!zero_init_p (TREE_TYPE (type)))
1065 next = build_zero_init (TREE_TYPE (type),
1066 /*nelts=*/NULL_TREE,
1067 /*static_storage_p=*/false);
1069 /* The default zero-initialization is fine for us; don't
1070 add anything to the CONSTRUCTOR. */
1073 flags |= picflag_from_initializer (next);
1074 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1077 CONSTRUCTOR_ELTS (init) = v;
1081 /* Subroutine of process_init_constructor, which will process an initializer
1082 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1083 the initializers. */
1086 process_init_constructor_record (tree type, tree init)
1088 VEC(constructor_elt,gc) *v = NULL;
1091 unsigned HOST_WIDE_INT idx = 0;
1093 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1094 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1095 gcc_assert (!TYPE_BINFO (type)
1096 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1097 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1099 /* Generally, we will always have an index for each initializer (which is
1100 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1101 reshape_init. So we need to handle both cases. */
1102 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1107 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1109 flags |= picflag_from_initializer (integer_zero_node);
1110 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1114 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1117 /* If this is a bitfield, first convert to the declared type. */
1118 type = TREE_TYPE (field);
1119 if (DECL_BIT_FIELD_TYPE (field))
1120 type = DECL_BIT_FIELD_TYPE (field);
1122 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1124 constructor_elt *ce = VEC_index (constructor_elt,
1125 CONSTRUCTOR_ELTS (init), idx);
1128 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1129 latter case can happen in templates where lookup has to be
1131 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1132 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1133 if (ce->index != field
1134 && ce->index != DECL_NAME (field))
1136 ce->value = error_mark_node;
1137 sorry ("non-trivial designated initializers not supported");
1141 gcc_assert (ce->value);
1142 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1145 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1147 /* If this type needs constructors run for
1148 default-initialization, we can't rely on the back end to do it
1149 for us, so build up TARGET_EXPRs. If the type in question is
1150 a class, just build one up; if it's an array, recurse. */
1151 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1152 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1153 tf_warning_or_error);
1155 next = build_constructor (init_list_type_node, NULL);
1157 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1159 /* Warn when some struct elements are implicitly initialized. */
1160 warning (OPT_Wmissing_field_initializers,
1161 "missing initializer for member %qD", field);
1165 if (TREE_READONLY (field))
1166 error ("uninitialized const member %qD", field);
1167 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1168 error ("member %qD with uninitialized const fields", field);
1169 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1170 error ("member %qD is uninitialized reference", field);
1172 /* Warn when some struct elements are implicitly initialized
1174 warning (OPT_Wmissing_field_initializers,
1175 "missing initializer for member %qD", field);
1177 if (!zero_init_p (TREE_TYPE (field)))
1178 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1179 /*static_storage_p=*/false);
1181 /* The default zero-initialization is fine for us; don't
1182 add anything to the CONSTRUCTOR. */
1186 /* If this is a bitfield, now convert to the lowered type. */
1187 if (type != TREE_TYPE (field))
1188 next = cp_convert_and_check (TREE_TYPE (field), next);
1189 flags |= picflag_from_initializer (next);
1190 CONSTRUCTOR_APPEND_ELT (v, field, next);
1193 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1194 error ("too many initializers for %qT", type);
1196 CONSTRUCTOR_ELTS (init) = v;
1200 /* Subroutine of process_init_constructor, which will process a single
1201 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1202 which describe the initializer. */
1205 process_init_constructor_union (tree type, tree init)
1207 constructor_elt *ce;
1210 /* If the initializer was empty, use default zero initialization. */
1211 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1214 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1217 error ("too many initializers for %qT", type);
1218 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1221 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1223 /* If this element specifies a field, initialize via that field. */
1226 if (TREE_CODE (ce->index) == FIELD_DECL)
1228 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1230 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1231 tree name = ce->index;
1233 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1234 if (DECL_NAME (field) == name)
1238 error ("no field %qD found in union being initialized", field);
1239 ce->value = error_mark_node;
1245 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1246 || TREE_CODE (ce->index) == RANGE_EXPR);
1247 error ("index value instead of field name in union initializer");
1248 ce->value = error_mark_node;
1253 /* Find the first named field. ANSI decided in September 1990
1254 that only named fields count here. */
1255 tree field = TYPE_FIELDS (type);
1256 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1257 field = TREE_CHAIN (field);
1258 if (field == NULL_TREE)
1260 error ("too many initializers for %qT", type);
1261 ce->value = error_mark_node;
1266 if (ce->value && ce->value != error_mark_node)
1267 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1269 return picflag_from_initializer (ce->value);
1272 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1273 constructor is a brace-enclosed initializer, and will be modified in-place.
1275 Each element is converted to the right type through digest_init, and
1276 missing initializers are added following the language rules (zero-padding,
1279 After the execution, the initializer will have TREE_CONSTANT if all elts are
1280 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1281 constants that the assembler and linker can compute them.
1283 The function returns the initializer itself, or error_mark_node in case
1287 process_init_constructor (tree type, tree init)
1291 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1293 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1294 flags = process_init_constructor_array (type, init);
1295 else if (TREE_CODE (type) == RECORD_TYPE)
1296 flags = process_init_constructor_record (type, init);
1297 else if (TREE_CODE (type) == UNION_TYPE)
1298 flags = process_init_constructor_union (type, init);
1302 if (flags & PICFLAG_ERRONEOUS)
1303 return error_mark_node;
1305 TREE_TYPE (init) = type;
1306 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1307 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1308 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1310 TREE_CONSTANT (init) = 1;
1311 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1312 TREE_STATIC (init) = 1;
1317 /* Given a structure or union value DATUM, construct and return
1318 the structure or union component which results from narrowing
1319 that value to the base specified in BASETYPE. For example, given the
1322 class L { int ii; };
1323 class A : L { ... };
1324 class B : L { ... };
1325 class C : A, B { ... };
1333 x.A::ii refers to the ii member of the L part of
1334 the A part of the C object named by X. In this case,
1335 DATUM would be x, and BASETYPE would be A.
1337 I used to think that this was nonconformant, that the standard specified
1338 that first we look up ii in A, then convert x to an L& and pull out the
1339 ii part. But in fact, it does say that we convert x to an A&; A here
1340 is known as the "naming class". (jason 2000-12-19)
1342 BINFO_P points to a variable initialized either to NULL_TREE or to the
1343 binfo for the specific base subobject we want to convert to. */
1346 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1350 if (datum == error_mark_node)
1351 return error_mark_node;
1355 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1357 if (!binfo || binfo == error_mark_node)
1359 *binfo_p = NULL_TREE;
1361 error_not_base_type (basetype, TREE_TYPE (datum));
1362 return error_mark_node;
1366 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1369 /* Build a reference to an object specified by the C++ `->' operator.
1370 Usually this just involves dereferencing the object, but if the
1371 `->' operator is overloaded, then such overloads must be
1372 performed until an object which does not have the `->' operator
1373 overloaded is found. An error is reported when circular pointer
1374 delegation is detected. */
1377 build_x_arrow (tree expr)
1379 tree orig_expr = expr;
1380 tree types_memoized = NULL_TREE;
1381 tree type = TREE_TYPE (expr);
1382 tree last_rval = NULL_TREE;
1384 if (type == error_mark_node)
1385 return error_mark_node;
1387 if (processing_template_decl)
1389 if (type_dependent_expression_p (expr))
1390 return build_min_nt (ARROW_EXPR, expr);
1391 expr = build_non_dependent_expr (expr);
1394 if (MAYBE_CLASS_TYPE_P (type))
1396 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1397 NULL_TREE, NULL_TREE,
1398 /*overloaded_p=*/NULL,
1399 tf_warning_or_error)))
1401 if (expr == error_mark_node)
1402 return error_mark_node;
1404 if (value_member (TREE_TYPE (expr), types_memoized))
1406 error ("circular pointer delegation detected");
1407 return error_mark_node;
1411 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1417 if (last_rval == NULL_TREE)
1419 error ("base operand of %<->%> has non-pointer type %qT", type);
1420 return error_mark_node;
1423 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1424 last_rval = convert_from_reference (last_rval);
1427 last_rval = decay_conversion (expr);
1429 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1431 if (processing_template_decl)
1433 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1434 /* It will be dereferenced. */
1435 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1439 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1443 error ("result of %<operator->()%> yields non-pointer result");
1445 error ("base operand of %<->%> is not a pointer");
1446 return error_mark_node;
1449 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1450 already been checked out to be of aggregate type. */
1453 build_m_component_ref (tree datum, tree component)
1461 if (error_operand_p (datum) || error_operand_p (component))
1462 return error_mark_node;
1464 ptrmem_type = TREE_TYPE (component);
1465 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1467 error ("%qE cannot be used as a member pointer, since it is of "
1469 component, ptrmem_type);
1470 return error_mark_node;
1473 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1474 if (! MAYBE_CLASS_TYPE_P (objtype))
1476 error ("cannot apply member pointer %qE to %qE, which is of "
1477 "non-class type %qT",
1478 component, datum, objtype);
1479 return error_mark_node;
1482 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1483 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1485 if (!COMPLETE_TYPE_P (ctype))
1487 if (!same_type_p (ctype, objtype))
1493 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1498 error ("pointer to member type %qT incompatible with object "
1501 return error_mark_node;
1503 else if (binfo == error_mark_node)
1504 return error_mark_node;
1507 if (TYPE_PTRMEM_P (ptrmem_type))
1511 /* Compute the type of the field, as described in [expr.ref].
1512 There's no such thing as a mutable pointer-to-member, so
1513 things are not as complex as they are for references to
1514 non-static data members. */
1515 type = cp_build_qualified_type (type,
1516 (cp_type_quals (type)
1517 | cp_type_quals (TREE_TYPE (datum))));
1519 datum = build_address (datum);
1521 /* Convert object to the correct base. */
1523 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1525 /* Build an expression for "object + offset" where offset is the
1526 value stored in the pointer-to-data-member. */
1527 ptype = build_pointer_type (type);
1528 datum = build2 (POINTER_PLUS_EXPR, ptype,
1529 fold_convert (ptype, datum),
1530 build_nop (sizetype, component));
1531 return cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1534 return build2 (OFFSET_REF, type, datum, component);
1537 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1540 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1542 /* This is either a call to a constructor,
1543 or a C cast in C++'s `functional' notation. */
1545 /* The type to which we are casting. */
1547 VEC(tree,gc) *parmvec;
1549 if (exp == error_mark_node || parms == error_mark_node)
1550 return error_mark_node;
1552 if (TREE_CODE (exp) == TYPE_DECL)
1553 type = TREE_TYPE (exp);
1557 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1559 error ("invalid value-initialization of reference types");
1560 return error_mark_node;
1563 if (processing_template_decl)
1565 tree t = build_min (CAST_EXPR, type, parms);
1566 /* We don't know if it will or will not have side effects. */
1567 TREE_SIDE_EFFECTS (t) = 1;
1571 if (! MAYBE_CLASS_TYPE_P (type))
1573 if (parms == NULL_TREE)
1574 return cp_convert (type, integer_zero_node);
1576 /* This must build a C cast. */
1577 parms = build_x_compound_expr_from_list (parms, "functional cast");
1578 return cp_build_c_cast (type, parms, complain);
1581 /* Prepare to evaluate as a call to a constructor. If this expression
1582 is actually used, for example,
1584 return X (arg1, arg2, ...);
1586 then the slot being initialized will be filled in. */
1588 if (!complete_type_or_else (type, NULL_TREE))
1589 return error_mark_node;
1590 if (abstract_virtuals_error (NULL_TREE, type))
1591 return error_mark_node;
1595 If the expression list is a single-expression, the type
1596 conversion is equivalent (in definedness, and if defined in
1597 meaning) to the corresponding cast expression. */
1598 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1599 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1603 The expression T(), where T is a simple-type-specifier for a
1604 non-array complete object type or the (possibly cv-qualified)
1605 void type, creates an rvalue of the specified type, which is
1606 value-initialized. */
1608 if (parms == NULL_TREE
1609 /* If there's a user-defined constructor, value-initialization is
1610 just calling the constructor, so fall through. */
1611 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1613 exp = build_value_init (type);
1614 return get_target_expr (exp);
1617 /* Call the constructor. */
1618 parmvec = make_tree_vector ();
1619 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1620 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1621 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1622 &parmvec, type, LOOKUP_NORMAL, complain);
1623 release_tree_vector (parmvec);
1625 if (exp == error_mark_node)
1626 return error_mark_node;
1628 return build_cplus_new (type, exp);
1632 /* Add new exception specifier SPEC, to the LIST we currently have.
1633 If it's already in LIST then do nothing.
1634 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1635 know what we're doing. */
1638 add_exception_specifier (tree list, tree spec, int complain)
1643 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1645 if (spec == error_mark_node)
1648 gcc_assert (spec && (!list || TREE_VALUE (list)));
1650 /* [except.spec] 1, type in an exception specifier shall not be
1651 incomplete, or pointer or ref to incomplete other than pointer
1653 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1654 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1655 core = TREE_TYPE (core);
1658 else if (VOID_TYPE_P (core))
1660 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1662 else if (processing_template_decl)
1667 /* 15.4/1 says that types in an exception specifier must be complete,
1668 but it seems more reasonable to only require this on definitions
1669 and calls. So just give a pedwarn at this point; we will give an
1670 error later if we hit one of those two cases. */
1671 if (!COMPLETE_TYPE_P (complete_type (core)))
1672 diag_type = DK_PEDWARN; /* pedwarn */
1679 for (probe = list; probe; probe = TREE_CHAIN (probe))
1680 if (same_type_p (TREE_VALUE (probe), spec))
1683 list = tree_cons (NULL_TREE, spec, list);
1686 diag_type = DK_ERROR; /* error */
1688 if (diag_type != DK_UNSPECIFIED && complain)
1689 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1694 /* Combine the two exceptions specifier lists LIST and ADD, and return
1698 merge_exception_specifiers (tree list, tree add)
1702 else if (!TREE_VALUE (list))
1704 else if (!TREE_VALUE (add))
1708 tree orig_list = list;
1710 for (; add; add = TREE_CHAIN (add))
1712 tree spec = TREE_VALUE (add);
1715 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1716 if (same_type_p (TREE_VALUE (probe), spec))
1720 spec = build_tree_list (NULL_TREE, spec);
1721 TREE_CHAIN (spec) = list;
1729 /* Subroutine of build_call. Ensure that each of the types in the
1730 exception specification is complete. Technically, 15.4/1 says that
1731 they need to be complete when we see a declaration of the function,
1732 but we should be able to get away with only requiring this when the
1733 function is defined or called. See also add_exception_specifier. */
1736 require_complete_eh_spec_types (tree fntype, tree decl)
1739 /* Don't complain about calls to op new. */
1740 if (decl && DECL_ARTIFICIAL (decl))
1742 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1743 raises = TREE_CHAIN (raises))
1745 tree type = TREE_VALUE (raises);
1746 if (type && !COMPLETE_TYPE_P (type))
1750 ("call to function %qD which throws incomplete type %q#T",
1753 error ("call to function which throws incomplete type %q#T",
1760 #include "gt-cp-typeck2.h"