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.
31 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
32 and to process initializations in declarations (since they work
33 like a strange sort of assignment). */
37 #include "coretypes.h"
44 #include "diagnostic.h"
46 static tree
process_init_constructor (tree
, tree
, tree
*);
48 /* Print an error message stemming from an attempt to use
49 BASETYPE as a base class for TYPE. */
52 error_not_base_type (tree basetype
, tree type
)
54 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
55 basetype
= DECL_CONTEXT (basetype
);
56 error ("type `%T' is not a base type for type `%T'", basetype
, type
);
57 return error_mark_node
;
61 binfo_or_else (tree base
, tree type
)
63 tree binfo
= lookup_base (type
, base
, ba_ignore
, NULL
);
65 if (binfo
== error_mark_node
)
68 error_not_base_type (base
, type
);
72 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
73 value may not be changed thereafter. Thus, we emit hard errors for these,
74 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
75 example, conversions to references.) */
78 readonly_error (tree arg
, const char* string
, int soft
)
81 void (*fn
) (const char *, ...);
88 if (TREE_CODE (arg
) == COMPONENT_REF
)
90 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
91 fmt
= "%s of data-member `%D' in read-only structure";
93 fmt
= "%s of read-only data-member `%D'";
94 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
96 else if (TREE_CODE (arg
) == VAR_DECL
)
98 if (DECL_LANG_SPECIFIC (arg
)
99 && DECL_IN_AGGR_P (arg
)
100 && !TREE_STATIC (arg
))
101 fmt
= "%s of constant field `%D'";
103 fmt
= "%s of read-only variable `%D'";
104 (*fn
) (fmt
, string
, arg
);
106 else if (TREE_CODE (arg
) == PARM_DECL
)
107 (*fn
) ("%s of read-only parameter `%D'", string
, arg
);
108 else if (TREE_CODE (arg
) == INDIRECT_REF
109 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
110 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
111 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
112 (*fn
) ("%s of read-only reference `%D'", string
, TREE_OPERAND (arg
, 0));
113 else if (TREE_CODE (arg
) == RESULT_DECL
)
114 (*fn
) ("%s of read-only named return value `%D'", string
, arg
);
115 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
116 (*fn
) ("%s of function `%D'", string
, arg
);
118 (*fn
) ("%s of read-only location", string
);
121 /* If TYPE has abstract virtual functions, issue an error about trying
122 to create an object of that type. DECL is the object declared, or
123 NULL_TREE if the declaration is unavailable. Returns 1 if an error
124 occurred; zero if all was well. */
127 abstract_virtuals_error (tree decl
, tree type
)
132 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
135 if (!TYPE_SIZE (type
))
136 /* TYPE is being defined, and during that time
137 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
140 if (dependent_type_p (type
))
141 /* For a dependent type, we do not yet know which functions are pure
145 u
= CLASSTYPE_PURE_VIRTUALS (type
);
148 if (TREE_CODE (decl
) == RESULT_DECL
)
151 if (TREE_CODE (decl
) == VAR_DECL
)
152 error ("cannot declare variable `%D' to be of type `%T'",
154 else if (TREE_CODE (decl
) == PARM_DECL
)
155 error ("cannot declare parameter `%D' to be of type `%T'",
157 else if (TREE_CODE (decl
) == FIELD_DECL
)
158 error ("cannot declare field `%D' to be of type `%T'",
160 else if (TREE_CODE (decl
) == FUNCTION_DECL
161 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
162 error ("invalid return type for member function `%#D'", decl
);
163 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
164 error ("invalid return type for function `%#D'", decl
);
167 error ("cannot allocate an object of type `%T'", type
);
169 /* Only go through this once. */
170 if (TREE_PURPOSE (u
) == NULL_TREE
)
172 TREE_PURPOSE (u
) = error_mark_node
;
174 error (" because the following virtual functions are abstract:");
175 for (tu
= u
; tu
; tu
= TREE_CHAIN (tu
))
176 cp_error_at ("\t%#D", TREE_VALUE (tu
));
179 error (" since type `%T' has abstract virtual functions", type
);
184 /* Print an error message for invalid use of an incomplete type.
185 VALUE is the expression that was used (or 0 if that isn't known)
186 and TYPE is the type that was invalid. DIAG_TYPE indicates the
187 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
191 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
194 void (*p_msg
) (const char *, ...);
195 void (*p_msg_at
) (const char *, ...);
200 p_msg_at
= cp_warning_at
;
202 else if (diag_type
== 2)
205 p_msg_at
= cp_pedwarn_at
;
210 p_msg_at
= cp_error_at
;
213 /* Avoid duplicate error message. */
214 if (TREE_CODE (type
) == ERROR_MARK
)
217 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
218 || TREE_CODE (value
) == PARM_DECL
219 || TREE_CODE (value
) == FIELD_DECL
))
221 (*p_msg_at
) ("`%D' has incomplete type", value
);
225 /* We must print an error message. Be clever about what it says. */
227 switch (TREE_CODE (type
))
233 (*p_msg
) ("invalid use of undefined type `%#T'", type
);
234 if (!TYPE_TEMPLATE_INFO (type
))
235 (*p_msg_at
) ("forward declaration of `%#T'", type
);
237 (*p_msg_at
) ("declaration of `%#T'", type
);
241 (*p_msg
) ("invalid use of `%T'", type
);
245 if (TYPE_DOMAIN (type
))
247 type
= TREE_TYPE (type
);
250 (*p_msg
) ("invalid use of array with unspecified bounds");
255 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
258 case TEMPLATE_TYPE_PARM
:
259 (*p_msg
) ("invalid use of template type parameter");
263 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
265 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
266 (*p_msg
) ("address of overloaded function with no contextual type information");
267 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
268 (*p_msg
) ("overloaded function with no contextual type information");
270 (*p_msg
) ("insufficient contextual information to determine type");
278 /* Backward-compatibility interface to incomplete_type_diagnostic;
279 required by ../tree.c. */
280 #undef cxx_incomplete_type_error
282 cxx_incomplete_type_error (tree value
, tree type
)
284 cxx_incomplete_type_diagnostic (value
, type
, 0);
288 /* The recursive part of split_nonconstant_init. DEST is an lvalue
289 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
290 PCODE is a pointer to the tail of a chain of statements being emitted.
291 The return value is the new tail of that chain after new statements
295 split_nonconstant_init_1 (tree dest
, tree init
, tree
*pcode
)
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 pcode
= split_nonconstant_init_1 (sub
, value
, pcode
);
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
);
342 pcode
= &TREE_CHAIN (code
);
345 pelt
= &TREE_CHAIN (elt
);
350 if (!initializer_constant_valid_p (init
, type
))
352 CONSTRUCTOR_ELTS (init
) = NULL
;
353 code
= build (MODIFY_EXPR
, type
, dest
, init
);
354 code
= build_stmt (EXPR_STMT
, code
);
355 pcode
= &TREE_CHAIN (code
);
366 /* A subroutine of store_init_value. Splits non-constant static
367 initializer INIT into a constant part and generates code to
368 perform the non-constant part of the initialization to DEST.
369 Returns the code for the runtime init. */
372 split_nonconstant_init (tree dest
, tree init
)
376 if (TREE_CODE (init
) == CONSTRUCTOR
)
378 code
= build_stmt (COMPOUND_STMT
, NULL_TREE
);
379 split_nonconstant_init_1 (dest
, init
, &COMPOUND_BODY (code
));
380 code
= build1 (STMT_EXPR
, void_type_node
, code
);
381 TREE_SIDE_EFFECTS (code
) = 1;
382 DECL_INITIAL (dest
) = init
;
383 TREE_READONLY (dest
) = 0;
386 code
= build (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
391 /* Perform appropriate conversions on the initial value of a variable,
392 store it in the declaration DECL,
393 and print any error messages that are appropriate.
394 If the init is invalid, store an ERROR_MARK.
396 C++: Note that INIT might be a TREE_LIST, which would mean that it is
397 a base class initializer for some aggregate type, hopefully compatible
398 with DECL. If INIT is a single element, and DECL is an aggregate
399 type, we silently convert INIT into a TREE_LIST, allowing a constructor
402 If INIT is a TREE_LIST and there is no constructor, turn INIT
403 into a CONSTRUCTOR and use standard initialization techniques.
404 Perhaps a warning should be generated?
406 Returns code to be executed if initialization could not be performed
407 for static variable. In that case, caller must emit the code. */
410 store_init_value (tree decl
, tree init
)
414 /* If variable's type was invalidly declared, just ignore it. */
416 type
= TREE_TYPE (decl
);
417 if (TREE_CODE (type
) == ERROR_MARK
)
420 if (IS_AGGR_TYPE (type
))
422 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
423 && TREE_CODE (init
) != CONSTRUCTOR
)
426 if (TREE_CODE (init
) == TREE_LIST
)
428 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
429 init
= build_constructor (NULL_TREE
, nreverse (init
));
432 else if (TREE_CODE (init
) == TREE_LIST
433 && TREE_TYPE (init
) != unknown_type_node
)
435 if (TREE_CODE (decl
) == RESULT_DECL
)
436 init
= build_x_compound_expr_from_list (init
,
437 "return value initializer");
438 else if (TREE_CODE (init
) == TREE_LIST
439 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
441 error ("cannot initialize arrays using this syntax");
445 /* We get here with code like `int a (2);' */
446 init
= build_x_compound_expr_from_list (init
, "initializer");
449 /* End of special C++ code. */
451 /* Digest the specified initializer into an expression. */
452 value
= digest_init (type
, init
, (tree
*) 0);
454 /* Store the expression if valid; else report error. */
456 if (TREE_CODE (value
) == ERROR_MARK
)
458 /* Other code expects that initializers for objects of types that need
459 constructing never make it into DECL_INITIAL, and passes 'init' to
460 build_aggr_init without checking DECL_INITIAL. So just return. */
461 else if (TYPE_NEEDS_CONSTRUCTING (type
))
462 return build (INIT_EXPR
, type
, decl
, value
);
463 else if (TREE_STATIC (decl
)
464 && (! TREE_CONSTANT (value
)
465 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
466 return split_nonconstant_init (decl
, value
);
468 /* Store the VALUE in DECL_INITIAL. If we're building a
469 statement-tree we will actually expand the initialization later
470 when we output this function. */
471 DECL_INITIAL (decl
) = value
;
476 /* Digest the parser output INIT as an initializer for type TYPE.
477 Return a C expression of type TYPE to represent the initial value.
479 If TAIL is nonzero, it points to a variable holding a list of elements
480 of which INIT is the first. We update the list stored there by
481 removing from the head all the elements that we use.
482 Normally this is only one; we use more than one element only if
483 TYPE is an aggregate and INIT is not a constructor. */
486 digest_init (tree type
, tree init
, tree
* tail
)
488 enum tree_code code
= TREE_CODE (type
);
489 tree element
= NULL_TREE
;
490 tree old_tail_contents
= NULL_TREE
;
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 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
521 && CONSTRUCTOR_ELTS (init
) != 0
522 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
524 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
525 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
526 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
527 element
= TREE_OPERAND (element
, 0);
528 if (element
== error_mark_node
)
532 /* Initialization of an array of chars from a string constant
533 optionally enclosed in braces. */
535 if (code
== ARRAY_TYPE
)
539 if (TREE_CODE (init
) == TREE_LIST
)
541 error ("initializing array with parameter list");
542 return error_mark_node
;
545 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
546 if (char_type_p (typ1
)
547 && ((init
&& TREE_CODE (init
) == STRING_CST
)
548 || (element
&& TREE_CODE (element
) == STRING_CST
)))
550 tree string
= element
? element
: init
;
552 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
554 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
556 error ("char-array initialized from wide string");
557 return error_mark_node
;
559 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
561 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
563 error ("int-array initialized from non-wide string");
564 return error_mark_node
;
567 TREE_TYPE (string
) = type
;
568 if (TYPE_DOMAIN (type
) != 0
569 && TREE_CONSTANT (TYPE_SIZE (type
)))
571 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
572 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
573 /* In C it is ok to subtract 1 from the length of the string
574 because it's ok to ignore the terminating null char that is
575 counted in the length of the constant, but in C++ this would
577 if (size
< TREE_STRING_LENGTH (string
))
578 pedwarn ("initializer-string for array of chars is too long");
584 /* Handle scalar types, including conversions,
585 and signature pointers and references. */
587 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
588 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
589 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
590 || TYPE_PTR_TO_MEMBER_P (type
))
592 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
596 error ("initializer for scalar variable requires one element");
597 return error_mark_node
;
601 while (BRACE_ENCLOSED_INITIALIZER_P (init
))
603 pedwarn ("braces around scalar initializer for `%T'", type
);
604 init
= CONSTRUCTOR_ELTS (init
);
605 if (TREE_CHAIN (init
))
606 pedwarn ("ignoring extra initializers for `%T'", type
);
607 init
= TREE_VALUE (init
);
610 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
611 "initialization", NULL_TREE
, 0);
614 /* Come here only for records and arrays (and unions with constructors). */
616 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
618 error ("variable-sized object of type `%T' may not be initialized",
620 return error_mark_node
;
623 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
625 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
627 if (TYPE_NON_AGGREGATE_CLASS (type
))
629 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
631 return error_mark_node
;
633 return process_init_constructor (type
, init
, (tree
*)0);
635 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
636 || TYPE_NON_AGGREGATE_CLASS (type
))
637 /* These are never initialized from multiple constructor elements. */;
640 *tail
= old_tail_contents
;
641 return process_init_constructor (type
, 0, tail
);
644 if (code
!= ARRAY_TYPE
)
646 int flags
= LOOKUP_NORMAL
;
647 /* Initialization from { } is copy-initialization. */
649 flags
|= LOOKUP_ONLYCONVERTING
;
651 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
652 "initialization", NULL_TREE
, 0);
656 error ("invalid initializer");
657 return error_mark_node
;
660 /* Process a constructor for a variable of type TYPE.
661 The constructor elements may be specified either with INIT or with ELTS,
662 only one of which should be non-null.
664 If INIT is specified, it is a CONSTRUCTOR node which is specifically
665 and solely for initializing this datum.
667 If ELTS is specified, it is the address of a variable containing
668 a list of expressions. We take as many elements as we need
669 from the head of the list and update the list.
671 In the resulting constructor, TREE_CONSTANT is set if all elts are
672 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
673 constants that the assembler and linker can compute them. */
676 process_init_constructor (tree type
, tree init
, tree
* elts
)
679 /* List of the elements of the result constructor,
688 /* Make TAIL be the list of elements to use for the initialization,
689 no matter how the data was given to us. */
693 if (warn_missing_braces
)
694 warning ("aggregate has a partly bracketed initializer");
698 tail
= CONSTRUCTOR_ELTS (init
);
700 /* Gobble as many elements as needed, and make a constructor or initial value
701 for each element of this aggregate. Chain them together in result.
702 If there are too few, use 0 for each scalar ultimate component. */
704 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
709 if (TREE_CODE (type
) == ARRAY_TYPE
)
711 tree domain
= TYPE_DOMAIN (type
);
713 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
714 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
717 len
= -1; /* Take as many as there are. */
721 /* Vectors are like simple fixed-size arrays. */
722 len
= TYPE_VECTOR_SUBPARTS (type
);
725 for (i
= 0; len
< 0 || i
< len
; i
++)
729 if (TREE_PURPOSE (tail
)
730 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
731 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
732 sorry ("non-trivial labeled initializers");
734 if (TREE_VALUE (tail
) != 0)
737 next1
= digest_init (TREE_TYPE (type
),
738 TREE_VALUE (tail
), &tail1
);
739 if (next1
== error_mark_node
)
742 (same_type_ignoring_top_level_qualifiers_p
743 (TREE_TYPE (type
), TREE_TYPE (next1
)),
745 my_friendly_assert (tail1
== 0
746 || TREE_CODE (tail1
) == TREE_LIST
, 319);
747 if (tail
== tail1
&& len
< 0)
749 error ("non-empty initializer for array of empty elements");
750 /* Just ignore what we were supposed to use. */
757 next1
= error_mark_node
;
758 tail
= TREE_CHAIN (tail
);
764 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
766 /* If this type needs constructors run for
767 default-initialization, we can't rely on the backend to do it
768 for us, so build up TARGET_EXPRs. If the type in question is
769 a class, just build one up; if it's an array, recurse. */
771 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
772 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
774 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
775 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
777 else if (! zero_init_p (TREE_TYPE (type
)))
778 next1
= build_zero_init (TREE_TYPE (type
),
780 /*static_storage_p=*/false);
782 /* The default zero-initialization is fine for us; don't
783 add anything to the CONSTRUCTOR. */
786 if (next1
== error_mark_node
)
788 else if (!TREE_CONSTANT (next1
))
790 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
792 members
= tree_cons (size_int (i
), next1
, members
);
795 else if (TREE_CODE (type
) == RECORD_TYPE
)
801 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
803 sorry ("initializer list for object of class with virtual base classes");
804 return error_mark_node
;
807 if (TYPE_BINFO_BASETYPES (type
))
809 sorry ("initializer list for object of class with base classes");
810 return error_mark_node
;
813 if (TYPE_POLYMORPHIC_P (type
))
815 sorry ("initializer list for object using virtual functions");
816 return error_mark_node
;
820 for (field
= TYPE_FIELDS (type
); field
;
821 field
= TREE_CHAIN (field
))
823 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
825 members
= tree_cons (field
, integer_zero_node
, members
);
829 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
834 if (TREE_PURPOSE (tail
)
835 && TREE_PURPOSE (tail
) != field
836 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
837 sorry ("non-trivial labeled initializers");
839 if (TREE_VALUE (tail
) != 0)
843 next1
= digest_init (TREE_TYPE (field
),
844 TREE_VALUE (tail
), &tail1
);
845 my_friendly_assert (tail1
== 0
846 || TREE_CODE (tail1
) == TREE_LIST
, 320);
851 next1
= error_mark_node
;
852 tail
= TREE_CHAIN (tail
);
855 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
857 /* If this type needs constructors run for
858 default-initialization, we can't rely on the backend to do it
859 for us, so build up TARGET_EXPRs. If the type in question is
860 a class, just build one up; if it's an array, recurse. */
862 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
863 next1
= build_functional_cast (TREE_TYPE (field
),
867 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
869 TREE_HAS_CONSTRUCTOR (next1
)
870 = TREE_HAS_CONSTRUCTOR (init
);
872 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
874 /* Warn when some struct elements are implicitly initialized. */
876 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
877 warning ("missing initializer for member `%D'", field
);
881 if (TREE_READONLY (field
))
882 error ("uninitialized const member `%D'", field
);
883 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
884 error ("member `%D' with uninitialized const fields",
886 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
887 error ("member `%D' is uninitialized reference", field
);
889 /* Warn when some struct elements are implicitly initialized
892 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
893 warning ("missing initializer for member `%D'", field
);
895 if (! zero_init_p (TREE_TYPE (field
)))
896 next1
= build_zero_init (TREE_TYPE (field
),
898 /*static_storage_p=*/false);
900 /* The default zero-initialization is fine for us; don't
901 add anything to the CONSTRUCTOR. */
905 if (next1
== error_mark_node
)
907 else if (!TREE_CONSTANT (next1
))
909 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
911 members
= tree_cons (field
, next1
, members
);
914 else if (TREE_CODE (type
) == UNION_TYPE
915 /* If the initializer was empty, use default zero initialization. */
918 tree field
= TYPE_FIELDS (type
);
920 /* Find the first named field. ANSI decided in September 1990
921 that only named fields count here. */
922 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
923 field
= TREE_CHAIN (field
);
925 /* If this element specifies a field, initialize via that field. */
926 if (TREE_PURPOSE (tail
) != NULL_TREE
)
930 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
931 /* Handle the case of a call by build_c_cast. */
932 field
= TREE_PURPOSE (tail
), win
= 1;
933 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
934 error ("index value instead of field name in union initializer");
938 for (temp
= TYPE_FIELDS (type
);
940 temp
= TREE_CHAIN (temp
))
941 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
944 field
= temp
, win
= 1;
946 error ("no field `%D' in union being initialized",
947 TREE_PURPOSE (tail
));
950 TREE_VALUE (tail
) = error_mark_node
;
954 error ("union `%T' with no named members cannot be initialized",
956 TREE_VALUE (tail
) = error_mark_node
;
959 if (TREE_VALUE (tail
) != 0)
963 next1
= digest_init (TREE_TYPE (field
),
964 TREE_VALUE (tail
), &tail1
);
965 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
971 next1
= error_mark_node
;
972 tail
= TREE_CHAIN (tail
);
975 if (next1
== error_mark_node
)
977 else if (!TREE_CONSTANT (next1
))
979 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
981 members
= tree_cons (field
, next1
, members
);
984 /* If arguments were specified as a list, just remove the ones we used. */
987 /* If arguments were specified as a constructor,
988 complain unless we used all the elements of the constructor. */
990 pedwarn ("excess elements in aggregate initializer");
993 return error_mark_node
;
995 result
= build_constructor (type
, nreverse (members
));
996 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
997 complete_array_type (type
, result
, /*do_default=*/0);
999 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
1000 if (allconstant
) TREE_CONSTANT (result
) = 1;
1001 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
1005 /* Given a structure or union value DATUM, construct and return
1006 the structure or union component which results from narrowing
1007 that value to the base specified in BASETYPE. For example, given the
1010 class L { int ii; };
1011 class A : L { ... };
1012 class B : L { ... };
1013 class C : A, B { ... };
1021 x.A::ii refers to the ii member of the L part of
1022 the A part of the C object named by X. In this case,
1023 DATUM would be x, and BASETYPE would be A.
1025 I used to think that this was nonconformant, that the standard specified
1026 that first we look up ii in A, then convert x to an L& and pull out the
1027 ii part. But in fact, it does say that we convert x to an A&; A here
1028 is known as the "naming class". (jason 2000-12-19)
1030 BINFO_P points to a variable initialized either to NULL_TREE or to the
1031 binfo for the specific base subobject we want to convert to. */
1034 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1038 if (datum
== error_mark_node
)
1039 return error_mark_node
;
1043 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1045 if (!binfo
|| binfo
== error_mark_node
)
1047 *binfo_p
= NULL_TREE
;
1049 error_not_base_type (basetype
, TREE_TYPE (datum
));
1050 return error_mark_node
;
1054 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1057 /* Build a reference to an object specified by the C++ `->' operator.
1058 Usually this just involves dereferencing the object, but if the
1059 `->' operator is overloaded, then such overloads must be
1060 performed until an object which does not have the `->' operator
1061 overloaded is found. An error is reported when circular pointer
1062 delegation is detected. */
1065 build_x_arrow (tree expr
)
1067 tree orig_expr
= expr
;
1068 tree types_memoized
= NULL_TREE
;
1069 tree type
= TREE_TYPE (expr
);
1070 tree last_rval
= NULL_TREE
;
1072 if (type
== error_mark_node
)
1073 return error_mark_node
;
1075 if (processing_template_decl
)
1077 if (type_dependent_expression_p (expr
))
1078 return build_min_nt (ARROW_EXPR
, expr
);
1079 expr
= build_non_dependent_expr (expr
);
1082 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1084 expr
= convert_from_reference (expr
);
1085 type
= TREE_TYPE (expr
);
1088 if (IS_AGGR_TYPE (type
))
1090 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1091 NULL_TREE
, NULL_TREE
,
1092 /*overloaded_p=*/NULL
)))
1094 if (expr
== error_mark_node
)
1095 return error_mark_node
;
1097 if (value_member (TREE_TYPE (expr
), types_memoized
))
1099 error ("circular pointer delegation detected");
1100 return error_mark_node
;
1104 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1110 if (last_rval
== NULL_TREE
)
1112 error ("base operand of `->' has non-pointer type `%T'", type
);
1113 return error_mark_node
;
1116 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1117 last_rval
= convert_from_reference (last_rval
);
1120 last_rval
= decay_conversion (expr
);
1122 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1124 if (processing_template_decl
)
1126 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1127 /* It will be dereferenced. */
1128 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1132 return build_indirect_ref (last_rval
, NULL
);
1136 error ("result of `operator->()' yields non-pointer result");
1138 error ("base operand of `->' is not a pointer");
1139 return error_mark_node
;
1142 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1143 already been checked out to be of aggregate type. */
1146 build_m_component_ref (tree datum
, tree component
)
1153 datum
= decay_conversion (datum
);
1155 if (datum
== error_mark_node
|| component
== error_mark_node
)
1156 return error_mark_node
;
1158 ptrmem_type
= TREE_TYPE (component
);
1159 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1161 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1162 component
, ptrmem_type
);
1163 return error_mark_node
;
1166 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1167 if (! IS_AGGR_TYPE (objtype
))
1169 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1170 component
, datum
, objtype
);
1171 return error_mark_node
;
1174 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1175 binfo
= lookup_base (objtype
, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
),
1179 error ("member type `%T::' incompatible with object type `%T'",
1181 return error_mark_node
;
1183 else if (binfo
== error_mark_node
)
1184 return error_mark_node
;
1186 if (TYPE_PTRMEM_P (ptrmem_type
))
1188 /* Compute the type of the field, as described in [expr.ref].
1189 There's no such thing as a mutable pointer-to-member, so
1190 things are not as complex as they are for references to
1191 non-static data members. */
1192 type
= cp_build_qualified_type (type
,
1193 (cp_type_quals (type
)
1194 | cp_type_quals (TREE_TYPE (datum
))));
1195 /* Build an expression for "object + offset" where offset is the
1196 value stored in the pointer-to-data-member. */
1197 datum
= build (PLUS_EXPR
, build_pointer_type (type
),
1198 build_base_path (PLUS_EXPR
, build_address (datum
),
1200 build_nop (ptrdiff_type_node
, component
));
1201 return build_indirect_ref (datum
, 0);
1204 return build (OFFSET_REF
, type
, datum
, component
);
1207 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1210 build_functional_cast (tree exp
, tree parms
)
1212 /* This is either a call to a constructor,
1213 or a C cast in C++'s `functional' notation. */
1216 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1217 return error_mark_node
;
1219 if (TREE_CODE (exp
) == TYPE_DECL
)
1220 type
= TREE_TYPE (exp
);
1224 if (processing_template_decl
)
1226 tree t
= build_min (CAST_EXPR
, type
, parms
);
1227 /* We don't know if it will or will not have side effects. */
1228 TREE_SIDE_EFFECTS (t
) = 1;
1232 if (! IS_AGGR_TYPE (type
))
1234 /* This must build a C cast. */
1235 if (parms
== NULL_TREE
)
1236 parms
= integer_zero_node
;
1238 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1240 return build_c_cast (type
, parms
);
1243 /* Prepare to evaluate as a call to a constructor. If this expression
1244 is actually used, for example,
1246 return X (arg1, arg2, ...);
1248 then the slot being initialized will be filled in. */
1250 if (!complete_type_or_else (type
, NULL_TREE
))
1251 return error_mark_node
;
1252 if (abstract_virtuals_error (NULL_TREE
, type
))
1253 return error_mark_node
;
1255 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1256 return build_c_cast (type
, TREE_VALUE (parms
));
1258 /* We need to zero-initialize POD types. Let's do that for everything
1259 that doesn't need a constructor. */
1260 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1261 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1263 exp
= build_constructor (type
, NULL_TREE
);
1264 return get_target_expr (exp
);
1267 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1268 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1270 if (exp
== error_mark_node
)
1271 return error_mark_node
;
1273 return build_cplus_new (type
, exp
);
1277 /* Add new exception specifier SPEC, to the LIST we currently have.
1278 If it's already in LIST then do nothing.
1279 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1280 know what we're doing. */
1283 add_exception_specifier (tree list
, tree spec
, int complain
)
1288 int diag_type
= -1; /* none */
1290 if (spec
== error_mark_node
)
1293 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1295 /* [except.spec] 1, type in an exception specifier shall not be
1296 incomplete, or pointer or ref to incomplete other than pointer
1298 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1299 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1300 core
= TREE_TYPE (core
);
1303 else if (VOID_TYPE_P (core
))
1305 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1307 else if (processing_template_decl
)
1312 /* 15.4/1 says that types in an exception specifier must be complete,
1313 but it seems more reasonable to only require this on definitions
1314 and calls. So just give a pedwarn at this point; we will give an
1315 error later if we hit one of those two cases. */
1316 if (!COMPLETE_TYPE_P (complete_type (core
)))
1317 diag_type
= 2; /* pedwarn */
1324 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1325 if (same_type_p (TREE_VALUE (probe
), spec
))
1328 list
= tree_cons (NULL_TREE
, spec
, list
);
1331 diag_type
= 0; /* error */
1333 if (diag_type
>= 0 && complain
)
1334 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1339 /* Combine the two exceptions specifier lists LIST and ADD, and return
1343 merge_exception_specifiers (tree list
, tree add
)
1347 else if (!TREE_VALUE (list
))
1349 else if (!TREE_VALUE (add
))
1353 tree orig_list
= list
;
1355 for (; add
; add
= TREE_CHAIN (add
))
1357 tree spec
= TREE_VALUE (add
);
1360 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1361 if (same_type_p (TREE_VALUE (probe
), spec
))
1365 spec
= build_tree_list (NULL_TREE
, spec
);
1366 TREE_CHAIN (spec
) = list
;
1374 /* Subroutine of build_call. Ensure that each of the types in the
1375 exception specification is complete. Technically, 15.4/1 says that
1376 they need to be complete when we see a declaration of the function,
1377 but we should be able to get away with only requiring this when the
1378 function is defined or called. See also add_exception_specifier. */
1381 require_complete_eh_spec_types (tree fntype
, tree decl
)
1384 /* Don't complain about calls to op new. */
1385 if (decl
&& DECL_ARTIFICIAL (decl
))
1387 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1388 raises
= TREE_CHAIN (raises
))
1390 tree type
= TREE_VALUE (raises
);
1391 if (type
&& !COMPLETE_TYPE_P (type
))
1395 ("call to function `%D' which throws incomplete type `%#T'",
1398 error ("call to function which throws incomplete type `%#T'",