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, 2010
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-core.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_alloc_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_EACH_VEC_ELT (tree, pure, ix, fn)
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 if (TREE_CODE (init) == TREE_LIST)
719 error ("constructor syntax used, but no constructor declared "
720 "for type %qT", type);
721 init = build_constructor_from_list (init_list_type_node, nreverse (init));
724 else if (TREE_CODE (init) == TREE_LIST
725 && TREE_TYPE (init) != unknown_type_node)
727 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
729 if (TREE_CODE (init) == TREE_LIST
730 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
732 error ("cannot initialize arrays using this syntax");
736 /* We get here with code like `int a (2);' */
737 init = build_x_compound_expr_from_list (init, ELK_INIT,
738 tf_warning_or_error);
741 /* End of special C++ code. */
743 if (flags & LOOKUP_ALREADY_DIGESTED)
746 /* Digest the specified initializer into an expression. */
747 value = digest_init_flags (type, init, flags);
749 /* In C++0x constant expression is a semantic, not syntactic, property.
750 In C++98, make sure that what we thought was a constant expression at
751 template definition time is still constant. */
752 if ((cxx_dialect >= cxx0x
753 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
754 && (decl_maybe_constant_var_p (decl)
755 || TREE_STATIC (decl)))
758 value = fold_non_dependent_expr (value);
759 value = maybe_constant_init (value);
760 if (DECL_DECLARED_CONSTEXPR_P (decl))
761 /* Diagnose a non-constant initializer for constexpr. */
762 value = cxx_constant_value (value);
763 const_init = (reduced_constant_expression_p (value)
764 || error_operand_p (value));
765 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
766 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
769 /* If the initializer is not a constant, fill in DECL_INITIAL with
770 the bits that are constant, and then return an expression that
771 will perform the dynamic initialization. */
772 if (value != error_mark_node
773 && (TREE_SIDE_EFFECTS (value)
774 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
775 return split_nonconstant_init (decl, value);
776 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
777 is an automatic variable, the middle end will turn this into a
778 dynamic initialization later. */
779 DECL_INITIAL (decl) = value;
784 /* Give errors about narrowing conversions within { }. */
787 check_narrowing (tree type, tree init)
789 tree ftype = unlowered_expr_type (init);
793 init = maybe_constant_value (init);
795 if (TREE_CODE (type) == INTEGER_TYPE
796 && TREE_CODE (ftype) == REAL_TYPE)
798 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
799 && CP_INTEGRAL_TYPE_P (type))
801 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
802 && (TREE_CODE (init) != INTEGER_CST
803 || !int_fits_type_p (init, type)))
806 else if (TREE_CODE (ftype) == REAL_TYPE
807 && TREE_CODE (type) == REAL_TYPE)
809 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
811 if (TREE_CODE (init) == REAL_CST)
813 /* Issue 703: Loss of precision is OK as long as the value is
814 within the representable range of the new type. */
816 d = TREE_REAL_CST (init);
817 real_convert (&r, TYPE_MODE (type), &d);
825 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
826 && TREE_CODE (type) == REAL_TYPE)
829 if (TREE_CODE (init) == INTEGER_CST)
831 d = real_value_from_int_cst (0, init);
832 if (exact_real_truncate (TYPE_MODE (type), &d))
838 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
842 /* Process the initializer INIT for a variable of type TYPE, emitting
843 diagnostics for invalid initializers and converting the initializer as
846 For aggregate types, it assumes that reshape_init has already run, thus the
847 initializer will have the right shape (brace elision has been undone).
849 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
852 digest_init_r (tree type, tree init, bool nested, int flags)
854 enum tree_code code = TREE_CODE (type);
856 if (error_operand_p (init))
857 return error_mark_node;
861 /* We must strip the outermost array type when completing the type,
862 because the its bounds might be incomplete at the moment. */
863 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
864 ? TREE_TYPE (type) : type, NULL_TREE))
865 return error_mark_node;
867 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
868 (g++.old-deja/g++.law/casts2.C). */
869 if (TREE_CODE (init) == NON_LVALUE_EXPR)
870 init = TREE_OPERAND (init, 0);
872 /* Initialization of an array of chars from a string constant. The initializer
873 can be optionally enclosed in braces, but reshape_init has already removed
874 them if they were present. */
875 if (code == ARRAY_TYPE)
877 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
878 if (char_type_p (typ1)
880 && TREE_CODE (init) == STRING_CST)
882 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
884 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
886 if (char_type != char_type_node)
888 error ("char-array initialized from wide string");
889 return error_mark_node;
894 if (char_type == char_type_node)
896 error ("int-array initialized from non-wide string");
897 return error_mark_node;
899 else if (char_type != typ1)
901 error ("int-array initialized from incompatible wide string");
902 return error_mark_node;
906 TREE_TYPE (init) = type;
907 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
909 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
910 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
911 /* In C it is ok to subtract 1 from the length of the string
912 because it's ok to ignore the terminating null char that is
913 counted in the length of the constant, but in C++ this would
915 if (size < TREE_STRING_LENGTH (init))
916 permerror (input_location, "initializer-string for array of chars is too long");
922 /* Handle scalar types (including conversions) and references. */
923 if ((TREE_CODE (type) != COMPLEX_TYPE
924 || BRACE_ENCLOSED_INITIALIZER_P (init))
925 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
929 if (cxx_dialect != cxx98 && nested)
930 check_narrowing (type, init);
931 init = convert_for_initialization (0, type, init, flags,
932 ICR_INIT, NULL_TREE, 0,
933 tf_warning_or_error);
936 /* Skip any conversions since we'll be outputting the underlying
938 while (CONVERT_EXPR_P (*exp)
939 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
940 exp = &TREE_OPERAND (*exp, 0);
942 *exp = cplus_expand_constant (*exp);
947 /* Come here only for aggregates: records, arrays, unions, complex numbers
949 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
950 || TREE_CODE (type) == VECTOR_TYPE
951 || TREE_CODE (type) == RECORD_TYPE
952 || TREE_CODE (type) == UNION_TYPE
953 || TREE_CODE (type) == COMPLEX_TYPE);
955 if (BRACE_ENCLOSED_INITIALIZER_P (init)
956 && !TYPE_NON_AGGREGATE_CLASS (type))
957 return process_init_constructor (type, init);
960 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
962 error ("cannot initialize aggregate of type %qT with "
963 "a compound literal", type);
965 return error_mark_node;
968 if (TREE_CODE (type) == ARRAY_TYPE
969 && !BRACE_ENCLOSED_INITIALIZER_P (init))
971 /* Allow the result of build_array_copy and of
972 build_value_init_noctor. */
973 if ((TREE_CODE (init) == TARGET_EXPR
974 || TREE_CODE (init) == CONSTRUCTOR)
975 && (same_type_ignoring_top_level_qualifiers_p
976 (type, TREE_TYPE (init))))
979 error ("array must be initialized with a brace-enclosed"
981 return error_mark_node;
984 return convert_for_initialization (NULL_TREE, type, init,
986 ICR_INIT, NULL_TREE, 0,
987 tf_warning_or_error);
992 digest_init (tree type, tree init)
994 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
998 digest_init_flags (tree type, tree init, int flags)
1000 return digest_init_r (type, init, false, flags);
1003 /* Set of flags used within process_init_constructor to describe the
1005 #define PICFLAG_ERRONEOUS 1
1006 #define PICFLAG_NOT_ALL_CONSTANT 2
1007 #define PICFLAG_NOT_ALL_SIMPLE 4
1009 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1013 picflag_from_initializer (tree init)
1015 if (init == error_mark_node)
1016 return PICFLAG_ERRONEOUS;
1017 else if (!TREE_CONSTANT (init))
1018 return PICFLAG_NOT_ALL_CONSTANT;
1019 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
1020 return PICFLAG_NOT_ALL_SIMPLE;
1024 /* Subroutine of process_init_constructor, which will process an initializer
1025 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1026 which describe the initializers. */
1029 process_init_constructor_array (tree type, tree init)
1031 unsigned HOST_WIDE_INT i, len = 0;
1033 bool unbounded = false;
1034 constructor_elt *ce;
1035 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1037 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1038 || TREE_CODE (type) == VECTOR_TYPE);
1040 if (TREE_CODE (type) == ARRAY_TYPE)
1042 tree domain = TYPE_DOMAIN (type);
1044 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1045 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1048 unbounded = true; /* Take as many as there are. */
1051 /* Vectors are like simple fixed-size arrays. */
1052 len = TYPE_VECTOR_SUBPARTS (type);
1054 /* There must not be more initializers than needed. */
1055 if (!unbounded && VEC_length (constructor_elt, v) > len)
1056 error ("too many initializers for %qT", type);
1058 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1062 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1063 if (compare_tree_int (ce->index, i) != 0)
1065 ce->value = error_mark_node;
1066 sorry ("non-trivial designated initializers not supported");
1070 ce->index = size_int (i);
1071 gcc_assert (ce->value);
1072 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
1074 if (ce->value != error_mark_node)
1075 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1076 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1078 flags |= picflag_from_initializer (ce->value);
1081 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1082 we must add initializers ourselves. */
1084 for (; i < len; ++i)
1088 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
1090 /* If this type needs constructors run for default-initialization,
1091 we can't rely on the back end to do it for us, so build up
1092 TARGET_EXPRs. If the type in question is a class, just build
1093 one up; if it's an array, recurse. */
1094 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
1095 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
1096 tf_warning_or_error);
1098 next = build_constructor (init_list_type_node, NULL);
1099 next = digest_init (TREE_TYPE (type), next);
1101 else if (!zero_init_p (TREE_TYPE (type)))
1102 next = build_zero_init (TREE_TYPE (type),
1103 /*nelts=*/NULL_TREE,
1104 /*static_storage_p=*/false);
1106 /* The default zero-initialization is fine for us; don't
1107 add anything to the CONSTRUCTOR. */
1110 flags |= picflag_from_initializer (next);
1111 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1114 CONSTRUCTOR_ELTS (init) = v;
1118 /* Subroutine of process_init_constructor, which will process an initializer
1119 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1120 the initializers. */
1123 process_init_constructor_record (tree type, tree init)
1125 VEC(constructor_elt,gc) *v = NULL;
1128 unsigned HOST_WIDE_INT idx = 0;
1130 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1131 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1132 gcc_assert (!TYPE_BINFO (type)
1133 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1134 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1136 /* Generally, we will always have an index for each initializer (which is
1137 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1138 reshape_init. So we need to handle both cases. */
1139 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1144 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1146 flags |= picflag_from_initializer (integer_zero_node);
1147 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1151 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1154 /* If this is a bitfield, first convert to the declared type. */
1155 type = TREE_TYPE (field);
1156 if (DECL_BIT_FIELD_TYPE (field))
1157 type = DECL_BIT_FIELD_TYPE (field);
1159 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1161 constructor_elt *ce = VEC_index (constructor_elt,
1162 CONSTRUCTOR_ELTS (init), idx);
1165 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1166 latter case can happen in templates where lookup has to be
1168 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1169 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1170 if (ce->index != field
1171 && ce->index != DECL_NAME (field))
1173 ce->value = error_mark_node;
1174 sorry ("non-trivial designated initializers not supported");
1178 gcc_assert (ce->value);
1179 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1182 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1184 /* If this type needs constructors run for
1185 default-initialization, we can't rely on the back end to do it
1186 for us, so build up TARGET_EXPRs. If the type in question is
1187 a class, just build one up; if it's an array, recurse. */
1188 next = build_constructor (init_list_type_node, NULL);
1189 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1191 next = finish_compound_literal (TREE_TYPE (field), next);
1192 /* direct-initialize the target. No temporary is going
1194 if (TREE_CODE (next) == TARGET_EXPR)
1195 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1198 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1200 /* Warn when some struct elements are implicitly initialized. */
1201 warning (OPT_Wmissing_field_initializers,
1202 "missing initializer for member %qD", field);
1206 if (TREE_READONLY (field))
1207 error ("uninitialized const member %qD", field);
1208 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1209 error ("member %qD with uninitialized const fields", field);
1210 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1211 error ("member %qD is uninitialized reference", field);
1213 /* Warn when some struct elements are implicitly initialized
1215 warning (OPT_Wmissing_field_initializers,
1216 "missing initializer for member %qD", field);
1218 if (!zero_init_p (TREE_TYPE (field)))
1219 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1220 /*static_storage_p=*/false);
1222 /* The default zero-initialization is fine for us; don't
1223 add anything to the CONSTRUCTOR. */
1227 /* If this is a bitfield, now convert to the lowered type. */
1228 if (type != TREE_TYPE (field))
1229 next = cp_convert_and_check (TREE_TYPE (field), next);
1230 flags |= picflag_from_initializer (next);
1231 CONSTRUCTOR_APPEND_ELT (v, field, next);
1234 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1235 error ("too many initializers for %qT", type);
1237 CONSTRUCTOR_ELTS (init) = v;
1241 /* Subroutine of process_init_constructor, which will process a single
1242 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1243 which describe the initializer. */
1246 process_init_constructor_union (tree type, tree init)
1248 constructor_elt *ce;
1251 /* If the initializer was empty, use default zero initialization. */
1252 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1255 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1258 error ("too many initializers for %qT", type);
1259 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1262 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1264 /* If this element specifies a field, initialize via that field. */
1267 if (TREE_CODE (ce->index) == FIELD_DECL)
1269 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1271 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1272 tree name = ce->index;
1274 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1275 if (DECL_NAME (field) == name)
1279 error ("no field %qD found in union being initialized", field);
1280 ce->value = error_mark_node;
1286 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1287 || TREE_CODE (ce->index) == RANGE_EXPR);
1288 error ("index value instead of field name in union initializer");
1289 ce->value = error_mark_node;
1294 /* Find the first named field. ANSI decided in September 1990
1295 that only named fields count here. */
1296 tree field = TYPE_FIELDS (type);
1297 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1298 field = TREE_CHAIN (field);
1299 if (field == NULL_TREE)
1301 error ("too many initializers for %qT", type);
1302 ce->value = error_mark_node;
1307 if (ce->value && ce->value != error_mark_node)
1308 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1310 return picflag_from_initializer (ce->value);
1313 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1314 constructor is a brace-enclosed initializer, and will be modified in-place.
1316 Each element is converted to the right type through digest_init, and
1317 missing initializers are added following the language rules (zero-padding,
1320 After the execution, the initializer will have TREE_CONSTANT if all elts are
1321 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1322 constants that the assembler and linker can compute them.
1324 The function returns the initializer itself, or error_mark_node in case
1328 process_init_constructor (tree type, tree init)
1332 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1334 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1335 flags = process_init_constructor_array (type, init);
1336 else if (TREE_CODE (type) == RECORD_TYPE)
1337 flags = process_init_constructor_record (type, init);
1338 else if (TREE_CODE (type) == UNION_TYPE)
1339 flags = process_init_constructor_union (type, init);
1343 if (flags & PICFLAG_ERRONEOUS)
1344 return error_mark_node;
1346 TREE_TYPE (init) = type;
1347 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1348 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1349 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1351 TREE_CONSTANT (init) = 1;
1352 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1353 TREE_STATIC (init) = 1;
1358 /* Given a structure or union value DATUM, construct and return
1359 the structure or union component which results from narrowing
1360 that value to the base specified in BASETYPE. For example, given the
1363 class L { int ii; };
1364 class A : L { ... };
1365 class B : L { ... };
1366 class C : A, B { ... };
1374 x.A::ii refers to the ii member of the L part of
1375 the A part of the C object named by X. In this case,
1376 DATUM would be x, and BASETYPE would be A.
1378 I used to think that this was nonconformant, that the standard specified
1379 that first we look up ii in A, then convert x to an L& and pull out the
1380 ii part. But in fact, it does say that we convert x to an A&; A here
1381 is known as the "naming class". (jason 2000-12-19)
1383 BINFO_P points to a variable initialized either to NULL_TREE or to the
1384 binfo for the specific base subobject we want to convert to. */
1387 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1391 if (datum == error_mark_node)
1392 return error_mark_node;
1396 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1398 if (!binfo || binfo == error_mark_node)
1400 *binfo_p = NULL_TREE;
1402 error_not_base_type (basetype, TREE_TYPE (datum));
1403 return error_mark_node;
1407 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1410 /* Build a reference to an object specified by the C++ `->' operator.
1411 Usually this just involves dereferencing the object, but if the
1412 `->' operator is overloaded, then such overloads must be
1413 performed until an object which does not have the `->' operator
1414 overloaded is found. An error is reported when circular pointer
1415 delegation is detected. */
1418 build_x_arrow (tree expr)
1420 tree orig_expr = expr;
1421 tree type = TREE_TYPE (expr);
1422 tree last_rval = NULL_TREE;
1423 VEC(tree,gc) *types_memoized = NULL;
1425 if (type == error_mark_node)
1426 return error_mark_node;
1428 if (processing_template_decl)
1430 if (type_dependent_expression_p (expr))
1431 return build_min_nt (ARROW_EXPR, expr);
1432 expr = build_non_dependent_expr (expr);
1435 if (MAYBE_CLASS_TYPE_P (type))
1437 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1438 NULL_TREE, NULL_TREE,
1439 /*overloaded_p=*/NULL,
1440 tf_warning_or_error)))
1442 if (expr == error_mark_node)
1443 return error_mark_node;
1445 if (vec_member (TREE_TYPE (expr), types_memoized))
1447 error ("circular pointer delegation detected");
1448 return error_mark_node;
1451 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1455 if (last_rval == NULL_TREE)
1457 error ("base operand of %<->%> has non-pointer type %qT", type);
1458 return error_mark_node;
1461 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1462 last_rval = convert_from_reference (last_rval);
1465 last_rval = decay_conversion (expr);
1467 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1469 if (processing_template_decl)
1471 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1472 /* It will be dereferenced. */
1473 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1477 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1481 error ("result of %<operator->()%> yields non-pointer result");
1483 error ("base operand of %<->%> is not a pointer");
1484 return error_mark_node;
1487 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1488 already been checked out to be of aggregate type. */
1491 build_m_component_ref (tree datum, tree component)
1499 if (error_operand_p (datum) || error_operand_p (component))
1500 return error_mark_node;
1502 datum = mark_lvalue_use (datum);
1503 component = mark_rvalue_use (component);
1505 ptrmem_type = TREE_TYPE (component);
1506 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1508 error ("%qE cannot be used as a member pointer, since it is of "
1510 component, ptrmem_type);
1511 return error_mark_node;
1514 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1515 if (! MAYBE_CLASS_TYPE_P (objtype))
1517 error ("cannot apply member pointer %qE to %qE, which is of "
1518 "non-class type %qT",
1519 component, datum, objtype);
1520 return error_mark_node;
1523 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1524 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1526 if (!COMPLETE_TYPE_P (ctype))
1528 if (!same_type_p (ctype, objtype))
1534 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1539 error ("pointer to member type %qT incompatible with object "
1542 return error_mark_node;
1544 else if (binfo == error_mark_node)
1545 return error_mark_node;
1548 if (TYPE_PTRMEM_P (ptrmem_type))
1552 /* Compute the type of the field, as described in [expr.ref].
1553 There's no such thing as a mutable pointer-to-member, so
1554 things are not as complex as they are for references to
1555 non-static data members. */
1556 type = cp_build_qualified_type (type,
1557 (cp_type_quals (type)
1558 | cp_type_quals (TREE_TYPE (datum))));
1560 datum = build_address (datum);
1562 /* Convert object to the correct base. */
1564 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1566 /* Build an expression for "object + offset" where offset is the
1567 value stored in the pointer-to-data-member. */
1568 ptype = build_pointer_type (type);
1569 datum = build2 (POINTER_PLUS_EXPR, ptype,
1570 fold_convert (ptype, datum),
1571 build_nop (sizetype, component));
1572 return cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1575 return build2 (OFFSET_REF, type, datum, component);
1578 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1581 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1583 /* This is either a call to a constructor,
1584 or a C cast in C++'s `functional' notation. */
1586 /* The type to which we are casting. */
1588 VEC(tree,gc) *parmvec;
1590 if (exp == error_mark_node || parms == error_mark_node)
1591 return error_mark_node;
1593 if (TREE_CODE (exp) == TYPE_DECL)
1594 type = TREE_TYPE (exp);
1598 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1600 error ("invalid value-initialization of reference type");
1601 return error_mark_node;
1604 if (processing_template_decl)
1606 tree t = build_min (CAST_EXPR, type, parms);
1607 /* We don't know if it will or will not have side effects. */
1608 TREE_SIDE_EFFECTS (t) = 1;
1612 if (! MAYBE_CLASS_TYPE_P (type))
1614 if (parms == NULL_TREE)
1615 return cp_convert (type, integer_zero_node);
1617 /* This must build a C cast. */
1618 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1619 return cp_build_c_cast (type, parms, complain);
1622 /* Prepare to evaluate as a call to a constructor. If this expression
1623 is actually used, for example,
1625 return X (arg1, arg2, ...);
1627 then the slot being initialized will be filled in. */
1629 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1630 return error_mark_node;
1631 if (abstract_virtuals_error (NULL_TREE, type))
1632 return error_mark_node;
1636 If the expression list is a single-expression, the type
1637 conversion is equivalent (in definedness, and if defined in
1638 meaning) to the corresponding cast expression. */
1639 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1640 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1644 The expression T(), where T is a simple-type-specifier for a
1645 non-array complete object type or the (possibly cv-qualified)
1646 void type, creates an rvalue of the specified type, which is
1647 value-initialized. */
1649 if (parms == NULL_TREE
1650 /* If there's a user-defined constructor, value-initialization is
1651 just calling the constructor, so fall through. */
1652 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1654 exp = build_value_init (type, complain);
1655 exp = get_target_expr (exp);
1656 /* FIXME this is wrong */
1657 if (literal_type_p (type))
1658 TREE_CONSTANT (exp) = true;
1662 /* Call the constructor. */
1663 parmvec = make_tree_vector ();
1664 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1665 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1666 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1667 &parmvec, type, LOOKUP_NORMAL, complain);
1668 release_tree_vector (parmvec);
1670 if (exp == error_mark_node)
1671 return error_mark_node;
1673 return build_cplus_new (type, exp);
1677 /* Add new exception specifier SPEC, to the LIST we currently have.
1678 If it's already in LIST then do nothing.
1679 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1680 know what we're doing. */
1683 add_exception_specifier (tree list, tree spec, int complain)
1688 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1690 if (spec == error_mark_node)
1693 gcc_assert (spec && (!list || TREE_VALUE (list)));
1695 /* [except.spec] 1, type in an exception specifier shall not be
1696 incomplete, or pointer or ref to incomplete other than pointer
1698 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1699 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1700 core = TREE_TYPE (core);
1703 else if (VOID_TYPE_P (core))
1705 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1707 else if (processing_template_decl)
1712 /* 15.4/1 says that types in an exception specifier must be complete,
1713 but it seems more reasonable to only require this on definitions
1714 and calls. So just give a pedwarn at this point; we will give an
1715 error later if we hit one of those two cases. */
1716 if (!COMPLETE_TYPE_P (complete_type (core)))
1717 diag_type = DK_PEDWARN; /* pedwarn */
1724 for (probe = list; probe; probe = TREE_CHAIN (probe))
1725 if (same_type_p (TREE_VALUE (probe), spec))
1728 list = tree_cons (NULL_TREE, spec, list);
1731 diag_type = DK_ERROR; /* error */
1733 if (diag_type != DK_UNSPECIFIED && complain)
1734 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1739 /* Combine the two exceptions specifier lists LIST and ADD, and return
1743 merge_exception_specifiers (tree list, tree add)
1747 /* For merging noexcept(true) and throw(), take the more recent one (LIST).
1748 A throw(type-list) spec takes precedence over a noexcept(false) spec.
1749 Any other noexcept-spec should only be merged with an equivalent one.
1750 So the !TREE_VALUE code below is correct for all cases. */
1751 else if (!TREE_VALUE (add))
1753 else if (!TREE_VALUE (list))
1757 tree orig_list = list;
1759 for (; add; add = TREE_CHAIN (add))
1761 tree spec = TREE_VALUE (add);
1764 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1765 if (same_type_p (TREE_VALUE (probe), spec))
1769 spec = build_tree_list (NULL_TREE, spec);
1770 TREE_CHAIN (spec) = list;
1778 /* Subroutine of build_call. Ensure that each of the types in the
1779 exception specification is complete. Technically, 15.4/1 says that
1780 they need to be complete when we see a declaration of the function,
1781 but we should be able to get away with only requiring this when the
1782 function is defined or called. See also add_exception_specifier. */
1785 require_complete_eh_spec_types (tree fntype, tree decl)
1788 /* Don't complain about calls to op new. */
1789 if (decl && DECL_ARTIFICIAL (decl))
1791 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1792 raises = TREE_CHAIN (raises))
1794 tree type = TREE_VALUE (raises);
1795 if (type && !COMPLETE_TYPE_P (type))
1799 ("call to function %qD which throws incomplete type %q#T",
1802 error ("call to function which throws incomplete type %q#T",
1809 #include "gt-cp-typeck2.h"