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 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* This file is part of the C++ front end.
26 It contains routines to build C++ expressions given their operands,
27 including computing the types of the result, C and C++ specific error
28 checks, and some optimization.
30 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
31 and to process initializations in declarations (since they work
32 like a strange sort of assignment). */
36 #include "coretypes.h"
43 #include "diagnostic.h"
45 static tree process_init_constructor (tree, tree, tree *);
47 /* Print an error message stemming from an attempt to use
48 BASETYPE as a base class for TYPE. */
51 error_not_base_type (tree basetype, tree type)
53 if (TREE_CODE (basetype) == FUNCTION_DECL)
54 basetype = DECL_CONTEXT (basetype);
55 error ("type `%T' is not a base type for type `%T'", basetype, type);
56 return error_mark_node;
60 binfo_or_else (tree base, tree type)
62 tree binfo = lookup_base (type, base, ba_ignore, NULL);
64 if (binfo == error_mark_node)
67 error_not_base_type (base, type);
71 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
72 value may not be changed thereafter. Thus, we emit hard errors for these,
73 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
74 example, conversions to references.) */
77 readonly_error (tree arg, const char* string, int soft)
80 void (*fn) (const char *, ...);
87 if (TREE_CODE (arg) == COMPONENT_REF)
89 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
90 fmt = "%s of data-member `%D' in read-only structure";
92 fmt = "%s of read-only data-member `%D'";
93 (*fn) (fmt, string, TREE_OPERAND (arg, 1));
95 else if (TREE_CODE (arg) == VAR_DECL)
97 if (DECL_LANG_SPECIFIC (arg)
98 && DECL_IN_AGGR_P (arg)
99 && !TREE_STATIC (arg))
100 fmt = "%s of constant field `%D'";
102 fmt = "%s of read-only variable `%D'";
103 (*fn) (fmt, string, arg);
105 else if (TREE_CODE (arg) == PARM_DECL)
106 (*fn) ("%s of read-only parameter `%D'", string, arg);
107 else if (TREE_CODE (arg) == INDIRECT_REF
108 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
109 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
110 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
111 (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0));
112 else if (TREE_CODE (arg) == RESULT_DECL)
113 (*fn) ("%s of read-only named return value `%D'", string, arg);
114 else if (TREE_CODE (arg) == FUNCTION_DECL)
115 (*fn) ("%s of function `%D'", string, arg);
117 (*fn) ("%s of read-only location", string);
120 /* If TYPE has abstract virtual functions, issue an error about trying
121 to create an object of that type. DECL is the object declared, or
122 NULL_TREE if the declaration is unavailable. Returns 1 if an error
123 occurred; zero if all was well. */
126 abstract_virtuals_error (tree decl, tree type)
131 if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type))
134 if (!TYPE_SIZE (type))
135 /* TYPE is being defined, and during that time
136 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
139 if (dependent_type_p (type))
140 /* For a dependent type, we do not yet know which functions are pure
144 u = CLASSTYPE_PURE_VIRTUALS (type);
147 if (TREE_CODE (decl) == RESULT_DECL)
150 if (TREE_CODE (decl) == VAR_DECL)
151 error ("cannot declare variable `%D' to be of type `%T'",
153 else if (TREE_CODE (decl) == PARM_DECL)
154 error ("cannot declare parameter `%D' to be of type `%T'",
156 else if (TREE_CODE (decl) == FIELD_DECL)
157 error ("cannot declare field `%D' to be of type `%T'",
159 else if (TREE_CODE (decl) == FUNCTION_DECL
160 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
161 error ("invalid return type for member function `%#D'", decl);
162 else if (TREE_CODE (decl) == FUNCTION_DECL)
163 error ("invalid return type for function `%#D'", decl);
166 error ("cannot allocate an object of type `%T'", type);
168 /* Only go through this once. */
169 if (TREE_PURPOSE (u) == NULL_TREE)
171 TREE_PURPOSE (u) = error_mark_node;
173 error (" because the following virtual functions are abstract:");
174 for (tu = u; tu; tu = TREE_CHAIN (tu))
175 cp_error_at ("\t%#D", TREE_VALUE (tu));
178 error (" since type `%T' has abstract virtual functions", type);
183 /* Print an error message for invalid use of an incomplete type.
184 VALUE is the expression that was used (or 0 if that isn't known)
185 and TYPE is the type that was invalid. DIAG_TYPE indicates the
186 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
190 cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
193 void (*p_msg) (const char *, ...);
194 void (*p_msg_at) (const char *, ...);
199 p_msg_at = cp_warning_at;
201 else if (diag_type == 2)
204 p_msg_at = cp_pedwarn_at;
209 p_msg_at = cp_error_at;
212 /* Avoid duplicate error message. */
213 if (TREE_CODE (type) == ERROR_MARK)
216 if (value != 0 && (TREE_CODE (value) == VAR_DECL
217 || TREE_CODE (value) == PARM_DECL
218 || TREE_CODE (value) == FIELD_DECL))
220 (*p_msg_at) ("`%D' has incomplete type", value);
224 /* We must print an error message. Be clever about what it says. */
226 switch (TREE_CODE (type))
232 (*p_msg) ("invalid use of undefined type `%#T'", type);
233 if (!TYPE_TEMPLATE_INFO (type))
234 (*p_msg_at) ("forward declaration of `%#T'", type);
236 (*p_msg_at) ("declaration of `%#T'", type);
240 (*p_msg) ("invalid use of `%T'", type);
244 if (TYPE_DOMAIN (type))
246 type = TREE_TYPE (type);
249 (*p_msg) ("invalid use of array with unspecified bounds");
254 (*p_msg) ("invalid use of member (did you forget the `&' ?)");
257 case TEMPLATE_TYPE_PARM:
258 (*p_msg) ("invalid use of template type parameter");
262 if (value && TREE_CODE (value) == COMPONENT_REF)
264 else if (value && TREE_CODE (value) == ADDR_EXPR)
265 (*p_msg) ("address of overloaded function with no contextual type information");
266 else if (value && TREE_CODE (value) == OVERLOAD)
267 (*p_msg) ("overloaded function with no contextual type information");
269 (*p_msg) ("insufficient contextual information to determine type");
277 /* Backward-compatibility interface to incomplete_type_diagnostic;
278 required by ../tree.c. */
279 #undef cxx_incomplete_type_error
281 cxx_incomplete_type_error (tree value, tree type)
283 cxx_incomplete_type_diagnostic (value, type, 0);
287 /* The recursive part of split_nonconstant_init. DEST is an lvalue
288 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
289 PCODE is a pointer to the tail of a chain of statements being emitted.
290 The return value is the new tail of that chain after new statements
294 split_nonconstant_init_1 (tree dest, tree init, tree *pcode)
296 tree *pelt, elt, type = TREE_TYPE (dest);
297 tree sub, code, inner_type = NULL;
298 bool array_type_p = false;
300 pelt = &CONSTRUCTOR_ELTS (init);
301 switch (TREE_CODE (type))
304 inner_type = TREE_TYPE (type);
310 case QUAL_UNION_TYPE:
311 while ((elt = *pelt))
313 tree field_index = TREE_PURPOSE (elt);
314 tree value = TREE_VALUE (elt);
317 inner_type = TREE_TYPE (field_index);
319 if (TREE_CODE (value) == CONSTRUCTOR)
322 sub = build (ARRAY_REF, inner_type, dest, field_index);
324 sub = build (COMPONENT_REF, inner_type, dest, field_index);
326 pcode = split_nonconstant_init_1 (sub, value, pcode);
328 else if (!initializer_constant_valid_p (value, inner_type))
330 *pelt = TREE_CHAIN (elt);
333 sub = build (ARRAY_REF, inner_type, dest, field_index);
335 sub = build (COMPONENT_REF, inner_type, dest, field_index);
337 code = build (MODIFY_EXPR, inner_type, sub, value);
338 code = build_stmt (EXPR_STMT, code);
341 pcode = &TREE_CHAIN (code);
344 pelt = &TREE_CHAIN (elt);
349 if (!initializer_constant_valid_p (init, type))
351 CONSTRUCTOR_ELTS (init) = NULL;
352 code = build (MODIFY_EXPR, type, dest, init);
353 code = build_stmt (EXPR_STMT, code);
354 pcode = &TREE_CHAIN (code);
365 /* A subroutine of store_init_value. Splits non-constant static
366 initializer INIT into a constant part and generates code to
367 perform the non-constant part of the initialization to DEST.
368 Returns the code for the runtime init. */
371 split_nonconstant_init (tree dest, tree init)
375 if (TREE_CODE (init) == CONSTRUCTOR)
377 code = build_stmt (COMPOUND_STMT, NULL_TREE);
378 split_nonconstant_init_1 (dest, init, &COMPOUND_BODY (code));
379 code = build1 (STMT_EXPR, void_type_node, code);
380 TREE_SIDE_EFFECTS (code) = 1;
381 DECL_INITIAL (dest) = init;
384 code = build (INIT_EXPR, TREE_TYPE (dest), dest, init);
389 /* Perform appropriate conversions on the initial value of a variable,
390 store it in the declaration DECL,
391 and print any error messages that are appropriate.
392 If the init is invalid, store an ERROR_MARK.
394 C++: Note that INIT might be a TREE_LIST, which would mean that it is
395 a base class initializer for some aggregate type, hopefully compatible
396 with DECL. If INIT is a single element, and DECL is an aggregate
397 type, we silently convert INIT into a TREE_LIST, allowing a constructor
400 If INIT is a TREE_LIST and there is no constructor, turn INIT
401 into a CONSTRUCTOR and use standard initialization techniques.
402 Perhaps a warning should be generated?
404 Returns code to be executed if initialization could not be performed
405 for static variable. In that case, caller must emit the code. */
408 store_init_value (tree decl, tree init)
412 /* If variable's type was invalidly declared, just ignore it. */
414 type = TREE_TYPE (decl);
415 if (TREE_CODE (type) == ERROR_MARK)
418 if (IS_AGGR_TYPE (type))
420 if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
421 && TREE_CODE (init) != CONSTRUCTOR)
424 if (TREE_CODE (init) == TREE_LIST)
426 error ("constructor syntax used, but no constructor declared for type `%T'", type);
427 init = build_constructor (NULL_TREE, nreverse (init));
430 else if (TREE_CODE (init) == TREE_LIST
431 && TREE_TYPE (init) != unknown_type_node)
433 if (TREE_CODE (decl) == RESULT_DECL)
434 init = build_x_compound_expr_from_list (init,
435 "return value initializer");
436 else if (TREE_CODE (init) == TREE_LIST
437 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
439 error ("cannot initialize arrays using this syntax");
443 /* We get here with code like `int a (2);' */
444 init = build_x_compound_expr_from_list (init, "initializer");
447 /* End of special C++ code. */
449 /* Digest the specified initializer into an expression. */
450 value = digest_init (type, init, (tree *) 0);
452 /* Store the expression if valid; else report error. */
454 if (TREE_CODE (value) == ERROR_MARK)
456 /* Other code expects that initializers for objects of types that need
457 constructing never make it into DECL_INITIAL, and passes 'init' to
458 build_aggr_init without checking DECL_INITIAL. So just return. */
459 else if (TYPE_NEEDS_CONSTRUCTING (type))
460 return build (INIT_EXPR, type, decl, value);
461 else if (TREE_STATIC (decl)
462 && (! TREE_CONSTANT (value)
463 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
464 return split_nonconstant_init (decl, value);
466 /* Store the VALUE in DECL_INITIAL. If we're building a
467 statement-tree we will actually expand the initialization later
468 when we output this function. */
469 DECL_INITIAL (decl) = value;
474 /* Digest the parser output INIT as an initializer for type TYPE.
475 Return a C expression of type TYPE to represent the initial value.
477 If TAIL is nonzero, it points to a variable holding a list of elements
478 of which INIT is the first. We update the list stored there by
479 removing from the head all the elements that we use.
480 Normally this is only one; we use more than one element only if
481 TYPE is an aggregate and INIT is not a constructor. */
484 digest_init (tree type, tree init, tree* tail)
486 enum tree_code code = TREE_CODE (type);
487 tree element = NULL_TREE;
488 tree old_tail_contents = NULL_TREE;
489 /* Nonzero if INIT is a braced grouping. */
492 /* By default, assume we use one element from a list.
493 We correct this later in the sole case where it is not true. */
497 old_tail_contents = *tail;
498 *tail = TREE_CHAIN (*tail);
501 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
502 && TREE_VALUE (init) == error_mark_node))
503 return error_mark_node;
505 if (TREE_CODE (init) == ERROR_MARK)
506 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
507 a template function. This gets substituted during instantiation. */
510 /* We must strip the outermost array type when completing the type,
511 because the its bounds might be incomplete at the moment. */
512 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
513 ? TREE_TYPE (type) : type, NULL_TREE))
514 return error_mark_node;
516 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
517 if (TREE_CODE (init) == NON_LVALUE_EXPR)
518 init = TREE_OPERAND (init, 0);
520 raw_constructor = (TREE_CODE (init) == CONSTRUCTOR
521 && TREE_HAS_CONSTRUCTOR (init));
524 && CONSTRUCTOR_ELTS (init) != 0
525 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
527 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
528 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
529 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
530 element = TREE_OPERAND (element, 0);
531 if (element == error_mark_node)
535 /* Initialization of an array of chars from a string constant
536 optionally enclosed in braces. */
538 if (code == ARRAY_TYPE)
542 if (TREE_CODE (init) == TREE_LIST)
544 error ("initializing array with parameter list");
545 return error_mark_node;
548 typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
549 if (char_type_p (typ1)
550 && ((init && TREE_CODE (init) == STRING_CST)
551 || (element && TREE_CODE (element) == STRING_CST)))
553 tree string = element ? element : init;
555 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
557 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
559 error ("char-array initialized from wide string");
560 return error_mark_node;
562 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
564 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
566 error ("int-array initialized from non-wide string");
567 return error_mark_node;
570 TREE_TYPE (string) = type;
571 if (TYPE_DOMAIN (type) != 0
572 && TREE_CONSTANT (TYPE_SIZE (type)))
574 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
575 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
576 /* In C it is ok to subtract 1 from the length of the string
577 because it's ok to ignore the terminating null char that is
578 counted in the length of the constant, but in C++ this would
580 if (size < TREE_STRING_LENGTH (string))
581 pedwarn ("initializer-string for array of chars is too long");
587 /* Handle scalar types, including conversions,
588 and signature pointers and references. */
590 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
591 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
592 || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
593 || TYPE_PTR_TO_MEMBER_P (type))
599 error ("initializer for scalar variable requires one element");
600 return error_mark_node;
604 while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
606 pedwarn ("braces around scalar initializer for `%T'", type);
607 init = CONSTRUCTOR_ELTS (init);
608 if (TREE_CHAIN (init))
609 pedwarn ("ignoring extra initializers for `%T'", type);
610 init = TREE_VALUE (init);
613 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
614 "initialization", NULL_TREE, 0);
617 /* Come here only for records and arrays (and unions with constructors). */
619 if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
621 error ("variable-sized object of type `%T' may not be initialized",
623 return error_mark_node;
626 if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
628 if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)
629 && TREE_HAS_CONSTRUCTOR (init))
631 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
633 return error_mark_node;
635 else if (raw_constructor)
636 return process_init_constructor (type, init, (tree *)0);
637 else if (can_convert_arg (type, TREE_TYPE (init), init)
638 || TYPE_NON_AGGREGATE_CLASS (type))
639 /* These are never initialized from multiple constructor elements. */;
642 *tail = old_tail_contents;
643 return process_init_constructor (type, 0, tail);
646 if (code != ARRAY_TYPE)
648 int flags = LOOKUP_NORMAL;
649 /* Initialization from { } is copy-initialization. */
651 flags |= LOOKUP_ONLYCONVERTING;
653 return convert_for_initialization (NULL_TREE, type, init, flags,
654 "initialization", NULL_TREE, 0);
658 error ("invalid initializer");
659 return error_mark_node;
662 /* Process a constructor for a variable of type TYPE.
663 The constructor elements may be specified either with INIT or with ELTS,
664 only one of which should be non-null.
666 If INIT is specified, it is a CONSTRUCTOR node which is specifically
667 and solely for initializing this datum.
669 If ELTS is specified, it is the address of a variable containing
670 a list of expressions. We take as many elements as we need
671 from the head of the list and update the list.
673 In the resulting constructor, TREE_CONSTANT is set if all elts are
674 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
675 constants that the assembler and linker can compute them. */
678 process_init_constructor (tree type, tree init, tree* elts)
681 /* List of the elements of the result constructor,
690 /* Make TAIL be the list of elements to use for the initialization,
691 no matter how the data was given to us. */
695 if (warn_missing_braces)
696 warning ("aggregate has a partly bracketed initializer");
700 tail = CONSTRUCTOR_ELTS (init);
702 /* Gobble as many elements as needed, and make a constructor or initial value
703 for each element of this aggregate. Chain them together in result.
704 If there are too few, use 0 for each scalar ultimate component. */
706 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
711 if (TREE_CODE (type) == ARRAY_TYPE)
713 tree domain = TYPE_DOMAIN (type);
715 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
716 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
719 len = -1; /* Take as many as there are. */
723 /* Vectors are like simple fixed-size arrays. */
724 len = TYPE_VECTOR_SUBPARTS (type);
727 for (i = 0; len < 0 || i < len; i++)
731 if (TREE_PURPOSE (tail)
732 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
733 || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
734 sorry ("non-trivial labeled initializers");
736 if (TREE_VALUE (tail) != 0)
739 next1 = digest_init (TREE_TYPE (type),
740 TREE_VALUE (tail), &tail1);
741 if (next1 == error_mark_node)
744 (same_type_ignoring_top_level_qualifiers_p
745 (TREE_TYPE (type), TREE_TYPE (next1)),
747 my_friendly_assert (tail1 == 0
748 || TREE_CODE (tail1) == TREE_LIST, 319);
749 if (tail == tail1 && len < 0)
751 error ("non-empty initializer for array of empty elements");
752 /* Just ignore what we were supposed to use. */
759 next1 = error_mark_node;
760 tail = TREE_CHAIN (tail);
766 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
768 /* If this type needs constructors run for
769 default-initialization, we can't rely on the backend to do it
770 for us, so build up TARGET_EXPRs. If the type in question is
771 a class, just build one up; if it's an array, recurse. */
773 if (IS_AGGR_TYPE (TREE_TYPE (type)))
774 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
776 next1 = build_constructor (NULL_TREE, NULL_TREE);
777 next1 = digest_init (TREE_TYPE (type), next1, 0);
779 else if (! zero_init_p (TREE_TYPE (type)))
780 next1 = build_zero_init (TREE_TYPE (type),
782 /*static_storage_p=*/false);
784 /* The default zero-initialization is fine for us; don't
785 add anything to the CONSTRUCTOR. */
788 if (next1 == error_mark_node)
790 else if (!TREE_CONSTANT (next1))
792 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
794 members = tree_cons (size_int (i), next1, members);
797 else if (TREE_CODE (type) == RECORD_TYPE)
803 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
805 sorry ("initializer list for object of class with virtual base classes");
806 return error_mark_node;
809 if (TYPE_BINFO_BASETYPES (type))
811 sorry ("initializer list for object of class with base classes");
812 return error_mark_node;
815 if (TYPE_POLYMORPHIC_P (type))
817 sorry ("initializer list for object using virtual functions");
818 return error_mark_node;
822 for (field = TYPE_FIELDS (type); field;
823 field = TREE_CHAIN (field))
825 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
827 members = tree_cons (field, integer_zero_node, members);
831 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
836 if (TREE_PURPOSE (tail)
837 && TREE_PURPOSE (tail) != field
838 && TREE_PURPOSE (tail) != DECL_NAME (field))
839 sorry ("non-trivial labeled initializers");
841 if (TREE_VALUE (tail) != 0)
845 next1 = digest_init (TREE_TYPE (field),
846 TREE_VALUE (tail), &tail1);
847 my_friendly_assert (tail1 == 0
848 || TREE_CODE (tail1) == TREE_LIST, 320);
853 next1 = error_mark_node;
854 tail = TREE_CHAIN (tail);
857 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
859 /* If this type needs constructors run for
860 default-initialization, we can't rely on the backend to do it
861 for us, so build up TARGET_EXPRs. If the type in question is
862 a class, just build one up; if it's an array, recurse. */
864 if (IS_AGGR_TYPE (TREE_TYPE (field)))
865 next1 = build_functional_cast (TREE_TYPE (field),
869 next1 = build_constructor (NULL_TREE, NULL_TREE);
871 TREE_HAS_CONSTRUCTOR (next1)
872 = TREE_HAS_CONSTRUCTOR (init);
874 next1 = digest_init (TREE_TYPE (field), next1, 0);
876 /* Warn when some struct elements are implicitly initialized. */
878 && (!init || TREE_HAS_CONSTRUCTOR (init)))
879 warning ("missing initializer for member `%D'", field);
883 if (TREE_READONLY (field))
884 error ("uninitialized const member `%D'", field);
885 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
886 error ("member `%D' with uninitialized const fields",
888 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
889 error ("member `%D' is uninitialized reference", field);
891 /* Warn when some struct elements are implicitly initialized
894 && (!init || TREE_HAS_CONSTRUCTOR (init)))
895 warning ("missing initializer for member `%D'", field);
897 if (! zero_init_p (TREE_TYPE (field)))
898 next1 = build_zero_init (TREE_TYPE (field),
900 /*static_storage_p=*/false);
902 /* The default zero-initialization is fine for us; don't
903 add anything to the CONSTRUCTOR. */
907 if (next1 == error_mark_node)
909 else if (!TREE_CONSTANT (next1))
911 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
913 members = tree_cons (field, next1, members);
916 else if (TREE_CODE (type) == UNION_TYPE
917 /* If the initializer was empty, use default zero initialization. */
920 tree field = TYPE_FIELDS (type);
922 /* Find the first named field. ANSI decided in September 1990
923 that only named fields count here. */
924 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
925 field = TREE_CHAIN (field);
927 /* If this element specifies a field, initialize via that field. */
928 if (TREE_PURPOSE (tail) != NULL_TREE)
932 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
933 /* Handle the case of a call by build_c_cast. */
934 field = TREE_PURPOSE (tail), win = 1;
935 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
936 error ("index value instead of field name in union initializer");
940 for (temp = TYPE_FIELDS (type);
942 temp = TREE_CHAIN (temp))
943 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
946 field = temp, win = 1;
948 error ("no field `%D' in union being initialized",
949 TREE_PURPOSE (tail));
952 TREE_VALUE (tail) = error_mark_node;
956 error ("union `%T' with no named members cannot be initialized",
958 TREE_VALUE (tail) = error_mark_node;
961 if (TREE_VALUE (tail) != 0)
965 next1 = digest_init (TREE_TYPE (field),
966 TREE_VALUE (tail), &tail1);
967 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
973 next1 = error_mark_node;
974 tail = TREE_CHAIN (tail);
977 if (next1 == error_mark_node)
979 else if (!TREE_CONSTANT (next1))
981 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
983 members = tree_cons (field, next1, members);
986 /* If arguments were specified as a list, just remove the ones we used. */
989 /* If arguments were specified as a constructor,
990 complain unless we used all the elements of the constructor. */
992 pedwarn ("excess elements in aggregate initializer");
995 return error_mark_node;
997 result = build_constructor (type, nreverse (members));
998 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
999 complete_array_type (type, result, /*do_default=*/0);
1001 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1002 if (allconstant) TREE_CONSTANT (result) = 1;
1003 if (allconstant && allsimple) TREE_STATIC (result) = 1;
1007 /* Given a structure or union value DATUM, construct and return
1008 the structure or union component which results from narrowing
1009 that value to the base specified in BASETYPE. For example, given the
1012 class L { int ii; };
1013 class A : L { ... };
1014 class B : L { ... };
1015 class C : A, B { ... };
1023 x.A::ii refers to the ii member of the L part of
1024 the A part of the C object named by X. In this case,
1025 DATUM would be x, and BASETYPE would be A.
1027 I used to think that this was nonconformant, that the standard specified
1028 that first we look up ii in A, then convert x to an L& and pull out the
1029 ii part. But in fact, it does say that we convert x to an A&; A here
1030 is known as the "naming class". (jason 2000-12-19)
1032 BINFO_P points to a variable initialized either to NULL_TREE or to the
1033 binfo for the specific base subobject we want to convert to. */
1036 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1040 if (datum == error_mark_node)
1041 return error_mark_node;
1045 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1047 if (!binfo || binfo == error_mark_node)
1049 *binfo_p = NULL_TREE;
1051 error_not_base_type (basetype, TREE_TYPE (datum));
1052 return error_mark_node;
1056 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1059 /* Build a reference to an object specified by the C++ `->' operator.
1060 Usually this just involves dereferencing the object, but if the
1061 `->' operator is overloaded, then such overloads must be
1062 performed until an object which does not have the `->' operator
1063 overloaded is found. An error is reported when circular pointer
1064 delegation is detected. */
1067 build_x_arrow (tree expr)
1069 tree orig_expr = expr;
1070 tree types_memoized = NULL_TREE;
1071 tree type = TREE_TYPE (expr);
1072 tree last_rval = NULL_TREE;
1074 if (type == error_mark_node)
1075 return error_mark_node;
1077 if (processing_template_decl)
1079 if (type_dependent_expression_p (expr))
1080 return build_min_nt (ARROW_EXPR, expr);
1081 expr = build_non_dependent_expr (expr);
1084 if (TREE_CODE (type) == REFERENCE_TYPE)
1086 expr = convert_from_reference (expr);
1087 type = TREE_TYPE (expr);
1090 if (IS_AGGR_TYPE (type))
1092 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1093 NULL_TREE, NULL_TREE)))
1095 if (expr == error_mark_node)
1096 return error_mark_node;
1098 if (value_member (TREE_TYPE (expr), types_memoized))
1100 error ("circular pointer delegation detected");
1101 return error_mark_node;
1105 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1111 if (last_rval == NULL_TREE)
1113 error ("base operand of `->' has non-pointer type `%T'", type);
1114 return error_mark_node;
1117 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1118 last_rval = convert_from_reference (last_rval);
1121 last_rval = decay_conversion (expr);
1123 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1125 if (processing_template_decl)
1127 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1128 /* It will be dereferenced. */
1129 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1133 return build_indirect_ref (last_rval, NULL);
1137 error ("result of `operator->()' yields non-pointer result");
1139 error ("base operand of `->' is not a pointer");
1140 return error_mark_node;
1143 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1144 already been checked out to be of aggregate type. */
1147 build_m_component_ref (tree datum, tree component)
1154 datum = decay_conversion (datum);
1156 if (datum == error_mark_node || component == error_mark_node)
1157 return error_mark_node;
1159 ptrmem_type = TREE_TYPE (component);
1160 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1162 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1163 component, ptrmem_type);
1164 return error_mark_node;
1167 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1168 if (! IS_AGGR_TYPE (objtype))
1170 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1171 component, datum, objtype);
1172 return error_mark_node;
1175 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1176 binfo = lookup_base (objtype, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type),
1180 error ("member type `%T::' incompatible with object type `%T'",
1182 return error_mark_node;
1184 else if (binfo == error_mark_node)
1185 return error_mark_node;
1187 if (TYPE_PTRMEM_P (ptrmem_type))
1189 /* Compute the type of the field, as described in [expr.ref].
1190 There's no such thing as a mutable pointer-to-member, so
1191 things are not as complex as they are for references to
1192 non-static data members. */
1193 type = cp_build_qualified_type (type,
1194 (cp_type_quals (type)
1195 | cp_type_quals (TREE_TYPE (datum))));
1196 /* Build an expression for "object + offset" where offset is the
1197 value stored in the pointer-to-data-member. */
1198 datum = build (PLUS_EXPR, build_pointer_type (type),
1199 build_base_path (PLUS_EXPR, build_address (datum),
1201 build_nop (ptrdiff_type_node, component));
1202 return build_indirect_ref (datum, 0);
1205 return build (OFFSET_REF, type, datum, component);
1208 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1211 build_functional_cast (tree exp, tree parms)
1213 /* This is either a call to a constructor,
1214 or a C cast in C++'s `functional' notation. */
1217 if (exp == error_mark_node || parms == error_mark_node)
1218 return error_mark_node;
1220 if (TREE_CODE (exp) == TYPE_DECL)
1221 type = TREE_TYPE (exp);
1225 if (processing_template_decl)
1227 tree t = build_min (CAST_EXPR, type, parms);
1228 /* We don't know if it will or will not have side effects. */
1229 TREE_SIDE_EFFECTS (t) = 1;
1233 if (! IS_AGGR_TYPE (type))
1235 /* This must build a C cast. */
1236 if (parms == NULL_TREE)
1237 parms = integer_zero_node;
1239 parms = build_x_compound_expr_from_list (parms, "functional cast");
1241 return build_c_cast (type, parms);
1244 /* Prepare to evaluate as a call to a constructor. If this expression
1245 is actually used, for example,
1247 return X (arg1, arg2, ...);
1249 then the slot being initialized will be filled in. */
1251 if (!complete_type_or_else (type, NULL_TREE))
1252 return error_mark_node;
1253 if (abstract_virtuals_error (NULL_TREE, type))
1254 return error_mark_node;
1256 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1257 return build_c_cast (type, TREE_VALUE (parms));
1259 /* We need to zero-initialize POD types. Let's do that for everything
1260 that doesn't need a constructor. */
1261 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1262 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1264 exp = build_constructor (type, NULL_TREE);
1265 return get_target_expr (exp);
1268 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1269 TYPE_BINFO (type), LOOKUP_NORMAL);
1271 if (exp == error_mark_node)
1272 return error_mark_node;
1274 return build_cplus_new (type, exp);
1278 /* Add new exception specifier SPEC, to the LIST we currently have.
1279 If it's already in LIST then do nothing.
1280 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1281 know what we're doing. */
1284 add_exception_specifier (tree list, tree spec, int complain)
1289 int diag_type = -1; /* none */
1291 if (spec == error_mark_node)
1294 my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1296 /* [except.spec] 1, type in an exception specifier shall not be
1297 incomplete, or pointer or ref to incomplete other than pointer
1299 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1300 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1301 core = TREE_TYPE (core);
1304 else if (VOID_TYPE_P (core))
1306 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1308 else if (processing_template_decl)
1313 /* 15.4/1 says that types in an exception specifier must be complete,
1314 but it seems more reasonable to only require this on definitions
1315 and calls. So just give a pedwarn at this point; we will give an
1316 error later if we hit one of those two cases. */
1317 if (!COMPLETE_TYPE_P (complete_type (core)))
1318 diag_type = 2; /* pedwarn */
1325 for (probe = list; probe; probe = TREE_CHAIN (probe))
1326 if (same_type_p (TREE_VALUE (probe), spec))
1329 list = tree_cons (NULL_TREE, spec, list);
1332 diag_type = 0; /* error */
1334 if (diag_type >= 0 && complain)
1335 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1340 /* Combine the two exceptions specifier lists LIST and ADD, and return
1344 merge_exception_specifiers (tree list, tree add)
1348 else if (!TREE_VALUE (list))
1350 else if (!TREE_VALUE (add))
1354 tree orig_list = list;
1356 for (; add; add = TREE_CHAIN (add))
1358 tree spec = TREE_VALUE (add);
1361 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1362 if (same_type_p (TREE_VALUE (probe), spec))
1366 spec = build_tree_list (NULL_TREE, spec);
1367 TREE_CHAIN (spec) = list;
1375 /* Subroutine of build_call. Ensure that each of the types in the
1376 exception specification is complete. Technically, 15.4/1 says that
1377 they need to be complete when we see a declaration of the function,
1378 but we should be able to get away with only requiring this when the
1379 function is defined or called. See also add_exception_specifier. */
1382 require_complete_eh_spec_types (tree fntype, tree decl)
1385 /* Don't complain about calls to op new. */
1386 if (decl && DECL_ARTIFICIAL (decl))
1388 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1389 raises = TREE_CHAIN (raises))
1391 tree type = TREE_VALUE (raises);
1392 if (type && !COMPLETE_TYPE_P (type))
1396 ("call to function `%D' which throws incomplete type `%#T'",
1399 error ("call to function which throws incomplete type `%#T'",