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
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
= val
;
149 return (hashval_t
) TYPE_UID (pat
->type
);
153 /* Compare node VAL1 with the type VAL2. This function is used by the
154 hash table abstract_pending_vars. */
157 pat_compare (const void* val1
, const void* val2
)
159 const struct pending_abstract_type
* pat1
= val1
;
160 tree type2
= (tree
)val2
;
162 return (pat1
->type
== type2
);
165 /* Hash table that maintains pending_abstract_type nodes, for which we still
166 need to check for type abstractness. The key of the table is the type
167 of the declaration. */
168 static GTY ((param_is (struct pending_abstract_type
)))
169 htab_t abstract_pending_vars
= NULL
;
172 /* This function is called after TYPE is completed, and will check if there
173 are pending declarations for which we still need to verify the abstractness
174 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
175 turned out to be incomplete. */
178 complete_type_check_abstract (tree type
)
181 struct pending_abstract_type
*pat
;
182 location_t cur_loc
= input_location
;
184 gcc_assert (COMPLETE_TYPE_P (type
));
186 if (!abstract_pending_vars
)
189 /* Retrieve the list of pending declarations for this type. */
190 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
191 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
194 pat
= (struct pending_abstract_type
*)*slot
;
197 /* If the type is not abstract, do not do anything. */
198 if (CLASSTYPE_PURE_VIRTUALS (type
))
200 struct pending_abstract_type
*prev
= 0, *next
;
202 /* Reverse the list to emit the errors in top-down order. */
203 for (; pat
; pat
= next
)
211 /* Go through the list, and call abstract_virtuals_error for each
212 element: it will issue a diagnostic if the type is abstract. */
215 gcc_assert (type
== pat
->type
);
217 /* Tweak input_location so that the diagnostic appears at the correct
218 location. Notice that this is only needed if the decl is an
220 input_location
= pat
->locus
;
221 abstract_virtuals_error (pat
->decl
, pat
->type
);
226 htab_clear_slot (abstract_pending_vars
, slot
);
228 input_location
= cur_loc
;
232 /* If TYPE has abstract virtual functions, issue an error about trying
233 to create an object of that type. DECL is the object declared, or
234 NULL_TREE if the declaration is unavailable. Returns 1 if an error
235 occurred; zero if all was well. */
238 abstract_virtuals_error (tree decl
, tree type
)
242 /* This function applies only to classes. Any other entity can never
244 if (!CLASS_TYPE_P (type
))
247 /* If the type is incomplete, we register it within a hash table,
248 so that we can check again once it is completed. This makes sense
249 only for objects for which we have a declaration or at least a
251 if (!COMPLETE_TYPE_P (type
))
254 struct pending_abstract_type
*pat
;
256 gcc_assert (!decl
|| DECL_P (decl
)
257 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
259 if (!abstract_pending_vars
)
260 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
263 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
264 (hashval_t
)TYPE_UID (type
), INSERT
);
266 pat
= GGC_NEW (struct pending_abstract_type
);
269 pat
->locus
= ((decl
&& DECL_P (decl
))
270 ? DECL_SOURCE_LOCATION (decl
)
279 if (!TYPE_SIZE (type
))
280 /* TYPE is being defined, and during that time
281 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
284 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
290 if (TREE_CODE (decl
) == RESULT_DECL
)
293 if (TREE_CODE (decl
) == VAR_DECL
)
294 error ("cannot declare variable %q+D to be of abstract "
295 "type %qT", decl
, type
);
296 else if (TREE_CODE (decl
) == PARM_DECL
)
297 error ("cannot declare parameter %q+D to be of abstract type %qT",
299 else if (TREE_CODE (decl
) == FIELD_DECL
)
300 error ("cannot declare field %q+D to be of abstract type %qT",
302 else if (TREE_CODE (decl
) == FUNCTION_DECL
303 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
304 error ("invalid abstract return type for member function %q+#D", decl
);
305 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
306 error ("invalid abstract return type for function %q+#D", decl
);
307 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
308 /* Here we do not have location information. */
309 error ("invalid abstract type %qT for %qE", type
, decl
);
311 error ("invalid abstract type for %q+D", decl
);
314 error ("cannot allocate an object of abstract type %qT", type
);
316 /* Only go through this once. */
317 if (VEC_length (tree
, pure
))
322 inform ("%J because the following virtual functions are pure "
323 "within %qT:", TYPE_MAIN_DECL (type
), type
);
325 for (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
326 inform ("\t%+#D", fn
);
327 /* Now truncate the vector. This leaves it non-null, so we know
328 there are pure virtuals, but empty so we don't list them out
330 VEC_truncate (tree
, pure
, 0);
333 inform ("%J since type %qT has pure virtual functions",
334 TYPE_MAIN_DECL (type
), type
);
339 /* Print an error message for invalid use of an incomplete type.
340 VALUE is the expression that was used (or 0 if that isn't known)
341 and TYPE is the type that was invalid. DIAG_TYPE indicates the
342 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
346 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
349 void (*p_msg
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
353 else if (diag_type
== 2)
358 /* Avoid duplicate error message. */
359 if (TREE_CODE (type
) == ERROR_MARK
)
362 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
363 || TREE_CODE (value
) == PARM_DECL
364 || TREE_CODE (value
) == FIELD_DECL
))
366 p_msg ("%q+D has incomplete type", value
);
370 /* We must print an error message. Be clever about what it says. */
372 switch (TREE_CODE (type
))
378 p_msg ("invalid use of undefined type %q#T", type
);
379 if (!TYPE_TEMPLATE_INFO (type
))
380 p_msg ("forward declaration of %q+#T", type
);
382 p_msg ("declaration of %q+#T", type
);
386 p_msg ("invalid use of %qT", type
);
390 if (TYPE_DOMAIN (type
))
392 type
= TREE_TYPE (type
);
395 p_msg ("invalid use of array with unspecified bounds");
400 p_msg ("invalid use of member (did you forget the %<&%> ?)");
403 case TEMPLATE_TYPE_PARM
:
404 p_msg ("invalid use of template type parameter");
408 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
410 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
411 p_msg ("address of overloaded function with no contextual "
413 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
414 p_msg ("overloaded function with no contextual type information");
416 p_msg ("insufficient contextual information to determine type");
424 /* Backward-compatibility interface to incomplete_type_diagnostic;
425 required by ../tree.c. */
426 #undef cxx_incomplete_type_error
428 cxx_incomplete_type_error (tree value
, tree type
)
430 cxx_incomplete_type_diagnostic (value
, type
, 0);
434 /* The recursive part of split_nonconstant_init. DEST is an lvalue
435 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
438 split_nonconstant_init_1 (tree dest
, tree init
)
440 unsigned HOST_WIDE_INT idx
;
441 tree field_index
, value
;
442 tree type
= TREE_TYPE (dest
);
443 tree inner_type
= NULL
;
444 bool array_type_p
= false;
446 switch (TREE_CODE (type
))
449 inner_type
= TREE_TYPE (type
);
455 case QUAL_UNION_TYPE
:
456 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
459 /* The current implementation of this algorithm assumes that
460 the field was set for all the elements. This is usually done
461 by process_init_constructor. */
462 gcc_assert (field_index
);
465 inner_type
= TREE_TYPE (field_index
);
467 if (TREE_CODE (value
) == CONSTRUCTOR
)
472 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
473 NULL_TREE
, NULL_TREE
);
475 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
478 split_nonconstant_init_1 (sub
, value
);
480 else if (!initializer_constant_valid_p (value
, inner_type
))
485 /* FIXME: Ordered removal is O(1) so the whole function is
486 worst-case quadratic. This could be fixed using an aside
487 bitmap to record which elements must be removed and remove
488 them all at the same time. Or by merging
489 split_non_constant_init into process_init_constructor_array,
490 that is separating constants from non-constants while building
492 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
497 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
498 NULL_TREE
, NULL_TREE
);
500 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
503 code
= build2 (MODIFY_EXPR
, inner_type
, sub
, value
);
504 code
= build_stmt (EXPR_STMT
, code
);
512 if (!initializer_constant_valid_p (init
, type
))
515 tree cons
= copy_node (init
);
516 CONSTRUCTOR_ELTS (init
) = NULL
;
517 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
518 code
= build_stmt (EXPR_STMT
, code
);
528 /* A subroutine of store_init_value. Splits non-constant static
529 initializer INIT into a constant part and generates code to
530 perform the non-constant part of the initialization to DEST.
531 Returns the code for the runtime init. */
534 split_nonconstant_init (tree dest
, tree init
)
538 if (TREE_CODE (init
) == CONSTRUCTOR
)
540 code
= push_stmt_list ();
541 split_nonconstant_init_1 (dest
, init
);
542 code
= pop_stmt_list (code
);
543 DECL_INITIAL (dest
) = init
;
544 TREE_READONLY (dest
) = 0;
547 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
552 /* Perform appropriate conversions on the initial value of a variable,
553 store it in the declaration DECL,
554 and print any error messages that are appropriate.
555 If the init is invalid, store an ERROR_MARK.
557 C++: Note that INIT might be a TREE_LIST, which would mean that it is
558 a base class initializer for some aggregate type, hopefully compatible
559 with DECL. If INIT is a single element, and DECL is an aggregate
560 type, we silently convert INIT into a TREE_LIST, allowing a constructor
563 If INIT is a TREE_LIST and there is no constructor, turn INIT
564 into a CONSTRUCTOR and use standard initialization techniques.
565 Perhaps a warning should be generated?
567 Returns code to be executed if initialization could not be performed
568 for static variable. In that case, caller must emit the code. */
571 store_init_value (tree decl
, tree init
)
575 /* If variable's type was invalidly declared, just ignore it. */
577 type
= TREE_TYPE (decl
);
578 if (TREE_CODE (type
) == ERROR_MARK
)
581 if (IS_AGGR_TYPE (type
))
583 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
584 || TREE_CODE (init
) == CONSTRUCTOR
);
586 if (TREE_CODE (init
) == TREE_LIST
)
588 error ("constructor syntax used, but no constructor declared "
589 "for type %qT", type
);
590 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
593 else if (TREE_CODE (init
) == TREE_LIST
594 && TREE_TYPE (init
) != unknown_type_node
)
596 if (TREE_CODE (decl
) == RESULT_DECL
)
597 init
= build_x_compound_expr_from_list (init
,
598 "return value initializer");
599 else if (TREE_CODE (init
) == TREE_LIST
600 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
602 error ("cannot initialize arrays using this syntax");
606 /* We get here with code like `int a (2);' */
607 init
= build_x_compound_expr_from_list (init
, "initializer");
610 /* End of special C++ code. */
612 /* Digest the specified initializer into an expression. */
613 value
= digest_init (type
, init
);
614 /* If the initializer is not a constant, fill in DECL_INITIAL with
615 the bits that are constant, and then return an expression that
616 will perform the dynamic initialization. */
617 if (value
!= error_mark_node
618 && (TREE_SIDE_EFFECTS (value
)
619 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
620 return split_nonconstant_init (decl
, value
);
621 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
622 is an automatic variable, the middle end will turn this into a
623 dynamic initialization later. */
624 DECL_INITIAL (decl
) = value
;
629 /* Process the initializer INIT for a variable of type TYPE, emitting
630 diagnostics for invalid initializers and converting the initializer as
633 For aggregate types, it assumes that reshape_init has already run, thus the
634 initializer will have the right shape (brace elision has been undone). */
637 digest_init (tree type
, tree init
)
639 enum tree_code code
= TREE_CODE (type
);
641 if (init
== error_mark_node
)
642 return error_mark_node
;
646 /* We must strip the outermost array type when completing the type,
647 because the its bounds might be incomplete at the moment. */
648 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
649 ? TREE_TYPE (type
) : type
, NULL_TREE
))
650 return error_mark_node
;
652 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
653 (g++.old-deja/g++.law/casts2.C). */
654 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
655 init
= TREE_OPERAND (init
, 0);
657 /* Initialization of an array of chars from a string constant. The initializer
658 can be optionally enclosed in braces, but reshape_init has already removed
659 them if they were present. */
660 if (code
== ARRAY_TYPE
)
662 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
663 if (char_type_p (typ1
)
665 && TREE_CODE (init
) == STRING_CST
)
667 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
669 if (char_type
!= char_type_node
670 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
672 error ("char-array initialized from wide string");
673 return error_mark_node
;
675 if (char_type
== char_type_node
676 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
678 error ("int-array initialized from non-wide string");
679 return error_mark_node
;
682 TREE_TYPE (init
) = type
;
683 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
685 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
686 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
687 /* In C it is ok to subtract 1 from the length of the string
688 because it's ok to ignore the terminating null char that is
689 counted in the length of the constant, but in C++ this would
691 if (size
< TREE_STRING_LENGTH (init
))
692 pedwarn ("initializer-string for array of chars is too long");
698 /* Handle scalar types (including conversions) and references. */
699 if (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
)
700 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
701 "initialization", NULL_TREE
, 0);
703 /* Come here only for aggregates: records, arrays, unions, complex numbers
705 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
706 || TREE_CODE (type
) == VECTOR_TYPE
707 || TREE_CODE (type
) == RECORD_TYPE
708 || TREE_CODE (type
) == UNION_TYPE
709 || TREE_CODE (type
) == COMPLEX_TYPE
);
711 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
712 return process_init_constructor (type
, init
);
715 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
717 error ("cannot initialize aggregate of type %qT with "
718 "a compound literal", type
);
720 return error_mark_node
;
722 return convert_for_initialization (NULL_TREE
, type
, init
,
723 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
724 "initialization", NULL_TREE
, 0);
729 /* Set of flags used within process_init_constructor to describe the
731 #define PICFLAG_ERRONEOUS 1
732 #define PICFLAG_NOT_ALL_CONSTANT 2
733 #define PICFLAG_NOT_ALL_SIMPLE 4
735 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
739 picflag_from_initializer (tree init
)
741 if (init
== error_mark_node
)
742 return PICFLAG_ERRONEOUS
;
743 else if (!TREE_CONSTANT (init
))
744 return PICFLAG_NOT_ALL_CONSTANT
;
745 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
746 return PICFLAG_NOT_ALL_SIMPLE
;
750 /* Subroutine of process_init_constructor, which will process an initializer
751 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which
752 describe the initializers. */
755 process_init_constructor_array (tree type
, tree init
)
757 unsigned HOST_WIDE_INT i
, len
= 0;
759 bool unbounded
= false;
761 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
763 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
764 || TREE_CODE (type
) == VECTOR_TYPE
);
766 if (TREE_CODE (type
) == ARRAY_TYPE
)
768 tree domain
= TYPE_DOMAIN (type
);
770 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
771 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
774 unbounded
= true; /* Take as many as there are. */
777 /* Vectors are like simple fixed-size arrays. */
778 len
= TYPE_VECTOR_SUBPARTS (type
);
780 /* There cannot be more initializers than needed (or reshape_init would
781 detect this before we do. */
783 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
785 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
789 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
790 if (compare_tree_int (ce
->index
, i
) != 0)
791 sorry ("non-trivial designated initializers not supported");
794 ce
->index
= size_int (i
);
795 gcc_assert (ce
->value
);
796 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
798 if (ce
->value
!= error_mark_node
)
799 gcc_assert (same_type_ignoring_top_level_qualifiers_p
800 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
802 flags
|= picflag_from_initializer (ce
->value
);
805 /* No more initializers. If the array is unbounded, we are done. Otherwise,
806 we must add initializers ourselves. */
812 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
814 /* If this type needs constructors run for default-initialization,
815 we can't rely on the backend to do it for us, so build up
816 TARGET_EXPRs. If the type in question is a class, just build
817 one up; if it's an array, recurse. */
818 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
819 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
821 next
= build_constructor (NULL_TREE
, NULL
);
822 next
= digest_init (TREE_TYPE (type
), next
);
824 else if (!zero_init_p (TREE_TYPE (type
)))
825 next
= build_zero_init (TREE_TYPE (type
),
827 /*static_storage_p=*/false);
829 /* The default zero-initialization is fine for us; don't
830 add anything to the CONSTRUCTOR. */
833 flags
|= picflag_from_initializer (next
);
834 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
837 CONSTRUCTOR_ELTS (init
) = v
;
841 /* Subroutine of process_init_constructor, which will process an initializer
842 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
846 process_init_constructor_record (tree type
, tree init
)
848 VEC(constructor_elt
,gc
) *v
= NULL
;
851 unsigned HOST_WIDE_INT idx
= 0;
853 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
854 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
855 gcc_assert (!TYPE_BINFO (type
)
856 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
857 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
859 /* Generally, we will always have an index for each initializer (which is
860 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
861 reshape_init. So we need to handle both cases. */
862 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
866 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
868 flags
|= picflag_from_initializer (integer_zero_node
);
869 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
873 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
876 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
878 constructor_elt
*ce
= VEC_index (constructor_elt
,
879 CONSTRUCTOR_ELTS (init
), idx
);
882 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
883 latter case can happen in templates where lookup has to be
885 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
886 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
887 if (ce
->index
!= field
888 && ce
->index
!= DECL_NAME (field
))
889 sorry ("non-trivial designated initializers not supported");
892 gcc_assert (ce
->value
);
893 next
= digest_init (TREE_TYPE (field
), ce
->value
);
896 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
898 /* If this type needs constructors run for
899 default-initialization, we can't rely on the backend to do it
900 for us, so build up TARGET_EXPRs. If the type in question is
901 a class, just build one up; if it's an array, recurse. */
902 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
903 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
);
905 next
= build_constructor (NULL_TREE
, NULL
);
907 next
= digest_init (TREE_TYPE (field
), next
);
909 /* Warn when some struct elements are implicitly initialized. */
910 warning (OPT_Wmissing_field_initializers
,
911 "missing initializer for member %qD", field
);
915 if (TREE_READONLY (field
))
916 error ("uninitialized const member %qD", field
);
917 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
918 error ("member %qD with uninitialized const fields", field
);
919 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
920 error ("member %qD is uninitialized reference", field
);
922 /* Warn when some struct elements are implicitly initialized
924 warning (OPT_Wmissing_field_initializers
,
925 "missing initializer for member %qD", field
);
927 if (!zero_init_p (TREE_TYPE (field
)))
928 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
929 /*static_storage_p=*/false);
931 /* The default zero-initialization is fine for us; don't
932 add anything to the CONSTRUCTOR. */
936 flags
|= picflag_from_initializer (next
);
937 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
940 CONSTRUCTOR_ELTS (init
) = v
;
944 /* Subroutine of process_init_constructor, which will process a single
945 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
946 which describe the initializer. */
949 process_init_constructor_union (tree type
, tree init
)
953 /* If the initializer was empty, use default zero initialization. */
954 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
957 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
958 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
960 /* If this element specifies a field, initialize via that field. */
963 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
965 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
967 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
968 tree name
= ce
->index
;
970 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
971 if (DECL_NAME (field
) == name
)
975 error ("no field %qD found in union being initialized", field
);
976 ce
->value
= error_mark_node
;
982 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
983 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
984 error ("index value instead of field name in union initializer");
985 ce
->value
= error_mark_node
;
990 /* Find the first named field. ANSI decided in September 1990
991 that only named fields count here. */
992 tree field
= TYPE_FIELDS (type
);
993 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
994 field
= TREE_CHAIN (field
);
999 if (ce
->value
&& ce
->value
!= error_mark_node
)
1000 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1002 return picflag_from_initializer (ce
->value
);
1005 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1006 constructor is a brace-enclosed initializer, and will be modified in-place.
1008 Each element is converted to the right type through digest_init, and
1009 missing initializers are added following the language rules (zero-padding,
1012 After the execution, the initializer will have TREE_CONSTANT if all elts are
1013 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1014 constants that the assembler and linker can compute them.
1016 The function returns the initializer itself, or error_mark_node in case
1020 process_init_constructor (tree type
, tree init
)
1024 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1026 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1027 flags
= process_init_constructor_array (type
, init
);
1028 else if (TREE_CODE (type
) == RECORD_TYPE
)
1029 flags
= process_init_constructor_record (type
, init
);
1030 else if (TREE_CODE (type
) == UNION_TYPE
)
1031 flags
= process_init_constructor_union (type
, init
);
1035 if (flags
& PICFLAG_ERRONEOUS
)
1036 return error_mark_node
;
1038 TREE_TYPE (init
) = type
;
1039 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1040 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1041 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1043 TREE_CONSTANT (init
) = 1;
1044 TREE_INVARIANT (init
) = 1;
1045 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1046 TREE_STATIC (init
) = 1;
1051 /* Given a structure or union value DATUM, construct and return
1052 the structure or union component which results from narrowing
1053 that value to the base specified in BASETYPE. For example, given the
1056 class L { int ii; };
1057 class A : L { ... };
1058 class B : L { ... };
1059 class C : A, B { ... };
1067 x.A::ii refers to the ii member of the L part of
1068 the A part of the C object named by X. In this case,
1069 DATUM would be x, and BASETYPE would be A.
1071 I used to think that this was nonconformant, that the standard specified
1072 that first we look up ii in A, then convert x to an L& and pull out the
1073 ii part. But in fact, it does say that we convert x to an A&; A here
1074 is known as the "naming class". (jason 2000-12-19)
1076 BINFO_P points to a variable initialized either to NULL_TREE or to the
1077 binfo for the specific base subobject we want to convert to. */
1080 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1084 if (datum
== error_mark_node
)
1085 return error_mark_node
;
1089 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1091 if (!binfo
|| binfo
== error_mark_node
)
1093 *binfo_p
= NULL_TREE
;
1095 error_not_base_type (basetype
, TREE_TYPE (datum
));
1096 return error_mark_node
;
1100 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1103 /* Build a reference to an object specified by the C++ `->' operator.
1104 Usually this just involves dereferencing the object, but if the
1105 `->' operator is overloaded, then such overloads must be
1106 performed until an object which does not have the `->' operator
1107 overloaded is found. An error is reported when circular pointer
1108 delegation is detected. */
1111 build_x_arrow (tree expr
)
1113 tree orig_expr
= expr
;
1114 tree types_memoized
= NULL_TREE
;
1115 tree type
= TREE_TYPE (expr
);
1116 tree last_rval
= NULL_TREE
;
1118 if (type
== error_mark_node
)
1119 return error_mark_node
;
1121 if (processing_template_decl
)
1123 if (type_dependent_expression_p (expr
))
1124 return build_min_nt (ARROW_EXPR
, expr
);
1125 expr
= build_non_dependent_expr (expr
);
1128 if (IS_AGGR_TYPE (type
))
1130 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1131 NULL_TREE
, NULL_TREE
,
1132 /*overloaded_p=*/NULL
)))
1134 if (expr
== error_mark_node
)
1135 return error_mark_node
;
1137 if (value_member (TREE_TYPE (expr
), types_memoized
))
1139 error ("circular pointer delegation detected");
1140 return error_mark_node
;
1144 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1150 if (last_rval
== NULL_TREE
)
1152 error ("base operand of %<->%> has non-pointer type %qT", type
);
1153 return error_mark_node
;
1156 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1157 last_rval
= convert_from_reference (last_rval
);
1160 last_rval
= decay_conversion (expr
);
1162 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1164 if (processing_template_decl
)
1166 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1167 /* It will be dereferenced. */
1168 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1172 return build_indirect_ref (last_rval
, NULL
);
1176 error ("result of %<operator->()%> yields non-pointer result");
1178 error ("base operand of %<->%> is not a pointer");
1179 return error_mark_node
;
1182 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1183 already been checked out to be of aggregate type. */
1186 build_m_component_ref (tree datum
, tree component
)
1194 datum
= decay_conversion (datum
);
1196 if (datum
== error_mark_node
|| component
== error_mark_node
)
1197 return error_mark_node
;
1199 ptrmem_type
= TREE_TYPE (component
);
1200 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1202 error ("%qE cannot be used as a member pointer, since it is of "
1204 component
, ptrmem_type
);
1205 return error_mark_node
;
1208 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1209 if (! IS_AGGR_TYPE (objtype
))
1211 error ("cannot apply member pointer %qE to %qE, which is of "
1212 "non-aggregate type %qT",
1213 component
, datum
, objtype
);
1214 return error_mark_node
;
1217 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1218 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1220 if (!COMPLETE_TYPE_P (ctype
))
1222 if (!same_type_p (ctype
, objtype
))
1228 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1233 error ("pointer to member type %qT incompatible with object "
1236 return error_mark_node
;
1238 else if (binfo
== error_mark_node
)
1239 return error_mark_node
;
1242 if (TYPE_PTRMEM_P (ptrmem_type
))
1244 /* Compute the type of the field, as described in [expr.ref].
1245 There's no such thing as a mutable pointer-to-member, so
1246 things are not as complex as they are for references to
1247 non-static data members. */
1248 type
= cp_build_qualified_type (type
,
1249 (cp_type_quals (type
)
1250 | cp_type_quals (TREE_TYPE (datum
))));
1252 datum
= build_address (datum
);
1254 /* Convert object to the correct base. */
1256 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1258 /* Build an expression for "object + offset" where offset is the
1259 value stored in the pointer-to-data-member. */
1260 datum
= build2 (PLUS_EXPR
, build_pointer_type (type
),
1261 datum
, build_nop (ptrdiff_type_node
, component
));
1262 return build_indirect_ref (datum
, 0);
1265 return build2 (OFFSET_REF
, type
, datum
, component
);
1268 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1271 build_functional_cast (tree exp
, tree parms
)
1273 /* This is either a call to a constructor,
1274 or a C cast in C++'s `functional' notation. */
1277 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1278 return error_mark_node
;
1280 if (TREE_CODE (exp
) == TYPE_DECL
)
1281 type
= TREE_TYPE (exp
);
1285 if (processing_template_decl
)
1287 tree t
= build_min (CAST_EXPR
, type
, parms
);
1288 /* We don't know if it will or will not have side effects. */
1289 TREE_SIDE_EFFECTS (t
) = 1;
1293 if (! IS_AGGR_TYPE (type
))
1295 /* This must build a C cast. */
1296 if (parms
== NULL_TREE
)
1297 parms
= integer_zero_node
;
1299 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1301 return build_c_cast (type
, parms
);
1304 /* Prepare to evaluate as a call to a constructor. If this expression
1305 is actually used, for example,
1307 return X (arg1, arg2, ...);
1309 then the slot being initialized will be filled in. */
1311 if (!complete_type_or_else (type
, NULL_TREE
))
1312 return error_mark_node
;
1313 if (abstract_virtuals_error (NULL_TREE
, type
))
1314 return error_mark_node
;
1316 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1317 return build_c_cast (type
, TREE_VALUE (parms
));
1319 /* We need to zero-initialize POD types. Let's do that for everything
1320 that doesn't need a constructor. */
1321 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1322 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1324 exp
= build_constructor (type
, NULL
);
1325 return get_target_expr (exp
);
1328 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1329 type
, LOOKUP_NORMAL
);
1331 if (exp
== error_mark_node
)
1332 return error_mark_node
;
1334 return build_cplus_new (type
, exp
);
1338 /* Add new exception specifier SPEC, to the LIST we currently have.
1339 If it's already in LIST then do nothing.
1340 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1341 know what we're doing. */
1344 add_exception_specifier (tree list
, tree spec
, int complain
)
1349 int diag_type
= -1; /* none */
1351 if (spec
== error_mark_node
)
1354 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1356 /* [except.spec] 1, type in an exception specifier shall not be
1357 incomplete, or pointer or ref to incomplete other than pointer
1359 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1360 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1361 core
= TREE_TYPE (core
);
1364 else if (VOID_TYPE_P (core
))
1366 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1368 else if (processing_template_decl
)
1373 /* 15.4/1 says that types in an exception specifier must be complete,
1374 but it seems more reasonable to only require this on definitions
1375 and calls. So just give a pedwarn at this point; we will give an
1376 error later if we hit one of those two cases. */
1377 if (!COMPLETE_TYPE_P (complete_type (core
)))
1378 diag_type
= 2; /* pedwarn */
1385 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1386 if (same_type_p (TREE_VALUE (probe
), spec
))
1389 list
= tree_cons (NULL_TREE
, spec
, list
);
1392 diag_type
= 0; /* error */
1394 if (diag_type
>= 0 && complain
)
1395 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1400 /* Combine the two exceptions specifier lists LIST and ADD, and return
1404 merge_exception_specifiers (tree list
, tree add
)
1408 else if (!TREE_VALUE (list
))
1410 else if (!TREE_VALUE (add
))
1414 tree orig_list
= list
;
1416 for (; add
; add
= TREE_CHAIN (add
))
1418 tree spec
= TREE_VALUE (add
);
1421 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1422 if (same_type_p (TREE_VALUE (probe
), spec
))
1426 spec
= build_tree_list (NULL_TREE
, spec
);
1427 TREE_CHAIN (spec
) = list
;
1435 /* Subroutine of build_call. Ensure that each of the types in the
1436 exception specification is complete. Technically, 15.4/1 says that
1437 they need to be complete when we see a declaration of the function,
1438 but we should be able to get away with only requiring this when the
1439 function is defined or called. See also add_exception_specifier. */
1442 require_complete_eh_spec_types (tree fntype
, tree decl
)
1445 /* Don't complain about calls to op new. */
1446 if (decl
&& DECL_ARTIFICIAL (decl
))
1448 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1449 raises
= TREE_CHAIN (raises
))
1451 tree type
= TREE_VALUE (raises
);
1452 if (type
&& !COMPLETE_TYPE_P (type
))
1456 ("call to function %qD which throws incomplete type %q#T",
1459 error ("call to function which throws incomplete type %q#T",
1466 #include "gt-cp-typeck2.h"