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 (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
416 inform (input_location
, "\t%+#D", fn
);
417 /* Now truncate the vector. This leaves it non-null, so we know
418 there are pure virtuals, but empty so we don't list them out
420 VEC_truncate (tree
, pure
, 0);
423 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
424 " since type %qT has pure virtual functions",
430 /* Print an error message for invalid use of an incomplete type.
431 VALUE is the expression that was used (or 0 if that isn't known)
432 and TYPE is the type that was invalid. DIAG_KIND indicates the
433 type of diagnostic (see diagnostic.def). */
436 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
,
437 diagnostic_t diag_kind
)
441 gcc_assert (diag_kind
== DK_WARNING
442 || diag_kind
== DK_PEDWARN
443 || diag_kind
== DK_ERROR
);
445 /* Avoid duplicate error message. */
446 if (TREE_CODE (type
) == ERROR_MARK
)
449 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
450 || TREE_CODE (value
) == PARM_DECL
451 || TREE_CODE (value
) == FIELD_DECL
))
453 emit_diagnostic (diag_kind
, input_location
, 0,
454 "%q+D has incomplete type", value
);
458 /* We must print an error message. Be clever about what it says. */
460 switch (TREE_CODE (type
))
466 emit_diagnostic (diag_kind
, input_location
, 0,
467 "invalid use of incomplete type %q#T", type
);
468 if (!TYPE_TEMPLATE_INFO (type
))
469 emit_diagnostic (diag_kind
, input_location
, 0,
470 "forward declaration of %q+#T", type
);
472 emit_diagnostic (diag_kind
, input_location
, 0,
473 "declaration of %q+#T", type
);
477 emit_diagnostic (diag_kind
, input_location
, 0,
478 "invalid use of %qT", type
);
482 if (TYPE_DOMAIN (type
))
484 type
= TREE_TYPE (type
);
487 emit_diagnostic (diag_kind
, input_location
, 0,
488 "invalid use of array with unspecified bounds");
493 emit_diagnostic (diag_kind
, input_location
, 0,
494 "invalid use of member (did you forget the %<&%> ?)");
497 case TEMPLATE_TYPE_PARM
:
499 emit_diagnostic (diag_kind
, input_location
, 0,
500 "invalid use of %<auto%>");
502 emit_diagnostic (diag_kind
, input_location
, 0,
503 "invalid use of template type parameter %qT", type
);
506 case BOUND_TEMPLATE_TEMPLATE_PARM
:
507 emit_diagnostic (diag_kind
, input_location
, 0,
508 "invalid use of template template parameter %qT",
513 emit_diagnostic (diag_kind
, input_location
, 0,
514 "invalid use of dependent type %qT", type
);
518 gcc_assert (type
== unknown_type_node
);
519 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
521 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
522 emit_diagnostic (diag_kind
, input_location
, 0,
523 "address of overloaded function with no contextual "
525 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
526 emit_diagnostic (diag_kind
, input_location
, 0,
527 "overloaded function with no contextual type information");
529 emit_diagnostic (diag_kind
, input_location
, 0,
530 "insufficient contextual information to determine type");
538 /* Backward-compatibility interface to incomplete_type_diagnostic;
539 required by ../tree.c. */
540 #undef cxx_incomplete_type_error
542 cxx_incomplete_type_error (const_tree value
, const_tree type
)
544 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
548 /* The recursive part of split_nonconstant_init. DEST is an lvalue
549 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
552 split_nonconstant_init_1 (tree dest
, tree
*initp
)
554 unsigned HOST_WIDE_INT idx
;
556 tree field_index
, value
;
557 tree type
= TREE_TYPE (dest
);
558 tree inner_type
= NULL
;
559 bool array_type_p
= false;
560 HOST_WIDE_INT num_type_elements
, num_initialized_elements
;
562 switch (TREE_CODE (type
))
565 inner_type
= TREE_TYPE (type
);
571 case QUAL_UNION_TYPE
:
572 num_initialized_elements
= 0;
573 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
576 /* The current implementation of this algorithm assumes that
577 the field was set for all the elements. This is usually done
578 by process_init_constructor. */
579 gcc_assert (field_index
);
582 inner_type
= TREE_TYPE (field_index
);
584 if (TREE_CODE (value
) == CONSTRUCTOR
)
589 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
590 NULL_TREE
, NULL_TREE
);
592 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
595 split_nonconstant_init_1 (sub
, &value
);
597 else if (!initializer_constant_valid_p (value
, inner_type
))
601 HOST_WIDE_INT inner_elements
;
603 /* FIXME: Ordered removal is O(1) so the whole function is
604 worst-case quadratic. This could be fixed using an aside
605 bitmap to record which elements must be removed and remove
606 them all at the same time. Or by merging
607 split_non_constant_init into process_init_constructor_array,
608 that is separating constants from non-constants while building
610 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
615 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
616 NULL_TREE
, NULL_TREE
);
618 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
621 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
622 code
= build_stmt (input_location
, EXPR_STMT
, code
);
625 inner_elements
= count_type_elements (inner_type
, true);
626 if (inner_elements
< 0)
627 num_initialized_elements
= -1;
628 else if (num_initialized_elements
>= 0)
629 num_initialized_elements
+= inner_elements
;
634 num_type_elements
= count_type_elements (type
, true);
635 /* If all elements of the initializer are non-constant and
636 have been split out, we don't need the empty CONSTRUCTOR. */
637 if (num_type_elements
> 0
638 && num_type_elements
== num_initialized_elements
)
643 if (!initializer_constant_valid_p (init
, type
))
646 tree cons
= copy_node (init
);
647 CONSTRUCTOR_ELTS (init
) = NULL
;
648 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
649 code
= build_stmt (input_location
, EXPR_STMT
, code
);
658 /* The rest of the initializer is now a constant. */
659 TREE_CONSTANT (init
) = 1;
662 /* A subroutine of store_init_value. Splits non-constant static
663 initializer INIT into a constant part and generates code to
664 perform the non-constant part of the initialization to DEST.
665 Returns the code for the runtime init. */
668 split_nonconstant_init (tree dest
, tree init
)
672 if (TREE_CODE (init
) == CONSTRUCTOR
)
674 code
= push_stmt_list ();
675 split_nonconstant_init_1 (dest
, &init
);
676 code
= pop_stmt_list (code
);
677 DECL_INITIAL (dest
) = init
;
678 TREE_READONLY (dest
) = 0;
681 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
686 /* Perform appropriate conversions on the initial value of a variable,
687 store it in the declaration DECL,
688 and print any error messages that are appropriate.
689 If the init is invalid, store an ERROR_MARK.
691 C++: Note that INIT might be a TREE_LIST, which would mean that it is
692 a base class initializer for some aggregate type, hopefully compatible
693 with DECL. If INIT is a single element, and DECL is an aggregate
694 type, we silently convert INIT into a TREE_LIST, allowing a constructor
697 If INIT is a TREE_LIST and there is no constructor, turn INIT
698 into a CONSTRUCTOR and use standard initialization techniques.
699 Perhaps a warning should be generated?
701 Returns code to be executed if initialization could not be performed
702 for static variable. In that case, caller must emit the code. */
705 store_init_value (tree decl
, tree init
, int flags
)
709 /* If variable's type was invalidly declared, just ignore it. */
711 type
= TREE_TYPE (decl
);
712 if (TREE_CODE (type
) == ERROR_MARK
)
715 if (MAYBE_CLASS_TYPE_P (type
))
717 gcc_assert (!type_has_nontrivial_copy_init (type
)
718 || TREE_CODE (init
) == CONSTRUCTOR
);
720 if (TREE_CODE (init
) == TREE_LIST
)
722 error ("constructor syntax used, but no constructor declared "
723 "for type %qT", type
);
724 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
727 else if (TREE_CODE (init
) == TREE_LIST
728 && TREE_TYPE (init
) != unknown_type_node
)
730 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
732 if (TREE_CODE (init
) == TREE_LIST
733 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
735 error ("cannot initialize arrays using this syntax");
739 /* We get here with code like `int a (2);' */
740 init
= build_x_compound_expr_from_list (init
, ELK_INIT
);
743 /* End of special C++ code. */
745 /* Digest the specified initializer into an expression. */
746 value
= digest_init_flags (type
, init
, flags
);
747 /* If the initializer is not a constant, fill in DECL_INITIAL with
748 the bits that are constant, and then return an expression that
749 will perform the dynamic initialization. */
750 if (value
!= error_mark_node
751 && (TREE_SIDE_EFFECTS (value
)
752 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
753 return split_nonconstant_init (decl
, value
);
754 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
755 is an automatic variable, the middle end will turn this into a
756 dynamic initialization later. */
757 DECL_INITIAL (decl
) = value
;
762 /* Give errors about narrowing conversions within { }. */
765 check_narrowing (tree type
, tree init
)
767 tree ftype
= unlowered_expr_type (init
);
772 init
= decl_constant_value (init
);
774 if (TREE_CODE (type
) == INTEGER_TYPE
775 && TREE_CODE (ftype
) == REAL_TYPE
)
777 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
778 && CP_INTEGRAL_TYPE_P (type
))
780 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
)
781 && (TREE_CODE (init
) != INTEGER_CST
782 || !int_fits_type_p (init
, type
)))
785 else if (TREE_CODE (ftype
) == REAL_TYPE
786 && TREE_CODE (type
) == REAL_TYPE
)
788 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
790 if (TREE_CODE (init
) == REAL_CST
)
792 /* Issue 703: Loss of precision is OK as long as the value is
793 within the representable range of the new type. */
795 d
= TREE_REAL_CST (init
);
796 real_convert (&r
, TYPE_MODE (type
), &d
);
804 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
805 && TREE_CODE (type
) == REAL_TYPE
)
808 if (TREE_CODE (init
) == INTEGER_CST
)
810 d
= real_value_from_int_cst (0, init
);
811 if (exact_real_truncate (TYPE_MODE (type
), &d
))
817 permerror (input_location
, "narrowing conversion of %qE from %qT to %qT inside { }",
821 /* Process the initializer INIT for a variable of type TYPE, emitting
822 diagnostics for invalid initializers and converting the initializer as
825 For aggregate types, it assumes that reshape_init has already run, thus the
826 initializer will have the right shape (brace elision has been undone).
828 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
831 digest_init_r (tree type
, tree init
, bool nested
, int flags
)
833 enum tree_code code
= TREE_CODE (type
);
835 if (error_operand_p (init
))
836 return error_mark_node
;
840 /* We must strip the outermost array type when completing the type,
841 because the its bounds might be incomplete at the moment. */
842 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
843 ? TREE_TYPE (type
) : type
, NULL_TREE
))
844 return error_mark_node
;
846 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
847 (g++.old-deja/g++.law/casts2.C). */
848 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
849 init
= TREE_OPERAND (init
, 0);
851 /* Initialization of an array of chars from a string constant. The initializer
852 can be optionally enclosed in braces, but reshape_init has already removed
853 them if they were present. */
854 if (code
== ARRAY_TYPE
)
856 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
857 if (char_type_p (typ1
)
859 && TREE_CODE (init
) == STRING_CST
)
861 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
863 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
865 if (char_type
!= char_type_node
)
867 error ("char-array initialized from wide string");
868 return error_mark_node
;
873 if (char_type
== char_type_node
)
875 error ("int-array initialized from non-wide string");
876 return error_mark_node
;
878 else if (char_type
!= typ1
)
880 error ("int-array initialized from incompatible wide string");
881 return error_mark_node
;
885 TREE_TYPE (init
) = type
;
886 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
888 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
889 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
890 /* In C it is ok to subtract 1 from the length of the string
891 because it's ok to ignore the terminating null char that is
892 counted in the length of the constant, but in C++ this would
894 if (size
< TREE_STRING_LENGTH (init
))
895 permerror (input_location
, "initializer-string for array of chars is too long");
901 /* Handle scalar types (including conversions) and references. */
902 if ((TREE_CODE (type
) != COMPLEX_TYPE
903 || BRACE_ENCLOSED_INITIALIZER_P (init
))
904 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
908 if (cxx_dialect
!= cxx98
&& nested
)
909 check_narrowing (type
, init
);
910 init
= convert_for_initialization (0, type
, init
, flags
,
911 ICR_INIT
, NULL_TREE
, 0,
912 tf_warning_or_error
);
915 /* Skip any conversions since we'll be outputting the underlying
917 while (CONVERT_EXPR_P (*exp
)
918 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
919 exp
= &TREE_OPERAND (*exp
, 0);
921 *exp
= cplus_expand_constant (*exp
);
926 /* Come here only for aggregates: records, arrays, unions, complex numbers
928 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
929 || TREE_CODE (type
) == VECTOR_TYPE
930 || TREE_CODE (type
) == RECORD_TYPE
931 || TREE_CODE (type
) == UNION_TYPE
932 || TREE_CODE (type
) == COMPLEX_TYPE
);
934 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
935 && !TYPE_NON_AGGREGATE_CLASS (type
))
936 return process_init_constructor (type
, init
);
939 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
941 error ("cannot initialize aggregate of type %qT with "
942 "a compound literal", type
);
944 return error_mark_node
;
947 if (TREE_CODE (type
) == ARRAY_TYPE
948 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
950 /* Allow the result of build_array_copy and of
951 build_value_init_noctor. */
952 if ((TREE_CODE (init
) == TARGET_EXPR
953 || TREE_CODE (init
) == CONSTRUCTOR
)
954 && (same_type_ignoring_top_level_qualifiers_p
955 (type
, TREE_TYPE (init
))))
958 error ("array must be initialized with a brace-enclosed"
960 return error_mark_node
;
963 return convert_for_initialization (NULL_TREE
, type
, init
,
965 ICR_INIT
, NULL_TREE
, 0,
966 tf_warning_or_error
);
971 digest_init (tree type
, tree init
)
973 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
);
977 digest_init_flags (tree type
, tree init
, int flags
)
979 return digest_init_r (type
, init
, false, flags
);
982 /* Set of flags used within process_init_constructor to describe the
984 #define PICFLAG_ERRONEOUS 1
985 #define PICFLAG_NOT_ALL_CONSTANT 2
986 #define PICFLAG_NOT_ALL_SIMPLE 4
988 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
992 picflag_from_initializer (tree init
)
994 if (init
== error_mark_node
)
995 return PICFLAG_ERRONEOUS
;
996 else if (!TREE_CONSTANT (init
))
997 return PICFLAG_NOT_ALL_CONSTANT
;
998 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
999 return PICFLAG_NOT_ALL_SIMPLE
;
1003 /* Subroutine of process_init_constructor, which will process an initializer
1004 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1005 which describe the initializers. */
1008 process_init_constructor_array (tree type
, tree init
)
1010 unsigned HOST_WIDE_INT i
, len
= 0;
1012 bool unbounded
= false;
1013 constructor_elt
*ce
;
1014 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
1016 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1017 || TREE_CODE (type
) == VECTOR_TYPE
);
1019 if (TREE_CODE (type
) == ARRAY_TYPE
)
1021 tree domain
= TYPE_DOMAIN (type
);
1023 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
1024 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
1027 unbounded
= true; /* Take as many as there are. */
1030 /* Vectors are like simple fixed-size arrays. */
1031 len
= TYPE_VECTOR_SUBPARTS (type
);
1033 /* There must not be more initializers than needed. */
1034 if (!unbounded
&& VEC_length (constructor_elt
, v
) > len
)
1035 error ("too many initializers for %qT", type
);
1037 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
1041 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1042 if (compare_tree_int (ce
->index
, i
) != 0)
1044 ce
->value
= error_mark_node
;
1045 sorry ("non-trivial designated initializers not supported");
1049 ce
->index
= size_int (i
);
1050 gcc_assert (ce
->value
);
1051 ce
->value
= digest_init_r (TREE_TYPE (type
), ce
->value
, true, LOOKUP_IMPLICIT
);
1053 if (ce
->value
!= error_mark_node
)
1054 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1055 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1057 flags
|= picflag_from_initializer (ce
->value
);
1060 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1061 we must add initializers ourselves. */
1063 for (; i
< len
; ++i
)
1067 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
1069 /* If this type needs constructors run for default-initialization,
1070 we can't rely on the back end to do it for us, so build up
1071 TARGET_EXPRs. If the type in question is a class, just build
1072 one up; if it's an array, recurse. */
1073 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
1074 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
,
1075 tf_warning_or_error
);
1077 next
= build_constructor (init_list_type_node
, NULL
);
1078 next
= digest_init (TREE_TYPE (type
), next
);
1080 else if (!zero_init_p (TREE_TYPE (type
)))
1081 next
= build_zero_init (TREE_TYPE (type
),
1082 /*nelts=*/NULL_TREE
,
1083 /*static_storage_p=*/false);
1085 /* The default zero-initialization is fine for us; don't
1086 add anything to the CONSTRUCTOR. */
1089 flags
|= picflag_from_initializer (next
);
1090 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1093 CONSTRUCTOR_ELTS (init
) = v
;
1097 /* Subroutine of process_init_constructor, which will process an initializer
1098 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1099 the initializers. */
1102 process_init_constructor_record (tree type
, tree init
)
1104 VEC(constructor_elt
,gc
) *v
= NULL
;
1107 unsigned HOST_WIDE_INT idx
= 0;
1109 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1110 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1111 gcc_assert (!TYPE_BINFO (type
)
1112 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1113 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1115 /* Generally, we will always have an index for each initializer (which is
1116 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1117 reshape_init. So we need to handle both cases. */
1118 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1123 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1125 flags
|= picflag_from_initializer (integer_zero_node
);
1126 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
1130 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1133 /* If this is a bitfield, first convert to the declared type. */
1134 type
= TREE_TYPE (field
);
1135 if (DECL_BIT_FIELD_TYPE (field
))
1136 type
= DECL_BIT_FIELD_TYPE (field
);
1138 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1140 constructor_elt
*ce
= VEC_index (constructor_elt
,
1141 CONSTRUCTOR_ELTS (init
), idx
);
1144 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1145 latter case can happen in templates where lookup has to be
1147 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1148 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
1149 if (ce
->index
!= field
1150 && ce
->index
!= DECL_NAME (field
))
1152 ce
->value
= error_mark_node
;
1153 sorry ("non-trivial designated initializers not supported");
1157 gcc_assert (ce
->value
);
1158 next
= digest_init_r (type
, ce
->value
, true, LOOKUP_IMPLICIT
);
1161 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1163 /* If this type needs constructors run for
1164 default-initialization, we can't rely on the back end to do it
1165 for us, so build up TARGET_EXPRs. If the type in question is
1166 a class, just build one up; if it's an array, recurse. */
1167 next
= build_constructor (init_list_type_node
, NULL
);
1168 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field
)))
1170 next
= finish_compound_literal (TREE_TYPE (field
), next
);
1171 /* direct-initialize the target. No temporary is going
1173 if (TREE_CODE (next
) == TARGET_EXPR
)
1174 TARGET_EXPR_DIRECT_INIT_P (next
) = true;
1177 next
= digest_init_r (TREE_TYPE (field
), next
, true, LOOKUP_IMPLICIT
);
1179 /* Warn when some struct elements are implicitly initialized. */
1180 warning (OPT_Wmissing_field_initializers
,
1181 "missing initializer for member %qD", field
);
1185 if (TREE_READONLY (field
))
1186 error ("uninitialized const member %qD", field
);
1187 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1188 error ("member %qD with uninitialized const fields", field
);
1189 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1190 error ("member %qD is uninitialized reference", field
);
1192 /* Warn when some struct elements are implicitly initialized
1194 warning (OPT_Wmissing_field_initializers
,
1195 "missing initializer for member %qD", field
);
1197 if (!zero_init_p (TREE_TYPE (field
)))
1198 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1199 /*static_storage_p=*/false);
1201 /* The default zero-initialization is fine for us; don't
1202 add anything to the CONSTRUCTOR. */
1206 /* If this is a bitfield, now convert to the lowered type. */
1207 if (type
!= TREE_TYPE (field
))
1208 next
= cp_convert_and_check (TREE_TYPE (field
), next
);
1209 flags
|= picflag_from_initializer (next
);
1210 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1213 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1214 error ("too many initializers for %qT", type
);
1216 CONSTRUCTOR_ELTS (init
) = v
;
1220 /* Subroutine of process_init_constructor, which will process a single
1221 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1222 which describe the initializer. */
1225 process_init_constructor_union (tree type
, tree init
)
1227 constructor_elt
*ce
;
1230 /* If the initializer was empty, use default zero initialization. */
1231 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
1234 len
= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
));
1237 error ("too many initializers for %qT", type
);
1238 VEC_block_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
), 1, len
-1);
1241 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
1243 /* If this element specifies a field, initialize via that field. */
1246 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1248 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
1250 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1251 tree name
= ce
->index
;
1253 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1254 if (DECL_NAME (field
) == name
)
1258 error ("no field %qD found in union being initialized", field
);
1259 ce
->value
= error_mark_node
;
1265 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1266 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1267 error ("index value instead of field name in union initializer");
1268 ce
->value
= error_mark_node
;
1273 /* Find the first named field. ANSI decided in September 1990
1274 that only named fields count here. */
1275 tree field
= TYPE_FIELDS (type
);
1276 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1277 field
= TREE_CHAIN (field
);
1278 if (field
== NULL_TREE
)
1280 error ("too many initializers for %qT", type
);
1281 ce
->value
= error_mark_node
;
1286 if (ce
->value
&& ce
->value
!= error_mark_node
)
1287 ce
->value
= digest_init_r (TREE_TYPE (ce
->index
), ce
->value
, true, LOOKUP_IMPLICIT
);
1289 return picflag_from_initializer (ce
->value
);
1292 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1293 constructor is a brace-enclosed initializer, and will be modified in-place.
1295 Each element is converted to the right type through digest_init, and
1296 missing initializers are added following the language rules (zero-padding,
1299 After the execution, the initializer will have TREE_CONSTANT if all elts are
1300 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1301 constants that the assembler and linker can compute them.
1303 The function returns the initializer itself, or error_mark_node in case
1307 process_init_constructor (tree type
, tree init
)
1311 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1313 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1314 flags
= process_init_constructor_array (type
, init
);
1315 else if (TREE_CODE (type
) == RECORD_TYPE
)
1316 flags
= process_init_constructor_record (type
, init
);
1317 else if (TREE_CODE (type
) == UNION_TYPE
)
1318 flags
= process_init_constructor_union (type
, init
);
1322 if (flags
& PICFLAG_ERRONEOUS
)
1323 return error_mark_node
;
1325 TREE_TYPE (init
) = type
;
1326 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1327 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1328 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1330 TREE_CONSTANT (init
) = 1;
1331 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1332 TREE_STATIC (init
) = 1;
1337 /* Given a structure or union value DATUM, construct and return
1338 the structure or union component which results from narrowing
1339 that value to the base specified in BASETYPE. For example, given the
1342 class L { int ii; };
1343 class A : L { ... };
1344 class B : L { ... };
1345 class C : A, B { ... };
1353 x.A::ii refers to the ii member of the L part of
1354 the A part of the C object named by X. In this case,
1355 DATUM would be x, and BASETYPE would be A.
1357 I used to think that this was nonconformant, that the standard specified
1358 that first we look up ii in A, then convert x to an L& and pull out the
1359 ii part. But in fact, it does say that we convert x to an A&; A here
1360 is known as the "naming class". (jason 2000-12-19)
1362 BINFO_P points to a variable initialized either to NULL_TREE or to the
1363 binfo for the specific base subobject we want to convert to. */
1366 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1370 if (datum
== error_mark_node
)
1371 return error_mark_node
;
1375 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1377 if (!binfo
|| binfo
== error_mark_node
)
1379 *binfo_p
= NULL_TREE
;
1381 error_not_base_type (basetype
, TREE_TYPE (datum
));
1382 return error_mark_node
;
1386 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1389 /* Build a reference to an object specified by the C++ `->' operator.
1390 Usually this just involves dereferencing the object, but if the
1391 `->' operator is overloaded, then such overloads must be
1392 performed until an object which does not have the `->' operator
1393 overloaded is found. An error is reported when circular pointer
1394 delegation is detected. */
1397 build_x_arrow (tree expr
)
1399 tree orig_expr
= expr
;
1400 tree type
= TREE_TYPE (expr
);
1401 tree last_rval
= NULL_TREE
;
1402 VEC(tree
,gc
) *types_memoized
= NULL
;
1404 if (type
== error_mark_node
)
1405 return error_mark_node
;
1407 if (processing_template_decl
)
1409 if (type_dependent_expression_p (expr
))
1410 return build_min_nt (ARROW_EXPR
, expr
);
1411 expr
= build_non_dependent_expr (expr
);
1414 if (MAYBE_CLASS_TYPE_P (type
))
1416 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1417 NULL_TREE
, NULL_TREE
,
1418 /*overloaded_p=*/NULL
,
1419 tf_warning_or_error
)))
1421 if (expr
== error_mark_node
)
1422 return error_mark_node
;
1424 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1426 error ("circular pointer delegation detected");
1427 return error_mark_node
;
1430 VEC_safe_push (tree
, gc
, types_memoized
, TREE_TYPE (expr
));
1434 if (last_rval
== NULL_TREE
)
1436 error ("base operand of %<->%> has non-pointer type %qT", type
);
1437 return error_mark_node
;
1440 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1441 last_rval
= convert_from_reference (last_rval
);
1444 last_rval
= decay_conversion (expr
);
1446 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1448 if (processing_template_decl
)
1450 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1451 /* It will be dereferenced. */
1452 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1456 return cp_build_indirect_ref (last_rval
, RO_NULL
, tf_warning_or_error
);
1460 error ("result of %<operator->()%> yields non-pointer result");
1462 error ("base operand of %<->%> is not a pointer");
1463 return error_mark_node
;
1466 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1467 already been checked out to be of aggregate type. */
1470 build_m_component_ref (tree datum
, tree component
)
1478 if (error_operand_p (datum
) || error_operand_p (component
))
1479 return error_mark_node
;
1481 mark_lvalue_use (datum
);
1482 mark_rvalue_use (component
);
1484 ptrmem_type
= TREE_TYPE (component
);
1485 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1487 error ("%qE cannot be used as a member pointer, since it is of "
1489 component
, ptrmem_type
);
1490 return error_mark_node
;
1493 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1494 if (! MAYBE_CLASS_TYPE_P (objtype
))
1496 error ("cannot apply member pointer %qE to %qE, which is of "
1497 "non-class type %qT",
1498 component
, datum
, objtype
);
1499 return error_mark_node
;
1502 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1503 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1505 if (!COMPLETE_TYPE_P (ctype
))
1507 if (!same_type_p (ctype
, objtype
))
1513 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1518 error ("pointer to member type %qT incompatible with object "
1521 return error_mark_node
;
1523 else if (binfo
== error_mark_node
)
1524 return error_mark_node
;
1527 if (TYPE_PTRMEM_P (ptrmem_type
))
1531 /* Compute the type of the field, as described in [expr.ref].
1532 There's no such thing as a mutable pointer-to-member, so
1533 things are not as complex as they are for references to
1534 non-static data members. */
1535 type
= cp_build_qualified_type (type
,
1536 (cp_type_quals (type
)
1537 | cp_type_quals (TREE_TYPE (datum
))));
1539 datum
= build_address (datum
);
1541 /* Convert object to the correct base. */
1543 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1545 /* Build an expression for "object + offset" where offset is the
1546 value stored in the pointer-to-data-member. */
1547 ptype
= build_pointer_type (type
);
1548 datum
= build2 (POINTER_PLUS_EXPR
, ptype
,
1549 fold_convert (ptype
, datum
),
1550 build_nop (sizetype
, component
));
1551 return cp_build_indirect_ref (datum
, RO_NULL
, tf_warning_or_error
);
1554 return build2 (OFFSET_REF
, type
, datum
, component
);
1557 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1560 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1562 /* This is either a call to a constructor,
1563 or a C cast in C++'s `functional' notation. */
1565 /* The type to which we are casting. */
1567 VEC(tree
,gc
) *parmvec
;
1569 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1570 return error_mark_node
;
1572 if (TREE_CODE (exp
) == TYPE_DECL
)
1573 type
= TREE_TYPE (exp
);
1577 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1579 error ("invalid value-initialization of reference type");
1580 return error_mark_node
;
1583 if (processing_template_decl
)
1585 tree t
= build_min (CAST_EXPR
, type
, parms
);
1586 /* We don't know if it will or will not have side effects. */
1587 TREE_SIDE_EFFECTS (t
) = 1;
1591 if (! MAYBE_CLASS_TYPE_P (type
))
1593 if (parms
== NULL_TREE
)
1594 return cp_convert (type
, integer_zero_node
);
1596 /* This must build a C cast. */
1597 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
);
1598 return cp_build_c_cast (type
, parms
, complain
);
1601 /* Prepare to evaluate as a call to a constructor. If this expression
1602 is actually used, for example,
1604 return X (arg1, arg2, ...);
1606 then the slot being initialized will be filled in. */
1608 if (!complete_type_or_else (type
, NULL_TREE
))
1609 return error_mark_node
;
1610 if (abstract_virtuals_error (NULL_TREE
, type
))
1611 return error_mark_node
;
1615 If the expression list is a single-expression, the type
1616 conversion is equivalent (in definedness, and if defined in
1617 meaning) to the corresponding cast expression. */
1618 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1619 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1623 The expression T(), where T is a simple-type-specifier for a
1624 non-array complete object type or the (possibly cv-qualified)
1625 void type, creates an rvalue of the specified type, which is
1626 value-initialized. */
1628 if (parms
== NULL_TREE
1629 /* If there's a user-defined constructor, value-initialization is
1630 just calling the constructor, so fall through. */
1631 && !TYPE_HAS_USER_CONSTRUCTOR (type
))
1633 exp
= build_value_init (type
);
1634 return get_target_expr (exp
);
1637 /* Call the constructor. */
1638 parmvec
= make_tree_vector ();
1639 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
1640 VEC_safe_push (tree
, gc
, parmvec
, TREE_VALUE (parms
));
1641 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
1642 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
1643 release_tree_vector (parmvec
);
1645 if (exp
== error_mark_node
)
1646 return error_mark_node
;
1648 return build_cplus_new (type
, exp
);
1652 /* Add new exception specifier SPEC, to the LIST we currently have.
1653 If it's already in LIST then do nothing.
1654 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1655 know what we're doing. */
1658 add_exception_specifier (tree list
, tree spec
, int complain
)
1663 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
1665 if (spec
== error_mark_node
)
1668 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1670 /* [except.spec] 1, type in an exception specifier shall not be
1671 incomplete, or pointer or ref to incomplete other than pointer
1673 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1674 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1675 core
= TREE_TYPE (core
);
1678 else if (VOID_TYPE_P (core
))
1680 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1682 else if (processing_template_decl
)
1687 /* 15.4/1 says that types in an exception specifier must be complete,
1688 but it seems more reasonable to only require this on definitions
1689 and calls. So just give a pedwarn at this point; we will give an
1690 error later if we hit one of those two cases. */
1691 if (!COMPLETE_TYPE_P (complete_type (core
)))
1692 diag_type
= DK_PEDWARN
; /* pedwarn */
1699 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1700 if (same_type_p (TREE_VALUE (probe
), spec
))
1703 list
= tree_cons (NULL_TREE
, spec
, list
);
1706 diag_type
= DK_ERROR
; /* error */
1708 if (diag_type
!= DK_UNSPECIFIED
&& complain
)
1709 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1714 /* Combine the two exceptions specifier lists LIST and ADD, and return
1718 merge_exception_specifiers (tree list
, tree add
)
1722 /* For merging noexcept(true) and throw(), take the more recent one (LIST).
1723 A throw(type-list) spec takes precedence over a noexcept(false) spec.
1724 Any other noexcept-spec should only be merged with an equivalent one.
1725 So the !TREE_VALUE code below is correct for all cases. */
1726 else if (!TREE_VALUE (add
))
1728 else if (!TREE_VALUE (list
))
1732 tree orig_list
= list
;
1734 for (; add
; add
= TREE_CHAIN (add
))
1736 tree spec
= TREE_VALUE (add
);
1739 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1740 if (same_type_p (TREE_VALUE (probe
), spec
))
1744 spec
= build_tree_list (NULL_TREE
, spec
);
1745 TREE_CHAIN (spec
) = list
;
1753 /* Subroutine of build_call. Ensure that each of the types in the
1754 exception specification is complete. Technically, 15.4/1 says that
1755 they need to be complete when we see a declaration of the function,
1756 but we should be able to get away with only requiring this when the
1757 function is defined or called. See also add_exception_specifier. */
1760 require_complete_eh_spec_types (tree fntype
, tree decl
)
1763 /* Don't complain about calls to op new. */
1764 if (decl
&& DECL_ARTIFICIAL (decl
))
1766 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1767 raises
= TREE_CHAIN (raises
))
1769 tree type
= TREE_VALUE (raises
);
1770 if (type
&& !COMPLETE_TYPE_P (type
))
1774 ("call to function %qD which throws incomplete type %q#T",
1777 error ("call to function which throws incomplete type %q#T",
1784 #include "gt-cp-typeck2.h"