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"
39 #include "diagnostic-core.h"
42 process_init_constructor (tree type
, tree init
);
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
49 error_not_base_type (tree basetype
, tree type
)
51 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
52 basetype
= DECL_CONTEXT (basetype
);
53 error ("type %qT is not a base type for type %qT", basetype
, type
);
54 return error_mark_node
;
58 binfo_or_else (tree base
, tree type
)
60 tree binfo
= lookup_base (type
, base
, ba_unique
, NULL
);
62 if (binfo
== error_mark_node
)
65 error_not_base_type (base
, type
);
69 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
70 value may not be changed thereafter. */
73 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
76 /* This macro is used to emit diagnostics to ensure that all format
77 strings are complete sentences, visible to gettext and checked at
80 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
101 /* Handle C++-specific things first. */
103 if (TREE_CODE (arg
) == VAR_DECL
104 && DECL_LANG_SPECIFIC (arg
)
105 && DECL_IN_AGGR_P (arg
)
106 && !TREE_STATIC (arg
))
107 ERROR_FOR_ASSIGNMENT (G_("assignment of "
108 "constant field %qD"),
109 G_("constant field %qD "
110 "used as %<asm%> output"),
112 "constant field %qD"),
114 "constant field %qD"),
116 else if (TREE_CODE (arg
) == INDIRECT_REF
117 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
118 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
119 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
120 ERROR_FOR_ASSIGNMENT (G_("assignment of "
121 "read-only reference %qD"),
122 G_("read-only reference %qD "
123 "used as %<asm%> output"),
125 "read-only reference %qD"),
127 "read-only reference %qD"),
128 TREE_OPERAND (arg
, 0));
130 readonly_error (arg
, errstring
);
134 /* Structure that holds information about declarations whose type was
135 incomplete and we could not check whether it was abstract or not. */
137 struct GTY((chain_next ("%h.next"))) pending_abstract_type
{
138 /* Declaration which we are checking for abstractness. It is either
139 a DECL node, or an IDENTIFIER_NODE if we do not have a full
140 declaration available. */
143 /* Type which will be checked for abstractness. */
146 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
147 because DECLs already carry locus information. */
150 /* Link to the next element in list. */
151 struct pending_abstract_type
* next
;
155 /* Compute the hash value of the node VAL. This function is used by the
156 hash table abstract_pending_vars. */
159 pat_calc_hash (const void* val
)
161 const struct pending_abstract_type
*pat
=
162 (const struct pending_abstract_type
*) val
;
163 return (hashval_t
) TYPE_UID (pat
->type
);
167 /* Compare node VAL1 with the type VAL2. This function is used by the
168 hash table abstract_pending_vars. */
171 pat_compare (const void* val1
, const void* val2
)
173 const struct pending_abstract_type
*const pat1
=
174 (const struct pending_abstract_type
*) val1
;
175 const_tree
const type2
= (const_tree
)val2
;
177 return (pat1
->type
== type2
);
180 /* Hash table that maintains pending_abstract_type nodes, for which we still
181 need to check for type abstractness. The key of the table is the type
182 of the declaration. */
183 static GTY ((param_is (struct pending_abstract_type
)))
184 htab_t abstract_pending_vars
= NULL
;
187 /* This function is called after TYPE is completed, and will check if there
188 are pending declarations for which we still need to verify the abstractness
189 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
190 turned out to be incomplete. */
193 complete_type_check_abstract (tree type
)
196 struct pending_abstract_type
*pat
;
197 location_t cur_loc
= input_location
;
199 gcc_assert (COMPLETE_TYPE_P (type
));
201 if (!abstract_pending_vars
)
204 /* Retrieve the list of pending declarations for this type. */
205 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
206 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
209 pat
= (struct pending_abstract_type
*)*slot
;
212 /* If the type is not abstract, do not do anything. */
213 if (CLASSTYPE_PURE_VIRTUALS (type
))
215 struct pending_abstract_type
*prev
= 0, *next
;
217 /* Reverse the list to emit the errors in top-down order. */
218 for (; pat
; pat
= next
)
226 /* Go through the list, and call abstract_virtuals_error for each
227 element: it will issue a diagnostic if the type is abstract. */
230 gcc_assert (type
== pat
->type
);
232 /* Tweak input_location so that the diagnostic appears at the correct
233 location. Notice that this is only needed if the decl is an
235 input_location
= pat
->locus
;
236 abstract_virtuals_error (pat
->decl
, pat
->type
);
241 htab_clear_slot (abstract_pending_vars
, slot
);
243 input_location
= cur_loc
;
247 /* If TYPE has abstract virtual functions, issue an error about trying
248 to create an object of that type. DECL is the object declared, or
249 NULL_TREE if the declaration is unavailable. Returns 1 if an error
250 occurred; zero if all was well. */
253 abstract_virtuals_error (tree decl
, tree type
)
257 /* This function applies only to classes. Any other entity can never
259 if (!CLASS_TYPE_P (type
))
261 type
= TYPE_MAIN_VARIANT (type
);
263 /* If the type is incomplete, we register it within a hash table,
264 so that we can check again once it is completed. This makes sense
265 only for objects for which we have a declaration or at least a
267 if (!COMPLETE_TYPE_P (type
))
270 struct pending_abstract_type
*pat
;
272 gcc_assert (!decl
|| DECL_P (decl
)
273 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
275 if (!abstract_pending_vars
)
276 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
279 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
280 (hashval_t
)TYPE_UID (type
), INSERT
);
282 pat
= ggc_alloc_pending_abstract_type ();
285 pat
->locus
= ((decl
&& DECL_P (decl
))
286 ? DECL_SOURCE_LOCATION (decl
)
289 pat
->next
= (struct pending_abstract_type
*) *slot
;
295 if (!TYPE_SIZE (type
))
296 /* TYPE is being defined, and during that time
297 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
300 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
306 if (TREE_CODE (decl
) == RESULT_DECL
)
309 if (TREE_CODE (decl
) == VAR_DECL
)
310 error ("cannot declare variable %q+D to be of abstract "
311 "type %qT", decl
, type
);
312 else if (TREE_CODE (decl
) == PARM_DECL
)
313 error ("cannot declare parameter %q+D to be of abstract type %qT",
315 else if (TREE_CODE (decl
) == FIELD_DECL
)
316 error ("cannot declare field %q+D to be of abstract type %qT",
318 else if (TREE_CODE (decl
) == FUNCTION_DECL
319 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
320 error ("invalid abstract return type for member function %q+#D", decl
);
321 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
322 error ("invalid abstract return type for function %q+#D", decl
);
323 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
324 /* Here we do not have location information. */
325 error ("invalid abstract type %qT for %qE", type
, decl
);
327 error ("invalid abstract type for %q+D", decl
);
330 error ("cannot allocate an object of abstract type %qT", type
);
332 /* Only go through this once. */
333 if (VEC_length (tree
, pure
))
338 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
339 " because the following virtual functions are pure within %qT:",
342 FOR_EACH_VEC_ELT (tree
, pure
, ix
, fn
)
343 inform (input_location
, "\t%+#D", fn
);
344 /* Now truncate the vector. This leaves it non-null, so we know
345 there are pure virtuals, but empty so we don't list them out
347 VEC_truncate (tree
, pure
, 0);
350 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
351 " since type %qT has pure virtual functions",
357 /* Print an error message for invalid use of an incomplete type.
358 VALUE is the expression that was used (or 0 if that isn't known)
359 and TYPE is the type that was invalid. DIAG_KIND indicates the
360 type of diagnostic (see diagnostic.def). */
363 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
,
364 diagnostic_t diag_kind
)
368 gcc_assert (diag_kind
== DK_WARNING
369 || diag_kind
== DK_PEDWARN
370 || diag_kind
== DK_ERROR
);
372 /* Avoid duplicate error message. */
373 if (TREE_CODE (type
) == ERROR_MARK
)
376 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
377 || TREE_CODE (value
) == PARM_DECL
378 || TREE_CODE (value
) == FIELD_DECL
))
380 emit_diagnostic (diag_kind
, input_location
, 0,
381 "%q+D has incomplete type", value
);
385 /* We must print an error message. Be clever about what it says. */
387 switch (TREE_CODE (type
))
393 emit_diagnostic (diag_kind
, input_location
, 0,
394 "invalid use of incomplete type %q#T", type
);
395 if (!TYPE_TEMPLATE_INFO (type
))
396 emit_diagnostic (diag_kind
, input_location
, 0,
397 "forward declaration of %q+#T", type
);
399 emit_diagnostic (diag_kind
, input_location
, 0,
400 "declaration of %q+#T", type
);
404 emit_diagnostic (diag_kind
, input_location
, 0,
405 "invalid use of %qT", type
);
409 if (TYPE_DOMAIN (type
))
411 type
= TREE_TYPE (type
);
414 emit_diagnostic (diag_kind
, input_location
, 0,
415 "invalid use of array with unspecified bounds");
420 emit_diagnostic (diag_kind
, input_location
, 0,
421 "invalid use of member (did you forget the %<&%> ?)");
424 case TEMPLATE_TYPE_PARM
:
426 emit_diagnostic (diag_kind
, input_location
, 0,
427 "invalid use of %<auto%>");
429 emit_diagnostic (diag_kind
, input_location
, 0,
430 "invalid use of template type parameter %qT", type
);
433 case BOUND_TEMPLATE_TEMPLATE_PARM
:
434 emit_diagnostic (diag_kind
, input_location
, 0,
435 "invalid use of template template parameter %qT",
440 emit_diagnostic (diag_kind
, input_location
, 0,
441 "invalid use of dependent type %qT", type
);
445 gcc_assert (type
== unknown_type_node
);
446 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
448 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
449 emit_diagnostic (diag_kind
, input_location
, 0,
450 "address of overloaded function with no contextual "
452 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
453 emit_diagnostic (diag_kind
, input_location
, 0,
454 "overloaded function with no contextual type information");
456 emit_diagnostic (diag_kind
, input_location
, 0,
457 "insufficient contextual information to determine type");
465 /* Backward-compatibility interface to incomplete_type_diagnostic;
466 required by ../tree.c. */
467 #undef cxx_incomplete_type_error
469 cxx_incomplete_type_error (const_tree value
, const_tree type
)
471 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
475 /* The recursive part of split_nonconstant_init. DEST is an lvalue
476 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
479 split_nonconstant_init_1 (tree dest
, tree
*initp
)
481 unsigned HOST_WIDE_INT idx
;
483 tree field_index
, value
;
484 tree type
= TREE_TYPE (dest
);
485 tree inner_type
= NULL
;
486 bool array_type_p
= false;
487 HOST_WIDE_INT num_type_elements
, num_initialized_elements
;
489 switch (TREE_CODE (type
))
492 inner_type
= TREE_TYPE (type
);
498 case QUAL_UNION_TYPE
:
499 num_initialized_elements
= 0;
500 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
503 /* The current implementation of this algorithm assumes that
504 the field was set for all the elements. This is usually done
505 by process_init_constructor. */
506 gcc_assert (field_index
);
509 inner_type
= TREE_TYPE (field_index
);
511 if (TREE_CODE (value
) == CONSTRUCTOR
)
516 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
517 NULL_TREE
, NULL_TREE
);
519 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
522 split_nonconstant_init_1 (sub
, &value
);
524 else if (!initializer_constant_valid_p (value
, inner_type
))
528 HOST_WIDE_INT inner_elements
;
530 /* FIXME: Ordered removal is O(1) so the whole function is
531 worst-case quadratic. This could be fixed using an aside
532 bitmap to record which elements must be removed and remove
533 them all at the same time. Or by merging
534 split_non_constant_init into process_init_constructor_array,
535 that is separating constants from non-constants while building
537 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
542 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
543 NULL_TREE
, NULL_TREE
);
545 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
548 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
549 code
= build_stmt (input_location
, EXPR_STMT
, code
);
552 inner_elements
= count_type_elements (inner_type
, true);
553 if (inner_elements
< 0)
554 num_initialized_elements
= -1;
555 else if (num_initialized_elements
>= 0)
556 num_initialized_elements
+= inner_elements
;
561 num_type_elements
= count_type_elements (type
, true);
562 /* If all elements of the initializer are non-constant and
563 have been split out, we don't need the empty CONSTRUCTOR. */
564 if (num_type_elements
> 0
565 && num_type_elements
== num_initialized_elements
)
570 if (!initializer_constant_valid_p (init
, type
))
573 tree cons
= copy_node (init
);
574 CONSTRUCTOR_ELTS (init
) = NULL
;
575 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
576 code
= build_stmt (input_location
, EXPR_STMT
, code
);
585 /* The rest of the initializer is now a constant. */
586 TREE_CONSTANT (init
) = 1;
589 /* A subroutine of store_init_value. Splits non-constant static
590 initializer INIT into a constant part and generates code to
591 perform the non-constant part of the initialization to DEST.
592 Returns the code for the runtime init. */
595 split_nonconstant_init (tree dest
, tree init
)
599 if (TREE_CODE (init
) == CONSTRUCTOR
)
601 code
= push_stmt_list ();
602 split_nonconstant_init_1 (dest
, &init
);
603 code
= pop_stmt_list (code
);
604 DECL_INITIAL (dest
) = init
;
605 TREE_READONLY (dest
) = 0;
608 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
613 /* Perform appropriate conversions on the initial value of a variable,
614 store it in the declaration DECL,
615 and print any error messages that are appropriate.
616 If the init is invalid, store an ERROR_MARK.
618 C++: Note that INIT might be a TREE_LIST, which would mean that it is
619 a base class initializer for some aggregate type, hopefully compatible
620 with DECL. If INIT is a single element, and DECL is an aggregate
621 type, we silently convert INIT into a TREE_LIST, allowing a constructor
624 If INIT is a TREE_LIST and there is no constructor, turn INIT
625 into a CONSTRUCTOR and use standard initialization techniques.
626 Perhaps a warning should be generated?
628 Returns code to be executed if initialization could not be performed
629 for static variable. In that case, caller must emit the code. */
632 store_init_value (tree decl
, tree init
, int flags
)
636 /* If variable's type was invalidly declared, just ignore it. */
638 type
= TREE_TYPE (decl
);
639 if (TREE_CODE (type
) == ERROR_MARK
)
642 if (MAYBE_CLASS_TYPE_P (type
))
644 if (TREE_CODE (init
) == TREE_LIST
)
646 error ("constructor syntax used, but no constructor declared "
647 "for type %qT", type
);
648 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
651 else if (TREE_CODE (init
) == TREE_LIST
652 && TREE_TYPE (init
) != unknown_type_node
)
654 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
656 if (TREE_CODE (init
) == TREE_LIST
657 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
659 error ("cannot initialize arrays using this syntax");
663 /* We get here with code like `int a (2);' */
664 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
665 tf_warning_or_error
);
668 /* End of special C++ code. */
670 if (flags
& LOOKUP_ALREADY_DIGESTED
)
673 /* Digest the specified initializer into an expression. */
674 value
= digest_init_flags (type
, init
, flags
);
676 /* In C++0x constant expression is a semantic, not syntactic, property.
677 In C++98, make sure that what we thought was a constant expression at
678 template definition time is still constant. */
679 if ((cxx_dialect
>= cxx0x
680 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
681 && (decl_maybe_constant_var_p (decl
)
682 || TREE_STATIC (decl
)))
685 value
= fold_non_dependent_expr (value
);
686 value
= maybe_constant_init (value
);
687 if (DECL_DECLARED_CONSTEXPR_P (decl
))
688 /* Diagnose a non-constant initializer for constexpr. */
689 value
= cxx_constant_value (value
);
690 const_init
= (reduced_constant_expression_p (value
)
691 || error_operand_p (value
));
692 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
693 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
696 /* If the initializer is not a constant, fill in DECL_INITIAL with
697 the bits that are constant, and then return an expression that
698 will perform the dynamic initialization. */
699 if (value
!= error_mark_node
700 && (TREE_SIDE_EFFECTS (value
)
701 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
702 return split_nonconstant_init (decl
, value
);
703 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
704 is an automatic variable, the middle end will turn this into a
705 dynamic initialization later. */
706 DECL_INITIAL (decl
) = value
;
711 /* Give errors about narrowing conversions within { }. */
714 check_narrowing (tree type
, tree init
)
716 tree ftype
= unlowered_expr_type (init
);
720 init
= maybe_constant_value (init
);
722 if (TREE_CODE (type
) == INTEGER_TYPE
723 && TREE_CODE (ftype
) == REAL_TYPE
)
725 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
726 && CP_INTEGRAL_TYPE_P (type
))
728 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
)
729 && (TREE_CODE (init
) != INTEGER_CST
730 || !int_fits_type_p (init
, type
)))
733 else if (TREE_CODE (ftype
) == REAL_TYPE
734 && TREE_CODE (type
) == REAL_TYPE
)
736 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
738 if (TREE_CODE (init
) == REAL_CST
)
740 /* Issue 703: Loss of precision is OK as long as the value is
741 within the representable range of the new type. */
743 d
= TREE_REAL_CST (init
);
744 real_convert (&r
, TYPE_MODE (type
), &d
);
752 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
753 && TREE_CODE (type
) == REAL_TYPE
)
756 if (TREE_CODE (init
) == INTEGER_CST
)
758 d
= real_value_from_int_cst (0, init
);
759 if (exact_real_truncate (TYPE_MODE (type
), &d
))
765 permerror (input_location
, "narrowing conversion of %qE from %qT to %qT inside { }",
769 /* Process the initializer INIT for a variable of type TYPE, emitting
770 diagnostics for invalid initializers and converting the initializer as
773 For aggregate types, it assumes that reshape_init has already run, thus the
774 initializer will have the right shape (brace elision has been undone).
776 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
779 digest_init_r (tree type
, tree init
, bool nested
, int flags
)
781 enum tree_code code
= TREE_CODE (type
);
783 if (error_operand_p (init
))
784 return error_mark_node
;
788 /* We must strip the outermost array type when completing the type,
789 because the its bounds might be incomplete at the moment. */
790 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
791 ? TREE_TYPE (type
) : type
, NULL_TREE
))
792 return error_mark_node
;
794 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
795 (g++.old-deja/g++.law/casts2.C). */
796 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
797 init
= TREE_OPERAND (init
, 0);
799 /* Initialization of an array of chars from a string constant. The initializer
800 can be optionally enclosed in braces, but reshape_init has already removed
801 them if they were present. */
802 if (code
== ARRAY_TYPE
)
804 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
805 if (char_type_p (typ1
)
807 && TREE_CODE (init
) == STRING_CST
)
809 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
811 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
813 if (char_type
!= char_type_node
)
815 error ("char-array initialized from wide string");
816 return error_mark_node
;
821 if (char_type
== char_type_node
)
823 error ("int-array initialized from non-wide string");
824 return error_mark_node
;
826 else if (char_type
!= typ1
)
828 error ("int-array initialized from incompatible wide string");
829 return error_mark_node
;
833 TREE_TYPE (init
) = type
;
834 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
836 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
837 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
838 /* In C it is ok to subtract 1 from the length of the string
839 because it's ok to ignore the terminating null char that is
840 counted in the length of the constant, but in C++ this would
842 if (size
< TREE_STRING_LENGTH (init
))
843 permerror (input_location
, "initializer-string for array of chars is too long");
849 /* Handle scalar types (including conversions) and references. */
850 if ((TREE_CODE (type
) != COMPLEX_TYPE
851 || BRACE_ENCLOSED_INITIALIZER_P (init
))
852 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
856 if (cxx_dialect
!= cxx98
&& nested
)
857 check_narrowing (type
, init
);
858 init
= convert_for_initialization (0, type
, init
, flags
,
859 ICR_INIT
, NULL_TREE
, 0,
860 tf_warning_or_error
);
863 /* Skip any conversions since we'll be outputting the underlying
865 while (CONVERT_EXPR_P (*exp
)
866 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
867 exp
= &TREE_OPERAND (*exp
, 0);
869 *exp
= cplus_expand_constant (*exp
);
874 /* Come here only for aggregates: records, arrays, unions, complex numbers
876 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
877 || TREE_CODE (type
) == VECTOR_TYPE
878 || TREE_CODE (type
) == RECORD_TYPE
879 || TREE_CODE (type
) == UNION_TYPE
880 || TREE_CODE (type
) == COMPLEX_TYPE
);
882 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
883 && !TYPE_NON_AGGREGATE_CLASS (type
))
884 return process_init_constructor (type
, init
);
887 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
889 error ("cannot initialize aggregate of type %qT with "
890 "a compound literal", type
);
892 return error_mark_node
;
895 if (TREE_CODE (type
) == ARRAY_TYPE
896 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
898 /* Allow the result of build_array_copy and of
899 build_value_init_noctor. */
900 if ((TREE_CODE (init
) == TARGET_EXPR
901 || TREE_CODE (init
) == CONSTRUCTOR
)
902 && (same_type_ignoring_top_level_qualifiers_p
903 (type
, TREE_TYPE (init
))))
906 error ("array must be initialized with a brace-enclosed"
908 return error_mark_node
;
911 return convert_for_initialization (NULL_TREE
, type
, init
,
913 ICR_INIT
, NULL_TREE
, 0,
914 tf_warning_or_error
);
919 digest_init (tree type
, tree init
)
921 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
);
925 digest_init_flags (tree type
, tree init
, int flags
)
927 return digest_init_r (type
, init
, false, flags
);
930 /* Set of flags used within process_init_constructor to describe the
932 #define PICFLAG_ERRONEOUS 1
933 #define PICFLAG_NOT_ALL_CONSTANT 2
934 #define PICFLAG_NOT_ALL_SIMPLE 4
936 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
940 picflag_from_initializer (tree init
)
942 if (init
== error_mark_node
)
943 return PICFLAG_ERRONEOUS
;
944 else if (!TREE_CONSTANT (init
))
945 return PICFLAG_NOT_ALL_CONSTANT
;
946 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
947 return PICFLAG_NOT_ALL_SIMPLE
;
951 /* Subroutine of process_init_constructor, which will process an initializer
952 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
953 which describe the initializers. */
956 process_init_constructor_array (tree type
, tree init
)
958 unsigned HOST_WIDE_INT i
, len
= 0;
960 bool unbounded
= false;
962 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
964 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
965 || TREE_CODE (type
) == VECTOR_TYPE
);
967 if (TREE_CODE (type
) == ARRAY_TYPE
)
969 tree domain
= TYPE_DOMAIN (type
);
971 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
972 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
975 unbounded
= true; /* Take as many as there are. */
978 /* Vectors are like simple fixed-size arrays. */
979 len
= TYPE_VECTOR_SUBPARTS (type
);
981 /* There must not be more initializers than needed. */
982 if (!unbounded
&& VEC_length (constructor_elt
, v
) > len
)
983 error ("too many initializers for %qT", type
);
985 FOR_EACH_VEC_ELT (constructor_elt
, v
, i
, ce
)
989 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
990 if (compare_tree_int (ce
->index
, i
) != 0)
992 ce
->value
= error_mark_node
;
993 sorry ("non-trivial designated initializers not supported");
997 ce
->index
= size_int (i
);
998 gcc_assert (ce
->value
);
999 ce
->value
= digest_init_r (TREE_TYPE (type
), ce
->value
, true, LOOKUP_IMPLICIT
);
1001 if (ce
->value
!= error_mark_node
)
1002 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1003 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1005 flags
|= picflag_from_initializer (ce
->value
);
1008 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1009 we must add initializers ourselves. */
1011 for (; i
< len
; ++i
)
1015 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
1017 /* If this type needs constructors run for default-initialization,
1018 we can't rely on the back end to do it for us, so build up
1019 TARGET_EXPRs. If the type in question is a class, just build
1020 one up; if it's an array, recurse. */
1021 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
1022 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
,
1023 tf_warning_or_error
);
1025 next
= build_constructor (init_list_type_node
, NULL
);
1026 next
= digest_init (TREE_TYPE (type
), next
);
1028 else if (!zero_init_p (TREE_TYPE (type
)))
1029 next
= build_zero_init (TREE_TYPE (type
),
1030 /*nelts=*/NULL_TREE
,
1031 /*static_storage_p=*/false);
1033 /* The default zero-initialization is fine for us; don't
1034 add anything to the CONSTRUCTOR. */
1037 flags
|= picflag_from_initializer (next
);
1038 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1041 CONSTRUCTOR_ELTS (init
) = v
;
1045 /* Subroutine of process_init_constructor, which will process an initializer
1046 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1047 the initializers. */
1050 process_init_constructor_record (tree type
, tree init
)
1052 VEC(constructor_elt
,gc
) *v
= NULL
;
1055 unsigned HOST_WIDE_INT idx
= 0;
1057 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1058 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1059 gcc_assert (!TYPE_BINFO (type
)
1060 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1061 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1063 /* Generally, we will always have an index for each initializer (which is
1064 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1065 reshape_init. So we need to handle both cases. */
1066 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1071 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1073 flags
|= picflag_from_initializer (integer_zero_node
);
1074 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
1078 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1081 /* If this is a bitfield, first convert to the declared type. */
1082 type
= TREE_TYPE (field
);
1083 if (DECL_BIT_FIELD_TYPE (field
))
1084 type
= DECL_BIT_FIELD_TYPE (field
);
1086 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1088 constructor_elt
*ce
= VEC_index (constructor_elt
,
1089 CONSTRUCTOR_ELTS (init
), idx
);
1092 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1093 latter case can happen in templates where lookup has to be
1095 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1096 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
1097 if (ce
->index
!= field
1098 && ce
->index
!= DECL_NAME (field
))
1100 ce
->value
= error_mark_node
;
1101 sorry ("non-trivial designated initializers not supported");
1105 gcc_assert (ce
->value
);
1106 next
= digest_init_r (type
, ce
->value
, true, LOOKUP_IMPLICIT
);
1109 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1111 /* If this type needs constructors run for
1112 default-initialization, we can't rely on the back end to do it
1113 for us, so build up TARGET_EXPRs. If the type in question is
1114 a class, just build one up; if it's an array, recurse. */
1115 next
= build_constructor (init_list_type_node
, NULL
);
1116 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field
)))
1118 next
= finish_compound_literal (TREE_TYPE (field
), next
);
1119 /* direct-initialize the target. No temporary is going
1121 if (TREE_CODE (next
) == TARGET_EXPR
)
1122 TARGET_EXPR_DIRECT_INIT_P (next
) = true;
1125 next
= digest_init_r (TREE_TYPE (field
), next
, true, LOOKUP_IMPLICIT
);
1127 /* Warn when some struct elements are implicitly initialized. */
1128 warning (OPT_Wmissing_field_initializers
,
1129 "missing initializer for member %qD", field
);
1133 if (TREE_READONLY (field
))
1134 error ("uninitialized const member %qD", field
);
1135 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1136 error ("member %qD with uninitialized const fields", field
);
1137 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1138 error ("member %qD is uninitialized reference", field
);
1140 /* Warn when some struct elements are implicitly initialized
1142 warning (OPT_Wmissing_field_initializers
,
1143 "missing initializer for member %qD", field
);
1145 if (!zero_init_p (TREE_TYPE (field
)))
1146 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1147 /*static_storage_p=*/false);
1149 /* The default zero-initialization is fine for us; don't
1150 add anything to the CONSTRUCTOR. */
1154 /* If this is a bitfield, now convert to the lowered type. */
1155 if (type
!= TREE_TYPE (field
))
1156 next
= cp_convert_and_check (TREE_TYPE (field
), next
);
1157 flags
|= picflag_from_initializer (next
);
1158 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1161 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1162 error ("too many initializers for %qT", type
);
1164 CONSTRUCTOR_ELTS (init
) = v
;
1168 /* Subroutine of process_init_constructor, which will process a single
1169 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1170 which describe the initializer. */
1173 process_init_constructor_union (tree type
, tree init
)
1175 constructor_elt
*ce
;
1178 /* If the initializer was empty, use default zero initialization. */
1179 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1182 len
= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
));
1185 error ("too many initializers for %qT", type
);
1186 VEC_block_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
), 1, len
-1);
1189 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
1191 /* If this element specifies a field, initialize via that field. */
1194 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1196 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
1198 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1199 tree name
= ce
->index
;
1201 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1202 if (DECL_NAME (field
) == name
)
1206 error ("no field %qD found in union being initialized", field
);
1207 ce
->value
= error_mark_node
;
1213 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1214 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1215 error ("index value instead of field name in union initializer");
1216 ce
->value
= error_mark_node
;
1221 /* Find the first named field. ANSI decided in September 1990
1222 that only named fields count here. */
1223 tree field
= TYPE_FIELDS (type
);
1224 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1225 field
= TREE_CHAIN (field
);
1226 if (field
== NULL_TREE
)
1228 error ("too many initializers for %qT", type
);
1229 ce
->value
= error_mark_node
;
1234 if (ce
->value
&& ce
->value
!= error_mark_node
)
1235 ce
->value
= digest_init_r (TREE_TYPE (ce
->index
), ce
->value
, true, LOOKUP_IMPLICIT
);
1237 return picflag_from_initializer (ce
->value
);
1240 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1241 constructor is a brace-enclosed initializer, and will be modified in-place.
1243 Each element is converted to the right type through digest_init, and
1244 missing initializers are added following the language rules (zero-padding,
1247 After the execution, the initializer will have TREE_CONSTANT if all elts are
1248 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1249 constants that the assembler and linker can compute them.
1251 The function returns the initializer itself, or error_mark_node in case
1255 process_init_constructor (tree type
, tree init
)
1259 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1261 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1262 flags
= process_init_constructor_array (type
, init
);
1263 else if (TREE_CODE (type
) == RECORD_TYPE
)
1264 flags
= process_init_constructor_record (type
, init
);
1265 else if (TREE_CODE (type
) == UNION_TYPE
)
1266 flags
= process_init_constructor_union (type
, init
);
1270 if (flags
& PICFLAG_ERRONEOUS
)
1271 return error_mark_node
;
1273 TREE_TYPE (init
) = type
;
1274 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1275 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1276 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1278 TREE_CONSTANT (init
) = 1;
1279 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1280 TREE_STATIC (init
) = 1;
1285 /* Given a structure or union value DATUM, construct and return
1286 the structure or union component which results from narrowing
1287 that value to the base specified in BASETYPE. For example, given the
1290 class L { int ii; };
1291 class A : L { ... };
1292 class B : L { ... };
1293 class C : A, B { ... };
1301 x.A::ii refers to the ii member of the L part of
1302 the A part of the C object named by X. In this case,
1303 DATUM would be x, and BASETYPE would be A.
1305 I used to think that this was nonconformant, that the standard specified
1306 that first we look up ii in A, then convert x to an L& and pull out the
1307 ii part. But in fact, it does say that we convert x to an A&; A here
1308 is known as the "naming class". (jason 2000-12-19)
1310 BINFO_P points to a variable initialized either to NULL_TREE or to the
1311 binfo for the specific base subobject we want to convert to. */
1314 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1318 if (datum
== error_mark_node
)
1319 return error_mark_node
;
1323 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1325 if (!binfo
|| binfo
== error_mark_node
)
1327 *binfo_p
= NULL_TREE
;
1329 error_not_base_type (basetype
, TREE_TYPE (datum
));
1330 return error_mark_node
;
1334 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1337 /* Build a reference to an object specified by the C++ `->' operator.
1338 Usually this just involves dereferencing the object, but if the
1339 `->' operator is overloaded, then such overloads must be
1340 performed until an object which does not have the `->' operator
1341 overloaded is found. An error is reported when circular pointer
1342 delegation is detected. */
1345 build_x_arrow (tree expr
)
1347 tree orig_expr
= expr
;
1348 tree type
= TREE_TYPE (expr
);
1349 tree last_rval
= NULL_TREE
;
1350 VEC(tree
,gc
) *types_memoized
= NULL
;
1352 if (type
== error_mark_node
)
1353 return error_mark_node
;
1355 if (processing_template_decl
)
1357 if (type_dependent_expression_p (expr
))
1358 return build_min_nt (ARROW_EXPR
, expr
);
1359 expr
= build_non_dependent_expr (expr
);
1362 if (MAYBE_CLASS_TYPE_P (type
))
1364 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1365 NULL_TREE
, NULL_TREE
,
1366 /*overloaded_p=*/NULL
,
1367 tf_warning_or_error
)))
1369 if (expr
== error_mark_node
)
1370 return error_mark_node
;
1372 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1374 error ("circular pointer delegation detected");
1375 return error_mark_node
;
1378 VEC_safe_push (tree
, gc
, types_memoized
, TREE_TYPE (expr
));
1382 if (last_rval
== NULL_TREE
)
1384 error ("base operand of %<->%> has non-pointer type %qT", type
);
1385 return error_mark_node
;
1388 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1389 last_rval
= convert_from_reference (last_rval
);
1392 last_rval
= decay_conversion (expr
);
1394 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1396 if (processing_template_decl
)
1398 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1399 /* It will be dereferenced. */
1400 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1404 return cp_build_indirect_ref (last_rval
, RO_NULL
, tf_warning_or_error
);
1408 error ("result of %<operator->()%> yields non-pointer result");
1410 error ("base operand of %<->%> is not a pointer");
1411 return error_mark_node
;
1414 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1415 already been checked out to be of aggregate type. */
1418 build_m_component_ref (tree datum
, tree component
)
1426 if (error_operand_p (datum
) || error_operand_p (component
))
1427 return error_mark_node
;
1429 datum
= mark_lvalue_use (datum
);
1430 component
= mark_rvalue_use (component
);
1432 ptrmem_type
= TREE_TYPE (component
);
1433 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1435 error ("%qE cannot be used as a member pointer, since it is of "
1437 component
, ptrmem_type
);
1438 return error_mark_node
;
1441 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1442 if (! MAYBE_CLASS_TYPE_P (objtype
))
1444 error ("cannot apply member pointer %qE to %qE, which is of "
1445 "non-class type %qT",
1446 component
, datum
, objtype
);
1447 return error_mark_node
;
1450 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1451 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1453 if (!COMPLETE_TYPE_P (ctype
))
1455 if (!same_type_p (ctype
, objtype
))
1461 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1466 error ("pointer to member type %qT incompatible with object "
1469 return error_mark_node
;
1471 else if (binfo
== error_mark_node
)
1472 return error_mark_node
;
1475 if (TYPE_PTRMEM_P (ptrmem_type
))
1479 /* Compute the type of the field, as described in [expr.ref].
1480 There's no such thing as a mutable pointer-to-member, so
1481 things are not as complex as they are for references to
1482 non-static data members. */
1483 type
= cp_build_qualified_type (type
,
1484 (cp_type_quals (type
)
1485 | cp_type_quals (TREE_TYPE (datum
))));
1487 datum
= build_address (datum
);
1489 /* Convert object to the correct base. */
1491 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1493 /* Build an expression for "object + offset" where offset is the
1494 value stored in the pointer-to-data-member. */
1495 ptype
= build_pointer_type (type
);
1496 datum
= build2 (POINTER_PLUS_EXPR
, ptype
,
1497 fold_convert (ptype
, datum
),
1498 build_nop (sizetype
, component
));
1499 return cp_build_indirect_ref (datum
, RO_NULL
, tf_warning_or_error
);
1502 return build2 (OFFSET_REF
, type
, datum
, component
);
1505 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1508 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1510 /* This is either a call to a constructor,
1511 or a C cast in C++'s `functional' notation. */
1513 /* The type to which we are casting. */
1515 VEC(tree
,gc
) *parmvec
;
1517 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1518 return error_mark_node
;
1520 if (TREE_CODE (exp
) == TYPE_DECL
)
1521 type
= TREE_TYPE (exp
);
1525 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1527 error ("invalid value-initialization of reference type");
1528 return error_mark_node
;
1531 if (processing_template_decl
)
1533 tree t
= build_min (CAST_EXPR
, type
, parms
);
1534 /* We don't know if it will or will not have side effects. */
1535 TREE_SIDE_EFFECTS (t
) = 1;
1539 if (! MAYBE_CLASS_TYPE_P (type
))
1541 if (parms
== NULL_TREE
)
1542 return cp_convert (type
, integer_zero_node
);
1544 /* This must build a C cast. */
1545 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
1546 return cp_build_c_cast (type
, parms
, complain
);
1549 /* Prepare to evaluate as a call to a constructor. If this expression
1550 is actually used, for example,
1552 return X (arg1, arg2, ...);
1554 then the slot being initialized will be filled in. */
1556 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
1557 return error_mark_node
;
1558 if (abstract_virtuals_error (NULL_TREE
, type
))
1559 return error_mark_node
;
1563 If the expression list is a single-expression, the type
1564 conversion is equivalent (in definedness, and if defined in
1565 meaning) to the corresponding cast expression. */
1566 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1567 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1571 The expression T(), where T is a simple-type-specifier for a
1572 non-array complete object type or the (possibly cv-qualified)
1573 void type, creates an rvalue of the specified type, which is
1574 value-initialized. */
1576 if (parms
== NULL_TREE
1577 /* If there's a user-defined constructor, value-initialization is
1578 just calling the constructor, so fall through. */
1579 && !TYPE_HAS_USER_CONSTRUCTOR (type
))
1581 exp
= build_value_init (type
, complain
);
1582 exp
= get_target_expr (exp
);
1583 /* FIXME this is wrong */
1584 if (literal_type_p (type
))
1585 TREE_CONSTANT (exp
) = true;
1589 /* Call the constructor. */
1590 parmvec
= make_tree_vector ();
1591 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
1592 VEC_safe_push (tree
, gc
, parmvec
, TREE_VALUE (parms
));
1593 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
1594 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
1595 release_tree_vector (parmvec
);
1597 if (exp
== error_mark_node
)
1598 return error_mark_node
;
1600 return build_cplus_new (type
, exp
);
1604 /* Add new exception specifier SPEC, to the LIST we currently have.
1605 If it's already in LIST then do nothing.
1606 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1607 know what we're doing. */
1610 add_exception_specifier (tree list
, tree spec
, int complain
)
1615 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
1617 if (spec
== error_mark_node
)
1620 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1622 /* [except.spec] 1, type in an exception specifier shall not be
1623 incomplete, or pointer or ref to incomplete other than pointer
1625 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1626 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1627 core
= TREE_TYPE (core
);
1630 else if (VOID_TYPE_P (core
))
1632 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1634 else if (processing_template_decl
)
1639 /* 15.4/1 says that types in an exception specifier must be complete,
1640 but it seems more reasonable to only require this on definitions
1641 and calls. So just give a pedwarn at this point; we will give an
1642 error later if we hit one of those two cases. */
1643 if (!COMPLETE_TYPE_P (complete_type (core
)))
1644 diag_type
= DK_PEDWARN
; /* pedwarn */
1651 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1652 if (same_type_p (TREE_VALUE (probe
), spec
))
1655 list
= tree_cons (NULL_TREE
, spec
, list
);
1658 diag_type
= DK_ERROR
; /* error */
1660 if (diag_type
!= DK_UNSPECIFIED
&& complain
)
1661 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1666 /* Combine the two exceptions specifier lists LIST and ADD, and return
1670 merge_exception_specifiers (tree list
, tree add
)
1674 /* For merging noexcept(true) and throw(), take the more recent one (LIST).
1675 A throw(type-list) spec takes precedence over a noexcept(false) spec.
1676 Any other noexcept-spec should only be merged with an equivalent one.
1677 So the !TREE_VALUE code below is correct for all cases. */
1678 else if (!TREE_VALUE (add
))
1680 else if (!TREE_VALUE (list
))
1684 tree orig_list
= list
;
1686 for (; add
; add
= TREE_CHAIN (add
))
1688 tree spec
= TREE_VALUE (add
);
1691 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1692 if (same_type_p (TREE_VALUE (probe
), spec
))
1696 spec
= build_tree_list (NULL_TREE
, spec
);
1697 TREE_CHAIN (spec
) = list
;
1705 /* Subroutine of build_call. Ensure that each of the types in the
1706 exception specification is complete. Technically, 15.4/1 says that
1707 they need to be complete when we see a declaration of the function,
1708 but we should be able to get away with only requiring this when the
1709 function is defined or called. See also add_exception_specifier. */
1712 require_complete_eh_spec_types (tree fntype
, tree decl
)
1715 /* Don't complain about calls to op new. */
1716 if (decl
&& DECL_ARTIFICIAL (decl
))
1718 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1719 raises
= TREE_CHAIN (raises
))
1721 tree type
= TREE_VALUE (raises
);
1722 if (type
&& !COMPLETE_TYPE_P (type
))
1726 ("call to function %qD which throws incomplete type %q#T",
1729 error ("call to function which throws incomplete type %q#T",
1736 #include "gt-cp-typeck2.h"