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. Thus, we emit hard errors for these,
72 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
73 example, conversions to references.) */
76 readonly_error (tree arg
, const char* string
, int soft
)
79 void (*fn
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
86 if (TREE_CODE (arg
) == COMPONENT_REF
)
88 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
89 fmt
= "%s of data-member %qD in read-only structure";
91 fmt
= "%s of read-only data-member %qD";
92 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
94 else if (TREE_CODE (arg
) == VAR_DECL
)
96 if (DECL_LANG_SPECIFIC (arg
)
97 && DECL_IN_AGGR_P (arg
)
98 && !TREE_STATIC (arg
))
99 fmt
= "%s of constant field %qD";
101 fmt
= "%s of read-only variable %qD";
102 (*fn
) (fmt
, string
, arg
);
104 else if (TREE_CODE (arg
) == PARM_DECL
)
105 (*fn
) ("%s of read-only parameter %qD", string
, arg
);
106 else if (TREE_CODE (arg
) == INDIRECT_REF
107 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
108 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
109 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
110 (*fn
) ("%s of read-only reference %qD", string
, TREE_OPERAND (arg
, 0));
111 else if (TREE_CODE (arg
) == RESULT_DECL
)
112 (*fn
) ("%s of read-only named return value %qD", string
, arg
);
113 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
114 (*fn
) ("%s of function %qD", string
, arg
);
116 (*fn
) ("%s of read-only location", string
);
120 /* Structure that holds information about declarations whose type was
121 incomplete and we could not check whether it was abstract or not. */
123 struct pending_abstract_type
GTY((chain_next ("%h.next")))
125 /* Declaration which we are checking for abstractness. It is either
126 a DECL node, or an IDENTIFIER_NODE if we do not have a full
127 declaration available. */
130 /* Type which will be checked for abstractness. */
133 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
134 because DECLs already carry locus information. */
137 /* Link to the next element in list. */
138 struct pending_abstract_type
* next
;
142 /* Compute the hash value of the node VAL. This function is used by the
143 hash table abstract_pending_vars. */
146 pat_calc_hash (const void* val
)
148 const struct pending_abstract_type
*pat
=
149 (const struct pending_abstract_type
*) val
;
150 return (hashval_t
) TYPE_UID (pat
->type
);
154 /* Compare node VAL1 with the type VAL2. This function is used by the
155 hash table abstract_pending_vars. */
158 pat_compare (const void* val1
, const void* val2
)
160 const struct pending_abstract_type
*pat1
=
161 (const struct pending_abstract_type
*) val1
;
162 tree type2
= (tree
)val2
;
164 return (pat1
->type
== type2
);
167 /* Hash table that maintains pending_abstract_type nodes, for which we still
168 need to check for type abstractness. The key of the table is the type
169 of the declaration. */
170 static GTY ((param_is (struct pending_abstract_type
)))
171 htab_t abstract_pending_vars
= NULL
;
174 /* This function is called after TYPE is completed, and will check if there
175 are pending declarations for which we still need to verify the abstractness
176 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
177 turned out to be incomplete. */
180 complete_type_check_abstract (tree type
)
183 struct pending_abstract_type
*pat
;
184 location_t cur_loc
= input_location
;
186 gcc_assert (COMPLETE_TYPE_P (type
));
188 if (!abstract_pending_vars
)
191 /* Retrieve the list of pending declarations for this type. */
192 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
193 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
196 pat
= (struct pending_abstract_type
*)*slot
;
199 /* If the type is not abstract, do not do anything. */
200 if (CLASSTYPE_PURE_VIRTUALS (type
))
202 struct pending_abstract_type
*prev
= 0, *next
;
204 /* Reverse the list to emit the errors in top-down order. */
205 for (; pat
; pat
= next
)
213 /* Go through the list, and call abstract_virtuals_error for each
214 element: it will issue a diagnostic if the type is abstract. */
217 gcc_assert (type
== pat
->type
);
219 /* Tweak input_location so that the diagnostic appears at the correct
220 location. Notice that this is only needed if the decl is an
222 input_location
= pat
->locus
;
223 abstract_virtuals_error (pat
->decl
, pat
->type
);
228 htab_clear_slot (abstract_pending_vars
, slot
);
230 input_location
= cur_loc
;
234 /* If TYPE has abstract virtual functions, issue an error about trying
235 to create an object of that type. DECL is the object declared, or
236 NULL_TREE if the declaration is unavailable. Returns 1 if an error
237 occurred; zero if all was well. */
240 abstract_virtuals_error (tree decl
, tree type
)
244 /* This function applies only to classes. Any other entity can never
246 if (!CLASS_TYPE_P (type
))
249 /* If the type is incomplete, we register it within a hash table,
250 so that we can check again once it is completed. This makes sense
251 only for objects for which we have a declaration or at least a
253 if (!COMPLETE_TYPE_P (type
))
256 struct pending_abstract_type
*pat
;
258 gcc_assert (!decl
|| DECL_P (decl
)
259 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
261 if (!abstract_pending_vars
)
262 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
265 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
266 (hashval_t
)TYPE_UID (type
), INSERT
);
268 pat
= GGC_NEW (struct pending_abstract_type
);
271 pat
->locus
= ((decl
&& DECL_P (decl
))
272 ? DECL_SOURCE_LOCATION (decl
)
275 pat
->next
= (struct pending_abstract_type
*) *slot
;
281 if (!TYPE_SIZE (type
))
282 /* TYPE is being defined, and during that time
283 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
286 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
292 if (TREE_CODE (decl
) == RESULT_DECL
)
295 if (TREE_CODE (decl
) == VAR_DECL
)
296 error ("cannot declare variable %q+D to be of abstract "
297 "type %qT", decl
, type
);
298 else if (TREE_CODE (decl
) == PARM_DECL
)
299 error ("cannot declare parameter %q+D to be of abstract type %qT",
301 else if (TREE_CODE (decl
) == FIELD_DECL
)
302 error ("cannot declare field %q+D to be of abstract type %qT",
304 else if (TREE_CODE (decl
) == FUNCTION_DECL
305 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
306 error ("invalid abstract return type for member function %q+#D", decl
);
307 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
308 error ("invalid abstract return type for function %q+#D", decl
);
309 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
310 /* Here we do not have location information. */
311 error ("invalid abstract type %qT for %qE", type
, decl
);
313 error ("invalid abstract type for %q+D", decl
);
316 error ("cannot allocate an object of abstract type %qT", type
);
318 /* Only go through this once. */
319 if (VEC_length (tree
, pure
))
324 inform ("%J because the following virtual functions are pure "
325 "within %qT:", TYPE_MAIN_DECL (type
), type
);
327 for (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
328 inform ("\t%+#D", fn
);
329 /* Now truncate the vector. This leaves it non-null, so we know
330 there are pure virtuals, but empty so we don't list them out
332 VEC_truncate (tree
, pure
, 0);
335 inform ("%J since type %qT has pure virtual functions",
336 TYPE_MAIN_DECL (type
), type
);
341 /* Print an error message for invalid use of an incomplete type.
342 VALUE is the expression that was used (or 0 if that isn't known)
343 and TYPE is the type that was invalid. DIAG_TYPE indicates the
344 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
348 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
351 void (*p_msg
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
355 else if (diag_type
== 2)
360 /* Avoid duplicate error message. */
361 if (TREE_CODE (type
) == ERROR_MARK
)
364 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
365 || TREE_CODE (value
) == PARM_DECL
366 || TREE_CODE (value
) == FIELD_DECL
))
368 p_msg ("%q+D has incomplete type", value
);
372 /* We must print an error message. Be clever about what it says. */
374 switch (TREE_CODE (type
))
380 p_msg ("invalid use of incomplete type %q#T", type
);
381 if (!TYPE_TEMPLATE_INFO (type
))
382 p_msg ("forward declaration of %q+#T", type
);
384 p_msg ("declaration of %q+#T", type
);
388 p_msg ("invalid use of %qT", type
);
392 if (TYPE_DOMAIN (type
))
394 type
= TREE_TYPE (type
);
397 p_msg ("invalid use of array with unspecified bounds");
402 p_msg ("invalid use of member (did you forget the %<&%> ?)");
405 case TEMPLATE_TYPE_PARM
:
406 p_msg ("invalid use of template type parameter");
410 p_msg ("invalid use of dependent type %qT", type
);
414 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
416 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
417 p_msg ("address of overloaded function with no contextual "
419 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
420 p_msg ("overloaded function with no contextual type information");
422 p_msg ("insufficient contextual information to determine type");
430 /* Backward-compatibility interface to incomplete_type_diagnostic;
431 required by ../tree.c. */
432 #undef cxx_incomplete_type_error
434 cxx_incomplete_type_error (tree value
, tree type
)
436 cxx_incomplete_type_diagnostic (value
, type
, 0);
440 /* The recursive part of split_nonconstant_init. DEST is an lvalue
441 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
444 split_nonconstant_init_1 (tree dest
, tree init
)
446 unsigned HOST_WIDE_INT idx
;
447 tree field_index
, value
;
448 tree type
= TREE_TYPE (dest
);
449 tree inner_type
= NULL
;
450 bool array_type_p
= false;
452 switch (TREE_CODE (type
))
455 inner_type
= TREE_TYPE (type
);
461 case QUAL_UNION_TYPE
:
462 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
465 /* The current implementation of this algorithm assumes that
466 the field was set for all the elements. This is usually done
467 by process_init_constructor. */
468 gcc_assert (field_index
);
471 inner_type
= TREE_TYPE (field_index
);
473 if (TREE_CODE (value
) == CONSTRUCTOR
)
478 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
479 NULL_TREE
, NULL_TREE
);
481 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
484 split_nonconstant_init_1 (sub
, value
);
486 else if (!initializer_constant_valid_p (value
, inner_type
))
491 /* FIXME: Ordered removal is O(1) so the whole function is
492 worst-case quadratic. This could be fixed using an aside
493 bitmap to record which elements must be removed and remove
494 them all at the same time. Or by merging
495 split_non_constant_init into process_init_constructor_array,
496 that is separating constants from non-constants while building
498 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
503 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
504 NULL_TREE
, NULL_TREE
);
506 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
509 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
510 code
= build_stmt (EXPR_STMT
, code
);
518 if (!initializer_constant_valid_p (init
, type
))
521 tree cons
= copy_node (init
);
522 CONSTRUCTOR_ELTS (init
) = NULL
;
523 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
524 code
= build_stmt (EXPR_STMT
, code
);
533 /* The rest of the initializer is now a constant. */
534 TREE_CONSTANT (init
) = 1;
537 /* A subroutine of store_init_value. Splits non-constant static
538 initializer INIT into a constant part and generates code to
539 perform the non-constant part of the initialization to DEST.
540 Returns the code for the runtime init. */
543 split_nonconstant_init (tree dest
, tree init
)
547 if (TREE_CODE (init
) == CONSTRUCTOR
)
549 code
= push_stmt_list ();
550 split_nonconstant_init_1 (dest
, init
);
551 code
= pop_stmt_list (code
);
552 DECL_INITIAL (dest
) = init
;
553 TREE_READONLY (dest
) = 0;
556 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
561 /* Perform appropriate conversions on the initial value of a variable,
562 store it in the declaration DECL,
563 and print any error messages that are appropriate.
564 If the init is invalid, store an ERROR_MARK.
566 C++: Note that INIT might be a TREE_LIST, which would mean that it is
567 a base class initializer for some aggregate type, hopefully compatible
568 with DECL. If INIT is a single element, and DECL is an aggregate
569 type, we silently convert INIT into a TREE_LIST, allowing a constructor
572 If INIT is a TREE_LIST and there is no constructor, turn INIT
573 into a CONSTRUCTOR and use standard initialization techniques.
574 Perhaps a warning should be generated?
576 Returns code to be executed if initialization could not be performed
577 for static variable. In that case, caller must emit the code. */
580 store_init_value (tree decl
, tree init
)
584 /* If variable's type was invalidly declared, just ignore it. */
586 type
= TREE_TYPE (decl
);
587 if (TREE_CODE (type
) == ERROR_MARK
)
590 if (IS_AGGR_TYPE (type
))
592 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
593 || TREE_CODE (init
) == CONSTRUCTOR
);
595 if (TREE_CODE (init
) == TREE_LIST
)
597 error ("constructor syntax used, but no constructor declared "
598 "for type %qT", type
);
599 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
602 else if (TREE_CODE (init
) == TREE_LIST
603 && TREE_TYPE (init
) != unknown_type_node
)
605 if (TREE_CODE (decl
) == RESULT_DECL
)
606 init
= build_x_compound_expr_from_list (init
,
607 "return value initializer");
608 else if (TREE_CODE (init
) == TREE_LIST
609 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
611 error ("cannot initialize arrays using this syntax");
615 /* We get here with code like `int a (2);' */
616 init
= build_x_compound_expr_from_list (init
, "initializer");
619 /* End of special C++ code. */
621 /* Digest the specified initializer into an expression. */
622 value
= digest_init (type
, init
);
623 /* If the initializer is not a constant, fill in DECL_INITIAL with
624 the bits that are constant, and then return an expression that
625 will perform the dynamic initialization. */
626 if (value
!= error_mark_node
627 && (TREE_SIDE_EFFECTS (value
)
628 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
629 return split_nonconstant_init (decl
, value
);
630 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
631 is an automatic variable, the middle end will turn this into a
632 dynamic initialization later. */
633 DECL_INITIAL (decl
) = value
;
638 /* Process the initializer INIT for a variable of type TYPE, emitting
639 diagnostics for invalid initializers and converting the initializer as
642 For aggregate types, it assumes that reshape_init has already run, thus the
643 initializer will have the right shape (brace elision has been undone). */
646 digest_init (tree type
, tree init
)
648 enum tree_code code
= TREE_CODE (type
);
650 if (init
== error_mark_node
)
651 return error_mark_node
;
655 /* We must strip the outermost array type when completing the type,
656 because the its bounds might be incomplete at the moment. */
657 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
658 ? TREE_TYPE (type
) : type
, NULL_TREE
))
659 return error_mark_node
;
661 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
662 (g++.old-deja/g++.law/casts2.C). */
663 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
664 init
= TREE_OPERAND (init
, 0);
666 /* Initialization of an array of chars from a string constant. The initializer
667 can be optionally enclosed in braces, but reshape_init has already removed
668 them if they were present. */
669 if (code
== ARRAY_TYPE
)
671 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
672 if (char_type_p (typ1
)
674 && TREE_CODE (init
) == STRING_CST
)
676 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
678 if (char_type
!= char_type_node
679 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
681 error ("char-array initialized from wide string");
682 return error_mark_node
;
684 if (char_type
== char_type_node
685 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
687 error ("int-array initialized from non-wide string");
688 return error_mark_node
;
691 TREE_TYPE (init
) = type
;
692 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
694 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
695 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
696 /* In C it is ok to subtract 1 from the length of the string
697 because it's ok to ignore the terminating null char that is
698 counted in the length of the constant, but in C++ this would
700 if (size
< TREE_STRING_LENGTH (init
))
701 pedwarn ("initializer-string for array of chars is too long");
707 /* Handle scalar types (including conversions) and references. */
708 if (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
)
709 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
710 "initialization", NULL_TREE
, 0);
712 /* Come here only for aggregates: records, arrays, unions, complex numbers
714 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
715 || TREE_CODE (type
) == VECTOR_TYPE
716 || TREE_CODE (type
) == RECORD_TYPE
717 || TREE_CODE (type
) == UNION_TYPE
718 || TREE_CODE (type
) == COMPLEX_TYPE
);
720 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
721 return process_init_constructor (type
, init
);
724 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
726 error ("cannot initialize aggregate of type %qT with "
727 "a compound literal", type
);
729 return error_mark_node
;
731 return convert_for_initialization (NULL_TREE
, type
, init
,
732 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
733 "initialization", NULL_TREE
, 0);
738 /* Set of flags used within process_init_constructor to describe the
740 #define PICFLAG_ERRONEOUS 1
741 #define PICFLAG_NOT_ALL_CONSTANT 2
742 #define PICFLAG_NOT_ALL_SIMPLE 4
744 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
748 picflag_from_initializer (tree init
)
750 if (init
== error_mark_node
)
751 return PICFLAG_ERRONEOUS
;
752 else if (!TREE_CONSTANT (init
))
753 return PICFLAG_NOT_ALL_CONSTANT
;
754 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
755 return PICFLAG_NOT_ALL_SIMPLE
;
759 /* Subroutine of process_init_constructor, which will process an initializer
760 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which
761 describe the initializers. */
764 process_init_constructor_array (tree type
, tree init
)
766 unsigned HOST_WIDE_INT i
, len
= 0;
768 bool unbounded
= false;
770 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
772 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
773 || TREE_CODE (type
) == VECTOR_TYPE
);
775 if (TREE_CODE (type
) == ARRAY_TYPE
)
777 tree domain
= TYPE_DOMAIN (type
);
779 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
780 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
783 unbounded
= true; /* Take as many as there are. */
786 /* Vectors are like simple fixed-size arrays. */
787 len
= TYPE_VECTOR_SUBPARTS (type
);
789 /* There cannot be more initializers than needed (or reshape_init would
790 detect this before we do. */
792 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
794 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
798 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
799 if (compare_tree_int (ce
->index
, i
) != 0)
801 ce
->value
= error_mark_node
;
802 sorry ("non-trivial designated initializers not supported");
806 ce
->index
= size_int (i
);
807 gcc_assert (ce
->value
);
808 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
810 if (ce
->value
!= error_mark_node
)
811 gcc_assert (same_type_ignoring_top_level_qualifiers_p
812 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
814 flags
|= picflag_from_initializer (ce
->value
);
817 /* No more initializers. If the array is unbounded, we are done. Otherwise,
818 we must add initializers ourselves. */
824 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
826 /* If this type needs constructors run for default-initialization,
827 we can't rely on the backend to do it for us, so build up
828 TARGET_EXPRs. If the type in question is a class, just build
829 one up; if it's an array, recurse. */
830 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
831 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
833 next
= build_constructor (NULL_TREE
, NULL
);
834 next
= digest_init (TREE_TYPE (type
), next
);
836 else if (!zero_init_p (TREE_TYPE (type
)))
837 next
= build_zero_init (TREE_TYPE (type
),
839 /*static_storage_p=*/false);
841 /* The default zero-initialization is fine for us; don't
842 add anything to the CONSTRUCTOR. */
845 flags
|= picflag_from_initializer (next
);
846 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
849 CONSTRUCTOR_ELTS (init
) = v
;
853 /* Subroutine of process_init_constructor, which will process an initializer
854 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
858 process_init_constructor_record (tree type
, tree init
)
860 VEC(constructor_elt
,gc
) *v
= NULL
;
863 unsigned HOST_WIDE_INT idx
= 0;
865 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
866 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
867 gcc_assert (!TYPE_BINFO (type
)
868 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
869 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
871 /* Generally, we will always have an index for each initializer (which is
872 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
873 reshape_init. So we need to handle both cases. */
874 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
878 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
880 flags
|= picflag_from_initializer (integer_zero_node
);
881 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
885 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
888 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
890 constructor_elt
*ce
= VEC_index (constructor_elt
,
891 CONSTRUCTOR_ELTS (init
), idx
);
894 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
895 latter case can happen in templates where lookup has to be
897 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
898 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
899 if (ce
->index
!= field
900 && ce
->index
!= DECL_NAME (field
))
902 ce
->value
= error_mark_node
;
903 sorry ("non-trivial designated initializers not supported");
907 gcc_assert (ce
->value
);
908 next
= digest_init (TREE_TYPE (field
), ce
->value
);
911 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
913 /* If this type needs constructors run for
914 default-initialization, we can't rely on the backend to do it
915 for us, so build up TARGET_EXPRs. If the type in question is
916 a class, just build one up; if it's an array, recurse. */
917 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
918 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
);
920 next
= build_constructor (NULL_TREE
, NULL
);
922 next
= digest_init (TREE_TYPE (field
), next
);
924 /* Warn when some struct elements are implicitly initialized. */
925 warning (OPT_Wmissing_field_initializers
,
926 "missing initializer for member %qD", field
);
930 if (TREE_READONLY (field
))
931 error ("uninitialized const member %qD", field
);
932 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
933 error ("member %qD with uninitialized const fields", field
);
934 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
935 error ("member %qD is uninitialized reference", field
);
937 /* Warn when some struct elements are implicitly initialized
939 warning (OPT_Wmissing_field_initializers
,
940 "missing initializer for member %qD", field
);
942 if (!zero_init_p (TREE_TYPE (field
)))
943 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
944 /*static_storage_p=*/false);
946 /* The default zero-initialization is fine for us; don't
947 add anything to the CONSTRUCTOR. */
951 flags
|= picflag_from_initializer (next
);
952 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
955 CONSTRUCTOR_ELTS (init
) = v
;
959 /* Subroutine of process_init_constructor, which will process a single
960 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
961 which describe the initializer. */
964 process_init_constructor_union (tree type
, tree init
)
968 /* If the initializer was empty, use default zero initialization. */
969 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
972 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
973 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
975 /* If this element specifies a field, initialize via that field. */
978 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
980 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
982 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
983 tree name
= ce
->index
;
985 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
986 if (DECL_NAME (field
) == name
)
990 error ("no field %qD found in union being initialized", field
);
991 ce
->value
= error_mark_node
;
997 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
998 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
999 error ("index value instead of field name in union initializer");
1000 ce
->value
= error_mark_node
;
1005 /* Find the first named field. ANSI decided in September 1990
1006 that only named fields count here. */
1007 tree field
= TYPE_FIELDS (type
);
1008 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1009 field
= TREE_CHAIN (field
);
1014 if (ce
->value
&& ce
->value
!= error_mark_node
)
1015 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1017 return picflag_from_initializer (ce
->value
);
1020 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1021 constructor is a brace-enclosed initializer, and will be modified in-place.
1023 Each element is converted to the right type through digest_init, and
1024 missing initializers are added following the language rules (zero-padding,
1027 After the execution, the initializer will have TREE_CONSTANT if all elts are
1028 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1029 constants that the assembler and linker can compute them.
1031 The function returns the initializer itself, or error_mark_node in case
1035 process_init_constructor (tree type
, tree init
)
1039 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1041 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1042 flags
= process_init_constructor_array (type
, init
);
1043 else if (TREE_CODE (type
) == RECORD_TYPE
)
1044 flags
= process_init_constructor_record (type
, init
);
1045 else if (TREE_CODE (type
) == UNION_TYPE
)
1046 flags
= process_init_constructor_union (type
, init
);
1050 if (flags
& PICFLAG_ERRONEOUS
)
1051 return error_mark_node
;
1053 TREE_TYPE (init
) = type
;
1054 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1055 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1056 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1058 TREE_CONSTANT (init
) = 1;
1059 TREE_INVARIANT (init
) = 1;
1060 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1061 TREE_STATIC (init
) = 1;
1066 /* Given a structure or union value DATUM, construct and return
1067 the structure or union component which results from narrowing
1068 that value to the base specified in BASETYPE. For example, given the
1071 class L { int ii; };
1072 class A : L { ... };
1073 class B : L { ... };
1074 class C : A, B { ... };
1082 x.A::ii refers to the ii member of the L part of
1083 the A part of the C object named by X. In this case,
1084 DATUM would be x, and BASETYPE would be A.
1086 I used to think that this was nonconformant, that the standard specified
1087 that first we look up ii in A, then convert x to an L& and pull out the
1088 ii part. But in fact, it does say that we convert x to an A&; A here
1089 is known as the "naming class". (jason 2000-12-19)
1091 BINFO_P points to a variable initialized either to NULL_TREE or to the
1092 binfo for the specific base subobject we want to convert to. */
1095 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1099 if (datum
== error_mark_node
)
1100 return error_mark_node
;
1104 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1106 if (!binfo
|| binfo
== error_mark_node
)
1108 *binfo_p
= NULL_TREE
;
1110 error_not_base_type (basetype
, TREE_TYPE (datum
));
1111 return error_mark_node
;
1115 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1118 /* Build a reference to an object specified by the C++ `->' operator.
1119 Usually this just involves dereferencing the object, but if the
1120 `->' operator is overloaded, then such overloads must be
1121 performed until an object which does not have the `->' operator
1122 overloaded is found. An error is reported when circular pointer
1123 delegation is detected. */
1126 build_x_arrow (tree expr
)
1128 tree orig_expr
= expr
;
1129 tree types_memoized
= NULL_TREE
;
1130 tree type
= TREE_TYPE (expr
);
1131 tree last_rval
= NULL_TREE
;
1133 if (type
== error_mark_node
)
1134 return error_mark_node
;
1136 if (processing_template_decl
)
1138 if (type_dependent_expression_p (expr
))
1139 return build_min_nt (ARROW_EXPR
, expr
);
1140 expr
= build_non_dependent_expr (expr
);
1143 if (IS_AGGR_TYPE (type
))
1145 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1146 NULL_TREE
, NULL_TREE
,
1147 /*overloaded_p=*/NULL
)))
1149 if (expr
== error_mark_node
)
1150 return error_mark_node
;
1152 if (value_member (TREE_TYPE (expr
), types_memoized
))
1154 error ("circular pointer delegation detected");
1155 return error_mark_node
;
1159 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1165 if (last_rval
== NULL_TREE
)
1167 error ("base operand of %<->%> has non-pointer type %qT", type
);
1168 return error_mark_node
;
1171 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1172 last_rval
= convert_from_reference (last_rval
);
1175 last_rval
= decay_conversion (expr
);
1177 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1179 if (processing_template_decl
)
1181 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1182 /* It will be dereferenced. */
1183 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1187 return build_indirect_ref (last_rval
, NULL
);
1191 error ("result of %<operator->()%> yields non-pointer result");
1193 error ("base operand of %<->%> is not a pointer");
1194 return error_mark_node
;
1197 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1198 already been checked out to be of aggregate type. */
1201 build_m_component_ref (tree datum
, tree component
)
1209 if (error_operand_p (datum
) || error_operand_p (component
))
1210 return error_mark_node
;
1212 ptrmem_type
= TREE_TYPE (component
);
1213 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1215 error ("%qE cannot be used as a member pointer, since it is of "
1217 component
, ptrmem_type
);
1218 return error_mark_node
;
1221 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1222 if (! IS_AGGR_TYPE (objtype
))
1224 error ("cannot apply member pointer %qE to %qE, which is of "
1225 "non-class type %qT",
1226 component
, datum
, objtype
);
1227 return error_mark_node
;
1230 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1231 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1233 if (!COMPLETE_TYPE_P (ctype
))
1235 if (!same_type_p (ctype
, objtype
))
1241 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1246 error ("pointer to member type %qT incompatible with object "
1249 return error_mark_node
;
1251 else if (binfo
== error_mark_node
)
1252 return error_mark_node
;
1255 if (TYPE_PTRMEM_P (ptrmem_type
))
1257 /* Compute the type of the field, as described in [expr.ref].
1258 There's no such thing as a mutable pointer-to-member, so
1259 things are not as complex as they are for references to
1260 non-static data members. */
1261 type
= cp_build_qualified_type (type
,
1262 (cp_type_quals (type
)
1263 | cp_type_quals (TREE_TYPE (datum
))));
1265 datum
= build_address (datum
);
1267 /* Convert object to the correct base. */
1269 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1271 /* Build an expression for "object + offset" where offset is the
1272 value stored in the pointer-to-data-member. */
1273 datum
= build2 (PLUS_EXPR
, build_pointer_type (type
),
1274 datum
, build_nop (ptrdiff_type_node
, component
));
1275 return build_indirect_ref (datum
, 0);
1278 return build2 (OFFSET_REF
, type
, datum
, component
);
1281 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1284 build_functional_cast (tree exp
, tree parms
)
1286 /* This is either a call to a constructor,
1287 or a C cast in C++'s `functional' notation. */
1290 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1291 return error_mark_node
;
1293 if (TREE_CODE (exp
) == TYPE_DECL
)
1294 type
= TREE_TYPE (exp
);
1298 if (processing_template_decl
)
1300 tree t
= build_min (CAST_EXPR
, type
, parms
);
1301 /* We don't know if it will or will not have side effects. */
1302 TREE_SIDE_EFFECTS (t
) = 1;
1306 if (! IS_AGGR_TYPE (type
))
1308 if (parms
== NULL_TREE
)
1309 return cp_convert (type
, integer_zero_node
);
1311 /* This must build a C cast. */
1312 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1313 return build_c_cast (type
, parms
);
1316 /* Prepare to evaluate as a call to a constructor. If this expression
1317 is actually used, for example,
1319 return X (arg1, arg2, ...);
1321 then the slot being initialized will be filled in. */
1323 if (!complete_type_or_else (type
, NULL_TREE
))
1324 return error_mark_node
;
1325 if (abstract_virtuals_error (NULL_TREE
, type
))
1326 return error_mark_node
;
1328 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1329 return build_c_cast (type
, TREE_VALUE (parms
));
1331 /* We need to zero-initialize POD types. Let's do that for everything
1332 that doesn't need a constructor. */
1333 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1334 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1336 exp
= build_constructor (type
, NULL
);
1337 return get_target_expr (exp
);
1340 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1341 type
, LOOKUP_NORMAL
);
1343 if (exp
== error_mark_node
)
1344 return error_mark_node
;
1346 return build_cplus_new (type
, exp
);
1350 /* Add new exception specifier SPEC, to the LIST we currently have.
1351 If it's already in LIST then do nothing.
1352 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1353 know what we're doing. */
1356 add_exception_specifier (tree list
, tree spec
, int complain
)
1361 int diag_type
= -1; /* none */
1363 if (spec
== error_mark_node
)
1366 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1368 /* [except.spec] 1, type in an exception specifier shall not be
1369 incomplete, or pointer or ref to incomplete other than pointer
1371 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1372 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1373 core
= TREE_TYPE (core
);
1376 else if (VOID_TYPE_P (core
))
1378 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1380 else if (processing_template_decl
)
1385 /* 15.4/1 says that types in an exception specifier must be complete,
1386 but it seems more reasonable to only require this on definitions
1387 and calls. So just give a pedwarn at this point; we will give an
1388 error later if we hit one of those two cases. */
1389 if (!COMPLETE_TYPE_P (complete_type (core
)))
1390 diag_type
= 2; /* pedwarn */
1397 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1398 if (same_type_p (TREE_VALUE (probe
), spec
))
1401 list
= tree_cons (NULL_TREE
, spec
, list
);
1404 diag_type
= 0; /* error */
1406 if (diag_type
>= 0 && complain
)
1407 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1412 /* Combine the two exceptions specifier lists LIST and ADD, and return
1416 merge_exception_specifiers (tree list
, tree add
)
1420 else if (!TREE_VALUE (list
))
1422 else if (!TREE_VALUE (add
))
1426 tree orig_list
= list
;
1428 for (; add
; add
= TREE_CHAIN (add
))
1430 tree spec
= TREE_VALUE (add
);
1433 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1434 if (same_type_p (TREE_VALUE (probe
), spec
))
1438 spec
= build_tree_list (NULL_TREE
, spec
);
1439 TREE_CHAIN (spec
) = list
;
1447 /* Subroutine of build_call. Ensure that each of the types in the
1448 exception specification is complete. Technically, 15.4/1 says that
1449 they need to be complete when we see a declaration of the function,
1450 but we should be able to get away with only requiring this when the
1451 function is defined or called. See also add_exception_specifier. */
1454 require_complete_eh_spec_types (tree fntype
, tree decl
)
1457 /* Don't complain about calls to op new. */
1458 if (decl
&& DECL_ARTIFICIAL (decl
))
1460 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1461 raises
= TREE_CHAIN (raises
))
1463 tree type
= TREE_VALUE (raises
);
1464 if (type
&& !COMPLETE_TYPE_P (type
))
1468 ("call to function %qD which throws incomplete type %q#T",
1471 error ("call to function which throws incomplete type %q#T",
1478 #include "gt-cp-typeck2.h"