1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* This file is part of the C++ front end.
26 It contains routines to build C++ expressions given their operands,
27 including computing the types of the result, C and C++ specific error
28 checks, and some optimization.
30 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
31 and to process initializations in declarations (since they work
32 like a strange sort of assignment). */
36 #include "coretypes.h"
43 #include "diagnostic.h"
45 static tree process_init_constructor
PARAMS ((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 (basetype
, 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 (base
, type
)
64 tree binfo
= lookup_base (type
, base
, ba_ignore
, NULL
);
66 if (binfo
== error_mark_node
)
69 error_not_base_type (base
, type
);
73 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
74 value may not be changed thereafter. Thus, we emit hard errors for these,
75 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
76 example, conversions to references.) */
79 readonly_error (arg
, string
, soft
)
85 void (*fn
) PARAMS ((const char *, ...));
92 if (TREE_CODE (arg
) == COMPONENT_REF
)
94 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
95 fmt
= "%s of data-member `%D' in read-only structure";
97 fmt
= "%s of read-only data-member `%D'";
98 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
100 else if (TREE_CODE (arg
) == VAR_DECL
)
102 if (DECL_LANG_SPECIFIC (arg
)
103 && DECL_IN_AGGR_P (arg
)
104 && !TREE_STATIC (arg
))
105 fmt
= "%s of constant field `%D'";
107 fmt
= "%s of read-only variable `%D'";
108 (*fn
) (fmt
, string
, arg
);
110 else if (TREE_CODE (arg
) == PARM_DECL
)
111 (*fn
) ("%s of read-only parameter `%D'", string
, arg
);
112 else if (TREE_CODE (arg
) == INDIRECT_REF
113 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
114 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
115 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
116 (*fn
) ("%s of read-only reference `%D'", string
, TREE_OPERAND (arg
, 0));
117 else if (TREE_CODE (arg
) == RESULT_DECL
)
118 (*fn
) ("%s of read-only named return value `%D'", string
, arg
);
119 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
120 (*fn
) ("%s of function `%D'", string
, arg
);
122 (*fn
) ("%s of read-only location", string
);
125 /* If TYPE has abstract virtual functions, issue an error about trying
126 to create an object of that type. DECL is the object declared, or
127 NULL_TREE if the declaration is unavailable. Returns 1 if an error
128 occurred; zero if all was well. */
131 abstract_virtuals_error (decl
, type
)
138 if (!CLASS_TYPE_P (type
) || !CLASSTYPE_PURE_VIRTUALS (type
))
141 if (!TYPE_SIZE (type
))
142 /* TYPE is being defined, and during that time
143 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
146 if (dependent_type_p (type
))
147 /* For a dependent type, we do not yet know which functions are pure
151 u
= CLASSTYPE_PURE_VIRTUALS (type
);
154 if (TREE_CODE (decl
) == RESULT_DECL
)
157 if (TREE_CODE (decl
) == VAR_DECL
)
158 error ("cannot declare variable `%D' to be of type `%T'",
160 else if (TREE_CODE (decl
) == PARM_DECL
)
161 error ("cannot declare parameter `%D' to be of type `%T'",
163 else if (TREE_CODE (decl
) == FIELD_DECL
)
164 error ("cannot declare field `%D' to be of type `%T'",
166 else if (TREE_CODE (decl
) == FUNCTION_DECL
167 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
168 error ("invalid return type for member function `%#D'", decl
);
169 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
170 error ("invalid return type for function `%#D'", decl
);
173 error ("cannot allocate an object of type `%T'", type
);
175 /* Only go through this once. */
176 if (TREE_PURPOSE (u
) == NULL_TREE
)
178 TREE_PURPOSE (u
) = error_mark_node
;
180 error (" because the following virtual functions are abstract:");
181 for (tu
= u
; tu
; tu
= TREE_CHAIN (tu
))
182 cp_error_at ("\t%#D", TREE_VALUE (tu
));
185 error (" since type `%T' has abstract virtual functions", type
);
190 /* Print an error message for invalid use of an incomplete type.
191 VALUE is the expression that was used (or 0 if that isn't known)
192 and TYPE is the type that was invalid. DIAG_TYPE indicates the
193 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
197 cxx_incomplete_type_diagnostic (value
, type
, diag_type
)
203 void (*p_msg
) PARAMS ((const char *, ...));
204 void (*p_msg_at
) PARAMS ((const char *, ...));
209 p_msg_at
= cp_warning_at
;
211 else if (diag_type
== 2)
214 p_msg_at
= cp_pedwarn_at
;
219 p_msg_at
= cp_error_at
;
222 /* Avoid duplicate error message. */
223 if (TREE_CODE (type
) == ERROR_MARK
)
226 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
227 || TREE_CODE (value
) == PARM_DECL
228 || TREE_CODE (value
) == FIELD_DECL
))
230 (*p_msg_at
) ("`%D' has incomplete type", value
);
234 /* We must print an error message. Be clever about what it says. */
236 switch (TREE_CODE (type
))
242 (*p_msg
) ("invalid use of undefined type `%#T'", type
);
243 if (!TYPE_TEMPLATE_INFO (type
))
244 (*p_msg_at
) ("forward declaration of `%#T'", type
);
246 (*p_msg_at
) ("declaration of `%#T'", type
);
250 (*p_msg
) ("invalid use of `%T'", type
);
254 if (TYPE_DOMAIN (type
))
256 type
= TREE_TYPE (type
);
259 (*p_msg
) ("invalid use of array with unspecified bounds");
264 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
267 case TEMPLATE_TYPE_PARM
:
268 (*p_msg
) ("invalid use of template type parameter");
272 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
274 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
275 (*p_msg
) ("address of overloaded function with no contextual type information");
276 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
277 (*p_msg
) ("overloaded function with no contextual type information");
279 (*p_msg
) ("insufficient contextual information to determine type");
287 /* Backward-compatibility interface to incomplete_type_diagnostic;
288 required by ../tree.c. */
289 #undef cxx_incomplete_type_error
291 cxx_incomplete_type_error (value
, type
)
295 cxx_incomplete_type_diagnostic (value
, type
, 0);
299 /* Perform appropriate conversions on the initial value of a variable,
300 store it in the declaration DECL,
301 and print any error messages that are appropriate.
302 If the init is invalid, store an ERROR_MARK.
304 C++: Note that INIT might be a TREE_LIST, which would mean that it is
305 a base class initializer for some aggregate type, hopefully compatible
306 with DECL. If INIT is a single element, and DECL is an aggregate
307 type, we silently convert INIT into a TREE_LIST, allowing a constructor
310 If INIT is a TREE_LIST and there is no constructor, turn INIT
311 into a CONSTRUCTOR and use standard initialization techniques.
312 Perhaps a warning should be generated?
314 Returns value of initializer if initialization could not be
315 performed for static variable. In that case, caller must do
319 store_init_value (decl
, init
)
322 register tree value
, type
;
324 /* If variable's type was invalidly declared, just ignore it. */
326 type
= TREE_TYPE (decl
);
327 if (TREE_CODE (type
) == ERROR_MARK
)
330 if (IS_AGGR_TYPE (type
))
332 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
333 && TREE_CODE (init
) != CONSTRUCTOR
)
336 if (TREE_CODE (init
) == TREE_LIST
)
338 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
339 init
= build_nt (CONSTRUCTOR
, NULL_TREE
, nreverse (init
));
342 else if (TREE_CODE (init
) == TREE_LIST
343 && TREE_TYPE (init
) != unknown_type_node
)
345 if (TREE_CODE (decl
) == RESULT_DECL
)
347 if (TREE_CHAIN (init
))
349 warning ("comma expression used to initialize return value");
350 init
= build_compound_expr (init
);
353 init
= TREE_VALUE (init
);
355 else if (TREE_CODE (init
) == TREE_LIST
356 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
358 error ("cannot initialize arrays using this syntax");
363 /* We get here with code like `int a (2);' */
365 if (TREE_CHAIN (init
) != NULL_TREE
)
367 pedwarn ("initializer list being treated as compound expression");
368 init
= build_compound_expr (init
);
371 init
= TREE_VALUE (init
);
375 /* End of special C++ code. */
377 /* Digest the specified initializer into an expression. */
378 value
= digest_init (type
, init
, (tree
*) 0);
380 /* Store the expression if valid; else report error. */
382 if (TREE_CODE (value
) == ERROR_MARK
)
384 /* Other code expects that initializers for objects of types that need
385 constructing never make it into DECL_INITIAL, and passes 'init' to
386 build_aggr_init without checking DECL_INITIAL. So just return. */
387 else if (TYPE_NEEDS_CONSTRUCTING (type
))
389 else if (TREE_STATIC (decl
)
390 && (! TREE_CONSTANT (value
)
391 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))
393 /* A STATIC PUBLIC int variable doesn't have to be
394 run time inited when doing pic. (mrs) */
395 /* Since ctors and dtors are the only things that can
396 reference vtables, and they are always written down
397 the vtable definition, we can leave the
398 vtables in initialized data space.
399 However, other initialized data cannot be initialized
400 this way. Instead a global file-level initializer
402 || (flag_pic
&& !DECL_VIRTUAL_P (decl
) && TREE_PUBLIC (decl
))
407 #if 0 /* No, that's C. jason 9/19/94 */
410 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
412 if (! TREE_CONSTANT (value
) || ! TREE_STATIC (value
))
413 pedwarn ("ISO C++ forbids non-constant aggregate initializer expressions");
418 /* Store the VALUE in DECL_INITIAL. If we're building a
419 statement-tree we will actually expand the initialization later
420 when we output this function. */
421 DECL_INITIAL (decl
) = value
;
426 /* Digest the parser output INIT as an initializer for type TYPE.
427 Return a C expression of type TYPE to represent the initial value.
429 If TAIL is nonzero, it points to a variable holding a list of elements
430 of which INIT is the first. We update the list stored there by
431 removing from the head all the elements that we use.
432 Normally this is only one; we use more than one element only if
433 TYPE is an aggregate and INIT is not a constructor. */
436 digest_init (type
, init
, tail
)
437 tree type
, init
, *tail
;
439 enum tree_code code
= TREE_CODE (type
);
440 tree element
= NULL_TREE
;
441 tree old_tail_contents
= NULL_TREE
;
442 /* Nonzero if INIT is a braced grouping. */
445 /* By default, assume we use one element from a list.
446 We correct this later in the sole case where it is not true. */
450 old_tail_contents
= *tail
;
451 *tail
= TREE_CHAIN (*tail
);
454 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
455 && TREE_VALUE (init
) == error_mark_node
))
456 return error_mark_node
;
458 if (TREE_CODE (init
) == ERROR_MARK
)
459 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
460 a template function. This gets substituted during instantiation. */
463 /* We must strip the outermost array type when completing the type,
464 because the its bounds might be incomplete at the moment. */
465 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
466 ? TREE_TYPE (type
) : type
, NULL_TREE
))
467 return error_mark_node
;
469 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
470 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
471 init
= TREE_OPERAND (init
, 0);
473 raw_constructor
= (TREE_CODE (init
) == CONSTRUCTOR
474 && TREE_HAS_CONSTRUCTOR (init
));
477 && CONSTRUCTOR_ELTS (init
) != 0
478 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
480 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
481 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
482 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
483 element
= TREE_OPERAND (element
, 0);
484 if (element
== error_mark_node
)
488 /* Initialization of an array of chars from a string constant
489 optionally enclosed in braces. */
491 if (code
== ARRAY_TYPE
)
495 if (TREE_CODE (init
) == TREE_LIST
)
497 error ("initializing array with parameter list");
498 return error_mark_node
;
501 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
502 if (char_type_p (typ1
)
503 && ((init
&& TREE_CODE (init
) == STRING_CST
)
504 || (element
&& TREE_CODE (element
) == STRING_CST
)))
506 tree string
= element
? element
: init
;
508 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
510 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
512 error ("char-array initialized from wide string");
513 return error_mark_node
;
515 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
517 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
519 error ("int-array initialized from non-wide string");
520 return error_mark_node
;
523 TREE_TYPE (string
) = type
;
524 if (TYPE_DOMAIN (type
) != 0
525 && TREE_CONSTANT (TYPE_SIZE (type
)))
528 = TREE_INT_CST_LOW (TYPE_SIZE (type
));
529 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
530 /* In C it is ok to subtract 1 from the length of the string
531 because it's ok to ignore the terminating null char that is
532 counted in the length of the constant, but in C++ this would
534 if (size
< TREE_STRING_LENGTH (string
))
535 pedwarn ("initializer-string for array of chars is too long");
541 /* Handle scalar types, including conversions,
542 and signature pointers and references. */
544 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
545 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
546 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
547 || TYPE_PTRMEMFUNC_P (type
))
553 error ("initializer for scalar variable requires one element");
554 return error_mark_node
;
558 while (TREE_CODE (init
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (init
))
560 pedwarn ("braces around scalar initializer for `%T'", type
);
561 init
= CONSTRUCTOR_ELTS (init
);
562 if (TREE_CHAIN (init
))
563 pedwarn ("ignoring extra initializers for `%T'", type
);
564 init
= TREE_VALUE (init
);
567 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
568 "initialization", NULL_TREE
, 0);
571 /* Come here only for records and arrays (and unions with constructors). */
573 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
575 error ("variable-sized object of type `%T' may not be initialized",
577 return error_mark_node
;
580 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
582 if (raw_constructor
&& TYPE_NON_AGGREGATE_CLASS (type
)
583 && TREE_HAS_CONSTRUCTOR (init
))
585 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
587 return error_mark_node
;
589 else if (raw_constructor
)
590 return process_init_constructor (type
, init
, (tree
*)0);
591 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
592 || TYPE_NON_AGGREGATE_CLASS (type
))
593 /* These are never initialized from multiple constructor elements. */;
596 *tail
= old_tail_contents
;
597 return process_init_constructor (type
, 0, tail
);
600 if (code
!= ARRAY_TYPE
)
602 int flags
= LOOKUP_NORMAL
;
603 /* Initialization from { } is copy-initialization. */
605 flags
|= LOOKUP_ONLYCONVERTING
;
607 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
608 "initialization", NULL_TREE
, 0);
612 error ("invalid initializer");
613 return error_mark_node
;
616 /* Process a constructor for a variable of type TYPE.
617 The constructor elements may be specified either with INIT or with ELTS,
618 only one of which should be non-null.
620 If INIT is specified, it is a CONSTRUCTOR node which is specifically
621 and solely for initializing this datum.
623 If ELTS is specified, it is the address of a variable containing
624 a list of expressions. We take as many elements as we need
625 from the head of the list and update the list.
627 In the resulting constructor, TREE_CONSTANT is set if all elts are
628 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
629 constants that the assembler and linker can compute them. */
632 process_init_constructor (type
, init
, elts
)
633 tree type
, init
, *elts
;
636 /* List of the elements of the result constructor,
638 register tree members
= NULL
;
645 /* Make TAIL be the list of elements to use for the initialization,
646 no matter how the data was given to us. */
650 if (warn_missing_braces
)
651 warning ("aggregate has a partly bracketed initializer");
655 tail
= CONSTRUCTOR_ELTS (init
);
657 /* Gobble as many elements as needed, and make a constructor or initial value
658 for each element of this aggregate. Chain them together in result.
659 If there are too few, use 0 for each scalar ultimate component. */
661 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
666 if (TREE_CODE (type
) == ARRAY_TYPE
)
668 tree domain
= TYPE_DOMAIN (type
);
670 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
671 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
674 len
= -1; /* Take as many as there are */
678 /* Vectors are like simple fixed-size arrays. */
679 len
= TYPE_VECTOR_SUBPARTS (type
);
682 for (i
= 0; len
< 0 || i
< len
; i
++)
686 if (TREE_PURPOSE (tail
)
687 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
688 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
689 sorry ("non-trivial labeled initializers");
691 if (TREE_VALUE (tail
) != 0)
694 next1
= digest_init (TREE_TYPE (type
),
695 TREE_VALUE (tail
), &tail1
);
696 if (next1
== error_mark_node
)
699 (same_type_ignoring_top_level_qualifiers_p
700 (TREE_TYPE (type
), TREE_TYPE (next1
)),
702 my_friendly_assert (tail1
== 0
703 || TREE_CODE (tail1
) == TREE_LIST
, 319);
704 if (tail
== tail1
&& len
< 0)
706 error ("non-empty initializer for array of empty elements");
707 /* Just ignore what we were supposed to use. */
714 next1
= error_mark_node
;
715 tail
= TREE_CHAIN (tail
);
721 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
723 /* If this type needs constructors run for
724 default-initialization, we can't rely on the backend to do it
725 for us, so build up TARGET_EXPRs. If the type in question is
726 a class, just build one up; if it's an array, recurse. */
728 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
729 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
731 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
732 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
734 else if (! zero_init_p (TREE_TYPE (type
)))
735 next1
= build_zero_init (TREE_TYPE (type
),
736 /*static_storage_p=*/false);
738 /* The default zero-initialization is fine for us; don't
739 add anything to the CONSTRUCTOR. */
742 if (next1
== error_mark_node
)
744 else if (!TREE_CONSTANT (next1
))
746 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
748 members
= tree_cons (size_int (i
), next1
, members
);
751 else if (TREE_CODE (type
) == RECORD_TYPE
)
757 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
759 sorry ("initializer list for object of class with virtual base classes");
760 return error_mark_node
;
763 if (TYPE_BINFO_BASETYPES (type
))
765 sorry ("initializer list for object of class with base classes");
766 return error_mark_node
;
769 if (TYPE_POLYMORPHIC_P (type
))
771 sorry ("initializer list for object using virtual functions");
772 return error_mark_node
;
776 for (field
= TYPE_FIELDS (type
); field
;
777 field
= TREE_CHAIN (field
))
779 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
781 members
= tree_cons (field
, integer_zero_node
, members
);
785 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
790 if (TREE_PURPOSE (tail
)
791 && TREE_PURPOSE (tail
) != field
792 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
793 sorry ("non-trivial labeled initializers");
795 if (TREE_VALUE (tail
) != 0)
799 next1
= digest_init (TREE_TYPE (field
),
800 TREE_VALUE (tail
), &tail1
);
801 my_friendly_assert (tail1
== 0
802 || TREE_CODE (tail1
) == TREE_LIST
, 320);
807 next1
= error_mark_node
;
808 tail
= TREE_CHAIN (tail
);
811 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
813 /* If this type needs constructors run for
814 default-initialization, we can't rely on the backend to do it
815 for us, so build up TARGET_EXPRs. If the type in question is
816 a class, just build one up; if it's an array, recurse. */
818 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
819 next1
= build_functional_cast (TREE_TYPE (field
),
823 next1
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
,
826 TREE_HAS_CONSTRUCTOR (next1
)
827 = TREE_HAS_CONSTRUCTOR (init
);
829 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
831 /* Warn when some struct elements are implicitly initialized. */
833 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
834 warning ("missing initializer for member `%D'", field
);
838 if (TREE_READONLY (field
))
839 error ("uninitialized const member `%D'", field
);
840 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
841 error ("member `%D' with uninitialized const fields",
843 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
844 error ("member `%D' is uninitialized reference", field
);
846 /* Warn when some struct elements are implicitly initialized
849 && (!init
|| TREE_HAS_CONSTRUCTOR (init
)))
850 warning ("missing initializer for member `%D'", field
);
852 if (! zero_init_p (TREE_TYPE (field
)))
853 next1
= build_zero_init (TREE_TYPE (field
),
854 /*static_storage_p=*/false);
856 /* The default zero-initialization is fine for us; don't
857 add anything to the CONSTRUCTOR. */
861 if (next1
== error_mark_node
)
863 else if (!TREE_CONSTANT (next1
))
865 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
867 members
= tree_cons (field
, next1
, members
);
870 else if (TREE_CODE (type
) == UNION_TYPE
871 /* If the initializer was empty, use default zero initialization. */
874 register tree field
= TYPE_FIELDS (type
);
876 /* Find the first named field. ANSI decided in September 1990
877 that only named fields count here. */
878 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
879 field
= TREE_CHAIN (field
);
881 /* If this element specifies a field, initialize via that field. */
882 if (TREE_PURPOSE (tail
) != NULL_TREE
)
886 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
887 /* Handle the case of a call by build_c_cast. */
888 field
= TREE_PURPOSE (tail
), win
= 1;
889 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
890 error ("index value instead of field name in union initializer");
894 for (temp
= TYPE_FIELDS (type
);
896 temp
= TREE_CHAIN (temp
))
897 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
900 field
= temp
, win
= 1;
902 error ("no field `%D' in union being initialized",
903 TREE_PURPOSE (tail
));
906 TREE_VALUE (tail
) = error_mark_node
;
910 error ("union `%T' with no named members cannot be initialized",
912 TREE_VALUE (tail
) = error_mark_node
;
915 if (TREE_VALUE (tail
) != 0)
919 next1
= digest_init (TREE_TYPE (field
),
920 TREE_VALUE (tail
), &tail1
);
921 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
927 next1
= error_mark_node
;
928 tail
= TREE_CHAIN (tail
);
931 if (next1
== error_mark_node
)
933 else if (!TREE_CONSTANT (next1
))
935 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
937 members
= tree_cons (field
, next1
, members
);
940 /* If arguments were specified as a list, just remove the ones we used. */
943 /* If arguments were specified as a constructor,
944 complain unless we used all the elements of the constructor. */
946 pedwarn ("excess elements in aggregate initializer");
949 return error_mark_node
;
951 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (members
));
952 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
953 complete_array_type (type
, result
, /*do_default=*/0);
955 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
956 if (allconstant
) TREE_CONSTANT (result
) = 1;
957 if (allconstant
&& allsimple
) TREE_STATIC (result
) = 1;
961 /* Given a structure or union value DATUM, construct and return
962 the structure or union component which results from narrowing
963 that value to the base specified in BASETYPE. For example, given the
969 class C : A, B { ... };
977 x.A::ii refers to the ii member of the L part of
978 the A part of the C object named by X. In this case,
979 DATUM would be x, and BASETYPE would be A.
981 I used to think that this was nonconformant, that the standard specified
982 that first we look up ii in A, then convert x to an L& and pull out the
983 ii part. But in fact, it does say that we convert x to an A&; A here
984 is known as the "naming class". (jason 2000-12-19)
986 BINFO_P points to a variable initialized either to NULL_TREE or to the
987 binfo for the specific base subobject we want to convert to. */
990 build_scoped_ref (datum
, basetype
, binfo_p
)
997 if (datum
== error_mark_node
)
998 return error_mark_node
;
1002 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1004 if (!binfo
|| binfo
== error_mark_node
)
1006 *binfo_p
= NULL_TREE
;
1008 error_not_base_type (basetype
, TREE_TYPE (datum
));
1009 return error_mark_node
;
1013 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1016 /* Build a reference to an object specified by the C++ `->' operator.
1017 Usually this just involves dereferencing the object, but if the
1018 `->' operator is overloaded, then such overloads must be
1019 performed until an object which does not have the `->' operator
1020 overloaded is found. An error is reported when circular pointer
1021 delegation is detected. */
1024 build_x_arrow (datum
)
1027 tree types_memoized
= NULL_TREE
;
1028 register tree rval
= datum
;
1029 tree type
= TREE_TYPE (rval
);
1030 tree last_rval
= NULL_TREE
;
1032 if (type
== error_mark_node
)
1033 return error_mark_node
;
1035 if (processing_template_decl
)
1036 return build_min_nt (ARROW_EXPR
, rval
);
1038 if (TREE_CODE (rval
) == OFFSET_REF
)
1040 rval
= resolve_offset_ref (datum
);
1041 type
= TREE_TYPE (rval
);
1044 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1046 rval
= convert_from_reference (rval
);
1047 type
= TREE_TYPE (rval
);
1050 if (IS_AGGR_TYPE (type
))
1052 while ((rval
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, rval
,
1053 NULL_TREE
, NULL_TREE
)))
1055 if (rval
== error_mark_node
)
1056 return error_mark_node
;
1058 if (value_member (TREE_TYPE (rval
), types_memoized
))
1060 error ("circular pointer delegation detected");
1061 return error_mark_node
;
1065 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (rval
),
1071 if (last_rval
== NULL_TREE
)
1073 error ("base operand of `->' has non-pointer type `%T'", type
);
1074 return error_mark_node
;
1077 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1078 last_rval
= convert_from_reference (last_rval
);
1081 last_rval
= default_conversion (rval
);
1083 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1084 return build_indirect_ref (last_rval
, NULL
);
1087 error ("result of `operator->()' yields non-pointer result");
1089 error ("base operand of `->' is not a pointer");
1090 return error_mark_node
;
1093 /* Make an expression to refer to the COMPONENT field of
1094 structure or union value DATUM. COMPONENT is an arbitrary
1095 expression. DATUM has not already been checked out to be of
1098 For C++, COMPONENT may be a TREE_LIST. This happens when we must
1099 return an object of member type to a method of the current class,
1100 but there is not yet enough typing information to know which one.
1101 As a special case, if there is only one method by that name,
1102 it is returned. Otherwise we return an expression which other
1103 routines will have to know how to deal with later. */
1106 build_m_component_ref (datum
, component
)
1107 tree datum
, component
;
1115 if (processing_template_decl
)
1116 return build_min_nt (DOTSTAR_EXPR
, datum
, component
);
1118 datum
= decay_conversion (datum
);
1120 if (datum
== error_mark_node
|| component
== error_mark_node
)
1121 return error_mark_node
;
1123 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1125 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component
)))
1127 type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component
)));
1130 else if (TYPE_PTRMEM_P (TREE_TYPE (component
)))
1132 type
= TREE_TYPE (TREE_TYPE (component
));
1133 field_type
= TREE_TYPE (type
);
1135 /* Compute the type of the field, as described in [expr.ref]. */
1136 type_quals
= TYPE_UNQUALIFIED
;
1137 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
1138 /* The standard says that the type of the result should be the
1139 type referred to by the reference. But for now, at least,
1140 we do the conversion from reference type later. */
1144 type_quals
= (cp_type_quals (field_type
)
1145 | cp_type_quals (TREE_TYPE (datum
)));
1147 /* There's no such thing as a mutable pointer-to-member, so
1148 things are not as complex as they are for references to
1149 non-static data members. */
1150 field_type
= cp_build_qualified_type (field_type
, type_quals
);
1155 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1156 component
, TREE_TYPE (component
));
1157 return error_mark_node
;
1160 if (! IS_AGGR_TYPE (objtype
))
1162 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1163 component
, datum
, objtype
);
1164 return error_mark_node
;
1167 binfo
= lookup_base (objtype
, TYPE_METHOD_BASETYPE (type
),
1171 error ("member type `%T::' incompatible with object type `%T'",
1172 TYPE_METHOD_BASETYPE (type
), objtype
);
1173 return error_mark_node
;
1175 else if (binfo
== error_mark_node
)
1176 return error_mark_node
;
1178 component
= build (OFFSET_REF
, field_type
, datum
, component
);
1179 if (TREE_CODE (type
) == OFFSET_TYPE
)
1180 component
= resolve_offset_ref (component
);
1184 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1187 build_functional_cast (exp
, parms
)
1191 /* This is either a call to a constructor,
1192 or a C cast in C++'s `functional' notation. */
1195 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1196 return error_mark_node
;
1198 if (TREE_CODE (exp
) == IDENTIFIER_NODE
)
1200 if (IDENTIFIER_HAS_TYPE_VALUE (exp
))
1201 /* Either an enum or an aggregate type. */
1202 type
= IDENTIFIER_TYPE_VALUE (exp
);
1205 type
= lookup_name (exp
, 1);
1206 if (!type
|| TREE_CODE (type
) != TYPE_DECL
)
1208 error ("`%T' fails to be a typedef or built-in type", exp
);
1209 return error_mark_node
;
1211 type
= TREE_TYPE (type
);
1214 else if (TREE_CODE (exp
) == TYPE_DECL
)
1215 type
= TREE_TYPE (exp
);
1219 if (processing_template_decl
)
1220 return build_min (CAST_EXPR
, type
, parms
);
1222 if (! IS_AGGR_TYPE (type
))
1224 /* this must build a C cast */
1225 if (parms
== NULL_TREE
)
1226 parms
= integer_zero_node
;
1229 if (TREE_CHAIN (parms
) != NULL_TREE
)
1230 pedwarn ("initializer list being treated as compound expression");
1231 parms
= build_compound_expr (parms
);
1234 return build_c_cast (type
, parms
);
1237 /* Prepare to evaluate as a call to a constructor. If this expression
1238 is actually used, for example,
1240 return X (arg1, arg2, ...);
1242 then the slot being initialized will be filled in. */
1244 if (!complete_type_or_else (type
, NULL_TREE
))
1245 return error_mark_node
;
1246 if (abstract_virtuals_error (NULL_TREE
, type
))
1247 return error_mark_node
;
1249 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1250 return build_c_cast (type
, TREE_VALUE (parms
));
1252 /* We need to zero-initialize POD types. Let's do that for everything
1253 that doesn't need a constructor. */
1254 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1255 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1257 exp
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
1258 return get_target_expr (exp
);
1261 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1262 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1264 if (exp
== error_mark_node
)
1265 return error_mark_node
;
1267 return build_cplus_new (type
, exp
);
1271 /* Add new exception specifier SPEC, to the LIST we currently have.
1272 If it's already in LIST then do nothing.
1273 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1274 know what we're doing. */
1277 add_exception_specifier (list
, spec
, complain
)
1284 int diag_type
= -1; /* none */
1286 if (spec
== error_mark_node
)
1289 my_friendly_assert (spec
&& (!list
|| TREE_VALUE (list
)), 19990317);
1291 /* [except.spec] 1, type in an exception specifier shall not be
1292 incomplete, or pointer or ref to incomplete other than pointer
1294 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1295 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1296 core
= TREE_TYPE (core
);
1299 else if (VOID_TYPE_P (core
))
1301 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1303 else if (processing_template_decl
)
1308 /* 15.4/1 says that types in an exception specifier must be complete,
1309 but it seems more reasonable to only require this on definitions
1310 and calls. So just give a pedwarn at this point; we will give an
1311 error later if we hit one of those two cases. */
1312 if (!COMPLETE_TYPE_P (complete_type (core
)))
1313 diag_type
= 2; /* pedwarn */
1320 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1321 if (same_type_p (TREE_VALUE (probe
), spec
))
1324 list
= tree_cons (NULL_TREE
, spec
, list
);
1327 diag_type
= 0; /* error */
1329 if (diag_type
>= 0 && complain
)
1330 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1335 /* Combine the two exceptions specifier lists LIST and ADD, and return
1339 merge_exception_specifiers (list
, add
)
1344 else if (!TREE_VALUE (list
))
1346 else if (!TREE_VALUE (add
))
1350 tree orig_list
= list
;
1352 for (; add
; add
= TREE_CHAIN (add
))
1354 tree spec
= TREE_VALUE (add
);
1357 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1358 if (same_type_p (TREE_VALUE (probe
), spec
))
1362 spec
= build_tree_list (NULL_TREE
, spec
);
1363 TREE_CHAIN (spec
) = list
;
1371 /* Subroutine of build_call. Ensure that each of the types in the
1372 exception specification is complete. Technically, 15.4/1 says that
1373 they need to be complete when we see a declaration of the function,
1374 but we should be able to get away with only requiring this when the
1375 function is defined or called. See also add_exception_specifier. */
1378 require_complete_eh_spec_types (fntype
, decl
)
1382 /* Don't complain about calls to op new. */
1383 if (decl
&& DECL_ARTIFICIAL (decl
))
1385 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1386 raises
= TREE_CHAIN (raises
))
1388 tree type
= TREE_VALUE (raises
);
1389 if (type
&& !COMPLETE_TYPE_P (type
))
1393 ("call to function `%D' which throws incomplete type `%#T'",
1396 error ("call to function which throws incomplete type `%#T'",