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 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 tree cons = copy_node (init);
352 CONSTRUCTOR_ELTS (init) = NULL;
353 code = build (MODIFY_EXPR, type, dest, cons);
354 code = build_stmt (EXPR_STMT, code);
356 pcode = &TREE_CHAIN (code);
367 /* A subroutine of store_init_value. Splits non-constant static
368 initializer INIT into a constant part and generates code to
369 perform the non-constant part of the initialization to DEST.
370 Returns the code for the runtime init. */
373 split_nonconstant_init (tree dest, tree init)
377 if (TREE_CODE (init) == CONSTRUCTOR)
379 code = build_stmt (COMPOUND_STMT, NULL_TREE);
380 split_nonconstant_init_1 (dest, init, &COMPOUND_BODY (code));
381 code = build1 (STMT_EXPR, void_type_node, code);
382 TREE_SIDE_EFFECTS (code) = 1;
383 DECL_INITIAL (dest) = init;
384 TREE_READONLY (dest) = 0;
387 code = build (INIT_EXPR, TREE_TYPE (dest), dest, init);
392 /* Perform appropriate conversions on the initial value of a variable,
393 store it in the declaration DECL,
394 and print any error messages that are appropriate.
395 If the init is invalid, store an ERROR_MARK.
397 C++: Note that INIT might be a TREE_LIST, which would mean that it is
398 a base class initializer for some aggregate type, hopefully compatible
399 with DECL. If INIT is a single element, and DECL is an aggregate
400 type, we silently convert INIT into a TREE_LIST, allowing a constructor
403 If INIT is a TREE_LIST and there is no constructor, turn INIT
404 into a CONSTRUCTOR and use standard initialization techniques.
405 Perhaps a warning should be generated?
407 Returns code to be executed if initialization could not be performed
408 for static variable. In that case, caller must emit the code. */
411 store_init_value (tree decl, tree init)
415 /* If variable's type was invalidly declared, just ignore it. */
417 type = TREE_TYPE (decl);
418 if (TREE_CODE (type) == ERROR_MARK)
421 if (IS_AGGR_TYPE (type))
423 if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
424 && TREE_CODE (init) != CONSTRUCTOR)
427 if (TREE_CODE (init) == TREE_LIST)
429 error ("constructor syntax used, but no constructor declared for type `%T'", type);
430 init = build_constructor (NULL_TREE, nreverse (init));
433 else if (TREE_CODE (init) == TREE_LIST
434 && TREE_TYPE (init) != unknown_type_node)
436 if (TREE_CODE (decl) == RESULT_DECL)
437 init = build_x_compound_expr_from_list (init,
438 "return value initializer");
439 else if (TREE_CODE (init) == TREE_LIST
440 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
442 error ("cannot initialize arrays using this syntax");
446 /* We get here with code like `int a (2);' */
447 init = build_x_compound_expr_from_list (init, "initializer");
450 /* Digest the specified initializer into an expression. */
451 value = digest_init (type, init, (tree *) 0);
452 /* If the initializer is not a constant, fill in DECL_INITIAL with
453 the bits that are constant, and then return an expression that
454 will perform the dynamic initialization. */
455 if (value != error_mark_node
456 && (! TREE_CONSTANT (value)
457 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
458 return split_nonconstant_init (decl, value);
459 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
460 is an automatic variable, the middle end will turn this into a
461 dynamic initialization later. */
462 DECL_INITIAL (decl) = value;
467 /* Digest the parser output INIT as an initializer for type TYPE.
468 Return a C expression of type TYPE to represent the initial value.
470 If TAIL is nonzero, it points to a variable holding a list of elements
471 of which INIT is the first. We update the list stored there by
472 removing from the head all the elements that we use.
473 Normally this is only one; we use more than one element only if
474 TYPE is an aggregate and INIT is not a constructor. */
477 digest_init (tree type, tree init, tree* tail)
479 enum tree_code code = TREE_CODE (type);
480 tree element = NULL_TREE;
481 tree old_tail_contents = NULL_TREE;
482 /* Nonzero if INIT is a braced grouping. */
485 /* By default, assume we use one element from a list.
486 We correct this later in the sole case where it is not true. */
490 old_tail_contents = *tail;
491 *tail = TREE_CHAIN (*tail);
494 if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
495 && TREE_VALUE (init) == error_mark_node))
496 return error_mark_node;
498 if (TREE_CODE (init) == ERROR_MARK)
499 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
500 a template function. This gets substituted during instantiation. */
503 /* We must strip the outermost array type when completing the type,
504 because the its bounds might be incomplete at the moment. */
505 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
506 ? TREE_TYPE (type) : type, NULL_TREE))
507 return error_mark_node;
509 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
510 if (TREE_CODE (init) == NON_LVALUE_EXPR)
511 init = TREE_OPERAND (init, 0);
513 raw_constructor = (TREE_CODE (init) == CONSTRUCTOR
514 && TREE_HAS_CONSTRUCTOR (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))
592 error ("initializer for scalar variable requires one element");
593 return error_mark_node;
597 while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (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 (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)
622 && TREE_HAS_CONSTRUCTOR (init))
624 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
626 return error_mark_node;
628 else if (raw_constructor)
629 return process_init_constructor (type, init, (tree *)0);
630 else if (can_convert_arg (type, TREE_TYPE (init), init)
631 || TYPE_NON_AGGREGATE_CLASS (type))
632 /* These are never initialized from multiple constructor elements. */;
635 *tail = old_tail_contents;
636 return process_init_constructor (type, 0, tail);
639 if (code != ARRAY_TYPE)
641 int flags = LOOKUP_NORMAL;
642 /* Initialization from { } is copy-initialization. */
644 flags |= LOOKUP_ONLYCONVERTING;
646 return convert_for_initialization (NULL_TREE, type, init, flags,
647 "initialization", NULL_TREE, 0);
651 error ("invalid initializer");
652 return error_mark_node;
655 /* Process a constructor for a variable of type TYPE.
656 The constructor elements may be specified either with INIT or with ELTS,
657 only one of which should be non-null.
659 If INIT is specified, it is a CONSTRUCTOR node which is specifically
660 and solely for initializing this datum.
662 If ELTS is specified, it is the address of a variable containing
663 a list of expressions. We take as many elements as we need
664 from the head of the list and update the list.
666 In the resulting constructor, TREE_CONSTANT is set if all elts are
667 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
668 constants that the assembler and linker can compute them. */
671 process_init_constructor (tree type, tree init, tree* elts)
674 /* List of the elements of the result constructor,
683 /* Make TAIL be the list of elements to use for the initialization,
684 no matter how the data was given to us. */
688 if (warn_missing_braces)
689 warning ("aggregate has a partly bracketed initializer");
693 tail = CONSTRUCTOR_ELTS (init);
695 /* Gobble as many elements as needed, and make a constructor or initial value
696 for each element of this aggregate. Chain them together in result.
697 If there are too few, use 0 for each scalar ultimate component. */
699 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
704 if (TREE_CODE (type) == ARRAY_TYPE)
706 tree domain = TYPE_DOMAIN (type);
708 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
709 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
712 len = -1; /* Take as many as there are. */
716 /* Vectors are like simple fixed-size arrays. */
717 len = TYPE_VECTOR_SUBPARTS (type);
720 for (i = 0; len < 0 || i < len; i++)
724 if (TREE_PURPOSE (tail)
725 && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
726 || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
727 sorry ("non-trivial labeled initializers");
729 if (TREE_VALUE (tail) != 0)
732 next1 = digest_init (TREE_TYPE (type),
733 TREE_VALUE (tail), &tail1);
734 if (next1 == error_mark_node)
737 (same_type_ignoring_top_level_qualifiers_p
738 (TREE_TYPE (type), TREE_TYPE (next1)),
740 my_friendly_assert (tail1 == 0
741 || TREE_CODE (tail1) == TREE_LIST, 319);
742 if (tail == tail1 && len < 0)
744 error ("non-empty initializer for array of empty elements");
745 /* Just ignore what we were supposed to use. */
752 next1 = error_mark_node;
753 tail = TREE_CHAIN (tail);
759 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
761 /* If this type needs constructors run for
762 default-initialization, we can't rely on the backend to do it
763 for us, so build up TARGET_EXPRs. If the type in question is
764 a class, just build one up; if it's an array, recurse. */
766 if (IS_AGGR_TYPE (TREE_TYPE (type)))
767 next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE);
769 next1 = build_constructor (NULL_TREE, NULL_TREE);
770 next1 = digest_init (TREE_TYPE (type), next1, 0);
772 else if (! zero_init_p (TREE_TYPE (type)))
773 next1 = build_zero_init (TREE_TYPE (type),
775 /*static_storage_p=*/false);
777 /* The default zero-initialization is fine for us; don't
778 add anything to the CONSTRUCTOR. */
781 if (next1 == error_mark_node)
783 else if (!TREE_CONSTANT (next1))
785 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
787 members = tree_cons (size_int (i), next1, members);
790 else if (TREE_CODE (type) == RECORD_TYPE)
796 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
798 sorry ("initializer list for object of class with virtual base classes");
799 return error_mark_node;
802 if (TYPE_BINFO_BASETYPES (type))
804 sorry ("initializer list for object of class with base classes");
805 return error_mark_node;
808 if (TYPE_POLYMORPHIC_P (type))
810 sorry ("initializer list for object using virtual functions");
811 return error_mark_node;
815 for (field = TYPE_FIELDS (type); field;
816 field = TREE_CHAIN (field))
818 if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field))
820 members = tree_cons (field, integer_zero_node, members);
824 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
829 if (TREE_PURPOSE (tail)
830 && TREE_PURPOSE (tail) != field
831 && TREE_PURPOSE (tail) != DECL_NAME (field))
832 sorry ("non-trivial labeled initializers");
834 if (TREE_VALUE (tail) != 0)
838 next1 = digest_init (TREE_TYPE (field),
839 TREE_VALUE (tail), &tail1);
840 my_friendly_assert (tail1 == 0
841 || TREE_CODE (tail1) == TREE_LIST, 320);
846 next1 = error_mark_node;
847 tail = TREE_CHAIN (tail);
850 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
852 /* If this type needs constructors run for
853 default-initialization, we can't rely on the backend to do it
854 for us, so build up TARGET_EXPRs. If the type in question is
855 a class, just build one up; if it's an array, recurse. */
857 if (IS_AGGR_TYPE (TREE_TYPE (field)))
858 next1 = build_functional_cast (TREE_TYPE (field),
862 next1 = build_constructor (NULL_TREE, NULL_TREE);
864 TREE_HAS_CONSTRUCTOR (next1)
865 = TREE_HAS_CONSTRUCTOR (init);
867 next1 = digest_init (TREE_TYPE (field), next1, 0);
869 /* Warn when some struct elements are implicitly initialized. */
871 && (!init || TREE_HAS_CONSTRUCTOR (init)))
872 warning ("missing initializer for member `%D'", field);
876 if (TREE_READONLY (field))
877 error ("uninitialized const member `%D'", field);
878 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
879 error ("member `%D' with uninitialized const fields",
881 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
882 error ("member `%D' is uninitialized reference", field);
884 /* Warn when some struct elements are implicitly initialized
887 && (!init || TREE_HAS_CONSTRUCTOR (init)))
888 warning ("missing initializer for member `%D'", field);
890 if (! zero_init_p (TREE_TYPE (field)))
891 next1 = build_zero_init (TREE_TYPE (field),
893 /*static_storage_p=*/false);
895 /* The default zero-initialization is fine for us; don't
896 add anything to the CONSTRUCTOR. */
900 if (next1 == error_mark_node)
902 else if (!TREE_CONSTANT (next1))
904 else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))
906 members = tree_cons (field, next1, members);
909 else if (TREE_CODE (type) == UNION_TYPE
910 /* If the initializer was empty, use default zero initialization. */
913 tree field = TYPE_FIELDS (type);
915 /* Find the first named field. ANSI decided in September 1990
916 that only named fields count here. */
917 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
918 field = TREE_CHAIN (field);
920 /* If this element specifies a field, initialize via that field. */
921 if (TREE_PURPOSE (tail) != NULL_TREE)
925 if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
926 /* Handle the case of a call by build_c_cast. */
927 field = TREE_PURPOSE (tail), win = 1;
928 else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
929 error ("index value instead of field name in union initializer");
933 for (temp = TYPE_FIELDS (type);
935 temp = TREE_CHAIN (temp))
936 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
939 field = temp, win = 1;
941 error ("no field `%D' in union being initialized",
942 TREE_PURPOSE (tail));
945 TREE_VALUE (tail) = error_mark_node;
949 error ("union `%T' with no named members cannot be initialized",
951 TREE_VALUE (tail) = error_mark_node;
954 if (TREE_VALUE (tail) != 0)
958 next1 = digest_init (TREE_TYPE (field),
959 TREE_VALUE (tail), &tail1);
960 if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
966 next1 = error_mark_node;
967 tail = TREE_CHAIN (tail);
970 if (next1 == error_mark_node)
972 else if (!TREE_CONSTANT (next1))
974 else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
976 members = tree_cons (field, next1, members);
979 /* If arguments were specified as a list, just remove the ones we used. */
982 /* If arguments were specified as a constructor,
983 complain unless we used all the elements of the constructor. */
985 pedwarn ("excess elements in aggregate initializer");
988 return error_mark_node;
990 result = build_constructor (type, nreverse (members));
991 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
992 complete_array_type (type, result, /*do_default=*/0);
994 TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
995 if (allconstant) TREE_CONSTANT (result) = 1;
996 if (allconstant && allsimple) TREE_STATIC (result) = 1;
1000 /* Given a structure or union value DATUM, construct and return
1001 the structure or union component which results from narrowing
1002 that value to the base specified in BASETYPE. For example, given the
1005 class L { int ii; };
1006 class A : L { ... };
1007 class B : L { ... };
1008 class C : A, B { ... };
1016 x.A::ii refers to the ii member of the L part of
1017 the A part of the C object named by X. In this case,
1018 DATUM would be x, and BASETYPE would be A.
1020 I used to think that this was nonconformant, that the standard specified
1021 that first we look up ii in A, then convert x to an L& and pull out the
1022 ii part. But in fact, it does say that we convert x to an A&; A here
1023 is known as the "naming class". (jason 2000-12-19)
1025 BINFO_P points to a variable initialized either to NULL_TREE or to the
1026 binfo for the specific base subobject we want to convert to. */
1029 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1033 if (datum == error_mark_node)
1034 return error_mark_node;
1038 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1040 if (!binfo || binfo == error_mark_node)
1042 *binfo_p = NULL_TREE;
1044 error_not_base_type (basetype, TREE_TYPE (datum));
1045 return error_mark_node;
1049 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1052 /* Build a reference to an object specified by the C++ `->' operator.
1053 Usually this just involves dereferencing the object, but if the
1054 `->' operator is overloaded, then such overloads must be
1055 performed until an object which does not have the `->' operator
1056 overloaded is found. An error is reported when circular pointer
1057 delegation is detected. */
1060 build_x_arrow (tree expr)
1062 tree orig_expr = expr;
1063 tree types_memoized = NULL_TREE;
1064 tree type = TREE_TYPE (expr);
1065 tree last_rval = NULL_TREE;
1067 if (type == error_mark_node)
1068 return error_mark_node;
1070 if (processing_template_decl)
1072 if (type_dependent_expression_p (expr))
1073 return build_min_nt (ARROW_EXPR, expr);
1074 expr = build_non_dependent_expr (expr);
1077 if (TREE_CODE (type) == REFERENCE_TYPE)
1079 expr = convert_from_reference (expr);
1080 type = TREE_TYPE (expr);
1083 if (IS_AGGR_TYPE (type))
1085 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1086 NULL_TREE, NULL_TREE,
1087 /*overloaded_p=*/NULL)))
1089 if (expr == error_mark_node)
1090 return error_mark_node;
1092 if (value_member (TREE_TYPE (expr), types_memoized))
1094 error ("circular pointer delegation detected");
1095 return error_mark_node;
1099 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1105 if (last_rval == NULL_TREE)
1107 error ("base operand of `->' has non-pointer type `%T'", type);
1108 return error_mark_node;
1111 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1112 last_rval = convert_from_reference (last_rval);
1115 last_rval = decay_conversion (expr);
1117 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1119 if (processing_template_decl)
1121 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1122 /* It will be dereferenced. */
1123 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1127 return build_indirect_ref (last_rval, NULL);
1131 error ("result of `operator->()' yields non-pointer result");
1133 error ("base operand of `->' is not a pointer");
1134 return error_mark_node;
1137 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1138 already been checked out to be of aggregate type. */
1141 build_m_component_ref (tree datum, tree component)
1148 datum = decay_conversion (datum);
1150 if (datum == error_mark_node || component == error_mark_node)
1151 return error_mark_node;
1153 ptrmem_type = TREE_TYPE (component);
1154 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1156 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1157 component, ptrmem_type);
1158 return error_mark_node;
1161 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1162 if (! IS_AGGR_TYPE (objtype))
1164 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1165 component, datum, objtype);
1166 return error_mark_node;
1169 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1170 binfo = lookup_base (objtype, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type),
1174 error ("member type `%T::' incompatible with object type `%T'",
1176 return error_mark_node;
1178 else if (binfo == error_mark_node)
1179 return error_mark_node;
1181 if (TYPE_PTRMEM_P (ptrmem_type))
1183 /* Compute the type of the field, as described in [expr.ref].
1184 There's no such thing as a mutable pointer-to-member, so
1185 things are not as complex as they are for references to
1186 non-static data members. */
1187 type = cp_build_qualified_type (type,
1188 (cp_type_quals (type)
1189 | cp_type_quals (TREE_TYPE (datum))));
1190 /* Build an expression for "object + offset" where offset is the
1191 value stored in the pointer-to-data-member. */
1192 datum = build (PLUS_EXPR, build_pointer_type (type),
1193 build_base_path (PLUS_EXPR, build_address (datum),
1195 build_nop (ptrdiff_type_node, component));
1196 return build_indirect_ref (datum, 0);
1199 return build (OFFSET_REF, type, datum, component);
1202 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1205 build_functional_cast (tree exp, tree parms)
1207 /* This is either a call to a constructor,
1208 or a C cast in C++'s `functional' notation. */
1211 if (exp == error_mark_node || parms == error_mark_node)
1212 return error_mark_node;
1214 if (TREE_CODE (exp) == TYPE_DECL)
1215 type = TREE_TYPE (exp);
1219 if (processing_template_decl)
1221 tree t = build_min (CAST_EXPR, type, parms);
1222 /* We don't know if it will or will not have side effects. */
1223 TREE_SIDE_EFFECTS (t) = 1;
1227 if (! IS_AGGR_TYPE (type))
1229 /* This must build a C cast. */
1230 if (parms == NULL_TREE)
1231 parms = integer_zero_node;
1233 parms = build_x_compound_expr_from_list (parms, "functional cast");
1235 return build_c_cast (type, parms);
1238 /* Prepare to evaluate as a call to a constructor. If this expression
1239 is actually used, for example,
1241 return X (arg1, arg2, ...);
1243 then the slot being initialized will be filled in. */
1245 if (!complete_type_or_else (type, NULL_TREE))
1246 return error_mark_node;
1247 if (abstract_virtuals_error (NULL_TREE, type))
1248 return error_mark_node;
1250 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1251 return build_c_cast (type, TREE_VALUE (parms));
1253 /* We need to zero-initialize POD types. Let's do that for everything
1254 that doesn't need a constructor. */
1255 if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type)
1256 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1258 exp = build_constructor (type, NULL_TREE);
1259 return get_target_expr (exp);
1262 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1263 TYPE_BINFO (type), LOOKUP_NORMAL);
1265 if (exp == error_mark_node)
1266 return error_mark_node;
1268 return build_cplus_new (type, exp);
1272 /* Add new exception specifier SPEC, to the LIST we currently have.
1273 If it's already in LIST then do nothing.
1274 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1275 know what we're doing. */
1278 add_exception_specifier (tree list, tree spec, int complain)
1283 int diag_type = -1; /* none */
1285 if (spec == error_mark_node)
1288 my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
1290 /* [except.spec] 1, type in an exception specifier shall not be
1291 incomplete, or pointer or ref to incomplete other than pointer
1293 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1294 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1295 core = TREE_TYPE (core);
1298 else if (VOID_TYPE_P (core))
1300 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1302 else if (processing_template_decl)
1307 /* 15.4/1 says that types in an exception specifier must be complete,
1308 but it seems more reasonable to only require this on definitions
1309 and calls. So just give a pedwarn at this point; we will give an
1310 error later if we hit one of those two cases. */
1311 if (!COMPLETE_TYPE_P (complete_type (core)))
1312 diag_type = 2; /* pedwarn */
1319 for (probe = list; probe; probe = TREE_CHAIN (probe))
1320 if (same_type_p (TREE_VALUE (probe), spec))
1323 list = tree_cons (NULL_TREE, spec, list);
1326 diag_type = 0; /* error */
1328 if (diag_type >= 0 && complain)
1329 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1334 /* Combine the two exceptions specifier lists LIST and ADD, and return
1338 merge_exception_specifiers (tree list, tree add)
1342 else if (!TREE_VALUE (list))
1344 else if (!TREE_VALUE (add))
1348 tree orig_list = list;
1350 for (; add; add = TREE_CHAIN (add))
1352 tree spec = TREE_VALUE (add);
1355 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1356 if (same_type_p (TREE_VALUE (probe), spec))
1360 spec = build_tree_list (NULL_TREE, spec);
1361 TREE_CHAIN (spec) = list;
1369 /* Subroutine of build_call. Ensure that each of the types in the
1370 exception specification is complete. Technically, 15.4/1 says that
1371 they need to be complete when we see a declaration of the function,
1372 but we should be able to get away with only requiring this when the
1373 function is defined or called. See also add_exception_specifier. */
1376 require_complete_eh_spec_types (tree fntype, tree decl)
1379 /* Don't complain about calls to op new. */
1380 if (decl && DECL_ARTIFICIAL (decl))
1382 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1383 raises = TREE_CHAIN (raises))
1385 tree type = TREE_VALUE (raises);
1386 if (type && !COMPLETE_TYPE_P (type))
1390 ("call to function `%D' which throws incomplete type `%#T'",
1393 error ("call to function which throws incomplete type `%#T'",