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"
42 static tree process_init_constructor (tree, tree, tree *);
44 /* Print an error message stemming from an attempt to use
45 BASETYPE as a base class for TYPE. */
48 error_not_base_type (tree basetype, tree type)
50 if (TREE_CODE (basetype) == FUNCTION_DECL)
51 basetype = DECL_CONTEXT (basetype);
52 error ("type %qT is not a base type for type %qT", basetype, type);
53 return error_mark_node;
57 binfo_or_else (tree base, tree type)
59 tree binfo = lookup_base (type, base, ba_unique, NULL);
61 if (binfo == error_mark_node)
64 error_not_base_type (base, type);
68 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
69 value may not be changed thereafter. Thus, we emit hard errors for these,
70 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
71 example, conversions to references.) */
74 readonly_error (tree arg, const char* string, int soft)
77 void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
84 if (TREE_CODE (arg) == COMPONENT_REF)
86 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
87 fmt = "%s of data-member %qD in read-only structure";
89 fmt = "%s of read-only data-member %qD";
90 (*fn) (fmt, string, TREE_OPERAND (arg, 1));
92 else if (TREE_CODE (arg) == VAR_DECL)
94 if (DECL_LANG_SPECIFIC (arg)
95 && DECL_IN_AGGR_P (arg)
96 && !TREE_STATIC (arg))
97 fmt = "%s of constant field %qD";
99 fmt = "%s of read-only variable %qD";
100 (*fn) (fmt, string, arg);
102 else if (TREE_CODE (arg) == PARM_DECL)
103 (*fn) ("%s of read-only parameter %qD", string, arg);
104 else if (TREE_CODE (arg) == INDIRECT_REF
105 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
106 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
107 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
108 (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
109 else if (TREE_CODE (arg) == RESULT_DECL)
110 (*fn) ("%s of read-only named return value %qD", string, arg);
111 else if (TREE_CODE (arg) == FUNCTION_DECL)
112 (*fn) ("%s of function %qD", string, arg);
114 (*fn) ("%s of read-only location", string);
118 /* Structure that holds information about declarations whose type was
119 incomplete and we could not check whether it was abstract or not. */
121 struct pending_abstract_type GTY((chain_next ("%h.next")))
123 /* Declaration which we are checking for abstractness. It is either
124 a DECL node, or an IDENTIFIER_NODE if we do not have a full
125 declaration available. */
128 /* Type which will be checked for abstractness. */
131 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
132 because DECLs already carry locus information. */
135 /* Link to the next element in list. */
136 struct pending_abstract_type* next;
140 /* Compute the hash value of the node VAL. This function is used by the
141 hash table abstract_pending_vars. */
144 pat_calc_hash (const void* val)
146 const struct pending_abstract_type* pat = val;
147 return (hashval_t) TYPE_UID (pat->type);
151 /* Compare node VAL1 with the type VAL2. This function is used by the
152 hash table abstract_pending_vars. */
155 pat_compare (const void* val1, const void* val2)
157 const struct pending_abstract_type* pat1 = val1;
158 tree type2 = (tree)val2;
160 return (pat1->type == type2);
163 /* Hash table that maintains pending_abstract_type nodes, for which we still
164 need to check for type abstractness. The key of the table is the type
165 of the declaration. */
166 static GTY ((param_is (struct pending_abstract_type)))
167 htab_t abstract_pending_vars = NULL;
170 /* This function is called after TYPE is completed, and will check if there
171 are pending declarations for which we still need to verify the abstractness
172 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
173 turned out to be incomplete. */
176 complete_type_check_abstract (tree type)
179 struct pending_abstract_type *pat;
180 location_t cur_loc = input_location;
182 gcc_assert (COMPLETE_TYPE_P (type));
184 if (!abstract_pending_vars)
187 /* Retrieve the list of pending declarations for this type. */
188 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
189 (hashval_t)TYPE_UID (type), NO_INSERT);
192 pat = (struct pending_abstract_type*)*slot;
195 /* If the type is not abstract, do not do anything. */
196 if (CLASSTYPE_PURE_VIRTUALS (type))
198 struct pending_abstract_type *prev = 0, *next;
200 /* Reverse the list to emit the errors in top-down order. */
201 for (; pat; pat = next)
209 /* Go through the list, and call abstract_virtuals_error for each
210 element: it will issue a diagnostic if the type is abstract. */
213 gcc_assert (type == pat->type);
215 /* Tweak input_location so that the diagnostic appears at the correct
216 location. Notice that this is only needed if the decl is an
218 input_location = pat->locus;
219 abstract_virtuals_error (pat->decl, pat->type);
224 htab_clear_slot (abstract_pending_vars, slot);
226 input_location = cur_loc;
230 /* If TYPE has abstract virtual functions, issue an error about trying
231 to create an object of that type. DECL is the object declared, or
232 NULL_TREE if the declaration is unavailable. Returns 1 if an error
233 occurred; zero if all was well. */
236 abstract_virtuals_error (tree decl, tree type)
240 /* This function applies only to classes. Any other entity can never
242 if (!CLASS_TYPE_P (type))
245 /* If the type is incomplete, we register it within a hash table,
246 so that we can check again once it is completed. This makes sense
247 only for objects for which we have a declaration or at least a
249 if (!COMPLETE_TYPE_P (type))
252 struct pending_abstract_type *pat;
254 gcc_assert (!decl || DECL_P (decl)
255 || TREE_CODE (decl) == IDENTIFIER_NODE);
257 if (!abstract_pending_vars)
258 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
261 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
262 (hashval_t)TYPE_UID (type), INSERT);
264 pat = GGC_NEW (struct pending_abstract_type);
267 pat->locus = ((decl && DECL_P (decl))
268 ? DECL_SOURCE_LOCATION (decl)
277 if (!TYPE_SIZE (type))
278 /* TYPE is being defined, and during that time
279 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
282 pure = CLASSTYPE_PURE_VIRTUALS (type);
288 if (TREE_CODE (decl) == RESULT_DECL)
291 if (TREE_CODE (decl) == VAR_DECL)
292 error ("cannot declare variable %q+D to be of abstract "
293 "type %qT", decl, type);
294 else if (TREE_CODE (decl) == PARM_DECL)
295 error ("cannot declare parameter %q+D to be of abstract type %qT",
297 else if (TREE_CODE (decl) == FIELD_DECL)
298 error ("cannot declare field %q+D to be of abstract type %qT",
300 else if (TREE_CODE (decl) == FUNCTION_DECL
301 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
302 error ("invalid abstract return type for member function %q+#D", decl);
303 else if (TREE_CODE (decl) == FUNCTION_DECL)
304 error ("invalid abstract return type for function %q+#D", decl);
305 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
306 /* Here we do not have location information. */
307 error ("invalid abstract type %qT for %qE", type, decl);
309 error ("invalid abstract type for %q+D", decl);
312 error ("cannot allocate an object of abstract type %qT", type);
314 /* Only go through this once. */
315 if (VEC_length (tree, pure))
320 inform ("%J because the following virtual functions are pure "
321 "within %qT:", TYPE_MAIN_DECL (type), type);
323 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
324 inform ("\t%+#D", fn);
325 /* Now truncate the vector. This leaves it non-null, so we know
326 there are pure virtuals, but empty so we don't list them out
328 VEC_truncate (tree, pure, 0);
331 inform ("%J since type %qT has pure virtual functions",
332 TYPE_MAIN_DECL (type), type);
337 /* Print an error message for invalid use of an incomplete type.
338 VALUE is the expression that was used (or 0 if that isn't known)
339 and TYPE is the type that was invalid. DIAG_TYPE indicates the
340 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
344 cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
347 void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
351 else if (diag_type == 2)
356 /* Avoid duplicate error message. */
357 if (TREE_CODE (type) == ERROR_MARK)
360 if (value != 0 && (TREE_CODE (value) == VAR_DECL
361 || TREE_CODE (value) == PARM_DECL
362 || TREE_CODE (value) == FIELD_DECL))
364 p_msg ("%q+D has incomplete type", value);
368 /* We must print an error message. Be clever about what it says. */
370 switch (TREE_CODE (type))
376 p_msg ("invalid use of undefined type %q#T", type);
377 if (!TYPE_TEMPLATE_INFO (type))
378 p_msg ("forward declaration of %q+#T", type);
380 p_msg ("declaration of %q+#T", type);
384 p_msg ("invalid use of %qT", type);
388 if (TYPE_DOMAIN (type))
390 type = TREE_TYPE (type);
393 p_msg ("invalid use of array with unspecified bounds");
398 p_msg ("invalid use of member (did you forget the %<&%> ?)");
401 case TEMPLATE_TYPE_PARM:
402 p_msg ("invalid use of template type parameter");
406 if (value && TREE_CODE (value) == COMPONENT_REF)
408 else if (value && TREE_CODE (value) == ADDR_EXPR)
409 p_msg ("address of overloaded function with no contextual "
411 else if (value && TREE_CODE (value) == OVERLOAD)
412 p_msg ("overloaded function with no contextual type information");
414 p_msg ("insufficient contextual information to determine type");
422 /* Backward-compatibility interface to incomplete_type_diagnostic;
423 required by ../tree.c. */
424 #undef cxx_incomplete_type_error
426 cxx_incomplete_type_error (tree value, tree type)
428 cxx_incomplete_type_diagnostic (value, type, 0);
432 /* The recursive part of split_nonconstant_init. DEST is an lvalue
433 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
436 split_nonconstant_init_1 (tree dest, tree init)
438 tree *pelt, elt, type = TREE_TYPE (dest);
439 tree sub, code, inner_type = NULL;
440 bool array_type_p = false;
442 pelt = &CONSTRUCTOR_ELTS (init);
443 switch (TREE_CODE (type))
446 inner_type = TREE_TYPE (type);
452 case QUAL_UNION_TYPE:
453 while ((elt = *pelt))
455 tree field_index = TREE_PURPOSE (elt);
456 tree value = TREE_VALUE (elt);
459 inner_type = TREE_TYPE (field_index);
461 if (TREE_CODE (value) == CONSTRUCTOR)
464 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
465 NULL_TREE, NULL_TREE);
467 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
470 split_nonconstant_init_1 (sub, value);
472 else if (!initializer_constant_valid_p (value, inner_type))
474 *pelt = TREE_CHAIN (elt);
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 code = build2 (MODIFY_EXPR, inner_type, sub, value);
484 code = build_stmt (EXPR_STMT, code);
489 pelt = &TREE_CHAIN (elt);
494 if (!initializer_constant_valid_p (init, type))
496 tree cons = copy_node (init);
497 CONSTRUCTOR_ELTS (init) = NULL;
498 code = build2 (MODIFY_EXPR, type, dest, cons);
499 code = build_stmt (EXPR_STMT, code);
509 /* A subroutine of store_init_value. Splits non-constant static
510 initializer INIT into a constant part and generates code to
511 perform the non-constant part of the initialization to DEST.
512 Returns the code for the runtime init. */
515 split_nonconstant_init (tree dest, tree init)
519 if (TREE_CODE (init) == CONSTRUCTOR)
521 code = push_stmt_list ();
522 split_nonconstant_init_1 (dest, init);
523 code = pop_stmt_list (code);
524 DECL_INITIAL (dest) = init;
525 TREE_READONLY (dest) = 0;
528 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
533 /* Perform appropriate conversions on the initial value of a variable,
534 store it in the declaration DECL,
535 and print any error messages that are appropriate.
536 If the init is invalid, store an ERROR_MARK.
538 C++: Note that INIT might be a TREE_LIST, which would mean that it is
539 a base class initializer for some aggregate type, hopefully compatible
540 with DECL. If INIT is a single element, and DECL is an aggregate
541 type, we silently convert INIT into a TREE_LIST, allowing a constructor
544 If INIT is a TREE_LIST and there is no constructor, turn INIT
545 into a CONSTRUCTOR and use standard initialization techniques.
546 Perhaps a warning should be generated?
548 Returns code to be executed if initialization could not be performed
549 for static variable. In that case, caller must emit the code. */
552 store_init_value (tree decl, tree init)
556 /* If variable's type was invalidly declared, just ignore it. */
558 type = TREE_TYPE (decl);
559 if (TREE_CODE (type) == ERROR_MARK)
562 if (IS_AGGR_TYPE (type))
564 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
565 || TREE_CODE (init) == CONSTRUCTOR);
567 if (TREE_CODE (init) == TREE_LIST)
569 error ("constructor syntax used, but no constructor declared "
570 "for type %qT", type);
571 init = build_constructor (NULL_TREE, nreverse (init));
574 else if (TREE_CODE (init) == TREE_LIST
575 && TREE_TYPE (init) != unknown_type_node)
577 if (TREE_CODE (decl) == RESULT_DECL)
578 init = build_x_compound_expr_from_list (init,
579 "return value initializer");
580 else if (TREE_CODE (init) == TREE_LIST
581 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
583 error ("cannot initialize arrays using this syntax");
587 /* We get here with code like `int a (2);' */
588 init = build_x_compound_expr_from_list (init, "initializer");
591 /* End of special C++ code. */
593 /* Digest the specified initializer into an expression. */
594 value = digest_init (type, init, (tree *) 0);
595 /* If the initializer is not a constant, fill in DECL_INITIAL with
596 the bits that are constant, and then return an expression that
597 will perform the dynamic initialization. */
598 if (value != error_mark_node
599 && (TREE_SIDE_EFFECTS (value)
600 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
601 return split_nonconstant_init (decl, value);
602 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
603 is an automatic variable, the middle end will turn this into a
604 dynamic initialization later. */
605 DECL_INITIAL (decl) = value;
610 /* Digest the parser output INIT as an initializer for type TYPE.
611 Return a C expression of type TYPE to represent the initial value.
613 If TAIL is nonzero, it points to a variable holding a list of elements
614 of which INIT is the first. We update the list stored there by
615 removing from the head all the elements that we use.
616 Normally this is only one; we use more than one element only if
617 TYPE is an aggregate and INIT is not a constructor. */
620 digest_init (tree type, tree init, tree* tail)
622 enum tree_code code = TREE_CODE (type);
623 tree element = NULL_TREE;
624 tree old_tail_contents = NULL_TREE;
626 /* By default, assume we use one element from a list.
627 We correct this later in the sole case where it is not true. */
631 old_tail_contents = *tail;
632 *tail = TREE_CHAIN (*tail);
635 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
636 && TREE_VALUE (init) == error_mark_node))
637 return error_mark_node;
639 if (TREE_CODE (init) == ERROR_MARK)
640 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
641 a template function. This gets substituted during instantiation. */
644 /* We must strip the outermost array type when completing the type,
645 because the its bounds might be incomplete at the moment. */
646 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
647 ? TREE_TYPE (type) : type, NULL_TREE))
648 return error_mark_node;
650 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
651 if (TREE_CODE (init) == NON_LVALUE_EXPR)
652 init = TREE_OPERAND (init, 0);
654 if (BRACE_ENCLOSED_INITIALIZER_P (init)
655 && CONSTRUCTOR_ELTS (init) != 0
656 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
658 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
659 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
660 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
661 element = TREE_OPERAND (element, 0);
662 if (element == error_mark_node)
666 /* Initialization of an array of chars from a string constant
667 optionally enclosed in braces. */
669 if (code == ARRAY_TYPE)
673 if (TREE_CODE (init) == TREE_LIST)
675 error ("initializing array with parameter list");
676 return error_mark_node;
679 typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
680 if (char_type_p (typ1)
681 && ((init && TREE_CODE (init) == STRING_CST)
682 || (element && TREE_CODE (element) == STRING_CST)))
684 tree string = element ? element : init;
686 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
688 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
690 error ("char-array initialized from wide string");
691 return error_mark_node;
693 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
695 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
697 error ("int-array initialized from non-wide string");
698 return error_mark_node;
701 TREE_TYPE (string) = type;
702 if (TYPE_DOMAIN (type) != 0
703 && TREE_CONSTANT (TYPE_SIZE (type)))
705 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
706 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
707 /* In C it is ok to subtract 1 from the length of the string
708 because it's ok to ignore the terminating null char that is
709 counted in the length of the constant, but in C++ this would
711 if (size < TREE_STRING_LENGTH (string))
712 pedwarn ("initializer-string for array of chars is too long");
718 /* Handle scalar types, including conversions,
719 and signature pointers and references. */
721 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
722 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
723 || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
724 || TYPE_PTR_TO_MEMBER_P (type))
726 if (BRACE_ENCLOSED_INITIALIZER_P (init))
730 error ("initializer for scalar variable requires one element");
731 return error_mark_node;
735 while (BRACE_ENCLOSED_INITIALIZER_P (init))
737 pedwarn ("braces around scalar initializer for %qT", type);
738 init = CONSTRUCTOR_ELTS (init);
739 if (TREE_CHAIN (init))
740 pedwarn ("ignoring extra initializers for %qT", type);
741 init = TREE_VALUE (init);
744 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
745 "initialization", NULL_TREE, 0);
748 /* Come here only for records and arrays (and unions with constructors). */
750 if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
752 error ("variable-sized object of type %qT may not be initialized",
754 return error_mark_node;
757 if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
759 if (BRACE_ENCLOSED_INITIALIZER_P (init))
761 if (TYPE_NON_AGGREGATE_CLASS (type))
763 error ("subobject of type %qT must be initialized by "
764 "constructor, not by %qE",
766 return error_mark_node;
768 return process_init_constructor (type, init, (tree *)0);
770 else if (can_convert_arg (type, TREE_TYPE (init), init)
771 || TYPE_NON_AGGREGATE_CLASS (type))
772 /* These are never initialized from multiple constructor elements. */;
775 *tail = old_tail_contents;
776 return process_init_constructor (type, 0, tail);
779 if (code != ARRAY_TYPE)
781 int flags = LOOKUP_NORMAL;
782 /* Initialization from { } is copy-initialization. */
784 flags |= LOOKUP_ONLYCONVERTING;
786 return convert_for_initialization (NULL_TREE, type, init, flags,
787 "initialization", NULL_TREE, 0);
791 error ("invalid initializer");
792 return error_mark_node;
795 /* Process a constructor for a variable of type TYPE.
796 The constructor elements may be specified either with INIT or with ELTS,
797 only one of which should be non-null.
799 If INIT is specified, it is a CONSTRUCTOR node which is specifically
800 and solely for initializing this datum.
802 If ELTS is specified, it is the address of a variable containing
803 a list of expressions. We take as many elements as we need
804 from the head of the list and update the list.
806 In the resulting constructor, TREE_CONSTANT is set if all elts are
807 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
808 constants that the assembler and linker can compute them. */
811 process_init_constructor (tree type, tree init, tree* elts)
814 /* List of the elements of the result constructor,
823 /* Make TAIL be the list of elements to use for the initialization,
824 no matter how the data was given to us. */
828 if (warn_missing_braces)
829 warning (0, "aggregate has a partly bracketed initializer");
833 tail = CONSTRUCTOR_ELTS (init);
835 /* Gobble as many elements as needed, and make a constructor or initial value
836 for each element of this aggregate. Chain them together in result.
837 If there are too few, use 0 for each scalar ultimate component. */
839 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
844 if (TREE_CODE (type) == ARRAY_TYPE)
846 tree domain = TYPE_DOMAIN (type);
848 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
849 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
852 len = -1; /* Take as many as there are. */
856 /* Vectors are like simple fixed-size arrays. */
857 len = TYPE_VECTOR_SUBPARTS (type);
860 for (i = 0; len < 0 || i < len; i++)
864 if (TREE_PURPOSE (tail)
865 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
866 || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
867 sorry ("non-trivial labeled initializers");
869 if (TREE_VALUE (tail) != 0)
872 next1 = digest_init (TREE_TYPE (type),
873 TREE_VALUE (tail), &tail1);
874 if (next1 == error_mark_node)
876 gcc_assert (same_type_ignoring_top_level_qualifiers_p
877 (TREE_TYPE (type), TREE_TYPE (next1)));
878 gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
879 if (tail == tail1 && len < 0)
881 error ("non-empty initializer for array of empty elements");
882 /* Just ignore what we were supposed to use. */
889 next1 = error_mark_node;
890 tail = TREE_CHAIN (tail);
896 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
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. */
903 if (IS_AGGR_TYPE (TREE_TYPE (type)))
904 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
906 next1 = build_constructor (NULL_TREE, NULL_TREE);
907 next1 = digest_init (TREE_TYPE (type), next1, 0);
909 else if (! zero_init_p (TREE_TYPE (type)))
910 next1 = build_zero_init (TREE_TYPE (type),
912 /*static_storage_p=*/false);
914 /* The default zero-initialization is fine for us; don't
915 add anything to the CONSTRUCTOR. */
918 if (next1 == error_mark_node)
920 else if (!TREE_CONSTANT (next1))
922 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
924 members = tree_cons (size_int (i), next1, members);
927 else if (TREE_CODE (type) == RECORD_TYPE)
933 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
934 gcc_assert (!TYPE_BINFO (type)
935 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
936 gcc_assert (!TYPE_POLYMORPHIC_P (type));
939 for (field = TYPE_FIELDS (type); field;
940 field = TREE_CHAIN (field))
942 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
944 members = tree_cons (field, integer_zero_node, members);
948 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
953 if (TREE_PURPOSE (tail)
954 && TREE_PURPOSE (tail) != field
955 && TREE_PURPOSE (tail) != DECL_NAME (field))
956 sorry ("non-trivial labeled initializers");
958 if (TREE_VALUE (tail) != 0)
962 next1 = digest_init (TREE_TYPE (field),
963 TREE_VALUE (tail), &tail1);
964 gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
969 next1 = error_mark_node;
970 tail = TREE_CHAIN (tail);
973 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
975 /* If this type needs constructors run for
976 default-initialization, we can't rely on the backend to do it
977 for us, so build up TARGET_EXPRs. If the type in question is
978 a class, just build one up; if it's an array, recurse. */
980 if (IS_AGGR_TYPE (TREE_TYPE (field)))
981 next1 = build_functional_cast (TREE_TYPE (field),
985 next1 = build_constructor (NULL_TREE, NULL_TREE);
987 TREE_HAS_CONSTRUCTOR (next1)
988 = TREE_HAS_CONSTRUCTOR (init);
990 next1 = digest_init (TREE_TYPE (field), next1, 0);
992 /* Warn when some struct elements are implicitly initialized. */
993 if (warn_missing_field_initializers
994 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
995 warning (0, "missing initializer for member %qD", field);
999 if (TREE_READONLY (field))
1000 error ("uninitialized const member %qD", field);
1001 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1002 error ("member %qD with uninitialized const fields", field);
1003 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1004 error ("member %qD is uninitialized reference", field);
1006 /* Warn when some struct elements are implicitly initialized
1008 if (warn_missing_field_initializers
1009 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
1010 warning (0, "missing initializer for member %qD", field);
1012 if (! zero_init_p (TREE_TYPE (field)))
1013 next1 = build_zero_init (TREE_TYPE (field),
1014 /*nelts=*/NULL_TREE,
1015 /*static_storage_p=*/false);
1017 /* The default zero-initialization is fine for us; don't
1018 add anything to the CONSTRUCTOR. */
1022 if (next1 == error_mark_node)
1024 else if (!TREE_CONSTANT (next1))
1026 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1028 members = tree_cons (field, next1, members);
1031 else if (TREE_CODE (type) == UNION_TYPE
1032 /* If the initializer was empty, use default zero initialization. */
1035 tree field = TYPE_FIELDS (type);
1037 /* Find the first named field. ANSI decided in September 1990
1038 that only named fields count here. */
1039 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1040 field = TREE_CHAIN (field);
1042 /* If this element specifies a field, initialize via that field. */
1043 if (TREE_PURPOSE (tail) != NULL_TREE)
1047 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
1048 /* Handle the case of a call by build_c_cast. */
1049 field = TREE_PURPOSE (tail), win = 1;
1050 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
1051 error ("index value instead of field name in union initializer");
1055 for (temp = TYPE_FIELDS (type);
1057 temp = TREE_CHAIN (temp))
1058 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
1061 field = temp, win = 1;
1063 error ("no field %qD in union being initialized",
1064 TREE_PURPOSE (tail));
1067 TREE_VALUE (tail) = error_mark_node;
1069 else if (field == 0)
1071 error ("union %qT with no named members cannot be initialized",
1073 TREE_VALUE (tail) = error_mark_node;
1076 if (TREE_VALUE (tail) != 0)
1080 next1 = digest_init (TREE_TYPE (field),
1081 TREE_VALUE (tail), &tail1);
1082 gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
1087 next1 = error_mark_node;
1088 tail = TREE_CHAIN (tail);
1091 if (next1 == error_mark_node)
1093 else if (!TREE_CONSTANT (next1))
1095 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
1097 members = tree_cons (field, next1, members);
1100 /* If arguments were specified as a list, just remove the ones we used. */
1103 /* If arguments were specified as a constructor,
1104 complain unless we used all the elements of the constructor. */
1106 pedwarn ("excess elements in aggregate initializer");
1109 return error_mark_node;
1111 result = build_constructor (type, nreverse (members));
1112 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1113 cp_complete_array_type (&TREE_TYPE (result), result, /*do_default=*/0);
1115 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1118 TREE_CONSTANT (result) = 1;
1119 TREE_INVARIANT (result) = 1;
1121 TREE_STATIC (result) = 1;
1126 /* Given a structure or union value DATUM, construct and return
1127 the structure or union component which results from narrowing
1128 that value to the base specified in BASETYPE. For example, given the
1131 class L { int ii; };
1132 class A : L { ... };
1133 class B : L { ... };
1134 class C : A, B { ... };
1142 x.A::ii refers to the ii member of the L part of
1143 the A part of the C object named by X. In this case,
1144 DATUM would be x, and BASETYPE would be A.
1146 I used to think that this was nonconformant, that the standard specified
1147 that first we look up ii in A, then convert x to an L& and pull out the
1148 ii part. But in fact, it does say that we convert x to an A&; A here
1149 is known as the "naming class". (jason 2000-12-19)
1151 BINFO_P points to a variable initialized either to NULL_TREE or to the
1152 binfo for the specific base subobject we want to convert to. */
1155 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1159 if (datum == error_mark_node)
1160 return error_mark_node;
1164 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1166 if (!binfo || binfo == error_mark_node)
1168 *binfo_p = NULL_TREE;
1170 error_not_base_type (basetype, TREE_TYPE (datum));
1171 return error_mark_node;
1175 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1178 /* Build a reference to an object specified by the C++ `->' operator.
1179 Usually this just involves dereferencing the object, but if the
1180 `->' operator is overloaded, then such overloads must be
1181 performed until an object which does not have the `->' operator
1182 overloaded is found. An error is reported when circular pointer
1183 delegation is detected. */
1186 build_x_arrow (tree expr)
1188 tree orig_expr = expr;
1189 tree types_memoized = NULL_TREE;
1190 tree type = TREE_TYPE (expr);
1191 tree last_rval = NULL_TREE;
1193 if (type == error_mark_node)
1194 return error_mark_node;
1196 if (processing_template_decl)
1198 if (type_dependent_expression_p (expr))
1199 return build_min_nt (ARROW_EXPR, expr);
1200 expr = build_non_dependent_expr (expr);
1203 if (IS_AGGR_TYPE (type))
1205 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1206 NULL_TREE, NULL_TREE,
1207 /*overloaded_p=*/NULL)))
1209 if (expr == error_mark_node)
1210 return error_mark_node;
1212 if (value_member (TREE_TYPE (expr), types_memoized))
1214 error ("circular pointer delegation detected");
1215 return error_mark_node;
1219 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1225 if (last_rval == NULL_TREE)
1227 error ("base operand of %<->%> has non-pointer type %qT", type);
1228 return error_mark_node;
1231 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1232 last_rval = convert_from_reference (last_rval);
1235 last_rval = decay_conversion (expr);
1237 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1239 if (processing_template_decl)
1241 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1242 /* It will be dereferenced. */
1243 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1247 return build_indirect_ref (last_rval, NULL);
1251 error ("result of %<operator->()%> yields non-pointer result");
1253 error ("base operand of %<->%> is not a pointer");
1254 return error_mark_node;
1257 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1258 already been checked out to be of aggregate type. */
1261 build_m_component_ref (tree datum, tree component)
1269 datum = decay_conversion (datum);
1271 if (datum == error_mark_node || component == error_mark_node)
1272 return error_mark_node;
1274 ptrmem_type = TREE_TYPE (component);
1275 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1277 error ("%qE cannot be used as a member pointer, since it is of "
1279 component, ptrmem_type);
1280 return error_mark_node;
1283 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1284 if (! IS_AGGR_TYPE (objtype))
1286 error ("cannot apply member pointer %qE to %qE, which is of "
1287 "non-aggregate type %qT",
1288 component, datum, objtype);
1289 return error_mark_node;
1292 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1293 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1295 if (!COMPLETE_TYPE_P (ctype))
1297 if (!same_type_p (ctype, objtype))
1303 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1308 error ("pointer to member type %qT incompatible with object "
1311 return error_mark_node;
1313 else if (binfo == error_mark_node)
1314 return error_mark_node;
1317 if (TYPE_PTRMEM_P (ptrmem_type))
1319 /* Compute the type of the field, as described in [expr.ref].
1320 There's no such thing as a mutable pointer-to-member, so
1321 things are not as complex as they are for references to
1322 non-static data members. */
1323 type = cp_build_qualified_type (type,
1324 (cp_type_quals (type)
1325 | cp_type_quals (TREE_TYPE (datum))));
1327 datum = build_address (datum);
1329 /* Convert object to the correct base. */
1331 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1333 /* Build an expression for "object + offset" where offset is the
1334 value stored in the pointer-to-data-member. */
1335 datum = build2 (PLUS_EXPR, build_pointer_type (type),
1336 datum, build_nop (ptrdiff_type_node, component));
1337 return build_indirect_ref (datum, 0);
1340 return build2 (OFFSET_REF, type, datum, component);
1343 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1346 build_functional_cast (tree exp, tree parms)
1348 /* This is either a call to a constructor,
1349 or a C cast in C++'s `functional' notation. */
1352 if (exp == error_mark_node || parms == error_mark_node)
1353 return error_mark_node;
1355 if (TREE_CODE (exp) == TYPE_DECL)
1356 type = TREE_TYPE (exp);
1360 if (processing_template_decl)
1362 tree t = build_min (CAST_EXPR, type, parms);
1363 /* We don't know if it will or will not have side effects. */
1364 TREE_SIDE_EFFECTS (t) = 1;
1368 if (! IS_AGGR_TYPE (type))
1370 /* This must build a C cast. */
1371 if (parms == NULL_TREE)
1372 parms = integer_zero_node;
1374 parms = build_x_compound_expr_from_list (parms, "functional cast");
1376 return build_c_cast (type, parms);
1379 /* Prepare to evaluate as a call to a constructor. If this expression
1380 is actually used, for example,
1382 return X (arg1, arg2, ...);
1384 then the slot being initialized will be filled in. */
1386 if (!complete_type_or_else (type, NULL_TREE))
1387 return error_mark_node;
1388 if (abstract_virtuals_error (NULL_TREE, type))
1389 return error_mark_node;
1391 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1392 return build_c_cast (type, TREE_VALUE (parms));
1394 /* We need to zero-initialize POD types. Let's do that for everything
1395 that doesn't need a constructor. */
1396 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1397 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1399 exp = build_constructor (type, NULL_TREE);
1400 return get_target_expr (exp);
1403 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1404 type, LOOKUP_NORMAL);
1406 if (exp == error_mark_node)
1407 return error_mark_node;
1409 return build_cplus_new (type, exp);
1413 /* Add new exception specifier SPEC, to the LIST we currently have.
1414 If it's already in LIST then do nothing.
1415 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1416 know what we're doing. */
1419 add_exception_specifier (tree list, tree spec, int complain)
1424 int diag_type = -1; /* none */
1426 if (spec == error_mark_node)
1429 gcc_assert (spec && (!list || TREE_VALUE (list)));
1431 /* [except.spec] 1, type in an exception specifier shall not be
1432 incomplete, or pointer or ref to incomplete other than pointer
1434 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1435 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1436 core = TREE_TYPE (core);
1439 else if (VOID_TYPE_P (core))
1441 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1443 else if (processing_template_decl)
1448 /* 15.4/1 says that types in an exception specifier must be complete,
1449 but it seems more reasonable to only require this on definitions
1450 and calls. So just give a pedwarn at this point; we will give an
1451 error later if we hit one of those two cases. */
1452 if (!COMPLETE_TYPE_P (complete_type (core)))
1453 diag_type = 2; /* pedwarn */
1460 for (probe = list; probe; probe = TREE_CHAIN (probe))
1461 if (same_type_p (TREE_VALUE (probe), spec))
1464 list = tree_cons (NULL_TREE, spec, list);
1467 diag_type = 0; /* error */
1469 if (diag_type >= 0 && complain)
1470 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1475 /* Combine the two exceptions specifier lists LIST and ADD, and return
1479 merge_exception_specifiers (tree list, tree add)
1483 else if (!TREE_VALUE (list))
1485 else if (!TREE_VALUE (add))
1489 tree orig_list = list;
1491 for (; add; add = TREE_CHAIN (add))
1493 tree spec = TREE_VALUE (add);
1496 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1497 if (same_type_p (TREE_VALUE (probe), spec))
1501 spec = build_tree_list (NULL_TREE, spec);
1502 TREE_CHAIN (spec) = list;
1510 /* Subroutine of build_call. Ensure that each of the types in the
1511 exception specification is complete. Technically, 15.4/1 says that
1512 they need to be complete when we see a declaration of the function,
1513 but we should be able to get away with only requiring this when the
1514 function is defined or called. See also add_exception_specifier. */
1517 require_complete_eh_spec_types (tree fntype, tree decl)
1520 /* Don't complain about calls to op new. */
1521 if (decl && DECL_ARTIFICIAL (decl))
1523 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1524 raises = TREE_CHAIN (raises))
1526 tree type = TREE_VALUE (raises);
1527 if (type && !COMPLETE_TYPE_P (type))
1531 ("call to function %qD which throws incomplete type %q#T",
1534 error ("call to function which throws incomplete type %q#T",
1541 #include "gt-cp-typeck2.h"