1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2004
5 Free Software Foundation, Inc.
6 Hacked by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
26 /* This file is part of the C++ front end.
27 It contains routines to build C++ expressions given their operands,
28 including computing the types of the result, C and C++ specific error
29 checks, and some optimization. */
33 #include "coretypes.h"
40 #include "diagnostic.h"
42 static tree
process_init_constructor (tree
, tree
, tree
*);
44 /* Print an error message stemming from an attempt to use
45 BASETYPE as a base class for TYPE. */
48 error_not_base_type (tree basetype
, tree type
)
50 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
51 basetype
= DECL_CONTEXT (basetype
);
52 error ("type `%T' is not a base type for type `%T'", basetype
, type
);
53 return error_mark_node
;
57 binfo_or_else (tree base
, tree type
)
59 tree binfo
= lookup_base (type
, base
, ba_ignore
, NULL
);
61 if (binfo
== error_mark_node
)
64 error_not_base_type (base
, type
);
68 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
69 value may not be changed thereafter. Thus, we emit hard errors for these,
70 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
71 example, conversions to references.) */
74 readonly_error (tree arg
, const char* string
, int soft
)
77 void (*fn
) (const char *, ...);
84 if (TREE_CODE (arg
) == COMPONENT_REF
)
86 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
87 fmt
= "%s of data-member `%D' in read-only structure";
89 fmt
= "%s of read-only data-member `%D'";
90 (*fn
) (fmt
, string
, TREE_OPERAND (arg
, 1));
92 else if (TREE_CODE (arg
) == VAR_DECL
)
94 if (DECL_LANG_SPECIFIC (arg
)
95 && DECL_IN_AGGR_P (arg
)
96 && !TREE_STATIC (arg
))
97 fmt
= "%s of constant field `%D'";
99 fmt
= "%s of read-only variable `%D'";
100 (*fn
) (fmt
, string
, arg
);
102 else if (TREE_CODE (arg
) == PARM_DECL
)
103 (*fn
) ("%s of read-only parameter `%D'", string
, arg
);
104 else if (TREE_CODE (arg
) == INDIRECT_REF
105 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
106 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
107 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
108 (*fn
) ("%s of read-only reference `%D'", string
, TREE_OPERAND (arg
, 0));
109 else if (TREE_CODE (arg
) == RESULT_DECL
)
110 (*fn
) ("%s of read-only named return value `%D'", string
, arg
);
111 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
112 (*fn
) ("%s of function `%D'", string
, arg
);
114 (*fn
) ("%s of read-only location", string
);
118 /* Structure that holds information about declarations whose type was
119 incomplete and we could not check whether it was abstract or not. */
121 struct pending_abstract_type
GTY((chain_next ("%h.next")))
123 /* Declaration which we are checking for abstractness. It is either
124 a DECL node, or an IDENTIFIER_NODE if we do not have a full
125 declaration available. */
128 /* Type which will be checked for abstractness. */
131 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
132 because DECLs already carry locus information. */
135 /* Link to the next element in list. */
136 struct pending_abstract_type
* next
;
140 /* Compute the hash value of the node VAL. This function is used by the
141 hash table abstract_pending_vars. */
144 pat_calc_hash (const void* val
)
146 const struct pending_abstract_type
* pat
= val
;
147 return (hashval_t
) TYPE_UID (pat
->type
);
151 /* Compare node VAL1 with the type VAL2. This function is used by the
152 hash table abstract_pending_vars. */
155 pat_compare (const void* val1
, const void* val2
)
157 const struct pending_abstract_type
* pat1
= val1
;
158 tree type2
= (tree
)val2
;
160 return (pat1
->type
== type2
);
163 /* Hash table that maintains pending_abstract_type nodes, for which we still
164 need to check for type abstractness. The key of the table is the type
165 of the declaration. */
166 static GTY ((param_is (struct pending_abstract_type
)))
167 htab_t abstract_pending_vars
= NULL
;
170 /* This function is called after TYPE is completed, and will check if there
171 are pending declarations for which we still need to verify the abstractness
172 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
173 turned out to be incomplete. */
176 complete_type_check_abstract (tree type
)
179 struct pending_abstract_type
*pat
;
180 location_t cur_loc
= input_location
;
182 gcc_assert (COMPLETE_TYPE_P (type
));
184 if (!abstract_pending_vars
)
187 /* Retrieve the list of pending declarations for this type. */
188 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
189 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
192 pat
= (struct pending_abstract_type
*)*slot
;
195 /* If the type is not abstract, do not do anything. */
196 if (CLASSTYPE_PURE_VIRTUALS (type
))
198 struct pending_abstract_type
*prev
= 0, *next
;
200 /* Reverse the list to emit the errors in top-down order. */
201 for (; pat
; pat
= next
)
209 /* Go through the list, and call abstract_virtuals_error for each
210 element: it will issue a diagostic if the type is abstract. */
213 gcc_assert (type
== pat
->type
);
215 /* Tweak input_location so that the diagnostic appears at the correct
216 location. Notice that this is only needed if the decl is an
217 IDENTIFIER_NODE, otherwise cp_error_at. */
218 input_location
= pat
->locus
;
219 abstract_virtuals_error (pat
->decl
, pat
->type
);
224 htab_clear_slot (abstract_pending_vars
, slot
);
226 input_location
= cur_loc
;
230 /* If TYPE has abstract virtual functions, issue an error about trying
231 to create an object of that type. DECL is the object declared, or
232 NULL_TREE if the declaration is unavailable. Returns 1 if an error
233 occurred; zero if all was well. */
236 abstract_virtuals_error (tree decl
, tree type
)
241 /* This function applies only to classes. Any other entity can never
243 if (!CLASS_TYPE_P (type
))
246 /* If the type is incomplete, we register it within a hash table,
247 so that we can check again once it is completed. This makes sense
248 only for objects for which we have a declaration or at least a
250 if (!COMPLETE_TYPE_P (type
))
253 struct pending_abstract_type
*pat
;
255 gcc_assert (!decl
|| DECL_P (decl
)
256 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
258 if (!abstract_pending_vars
)
259 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
262 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
263 (hashval_t
)TYPE_UID (type
), INSERT
);
265 pat
= GGC_NEW (struct pending_abstract_type
);
268 pat
->locus
= ((decl
&& DECL_P (decl
))
269 ? DECL_SOURCE_LOCATION (decl
)
278 if (!CLASSTYPE_PURE_VIRTUALS (type
))
281 if (!TYPE_SIZE (type
))
282 /* TYPE is being defined, and during that time
283 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
286 u
= CLASSTYPE_PURE_VIRTUALS (type
);
289 if (TREE_CODE (decl
) == RESULT_DECL
)
292 if (TREE_CODE (decl
) == VAR_DECL
)
293 cp_error_at ("cannot declare variable `%+D' to be of abstract "
294 "type `%T'", decl
, type
);
295 else if (TREE_CODE (decl
) == PARM_DECL
)
296 cp_error_at ("cannot declare parameter `%+D' to be of abstract "
297 "type `%T'", decl
, type
);
298 else if (TREE_CODE (decl
) == FIELD_DECL
)
299 cp_error_at ("cannot declare field `%+D' to be of abstract "
300 "type `%T'", decl
, type
);
301 else if (TREE_CODE (decl
) == FUNCTION_DECL
302 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
303 cp_error_at ("invalid abstract return type for member function `%+#D'",
305 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
306 cp_error_at ("invalid abstract return type for function `%+#D'",
308 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
309 /* Here we do not have location information, so use error instead
311 error ("invalid abstract type `%T' for `%E'", type
, decl
);
313 cp_error_at ("invalid abstract type for `%+D'", decl
);
316 error ("cannot allocate an object of abstract type `%T'", type
);
318 /* Only go through this once. */
319 if (TREE_PURPOSE (u
) == NULL_TREE
)
321 TREE_PURPOSE (u
) = error_mark_node
;
323 inform ("%J because the following virtual functions are pure "
324 "within `%T':", TYPE_MAIN_DECL (type
), type
);
326 for (tu
= u
; tu
; tu
= TREE_CHAIN (tu
))
327 inform ("%J\t%#D", TREE_VALUE (tu
), TREE_VALUE (tu
));
330 inform ("%J since type `%T' has pure virtual functions",
331 TYPE_MAIN_DECL (type
), type
);
336 /* Print an error message for invalid use of an incomplete type.
337 VALUE is the expression that was used (or 0 if that isn't known)
338 and TYPE is the type that was invalid. DIAG_TYPE indicates the
339 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
343 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
346 void (*p_msg
) (const char *, ...);
347 void (*p_msg_at
) (const char *, ...);
352 p_msg_at
= cp_warning_at
;
354 else if (diag_type
== 2)
357 p_msg_at
= cp_pedwarn_at
;
362 p_msg_at
= cp_error_at
;
365 /* Avoid duplicate error message. */
366 if (TREE_CODE (type
) == ERROR_MARK
)
369 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
370 || TREE_CODE (value
) == PARM_DECL
371 || TREE_CODE (value
) == FIELD_DECL
))
373 (*p_msg_at
) ("`%D' has incomplete type", value
);
377 /* We must print an error message. Be clever about what it says. */
379 switch (TREE_CODE (type
))
385 (*p_msg
) ("invalid use of undefined type `%#T'", type
);
386 if (!TYPE_TEMPLATE_INFO (type
))
387 (*p_msg_at
) ("forward declaration of `%#T'", type
);
389 (*p_msg_at
) ("declaration of `%#T'", type
);
393 (*p_msg
) ("invalid use of `%T'", type
);
397 if (TYPE_DOMAIN (type
))
399 type
= TREE_TYPE (type
);
402 (*p_msg
) ("invalid use of array with unspecified bounds");
407 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
410 case TEMPLATE_TYPE_PARM
:
411 (*p_msg
) ("invalid use of template type parameter");
415 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
417 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
418 (*p_msg
) ("address of overloaded function with no contextual type information");
419 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
420 (*p_msg
) ("overloaded function with no contextual type information");
422 (*p_msg
) ("insufficient contextual information to determine type");
430 /* Backward-compatibility interface to incomplete_type_diagnostic;
431 required by ../tree.c. */
432 #undef cxx_incomplete_type_error
434 cxx_incomplete_type_error (tree value
, tree type
)
436 cxx_incomplete_type_diagnostic (value
, type
, 0);
440 /* The recursive part of split_nonconstant_init. DEST is an lvalue
441 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
444 split_nonconstant_init_1 (tree dest
, tree init
)
446 tree
*pelt
, elt
, type
= TREE_TYPE (dest
);
447 tree sub
, code
, inner_type
= NULL
;
448 bool array_type_p
= false;
450 pelt
= &CONSTRUCTOR_ELTS (init
);
451 switch (TREE_CODE (type
))
454 inner_type
= TREE_TYPE (type
);
460 case QUAL_UNION_TYPE
:
461 while ((elt
= *pelt
))
463 tree field_index
= TREE_PURPOSE (elt
);
464 tree value
= TREE_VALUE (elt
);
467 inner_type
= TREE_TYPE (field_index
);
469 if (TREE_CODE (value
) == CONSTRUCTOR
)
472 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
473 NULL_TREE
, NULL_TREE
);
475 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
478 split_nonconstant_init_1 (sub
, value
);
480 else if (!initializer_constant_valid_p (value
, inner_type
))
482 *pelt
= TREE_CHAIN (elt
);
485 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
486 NULL_TREE
, NULL_TREE
);
488 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
491 code
= build2 (MODIFY_EXPR
, inner_type
, sub
, value
);
492 code
= build_stmt (EXPR_STMT
, code
);
497 pelt
= &TREE_CHAIN (elt
);
502 if (!initializer_constant_valid_p (init
, type
))
504 CONSTRUCTOR_ELTS (init
) = NULL
;
505 code
= build2 (MODIFY_EXPR
, type
, dest
, init
);
506 code
= build_stmt (EXPR_STMT
, code
);
516 /* A subroutine of store_init_value. Splits non-constant static
517 initializer INIT into a constant part and generates code to
518 perform the non-constant part of the initialization to DEST.
519 Returns the code for the runtime init. */
522 split_nonconstant_init (tree dest
, tree init
)
526 if (TREE_CODE (init
) == CONSTRUCTOR
)
528 code
= push_stmt_list ();
529 split_nonconstant_init_1 (dest
, init
);
530 code
= pop_stmt_list (code
);
531 DECL_INITIAL (dest
) = init
;
532 TREE_READONLY (dest
) = 0;
535 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
540 /* Perform appropriate conversions on the initial value of a variable,
541 store it in the declaration DECL,
542 and print any error messages that are appropriate.
543 If the init is invalid, store an ERROR_MARK.
545 C++: Note that INIT might be a TREE_LIST, which would mean that it is
546 a base class initializer for some aggregate type, hopefully compatible
547 with DECL. If INIT is a single element, and DECL is an aggregate
548 type, we silently convert INIT into a TREE_LIST, allowing a constructor
551 If INIT is a TREE_LIST and there is no constructor, turn INIT
552 into a CONSTRUCTOR and use standard initialization techniques.
553 Perhaps a warning should be generated?
555 Returns code to be executed if initialization could not be performed
556 for static variable. In that case, caller must emit the code. */
559 store_init_value (tree decl
, tree init
)
563 /* If variable's type was invalidly declared, just ignore it. */
565 type
= TREE_TYPE (decl
);
566 if (TREE_CODE (type
) == ERROR_MARK
)
569 if (IS_AGGR_TYPE (type
))
571 if (! TYPE_HAS_TRIVIAL_INIT_REF (type
)
572 && TREE_CODE (init
) != CONSTRUCTOR
)
575 if (TREE_CODE (init
) == TREE_LIST
)
577 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
578 init
= build_constructor (NULL_TREE
, nreverse (init
));
581 else if (TREE_CODE (init
) == TREE_LIST
582 && TREE_TYPE (init
) != unknown_type_node
)
584 if (TREE_CODE (decl
) == RESULT_DECL
)
585 init
= build_x_compound_expr_from_list (init
,
586 "return value initializer");
587 else if (TREE_CODE (init
) == TREE_LIST
588 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
590 error ("cannot initialize arrays using this syntax");
594 /* We get here with code like `int a (2);' */
595 init
= build_x_compound_expr_from_list (init
, "initializer");
598 /* End of special C++ code. */
600 /* Digest the specified initializer into an expression. */
601 value
= digest_init (type
, init
, (tree
*) 0);
603 /* Store the expression if valid; else report error. */
605 if (TREE_CODE (value
) == ERROR_MARK
)
607 /* Other code expects that initializers for objects of types that need
608 constructing never make it into DECL_INITIAL, and passes 'init' to
609 build_aggr_init without checking DECL_INITIAL. So just return. */
610 else if (TYPE_NEEDS_CONSTRUCTING (type
))
611 return build2 (INIT_EXPR
, type
, decl
, value
);
612 else if (TREE_STATIC (decl
)
613 && (! TREE_CONSTANT (value
)
614 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
615 return split_nonconstant_init (decl
, value
);
617 /* Store the VALUE in DECL_INITIAL. If we're building a
618 statement-tree we will actually expand the initialization later
619 when we output this function. */
620 DECL_INITIAL (decl
) = value
;
625 /* Digest the parser output INIT as an initializer for type TYPE.
626 Return a C expression of type TYPE to represent the initial value.
628 If TAIL is nonzero, it points to a variable holding a list of elements
629 of which INIT is the first. We update the list stored there by
630 removing from the head all the elements that we use.
631 Normally this is only one; we use more than one element only if
632 TYPE is an aggregate and INIT is not a constructor. */
635 digest_init (tree type
, tree init
, tree
* tail
)
637 enum tree_code code
= TREE_CODE (type
);
638 tree element
= NULL_TREE
;
639 tree old_tail_contents
= NULL_TREE
;
641 /* By default, assume we use one element from a list.
642 We correct this later in the sole case where it is not true. */
646 old_tail_contents
= *tail
;
647 *tail
= TREE_CHAIN (*tail
);
650 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
651 && TREE_VALUE (init
) == error_mark_node
))
652 return error_mark_node
;
654 if (TREE_CODE (init
) == ERROR_MARK
)
655 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
656 a template function. This gets substituted during instantiation. */
659 /* We must strip the outermost array type when completing the type,
660 because the its bounds might be incomplete at the moment. */
661 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
662 ? TREE_TYPE (type
) : type
, NULL_TREE
))
663 return error_mark_node
;
665 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
666 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
667 init
= TREE_OPERAND (init
, 0);
669 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
670 && CONSTRUCTOR_ELTS (init
) != 0
671 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
673 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
674 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
675 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
676 element
= TREE_OPERAND (element
, 0);
677 if (element
== error_mark_node
)
681 /* Initialization of an array of chars from a string constant
682 optionally enclosed in braces. */
684 if (code
== ARRAY_TYPE
)
688 if (TREE_CODE (init
) == TREE_LIST
)
690 error ("initializing array with parameter list");
691 return error_mark_node
;
694 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
695 if (char_type_p (typ1
)
696 && ((init
&& TREE_CODE (init
) == STRING_CST
)
697 || (element
&& TREE_CODE (element
) == STRING_CST
)))
699 tree string
= element
? element
: init
;
701 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
703 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
705 error ("char-array initialized from wide string");
706 return error_mark_node
;
708 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
710 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
712 error ("int-array initialized from non-wide string");
713 return error_mark_node
;
716 TREE_TYPE (string
) = type
;
717 if (TYPE_DOMAIN (type
) != 0
718 && TREE_CONSTANT (TYPE_SIZE (type
)))
720 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
721 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
722 /* In C it is ok to subtract 1 from the length of the string
723 because it's ok to ignore the terminating null char that is
724 counted in the length of the constant, but in C++ this would
726 if (size
< TREE_STRING_LENGTH (string
))
727 pedwarn ("initializer-string for array of chars is too long");
733 /* Handle scalar types, including conversions,
734 and signature pointers and references. */
736 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
737 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
738 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
739 || TYPE_PTR_TO_MEMBER_P (type
))
741 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
745 error ("initializer for scalar variable requires one element");
746 return error_mark_node
;
750 while (BRACE_ENCLOSED_INITIALIZER_P (init
))
752 pedwarn ("braces around scalar initializer for `%T'", type
);
753 init
= CONSTRUCTOR_ELTS (init
);
754 if (TREE_CHAIN (init
))
755 pedwarn ("ignoring extra initializers for `%T'", type
);
756 init
= TREE_VALUE (init
);
759 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
760 "initialization", NULL_TREE
, 0);
763 /* Come here only for records and arrays (and unions with constructors). */
765 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
767 error ("variable-sized object of type `%T' may not be initialized",
769 return error_mark_node
;
772 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
774 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
776 if (TYPE_NON_AGGREGATE_CLASS (type
))
778 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
780 return error_mark_node
;
782 return process_init_constructor (type
, init
, (tree
*)0);
784 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
785 || TYPE_NON_AGGREGATE_CLASS (type
))
786 /* These are never initialized from multiple constructor elements. */;
789 *tail
= old_tail_contents
;
790 return process_init_constructor (type
, 0, tail
);
793 if (code
!= ARRAY_TYPE
)
795 int flags
= LOOKUP_NORMAL
;
796 /* Initialization from { } is copy-initialization. */
798 flags
|= LOOKUP_ONLYCONVERTING
;
800 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
801 "initialization", NULL_TREE
, 0);
805 error ("invalid initializer");
806 return error_mark_node
;
809 /* Process a constructor for a variable of type TYPE.
810 The constructor elements may be specified either with INIT or with ELTS,
811 only one of which should be non-null.
813 If INIT is specified, it is a CONSTRUCTOR node which is specifically
814 and solely for initializing this datum.
816 If ELTS is specified, it is the address of a variable containing
817 a list of expressions. We take as many elements as we need
818 from the head of the list and update the list.
820 In the resulting constructor, TREE_CONSTANT is set if all elts are
821 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
822 constants that the assembler and linker can compute them. */
825 process_init_constructor (tree type
, tree init
, tree
* elts
)
828 /* List of the elements of the result constructor,
837 /* Make TAIL be the list of elements to use for the initialization,
838 no matter how the data was given to us. */
842 if (warn_missing_braces
)
843 warning ("aggregate has a partly bracketed initializer");
847 tail
= CONSTRUCTOR_ELTS (init
);
849 /* Gobble as many elements as needed, and make a constructor or initial value
850 for each element of this aggregate. Chain them together in result.
851 If there are too few, use 0 for each scalar ultimate component. */
853 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
858 if (TREE_CODE (type
) == ARRAY_TYPE
)
860 tree domain
= TYPE_DOMAIN (type
);
862 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
863 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
866 len
= -1; /* Take as many as there are. */
870 /* Vectors are like simple fixed-size arrays. */
871 len
= TYPE_VECTOR_SUBPARTS (type
);
874 for (i
= 0; len
< 0 || i
< len
; i
++)
878 if (TREE_PURPOSE (tail
)
879 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
880 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
881 sorry ("non-trivial labeled initializers");
883 if (TREE_VALUE (tail
) != 0)
886 next1
= digest_init (TREE_TYPE (type
),
887 TREE_VALUE (tail
), &tail1
);
888 if (next1
== error_mark_node
)
890 gcc_assert (same_type_ignoring_top_level_qualifiers_p
891 (TREE_TYPE (type
), TREE_TYPE (next1
)));
892 gcc_assert (!tail1
|| TREE_CODE (tail1
) == TREE_LIST
);
893 if (tail
== tail1
&& len
< 0)
895 error ("non-empty initializer for array of empty elements");
896 /* Just ignore what we were supposed to use. */
903 next1
= error_mark_node
;
904 tail
= TREE_CHAIN (tail
);
910 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
912 /* If this type needs constructors run for
913 default-initialization, we can't rely on the backend to do it
914 for us, so build up TARGET_EXPRs. If the type in question is
915 a class, just build one up; if it's an array, recurse. */
917 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
918 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
920 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
921 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
923 else if (! zero_init_p (TREE_TYPE (type
)))
924 next1
= build_zero_init (TREE_TYPE (type
),
926 /*static_storage_p=*/false);
928 /* The default zero-initialization is fine for us; don't
929 add anything to the CONSTRUCTOR. */
932 if (next1
== error_mark_node
)
934 else if (!TREE_CONSTANT (next1
))
936 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
938 members
= tree_cons (size_int (i
), next1
, members
);
941 else if (TREE_CODE (type
) == RECORD_TYPE
)
947 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
949 sorry ("initializer list for object of class with virtual base classes");
950 return error_mark_node
;
953 if (TYPE_BINFO (type
) && BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
955 sorry ("initializer list for object of class with base classes");
956 return error_mark_node
;
959 if (TYPE_POLYMORPHIC_P (type
))
961 sorry ("initializer list for object using virtual functions");
962 return error_mark_node
;
966 for (field
= TYPE_FIELDS (type
); field
;
967 field
= TREE_CHAIN (field
))
969 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
971 members
= tree_cons (field
, integer_zero_node
, members
);
975 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
980 if (TREE_PURPOSE (tail
)
981 && TREE_PURPOSE (tail
) != field
982 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
983 sorry ("non-trivial labeled initializers");
985 if (TREE_VALUE (tail
) != 0)
989 next1
= digest_init (TREE_TYPE (field
),
990 TREE_VALUE (tail
), &tail1
);
991 gcc_assert (!tail1
|| TREE_CODE (tail1
) == TREE_LIST
);
996 next1
= error_mark_node
;
997 tail
= TREE_CHAIN (tail
);
1000 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1002 /* If this type needs constructors run for
1003 default-initialization, we can't rely on the backend to do it
1004 for us, so build up TARGET_EXPRs. If the type in question is
1005 a class, just build one up; if it's an array, recurse. */
1007 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
1008 next1
= build_functional_cast (TREE_TYPE (field
),
1012 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
1014 TREE_HAS_CONSTRUCTOR (next1
)
1015 = TREE_HAS_CONSTRUCTOR (init
);
1017 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
1019 /* Warn when some struct elements are implicitly initialized. */
1020 if (warn_missing_field_initializers
1021 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
1022 warning ("missing initializer for member `%D'", field
);
1026 if (TREE_READONLY (field
))
1027 error ("uninitialized const member `%D'", field
);
1028 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1029 error ("member `%D' with uninitialized const fields",
1031 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1032 error ("member `%D' is uninitialized reference", field
);
1034 /* Warn when some struct elements are implicitly initialized
1036 if (warn_missing_field_initializers
1037 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
1038 warning ("missing initializer for member `%D'", field
);
1040 if (! zero_init_p (TREE_TYPE (field
)))
1041 next1
= build_zero_init (TREE_TYPE (field
),
1042 /*nelts=*/NULL_TREE
,
1043 /*static_storage_p=*/false);
1045 /* The default zero-initialization is fine for us; don't
1046 add anything to the CONSTRUCTOR. */
1050 if (next1
== error_mark_node
)
1052 else if (!TREE_CONSTANT (next1
))
1054 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
1056 members
= tree_cons (field
, next1
, members
);
1059 else if (TREE_CODE (type
) == UNION_TYPE
1060 /* If the initializer was empty, use default zero initialization. */
1063 tree field
= TYPE_FIELDS (type
);
1065 /* Find the first named field. ANSI decided in September 1990
1066 that only named fields count here. */
1067 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1068 field
= TREE_CHAIN (field
);
1070 /* If this element specifies a field, initialize via that field. */
1071 if (TREE_PURPOSE (tail
) != NULL_TREE
)
1075 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
1076 /* Handle the case of a call by build_c_cast. */
1077 field
= TREE_PURPOSE (tail
), win
= 1;
1078 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
1079 error ("index value instead of field name in union initializer");
1083 for (temp
= TYPE_FIELDS (type
);
1085 temp
= TREE_CHAIN (temp
))
1086 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
1089 field
= temp
, win
= 1;
1091 error ("no field `%D' in union being initialized",
1092 TREE_PURPOSE (tail
));
1095 TREE_VALUE (tail
) = error_mark_node
;
1097 else if (field
== 0)
1099 error ("union `%T' with no named members cannot be initialized",
1101 TREE_VALUE (tail
) = error_mark_node
;
1104 if (TREE_VALUE (tail
) != 0)
1108 next1
= digest_init (TREE_TYPE (field
),
1109 TREE_VALUE (tail
), &tail1
);
1110 if (tail1
!= 0 && TREE_CODE (tail1
) != TREE_LIST
)
1116 next1
= error_mark_node
;
1117 tail
= TREE_CHAIN (tail
);
1120 if (next1
== error_mark_node
)
1122 else if (!TREE_CONSTANT (next1
))
1124 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
1126 members
= tree_cons (field
, next1
, members
);
1129 /* If arguments were specified as a list, just remove the ones we used. */
1132 /* If arguments were specified as a constructor,
1133 complain unless we used all the elements of the constructor. */
1135 pedwarn ("excess elements in aggregate initializer");
1138 return error_mark_node
;
1140 result
= build_constructor (type
, nreverse (members
));
1141 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1142 complete_array_type (type
, result
, /*do_default=*/0);
1144 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
1147 TREE_CONSTANT (result
) = 1;
1148 TREE_INVARIANT (result
) = 1;
1150 TREE_STATIC (result
) = 1;
1155 /* Given a structure or union value DATUM, construct and return
1156 the structure or union component which results from narrowing
1157 that value to the base specified in BASETYPE. For example, given the
1160 class L { int ii; };
1161 class A : L { ... };
1162 class B : L { ... };
1163 class C : A, B { ... };
1171 x.A::ii refers to the ii member of the L part of
1172 the A part of the C object named by X. In this case,
1173 DATUM would be x, and BASETYPE would be A.
1175 I used to think that this was nonconformant, that the standard specified
1176 that first we look up ii in A, then convert x to an L& and pull out the
1177 ii part. But in fact, it does say that we convert x to an A&; A here
1178 is known as the "naming class". (jason 2000-12-19)
1180 BINFO_P points to a variable initialized either to NULL_TREE or to the
1181 binfo for the specific base subobject we want to convert to. */
1184 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1188 if (datum
== error_mark_node
)
1189 return error_mark_node
;
1193 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1195 if (!binfo
|| binfo
== error_mark_node
)
1197 *binfo_p
= NULL_TREE
;
1199 error_not_base_type (basetype
, TREE_TYPE (datum
));
1200 return error_mark_node
;
1204 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1207 /* Build a reference to an object specified by the C++ `->' operator.
1208 Usually this just involves dereferencing the object, but if the
1209 `->' operator is overloaded, then such overloads must be
1210 performed until an object which does not have the `->' operator
1211 overloaded is found. An error is reported when circular pointer
1212 delegation is detected. */
1215 build_x_arrow (tree expr
)
1217 tree orig_expr
= expr
;
1218 tree types_memoized
= NULL_TREE
;
1219 tree type
= TREE_TYPE (expr
);
1220 tree last_rval
= NULL_TREE
;
1222 if (type
== error_mark_node
)
1223 return error_mark_node
;
1225 if (processing_template_decl
)
1227 if (type_dependent_expression_p (expr
))
1228 return build_min_nt (ARROW_EXPR
, expr
);
1229 expr
= build_non_dependent_expr (expr
);
1232 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1234 expr
= convert_from_reference (expr
);
1235 type
= TREE_TYPE (expr
);
1238 if (IS_AGGR_TYPE (type
))
1240 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1241 NULL_TREE
, NULL_TREE
,
1242 /*overloaded_p=*/NULL
)))
1244 if (expr
== error_mark_node
)
1245 return error_mark_node
;
1247 if (value_member (TREE_TYPE (expr
), types_memoized
))
1249 error ("circular pointer delegation detected");
1250 return error_mark_node
;
1254 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1260 if (last_rval
== NULL_TREE
)
1262 error ("base operand of `->' has non-pointer type `%T'", type
);
1263 return error_mark_node
;
1266 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1267 last_rval
= convert_from_reference (last_rval
);
1270 last_rval
= decay_conversion (expr
);
1272 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1274 if (processing_template_decl
)
1276 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1277 /* It will be dereferenced. */
1278 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1282 return build_indirect_ref (last_rval
, NULL
);
1286 error ("result of `operator->()' yields non-pointer result");
1288 error ("base operand of `->' is not a pointer");
1289 return error_mark_node
;
1292 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1293 already been checked out to be of aggregate type. */
1296 build_m_component_ref (tree datum
, tree component
)
1304 datum
= decay_conversion (datum
);
1306 if (datum
== error_mark_node
|| component
== error_mark_node
)
1307 return error_mark_node
;
1309 ptrmem_type
= TREE_TYPE (component
);
1310 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1312 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1313 component
, ptrmem_type
);
1314 return error_mark_node
;
1317 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1318 if (! IS_AGGR_TYPE (objtype
))
1320 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1321 component
, datum
, objtype
);
1322 return error_mark_node
;
1325 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1326 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1328 if (!COMPLETE_TYPE_P (ctype
))
1330 if (!same_type_p (ctype
, objtype
))
1336 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1341 error ("pointer to member type `%T' incompatible with object type `%T'",
1343 return error_mark_node
;
1345 else if (binfo
== error_mark_node
)
1346 return error_mark_node
;
1349 if (TYPE_PTRMEM_P (ptrmem_type
))
1351 /* Compute the type of the field, as described in [expr.ref].
1352 There's no such thing as a mutable pointer-to-member, so
1353 things are not as complex as they are for references to
1354 non-static data members. */
1355 type
= cp_build_qualified_type (type
,
1356 (cp_type_quals (type
)
1357 | cp_type_quals (TREE_TYPE (datum
))));
1359 datum
= build_address (datum
);
1361 /* Convert object to the correct base. */
1363 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1365 /* Build an expression for "object + offset" where offset is the
1366 value stored in the pointer-to-data-member. */
1367 datum
= build2 (PLUS_EXPR
, build_pointer_type (type
),
1368 datum
, build_nop (ptrdiff_type_node
, component
));
1369 return build_indirect_ref (datum
, 0);
1372 return build2 (OFFSET_REF
, type
, datum
, component
);
1375 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1378 build_functional_cast (tree exp
, tree parms
)
1380 /* This is either a call to a constructor,
1381 or a C cast in C++'s `functional' notation. */
1384 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1385 return error_mark_node
;
1387 if (TREE_CODE (exp
) == TYPE_DECL
)
1388 type
= TREE_TYPE (exp
);
1392 if (processing_template_decl
)
1394 tree t
= build_min (CAST_EXPR
, type
, parms
);
1395 /* We don't know if it will or will not have side effects. */
1396 TREE_SIDE_EFFECTS (t
) = 1;
1400 if (! IS_AGGR_TYPE (type
))
1402 /* This must build a C cast. */
1403 if (parms
== NULL_TREE
)
1404 parms
= integer_zero_node
;
1406 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1408 return build_c_cast (type
, parms
);
1411 /* Prepare to evaluate as a call to a constructor. If this expression
1412 is actually used, for example,
1414 return X (arg1, arg2, ...);
1416 then the slot being initialized will be filled in. */
1418 if (!complete_type_or_else (type
, NULL_TREE
))
1419 return error_mark_node
;
1420 if (abstract_virtuals_error (NULL_TREE
, type
))
1421 return error_mark_node
;
1423 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1424 return build_c_cast (type
, TREE_VALUE (parms
));
1426 /* We need to zero-initialize POD types. Let's do that for everything
1427 that doesn't need a constructor. */
1428 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1429 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1431 exp
= build_constructor (type
, NULL_TREE
);
1432 return get_target_expr (exp
);
1435 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1436 type
, LOOKUP_NORMAL
);
1438 if (exp
== error_mark_node
)
1439 return error_mark_node
;
1441 return build_cplus_new (type
, exp
);
1445 /* Add new exception specifier SPEC, to the LIST we currently have.
1446 If it's already in LIST then do nothing.
1447 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1448 know what we're doing. */
1451 add_exception_specifier (tree list
, tree spec
, int complain
)
1456 int diag_type
= -1; /* none */
1458 if (spec
== error_mark_node
)
1461 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1463 /* [except.spec] 1, type in an exception specifier shall not be
1464 incomplete, or pointer or ref to incomplete other than pointer
1466 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1467 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1468 core
= TREE_TYPE (core
);
1471 else if (VOID_TYPE_P (core
))
1473 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1475 else if (processing_template_decl
)
1480 /* 15.4/1 says that types in an exception specifier must be complete,
1481 but it seems more reasonable to only require this on definitions
1482 and calls. So just give a pedwarn at this point; we will give an
1483 error later if we hit one of those two cases. */
1484 if (!COMPLETE_TYPE_P (complete_type (core
)))
1485 diag_type
= 2; /* pedwarn */
1492 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1493 if (same_type_p (TREE_VALUE (probe
), spec
))
1496 list
= tree_cons (NULL_TREE
, spec
, list
);
1499 diag_type
= 0; /* error */
1501 if (diag_type
>= 0 && complain
)
1502 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1507 /* Combine the two exceptions specifier lists LIST and ADD, and return
1511 merge_exception_specifiers (tree list
, tree add
)
1515 else if (!TREE_VALUE (list
))
1517 else if (!TREE_VALUE (add
))
1521 tree orig_list
= list
;
1523 for (; add
; add
= TREE_CHAIN (add
))
1525 tree spec
= TREE_VALUE (add
);
1528 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1529 if (same_type_p (TREE_VALUE (probe
), spec
))
1533 spec
= build_tree_list (NULL_TREE
, spec
);
1534 TREE_CHAIN (spec
) = list
;
1542 /* Subroutine of build_call. Ensure that each of the types in the
1543 exception specification is complete. Technically, 15.4/1 says that
1544 they need to be complete when we see a declaration of the function,
1545 but we should be able to get away with only requiring this when the
1546 function is defined or called. See also add_exception_specifier. */
1549 require_complete_eh_spec_types (tree fntype
, tree decl
)
1552 /* Don't complain about calls to op new. */
1553 if (decl
&& DECL_ARTIFICIAL (decl
))
1555 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1556 raises
= TREE_CHAIN (raises
))
1558 tree type
= TREE_VALUE (raises
);
1559 if (type
&& !COMPLETE_TYPE_P (type
))
1563 ("call to function `%D' which throws incomplete type `%#T'",
1566 error ("call to function which throws incomplete type `%#T'",
1573 #include "gt-cp-typeck2.h"