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 %qT", type);
407 case BOUND_TEMPLATE_TEMPLATE_PARM:
408 p_msg ("invalid use of template template parameter %qT",
413 if (value && TREE_CODE (value) == COMPONENT_REF)
415 else if (value && TREE_CODE (value) == ADDR_EXPR)
416 p_msg ("address of overloaded function with no contextual "
418 else if (value && TREE_CODE (value) == OVERLOAD)
419 p_msg ("overloaded function with no contextual type information");
421 p_msg ("insufficient contextual information to determine type");
429 /* Backward-compatibility interface to incomplete_type_diagnostic;
430 required by ../tree.c. */
431 #undef cxx_incomplete_type_error
433 cxx_incomplete_type_error (tree value, tree type)
435 cxx_incomplete_type_diagnostic (value, type, 0);
439 /* The recursive part of split_nonconstant_init. DEST is an lvalue
440 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
443 split_nonconstant_init_1 (tree dest, tree init)
445 unsigned HOST_WIDE_INT idx;
446 tree field_index, value;
447 tree type = TREE_TYPE (dest);
448 tree inner_type = NULL;
449 bool array_type_p = false;
451 switch (TREE_CODE (type))
454 inner_type = TREE_TYPE (type);
460 case QUAL_UNION_TYPE:
461 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
464 /* The current implementation of this algorithm assumes that
465 the field was set for all the elements. This is usually done
466 by process_init_constructor. */
467 gcc_assert (field_index);
470 inner_type = TREE_TYPE (field_index);
472 if (TREE_CODE (value) == CONSTRUCTOR)
477 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
478 NULL_TREE, NULL_TREE);
480 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
483 split_nonconstant_init_1 (sub, value);
485 else if (!initializer_constant_valid_p (value, inner_type))
490 /* FIXME: Ordered removal is O(1) so the whole function is
491 worst-case quadratic. This could be fixed using an aside
492 bitmap to record which elements must be removed and remove
493 them all at the same time. Or by merging
494 split_non_constant_init into process_init_constructor_array,
495 that is separating constants from non-constants while building
497 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
502 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
503 NULL_TREE, NULL_TREE);
505 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
508 code = build2 (INIT_EXPR, inner_type, sub, value);
509 code = build_stmt (EXPR_STMT, code);
517 if (!initializer_constant_valid_p (init, type))
520 tree cons = copy_node (init);
521 CONSTRUCTOR_ELTS (init) = NULL;
522 code = build2 (MODIFY_EXPR, type, dest, cons);
523 code = build_stmt (EXPR_STMT, code);
533 /* A subroutine of store_init_value. Splits non-constant static
534 initializer INIT into a constant part and generates code to
535 perform the non-constant part of the initialization to DEST.
536 Returns the code for the runtime init. */
539 split_nonconstant_init (tree dest, tree init)
543 if (TREE_CODE (init) == CONSTRUCTOR)
545 code = push_stmt_list ();
546 split_nonconstant_init_1 (dest, init);
547 code = pop_stmt_list (code);
548 DECL_INITIAL (dest) = init;
549 TREE_READONLY (dest) = 0;
552 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
557 /* Perform appropriate conversions on the initial value of a variable,
558 store it in the declaration DECL,
559 and print any error messages that are appropriate.
560 If the init is invalid, store an ERROR_MARK.
562 C++: Note that INIT might be a TREE_LIST, which would mean that it is
563 a base class initializer for some aggregate type, hopefully compatible
564 with DECL. If INIT is a single element, and DECL is an aggregate
565 type, we silently convert INIT into a TREE_LIST, allowing a constructor
568 If INIT is a TREE_LIST and there is no constructor, turn INIT
569 into a CONSTRUCTOR and use standard initialization techniques.
570 Perhaps a warning should be generated?
572 Returns code to be executed if initialization could not be performed
573 for static variable. In that case, caller must emit the code. */
576 store_init_value (tree decl, tree init)
580 /* If variable's type was invalidly declared, just ignore it. */
582 type = TREE_TYPE (decl);
583 if (TREE_CODE (type) == ERROR_MARK)
586 if (IS_AGGR_TYPE (type))
588 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
589 || TREE_CODE (init) == CONSTRUCTOR);
591 if (TREE_CODE (init) == TREE_LIST)
593 error ("constructor syntax used, but no constructor declared "
594 "for type %qT", type);
595 init = build_constructor_from_list (NULL_TREE, nreverse (init));
598 else if (TREE_CODE (init) == TREE_LIST
599 && TREE_TYPE (init) != unknown_type_node)
601 if (TREE_CODE (decl) == RESULT_DECL)
602 init = build_x_compound_expr_from_list (init,
603 "return value initializer");
604 else if (TREE_CODE (init) == TREE_LIST
605 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
607 error ("cannot initialize arrays using this syntax");
611 /* We get here with code like `int a (2);' */
612 init = build_x_compound_expr_from_list (init, "initializer");
615 /* End of special C++ code. */
617 /* Digest the specified initializer into an expression. */
618 value = digest_init (type, init);
619 /* If the initializer is not a constant, fill in DECL_INITIAL with
620 the bits that are constant, and then return an expression that
621 will perform the dynamic initialization. */
622 if (value != error_mark_node
623 && (TREE_SIDE_EFFECTS (value)
624 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
625 return split_nonconstant_init (decl, value);
626 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
627 is an automatic variable, the middle end will turn this into a
628 dynamic initialization later. */
629 DECL_INITIAL (decl) = value;
634 /* Process the initializer INIT for a variable of type TYPE, emitting
635 diagnostics for invalid initializers and converting the initializer as
638 For aggregate types, it assumes that reshape_init has already run, thus the
639 initializer will have the right shape (brace elision has been undone). */
642 digest_init (tree type, tree init)
644 enum tree_code code = TREE_CODE (type);
646 if (init == error_mark_node)
647 return error_mark_node;
651 /* We must strip the outermost array type when completing the type,
652 because the its bounds might be incomplete at the moment. */
653 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
654 ? TREE_TYPE (type) : type, NULL_TREE))
655 return error_mark_node;
657 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
658 (g++.old-deja/g++.law/casts2.C). */
659 if (TREE_CODE (init) == NON_LVALUE_EXPR)
660 init = TREE_OPERAND (init, 0);
662 /* Initialization of an array of chars from a string constant. The initializer
663 can be optionally enclosed in braces, but reshape_init has already removed
664 them if they were present. */
665 if (code == ARRAY_TYPE)
667 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
668 if (char_type_p (typ1)
670 && TREE_CODE (init) == STRING_CST)
672 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
674 if (char_type != char_type_node
675 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
677 error ("char-array initialized from wide string");
678 return error_mark_node;
680 if (char_type == char_type_node
681 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
683 error ("int-array initialized from non-wide string");
684 return error_mark_node;
687 TREE_TYPE (init) = type;
688 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
690 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
691 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
692 /* In C it is ok to subtract 1 from the length of the string
693 because it's ok to ignore the terminating null char that is
694 counted in the length of the constant, but in C++ this would
696 if (size < TREE_STRING_LENGTH (init))
697 pedwarn ("initializer-string for array of chars is too long");
703 /* Handle scalar types (including conversions) and references. */
704 if (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE)
705 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
706 "initialization", NULL_TREE, 0);
708 /* Come here only for aggregates: records, arrays, unions, complex numbers
710 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
711 || TREE_CODE (type) == VECTOR_TYPE
712 || TREE_CODE (type) == RECORD_TYPE
713 || TREE_CODE (type) == UNION_TYPE
714 || TREE_CODE (type) == COMPLEX_TYPE);
716 if (BRACE_ENCLOSED_INITIALIZER_P (init))
717 return process_init_constructor (type, init);
720 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
722 error ("cannot initialize aggregate of type %qT with "
723 "a compound literal", type);
725 return error_mark_node;
728 if (TREE_CODE (type) == ARRAY_TYPE
729 && TREE_CODE (init) != CONSTRUCTOR)
731 error ("array must be initialized with a brace-enclosed"
733 return error_mark_node;
736 return convert_for_initialization (NULL_TREE, type, init,
737 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING,
738 "initialization", NULL_TREE, 0);
743 /* Set of flags used within process_init_constructor to describe the
745 #define PICFLAG_ERRONEOUS 1
746 #define PICFLAG_NOT_ALL_CONSTANT 2
747 #define PICFLAG_NOT_ALL_SIMPLE 4
749 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
753 picflag_from_initializer (tree init)
755 if (init == error_mark_node)
756 return PICFLAG_ERRONEOUS;
757 else if (!TREE_CONSTANT (init))
758 return PICFLAG_NOT_ALL_CONSTANT;
759 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
760 return PICFLAG_NOT_ALL_SIMPLE;
764 /* Subroutine of process_init_constructor, which will process an initializer
765 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which
766 describe the initializers. */
769 process_init_constructor_array (tree type, tree init)
771 unsigned HOST_WIDE_INT i, len = 0;
773 bool unbounded = false;
775 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
777 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
778 || TREE_CODE (type) == VECTOR_TYPE);
780 if (TREE_CODE (type) == ARRAY_TYPE)
782 tree domain = TYPE_DOMAIN (type);
784 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
785 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
788 unbounded = true; /* Take as many as there are. */
791 /* Vectors are like simple fixed-size arrays. */
792 len = TYPE_VECTOR_SUBPARTS (type);
794 /* There cannot be more initializers than needed (or reshape_init would
795 detect this before we do. */
797 gcc_assert (VEC_length (constructor_elt, v) <= len);
799 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
803 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
804 if (compare_tree_int (ce->index, i) != 0)
806 ce->value = error_mark_node;
807 sorry ("non-trivial designated initializers not supported");
811 ce->index = size_int (i);
812 gcc_assert (ce->value);
813 ce->value = digest_init (TREE_TYPE (type), ce->value);
815 if (ce->value != error_mark_node)
816 gcc_assert (same_type_ignoring_top_level_qualifiers_p
817 (TREE_TYPE (type), TREE_TYPE (ce->value)));
819 flags |= picflag_from_initializer (ce->value);
822 /* No more initializers. If the array is unbounded, we are done. Otherwise,
823 we must add initializers ourselves. */
829 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
831 /* If this type needs constructors run for default-initialization,
832 we can't rely on the backend to do it for us, so build up
833 TARGET_EXPRs. If the type in question is a class, just build
834 one up; if it's an array, recurse. */
835 if (IS_AGGR_TYPE (TREE_TYPE (type)))
836 next = build_functional_cast (TREE_TYPE (type), NULL_TREE);
838 next = build_constructor (NULL_TREE, NULL);
839 next = digest_init (TREE_TYPE (type), next);
841 else if (!zero_init_p (TREE_TYPE (type)))
842 next = build_zero_init (TREE_TYPE (type),
844 /*static_storage_p=*/false);
846 /* The default zero-initialization is fine for us; don't
847 add anything to the CONSTRUCTOR. */
850 flags |= picflag_from_initializer (next);
851 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
854 CONSTRUCTOR_ELTS (init) = v;
858 /* INIT is the initializer for FIELD. If FIELD is a bitfield, mask
859 INIT so that its range is bounded by that of FIELD. Returns the
860 (possibly adjusted) initializer. */
863 adjust_bitfield_initializer (tree field, tree init)
868 if (!DECL_C_BIT_FIELD (field))
871 width = tree_low_cst (DECL_SIZE (field), /*pos=*/1);
872 if (width < TYPE_PRECISION (TREE_TYPE (field)))
874 mask = build_low_bits_mask (TREE_TYPE (field), width);
875 init = cp_build_binary_op (BIT_AND_EXPR, init, mask);
880 /* Subroutine of process_init_constructor, which will process an initializer
881 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
885 process_init_constructor_record (tree type, tree init)
887 VEC(constructor_elt,gc) *v = NULL;
890 unsigned HOST_WIDE_INT idx = 0;
892 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
893 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
894 gcc_assert (!TYPE_BINFO (type)
895 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
896 gcc_assert (!TYPE_POLYMORPHIC_P (type));
898 /* Generally, we will always have an index for each initializer (which is
899 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
900 reshape_init. So we need to handle both cases. */
901 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
905 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
907 flags |= picflag_from_initializer (integer_zero_node);
908 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
912 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
915 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
917 constructor_elt *ce = VEC_index (constructor_elt,
918 CONSTRUCTOR_ELTS (init), idx);
921 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
922 latter case can happen in templates where lookup has to be
924 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
925 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
926 if (ce->index != field
927 && ce->index != DECL_NAME (field))
929 ce->value = error_mark_node;
930 sorry ("non-trivial designated initializers not supported");
934 gcc_assert (ce->value);
935 next = digest_init (TREE_TYPE (field), ce->value);
936 next = adjust_bitfield_initializer (field, next);
939 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
941 /* If this type needs constructors run for
942 default-initialization, we can't rely on the backend to do it
943 for us, so build up TARGET_EXPRs. If the type in question is
944 a class, just build one up; if it's an array, recurse. */
945 if (IS_AGGR_TYPE (TREE_TYPE (field)))
946 next = build_functional_cast (TREE_TYPE (field), NULL_TREE);
948 next = build_constructor (NULL_TREE, NULL);
950 next = digest_init (TREE_TYPE (field), next);
952 /* Warn when some struct elements are implicitly initialized. */
953 warning (OPT_Wmissing_field_initializers,
954 "missing initializer for member %qD", field);
958 if (TREE_READONLY (field))
959 error ("uninitialized const member %qD", field);
960 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
961 error ("member %qD with uninitialized const fields", field);
962 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
963 error ("member %qD is uninitialized reference", field);
965 /* Warn when some struct elements are implicitly initialized
967 warning (OPT_Wmissing_field_initializers,
968 "missing initializer for member %qD", field);
970 if (!zero_init_p (TREE_TYPE (field)))
971 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
972 /*static_storage_p=*/false);
974 /* The default zero-initialization is fine for us; don't
975 add anything to the CONSTRUCTOR. */
979 flags |= picflag_from_initializer (next);
980 CONSTRUCTOR_APPEND_ELT (v, field, next);
983 CONSTRUCTOR_ELTS (init) = v;
987 /* Subroutine of process_init_constructor, which will process a single
988 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
989 which describe the initializer. */
992 process_init_constructor_union (tree type, tree init)
996 /* If the initializer was empty, use default zero initialization. */
997 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1000 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1);
1001 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1003 /* If this element specifies a field, initialize via that field. */
1006 if (TREE_CODE (ce->index) == FIELD_DECL)
1008 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1010 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1011 tree name = ce->index;
1013 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1014 if (DECL_NAME (field) == name)
1018 error ("no field %qD found in union being initialized", field);
1019 ce->value = error_mark_node;
1025 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1026 || TREE_CODE (ce->index) == RANGE_EXPR);
1027 error ("index value instead of field name in union initializer");
1028 ce->value = error_mark_node;
1033 /* Find the first named field. ANSI decided in September 1990
1034 that only named fields count here. */
1035 tree field = TYPE_FIELDS (type);
1036 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1037 field = TREE_CHAIN (field);
1040 error ("union %qT with no named members cannot be initialized",
1042 ce->value = error_mark_node;
1047 if (ce->value && ce->value != error_mark_node)
1048 ce->value = digest_init (TREE_TYPE (ce->index), ce->value);
1050 return picflag_from_initializer (ce->value);
1053 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1054 constructor is a brace-enclosed initializer, and will be modified in-place.
1056 Each element is converted to the right type through digest_init, and
1057 missing initializers are added following the language rules (zero-padding,
1060 After the execution, the initializer will have TREE_CONSTANT if all elts are
1061 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1062 constants that the assembler and linker can compute them.
1064 The function returns the initializer itself, or error_mark_node in case
1068 process_init_constructor (tree type, tree init)
1072 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1074 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1075 flags = process_init_constructor_array (type, init);
1076 else if (TREE_CODE (type) == RECORD_TYPE)
1077 flags = process_init_constructor_record (type, init);
1078 else if (TREE_CODE (type) == UNION_TYPE)
1079 flags = process_init_constructor_union (type, init);
1083 if (flags & PICFLAG_ERRONEOUS)
1084 return error_mark_node;
1086 TREE_TYPE (init) = type;
1087 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1088 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1089 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1091 TREE_CONSTANT (init) = 1;
1092 TREE_INVARIANT (init) = 1;
1093 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1094 TREE_STATIC (init) = 1;
1099 /* Given a structure or union value DATUM, construct and return
1100 the structure or union component which results from narrowing
1101 that value to the base specified in BASETYPE. For example, given the
1104 class L { int ii; };
1105 class A : L { ... };
1106 class B : L { ... };
1107 class C : A, B { ... };
1115 x.A::ii refers to the ii member of the L part of
1116 the A part of the C object named by X. In this case,
1117 DATUM would be x, and BASETYPE would be A.
1119 I used to think that this was nonconformant, that the standard specified
1120 that first we look up ii in A, then convert x to an L& and pull out the
1121 ii part. But in fact, it does say that we convert x to an A&; A here
1122 is known as the "naming class". (jason 2000-12-19)
1124 BINFO_P points to a variable initialized either to NULL_TREE or to the
1125 binfo for the specific base subobject we want to convert to. */
1128 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1132 if (datum == error_mark_node)
1133 return error_mark_node;
1137 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1139 if (!binfo || binfo == error_mark_node)
1141 *binfo_p = NULL_TREE;
1143 error_not_base_type (basetype, TREE_TYPE (datum));
1144 return error_mark_node;
1148 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1151 /* Build a reference to an object specified by the C++ `->' operator.
1152 Usually this just involves dereferencing the object, but if the
1153 `->' operator is overloaded, then such overloads must be
1154 performed until an object which does not have the `->' operator
1155 overloaded is found. An error is reported when circular pointer
1156 delegation is detected. */
1159 build_x_arrow (tree expr)
1161 tree orig_expr = expr;
1162 tree types_memoized = NULL_TREE;
1163 tree type = TREE_TYPE (expr);
1164 tree last_rval = NULL_TREE;
1166 if (type == error_mark_node)
1167 return error_mark_node;
1169 if (processing_template_decl)
1171 if (type_dependent_expression_p (expr))
1172 return build_min_nt (ARROW_EXPR, expr);
1173 expr = build_non_dependent_expr (expr);
1176 if (IS_AGGR_TYPE (type))
1178 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1179 NULL_TREE, NULL_TREE,
1180 /*overloaded_p=*/NULL)))
1182 if (expr == error_mark_node)
1183 return error_mark_node;
1185 if (value_member (TREE_TYPE (expr), types_memoized))
1187 error ("circular pointer delegation detected");
1188 return error_mark_node;
1192 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1198 if (last_rval == NULL_TREE)
1200 error ("base operand of %<->%> has non-pointer type %qT", type);
1201 return error_mark_node;
1204 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1205 last_rval = convert_from_reference (last_rval);
1208 last_rval = decay_conversion (expr);
1210 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1212 if (processing_template_decl)
1214 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1215 /* It will be dereferenced. */
1216 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1220 return build_indirect_ref (last_rval, NULL);
1224 error ("result of %<operator->()%> yields non-pointer result");
1226 error ("base operand of %<->%> is not a pointer");
1227 return error_mark_node;
1230 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1231 already been checked out to be of aggregate type. */
1234 build_m_component_ref (tree datum, tree component)
1242 datum = decay_conversion (datum);
1244 if (datum == error_mark_node || component == error_mark_node)
1245 return error_mark_node;
1247 ptrmem_type = TREE_TYPE (component);
1248 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1250 error ("%qE cannot be used as a member pointer, since it is of "
1252 component, ptrmem_type);
1253 return error_mark_node;
1256 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1257 if (! IS_AGGR_TYPE (objtype))
1259 error ("cannot apply member pointer %qE to %qE, which is of "
1260 "non-aggregate type %qT",
1261 component, datum, objtype);
1262 return error_mark_node;
1265 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1266 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1268 if (!COMPLETE_TYPE_P (ctype))
1270 if (!same_type_p (ctype, objtype))
1276 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1281 error ("pointer to member type %qT incompatible with object "
1284 return error_mark_node;
1286 else if (binfo == error_mark_node)
1287 return error_mark_node;
1290 if (TYPE_PTRMEM_P (ptrmem_type))
1292 /* Compute the type of the field, as described in [expr.ref].
1293 There's no such thing as a mutable pointer-to-member, so
1294 things are not as complex as they are for references to
1295 non-static data members. */
1296 type = cp_build_qualified_type (type,
1297 (cp_type_quals (type)
1298 | cp_type_quals (TREE_TYPE (datum))));
1300 datum = build_address (datum);
1302 /* Convert object to the correct base. */
1304 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1306 /* Build an expression for "object + offset" where offset is the
1307 value stored in the pointer-to-data-member. */
1308 datum = build2 (PLUS_EXPR, build_pointer_type (type),
1309 datum, build_nop (ptrdiff_type_node, component));
1310 return build_indirect_ref (datum, 0);
1313 return build2 (OFFSET_REF, type, datum, component);
1316 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1319 build_functional_cast (tree exp, tree parms)
1321 /* This is either a call to a constructor,
1322 or a C cast in C++'s `functional' notation. */
1325 if (exp == error_mark_node || parms == error_mark_node)
1326 return error_mark_node;
1328 if (TREE_CODE (exp) == TYPE_DECL)
1329 type = TREE_TYPE (exp);
1333 if (processing_template_decl)
1335 tree t = build_min (CAST_EXPR, type, parms);
1336 /* We don't know if it will or will not have side effects. */
1337 TREE_SIDE_EFFECTS (t) = 1;
1341 if (! IS_AGGR_TYPE (type))
1343 if (parms == NULL_TREE)
1344 return cp_convert (type, integer_zero_node);
1346 /* This must build a C cast. */
1347 parms = build_x_compound_expr_from_list (parms, "functional cast");
1348 return build_c_cast (type, parms);
1351 /* Prepare to evaluate as a call to a constructor. If this expression
1352 is actually used, for example,
1354 return X (arg1, arg2, ...);
1356 then the slot being initialized will be filled in. */
1358 if (!complete_type_or_else (type, NULL_TREE))
1359 return error_mark_node;
1360 if (abstract_virtuals_error (NULL_TREE, type))
1361 return error_mark_node;
1363 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1364 return build_c_cast (type, TREE_VALUE (parms));
1366 /* We need to zero-initialize POD types. Let's do that for everything
1367 that doesn't need a constructor. */
1368 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1369 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1371 exp = build_constructor (type, NULL);
1372 return get_target_expr (exp);
1375 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1376 type, LOOKUP_NORMAL);
1378 if (exp == error_mark_node)
1379 return error_mark_node;
1381 return build_cplus_new (type, exp);
1385 /* Add new exception specifier SPEC, to the LIST we currently have.
1386 If it's already in LIST then do nothing.
1387 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1388 know what we're doing. */
1391 add_exception_specifier (tree list, tree spec, int complain)
1396 int diag_type = -1; /* none */
1398 if (spec == error_mark_node)
1401 gcc_assert (spec && (!list || TREE_VALUE (list)));
1403 /* [except.spec] 1, type in an exception specifier shall not be
1404 incomplete, or pointer or ref to incomplete other than pointer
1406 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1407 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1408 core = TREE_TYPE (core);
1411 else if (VOID_TYPE_P (core))
1413 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1415 else if (processing_template_decl)
1420 /* 15.4/1 says that types in an exception specifier must be complete,
1421 but it seems more reasonable to only require this on definitions
1422 and calls. So just give a pedwarn at this point; we will give an
1423 error later if we hit one of those two cases. */
1424 if (!COMPLETE_TYPE_P (complete_type (core)))
1425 diag_type = 2; /* pedwarn */
1432 for (probe = list; probe; probe = TREE_CHAIN (probe))
1433 if (same_type_p (TREE_VALUE (probe), spec))
1436 list = tree_cons (NULL_TREE, spec, list);
1439 diag_type = 0; /* error */
1441 if (diag_type >= 0 && complain)
1442 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1447 /* Combine the two exceptions specifier lists LIST and ADD, and return
1451 merge_exception_specifiers (tree list, tree add)
1455 else if (!TREE_VALUE (list))
1457 else if (!TREE_VALUE (add))
1461 tree orig_list = list;
1463 for (; add; add = TREE_CHAIN (add))
1465 tree spec = TREE_VALUE (add);
1468 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1469 if (same_type_p (TREE_VALUE (probe), spec))
1473 spec = build_tree_list (NULL_TREE, spec);
1474 TREE_CHAIN (spec) = list;
1482 /* Subroutine of build_call. Ensure that each of the types in the
1483 exception specification is complete. Technically, 15.4/1 says that
1484 they need to be complete when we see a declaration of the function,
1485 but we should be able to get away with only requiring this when the
1486 function is defined or called. See also add_exception_specifier. */
1489 require_complete_eh_spec_types (tree fntype, tree decl)
1492 /* Don't complain about calls to op new. */
1493 if (decl && DECL_ARTIFICIAL (decl))
1495 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1496 raises = TREE_CHAIN (raises))
1498 tree type = TREE_VALUE (raises);
1499 if (type && !COMPLETE_TYPE_P (type))
1503 ("call to function %qD which throws incomplete type %q#T",
1506 error ("call to function which throws incomplete type %q#T",
1513 #include "gt-cp-typeck2.h"