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"
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, readonly_error_kind errstring)
77 /* This macro is used to emit diagnostics to ensure that all format
78 strings are complete sentences, visible to gettext and checked at
81 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
85 case REK_ASSIGNMENT: \
88 case REK_ASSIGNMENT_ASM: \
102 if (TREE_CODE (arg) == COMPONENT_REF)
104 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
105 ERROR_FOR_ASSIGNMENT (G_("assignment of "
106 "data-member %qD in read-only structure"),
107 G_("assignment (via 'asm' output) of "
108 "data-member %qD in read-only structure"),
110 "data-member %qD in read-only structure"),
112 "data-member %qD in read-only structure"),
113 TREE_OPERAND (arg, 1));
115 ERROR_FOR_ASSIGNMENT (G_("assignment of "
116 "read-only data-member %qD"),
117 G_("assignment (via 'asm' output) of "
118 "read-only data-member %qD"),
120 "read-only data-member %qD"),
122 "read-only data-member %qD"),
123 TREE_OPERAND (arg, 1));
125 else if (TREE_CODE (arg) == VAR_DECL)
127 if (DECL_LANG_SPECIFIC (arg)
128 && DECL_IN_AGGR_P (arg)
129 && !TREE_STATIC (arg))
130 ERROR_FOR_ASSIGNMENT (G_("assignment of "
131 "constant field %qD"),
132 G_("assignment (via 'asm' output) of "
133 "constant field %qD"),
135 "constant field %qD"),
137 "constant field %qD"),
140 ERROR_FOR_ASSIGNMENT (G_("assignment of "
141 "read-only variable %qD"),
142 G_("assignment (via 'asm' output) of "
143 "read-only variable %qD"),
145 "read-only variable %qD"),
147 "read-only variable %qD"),
151 else if (TREE_CODE (arg) == PARM_DECL)
152 ERROR_FOR_ASSIGNMENT (G_("assignment of "
153 "read-only parameter %qD"),
154 G_("assignment (via 'asm' output) of "
155 "read-only parameter %qD"),
157 "read-only parameter %qD"),
159 "read-only parameter %qD"),
161 else if (TREE_CODE (arg) == INDIRECT_REF
162 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
163 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
164 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
165 ERROR_FOR_ASSIGNMENT (G_("assignment of "
166 "read-only reference %qD"),
167 G_("assignment (via 'asm' output) of "
168 "read-only reference %qD"),
170 "read-only reference %qD"),
172 "read-only reference %qD"),
173 TREE_OPERAND (arg, 0));
174 else if (TREE_CODE (arg) == RESULT_DECL)
175 ERROR_FOR_ASSIGNMENT (G_("assignment of "
176 "read-only named return value %qD"),
177 G_("assignment (via 'asm' output) of "
178 "read-only named return value %qD"),
180 "read-only named return value %qD"),
182 "read-only named return value %qD"),
184 else if (TREE_CODE (arg) == FUNCTION_DECL)
185 ERROR_FOR_ASSIGNMENT (G_("assignment of "
187 G_("assignment (via 'asm' output) of "
195 ERROR_FOR_ASSIGNMENT (G_("assignment of "
196 "read-only location %qE"),
197 G_("assignment (via 'asm' output) of "
198 "read-only location %qE"),
200 "read-only location %qE"),
202 "read-only location %qE"),
207 /* Structure that holds information about declarations whose type was
208 incomplete and we could not check whether it was abstract or not. */
210 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
211 /* Declaration which we are checking for abstractness. It is either
212 a DECL node, or an IDENTIFIER_NODE if we do not have a full
213 declaration available. */
216 /* Type which will be checked for abstractness. */
219 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
220 because DECLs already carry locus information. */
223 /* Link to the next element in list. */
224 struct pending_abstract_type* next;
228 /* Compute the hash value of the node VAL. This function is used by the
229 hash table abstract_pending_vars. */
232 pat_calc_hash (const void* val)
234 const struct pending_abstract_type *pat =
235 (const struct pending_abstract_type *) val;
236 return (hashval_t) TYPE_UID (pat->type);
240 /* Compare node VAL1 with the type VAL2. This function is used by the
241 hash table abstract_pending_vars. */
244 pat_compare (const void* val1, const void* val2)
246 const struct pending_abstract_type *const pat1 =
247 (const struct pending_abstract_type *) val1;
248 const_tree const type2 = (const_tree)val2;
250 return (pat1->type == type2);
253 /* Hash table that maintains pending_abstract_type nodes, for which we still
254 need to check for type abstractness. The key of the table is the type
255 of the declaration. */
256 static GTY ((param_is (struct pending_abstract_type)))
257 htab_t abstract_pending_vars = NULL;
260 /* This function is called after TYPE is completed, and will check if there
261 are pending declarations for which we still need to verify the abstractness
262 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
263 turned out to be incomplete. */
266 complete_type_check_abstract (tree type)
269 struct pending_abstract_type *pat;
270 location_t cur_loc = input_location;
272 gcc_assert (COMPLETE_TYPE_P (type));
274 if (!abstract_pending_vars)
277 /* Retrieve the list of pending declarations for this type. */
278 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
279 (hashval_t)TYPE_UID (type), NO_INSERT);
282 pat = (struct pending_abstract_type*)*slot;
285 /* If the type is not abstract, do not do anything. */
286 if (CLASSTYPE_PURE_VIRTUALS (type))
288 struct pending_abstract_type *prev = 0, *next;
290 /* Reverse the list to emit the errors in top-down order. */
291 for (; pat; pat = next)
299 /* Go through the list, and call abstract_virtuals_error for each
300 element: it will issue a diagnostic if the type is abstract. */
303 gcc_assert (type == pat->type);
305 /* Tweak input_location so that the diagnostic appears at the correct
306 location. Notice that this is only needed if the decl is an
308 input_location = pat->locus;
309 abstract_virtuals_error (pat->decl, pat->type);
314 htab_clear_slot (abstract_pending_vars, slot);
316 input_location = cur_loc;
320 /* If TYPE has abstract virtual functions, issue an error about trying
321 to create an object of that type. DECL is the object declared, or
322 NULL_TREE if the declaration is unavailable. Returns 1 if an error
323 occurred; zero if all was well. */
326 abstract_virtuals_error (tree decl, tree type)
330 /* This function applies only to classes. Any other entity can never
332 if (!CLASS_TYPE_P (type))
334 type = TYPE_MAIN_VARIANT (type);
336 /* If the type is incomplete, we register it within a hash table,
337 so that we can check again once it is completed. This makes sense
338 only for objects for which we have a declaration or at least a
340 if (!COMPLETE_TYPE_P (type))
343 struct pending_abstract_type *pat;
345 gcc_assert (!decl || DECL_P (decl)
346 || TREE_CODE (decl) == IDENTIFIER_NODE);
348 if (!abstract_pending_vars)
349 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
352 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
353 (hashval_t)TYPE_UID (type), INSERT);
355 pat = GGC_NEW (struct pending_abstract_type);
358 pat->locus = ((decl && DECL_P (decl))
359 ? DECL_SOURCE_LOCATION (decl)
362 pat->next = (struct pending_abstract_type *) *slot;
368 if (!TYPE_SIZE (type))
369 /* TYPE is being defined, and during that time
370 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
373 pure = CLASSTYPE_PURE_VIRTUALS (type);
379 if (TREE_CODE (decl) == RESULT_DECL)
382 if (TREE_CODE (decl) == VAR_DECL)
383 error ("cannot declare variable %q+D to be of abstract "
384 "type %qT", decl, type);
385 else if (TREE_CODE (decl) == PARM_DECL)
386 error ("cannot declare parameter %q+D to be of abstract type %qT",
388 else if (TREE_CODE (decl) == FIELD_DECL)
389 error ("cannot declare field %q+D to be of abstract type %qT",
391 else if (TREE_CODE (decl) == FUNCTION_DECL
392 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
393 error ("invalid abstract return type for member function %q+#D", decl);
394 else if (TREE_CODE (decl) == FUNCTION_DECL)
395 error ("invalid abstract return type for function %q+#D", decl);
396 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
397 /* Here we do not have location information. */
398 error ("invalid abstract type %qT for %qE", type, decl);
400 error ("invalid abstract type for %q+D", decl);
403 error ("cannot allocate an object of abstract type %qT", type);
405 /* Only go through this once. */
406 if (VEC_length (tree, pure))
411 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
412 " because the following virtual functions are pure within %qT:",
415 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
416 inform (input_location, "\t%+#D", fn);
417 /* Now truncate the vector. This leaves it non-null, so we know
418 there are pure virtuals, but empty so we don't list them out
420 VEC_truncate (tree, pure, 0);
423 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
424 " since type %qT has pure virtual functions",
430 /* Print an error message for invalid use of an incomplete type.
431 VALUE is the expression that was used (or 0 if that isn't known)
432 and TYPE is the type that was invalid. DIAG_KIND indicates the
433 type of diagnostic (see diagnostic.def). */
436 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
437 diagnostic_t diag_kind)
441 gcc_assert (diag_kind == DK_WARNING
442 || diag_kind == DK_PEDWARN
443 || diag_kind == DK_ERROR);
445 /* Avoid duplicate error message. */
446 if (TREE_CODE (type) == ERROR_MARK)
449 if (value != 0 && (TREE_CODE (value) == VAR_DECL
450 || TREE_CODE (value) == PARM_DECL
451 || TREE_CODE (value) == FIELD_DECL))
453 emit_diagnostic (diag_kind, input_location, 0,
454 "%q+D has incomplete type", value);
458 /* We must print an error message. Be clever about what it says. */
460 switch (TREE_CODE (type))
466 emit_diagnostic (diag_kind, input_location, 0,
467 "invalid use of incomplete type %q#T", type);
468 if (!TYPE_TEMPLATE_INFO (type))
469 emit_diagnostic (diag_kind, input_location, 0,
470 "forward declaration of %q+#T", type);
472 emit_diagnostic (diag_kind, input_location, 0,
473 "declaration of %q+#T", type);
477 emit_diagnostic (diag_kind, input_location, 0,
478 "invalid use of %qT", type);
482 if (TYPE_DOMAIN (type))
484 type = TREE_TYPE (type);
487 emit_diagnostic (diag_kind, input_location, 0,
488 "invalid use of array with unspecified bounds");
493 emit_diagnostic (diag_kind, input_location, 0,
494 "invalid use of member (did you forget the %<&%> ?)");
497 case TEMPLATE_TYPE_PARM:
499 emit_diagnostic (diag_kind, input_location, 0,
500 "invalid use of %<auto%>");
502 emit_diagnostic (diag_kind, input_location, 0,
503 "invalid use of template type parameter %qT", type);
506 case BOUND_TEMPLATE_TEMPLATE_PARM:
507 emit_diagnostic (diag_kind, input_location, 0,
508 "invalid use of template template parameter %qT",
513 emit_diagnostic (diag_kind, input_location, 0,
514 "invalid use of dependent type %qT", type);
518 gcc_assert (type == unknown_type_node);
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 *initp)
554 unsigned HOST_WIDE_INT idx;
556 tree field_index, value;
557 tree type = TREE_TYPE (dest);
558 tree inner_type = NULL;
559 bool array_type_p = false;
560 HOST_WIDE_INT num_type_elements, num_initialized_elements;
562 switch (TREE_CODE (type))
565 inner_type = TREE_TYPE (type);
571 case QUAL_UNION_TYPE:
572 num_initialized_elements = 0;
573 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
576 /* The current implementation of this algorithm assumes that
577 the field was set for all the elements. This is usually done
578 by process_init_constructor. */
579 gcc_assert (field_index);
582 inner_type = TREE_TYPE (field_index);
584 if (TREE_CODE (value) == CONSTRUCTOR)
589 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
590 NULL_TREE, NULL_TREE);
592 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
595 split_nonconstant_init_1 (sub, &value);
597 else if (!initializer_constant_valid_p (value, inner_type))
601 HOST_WIDE_INT inner_elements;
603 /* FIXME: Ordered removal is O(1) so the whole function is
604 worst-case quadratic. This could be fixed using an aside
605 bitmap to record which elements must be removed and remove
606 them all at the same time. Or by merging
607 split_non_constant_init into process_init_constructor_array,
608 that is separating constants from non-constants while building
610 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
615 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
616 NULL_TREE, NULL_TREE);
618 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
621 code = build2 (INIT_EXPR, inner_type, sub, value);
622 code = build_stmt (input_location, EXPR_STMT, code);
625 inner_elements = count_type_elements (inner_type, true);
626 if (inner_elements < 0)
627 num_initialized_elements = -1;
628 else if (num_initialized_elements >= 0)
629 num_initialized_elements += inner_elements;
634 num_type_elements = count_type_elements (type, true);
635 /* If all elements of the initializer are non-constant and
636 have been split out, we don't need the empty CONSTRUCTOR. */
637 if (num_type_elements > 0
638 && num_type_elements == num_initialized_elements)
643 if (!initializer_constant_valid_p (init, type))
646 tree cons = copy_node (init);
647 CONSTRUCTOR_ELTS (init) = NULL;
648 code = build2 (MODIFY_EXPR, type, dest, cons);
649 code = build_stmt (input_location, EXPR_STMT, code);
658 /* The rest of the initializer is now a constant. */
659 TREE_CONSTANT (init) = 1;
662 /* A subroutine of store_init_value. Splits non-constant static
663 initializer INIT into a constant part and generates code to
664 perform the non-constant part of the initialization to DEST.
665 Returns the code for the runtime init. */
668 split_nonconstant_init (tree dest, tree init)
672 if (TREE_CODE (init) == CONSTRUCTOR)
674 code = push_stmt_list ();
675 split_nonconstant_init_1 (dest, &init);
676 code = pop_stmt_list (code);
677 DECL_INITIAL (dest) = init;
678 TREE_READONLY (dest) = 0;
681 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
686 /* Perform appropriate conversions on the initial value of a variable,
687 store it in the declaration DECL,
688 and print any error messages that are appropriate.
689 If the init is invalid, store an ERROR_MARK.
691 C++: Note that INIT might be a TREE_LIST, which would mean that it is
692 a base class initializer for some aggregate type, hopefully compatible
693 with DECL. If INIT is a single element, and DECL is an aggregate
694 type, we silently convert INIT into a TREE_LIST, allowing a constructor
697 If INIT is a TREE_LIST and there is no constructor, turn INIT
698 into a CONSTRUCTOR and use standard initialization techniques.
699 Perhaps a warning should be generated?
701 Returns code to be executed if initialization could not be performed
702 for static variable. In that case, caller must emit the code. */
705 store_init_value (tree decl, tree init, int flags)
709 /* If variable's type was invalidly declared, just ignore it. */
711 type = TREE_TYPE (decl);
712 if (TREE_CODE (type) == ERROR_MARK)
715 if (MAYBE_CLASS_TYPE_P (type))
717 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
718 || TREE_CODE (init) == CONSTRUCTOR);
720 if (TREE_CODE (init) == TREE_LIST)
722 error ("constructor syntax used, but no constructor declared "
723 "for type %qT", type);
724 init = build_constructor_from_list (init_list_type_node, nreverse (init));
727 else if (TREE_CODE (init) == TREE_LIST
728 && TREE_TYPE (init) != unknown_type_node)
730 if (TREE_CODE (decl) == RESULT_DECL)
731 init = build_x_compound_expr_from_list (init,
732 "return value initializer");
733 else if (TREE_CODE (init) == TREE_LIST
734 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
736 error ("cannot initialize arrays using this syntax");
740 /* We get here with code like `int a (2);' */
741 init = build_x_compound_expr_from_list (init, "initializer");
744 /* End of special C++ code. */
746 /* Digest the specified initializer into an expression. */
747 value = digest_init_flags (type, init, flags);
748 /* If the initializer is not a constant, fill in DECL_INITIAL with
749 the bits that are constant, and then return an expression that
750 will perform the dynamic initialization. */
751 if (value != error_mark_node
752 && (TREE_SIDE_EFFECTS (value)
753 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
754 return split_nonconstant_init (decl, value);
755 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
756 is an automatic variable, the middle end will turn this into a
757 dynamic initialization later. */
758 DECL_INITIAL (decl) = value;
763 /* Give errors about narrowing conversions within { }. */
766 check_narrowing (tree type, tree init)
768 tree ftype = unlowered_expr_type (init);
773 init = decl_constant_value (init);
775 if (TREE_CODE (type) == INTEGER_TYPE
776 && TREE_CODE (ftype) == REAL_TYPE)
778 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
779 && CP_INTEGRAL_TYPE_P (type))
781 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
782 && (TREE_CODE (init) != INTEGER_CST
783 || !int_fits_type_p (init, type)))
786 else if (TREE_CODE (ftype) == REAL_TYPE
787 && TREE_CODE (type) == REAL_TYPE)
789 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
791 if (TREE_CODE (init) == REAL_CST)
793 /* Issue 703: Loss of precision is OK as long as the value is
794 within the representable range of the new type. */
796 d = TREE_REAL_CST (init);
797 real_convert (&r, TYPE_MODE (type), &d);
805 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
806 && TREE_CODE (type) == REAL_TYPE)
809 if (TREE_CODE (init) == INTEGER_CST)
811 d = real_value_from_int_cst (0, init);
812 if (exact_real_truncate (TYPE_MODE (type), &d))
818 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
822 /* Process the initializer INIT for a variable of type TYPE, emitting
823 diagnostics for invalid initializers and converting the initializer as
826 For aggregate types, it assumes that reshape_init has already run, thus the
827 initializer will have the right shape (brace elision has been undone).
829 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
832 digest_init_r (tree type, tree init, bool nested, int flags)
834 enum tree_code code = TREE_CODE (type);
836 if (error_operand_p (init))
837 return error_mark_node;
841 /* We must strip the outermost array type when completing the type,
842 because the its bounds might be incomplete at the moment. */
843 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
844 ? TREE_TYPE (type) : type, NULL_TREE))
845 return error_mark_node;
847 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
848 (g++.old-deja/g++.law/casts2.C). */
849 if (TREE_CODE (init) == NON_LVALUE_EXPR)
850 init = TREE_OPERAND (init, 0);
852 /* Initialization of an array of chars from a string constant. The initializer
853 can be optionally enclosed in braces, but reshape_init has already removed
854 them if they were present. */
855 if (code == ARRAY_TYPE)
857 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
858 if (char_type_p (typ1)
860 && TREE_CODE (init) == STRING_CST)
862 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
864 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
866 if (char_type != char_type_node)
868 error ("char-array initialized from wide string");
869 return error_mark_node;
874 if (char_type == char_type_node)
876 error ("int-array initialized from non-wide string");
877 return error_mark_node;
879 else if (char_type != typ1)
881 error ("int-array initialized from incompatible wide string");
882 return error_mark_node;
886 TREE_TYPE (init) = type;
887 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
889 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
890 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
891 /* In C it is ok to subtract 1 from the length of the string
892 because it's ok to ignore the terminating null char that is
893 counted in the length of the constant, but in C++ this would
895 if (size < TREE_STRING_LENGTH (init))
896 permerror (input_location, "initializer-string for array of chars is too long");
902 /* Handle scalar types (including conversions) and references. */
903 if ((TREE_CODE (type) != COMPLEX_TYPE
904 || BRACE_ENCLOSED_INITIALIZER_P (init))
905 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
909 if (cxx_dialect != cxx98 && nested)
910 check_narrowing (type, init);
911 init = convert_for_initialization (0, type, init, flags,
912 "initialization", NULL_TREE, 0,
913 tf_warning_or_error);
916 /* Skip any conversions since we'll be outputting the underlying
918 while (CONVERT_EXPR_P (*exp)
919 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
920 exp = &TREE_OPERAND (*exp, 0);
922 *exp = cplus_expand_constant (*exp);
927 /* Come here only for aggregates: records, arrays, unions, complex numbers
929 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
930 || TREE_CODE (type) == VECTOR_TYPE
931 || TREE_CODE (type) == RECORD_TYPE
932 || TREE_CODE (type) == UNION_TYPE
933 || TREE_CODE (type) == COMPLEX_TYPE);
935 if (BRACE_ENCLOSED_INITIALIZER_P (init)
936 && !TYPE_NON_AGGREGATE_CLASS (type))
937 return process_init_constructor (type, init);
940 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
942 error ("cannot initialize aggregate of type %qT with "
943 "a compound literal", type);
945 return error_mark_node;
948 if (TREE_CODE (type) == ARRAY_TYPE
949 && !BRACE_ENCLOSED_INITIALIZER_P (init))
951 /* Allow the result of build_array_copy and of
952 build_value_init_noctor. */
953 if ((TREE_CODE (init) == TARGET_EXPR
954 || TREE_CODE (init) == CONSTRUCTOR)
955 && (same_type_ignoring_top_level_qualifiers_p
956 (type, TREE_TYPE (init))))
959 error ("array must be initialized with a brace-enclosed"
961 return error_mark_node;
964 return convert_for_initialization (NULL_TREE, type, init,
966 "initialization", NULL_TREE, 0,
967 tf_warning_or_error);
972 digest_init (tree type, tree init)
974 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
978 digest_init_flags (tree type, tree init, int flags)
980 return digest_init_r (type, init, false, flags);
983 /* Set of flags used within process_init_constructor to describe the
985 #define PICFLAG_ERRONEOUS 1
986 #define PICFLAG_NOT_ALL_CONSTANT 2
987 #define PICFLAG_NOT_ALL_SIMPLE 4
989 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
993 picflag_from_initializer (tree init)
995 if (init == error_mark_node)
996 return PICFLAG_ERRONEOUS;
997 else if (!TREE_CONSTANT (init))
998 return PICFLAG_NOT_ALL_CONSTANT;
999 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
1000 return PICFLAG_NOT_ALL_SIMPLE;
1004 /* Subroutine of process_init_constructor, which will process an initializer
1005 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1006 which describe the initializers. */
1009 process_init_constructor_array (tree type, tree init)
1011 unsigned HOST_WIDE_INT i, len = 0;
1013 bool unbounded = false;
1014 constructor_elt *ce;
1015 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1017 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1018 || TREE_CODE (type) == VECTOR_TYPE);
1020 if (TREE_CODE (type) == ARRAY_TYPE)
1022 tree domain = TYPE_DOMAIN (type);
1024 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1025 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1028 unbounded = true; /* Take as many as there are. */
1031 /* Vectors are like simple fixed-size arrays. */
1032 len = TYPE_VECTOR_SUBPARTS (type);
1034 /* There must not be more initializers than needed. */
1035 if (!unbounded && VEC_length (constructor_elt, v) > len)
1036 error ("too many initializers for %qT", type);
1038 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
1042 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1043 if (compare_tree_int (ce->index, i) != 0)
1045 ce->value = error_mark_node;
1046 sorry ("non-trivial designated initializers not supported");
1050 ce->index = size_int (i);
1051 gcc_assert (ce->value);
1052 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
1054 if (ce->value != error_mark_node)
1055 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1056 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1058 flags |= picflag_from_initializer (ce->value);
1061 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1062 we must add initializers ourselves. */
1064 for (; i < len; ++i)
1068 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
1070 /* If this type needs constructors run for default-initialization,
1071 we can't rely on the back end to do it for us, so build up
1072 TARGET_EXPRs. If the type in question is a class, just build
1073 one up; if it's an array, recurse. */
1074 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
1075 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
1076 tf_warning_or_error);
1078 next = build_constructor (init_list_type_node, NULL);
1079 next = digest_init (TREE_TYPE (type), next);
1081 else if (!zero_init_p (TREE_TYPE (type)))
1082 next = build_zero_init (TREE_TYPE (type),
1083 /*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. */
1090 flags |= picflag_from_initializer (next);
1091 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1094 CONSTRUCTOR_ELTS (init) = v;
1098 /* Subroutine of process_init_constructor, which will process an initializer
1099 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1100 the initializers. */
1103 process_init_constructor_record (tree type, tree init)
1105 VEC(constructor_elt,gc) *v = NULL;
1108 unsigned HOST_WIDE_INT idx = 0;
1110 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1111 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1112 gcc_assert (!TYPE_BINFO (type)
1113 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1114 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1116 /* Generally, we will always have an index for each initializer (which is
1117 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1118 reshape_init. So we need to handle both cases. */
1119 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1124 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1126 flags |= picflag_from_initializer (integer_zero_node);
1127 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1131 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1134 /* If this is a bitfield, first convert to the declared type. */
1135 type = TREE_TYPE (field);
1136 if (DECL_BIT_FIELD_TYPE (field))
1137 type = DECL_BIT_FIELD_TYPE (field);
1139 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1141 constructor_elt *ce = VEC_index (constructor_elt,
1142 CONSTRUCTOR_ELTS (init), idx);
1145 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1146 latter case can happen in templates where lookup has to be
1148 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1149 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1150 if (ce->index != field
1151 && ce->index != DECL_NAME (field))
1153 ce->value = error_mark_node;
1154 sorry ("non-trivial designated initializers not supported");
1158 gcc_assert (ce->value);
1159 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1162 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1164 /* If this type needs constructors run for
1165 default-initialization, we can't rely on the back end to do it
1166 for us, so build up TARGET_EXPRs. If the type in question is
1167 a class, just build one up; if it's an array, recurse. */
1168 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1170 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1171 tf_warning_or_error);
1172 /* direct-initialize the target. No temporary is going
1174 if (TREE_CODE (next) == TARGET_EXPR)
1175 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1178 next = build_constructor (init_list_type_node, NULL);
1180 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1182 /* Warn when some struct elements are implicitly initialized. */
1183 warning (OPT_Wmissing_field_initializers,
1184 "missing initializer for member %qD", field);
1188 if (TREE_READONLY (field))
1189 error ("uninitialized const member %qD", field);
1190 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1191 error ("member %qD with uninitialized const fields", field);
1192 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1193 error ("member %qD is uninitialized reference", field);
1195 /* Warn when some struct elements are implicitly initialized
1197 warning (OPT_Wmissing_field_initializers,
1198 "missing initializer for member %qD", field);
1200 if (!zero_init_p (TREE_TYPE (field)))
1201 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1202 /*static_storage_p=*/false);
1204 /* The default zero-initialization is fine for us; don't
1205 add anything to the CONSTRUCTOR. */
1209 /* If this is a bitfield, now convert to the lowered type. */
1210 if (type != TREE_TYPE (field))
1211 next = cp_convert_and_check (TREE_TYPE (field), next);
1212 flags |= picflag_from_initializer (next);
1213 CONSTRUCTOR_APPEND_ELT (v, field, next);
1216 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1217 error ("too many initializers for %qT", type);
1219 CONSTRUCTOR_ELTS (init) = v;
1223 /* Subroutine of process_init_constructor, which will process a single
1224 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1225 which describe the initializer. */
1228 process_init_constructor_union (tree type, tree init)
1230 constructor_elt *ce;
1233 /* If the initializer was empty, use default zero initialization. */
1234 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1237 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1240 error ("too many initializers for %qT", type);
1241 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1244 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1246 /* If this element specifies a field, initialize via that field. */
1249 if (TREE_CODE (ce->index) == FIELD_DECL)
1251 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1253 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1254 tree name = ce->index;
1256 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1257 if (DECL_NAME (field) == name)
1261 error ("no field %qD found in union being initialized", field);
1262 ce->value = error_mark_node;
1268 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1269 || TREE_CODE (ce->index) == RANGE_EXPR);
1270 error ("index value instead of field name in union initializer");
1271 ce->value = error_mark_node;
1276 /* Find the first named field. ANSI decided in September 1990
1277 that only named fields count here. */
1278 tree field = TYPE_FIELDS (type);
1279 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1280 field = TREE_CHAIN (field);
1281 if (field == NULL_TREE)
1283 error ("too many initializers for %qT", type);
1284 ce->value = error_mark_node;
1289 if (ce->value && ce->value != error_mark_node)
1290 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1292 return picflag_from_initializer (ce->value);
1295 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1296 constructor is a brace-enclosed initializer, and will be modified in-place.
1298 Each element is converted to the right type through digest_init, and
1299 missing initializers are added following the language rules (zero-padding,
1302 After the execution, the initializer will have TREE_CONSTANT if all elts are
1303 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1304 constants that the assembler and linker can compute them.
1306 The function returns the initializer itself, or error_mark_node in case
1310 process_init_constructor (tree type, tree init)
1314 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1316 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1317 flags = process_init_constructor_array (type, init);
1318 else if (TREE_CODE (type) == RECORD_TYPE)
1319 flags = process_init_constructor_record (type, init);
1320 else if (TREE_CODE (type) == UNION_TYPE)
1321 flags = process_init_constructor_union (type, init);
1325 if (flags & PICFLAG_ERRONEOUS)
1326 return error_mark_node;
1328 TREE_TYPE (init) = type;
1329 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1330 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1331 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1333 TREE_CONSTANT (init) = 1;
1334 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1335 TREE_STATIC (init) = 1;
1340 /* Given a structure or union value DATUM, construct and return
1341 the structure or union component which results from narrowing
1342 that value to the base specified in BASETYPE. For example, given the
1345 class L { int ii; };
1346 class A : L { ... };
1347 class B : L { ... };
1348 class C : A, B { ... };
1356 x.A::ii refers to the ii member of the L part of
1357 the A part of the C object named by X. In this case,
1358 DATUM would be x, and BASETYPE would be A.
1360 I used to think that this was nonconformant, that the standard specified
1361 that first we look up ii in A, then convert x to an L& and pull out the
1362 ii part. But in fact, it does say that we convert x to an A&; A here
1363 is known as the "naming class". (jason 2000-12-19)
1365 BINFO_P points to a variable initialized either to NULL_TREE or to the
1366 binfo for the specific base subobject we want to convert to. */
1369 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1373 if (datum == error_mark_node)
1374 return error_mark_node;
1378 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1380 if (!binfo || binfo == error_mark_node)
1382 *binfo_p = NULL_TREE;
1384 error_not_base_type (basetype, TREE_TYPE (datum));
1385 return error_mark_node;
1389 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1392 /* Build a reference to an object specified by the C++ `->' operator.
1393 Usually this just involves dereferencing the object, but if the
1394 `->' operator is overloaded, then such overloads must be
1395 performed until an object which does not have the `->' operator
1396 overloaded is found. An error is reported when circular pointer
1397 delegation is detected. */
1400 build_x_arrow (tree expr)
1402 tree orig_expr = expr;
1403 tree types_memoized = NULL_TREE;
1404 tree type = TREE_TYPE (expr);
1405 tree last_rval = NULL_TREE;
1407 if (type == error_mark_node)
1408 return error_mark_node;
1410 if (processing_template_decl)
1412 if (type_dependent_expression_p (expr))
1413 return build_min_nt (ARROW_EXPR, expr);
1414 expr = build_non_dependent_expr (expr);
1417 if (MAYBE_CLASS_TYPE_P (type))
1419 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1420 NULL_TREE, NULL_TREE,
1421 /*overloaded_p=*/NULL,
1422 tf_warning_or_error)))
1424 if (expr == error_mark_node)
1425 return error_mark_node;
1427 if (value_member (TREE_TYPE (expr), types_memoized))
1429 error ("circular pointer delegation detected");
1430 return error_mark_node;
1434 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1440 if (last_rval == NULL_TREE)
1442 error ("base operand of %<->%> has non-pointer type %qT", type);
1443 return error_mark_node;
1446 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1447 last_rval = convert_from_reference (last_rval);
1450 last_rval = decay_conversion (expr);
1452 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1454 if (processing_template_decl)
1456 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1457 /* It will be dereferenced. */
1458 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1462 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1466 error ("result of %<operator->()%> yields non-pointer result");
1468 error ("base operand of %<->%> is not a pointer");
1469 return error_mark_node;
1472 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1473 already been checked out to be of aggregate type. */
1476 build_m_component_ref (tree datum, tree component)
1484 if (error_operand_p (datum) || error_operand_p (component))
1485 return error_mark_node;
1487 ptrmem_type = TREE_TYPE (component);
1488 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1490 error ("%qE cannot be used as a member pointer, since it is of "
1492 component, ptrmem_type);
1493 return error_mark_node;
1496 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1497 if (! MAYBE_CLASS_TYPE_P (objtype))
1499 error ("cannot apply member pointer %qE to %qE, which is of "
1500 "non-class type %qT",
1501 component, datum, objtype);
1502 return error_mark_node;
1505 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1506 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1508 if (!COMPLETE_TYPE_P (ctype))
1510 if (!same_type_p (ctype, objtype))
1516 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1521 error ("pointer to member type %qT incompatible with object "
1524 return error_mark_node;
1526 else if (binfo == error_mark_node)
1527 return error_mark_node;
1530 if (TYPE_PTRMEM_P (ptrmem_type))
1534 /* Compute the type of the field, as described in [expr.ref].
1535 There's no such thing as a mutable pointer-to-member, so
1536 things are not as complex as they are for references to
1537 non-static data members. */
1538 type = cp_build_qualified_type (type,
1539 (cp_type_quals (type)
1540 | cp_type_quals (TREE_TYPE (datum))));
1542 datum = build_address (datum);
1544 /* Convert object to the correct base. */
1546 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1548 /* Build an expression for "object + offset" where offset is the
1549 value stored in the pointer-to-data-member. */
1550 ptype = build_pointer_type (type);
1551 datum = build2 (POINTER_PLUS_EXPR, ptype,
1552 fold_convert (ptype, datum),
1553 build_nop (sizetype, component));
1554 return cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1557 return build2 (OFFSET_REF, type, datum, component);
1560 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1563 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1565 /* This is either a call to a constructor,
1566 or a C cast in C++'s `functional' notation. */
1568 /* The type to which we are casting. */
1570 VEC(tree,gc) *parmvec;
1572 if (exp == error_mark_node || parms == error_mark_node)
1573 return error_mark_node;
1575 if (TREE_CODE (exp) == TYPE_DECL)
1576 type = TREE_TYPE (exp);
1580 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1582 error ("invalid value-initialization of reference type");
1583 return error_mark_node;
1586 if (processing_template_decl)
1588 tree t = build_min (CAST_EXPR, type, parms);
1589 /* We don't know if it will or will not have side effects. */
1590 TREE_SIDE_EFFECTS (t) = 1;
1594 if (! MAYBE_CLASS_TYPE_P (type))
1596 if (parms == NULL_TREE)
1597 return cp_convert (type, integer_zero_node);
1599 /* This must build a C cast. */
1600 parms = build_x_compound_expr_from_list (parms, "functional cast");
1601 return cp_build_c_cast (type, parms, complain);
1604 /* Prepare to evaluate as a call to a constructor. If this expression
1605 is actually used, for example,
1607 return X (arg1, arg2, ...);
1609 then the slot being initialized will be filled in. */
1611 if (!complete_type_or_else (type, NULL_TREE))
1612 return error_mark_node;
1613 if (abstract_virtuals_error (NULL_TREE, type))
1614 return error_mark_node;
1618 If the expression list is a single-expression, the type
1619 conversion is equivalent (in definedness, and if defined in
1620 meaning) to the corresponding cast expression. */
1621 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1622 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1626 The expression T(), where T is a simple-type-specifier for a
1627 non-array complete object type or the (possibly cv-qualified)
1628 void type, creates an rvalue of the specified type, which is
1629 value-initialized. */
1631 if (parms == NULL_TREE
1632 /* If there's a user-defined constructor, value-initialization is
1633 just calling the constructor, so fall through. */
1634 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1636 exp = build_value_init (type);
1637 return get_target_expr (exp);
1640 /* Call the constructor. */
1641 parmvec = make_tree_vector ();
1642 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1643 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1644 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1645 &parmvec, type, LOOKUP_NORMAL, complain);
1646 release_tree_vector (parmvec);
1648 if (exp == error_mark_node)
1649 return error_mark_node;
1651 return build_cplus_new (type, exp);
1655 /* Add new exception specifier SPEC, to the LIST we currently have.
1656 If it's already in LIST then do nothing.
1657 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1658 know what we're doing. */
1661 add_exception_specifier (tree list, tree spec, int complain)
1666 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1668 if (spec == error_mark_node)
1671 gcc_assert (spec && (!list || TREE_VALUE (list)));
1673 /* [except.spec] 1, type in an exception specifier shall not be
1674 incomplete, or pointer or ref to incomplete other than pointer
1676 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1677 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1678 core = TREE_TYPE (core);
1681 else if (VOID_TYPE_P (core))
1683 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1685 else if (processing_template_decl)
1690 /* 15.4/1 says that types in an exception specifier must be complete,
1691 but it seems more reasonable to only require this on definitions
1692 and calls. So just give a pedwarn at this point; we will give an
1693 error later if we hit one of those two cases. */
1694 if (!COMPLETE_TYPE_P (complete_type (core)))
1695 diag_type = DK_PEDWARN; /* pedwarn */
1702 for (probe = list; probe; probe = TREE_CHAIN (probe))
1703 if (same_type_p (TREE_VALUE (probe), spec))
1706 list = tree_cons (NULL_TREE, spec, list);
1709 diag_type = DK_ERROR; /* error */
1711 if (diag_type != DK_UNSPECIFIED && complain)
1712 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1717 /* Combine the two exceptions specifier lists LIST and ADD, and return
1721 merge_exception_specifiers (tree list, tree add)
1725 else if (!TREE_VALUE (list))
1727 else if (!TREE_VALUE (add))
1731 tree orig_list = list;
1733 for (; add; add = TREE_CHAIN (add))
1735 tree spec = TREE_VALUE (add);
1738 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1739 if (same_type_p (TREE_VALUE (probe), spec))
1743 spec = build_tree_list (NULL_TREE, spec);
1744 TREE_CHAIN (spec) = list;
1752 /* Subroutine of build_call. Ensure that each of the types in the
1753 exception specification is complete. Technically, 15.4/1 says that
1754 they need to be complete when we see a declaration of the function,
1755 but we should be able to get away with only requiring this when the
1756 function is defined or called. See also add_exception_specifier. */
1759 require_complete_eh_spec_types (tree fntype, tree decl)
1762 /* Don't complain about calls to op new. */
1763 if (decl && DECL_ARTIFICIAL (decl))
1765 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1766 raises = TREE_CHAIN (raises))
1768 tree type = TREE_VALUE (raises);
1769 if (type && !COMPLETE_TYPE_P (type))
1773 ("call to function %qD which throws incomplete type %q#T",
1776 error ("call to function which throws incomplete type %q#T",
1783 #include "gt-cp-typeck2.h"