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
= 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
);
527 /* The rest of the initializer is now a constant. */
528 TREE_CONSTANT (init
) = 1;
531 /* A subroutine of store_init_value. Splits non-constant static
532 initializer INIT into a constant part and generates code to
533 perform the non-constant part of the initialization to DEST.
534 Returns the code for the runtime init. */
537 split_nonconstant_init (tree dest
, tree init
)
541 if (TREE_CODE (init
) == CONSTRUCTOR
)
543 code
= push_stmt_list ();
544 split_nonconstant_init_1 (dest
, init
);
545 code
= pop_stmt_list (code
);
546 DECL_INITIAL (dest
) = init
;
547 TREE_READONLY (dest
) = 0;
550 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
555 /* Perform appropriate conversions on the initial value of a variable,
556 store it in the declaration DECL,
557 and print any error messages that are appropriate.
558 If the init is invalid, store an ERROR_MARK.
560 C++: Note that INIT might be a TREE_LIST, which would mean that it is
561 a base class initializer for some aggregate type, hopefully compatible
562 with DECL. If INIT is a single element, and DECL is an aggregate
563 type, we silently convert INIT into a TREE_LIST, allowing a constructor
566 If INIT is a TREE_LIST and there is no constructor, turn INIT
567 into a CONSTRUCTOR and use standard initialization techniques.
568 Perhaps a warning should be generated?
570 Returns code to be executed if initialization could not be performed
571 for static variable. In that case, caller must emit the code. */
574 store_init_value (tree decl
, tree init
)
578 /* If variable's type was invalidly declared, just ignore it. */
580 type
= TREE_TYPE (decl
);
581 if (TREE_CODE (type
) == ERROR_MARK
)
584 if (IS_AGGR_TYPE (type
))
586 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
587 || TREE_CODE (init
) == CONSTRUCTOR
);
589 if (TREE_CODE (init
) == TREE_LIST
)
591 error ("constructor syntax used, but no constructor declared "
592 "for type %qT", type
);
593 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
596 else if (TREE_CODE (init
) == TREE_LIST
597 && TREE_TYPE (init
) != unknown_type_node
)
599 if (TREE_CODE (decl
) == RESULT_DECL
)
600 init
= build_x_compound_expr_from_list (init
,
601 "return value initializer");
602 else if (TREE_CODE (init
) == TREE_LIST
603 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
605 error ("cannot initialize arrays using this syntax");
609 /* We get here with code like `int a (2);' */
610 init
= build_x_compound_expr_from_list (init
, "initializer");
613 /* End of special C++ code. */
615 /* Digest the specified initializer into an expression. */
616 value
= digest_init (type
, init
);
617 /* If the initializer is not a constant, fill in DECL_INITIAL with
618 the bits that are constant, and then return an expression that
619 will perform the dynamic initialization. */
620 if (value
!= error_mark_node
621 && (TREE_SIDE_EFFECTS (value
)
622 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
623 return split_nonconstant_init (decl
, value
);
624 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
625 is an automatic variable, the middle end will turn this into a
626 dynamic initialization later. */
627 DECL_INITIAL (decl
) = value
;
632 /* Process the initializer INIT for a variable of type TYPE, emitting
633 diagnostics for invalid initializers and converting the initializer as
636 For aggregate types, it assumes that reshape_init has already run, thus the
637 initializer will have the right shape (brace elision has been undone). */
640 digest_init (tree type
, tree init
)
642 enum tree_code code
= TREE_CODE (type
);
644 if (init
== error_mark_node
)
645 return error_mark_node
;
649 /* We must strip the outermost array type when completing the type,
650 because the its bounds might be incomplete at the moment. */
651 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
652 ? TREE_TYPE (type
) : type
, NULL_TREE
))
653 return error_mark_node
;
655 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
656 (g++.old-deja/g++.law/casts2.C). */
657 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
658 init
= TREE_OPERAND (init
, 0);
660 /* Initialization of an array of chars from a string constant. The initializer
661 can be optionally enclosed in braces, but reshape_init has already removed
662 them if they were present. */
663 if (code
== ARRAY_TYPE
)
665 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
666 if (char_type_p (typ1
)
668 && TREE_CODE (init
) == STRING_CST
)
670 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
672 if (char_type
!= char_type_node
673 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
675 error ("char-array initialized from wide string");
676 return error_mark_node
;
678 if (char_type
== char_type_node
679 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
681 error ("int-array initialized from non-wide string");
682 return error_mark_node
;
685 TREE_TYPE (init
) = type
;
686 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
688 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
689 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
690 /* In C it is ok to subtract 1 from the length of the string
691 because it's ok to ignore the terminating null char that is
692 counted in the length of the constant, but in C++ this would
694 if (size
< TREE_STRING_LENGTH (init
))
695 pedwarn ("initializer-string for array of chars is too long");
701 /* Handle scalar types (including conversions) and references. */
702 if (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
)
703 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
704 "initialization", NULL_TREE
, 0);
706 /* Come here only for aggregates: records, arrays, unions, complex numbers
708 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
709 || TREE_CODE (type
) == VECTOR_TYPE
710 || TREE_CODE (type
) == RECORD_TYPE
711 || TREE_CODE (type
) == UNION_TYPE
712 || TREE_CODE (type
) == COMPLEX_TYPE
);
714 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
715 return process_init_constructor (type
, init
);
718 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
720 error ("cannot initialize aggregate of type %qT with "
721 "a compound literal", type
);
723 return error_mark_node
;
725 return convert_for_initialization (NULL_TREE
, type
, init
,
726 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
727 "initialization", NULL_TREE
, 0);
732 /* Set of flags used within process_init_constructor to describe the
734 #define PICFLAG_ERRONEOUS 1
735 #define PICFLAG_NOT_ALL_CONSTANT 2
736 #define PICFLAG_NOT_ALL_SIMPLE 4
738 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
742 picflag_from_initializer (tree init
)
744 if (init
== error_mark_node
)
745 return PICFLAG_ERRONEOUS
;
746 else if (!TREE_CONSTANT (init
))
747 return PICFLAG_NOT_ALL_CONSTANT
;
748 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
749 return PICFLAG_NOT_ALL_SIMPLE
;
753 /* Subroutine of process_init_constructor, which will process an initializer
754 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which
755 describe the initializers. */
758 process_init_constructor_array (tree type
, tree init
)
760 unsigned HOST_WIDE_INT i
, len
= 0;
762 bool unbounded
= false;
764 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
766 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
767 || TREE_CODE (type
) == VECTOR_TYPE
);
769 if (TREE_CODE (type
) == ARRAY_TYPE
)
771 tree domain
= TYPE_DOMAIN (type
);
773 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
774 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
777 unbounded
= true; /* Take as many as there are. */
780 /* Vectors are like simple fixed-size arrays. */
781 len
= TYPE_VECTOR_SUBPARTS (type
);
783 /* There cannot be more initializers than needed (or reshape_init would
784 detect this before we do. */
786 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
788 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
792 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
793 if (compare_tree_int (ce
->index
, i
) != 0)
794 sorry ("non-trivial designated initializers not supported");
797 ce
->index
= size_int (i
);
798 gcc_assert (ce
->value
);
799 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
801 if (ce
->value
!= error_mark_node
)
802 gcc_assert (same_type_ignoring_top_level_qualifiers_p
803 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
805 flags
|= picflag_from_initializer (ce
->value
);
808 /* No more initializers. If the array is unbounded, we are done. Otherwise,
809 we must add initializers ourselves. */
815 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
817 /* If this type needs constructors run for default-initialization,
818 we can't rely on the backend to do it for us, so build up
819 TARGET_EXPRs. If the type in question is a class, just build
820 one up; if it's an array, recurse. */
821 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
822 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
824 next
= build_constructor (NULL_TREE
, NULL
);
825 next
= digest_init (TREE_TYPE (type
), next
);
827 else if (!zero_init_p (TREE_TYPE (type
)))
828 next
= build_zero_init (TREE_TYPE (type
),
830 /*static_storage_p=*/false);
832 /* The default zero-initialization is fine for us; don't
833 add anything to the CONSTRUCTOR. */
836 flags
|= picflag_from_initializer (next
);
837 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
840 CONSTRUCTOR_ELTS (init
) = v
;
844 /* Subroutine of process_init_constructor, which will process an initializer
845 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
849 process_init_constructor_record (tree type
, tree init
)
851 VEC(constructor_elt
,gc
) *v
= NULL
;
854 unsigned HOST_WIDE_INT idx
= 0;
856 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
857 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
858 gcc_assert (!TYPE_BINFO (type
)
859 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
860 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
862 /* Generally, we will always have an index for each initializer (which is
863 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
864 reshape_init. So we need to handle both cases. */
865 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
869 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
871 flags
|= picflag_from_initializer (integer_zero_node
);
872 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
876 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
879 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
881 constructor_elt
*ce
= VEC_index (constructor_elt
,
882 CONSTRUCTOR_ELTS (init
), idx
);
885 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
886 latter case can happen in templates where lookup has to be
888 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
889 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
890 if (ce
->index
!= field
891 && ce
->index
!= DECL_NAME (field
))
892 sorry ("non-trivial designated initializers not supported");
895 gcc_assert (ce
->value
);
896 next
= digest_init (TREE_TYPE (field
), ce
->value
);
899 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
901 /* If this type needs constructors run for
902 default-initialization, we can't rely on the backend to do it
903 for us, so build up TARGET_EXPRs. If the type in question is
904 a class, just build one up; if it's an array, recurse. */
905 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
906 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
);
908 next
= build_constructor (NULL_TREE
, NULL
);
910 next
= digest_init (TREE_TYPE (field
), next
);
912 /* Warn when some struct elements are implicitly initialized. */
913 warning (OPT_Wmissing_field_initializers
,
914 "missing initializer for member %qD", field
);
918 if (TREE_READONLY (field
))
919 error ("uninitialized const member %qD", field
);
920 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
921 error ("member %qD with uninitialized const fields", field
);
922 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
923 error ("member %qD is uninitialized reference", field
);
925 /* Warn when some struct elements are implicitly initialized
927 warning (OPT_Wmissing_field_initializers
,
928 "missing initializer for member %qD", field
);
930 if (!zero_init_p (TREE_TYPE (field
)))
931 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
932 /*static_storage_p=*/false);
934 /* The default zero-initialization is fine for us; don't
935 add anything to the CONSTRUCTOR. */
939 flags
|= picflag_from_initializer (next
);
940 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
943 CONSTRUCTOR_ELTS (init
) = v
;
947 /* Subroutine of process_init_constructor, which will process a single
948 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
949 which describe the initializer. */
952 process_init_constructor_union (tree type
, tree init
)
956 /* If the initializer was empty, use default zero initialization. */
957 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
960 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
961 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
963 /* If this element specifies a field, initialize via that field. */
966 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
968 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
970 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
971 tree name
= ce
->index
;
973 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
974 if (DECL_NAME (field
) == name
)
978 error ("no field %qD found in union being initialized", field
);
979 ce
->value
= error_mark_node
;
985 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
986 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
987 error ("index value instead of field name in union initializer");
988 ce
->value
= error_mark_node
;
993 /* Find the first named field. ANSI decided in September 1990
994 that only named fields count here. */
995 tree field
= TYPE_FIELDS (type
);
996 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
997 field
= TREE_CHAIN (field
);
1002 if (ce
->value
&& ce
->value
!= error_mark_node
)
1003 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1005 return picflag_from_initializer (ce
->value
);
1008 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1009 constructor is a brace-enclosed initializer, and will be modified in-place.
1011 Each element is converted to the right type through digest_init, and
1012 missing initializers are added following the language rules (zero-padding,
1015 After the execution, the initializer will have TREE_CONSTANT if all elts are
1016 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1017 constants that the assembler and linker can compute them.
1019 The function returns the initializer itself, or error_mark_node in case
1023 process_init_constructor (tree type
, tree init
)
1027 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1029 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1030 flags
= process_init_constructor_array (type
, init
);
1031 else if (TREE_CODE (type
) == RECORD_TYPE
)
1032 flags
= process_init_constructor_record (type
, init
);
1033 else if (TREE_CODE (type
) == UNION_TYPE
)
1034 flags
= process_init_constructor_union (type
, init
);
1038 if (flags
& PICFLAG_ERRONEOUS
)
1039 return error_mark_node
;
1041 TREE_TYPE (init
) = type
;
1042 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1043 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1044 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1046 TREE_CONSTANT (init
) = 1;
1047 TREE_INVARIANT (init
) = 1;
1048 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1049 TREE_STATIC (init
) = 1;
1054 /* Given a structure or union value DATUM, construct and return
1055 the structure or union component which results from narrowing
1056 that value to the base specified in BASETYPE. For example, given the
1059 class L { int ii; };
1060 class A : L { ... };
1061 class B : L { ... };
1062 class C : A, B { ... };
1070 x.A::ii refers to the ii member of the L part of
1071 the A part of the C object named by X. In this case,
1072 DATUM would be x, and BASETYPE would be A.
1074 I used to think that this was nonconformant, that the standard specified
1075 that first we look up ii in A, then convert x to an L& and pull out the
1076 ii part. But in fact, it does say that we convert x to an A&; A here
1077 is known as the "naming class". (jason 2000-12-19)
1079 BINFO_P points to a variable initialized either to NULL_TREE or to the
1080 binfo for the specific base subobject we want to convert to. */
1083 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1087 if (datum
== error_mark_node
)
1088 return error_mark_node
;
1092 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1094 if (!binfo
|| binfo
== error_mark_node
)
1096 *binfo_p
= NULL_TREE
;
1098 error_not_base_type (basetype
, TREE_TYPE (datum
));
1099 return error_mark_node
;
1103 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1106 /* Build a reference to an object specified by the C++ `->' operator.
1107 Usually this just involves dereferencing the object, but if the
1108 `->' operator is overloaded, then such overloads must be
1109 performed until an object which does not have the `->' operator
1110 overloaded is found. An error is reported when circular pointer
1111 delegation is detected. */
1114 build_x_arrow (tree expr
)
1116 tree orig_expr
= expr
;
1117 tree types_memoized
= NULL_TREE
;
1118 tree type
= TREE_TYPE (expr
);
1119 tree last_rval
= NULL_TREE
;
1121 if (type
== error_mark_node
)
1122 return error_mark_node
;
1124 if (processing_template_decl
)
1126 if (type_dependent_expression_p (expr
))
1127 return build_min_nt (ARROW_EXPR
, expr
);
1128 expr
= build_non_dependent_expr (expr
);
1131 if (IS_AGGR_TYPE (type
))
1133 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1134 NULL_TREE
, NULL_TREE
,
1135 /*overloaded_p=*/NULL
)))
1137 if (expr
== error_mark_node
)
1138 return error_mark_node
;
1140 if (value_member (TREE_TYPE (expr
), types_memoized
))
1142 error ("circular pointer delegation detected");
1143 return error_mark_node
;
1147 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1153 if (last_rval
== NULL_TREE
)
1155 error ("base operand of %<->%> has non-pointer type %qT", type
);
1156 return error_mark_node
;
1159 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1160 last_rval
= convert_from_reference (last_rval
);
1163 last_rval
= decay_conversion (expr
);
1165 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1167 if (processing_template_decl
)
1169 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1170 /* It will be dereferenced. */
1171 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1175 return build_indirect_ref (last_rval
, NULL
);
1179 error ("result of %<operator->()%> yields non-pointer result");
1181 error ("base operand of %<->%> is not a pointer");
1182 return error_mark_node
;
1185 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1186 already been checked out to be of aggregate type. */
1189 build_m_component_ref (tree datum
, tree component
)
1197 datum
= decay_conversion (datum
);
1199 if (datum
== error_mark_node
|| component
== error_mark_node
)
1200 return error_mark_node
;
1202 ptrmem_type
= TREE_TYPE (component
);
1203 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1205 error ("%qE cannot be used as a member pointer, since it is of "
1207 component
, ptrmem_type
);
1208 return error_mark_node
;
1211 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1212 if (! IS_AGGR_TYPE (objtype
))
1214 error ("cannot apply member pointer %qE to %qE, which is of "
1215 "non-aggregate type %qT",
1216 component
, datum
, objtype
);
1217 return error_mark_node
;
1220 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1221 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1223 if (!COMPLETE_TYPE_P (ctype
))
1225 if (!same_type_p (ctype
, objtype
))
1231 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1236 error ("pointer to member type %qT incompatible with object "
1239 return error_mark_node
;
1241 else if (binfo
== error_mark_node
)
1242 return error_mark_node
;
1245 if (TYPE_PTRMEM_P (ptrmem_type
))
1247 /* Compute the type of the field, as described in [expr.ref].
1248 There's no such thing as a mutable pointer-to-member, so
1249 things are not as complex as they are for references to
1250 non-static data members. */
1251 type
= cp_build_qualified_type (type
,
1252 (cp_type_quals (type
)
1253 | cp_type_quals (TREE_TYPE (datum
))));
1255 datum
= build_address (datum
);
1257 /* Convert object to the correct base. */
1259 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1261 /* Build an expression for "object + offset" where offset is the
1262 value stored in the pointer-to-data-member. */
1263 datum
= build2 (PLUS_EXPR
, build_pointer_type (type
),
1264 datum
, build_nop (ptrdiff_type_node
, component
));
1265 return build_indirect_ref (datum
, 0);
1268 return build2 (OFFSET_REF
, type
, datum
, component
);
1271 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1274 build_functional_cast (tree exp
, tree parms
)
1276 /* This is either a call to a constructor,
1277 or a C cast in C++'s `functional' notation. */
1280 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1281 return error_mark_node
;
1283 if (TREE_CODE (exp
) == TYPE_DECL
)
1284 type
= TREE_TYPE (exp
);
1288 if (processing_template_decl
)
1290 tree t
= build_min (CAST_EXPR
, type
, parms
);
1291 /* We don't know if it will or will not have side effects. */
1292 TREE_SIDE_EFFECTS (t
) = 1;
1296 if (! IS_AGGR_TYPE (type
))
1298 /* This must build a C cast. */
1299 if (parms
== NULL_TREE
)
1300 parms
= integer_zero_node
;
1302 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1304 return build_c_cast (type
, parms
);
1307 /* Prepare to evaluate as a call to a constructor. If this expression
1308 is actually used, for example,
1310 return X (arg1, arg2, ...);
1312 then the slot being initialized will be filled in. */
1314 if (!complete_type_or_else (type
, NULL_TREE
))
1315 return error_mark_node
;
1316 if (abstract_virtuals_error (NULL_TREE
, type
))
1317 return error_mark_node
;
1319 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1320 return build_c_cast (type
, TREE_VALUE (parms
));
1322 /* We need to zero-initialize POD types. Let's do that for everything
1323 that doesn't need a constructor. */
1324 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1325 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1327 exp
= build_constructor (type
, NULL
);
1328 return get_target_expr (exp
);
1331 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1332 type
, LOOKUP_NORMAL
);
1334 if (exp
== error_mark_node
)
1335 return error_mark_node
;
1337 return build_cplus_new (type
, exp
);
1341 /* Add new exception specifier SPEC, to the LIST we currently have.
1342 If it's already in LIST then do nothing.
1343 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1344 know what we're doing. */
1347 add_exception_specifier (tree list
, tree spec
, int complain
)
1352 int diag_type
= -1; /* none */
1354 if (spec
== error_mark_node
)
1357 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1359 /* [except.spec] 1, type in an exception specifier shall not be
1360 incomplete, or pointer or ref to incomplete other than pointer
1362 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1363 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1364 core
= TREE_TYPE (core
);
1367 else if (VOID_TYPE_P (core
))
1369 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1371 else if (processing_template_decl
)
1376 /* 15.4/1 says that types in an exception specifier must be complete,
1377 but it seems more reasonable to only require this on definitions
1378 and calls. So just give a pedwarn at this point; we will give an
1379 error later if we hit one of those two cases. */
1380 if (!COMPLETE_TYPE_P (complete_type (core
)))
1381 diag_type
= 2; /* pedwarn */
1388 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1389 if (same_type_p (TREE_VALUE (probe
), spec
))
1392 list
= tree_cons (NULL_TREE
, spec
, list
);
1395 diag_type
= 0; /* error */
1397 if (diag_type
>= 0 && complain
)
1398 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1403 /* Combine the two exceptions specifier lists LIST and ADD, and return
1407 merge_exception_specifiers (tree list
, tree add
)
1411 else if (!TREE_VALUE (list
))
1413 else if (!TREE_VALUE (add
))
1417 tree orig_list
= list
;
1419 for (; add
; add
= TREE_CHAIN (add
))
1421 tree spec
= TREE_VALUE (add
);
1424 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1425 if (same_type_p (TREE_VALUE (probe
), spec
))
1429 spec
= build_tree_list (NULL_TREE
, spec
);
1430 TREE_CHAIN (spec
) = list
;
1438 /* Subroutine of build_call. Ensure that each of the types in the
1439 exception specification is complete. Technically, 15.4/1 says that
1440 they need to be complete when we see a declaration of the function,
1441 but we should be able to get away with only requiring this when the
1442 function is defined or called. See also add_exception_specifier. */
1445 require_complete_eh_spec_types (tree fntype
, tree decl
)
1448 /* Don't complain about calls to op new. */
1449 if (decl
&& DECL_ARTIFICIAL (decl
))
1451 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1452 raises
= TREE_CHAIN (raises
))
1454 tree type
= TREE_VALUE (raises
);
1455 if (type
&& !COMPLETE_TYPE_P (type
))
1459 ("call to function %qD which throws incomplete type %q#T",
1462 error ("call to function which throws incomplete type %q#T",
1469 #include "gt-cp-typeck2.h"