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
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, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, 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 `%T' is not a base type for type `%T'", basetype, type);
53 return error_mark_node;
57 binfo_or_else (tree base, tree type)
59 tree binfo = lookup_base (type, base, ba_ignore, 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 *, ...);
84 if (TREE_CODE (arg) == COMPONENT_REF)
86 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
87 fmt = "%s of data-member `%D' in read-only structure";
89 fmt = "%s of read-only data-member `%D'";
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 `%D'";
99 fmt = "%s of read-only variable `%D'";
100 (*fn) (fmt, string, arg);
102 else if (TREE_CODE (arg) == PARM_DECL)
103 (*fn) ("%s of read-only parameter `%D'", 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 `%D'", string, TREE_OPERAND (arg, 0));
109 else if (TREE_CODE (arg) == RESULT_DECL)
110 (*fn) ("%s of read-only named return value `%D'", string, arg);
111 else if (TREE_CODE (arg) == FUNCTION_DECL)
112 (*fn) ("%s of function `%D'", 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 my_friendly_assert (COMPLETE_TYPE_P (type), 20040620_3);
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;
193 my_friendly_assert (pat, 20040620_2);
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 diagostic if the type is abstract. */
213 my_friendly_assert (type == pat->type, 20040620_4);
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
217 IDENTIFIER_NODE, otherwise cp_error_at. */
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)
241 /* This function applies only to classes. Any other entity can never
243 if (!CLASS_TYPE_P (type))
246 /* If the type is incomplete, we register it within a hash table,
247 so that we can check again once it is completed. This makes sense
248 only for objects for which we have a declaration or at least a
250 if (!COMPLETE_TYPE_P (type))
253 struct pending_abstract_type *pat;
255 my_friendly_assert (!decl || (DECL_P (decl)
256 || 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_alloc (sizeof (struct pending_abstract_type));
269 pat->locus = ((decl && DECL_P (decl))
270 ? DECL_SOURCE_LOCATION (decl)
279 if (!CLASSTYPE_PURE_VIRTUALS (type))
282 if (!TYPE_SIZE (type))
283 /* TYPE is being defined, and during that time
284 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
287 u = CLASSTYPE_PURE_VIRTUALS (type);
290 if (TREE_CODE (decl) == RESULT_DECL)
293 if (TREE_CODE (decl) == VAR_DECL)
294 cp_error_at ("cannot declare variable `%+D' to be of abstract "
295 "type `%T'", decl, type);
296 else if (TREE_CODE (decl) == PARM_DECL)
297 cp_error_at ("cannot declare parameter `%+D' to be of abstract "
298 "type `%T'", decl, type);
299 else if (TREE_CODE (decl) == FIELD_DECL)
300 cp_error_at ("cannot declare field `%+D' to be of abstract "
301 "type `%T'", decl, type);
302 else if (TREE_CODE (decl) == FUNCTION_DECL
303 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
304 cp_error_at ("invalid abstract return type for member function `%+#D'",
306 else if (TREE_CODE (decl) == FUNCTION_DECL)
307 cp_error_at ("invalid abstract return type for function `%+#D'",
309 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
310 /* Here we do not have location information, so use error instead
312 error ("invalid abstract type `%T' for `%E'", type, decl);
314 cp_error_at ("invalid abstract type for `%+D'", decl);
317 error ("cannot allocate an object of abstract type `%T'", type);
319 /* Only go through this once. */
320 if (TREE_PURPOSE (u) == NULL_TREE)
322 TREE_PURPOSE (u) = error_mark_node;
324 inform ("%J because the following virtual functions are pure "
325 "within `%T':", TYPE_MAIN_DECL (type), type);
327 for (tu = u; tu; tu = TREE_CHAIN (tu))
328 inform ("%J\t%#D", TREE_VALUE (tu), TREE_VALUE (tu));
331 inform ("%J since type `%T' 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 *, ...);
348 void (*p_msg_at) (const char *, ...);
353 p_msg_at = cp_warning_at;
355 else if (diag_type == 2)
358 p_msg_at = cp_pedwarn_at;
363 p_msg_at = cp_error_at;
366 /* Avoid duplicate error message. */
367 if (TREE_CODE (type) == ERROR_MARK)
370 if (value != 0 && (TREE_CODE (value) == VAR_DECL
371 || TREE_CODE (value) == PARM_DECL
372 || TREE_CODE (value) == FIELD_DECL))
374 (*p_msg_at) ("`%D' has incomplete type", value);
378 /* We must print an error message. Be clever about what it says. */
380 switch (TREE_CODE (type))
386 (*p_msg) ("invalid use of undefined type `%#T'", type);
387 if (!TYPE_TEMPLATE_INFO (type))
388 (*p_msg_at) ("forward declaration of `%#T'", type);
390 (*p_msg_at) ("declaration of `%#T'", type);
394 (*p_msg) ("invalid use of `%T'", type);
398 if (TYPE_DOMAIN (type))
400 type = TREE_TYPE (type);
403 (*p_msg) ("invalid use of array with unspecified bounds");
408 (*p_msg) ("invalid use of member (did you forget the `&' ?)");
411 case TEMPLATE_TYPE_PARM:
412 (*p_msg) ("invalid use of template type parameter");
416 if (value && TREE_CODE (value) == COMPONENT_REF)
418 else if (value && TREE_CODE (value) == ADDR_EXPR)
419 (*p_msg) ("address of overloaded function with no contextual type information");
420 else if (value && TREE_CODE (value) == OVERLOAD)
421 (*p_msg) ("overloaded function with no contextual type information");
423 (*p_msg) ("insufficient contextual information to determine type");
431 /* Backward-compatibility interface to incomplete_type_diagnostic;
432 required by ../tree.c. */
433 #undef cxx_incomplete_type_error
435 cxx_incomplete_type_error (tree value, tree type)
437 cxx_incomplete_type_diagnostic (value, type, 0);
441 /* The recursive part of split_nonconstant_init. DEST is an lvalue
442 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
445 split_nonconstant_init_1 (tree dest, tree init)
447 tree *pelt, elt, type = TREE_TYPE (dest);
448 tree sub, code, inner_type = NULL;
449 bool array_type_p = false;
451 pelt = &CONSTRUCTOR_ELTS (init);
452 switch (TREE_CODE (type))
455 inner_type = TREE_TYPE (type);
461 case QUAL_UNION_TYPE:
462 while ((elt = *pelt))
464 tree field_index = TREE_PURPOSE (elt);
465 tree value = TREE_VALUE (elt);
468 inner_type = TREE_TYPE (field_index);
470 if (TREE_CODE (value) == CONSTRUCTOR)
473 sub = build (ARRAY_REF, inner_type, dest, field_index,
474 NULL_TREE, NULL_TREE);
476 sub = build (COMPONENT_REF, inner_type, dest, field_index,
479 split_nonconstant_init_1 (sub, value);
481 else if (!initializer_constant_valid_p (value, inner_type))
483 *pelt = TREE_CHAIN (elt);
486 sub = build (ARRAY_REF, inner_type, dest, field_index,
487 NULL_TREE, NULL_TREE);
489 sub = build (COMPONENT_REF, inner_type, dest, field_index,
492 code = build (MODIFY_EXPR, inner_type, sub, value);
493 code = build_stmt (EXPR_STMT, code);
498 pelt = &TREE_CHAIN (elt);
503 if (!initializer_constant_valid_p (init, type))
505 CONSTRUCTOR_ELTS (init) = NULL;
506 code = build (MODIFY_EXPR, type, dest, init);
507 code = build_stmt (EXPR_STMT, code);
517 /* A subroutine of store_init_value. Splits non-constant static
518 initializer INIT into a constant part and generates code to
519 perform the non-constant part of the initialization to DEST.
520 Returns the code for the runtime init. */
523 split_nonconstant_init (tree dest, tree init)
527 if (TREE_CODE (init) == CONSTRUCTOR)
529 code = push_stmt_list ();
530 split_nonconstant_init_1 (dest, init);
531 code = pop_stmt_list (code);
532 DECL_INITIAL (dest) = init;
533 TREE_READONLY (dest) = 0;
536 code = build (INIT_EXPR, TREE_TYPE (dest), dest, init);
541 /* Perform appropriate conversions on the initial value of a variable,
542 store it in the declaration DECL,
543 and print any error messages that are appropriate.
544 If the init is invalid, store an ERROR_MARK.
546 C++: Note that INIT might be a TREE_LIST, which would mean that it is
547 a base class initializer for some aggregate type, hopefully compatible
548 with DECL. If INIT is a single element, and DECL is an aggregate
549 type, we silently convert INIT into a TREE_LIST, allowing a constructor
552 If INIT is a TREE_LIST and there is no constructor, turn INIT
553 into a CONSTRUCTOR and use standard initialization techniques.
554 Perhaps a warning should be generated?
556 Returns code to be executed if initialization could not be performed
557 for static variable. In that case, caller must emit the code. */
560 store_init_value (tree decl, tree init)
564 /* If variable's type was invalidly declared, just ignore it. */
566 type = TREE_TYPE (decl);
567 if (TREE_CODE (type) == ERROR_MARK)
570 if (IS_AGGR_TYPE (type))
572 if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
573 && TREE_CODE (init) != CONSTRUCTOR)
576 if (TREE_CODE (init) == TREE_LIST)
578 error ("constructor syntax used, but no constructor declared for type `%T'", type);
579 init = build_constructor (NULL_TREE, nreverse (init));
582 else if (TREE_CODE (init) == TREE_LIST
583 && TREE_TYPE (init) != unknown_type_node)
585 if (TREE_CODE (decl) == RESULT_DECL)
586 init = build_x_compound_expr_from_list (init,
587 "return value initializer");
588 else if (TREE_CODE (init) == TREE_LIST
589 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
591 error ("cannot initialize arrays using this syntax");
595 /* We get here with code like `int a (2);' */
596 init = build_x_compound_expr_from_list (init, "initializer");
599 /* End of special C++ code. */
601 /* Digest the specified initializer into an expression. */
602 value = digest_init (type, init, (tree *) 0);
604 /* Store the expression if valid; else report error. */
606 if (TREE_CODE (value) == ERROR_MARK)
608 /* Other code expects that initializers for objects of types that need
609 constructing never make it into DECL_INITIAL, and passes 'init' to
610 build_aggr_init without checking DECL_INITIAL. So just return. */
611 else if (TYPE_NEEDS_CONSTRUCTING (type))
612 return build (INIT_EXPR, type, decl, value);
613 else if (TREE_STATIC (decl)
614 && (! TREE_CONSTANT (value)
615 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
616 return split_nonconstant_init (decl, value);
618 /* Store the VALUE in DECL_INITIAL. If we're building a
619 statement-tree we will actually expand the initialization later
620 when we output this function. */
621 DECL_INITIAL (decl) = value;
626 /* Digest the parser output INIT as an initializer for type TYPE.
627 Return a C expression of type TYPE to represent the initial value.
629 If TAIL is nonzero, it points to a variable holding a list of elements
630 of which INIT is the first. We update the list stored there by
631 removing from the head all the elements that we use.
632 Normally this is only one; we use more than one element only if
633 TYPE is an aggregate and INIT is not a constructor. */
636 digest_init (tree type, tree init, tree* tail)
638 enum tree_code code = TREE_CODE (type);
639 tree element = NULL_TREE;
640 tree old_tail_contents = NULL_TREE;
642 /* By default, assume we use one element from a list.
643 We correct this later in the sole case where it is not true. */
647 old_tail_contents = *tail;
648 *tail = TREE_CHAIN (*tail);
651 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
652 && TREE_VALUE (init) == error_mark_node))
653 return error_mark_node;
655 if (TREE_CODE (init) == ERROR_MARK)
656 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
657 a template function. This gets substituted during instantiation. */
660 /* We must strip the outermost array type when completing the type,
661 because the its bounds might be incomplete at the moment. */
662 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
663 ? TREE_TYPE (type) : type, NULL_TREE))
664 return error_mark_node;
666 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
667 if (TREE_CODE (init) == NON_LVALUE_EXPR)
668 init = TREE_OPERAND (init, 0);
670 if (BRACE_ENCLOSED_INITIALIZER_P (init)
671 && CONSTRUCTOR_ELTS (init) != 0
672 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
674 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
675 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
676 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
677 element = TREE_OPERAND (element, 0);
678 if (element == error_mark_node)
682 /* Initialization of an array of chars from a string constant
683 optionally enclosed in braces. */
685 if (code == ARRAY_TYPE)
689 if (TREE_CODE (init) == TREE_LIST)
691 error ("initializing array with parameter list");
692 return error_mark_node;
695 typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
696 if (char_type_p (typ1)
697 && ((init && TREE_CODE (init) == STRING_CST)
698 || (element && TREE_CODE (element) == STRING_CST)))
700 tree string = element ? element : init;
702 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
704 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
706 error ("char-array initialized from wide string");
707 return error_mark_node;
709 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
711 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
713 error ("int-array initialized from non-wide string");
714 return error_mark_node;
717 TREE_TYPE (string) = type;
718 if (TYPE_DOMAIN (type) != 0
719 && TREE_CONSTANT (TYPE_SIZE (type)))
721 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
722 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
723 /* In C it is ok to subtract 1 from the length of the string
724 because it's ok to ignore the terminating null char that is
725 counted in the length of the constant, but in C++ this would
727 if (size < TREE_STRING_LENGTH (string))
728 pedwarn ("initializer-string for array of chars is too long");
734 /* Handle scalar types, including conversions,
735 and signature pointers and references. */
737 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
738 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
739 || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
740 || TYPE_PTR_TO_MEMBER_P (type))
742 if (BRACE_ENCLOSED_INITIALIZER_P (init))
746 error ("initializer for scalar variable requires one element");
747 return error_mark_node;
751 while (BRACE_ENCLOSED_INITIALIZER_P (init))
753 pedwarn ("braces around scalar initializer for `%T'", type);
754 init = CONSTRUCTOR_ELTS (init);
755 if (TREE_CHAIN (init))
756 pedwarn ("ignoring extra initializers for `%T'", type);
757 init = TREE_VALUE (init);
760 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
761 "initialization", NULL_TREE, 0);
764 /* Come here only for records and arrays (and unions with constructors). */
766 if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
768 error ("variable-sized object of type `%T' may not be initialized",
770 return error_mark_node;
773 if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
775 if (BRACE_ENCLOSED_INITIALIZER_P (init))
777 if (TYPE_NON_AGGREGATE_CLASS (type))
779 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
781 return error_mark_node;
783 return process_init_constructor (type, init, (tree *)0);
785 else if (can_convert_arg (type, TREE_TYPE (init), init)
786 || TYPE_NON_AGGREGATE_CLASS (type))
787 /* These are never initialized from multiple constructor elements. */;
790 *tail = old_tail_contents;
791 return process_init_constructor (type, 0, tail);
794 if (code != ARRAY_TYPE)
796 int flags = LOOKUP_NORMAL;
797 /* Initialization from { } is copy-initialization. */
799 flags |= LOOKUP_ONLYCONVERTING;
801 return convert_for_initialization (NULL_TREE, type, init, flags,
802 "initialization", NULL_TREE, 0);
806 error ("invalid initializer");
807 return error_mark_node;
810 /* Process a constructor for a variable of type TYPE.
811 The constructor elements may be specified either with INIT or with ELTS,
812 only one of which should be non-null.
814 If INIT is specified, it is a CONSTRUCTOR node which is specifically
815 and solely for initializing this datum.
817 If ELTS is specified, it is the address of a variable containing
818 a list of expressions. We take as many elements as we need
819 from the head of the list and update the list.
821 In the resulting constructor, TREE_CONSTANT is set if all elts are
822 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
823 constants that the assembler and linker can compute them. */
826 process_init_constructor (tree type, tree init, tree* elts)
829 /* List of the elements of the result constructor,
838 /* Make TAIL be the list of elements to use for the initialization,
839 no matter how the data was given to us. */
843 if (warn_missing_braces)
844 warning ("aggregate has a partly bracketed initializer");
848 tail = CONSTRUCTOR_ELTS (init);
850 /* Gobble as many elements as needed, and make a constructor or initial value
851 for each element of this aggregate. Chain them together in result.
852 If there are too few, use 0 for each scalar ultimate component. */
854 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
859 if (TREE_CODE (type) == ARRAY_TYPE)
861 tree domain = TYPE_DOMAIN (type);
863 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
864 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
867 len = -1; /* Take as many as there are. */
871 /* Vectors are like simple fixed-size arrays. */
872 len = TYPE_VECTOR_SUBPARTS (type);
875 for (i = 0; len < 0 || i < len; i++)
879 if (TREE_PURPOSE (tail)
880 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
881 || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
882 sorry ("non-trivial labeled initializers");
884 if (TREE_VALUE (tail) != 0)
887 next1 = digest_init (TREE_TYPE (type),
888 TREE_VALUE (tail), &tail1);
889 if (next1 == error_mark_node)
892 (same_type_ignoring_top_level_qualifiers_p
893 (TREE_TYPE (type), TREE_TYPE (next1)),
895 my_friendly_assert (tail1 == 0
896 || TREE_CODE (tail1) == TREE_LIST, 319);
897 if (tail == tail1 && len < 0)
899 error ("non-empty initializer for array of empty elements");
900 /* Just ignore what we were supposed to use. */
907 next1 = error_mark_node;
908 tail = TREE_CHAIN (tail);
914 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
916 /* If this type needs constructors run for
917 default-initialization, we can't rely on the backend to do it
918 for us, so build up TARGET_EXPRs. If the type in question is
919 a class, just build one up; if it's an array, recurse. */
921 if (IS_AGGR_TYPE (TREE_TYPE (type)))
922 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
924 next1 = build_constructor (NULL_TREE, NULL_TREE);
925 next1 = digest_init (TREE_TYPE (type), next1, 0);
927 else if (! zero_init_p (TREE_TYPE (type)))
928 next1 = build_zero_init (TREE_TYPE (type),
930 /*static_storage_p=*/false);
932 /* The default zero-initialization is fine for us; don't
933 add anything to the CONSTRUCTOR. */
936 if (next1 == error_mark_node)
938 else if (!TREE_CONSTANT (next1))
940 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
942 members = tree_cons (size_int (i), next1, members);
945 else if (TREE_CODE (type) == RECORD_TYPE)
951 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
953 sorry ("initializer list for object of class with virtual base classes");
954 return error_mark_node;
957 if (TYPE_BINFO (type) && BINFO_BASE_BINFOS (TYPE_BINFO (type)))
959 sorry ("initializer list for object of class with base classes");
960 return error_mark_node;
963 if (TYPE_POLYMORPHIC_P (type))
965 sorry ("initializer list for object using virtual functions");
966 return error_mark_node;
970 for (field = TYPE_FIELDS (type); field;
971 field = TREE_CHAIN (field))
973 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
975 members = tree_cons (field, integer_zero_node, members);
979 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
984 if (TREE_PURPOSE (tail)
985 && TREE_PURPOSE (tail) != field
986 && TREE_PURPOSE (tail) != DECL_NAME (field))
987 sorry ("non-trivial labeled initializers");
989 if (TREE_VALUE (tail) != 0)
993 next1 = digest_init (TREE_TYPE (field),
994 TREE_VALUE (tail), &tail1);
995 my_friendly_assert (tail1 == 0
996 || TREE_CODE (tail1) == TREE_LIST, 320);
1001 next1 = error_mark_node;
1002 tail = TREE_CHAIN (tail);
1005 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1007 /* If this type needs constructors run for
1008 default-initialization, we can't rely on the backend to do it
1009 for us, so build up TARGET_EXPRs. If the type in question is
1010 a class, just build one up; if it's an array, recurse. */
1012 if (IS_AGGR_TYPE (TREE_TYPE (field)))
1013 next1 = build_functional_cast (TREE_TYPE (field),
1017 next1 = build_constructor (NULL_TREE, NULL_TREE);
1019 TREE_HAS_CONSTRUCTOR (next1)
1020 = TREE_HAS_CONSTRUCTOR (init);
1022 next1 = digest_init (TREE_TYPE (field), next1, 0);
1024 /* Warn when some struct elements are implicitly initialized. */
1026 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
1027 warning ("missing initializer for member `%D'", field);
1031 if (TREE_READONLY (field))
1032 error ("uninitialized const member `%D'", field);
1033 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1034 error ("member `%D' with uninitialized const fields",
1036 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1037 error ("member `%D' is uninitialized reference", field);
1039 /* Warn when some struct elements are implicitly initialized
1042 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
1043 warning ("missing initializer for member `%D'", field);
1045 if (! zero_init_p (TREE_TYPE (field)))
1046 next1 = build_zero_init (TREE_TYPE (field),
1047 /*nelts=*/NULL_TREE,
1048 /*static_storage_p=*/false);
1050 /* The default zero-initialization is fine for us; don't
1051 add anything to the CONSTRUCTOR. */
1055 if (next1 == error_mark_node)
1057 else if (!TREE_CONSTANT (next1))
1059 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
1061 members = tree_cons (field, next1, members);
1064 else if (TREE_CODE (type) == UNION_TYPE
1065 /* If the initializer was empty, use default zero initialization. */
1068 tree field = TYPE_FIELDS (type);
1070 /* Find the first named field. ANSI decided in September 1990
1071 that only named fields count here. */
1072 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1073 field = TREE_CHAIN (field);
1075 /* If this element specifies a field, initialize via that field. */
1076 if (TREE_PURPOSE (tail) != NULL_TREE)
1080 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
1081 /* Handle the case of a call by build_c_cast. */
1082 field = TREE_PURPOSE (tail), win = 1;
1083 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
1084 error ("index value instead of field name in union initializer");
1088 for (temp = TYPE_FIELDS (type);
1090 temp = TREE_CHAIN (temp))
1091 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
1094 field = temp, win = 1;
1096 error ("no field `%D' in union being initialized",
1097 TREE_PURPOSE (tail));
1100 TREE_VALUE (tail) = error_mark_node;
1102 else if (field == 0)
1104 error ("union `%T' with no named members cannot be initialized",
1106 TREE_VALUE (tail) = error_mark_node;
1109 if (TREE_VALUE (tail) != 0)
1113 next1 = digest_init (TREE_TYPE (field),
1114 TREE_VALUE (tail), &tail1);
1115 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
1121 next1 = error_mark_node;
1122 tail = TREE_CHAIN (tail);
1125 if (next1 == error_mark_node)
1127 else if (!TREE_CONSTANT (next1))
1129 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
1131 members = tree_cons (field, next1, members);
1134 /* If arguments were specified as a list, just remove the ones we used. */
1137 /* If arguments were specified as a constructor,
1138 complain unless we used all the elements of the constructor. */
1140 pedwarn ("excess elements in aggregate initializer");
1143 return error_mark_node;
1145 result = build_constructor (type, nreverse (members));
1146 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1147 complete_array_type (type, result, /*do_default=*/0);
1149 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1152 TREE_CONSTANT (result) = 1;
1153 TREE_INVARIANT (result) = 1;
1155 TREE_STATIC (result) = 1;
1160 /* Given a structure or union value DATUM, construct and return
1161 the structure or union component which results from narrowing
1162 that value to the base specified in BASETYPE. For example, given the
1165 class L { int ii; };
1166 class A : L { ... };
1167 class B : L { ... };
1168 class C : A, B { ... };
1176 x.A::ii refers to the ii member of the L part of
1177 the A part of the C object named by X. In this case,
1178 DATUM would be x, and BASETYPE would be A.
1180 I used to think that this was nonconformant, that the standard specified
1181 that first we look up ii in A, then convert x to an L& and pull out the
1182 ii part. But in fact, it does say that we convert x to an A&; A here
1183 is known as the "naming class". (jason 2000-12-19)
1185 BINFO_P points to a variable initialized either to NULL_TREE or to the
1186 binfo for the specific base subobject we want to convert to. */
1189 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1193 if (datum == error_mark_node)
1194 return error_mark_node;
1198 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1200 if (!binfo || binfo == error_mark_node)
1202 *binfo_p = NULL_TREE;
1204 error_not_base_type (basetype, TREE_TYPE (datum));
1205 return error_mark_node;
1209 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1212 /* Build a reference to an object specified by the C++ `->' operator.
1213 Usually this just involves dereferencing the object, but if the
1214 `->' operator is overloaded, then such overloads must be
1215 performed until an object which does not have the `->' operator
1216 overloaded is found. An error is reported when circular pointer
1217 delegation is detected. */
1220 build_x_arrow (tree expr)
1222 tree orig_expr = expr;
1223 tree types_memoized = NULL_TREE;
1224 tree type = TREE_TYPE (expr);
1225 tree last_rval = NULL_TREE;
1227 if (type == error_mark_node)
1228 return error_mark_node;
1230 if (processing_template_decl)
1232 if (type_dependent_expression_p (expr))
1233 return build_min_nt (ARROW_EXPR, expr);
1234 expr = build_non_dependent_expr (expr);
1237 if (TREE_CODE (type) == REFERENCE_TYPE)
1239 expr = convert_from_reference (expr);
1240 type = TREE_TYPE (expr);
1243 if (IS_AGGR_TYPE (type))
1245 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1246 NULL_TREE, NULL_TREE,
1247 /*overloaded_p=*/NULL)))
1249 if (expr == error_mark_node)
1250 return error_mark_node;
1252 if (value_member (TREE_TYPE (expr), types_memoized))
1254 error ("circular pointer delegation detected");
1255 return error_mark_node;
1259 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1265 if (last_rval == NULL_TREE)
1267 error ("base operand of `->' has non-pointer type `%T'", type);
1268 return error_mark_node;
1271 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1272 last_rval = convert_from_reference (last_rval);
1275 last_rval = decay_conversion (expr);
1277 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1279 if (processing_template_decl)
1281 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1282 /* It will be dereferenced. */
1283 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1287 return build_indirect_ref (last_rval, NULL);
1291 error ("result of `operator->()' yields non-pointer result");
1293 error ("base operand of `->' is not a pointer");
1294 return error_mark_node;
1297 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1298 already been checked out to be of aggregate type. */
1301 build_m_component_ref (tree datum, tree component)
1309 datum = decay_conversion (datum);
1311 if (datum == error_mark_node || component == error_mark_node)
1312 return error_mark_node;
1314 ptrmem_type = TREE_TYPE (component);
1315 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1317 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1318 component, ptrmem_type);
1319 return error_mark_node;
1322 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1323 if (! IS_AGGR_TYPE (objtype))
1325 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1326 component, datum, objtype);
1327 return error_mark_node;
1330 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1331 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1333 if (!COMPLETE_TYPE_P (ctype))
1335 if (!same_type_p (ctype, objtype))
1341 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1346 error ("pointer to member type `%T' incompatible with object type `%T'",
1348 return error_mark_node;
1350 else if (binfo == error_mark_node)
1351 return error_mark_node;
1354 if (TYPE_PTRMEM_P (ptrmem_type))
1356 /* Compute the type of the field, as described in [expr.ref].
1357 There's no such thing as a mutable pointer-to-member, so
1358 things are not as complex as they are for references to
1359 non-static data members. */
1360 type = cp_build_qualified_type (type,
1361 (cp_type_quals (type)
1362 | cp_type_quals (TREE_TYPE (datum))));
1364 datum = build_address (datum);
1366 /* Convert object to the correct base. */
1368 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1370 /* Build an expression for "object + offset" where offset is the
1371 value stored in the pointer-to-data-member. */
1372 datum = build (PLUS_EXPR, build_pointer_type (type),
1373 datum, build_nop (ptrdiff_type_node, component));
1374 return build_indirect_ref (datum, 0);
1377 return build (OFFSET_REF, type, datum, component);
1380 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1383 build_functional_cast (tree exp, tree parms)
1385 /* This is either a call to a constructor,
1386 or a C cast in C++'s `functional' notation. */
1389 if (exp == error_mark_node || parms == error_mark_node)
1390 return error_mark_node;
1392 if (TREE_CODE (exp) == TYPE_DECL)
1393 type = TREE_TYPE (exp);
1397 if (processing_template_decl)
1399 tree t = build_min (CAST_EXPR, type, parms);
1400 /* We don't know if it will or will not have side effects. */
1401 TREE_SIDE_EFFECTS (t) = 1;
1405 if (! IS_AGGR_TYPE (type))
1407 /* This must build a C cast. */
1408 if (parms == NULL_TREE)
1409 parms = integer_zero_node;
1411 parms = build_x_compound_expr_from_list (parms, "functional cast");
1413 return build_c_cast (type, parms);
1416 /* Prepare to evaluate as a call to a constructor. If this expression
1417 is actually used, for example,
1419 return X (arg1, arg2, ...);
1421 then the slot being initialized will be filled in. */
1423 if (!complete_type_or_else (type, NULL_TREE))
1424 return error_mark_node;
1425 if (abstract_virtuals_error (NULL_TREE, type))
1426 return error_mark_node;
1428 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1429 return build_c_cast (type, TREE_VALUE (parms));
1431 /* We need to zero-initialize POD types. Let's do that for everything
1432 that doesn't need a constructor. */
1433 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1434 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1436 exp = build_constructor (type, NULL_TREE);
1437 return get_target_expr (exp);
1440 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1441 type, LOOKUP_NORMAL);
1443 if (exp == error_mark_node)
1444 return error_mark_node;
1446 return build_cplus_new (type, exp);
1450 /* Add new exception specifier SPEC, to the LIST we currently have.
1451 If it's already in LIST then do nothing.
1452 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1453 know what we're doing. */
1456 add_exception_specifier (tree list, tree spec, int complain)
1461 int diag_type = -1; /* none */
1463 if (spec == error_mark_node)
1466 my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1468 /* [except.spec] 1, type in an exception specifier shall not be
1469 incomplete, or pointer or ref to incomplete other than pointer
1471 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1472 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1473 core = TREE_TYPE (core);
1476 else if (VOID_TYPE_P (core))
1478 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1480 else if (processing_template_decl)
1485 /* 15.4/1 says that types in an exception specifier must be complete,
1486 but it seems more reasonable to only require this on definitions
1487 and calls. So just give a pedwarn at this point; we will give an
1488 error later if we hit one of those two cases. */
1489 if (!COMPLETE_TYPE_P (complete_type (core)))
1490 diag_type = 2; /* pedwarn */
1497 for (probe = list; probe; probe = TREE_CHAIN (probe))
1498 if (same_type_p (TREE_VALUE (probe), spec))
1501 list = tree_cons (NULL_TREE, spec, list);
1504 diag_type = 0; /* error */
1506 if (diag_type >= 0 && complain)
1507 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1512 /* Combine the two exceptions specifier lists LIST and ADD, and return
1516 merge_exception_specifiers (tree list, tree add)
1520 else if (!TREE_VALUE (list))
1522 else if (!TREE_VALUE (add))
1526 tree orig_list = list;
1528 for (; add; add = TREE_CHAIN (add))
1530 tree spec = TREE_VALUE (add);
1533 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1534 if (same_type_p (TREE_VALUE (probe), spec))
1538 spec = build_tree_list (NULL_TREE, spec);
1539 TREE_CHAIN (spec) = list;
1547 /* Subroutine of build_call. Ensure that each of the types in the
1548 exception specification is complete. Technically, 15.4/1 says that
1549 they need to be complete when we see a declaration of the function,
1550 but we should be able to get away with only requiring this when the
1551 function is defined or called. See also add_exception_specifier. */
1554 require_complete_eh_spec_types (tree fntype, tree decl)
1557 /* Don't complain about calls to op new. */
1558 if (decl && DECL_ARTIFICIAL (decl))
1560 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1561 raises = TREE_CHAIN (raises))
1563 tree type = TREE_VALUE (raises);
1564 if (type && !COMPLETE_TYPE_P (type))
1568 ("call to function `%D' which throws incomplete type `%#T'",
1571 error ("call to function which throws incomplete type `%#T'",
1578 #include "gt-cp-typeck2.h"