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);
117 /* If TYPE has abstract virtual functions, issue an error about trying
118 to create an object of that type. DECL is the object declared, or
119 NULL_TREE if the declaration is unavailable. Returns 1 if an error
120 occurred; zero if all was well. */
123 abstract_virtuals_error (tree decl, tree type)
128 if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type))
131 if (!TYPE_SIZE (type))
132 /* TYPE is being defined, and during that time
133 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
136 if (dependent_type_p (type))
137 /* For a dependent type, we do not yet know which functions are pure
141 u = CLASSTYPE_PURE_VIRTUALS (type);
144 if (TREE_CODE (decl) == RESULT_DECL)
147 if (TREE_CODE (decl) == VAR_DECL)
148 cp_error_at ("cannot declare variable `%+D' to be of abstract "
149 "type `%T'", decl, type);
150 else if (TREE_CODE (decl) == PARM_DECL)
151 cp_error_at ("cannot declare parameter `%+D' to be of abstract "
152 "type `%T'", decl, type);
153 else if (TREE_CODE (decl) == FIELD_DECL)
154 cp_error_at ("cannot declare field `%+D' to be of abstract "
155 "type `%T'", decl, type);
156 else if (TREE_CODE (decl) == FUNCTION_DECL
157 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
158 cp_error_at ("invalid abstract return type for member function `%+#D'",
160 else if (TREE_CODE (decl) == FUNCTION_DECL)
161 cp_error_at ("invalid abstract return type for function `%+#D'",
164 cp_error_at ("invalid abstract type for `%+D'", decl);
167 error ("cannot allocate an object of abstract type `%T'", type);
169 /* Only go through this once. */
170 if (TREE_PURPOSE (u) == NULL_TREE)
172 TREE_PURPOSE (u) = error_mark_node;
174 inform ("%J because the following virtual functions are pure "
175 "within `%T':", TYPE_MAIN_DECL (type), type);
177 for (tu = u; tu; tu = TREE_CHAIN (tu))
178 inform ("%J\t%#D", TREE_VALUE (tu), TREE_VALUE (tu));
181 inform ("%J since type `%T' has pure virtual functions",
182 TYPE_MAIN_DECL (type), type);
187 /* Print an error message for invalid use of an incomplete type.
188 VALUE is the expression that was used (or 0 if that isn't known)
189 and TYPE is the type that was invalid. DIAG_TYPE indicates the
190 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
194 cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
197 void (*p_msg) (const char *, ...);
198 void (*p_msg_at) (const char *, ...);
203 p_msg_at = cp_warning_at;
205 else if (diag_type == 2)
208 p_msg_at = cp_pedwarn_at;
213 p_msg_at = cp_error_at;
216 /* Avoid duplicate error message. */
217 if (TREE_CODE (type) == ERROR_MARK)
220 if (value != 0 && (TREE_CODE (value) == VAR_DECL
221 || TREE_CODE (value) == PARM_DECL
222 || TREE_CODE (value) == FIELD_DECL))
224 (*p_msg_at) ("`%D' has incomplete type", value);
228 /* We must print an error message. Be clever about what it says. */
230 switch (TREE_CODE (type))
236 (*p_msg) ("invalid use of undefined type `%#T'", type);
237 if (!TYPE_TEMPLATE_INFO (type))
238 (*p_msg_at) ("forward declaration of `%#T'", type);
240 (*p_msg_at) ("declaration of `%#T'", type);
244 (*p_msg) ("invalid use of `%T'", type);
248 if (TYPE_DOMAIN (type))
250 type = TREE_TYPE (type);
253 (*p_msg) ("invalid use of array with unspecified bounds");
258 (*p_msg) ("invalid use of member (did you forget the `&' ?)");
261 case TEMPLATE_TYPE_PARM:
262 (*p_msg) ("invalid use of template type parameter");
266 if (value && TREE_CODE (value) == COMPONENT_REF)
268 else if (value && TREE_CODE (value) == ADDR_EXPR)
269 (*p_msg) ("address of overloaded function with no contextual type information");
270 else if (value && TREE_CODE (value) == OVERLOAD)
271 (*p_msg) ("overloaded function with no contextual type information");
273 (*p_msg) ("insufficient contextual information to determine type");
281 /* Backward-compatibility interface to incomplete_type_diagnostic;
282 required by ../tree.c. */
283 #undef cxx_incomplete_type_error
285 cxx_incomplete_type_error (tree value, tree type)
287 cxx_incomplete_type_diagnostic (value, type, 0);
291 /* The recursive part of split_nonconstant_init. DEST is an lvalue
292 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
295 split_nonconstant_init_1 (tree dest, tree init)
297 tree *pelt, elt, type = TREE_TYPE (dest);
298 tree sub, code, inner_type = NULL;
299 bool array_type_p = false;
301 pelt = &CONSTRUCTOR_ELTS (init);
302 switch (TREE_CODE (type))
305 inner_type = TREE_TYPE (type);
311 case QUAL_UNION_TYPE:
312 while ((elt = *pelt))
314 tree field_index = TREE_PURPOSE (elt);
315 tree value = TREE_VALUE (elt);
318 inner_type = TREE_TYPE (field_index);
320 if (TREE_CODE (value) == CONSTRUCTOR)
323 sub = build (ARRAY_REF, inner_type, dest, field_index);
325 sub = build (COMPONENT_REF, inner_type, dest, field_index);
327 split_nonconstant_init_1 (sub, value);
329 else if (!initializer_constant_valid_p (value, inner_type))
331 *pelt = TREE_CHAIN (elt);
334 sub = build (ARRAY_REF, inner_type, dest, field_index);
336 sub = build (COMPONENT_REF, inner_type, dest, field_index);
338 code = build (MODIFY_EXPR, inner_type, sub, value);
339 code = build_stmt (EXPR_STMT, 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);
363 /* A subroutine of store_init_value. Splits non-constant static
364 initializer INIT into a constant part and generates code to
365 perform the non-constant part of the initialization to DEST.
366 Returns the code for the runtime init. */
369 split_nonconstant_init (tree dest, tree init)
373 if (TREE_CODE (init) == CONSTRUCTOR)
375 code = push_stmt_list ();
376 split_nonconstant_init_1 (dest, init);
377 code = pop_stmt_list (code);
378 DECL_INITIAL (dest) = init;
379 TREE_READONLY (dest) = 0;
382 code = build (INIT_EXPR, TREE_TYPE (dest), dest, init);
387 /* Perform appropriate conversions on the initial value of a variable,
388 store it in the declaration DECL,
389 and print any error messages that are appropriate.
390 If the init is invalid, store an ERROR_MARK.
392 C++: Note that INIT might be a TREE_LIST, which would mean that it is
393 a base class initializer for some aggregate type, hopefully compatible
394 with DECL. If INIT is a single element, and DECL is an aggregate
395 type, we silently convert INIT into a TREE_LIST, allowing a constructor
398 If INIT is a TREE_LIST and there is no constructor, turn INIT
399 into a CONSTRUCTOR and use standard initialization techniques.
400 Perhaps a warning should be generated?
402 Returns code to be executed if initialization could not be performed
403 for static variable. In that case, caller must emit the code. */
406 store_init_value (tree decl, tree init)
410 /* If variable's type was invalidly declared, just ignore it. */
412 type = TREE_TYPE (decl);
413 if (TREE_CODE (type) == ERROR_MARK)
416 if (IS_AGGR_TYPE (type))
418 if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
419 && TREE_CODE (init) != CONSTRUCTOR)
422 if (TREE_CODE (init) == TREE_LIST)
424 error ("constructor syntax used, but no constructor declared for type `%T'", type);
425 init = build_constructor (NULL_TREE, nreverse (init));
428 else if (TREE_CODE (init) == TREE_LIST
429 && TREE_TYPE (init) != unknown_type_node)
431 if (TREE_CODE (decl) == RESULT_DECL)
432 init = build_x_compound_expr_from_list (init,
433 "return value initializer");
434 else if (TREE_CODE (init) == TREE_LIST
435 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
437 error ("cannot initialize arrays using this syntax");
441 /* We get here with code like `int a (2);' */
442 init = build_x_compound_expr_from_list (init, "initializer");
445 /* End of special C++ code. */
447 /* Digest the specified initializer into an expression. */
448 value = digest_init (type, init, (tree *) 0);
450 /* Store the expression if valid; else report error. */
452 if (TREE_CODE (value) == ERROR_MARK)
454 /* Other code expects that initializers for objects of types that need
455 constructing never make it into DECL_INITIAL, and passes 'init' to
456 build_aggr_init without checking DECL_INITIAL. So just return. */
457 else if (TYPE_NEEDS_CONSTRUCTING (type))
458 return build (INIT_EXPR, type, decl, value);
459 else if (TREE_STATIC (decl)
460 && (! TREE_CONSTANT (value)
461 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
462 return split_nonconstant_init (decl, value);
464 /* Store the VALUE in DECL_INITIAL. If we're building a
465 statement-tree we will actually expand the initialization later
466 when we output this function. */
467 DECL_INITIAL (decl) = value;
472 /* Digest the parser output INIT as an initializer for type TYPE.
473 Return a C expression of type TYPE to represent the initial value.
475 If TAIL is nonzero, it points to a variable holding a list of elements
476 of which INIT is the first. We update the list stored there by
477 removing from the head all the elements that we use.
478 Normally this is only one; we use more than one element only if
479 TYPE is an aggregate and INIT is not a constructor. */
482 digest_init (tree type, tree init, tree* tail)
484 enum tree_code code = TREE_CODE (type);
485 tree element = NULL_TREE;
486 tree old_tail_contents = NULL_TREE;
488 /* By default, assume we use one element from a list.
489 We correct this later in the sole case where it is not true. */
493 old_tail_contents = *tail;
494 *tail = TREE_CHAIN (*tail);
497 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
498 && TREE_VALUE (init) == error_mark_node))
499 return error_mark_node;
501 if (TREE_CODE (init) == ERROR_MARK)
502 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
503 a template function. This gets substituted during instantiation. */
506 /* We must strip the outermost array type when completing the type,
507 because the its bounds might be incomplete at the moment. */
508 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
509 ? TREE_TYPE (type) : type, NULL_TREE))
510 return error_mark_node;
512 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
513 if (TREE_CODE (init) == NON_LVALUE_EXPR)
514 init = TREE_OPERAND (init, 0);
516 if (BRACE_ENCLOSED_INITIALIZER_P (init)
517 && CONSTRUCTOR_ELTS (init) != 0
518 && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
520 element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
521 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
522 if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
523 element = TREE_OPERAND (element, 0);
524 if (element == error_mark_node)
528 /* Initialization of an array of chars from a string constant
529 optionally enclosed in braces. */
531 if (code == ARRAY_TYPE)
535 if (TREE_CODE (init) == TREE_LIST)
537 error ("initializing array with parameter list");
538 return error_mark_node;
541 typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
542 if (char_type_p (typ1)
543 && ((init && TREE_CODE (init) == STRING_CST)
544 || (element && TREE_CODE (element) == STRING_CST)))
546 tree string = element ? element : init;
548 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
550 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
552 error ("char-array initialized from wide string");
553 return error_mark_node;
555 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
557 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
559 error ("int-array initialized from non-wide string");
560 return error_mark_node;
563 TREE_TYPE (string) = type;
564 if (TYPE_DOMAIN (type) != 0
565 && TREE_CONSTANT (TYPE_SIZE (type)))
567 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
568 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
569 /* In C it is ok to subtract 1 from the length of the string
570 because it's ok to ignore the terminating null char that is
571 counted in the length of the constant, but in C++ this would
573 if (size < TREE_STRING_LENGTH (string))
574 pedwarn ("initializer-string for array of chars is too long");
580 /* Handle scalar types, including conversions,
581 and signature pointers and references. */
583 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
584 || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
585 || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
586 || TYPE_PTR_TO_MEMBER_P (type))
588 if (BRACE_ENCLOSED_INITIALIZER_P (init))
592 error ("initializer for scalar variable requires one element");
593 return error_mark_node;
597 while (BRACE_ENCLOSED_INITIALIZER_P (init))
599 pedwarn ("braces around scalar initializer for `%T'", type);
600 init = CONSTRUCTOR_ELTS (init);
601 if (TREE_CHAIN (init))
602 pedwarn ("ignoring extra initializers for `%T'", type);
603 init = TREE_VALUE (init);
606 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
607 "initialization", NULL_TREE, 0);
610 /* Come here only for records and arrays (and unions with constructors). */
612 if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
614 error ("variable-sized object of type `%T' may not be initialized",
616 return error_mark_node;
619 if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))
621 if (BRACE_ENCLOSED_INITIALIZER_P (init))
623 if (TYPE_NON_AGGREGATE_CLASS (type))
625 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
627 return error_mark_node;
629 return process_init_constructor (type, init, (tree *)0);
631 else if (can_convert_arg (type, TREE_TYPE (init), init)
632 || TYPE_NON_AGGREGATE_CLASS (type))
633 /* These are never initialized from multiple constructor elements. */;
636 *tail = old_tail_contents;
637 return process_init_constructor (type, 0, tail);
640 if (code != ARRAY_TYPE)
642 int flags = LOOKUP_NORMAL;
643 /* Initialization from { } is copy-initialization. */
645 flags |= LOOKUP_ONLYCONVERTING;
647 return convert_for_initialization (NULL_TREE, type, init, flags,
648 "initialization", NULL_TREE, 0);
652 error ("invalid initializer");
653 return error_mark_node;
656 /* Process a constructor for a variable of type TYPE.
657 The constructor elements may be specified either with INIT or with ELTS,
658 only one of which should be non-null.
660 If INIT is specified, it is a CONSTRUCTOR node which is specifically
661 and solely for initializing this datum.
663 If ELTS is specified, it is the address of a variable containing
664 a list of expressions. We take as many elements as we need
665 from the head of the list and update the list.
667 In the resulting constructor, TREE_CONSTANT is set if all elts are
668 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
669 constants that the assembler and linker can compute them. */
672 process_init_constructor (tree type, tree init, tree* elts)
675 /* List of the elements of the result constructor,
684 /* Make TAIL be the list of elements to use for the initialization,
685 no matter how the data was given to us. */
689 if (warn_missing_braces)
690 warning ("aggregate has a partly bracketed initializer");
694 tail = CONSTRUCTOR_ELTS (init);
696 /* Gobble as many elements as needed, and make a constructor or initial value
697 for each element of this aggregate. Chain them together in result.
698 If there are too few, use 0 for each scalar ultimate component. */
700 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
705 if (TREE_CODE (type) == ARRAY_TYPE)
707 tree domain = TYPE_DOMAIN (type);
709 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
710 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
713 len = -1; /* Take as many as there are. */
717 /* Vectors are like simple fixed-size arrays. */
718 len = TYPE_VECTOR_SUBPARTS (type);
721 for (i = 0; len < 0 || i < len; i++)
725 if (TREE_PURPOSE (tail)
726 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
727 || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
728 sorry ("non-trivial labeled initializers");
730 if (TREE_VALUE (tail) != 0)
733 next1 = digest_init (TREE_TYPE (type),
734 TREE_VALUE (tail), &tail1);
735 if (next1 == error_mark_node)
738 (same_type_ignoring_top_level_qualifiers_p
739 (TREE_TYPE (type), TREE_TYPE (next1)),
741 my_friendly_assert (tail1 == 0
742 || TREE_CODE (tail1) == TREE_LIST, 319);
743 if (tail == tail1 && len < 0)
745 error ("non-empty initializer for array of empty elements");
746 /* Just ignore what we were supposed to use. */
753 next1 = error_mark_node;
754 tail = TREE_CHAIN (tail);
760 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
762 /* If this type needs constructors run for
763 default-initialization, we can't rely on the backend to do it
764 for us, so build up TARGET_EXPRs. If the type in question is
765 a class, just build one up; if it's an array, recurse. */
767 if (IS_AGGR_TYPE (TREE_TYPE (type)))
768 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
770 next1 = build_constructor (NULL_TREE, NULL_TREE);
771 next1 = digest_init (TREE_TYPE (type), next1, 0);
773 else if (! zero_init_p (TREE_TYPE (type)))
774 next1 = build_zero_init (TREE_TYPE (type),
776 /*static_storage_p=*/false);
778 /* The default zero-initialization is fine for us; don't
779 add anything to the CONSTRUCTOR. */
782 if (next1 == error_mark_node)
784 else if (!TREE_CONSTANT (next1))
786 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
788 members = tree_cons (size_int (i), next1, members);
791 else if (TREE_CODE (type) == RECORD_TYPE)
797 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
799 sorry ("initializer list for object of class with virtual base classes");
800 return error_mark_node;
803 if (TYPE_BINFO_BASETYPES (type))
805 sorry ("initializer list for object of class with base classes");
806 return error_mark_node;
809 if (TYPE_POLYMORPHIC_P (type))
811 sorry ("initializer list for object using virtual functions");
812 return error_mark_node;
816 for (field = TYPE_FIELDS (type); field;
817 field = TREE_CHAIN (field))
819 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
821 members = tree_cons (field, integer_zero_node, members);
825 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
830 if (TREE_PURPOSE (tail)
831 && TREE_PURPOSE (tail) != field
832 && TREE_PURPOSE (tail) != DECL_NAME (field))
833 sorry ("non-trivial labeled initializers");
835 if (TREE_VALUE (tail) != 0)
839 next1 = digest_init (TREE_TYPE (field),
840 TREE_VALUE (tail), &tail1);
841 my_friendly_assert (tail1 == 0
842 || TREE_CODE (tail1) == TREE_LIST, 320);
847 next1 = error_mark_node;
848 tail = TREE_CHAIN (tail);
851 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
853 /* If this type needs constructors run for
854 default-initialization, we can't rely on the backend to do it
855 for us, so build up TARGET_EXPRs. If the type in question is
856 a class, just build one up; if it's an array, recurse. */
858 if (IS_AGGR_TYPE (TREE_TYPE (field)))
859 next1 = build_functional_cast (TREE_TYPE (field),
863 next1 = build_constructor (NULL_TREE, NULL_TREE);
865 TREE_HAS_CONSTRUCTOR (next1)
866 = TREE_HAS_CONSTRUCTOR (init);
868 next1 = digest_init (TREE_TYPE (field), next1, 0);
870 /* Warn when some struct elements are implicitly initialized. */
872 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
873 warning ("missing initializer for member `%D'", field);
877 if (TREE_READONLY (field))
878 error ("uninitialized const member `%D'", field);
879 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
880 error ("member `%D' with uninitialized const fields",
882 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
883 error ("member `%D' is uninitialized reference", field);
885 /* Warn when some struct elements are implicitly initialized
888 && (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
889 warning ("missing initializer for member `%D'", field);
891 if (! zero_init_p (TREE_TYPE (field)))
892 next1 = build_zero_init (TREE_TYPE (field),
894 /*static_storage_p=*/false);
896 /* The default zero-initialization is fine for us; don't
897 add anything to the CONSTRUCTOR. */
901 if (next1 == error_mark_node)
903 else if (!TREE_CONSTANT (next1))
905 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
907 members = tree_cons (field, next1, members);
910 else if (TREE_CODE (type) == UNION_TYPE
911 /* If the initializer was empty, use default zero initialization. */
914 tree field = TYPE_FIELDS (type);
916 /* Find the first named field. ANSI decided in September 1990
917 that only named fields count here. */
918 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
919 field = TREE_CHAIN (field);
921 /* If this element specifies a field, initialize via that field. */
922 if (TREE_PURPOSE (tail) != NULL_TREE)
926 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
927 /* Handle the case of a call by build_c_cast. */
928 field = TREE_PURPOSE (tail), win = 1;
929 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
930 error ("index value instead of field name in union initializer");
934 for (temp = TYPE_FIELDS (type);
936 temp = TREE_CHAIN (temp))
937 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
940 field = temp, win = 1;
942 error ("no field `%D' in union being initialized",
943 TREE_PURPOSE (tail));
946 TREE_VALUE (tail) = error_mark_node;
950 error ("union `%T' with no named members cannot be initialized",
952 TREE_VALUE (tail) = error_mark_node;
955 if (TREE_VALUE (tail) != 0)
959 next1 = digest_init (TREE_TYPE (field),
960 TREE_VALUE (tail), &tail1);
961 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
967 next1 = error_mark_node;
968 tail = TREE_CHAIN (tail);
971 if (next1 == error_mark_node)
973 else if (!TREE_CONSTANT (next1))
975 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
977 members = tree_cons (field, next1, members);
980 /* If arguments were specified as a list, just remove the ones we used. */
983 /* If arguments were specified as a constructor,
984 complain unless we used all the elements of the constructor. */
986 pedwarn ("excess elements in aggregate initializer");
989 return error_mark_node;
991 result = build_constructor (type, nreverse (members));
992 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
993 complete_array_type (type, result, /*do_default=*/0);
995 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
998 TREE_CONSTANT (result) = 1;
999 TREE_INVARIANT (result) = 1;
1001 TREE_STATIC (result) = 1;
1006 /* Given a structure or union value DATUM, construct and return
1007 the structure or union component which results from narrowing
1008 that value to the base specified in BASETYPE. For example, given the
1011 class L { int ii; };
1012 class A : L { ... };
1013 class B : L { ... };
1014 class C : A, B { ... };
1022 x.A::ii refers to the ii member of the L part of
1023 the A part of the C object named by X. In this case,
1024 DATUM would be x, and BASETYPE would be A.
1026 I used to think that this was nonconformant, that the standard specified
1027 that first we look up ii in A, then convert x to an L& and pull out the
1028 ii part. But in fact, it does say that we convert x to an A&; A here
1029 is known as the "naming class". (jason 2000-12-19)
1031 BINFO_P points to a variable initialized either to NULL_TREE or to the
1032 binfo for the specific base subobject we want to convert to. */
1035 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1039 if (datum == error_mark_node)
1040 return error_mark_node;
1044 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1046 if (!binfo || binfo == error_mark_node)
1048 *binfo_p = NULL_TREE;
1050 error_not_base_type (basetype, TREE_TYPE (datum));
1051 return error_mark_node;
1055 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1058 /* Build a reference to an object specified by the C++ `->' operator.
1059 Usually this just involves dereferencing the object, but if the
1060 `->' operator is overloaded, then such overloads must be
1061 performed until an object which does not have the `->' operator
1062 overloaded is found. An error is reported when circular pointer
1063 delegation is detected. */
1066 build_x_arrow (tree expr)
1068 tree orig_expr = expr;
1069 tree types_memoized = NULL_TREE;
1070 tree type = TREE_TYPE (expr);
1071 tree last_rval = NULL_TREE;
1073 if (type == error_mark_node)
1074 return error_mark_node;
1076 if (processing_template_decl)
1078 if (type_dependent_expression_p (expr))
1079 return build_min_nt (ARROW_EXPR, expr);
1080 expr = build_non_dependent_expr (expr);
1083 if (TREE_CODE (type) == REFERENCE_TYPE)
1085 expr = convert_from_reference (expr);
1086 type = TREE_TYPE (expr);
1089 if (IS_AGGR_TYPE (type))
1091 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1092 NULL_TREE, NULL_TREE,
1093 /*overloaded_p=*/NULL)))
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'",