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
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 2, 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 COPYING. If not, write to
22 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
26 /* This file is part of the C++ front end.
27 It contains routines to build C++ expressions given their operands,
28 including computing the types of the result, C and C++ specific error
29 checks, and some optimization. */
33 #include "coretypes.h"
40 #include "diagnostic.h"
43 process_init_constructor (tree type
, tree init
);
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
50 error_not_base_type (tree basetype
, tree type
)
52 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
53 basetype
= DECL_CONTEXT (basetype
);
54 error ("type %qT is not a base type for type %qT", basetype
, type
);
55 return error_mark_node
;
59 binfo_or_else (tree base
, tree type
)
61 tree binfo
= lookup_base (type
, base
, ba_unique
, NULL
);
63 if (binfo
== error_mark_node
)
66 error_not_base_type (base
, type
);
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. */
74 readonly_error (tree arg
, const char* string
)
78 if (TREE_CODE (arg
) == COMPONENT_REF
)
80 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
81 fmt
= "%s of data-member %qD in read-only structure";
83 fmt
= "%s of read-only data-member %qD";
84 error (fmt
, string
, TREE_OPERAND (arg
, 1));
86 else if (TREE_CODE (arg
) == VAR_DECL
)
88 if (DECL_LANG_SPECIFIC (arg
)
89 && DECL_IN_AGGR_P (arg
)
90 && !TREE_STATIC (arg
))
91 fmt
= "%s of constant field %qD";
93 fmt
= "%s of read-only variable %qD";
94 error (fmt
, string
, arg
);
96 else if (TREE_CODE (arg
) == PARM_DECL
)
97 error ("%s of read-only parameter %qD", string
, arg
);
98 else if (TREE_CODE (arg
) == INDIRECT_REF
99 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
100 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
101 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
102 error ("%s of read-only reference %qD", string
, TREE_OPERAND (arg
, 0));
103 else if (TREE_CODE (arg
) == RESULT_DECL
)
104 error ("%s of read-only named return value %qD", string
, arg
);
105 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
106 error ("%s of function %qD", string
, arg
);
108 error ("%s of read-only location", string
);
112 /* Structure that holds information about declarations whose type was
113 incomplete and we could not check whether it was abstract or not. */
115 struct pending_abstract_type
GTY((chain_next ("%h.next")))
117 /* Declaration which we are checking for abstractness. It is either
118 a DECL node, or an IDENTIFIER_NODE if we do not have a full
119 declaration available. */
122 /* Type which will be checked for abstractness. */
125 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
126 because DECLs already carry locus information. */
129 /* Link to the next element in list. */
130 struct pending_abstract_type
* next
;
134 /* Compute the hash value of the node VAL. This function is used by the
135 hash table abstract_pending_vars. */
138 pat_calc_hash (const void* val
)
140 const struct pending_abstract_type
*pat
=
141 (const struct pending_abstract_type
*) val
;
142 return (hashval_t
) TYPE_UID (pat
->type
);
146 /* Compare node VAL1 with the type VAL2. This function is used by the
147 hash table abstract_pending_vars. */
150 pat_compare (const void* val1
, const void* val2
)
152 const struct pending_abstract_type
*const pat1
=
153 (const struct pending_abstract_type
*) val1
;
154 const_tree
const type2
= (const_tree
)val2
;
156 return (pat1
->type
== type2
);
159 /* Hash table that maintains pending_abstract_type nodes, for which we still
160 need to check for type abstractness. The key of the table is the type
161 of the declaration. */
162 static GTY ((param_is (struct pending_abstract_type
)))
163 htab_t abstract_pending_vars
= NULL
;
166 /* This function is called after TYPE is completed, and will check if there
167 are pending declarations for which we still need to verify the abstractness
168 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
169 turned out to be incomplete. */
172 complete_type_check_abstract (tree type
)
175 struct pending_abstract_type
*pat
;
176 location_t cur_loc
= input_location
;
178 gcc_assert (COMPLETE_TYPE_P (type
));
180 if (!abstract_pending_vars
)
183 /* Retrieve the list of pending declarations for this type. */
184 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
185 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
188 pat
= (struct pending_abstract_type
*)*slot
;
191 /* If the type is not abstract, do not do anything. */
192 if (CLASSTYPE_PURE_VIRTUALS (type
))
194 struct pending_abstract_type
*prev
= 0, *next
;
196 /* Reverse the list to emit the errors in top-down order. */
197 for (; pat
; pat
= next
)
205 /* Go through the list, and call abstract_virtuals_error for each
206 element: it will issue a diagnostic if the type is abstract. */
209 gcc_assert (type
== pat
->type
);
211 /* Tweak input_location so that the diagnostic appears at the correct
212 location. Notice that this is only needed if the decl is an
214 input_location
= pat
->locus
;
215 abstract_virtuals_error (pat
->decl
, pat
->type
);
220 htab_clear_slot (abstract_pending_vars
, slot
);
222 input_location
= cur_loc
;
226 /* If TYPE has abstract virtual functions, issue an error about trying
227 to create an object of that type. DECL is the object declared, or
228 NULL_TREE if the declaration is unavailable. Returns 1 if an error
229 occurred; zero if all was well. */
232 abstract_virtuals_error (tree decl
, tree type
)
236 /* This function applies only to classes. Any other entity can never
238 if (!CLASS_TYPE_P (type
))
241 /* If the type is incomplete, we register it within a hash table,
242 so that we can check again once it is completed. This makes sense
243 only for objects for which we have a declaration or at least a
245 if (!COMPLETE_TYPE_P (type
))
248 struct pending_abstract_type
*pat
;
250 gcc_assert (!decl
|| DECL_P (decl
)
251 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
253 if (!abstract_pending_vars
)
254 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
257 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
258 (hashval_t
)TYPE_UID (type
), INSERT
);
260 pat
= GGC_NEW (struct pending_abstract_type
);
263 pat
->locus
= ((decl
&& DECL_P (decl
))
264 ? DECL_SOURCE_LOCATION (decl
)
267 pat
->next
= (struct pending_abstract_type
*) *slot
;
273 if (!TYPE_SIZE (type
))
274 /* TYPE is being defined, and during that time
275 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
278 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
284 if (TREE_CODE (decl
) == RESULT_DECL
)
287 if (TREE_CODE (decl
) == VAR_DECL
)
288 error ("cannot declare variable %q+D to be of abstract "
289 "type %qT", decl
, type
);
290 else if (TREE_CODE (decl
) == PARM_DECL
)
291 error ("cannot declare parameter %q+D to be of abstract type %qT",
293 else if (TREE_CODE (decl
) == FIELD_DECL
)
294 error ("cannot declare field %q+D to be of abstract type %qT",
296 else if (TREE_CODE (decl
) == FUNCTION_DECL
297 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
298 error ("invalid abstract return type for member function %q+#D", decl
);
299 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
300 error ("invalid abstract return type for function %q+#D", decl
);
301 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
302 /* Here we do not have location information. */
303 error ("invalid abstract type %qT for %qE", type
, decl
);
305 error ("invalid abstract type for %q+D", decl
);
308 error ("cannot allocate an object of abstract type %qT", type
);
310 /* Only go through this once. */
311 if (VEC_length (tree
, pure
))
316 inform ("%J because the following virtual functions are pure "
317 "within %qT:", TYPE_MAIN_DECL (type
), type
);
319 for (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
320 inform ("\t%+#D", fn
);
321 /* Now truncate the vector. This leaves it non-null, so we know
322 there are pure virtuals, but empty so we don't list them out
324 VEC_truncate (tree
, pure
, 0);
327 inform ("%J since type %qT has pure virtual functions",
328 TYPE_MAIN_DECL (type
), type
);
333 /* Print an error message for invalid use of an incomplete type.
334 VALUE is the expression that was used (or 0 if that isn't known)
335 and TYPE is the type that was invalid. DIAG_TYPE indicates the
336 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
340 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
343 void (*p_msg
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
347 else if (diag_type
== 2)
352 /* Avoid duplicate error message. */
353 if (TREE_CODE (type
) == ERROR_MARK
)
356 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
357 || TREE_CODE (value
) == PARM_DECL
358 || TREE_CODE (value
) == FIELD_DECL
))
360 p_msg ("%q+D has incomplete type", value
);
364 /* We must print an error message. Be clever about what it says. */
366 switch (TREE_CODE (type
))
372 p_msg ("invalid use of incomplete type %q#T", type
);
373 if (!TYPE_TEMPLATE_INFO (type
))
374 p_msg ("forward declaration of %q+#T", type
);
376 p_msg ("declaration of %q+#T", type
);
380 p_msg ("invalid use of %qT", type
);
384 if (TYPE_DOMAIN (type
))
386 type
= TREE_TYPE (type
);
389 p_msg ("invalid use of array with unspecified bounds");
394 p_msg ("invalid use of member (did you forget the %<&%> ?)");
397 case TEMPLATE_TYPE_PARM
:
398 p_msg ("invalid use of template type parameter %qT", type
);
401 case BOUND_TEMPLATE_TEMPLATE_PARM
:
402 p_msg ("invalid use of template template parameter %qT",
407 p_msg ("invalid use of dependent type %qT", type
);
411 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
413 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
414 p_msg ("address of overloaded function with no contextual "
416 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
417 p_msg ("overloaded function with no contextual type information");
419 p_msg ("insufficient contextual information to determine type");
427 /* Backward-compatibility interface to incomplete_type_diagnostic;
428 required by ../tree.c. */
429 #undef cxx_incomplete_type_error
431 cxx_incomplete_type_error (tree value
, tree type
)
433 cxx_incomplete_type_diagnostic (value
, type
, 0);
437 /* The recursive part of split_nonconstant_init. DEST is an lvalue
438 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
441 split_nonconstant_init_1 (tree dest
, tree init
)
443 unsigned HOST_WIDE_INT idx
;
444 tree field_index
, value
;
445 tree type
= TREE_TYPE (dest
);
446 tree inner_type
= NULL
;
447 bool array_type_p
= false;
449 switch (TREE_CODE (type
))
452 inner_type
= TREE_TYPE (type
);
458 case QUAL_UNION_TYPE
:
459 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
462 /* The current implementation of this algorithm assumes that
463 the field was set for all the elements. This is usually done
464 by process_init_constructor. */
465 gcc_assert (field_index
);
468 inner_type
= TREE_TYPE (field_index
);
470 if (TREE_CODE (value
) == CONSTRUCTOR
)
475 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
476 NULL_TREE
, NULL_TREE
);
478 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
481 split_nonconstant_init_1 (sub
, value
);
483 else if (!initializer_constant_valid_p (value
, inner_type
))
488 /* FIXME: Ordered removal is O(1) so the whole function is
489 worst-case quadratic. This could be fixed using an aside
490 bitmap to record which elements must be removed and remove
491 them all at the same time. Or by merging
492 split_non_constant_init into process_init_constructor_array,
493 that is separating constants from non-constants while building
495 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
500 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
501 NULL_TREE
, NULL_TREE
);
503 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
506 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
507 code
= build_stmt (EXPR_STMT
, code
);
515 if (!initializer_constant_valid_p (init
, type
))
518 tree cons
= copy_node (init
);
519 CONSTRUCTOR_ELTS (init
) = NULL
;
520 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
521 code
= build_stmt (EXPR_STMT
, code
);
530 /* The rest of the initializer is now a constant. */
531 TREE_CONSTANT (init
) = 1;
534 /* A subroutine of store_init_value. Splits non-constant static
535 initializer INIT into a constant part and generates code to
536 perform the non-constant part of the initialization to DEST.
537 Returns the code for the runtime init. */
540 split_nonconstant_init (tree dest
, tree init
)
544 if (TREE_CODE (init
) == CONSTRUCTOR
)
546 code
= push_stmt_list ();
547 split_nonconstant_init_1 (dest
, init
);
548 code
= pop_stmt_list (code
);
549 DECL_INITIAL (dest
) = init
;
550 TREE_READONLY (dest
) = 0;
553 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
558 /* Perform appropriate conversions on the initial value of a variable,
559 store it in the declaration DECL,
560 and print any error messages that are appropriate.
561 If the init is invalid, store an ERROR_MARK.
563 C++: Note that INIT might be a TREE_LIST, which would mean that it is
564 a base class initializer for some aggregate type, hopefully compatible
565 with DECL. If INIT is a single element, and DECL is an aggregate
566 type, we silently convert INIT into a TREE_LIST, allowing a constructor
569 If INIT is a TREE_LIST and there is no constructor, turn INIT
570 into a CONSTRUCTOR and use standard initialization techniques.
571 Perhaps a warning should be generated?
573 Returns code to be executed if initialization could not be performed
574 for static variable. In that case, caller must emit the code. */
577 store_init_value (tree decl
, tree init
)
581 /* If variable's type was invalidly declared, just ignore it. */
583 type
= TREE_TYPE (decl
);
584 if (TREE_CODE (type
) == ERROR_MARK
)
587 if (IS_AGGR_TYPE (type
))
589 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
590 || TREE_CODE (init
) == CONSTRUCTOR
);
592 if (TREE_CODE (init
) == TREE_LIST
)
594 error ("constructor syntax used, but no constructor declared "
595 "for type %qT", type
);
596 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
599 else if (TREE_CODE (init
) == TREE_LIST
600 && TREE_TYPE (init
) != unknown_type_node
)
602 if (TREE_CODE (decl
) == RESULT_DECL
)
603 init
= build_x_compound_expr_from_list (init
,
604 "return value initializer");
605 else if (TREE_CODE (init
) == TREE_LIST
606 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
608 error ("cannot initialize arrays using this syntax");
612 /* We get here with code like `int a (2);' */
613 init
= build_x_compound_expr_from_list (init
, "initializer");
616 /* End of special C++ code. */
618 /* Digest the specified initializer into an expression. */
619 value
= digest_init (type
, init
);
620 /* If the initializer is not a constant, fill in DECL_INITIAL with
621 the bits that are constant, and then return an expression that
622 will perform the dynamic initialization. */
623 if (value
!= error_mark_node
624 && (TREE_SIDE_EFFECTS (value
)
625 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
626 return split_nonconstant_init (decl
, value
);
627 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
628 is an automatic variable, the middle end will turn this into a
629 dynamic initialization later. */
630 DECL_INITIAL (decl
) = value
;
635 /* Process the initializer INIT for a variable of type TYPE, emitting
636 diagnostics for invalid initializers and converting the initializer as
639 For aggregate types, it assumes that reshape_init has already run, thus the
640 initializer will have the right shape (brace elision has been undone). */
643 digest_init (tree type
, tree init
)
645 enum tree_code code
= TREE_CODE (type
);
647 if (init
== error_mark_node
)
648 return error_mark_node
;
652 /* We must strip the outermost array type when completing the type,
653 because the its bounds might be incomplete at the moment. */
654 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
655 ? TREE_TYPE (type
) : type
, NULL_TREE
))
656 return error_mark_node
;
658 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
659 (g++.old-deja/g++.law/casts2.C). */
660 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
661 init
= TREE_OPERAND (init
, 0);
663 /* Initialization of an array of chars from a string constant. The initializer
664 can be optionally enclosed in braces, but reshape_init has already removed
665 them if they were present. */
666 if (code
== ARRAY_TYPE
)
668 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
669 if (char_type_p (typ1
)
671 && TREE_CODE (init
) == STRING_CST
)
673 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
675 if (char_type
!= char_type_node
676 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
678 error ("char-array initialized from wide string");
679 return error_mark_node
;
681 if (char_type
== char_type_node
682 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
684 error ("int-array initialized from non-wide string");
685 return error_mark_node
;
688 TREE_TYPE (init
) = type
;
689 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
691 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
692 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
693 /* In C it is ok to subtract 1 from the length of the string
694 because it's ok to ignore the terminating null char that is
695 counted in the length of the constant, but in C++ this would
697 if (size
< TREE_STRING_LENGTH (init
))
698 pedwarn ("initializer-string for array of chars is too long");
704 /* Handle scalar types (including conversions) and references. */
705 if (TREE_CODE (type
) != COMPLEX_TYPE
706 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
707 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
708 "initialization", NULL_TREE
, 0);
710 /* Come here only for aggregates: records, arrays, unions, complex numbers
712 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
713 || TREE_CODE (type
) == VECTOR_TYPE
714 || TREE_CODE (type
) == RECORD_TYPE
715 || TREE_CODE (type
) == UNION_TYPE
716 || TREE_CODE (type
) == COMPLEX_TYPE
);
718 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
719 return process_init_constructor (type
, init
);
722 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
724 error ("cannot initialize aggregate of type %qT with "
725 "a compound literal", type
);
727 return error_mark_node
;
730 if (TREE_CODE (type
) == ARRAY_TYPE
731 && TREE_CODE (init
) != CONSTRUCTOR
)
733 error ("array must be initialized with a brace-enclosed"
735 return error_mark_node
;
738 return convert_for_initialization (NULL_TREE
, type
, init
,
739 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
740 "initialization", NULL_TREE
, 0);
745 /* Set of flags used within process_init_constructor to describe the
747 #define PICFLAG_ERRONEOUS 1
748 #define PICFLAG_NOT_ALL_CONSTANT 2
749 #define PICFLAG_NOT_ALL_SIMPLE 4
751 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
755 picflag_from_initializer (tree init
)
757 if (init
== error_mark_node
)
758 return PICFLAG_ERRONEOUS
;
759 else if (!TREE_CONSTANT (init
))
760 return PICFLAG_NOT_ALL_CONSTANT
;
761 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
762 return PICFLAG_NOT_ALL_SIMPLE
;
766 /* Subroutine of process_init_constructor, which will process an initializer
767 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
768 which describe the initializers. */
771 process_init_constructor_array (tree type
, tree init
)
773 unsigned HOST_WIDE_INT i
, len
= 0;
775 bool unbounded
= false;
777 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
779 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
780 || TREE_CODE (type
) == VECTOR_TYPE
);
782 if (TREE_CODE (type
) == ARRAY_TYPE
)
784 tree domain
= TYPE_DOMAIN (type
);
786 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
787 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
790 unbounded
= true; /* Take as many as there are. */
793 /* Vectors are like simple fixed-size arrays. */
794 len
= TYPE_VECTOR_SUBPARTS (type
);
796 /* There cannot be more initializers than needed as otherwise
797 reshape_init would have already rejected the initializer. */
799 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
801 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
805 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
806 if (compare_tree_int (ce
->index
, i
) != 0)
808 ce
->value
= error_mark_node
;
809 sorry ("non-trivial designated initializers not supported");
813 ce
->index
= size_int (i
);
814 gcc_assert (ce
->value
);
815 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
817 if (ce
->value
!= error_mark_node
)
818 gcc_assert (same_type_ignoring_top_level_qualifiers_p
819 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
821 flags
|= picflag_from_initializer (ce
->value
);
824 /* No more initializers. If the array is unbounded, we are done. Otherwise,
825 we must add initializers ourselves. */
831 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
833 /* If this type needs constructors run for default-initialization,
834 we can't rely on the back end to do it for us, so build up
835 TARGET_EXPRs. If the type in question is a class, just build
836 one up; if it's an array, recurse. */
837 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
838 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
840 next
= build_constructor (NULL_TREE
, NULL
);
841 next
= digest_init (TREE_TYPE (type
), next
);
843 else if (!zero_init_p (TREE_TYPE (type
)))
844 next
= build_zero_init (TREE_TYPE (type
),
846 /*static_storage_p=*/false);
848 /* The default zero-initialization is fine for us; don't
849 add anything to the CONSTRUCTOR. */
852 flags
|= picflag_from_initializer (next
);
853 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
856 CONSTRUCTOR_ELTS (init
) = v
;
860 /* Subroutine of process_init_constructor, which will process an initializer
861 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
865 process_init_constructor_record (tree type
, tree init
)
867 VEC(constructor_elt
,gc
) *v
= NULL
;
870 unsigned HOST_WIDE_INT idx
= 0;
872 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
873 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
874 gcc_assert (!TYPE_BINFO (type
)
875 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
876 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
878 /* Generally, we will always have an index for each initializer (which is
879 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
880 reshape_init. So we need to handle both cases. */
881 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
885 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
887 flags
|= picflag_from_initializer (integer_zero_node
);
888 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
892 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
895 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
897 constructor_elt
*ce
= VEC_index (constructor_elt
,
898 CONSTRUCTOR_ELTS (init
), idx
);
901 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
902 latter case can happen in templates where lookup has to be
904 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
905 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
906 if (ce
->index
!= field
907 && ce
->index
!= DECL_NAME (field
))
909 ce
->value
= error_mark_node
;
910 sorry ("non-trivial designated initializers not supported");
914 gcc_assert (ce
->value
);
915 next
= digest_init (TREE_TYPE (field
), ce
->value
);
918 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
920 /* If this type needs constructors run for
921 default-initialization, we can't rely on the back end to do it
922 for us, so build up TARGET_EXPRs. If the type in question is
923 a class, just build one up; if it's an array, recurse. */
924 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
925 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
);
927 next
= build_constructor (NULL_TREE
, NULL
);
929 next
= digest_init (TREE_TYPE (field
), next
);
931 /* Warn when some struct elements are implicitly initialized. */
932 warning (OPT_Wmissing_field_initializers
,
933 "missing initializer for member %qD", field
);
937 if (TREE_READONLY (field
))
938 error ("uninitialized const member %qD", field
);
939 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
940 error ("member %qD with uninitialized const fields", field
);
941 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
942 error ("member %qD is uninitialized reference", field
);
944 /* Warn when some struct elements are implicitly initialized
946 warning (OPT_Wmissing_field_initializers
,
947 "missing initializer for member %qD", field
);
949 if (!zero_init_p (TREE_TYPE (field
)))
950 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
951 /*static_storage_p=*/false);
953 /* The default zero-initialization is fine for us; don't
954 add anything to the CONSTRUCTOR. */
958 flags
|= picflag_from_initializer (next
);
959 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
962 CONSTRUCTOR_ELTS (init
) = v
;
966 /* Subroutine of process_init_constructor, which will process a single
967 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
968 which describe the initializer. */
971 process_init_constructor_union (tree type
, tree init
)
975 /* If the initializer was empty, use default zero initialization. */
976 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
979 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
980 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
982 /* If this element specifies a field, initialize via that field. */
985 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
987 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
989 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
990 tree name
= ce
->index
;
992 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
993 if (DECL_NAME (field
) == name
)
997 error ("no field %qD found in union being initialized", field
);
998 ce
->value
= error_mark_node
;
1004 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1005 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1006 error ("index value instead of field name in union initializer");
1007 ce
->value
= error_mark_node
;
1012 /* Find the first named field. ANSI decided in September 1990
1013 that only named fields count here. */
1014 tree field
= TYPE_FIELDS (type
);
1015 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1016 field
= TREE_CHAIN (field
);
1021 if (ce
->value
&& ce
->value
!= error_mark_node
)
1022 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1024 return picflag_from_initializer (ce
->value
);
1027 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1028 constructor is a brace-enclosed initializer, and will be modified in-place.
1030 Each element is converted to the right type through digest_init, and
1031 missing initializers are added following the language rules (zero-padding,
1034 After the execution, the initializer will have TREE_CONSTANT if all elts are
1035 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1036 constants that the assembler and linker can compute them.
1038 The function returns the initializer itself, or error_mark_node in case
1042 process_init_constructor (tree type
, tree init
)
1046 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1048 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1049 flags
= process_init_constructor_array (type
, init
);
1050 else if (TREE_CODE (type
) == RECORD_TYPE
)
1051 flags
= process_init_constructor_record (type
, init
);
1052 else if (TREE_CODE (type
) == UNION_TYPE
)
1053 flags
= process_init_constructor_union (type
, init
);
1057 if (flags
& PICFLAG_ERRONEOUS
)
1058 return error_mark_node
;
1060 TREE_TYPE (init
) = type
;
1061 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1062 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1063 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1065 TREE_CONSTANT (init
) = 1;
1066 TREE_INVARIANT (init
) = 1;
1067 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1068 TREE_STATIC (init
) = 1;
1073 /* Given a structure or union value DATUM, construct and return
1074 the structure or union component which results from narrowing
1075 that value to the base specified in BASETYPE. For example, given the
1078 class L { int ii; };
1079 class A : L { ... };
1080 class B : L { ... };
1081 class C : A, B { ... };
1089 x.A::ii refers to the ii member of the L part of
1090 the A part of the C object named by X. In this case,
1091 DATUM would be x, and BASETYPE would be A.
1093 I used to think that this was nonconformant, that the standard specified
1094 that first we look up ii in A, then convert x to an L& and pull out the
1095 ii part. But in fact, it does say that we convert x to an A&; A here
1096 is known as the "naming class". (jason 2000-12-19)
1098 BINFO_P points to a variable initialized either to NULL_TREE or to the
1099 binfo for the specific base subobject we want to convert to. */
1102 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1106 if (datum
== error_mark_node
)
1107 return error_mark_node
;
1111 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1113 if (!binfo
|| binfo
== error_mark_node
)
1115 *binfo_p
= NULL_TREE
;
1117 error_not_base_type (basetype
, TREE_TYPE (datum
));
1118 return error_mark_node
;
1122 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1125 /* Build a reference to an object specified by the C++ `->' operator.
1126 Usually this just involves dereferencing the object, but if the
1127 `->' operator is overloaded, then such overloads must be
1128 performed until an object which does not have the `->' operator
1129 overloaded is found. An error is reported when circular pointer
1130 delegation is detected. */
1133 build_x_arrow (tree expr
)
1135 tree orig_expr
= expr
;
1136 tree types_memoized
= NULL_TREE
;
1137 tree type
= TREE_TYPE (expr
);
1138 tree last_rval
= NULL_TREE
;
1140 if (type
== error_mark_node
)
1141 return error_mark_node
;
1143 if (processing_template_decl
)
1145 if (type_dependent_expression_p (expr
))
1146 return build_min_nt (ARROW_EXPR
, expr
);
1147 expr
= build_non_dependent_expr (expr
);
1150 if (IS_AGGR_TYPE (type
))
1152 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1153 NULL_TREE
, NULL_TREE
,
1154 /*overloaded_p=*/NULL
)))
1156 if (expr
== error_mark_node
)
1157 return error_mark_node
;
1159 if (value_member (TREE_TYPE (expr
), types_memoized
))
1161 error ("circular pointer delegation detected");
1162 return error_mark_node
;
1166 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1172 if (last_rval
== NULL_TREE
)
1174 error ("base operand of %<->%> has non-pointer type %qT", type
);
1175 return error_mark_node
;
1178 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1179 last_rval
= convert_from_reference (last_rval
);
1182 last_rval
= decay_conversion (expr
);
1184 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1186 if (processing_template_decl
)
1188 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1189 /* It will be dereferenced. */
1190 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1194 return build_indirect_ref (last_rval
, NULL
);
1198 error ("result of %<operator->()%> yields non-pointer result");
1200 error ("base operand of %<->%> is not a pointer");
1201 return error_mark_node
;
1204 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1205 already been checked out to be of aggregate type. */
1208 build_m_component_ref (tree datum
, tree component
)
1216 if (error_operand_p (datum
) || error_operand_p (component
))
1217 return error_mark_node
;
1219 ptrmem_type
= TREE_TYPE (component
);
1220 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1222 error ("%qE cannot be used as a member pointer, since it is of "
1224 component
, ptrmem_type
);
1225 return error_mark_node
;
1228 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1229 if (! IS_AGGR_TYPE (objtype
))
1231 error ("cannot apply member pointer %qE to %qE, which is of "
1232 "non-class type %qT",
1233 component
, datum
, objtype
);
1234 return error_mark_node
;
1237 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1238 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1240 if (!COMPLETE_TYPE_P (ctype
))
1242 if (!same_type_p (ctype
, objtype
))
1248 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1253 error ("pointer to member type %qT incompatible with object "
1256 return error_mark_node
;
1258 else if (binfo
== error_mark_node
)
1259 return error_mark_node
;
1262 if (TYPE_PTRMEM_P (ptrmem_type
))
1266 /* Compute the type of the field, as described in [expr.ref].
1267 There's no such thing as a mutable pointer-to-member, so
1268 things are not as complex as they are for references to
1269 non-static data members. */
1270 type
= cp_build_qualified_type (type
,
1271 (cp_type_quals (type
)
1272 | cp_type_quals (TREE_TYPE (datum
))));
1274 datum
= build_address (datum
);
1276 /* Convert object to the correct base. */
1278 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1280 /* Build an expression for "object + offset" where offset is the
1281 value stored in the pointer-to-data-member. */
1282 ptype
= build_pointer_type (type
);
1283 datum
= build2 (POINTER_PLUS_EXPR
, ptype
,
1284 fold_convert (ptype
, datum
),
1285 build_nop (sizetype
, component
));
1286 return build_indirect_ref (datum
, 0);
1289 return build2 (OFFSET_REF
, type
, datum
, component
);
1292 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1295 build_functional_cast (tree exp
, tree parms
)
1297 /* This is either a call to a constructor,
1298 or a C cast in C++'s `functional' notation. */
1301 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1302 return error_mark_node
;
1304 if (TREE_CODE (exp
) == TYPE_DECL
)
1305 type
= TREE_TYPE (exp
);
1309 if (processing_template_decl
)
1311 tree t
= build_min (CAST_EXPR
, type
, parms
);
1312 /* We don't know if it will or will not have side effects. */
1313 TREE_SIDE_EFFECTS (t
) = 1;
1317 if (! IS_AGGR_TYPE (type
))
1319 if (parms
== NULL_TREE
)
1320 return cp_convert (type
, integer_zero_node
);
1322 /* This must build a C cast. */
1323 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1324 return build_c_cast (type
, parms
);
1327 /* Prepare to evaluate as a call to a constructor. If this expression
1328 is actually used, for example,
1330 return X (arg1, arg2, ...);
1332 then the slot being initialized will be filled in. */
1334 if (!complete_type_or_else (type
, NULL_TREE
))
1335 return error_mark_node
;
1336 if (abstract_virtuals_error (NULL_TREE
, type
))
1337 return error_mark_node
;
1339 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1340 return build_c_cast (type
, TREE_VALUE (parms
));
1342 /* We need to zero-initialize POD types. */
1343 if (parms
== NULL_TREE
1344 && !CLASSTYPE_NON_POD_P (type
)
1345 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1347 exp
= build_zero_init (type
,
1348 /*nelts=*/NULL_TREE
,
1349 /*static_storage_p=*/false);
1350 return get_target_expr (exp
);
1353 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1354 type
, LOOKUP_NORMAL
);
1356 if (exp
== error_mark_node
)
1357 return error_mark_node
;
1359 return build_cplus_new (type
, exp
);
1363 /* Add new exception specifier SPEC, to the LIST we currently have.
1364 If it's already in LIST then do nothing.
1365 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1366 know what we're doing. */
1369 add_exception_specifier (tree list
, tree spec
, int complain
)
1374 int diag_type
= -1; /* none */
1376 if (spec
== error_mark_node
)
1379 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1381 /* [except.spec] 1, type in an exception specifier shall not be
1382 incomplete, or pointer or ref to incomplete other than pointer
1384 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1385 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1386 core
= TREE_TYPE (core
);
1389 else if (VOID_TYPE_P (core
))
1391 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1393 else if (processing_template_decl
)
1398 /* 15.4/1 says that types in an exception specifier must be complete,
1399 but it seems more reasonable to only require this on definitions
1400 and calls. So just give a pedwarn at this point; we will give an
1401 error later if we hit one of those two cases. */
1402 if (!COMPLETE_TYPE_P (complete_type (core
)))
1403 diag_type
= 2; /* pedwarn */
1410 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1411 if (same_type_p (TREE_VALUE (probe
), spec
))
1414 list
= tree_cons (NULL_TREE
, spec
, list
);
1417 diag_type
= 0; /* error */
1419 if (diag_type
>= 0 && complain
)
1420 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1425 /* Combine the two exceptions specifier lists LIST and ADD, and return
1429 merge_exception_specifiers (tree list
, tree add
)
1433 else if (!TREE_VALUE (list
))
1435 else if (!TREE_VALUE (add
))
1439 tree orig_list
= list
;
1441 for (; add
; add
= TREE_CHAIN (add
))
1443 tree spec
= TREE_VALUE (add
);
1446 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1447 if (same_type_p (TREE_VALUE (probe
), spec
))
1451 spec
= build_tree_list (NULL_TREE
, spec
);
1452 TREE_CHAIN (spec
) = list
;
1460 /* Subroutine of build_call. Ensure that each of the types in the
1461 exception specification is complete. Technically, 15.4/1 says that
1462 they need to be complete when we see a declaration of the function,
1463 but we should be able to get away with only requiring this when the
1464 function is defined or called. See also add_exception_specifier. */
1467 require_complete_eh_spec_types (tree fntype
, tree decl
)
1470 /* Don't complain about calls to op new. */
1471 if (decl
&& DECL_ARTIFICIAL (decl
))
1473 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1474 raises
= TREE_CHAIN (raises
))
1476 tree type
= TREE_VALUE (raises
);
1477 if (type
&& !COMPLETE_TYPE_P (type
))
1481 ("call to function %qD which throws incomplete type %q#T",
1484 error ("call to function which throws incomplete type %q#T",
1491 #include "gt-cp-typeck2.h"