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 diagnostic 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
)
240 /* This function applies only to classes. Any other entity can never
242 if (!CLASS_TYPE_P (type
))
245 /* If the type is incomplete, we register it within a hash table,
246 so that we can check again once it is completed. This makes sense
247 only for objects for which we have a declaration or at least a
249 if (!COMPLETE_TYPE_P (type
))
252 struct pending_abstract_type
*pat
;
254 gcc_assert (!decl
|| DECL_P (decl
)
255 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
257 if (!abstract_pending_vars
)
258 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
261 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
262 (hashval_t
)TYPE_UID (type
), INSERT
);
264 pat
= GGC_NEW (struct pending_abstract_type
);
267 pat
->locus
= ((decl
&& DECL_P (decl
))
268 ? DECL_SOURCE_LOCATION (decl
)
277 if (!TYPE_SIZE (type
))
278 /* TYPE is being defined, and during that time
279 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
282 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
288 if (TREE_CODE (decl
) == RESULT_DECL
)
291 if (TREE_CODE (decl
) == VAR_DECL
)
292 cp_error_at ("cannot declare variable `%+D' to be of abstract "
293 "type `%T'", decl
, type
);
294 else if (TREE_CODE (decl
) == PARM_DECL
)
295 cp_error_at ("cannot declare parameter `%+D' to be of abstract "
296 "type `%T'", decl
, type
);
297 else if (TREE_CODE (decl
) == FIELD_DECL
)
298 cp_error_at ("cannot declare field `%+D' to be of abstract "
299 "type `%T'", decl
, type
);
300 else if (TREE_CODE (decl
) == FUNCTION_DECL
301 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
302 cp_error_at ("invalid abstract return type for member function `%+#D'",
304 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
305 cp_error_at ("invalid abstract return type for function `%+#D'",
307 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
308 /* Here we do not have location information, so use error instead
310 error ("invalid abstract type `%T' for `%E'", type
, decl
);
312 cp_error_at ("invalid abstract type for `%+D'", decl
);
315 error ("cannot allocate an object of abstract type `%T'", type
);
317 /* Only go through this once. */
318 if (VEC_length (tree
, pure
))
323 inform ("%J because the following virtual functions are pure "
324 "within `%T':", TYPE_MAIN_DECL (type
), type
);
326 for (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
327 inform ("%J\t%#D", fn
, fn
);
328 /* Now truncate the vector. This leaves it non-null, so we know
329 there are pure virtuals, but empty so we don't list them out
331 VEC_truncate (tree
, pure
, 0);
334 inform ("%J since type `%T' has pure virtual functions",
335 TYPE_MAIN_DECL (type
), type
);
340 /* Print an error message for invalid use of an incomplete type.
341 VALUE is the expression that was used (or 0 if that isn't known)
342 and TYPE is the type that was invalid. DIAG_TYPE indicates the
343 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
347 cxx_incomplete_type_diagnostic (tree value
, tree type
, int diag_type
)
350 void (*p_msg
) (const char *, ...);
351 void (*p_msg_at
) (const char *, ...);
356 p_msg_at
= cp_warning_at
;
358 else if (diag_type
== 2)
361 p_msg_at
= cp_pedwarn_at
;
366 p_msg_at
= cp_error_at
;
369 /* Avoid duplicate error message. */
370 if (TREE_CODE (type
) == ERROR_MARK
)
373 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
374 || TREE_CODE (value
) == PARM_DECL
375 || TREE_CODE (value
) == FIELD_DECL
))
377 (*p_msg_at
) ("`%D' has incomplete type", value
);
381 /* We must print an error message. Be clever about what it says. */
383 switch (TREE_CODE (type
))
389 (*p_msg
) ("invalid use of undefined type `%#T'", type
);
390 if (!TYPE_TEMPLATE_INFO (type
))
391 (*p_msg_at
) ("forward declaration of `%#T'", type
);
393 (*p_msg_at
) ("declaration of `%#T'", type
);
397 (*p_msg
) ("invalid use of `%T'", type
);
401 if (TYPE_DOMAIN (type
))
403 type
= TREE_TYPE (type
);
406 (*p_msg
) ("invalid use of array with unspecified bounds");
411 (*p_msg
) ("invalid use of member (did you forget the `&' ?)");
414 case TEMPLATE_TYPE_PARM
:
415 (*p_msg
) ("invalid use of template type parameter");
419 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
421 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
422 (*p_msg
) ("address of overloaded function with no contextual type information");
423 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
424 (*p_msg
) ("overloaded function with no contextual type information");
426 (*p_msg
) ("insufficient contextual information to determine type");
434 /* Backward-compatibility interface to incomplete_type_diagnostic;
435 required by ../tree.c. */
436 #undef cxx_incomplete_type_error
438 cxx_incomplete_type_error (tree value
, tree type
)
440 cxx_incomplete_type_diagnostic (value
, type
, 0);
444 /* The recursive part of split_nonconstant_init. DEST is an lvalue
445 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
448 split_nonconstant_init_1 (tree dest
, tree init
)
450 tree
*pelt
, elt
, type
= TREE_TYPE (dest
);
451 tree sub
, code
, inner_type
= NULL
;
452 bool array_type_p
= false;
454 pelt
= &CONSTRUCTOR_ELTS (init
);
455 switch (TREE_CODE (type
))
458 inner_type
= TREE_TYPE (type
);
464 case QUAL_UNION_TYPE
:
465 while ((elt
= *pelt
))
467 tree field_index
= TREE_PURPOSE (elt
);
468 tree value
= TREE_VALUE (elt
);
471 inner_type
= TREE_TYPE (field_index
);
473 if (TREE_CODE (value
) == CONSTRUCTOR
)
476 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
477 NULL_TREE
, NULL_TREE
);
479 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
482 split_nonconstant_init_1 (sub
, value
);
484 else if (!initializer_constant_valid_p (value
, inner_type
))
486 *pelt
= TREE_CHAIN (elt
);
489 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
490 NULL_TREE
, NULL_TREE
);
492 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
495 code
= build2 (MODIFY_EXPR
, inner_type
, sub
, value
);
496 code
= build_stmt (EXPR_STMT
, code
);
501 pelt
= &TREE_CHAIN (elt
);
506 if (!initializer_constant_valid_p (init
, type
))
508 CONSTRUCTOR_ELTS (init
) = NULL
;
509 code
= build2 (MODIFY_EXPR
, type
, dest
, init
);
510 code
= build_stmt (EXPR_STMT
, code
);
520 /* A subroutine of store_init_value. Splits non-constant static
521 initializer INIT into a constant part and generates code to
522 perform the non-constant part of the initialization to DEST.
523 Returns the code for the runtime init. */
526 split_nonconstant_init (tree dest
, tree init
)
530 if (TREE_CODE (init
) == CONSTRUCTOR
)
532 code
= push_stmt_list ();
533 split_nonconstant_init_1 (dest
, init
);
534 code
= pop_stmt_list (code
);
535 DECL_INITIAL (dest
) = init
;
536 TREE_READONLY (dest
) = 0;
539 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
544 /* Perform appropriate conversions on the initial value of a variable,
545 store it in the declaration DECL,
546 and print any error messages that are appropriate.
547 If the init is invalid, store an ERROR_MARK.
549 C++: Note that INIT might be a TREE_LIST, which would mean that it is
550 a base class initializer for some aggregate type, hopefully compatible
551 with DECL. If INIT is a single element, and DECL is an aggregate
552 type, we silently convert INIT into a TREE_LIST, allowing a constructor
555 If INIT is a TREE_LIST and there is no constructor, turn INIT
556 into a CONSTRUCTOR and use standard initialization techniques.
557 Perhaps a warning should be generated?
559 Returns code to be executed if initialization could not be performed
560 for static variable. In that case, caller must emit the code. */
563 store_init_value (tree decl
, tree init
)
567 /* If variable's type was invalidly declared, just ignore it. */
569 type
= TREE_TYPE (decl
);
570 if (TREE_CODE (type
) == ERROR_MARK
)
573 if (IS_AGGR_TYPE (type
))
575 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
576 || TREE_CODE (init
) == CONSTRUCTOR
);
578 if (TREE_CODE (init
) == TREE_LIST
)
580 error ("constructor syntax used, but no constructor declared for type `%T'", type
);
581 init
= build_constructor (NULL_TREE
, nreverse (init
));
584 else if (TREE_CODE (init
) == TREE_LIST
585 && TREE_TYPE (init
) != unknown_type_node
)
587 if (TREE_CODE (decl
) == RESULT_DECL
)
588 init
= build_x_compound_expr_from_list (init
,
589 "return value initializer");
590 else if (TREE_CODE (init
) == TREE_LIST
591 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
593 error ("cannot initialize arrays using this syntax");
597 /* We get here with code like `int a (2);' */
598 init
= build_x_compound_expr_from_list (init
, "initializer");
601 /* End of special C++ code. */
603 /* Digest the specified initializer into an expression. */
604 value
= digest_init (type
, init
, (tree
*) 0);
606 /* Store the expression if valid; else report error. */
608 if (TREE_CODE (value
) == ERROR_MARK
)
610 /* Other code expects that initializers for objects of types that need
611 constructing never make it into DECL_INITIAL, and passes 'init' to
612 build_aggr_init without checking DECL_INITIAL. So just return. */
613 else if (TYPE_NEEDS_CONSTRUCTING (type
))
614 return build2 (INIT_EXPR
, type
, decl
, value
);
615 else if (TREE_STATIC (decl
)
616 && (TREE_SIDE_EFFECTS (value
)
617 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
618 return split_nonconstant_init (decl
, value
);
620 /* Store the VALUE in DECL_INITIAL. If we're building a
621 statement-tree we will actually expand the initialization later
622 when we output this function. */
623 DECL_INITIAL (decl
) = value
;
628 /* Digest the parser output INIT as an initializer for type TYPE.
629 Return a C expression of type TYPE to represent the initial value.
631 If TAIL is nonzero, it points to a variable holding a list of elements
632 of which INIT is the first. We update the list stored there by
633 removing from the head all the elements that we use.
634 Normally this is only one; we use more than one element only if
635 TYPE is an aggregate and INIT is not a constructor. */
638 digest_init (tree type
, tree init
, tree
* tail
)
640 enum tree_code code
= TREE_CODE (type
);
641 tree element
= NULL_TREE
;
642 tree old_tail_contents
= NULL_TREE
;
644 /* By default, assume we use one element from a list.
645 We correct this later in the sole case where it is not true. */
649 old_tail_contents
= *tail
;
650 *tail
= TREE_CHAIN (*tail
);
653 if (init
== error_mark_node
|| (TREE_CODE (init
) == TREE_LIST
654 && TREE_VALUE (init
) == error_mark_node
))
655 return error_mark_node
;
657 if (TREE_CODE (init
) == ERROR_MARK
)
658 /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
659 a template function. This gets substituted during instantiation. */
662 /* We must strip the outermost array type when completing the type,
663 because the its bounds might be incomplete at the moment. */
664 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
665 ? TREE_TYPE (type
) : type
, NULL_TREE
))
666 return error_mark_node
;
668 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
669 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
670 init
= TREE_OPERAND (init
, 0);
672 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
673 && CONSTRUCTOR_ELTS (init
) != 0
674 && TREE_CHAIN (CONSTRUCTOR_ELTS (init
)) == 0)
676 element
= TREE_VALUE (CONSTRUCTOR_ELTS (init
));
677 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
678 if (element
&& TREE_CODE (element
) == NON_LVALUE_EXPR
)
679 element
= TREE_OPERAND (element
, 0);
680 if (element
== error_mark_node
)
684 /* Initialization of an array of chars from a string constant
685 optionally enclosed in braces. */
687 if (code
== ARRAY_TYPE
)
691 if (TREE_CODE (init
) == TREE_LIST
)
693 error ("initializing array with parameter list");
694 return error_mark_node
;
697 typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
698 if (char_type_p (typ1
)
699 && ((init
&& TREE_CODE (init
) == STRING_CST
)
700 || (element
&& TREE_CODE (element
) == STRING_CST
)))
702 tree string
= element
? element
: init
;
704 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
706 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
708 error ("char-array initialized from wide string");
709 return error_mark_node
;
711 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string
)))
713 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
715 error ("int-array initialized from non-wide string");
716 return error_mark_node
;
719 TREE_TYPE (string
) = type
;
720 if (TYPE_DOMAIN (type
) != 0
721 && TREE_CONSTANT (TYPE_SIZE (type
)))
723 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
724 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
725 /* In C it is ok to subtract 1 from the length of the string
726 because it's ok to ignore the terminating null char that is
727 counted in the length of the constant, but in C++ this would
729 if (size
< TREE_STRING_LENGTH (string
))
730 pedwarn ("initializer-string for array of chars is too long");
736 /* Handle scalar types, including conversions,
737 and signature pointers and references. */
739 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
740 || code
== ENUMERAL_TYPE
|| code
== REFERENCE_TYPE
741 || code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
742 || TYPE_PTR_TO_MEMBER_P (type
))
744 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
748 error ("initializer for scalar variable requires one element");
749 return error_mark_node
;
753 while (BRACE_ENCLOSED_INITIALIZER_P (init
))
755 pedwarn ("braces around scalar initializer for `%T'", type
);
756 init
= CONSTRUCTOR_ELTS (init
);
757 if (TREE_CHAIN (init
))
758 pedwarn ("ignoring extra initializers for `%T'", type
);
759 init
= TREE_VALUE (init
);
762 return convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
763 "initialization", NULL_TREE
, 0);
766 /* Come here only for records and arrays (and unions with constructors). */
768 if (COMPLETE_TYPE_P (type
) && ! TREE_CONSTANT (TYPE_SIZE (type
)))
770 error ("variable-sized object of type `%T' may not be initialized",
772 return error_mark_node
;
775 if (code
== ARRAY_TYPE
|| code
== VECTOR_TYPE
|| IS_AGGR_TYPE_CODE (code
))
777 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
779 if (TYPE_NON_AGGREGATE_CLASS (type
))
781 error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
783 return error_mark_node
;
785 return process_init_constructor (type
, init
, (tree
*)0);
787 else if (can_convert_arg (type
, TREE_TYPE (init
), init
)
788 || TYPE_NON_AGGREGATE_CLASS (type
))
789 /* These are never initialized from multiple constructor elements. */;
792 *tail
= old_tail_contents
;
793 return process_init_constructor (type
, 0, tail
);
796 if (code
!= ARRAY_TYPE
)
798 int flags
= LOOKUP_NORMAL
;
799 /* Initialization from { } is copy-initialization. */
801 flags
|= LOOKUP_ONLYCONVERTING
;
803 return convert_for_initialization (NULL_TREE
, type
, init
, flags
,
804 "initialization", NULL_TREE
, 0);
808 error ("invalid initializer");
809 return error_mark_node
;
812 /* Process a constructor for a variable of type TYPE.
813 The constructor elements may be specified either with INIT or with ELTS,
814 only one of which should be non-null.
816 If INIT is specified, it is a CONSTRUCTOR node which is specifically
817 and solely for initializing this datum.
819 If ELTS is specified, it is the address of a variable containing
820 a list of expressions. We take as many elements as we need
821 from the head of the list and update the list.
823 In the resulting constructor, TREE_CONSTANT is set if all elts are
824 constant, and TREE_STATIC is set if, in addition, all elts are simple enough
825 constants that the assembler and linker can compute them. */
828 process_init_constructor (tree type
, tree init
, tree
* elts
)
831 /* List of the elements of the result constructor,
840 /* Make TAIL be the list of elements to use for the initialization,
841 no matter how the data was given to us. */
845 if (warn_missing_braces
)
846 warning ("aggregate has a partly bracketed initializer");
850 tail
= CONSTRUCTOR_ELTS (init
);
852 /* Gobble as many elements as needed, and make a constructor or initial value
853 for each element of this aggregate. Chain them together in result.
854 If there are too few, use 0 for each scalar ultimate component. */
856 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
861 if (TREE_CODE (type
) == ARRAY_TYPE
)
863 tree domain
= TYPE_DOMAIN (type
);
865 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
866 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
869 len
= -1; /* Take as many as there are. */
873 /* Vectors are like simple fixed-size arrays. */
874 len
= TYPE_VECTOR_SUBPARTS (type
);
877 for (i
= 0; len
< 0 || i
< len
; i
++)
881 if (TREE_PURPOSE (tail
)
882 && (TREE_CODE (TREE_PURPOSE (tail
)) != INTEGER_CST
883 || compare_tree_int (TREE_PURPOSE (tail
), i
) != 0))
884 sorry ("non-trivial labeled initializers");
886 if (TREE_VALUE (tail
) != 0)
889 next1
= digest_init (TREE_TYPE (type
),
890 TREE_VALUE (tail
), &tail1
);
891 if (next1
== error_mark_node
)
893 gcc_assert (same_type_ignoring_top_level_qualifiers_p
894 (TREE_TYPE (type
), TREE_TYPE (next1
)));
895 gcc_assert (!tail1
|| TREE_CODE (tail1
) == TREE_LIST
);
896 if (tail
== tail1
&& len
< 0)
898 error ("non-empty initializer for array of empty elements");
899 /* Just ignore what we were supposed to use. */
906 next1
= error_mark_node
;
907 tail
= TREE_CHAIN (tail
);
913 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
915 /* If this type needs constructors run for
916 default-initialization, we can't rely on the backend to do it
917 for us, so build up TARGET_EXPRs. If the type in question is
918 a class, just build one up; if it's an array, recurse. */
920 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
921 next1
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
923 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
924 next1
= digest_init (TREE_TYPE (type
), next1
, 0);
926 else if (! zero_init_p (TREE_TYPE (type
)))
927 next1
= build_zero_init (TREE_TYPE (type
),
929 /*static_storage_p=*/false);
931 /* The default zero-initialization is fine for us; don't
932 add anything to the CONSTRUCTOR. */
935 if (next1
== error_mark_node
)
937 else if (!TREE_CONSTANT (next1
))
939 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
941 members
= tree_cons (size_int (i
), next1
, members
);
944 else if (TREE_CODE (type
) == RECORD_TYPE
)
950 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
951 gcc_assert (!TYPE_BINFO (type
)
952 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
953 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
956 for (field
= TYPE_FIELDS (type
); field
;
957 field
= TREE_CHAIN (field
))
959 if (! DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
961 members
= tree_cons (field
, integer_zero_node
, members
);
965 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
970 if (TREE_PURPOSE (tail
)
971 && TREE_PURPOSE (tail
) != field
972 && TREE_PURPOSE (tail
) != DECL_NAME (field
))
973 sorry ("non-trivial labeled initializers");
975 if (TREE_VALUE (tail
) != 0)
979 next1
= digest_init (TREE_TYPE (field
),
980 TREE_VALUE (tail
), &tail1
);
981 gcc_assert (!tail1
|| TREE_CODE (tail1
) == TREE_LIST
);
986 next1
= error_mark_node
;
987 tail
= TREE_CHAIN (tail
);
990 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
992 /* If this type needs constructors run for
993 default-initialization, we can't rely on the backend to do it
994 for us, so build up TARGET_EXPRs. If the type in question is
995 a class, just build one up; if it's an array, recurse. */
997 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
998 next1
= build_functional_cast (TREE_TYPE (field
),
1002 next1
= build_constructor (NULL_TREE
, NULL_TREE
);
1004 TREE_HAS_CONSTRUCTOR (next1
)
1005 = TREE_HAS_CONSTRUCTOR (init
);
1007 next1
= digest_init (TREE_TYPE (field
), next1
, 0);
1009 /* Warn when some struct elements are implicitly initialized. */
1010 if (warn_missing_field_initializers
1011 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
1012 warning ("missing initializer for member `%D'", field
);
1016 if (TREE_READONLY (field
))
1017 error ("uninitialized const member `%D'", field
);
1018 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1019 error ("member `%D' with uninitialized const fields",
1021 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1022 error ("member `%D' is uninitialized reference", field
);
1024 /* Warn when some struct elements are implicitly initialized
1026 if (warn_missing_field_initializers
1027 && (!init
|| BRACE_ENCLOSED_INITIALIZER_P (init
)))
1028 warning ("missing initializer for member `%D'", field
);
1030 if (! zero_init_p (TREE_TYPE (field
)))
1031 next1
= build_zero_init (TREE_TYPE (field
),
1032 /*nelts=*/NULL_TREE
,
1033 /*static_storage_p=*/false);
1035 /* The default zero-initialization is fine for us; don't
1036 add anything to the CONSTRUCTOR. */
1040 if (next1
== error_mark_node
)
1042 else if (!TREE_CONSTANT (next1
))
1044 else if (! initializer_constant_valid_p (next1
, TREE_TYPE (next1
)))
1046 members
= tree_cons (field
, next1
, members
);
1049 else if (TREE_CODE (type
) == UNION_TYPE
1050 /* If the initializer was empty, use default zero initialization. */
1053 tree field
= TYPE_FIELDS (type
);
1055 /* Find the first named field. ANSI decided in September 1990
1056 that only named fields count here. */
1057 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1058 field
= TREE_CHAIN (field
);
1060 /* If this element specifies a field, initialize via that field. */
1061 if (TREE_PURPOSE (tail
) != NULL_TREE
)
1065 if (TREE_CODE (TREE_PURPOSE (tail
)) == FIELD_DECL
)
1066 /* Handle the case of a call by build_c_cast. */
1067 field
= TREE_PURPOSE (tail
), win
= 1;
1068 else if (TREE_CODE (TREE_PURPOSE (tail
)) != IDENTIFIER_NODE
)
1069 error ("index value instead of field name in union initializer");
1073 for (temp
= TYPE_FIELDS (type
);
1075 temp
= TREE_CHAIN (temp
))
1076 if (DECL_NAME (temp
) == TREE_PURPOSE (tail
))
1079 field
= temp
, win
= 1;
1081 error ("no field `%D' in union being initialized",
1082 TREE_PURPOSE (tail
));
1085 TREE_VALUE (tail
) = error_mark_node
;
1087 else if (field
== 0)
1089 error ("union `%T' with no named members cannot be initialized",
1091 TREE_VALUE (tail
) = error_mark_node
;
1094 if (TREE_VALUE (tail
) != 0)
1098 next1
= digest_init (TREE_TYPE (field
),
1099 TREE_VALUE (tail
), &tail1
);
1100 gcc_assert (!tail1
|| TREE_CODE (tail1
) == TREE_LIST
);
1105 next1
= error_mark_node
;
1106 tail
= TREE_CHAIN (tail
);
1109 if (next1
== error_mark_node
)
1111 else if (!TREE_CONSTANT (next1
))
1113 else if (initializer_constant_valid_p (next1
, TREE_TYPE (next1
)) == 0)
1115 members
= tree_cons (field
, next1
, members
);
1118 /* If arguments were specified as a list, just remove the ones we used. */
1121 /* If arguments were specified as a constructor,
1122 complain unless we used all the elements of the constructor. */
1124 pedwarn ("excess elements in aggregate initializer");
1127 return error_mark_node
;
1129 result
= build_constructor (type
, nreverse (members
));
1130 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1131 complete_array_type (type
, result
, /*do_default=*/0);
1133 TREE_HAS_CONSTRUCTOR (result
) = TREE_HAS_CONSTRUCTOR (init
);
1136 TREE_CONSTANT (result
) = 1;
1137 TREE_INVARIANT (result
) = 1;
1139 TREE_STATIC (result
) = 1;
1144 /* Given a structure or union value DATUM, construct and return
1145 the structure or union component which results from narrowing
1146 that value to the base specified in BASETYPE. For example, given the
1149 class L { int ii; };
1150 class A : L { ... };
1151 class B : L { ... };
1152 class C : A, B { ... };
1160 x.A::ii refers to the ii member of the L part of
1161 the A part of the C object named by X. In this case,
1162 DATUM would be x, and BASETYPE would be A.
1164 I used to think that this was nonconformant, that the standard specified
1165 that first we look up ii in A, then convert x to an L& and pull out the
1166 ii part. But in fact, it does say that we convert x to an A&; A here
1167 is known as the "naming class". (jason 2000-12-19)
1169 BINFO_P points to a variable initialized either to NULL_TREE or to the
1170 binfo for the specific base subobject we want to convert to. */
1173 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1177 if (datum
== error_mark_node
)
1178 return error_mark_node
;
1182 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1184 if (!binfo
|| binfo
== error_mark_node
)
1186 *binfo_p
= NULL_TREE
;
1188 error_not_base_type (basetype
, TREE_TYPE (datum
));
1189 return error_mark_node
;
1193 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1196 /* Build a reference to an object specified by the C++ `->' operator.
1197 Usually this just involves dereferencing the object, but if the
1198 `->' operator is overloaded, then such overloads must be
1199 performed until an object which does not have the `->' operator
1200 overloaded is found. An error is reported when circular pointer
1201 delegation is detected. */
1204 build_x_arrow (tree expr
)
1206 tree orig_expr
= expr
;
1207 tree types_memoized
= NULL_TREE
;
1208 tree type
= TREE_TYPE (expr
);
1209 tree last_rval
= NULL_TREE
;
1211 if (type
== error_mark_node
)
1212 return error_mark_node
;
1214 if (processing_template_decl
)
1216 if (type_dependent_expression_p (expr
))
1217 return build_min_nt (ARROW_EXPR
, expr
);
1218 expr
= build_non_dependent_expr (expr
);
1221 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1223 expr
= convert_from_reference (expr
);
1224 type
= TREE_TYPE (expr
);
1227 if (IS_AGGR_TYPE (type
))
1229 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1230 NULL_TREE
, NULL_TREE
,
1231 /*overloaded_p=*/NULL
)))
1233 if (expr
== error_mark_node
)
1234 return error_mark_node
;
1236 if (value_member (TREE_TYPE (expr
), types_memoized
))
1238 error ("circular pointer delegation detected");
1239 return error_mark_node
;
1243 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1249 if (last_rval
== NULL_TREE
)
1251 error ("base operand of `->' has non-pointer type `%T'", type
);
1252 return error_mark_node
;
1255 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1256 last_rval
= convert_from_reference (last_rval
);
1259 last_rval
= decay_conversion (expr
);
1261 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1263 if (processing_template_decl
)
1265 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1266 /* It will be dereferenced. */
1267 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1271 return build_indirect_ref (last_rval
, NULL
);
1275 error ("result of `operator->()' yields non-pointer result");
1277 error ("base operand of `->' is not a pointer");
1278 return error_mark_node
;
1281 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1282 already been checked out to be of aggregate type. */
1285 build_m_component_ref (tree datum
, tree component
)
1293 datum
= decay_conversion (datum
);
1295 if (datum
== error_mark_node
|| component
== error_mark_node
)
1296 return error_mark_node
;
1298 ptrmem_type
= TREE_TYPE (component
);
1299 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1301 error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
1302 component
, ptrmem_type
);
1303 return error_mark_node
;
1306 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1307 if (! IS_AGGR_TYPE (objtype
))
1309 error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
1310 component
, datum
, objtype
);
1311 return error_mark_node
;
1314 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1315 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1317 if (!COMPLETE_TYPE_P (ctype
))
1319 if (!same_type_p (ctype
, objtype
))
1325 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1330 error ("pointer to member type `%T' incompatible with object type `%T'",
1332 return error_mark_node
;
1334 else if (binfo
== error_mark_node
)
1335 return error_mark_node
;
1338 if (TYPE_PTRMEM_P (ptrmem_type
))
1340 /* Compute the type of the field, as described in [expr.ref].
1341 There's no such thing as a mutable pointer-to-member, so
1342 things are not as complex as they are for references to
1343 non-static data members. */
1344 type
= cp_build_qualified_type (type
,
1345 (cp_type_quals (type
)
1346 | cp_type_quals (TREE_TYPE (datum
))));
1348 datum
= build_address (datum
);
1350 /* Convert object to the correct base. */
1352 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1354 /* Build an expression for "object + offset" where offset is the
1355 value stored in the pointer-to-data-member. */
1356 datum
= build2 (PLUS_EXPR
, build_pointer_type (type
),
1357 datum
, build_nop (ptrdiff_type_node
, component
));
1358 return build_indirect_ref (datum
, 0);
1361 return build2 (OFFSET_REF
, type
, datum
, component
);
1364 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1367 build_functional_cast (tree exp
, tree parms
)
1369 /* This is either a call to a constructor,
1370 or a C cast in C++'s `functional' notation. */
1373 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1374 return error_mark_node
;
1376 if (TREE_CODE (exp
) == TYPE_DECL
)
1377 type
= TREE_TYPE (exp
);
1381 if (processing_template_decl
)
1383 tree t
= build_min (CAST_EXPR
, type
, parms
);
1384 /* We don't know if it will or will not have side effects. */
1385 TREE_SIDE_EFFECTS (t
) = 1;
1389 if (! IS_AGGR_TYPE (type
))
1391 /* This must build a C cast. */
1392 if (parms
== NULL_TREE
)
1393 parms
= integer_zero_node
;
1395 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1397 return build_c_cast (type
, parms
);
1400 /* Prepare to evaluate as a call to a constructor. If this expression
1401 is actually used, for example,
1403 return X (arg1, arg2, ...);
1405 then the slot being initialized will be filled in. */
1407 if (!complete_type_or_else (type
, NULL_TREE
))
1408 return error_mark_node
;
1409 if (abstract_virtuals_error (NULL_TREE
, type
))
1410 return error_mark_node
;
1412 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1413 return build_c_cast (type
, TREE_VALUE (parms
));
1415 /* We need to zero-initialize POD types. Let's do that for everything
1416 that doesn't need a constructor. */
1417 if (parms
== NULL_TREE
&& !TYPE_NEEDS_CONSTRUCTING (type
)
1418 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1420 exp
= build_constructor (type
, NULL_TREE
);
1421 return get_target_expr (exp
);
1424 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1425 type
, LOOKUP_NORMAL
);
1427 if (exp
== error_mark_node
)
1428 return error_mark_node
;
1430 return build_cplus_new (type
, exp
);
1434 /* Add new exception specifier SPEC, to the LIST we currently have.
1435 If it's already in LIST then do nothing.
1436 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1437 know what we're doing. */
1440 add_exception_specifier (tree list
, tree spec
, int complain
)
1445 int diag_type
= -1; /* none */
1447 if (spec
== error_mark_node
)
1450 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1452 /* [except.spec] 1, type in an exception specifier shall not be
1453 incomplete, or pointer or ref to incomplete other than pointer
1455 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1456 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1457 core
= TREE_TYPE (core
);
1460 else if (VOID_TYPE_P (core
))
1462 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1464 else if (processing_template_decl
)
1469 /* 15.4/1 says that types in an exception specifier must be complete,
1470 but it seems more reasonable to only require this on definitions
1471 and calls. So just give a pedwarn at this point; we will give an
1472 error later if we hit one of those two cases. */
1473 if (!COMPLETE_TYPE_P (complete_type (core
)))
1474 diag_type
= 2; /* pedwarn */
1481 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1482 if (same_type_p (TREE_VALUE (probe
), spec
))
1485 list
= tree_cons (NULL_TREE
, spec
, list
);
1488 diag_type
= 0; /* error */
1490 if (diag_type
>= 0 && complain
)
1491 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1496 /* Combine the two exceptions specifier lists LIST and ADD, and return
1500 merge_exception_specifiers (tree list
, tree add
)
1504 else if (!TREE_VALUE (list
))
1506 else if (!TREE_VALUE (add
))
1510 tree orig_list
= list
;
1512 for (; add
; add
= TREE_CHAIN (add
))
1514 tree spec
= TREE_VALUE (add
);
1517 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1518 if (same_type_p (TREE_VALUE (probe
), spec
))
1522 spec
= build_tree_list (NULL_TREE
, spec
);
1523 TREE_CHAIN (spec
) = list
;
1531 /* Subroutine of build_call. Ensure that each of the types in the
1532 exception specification is complete. Technically, 15.4/1 says that
1533 they need to be complete when we see a declaration of the function,
1534 but we should be able to get away with only requiring this when the
1535 function is defined or called. See also add_exception_specifier. */
1538 require_complete_eh_spec_types (tree fntype
, tree decl
)
1541 /* Don't complain about calls to op new. */
1542 if (decl
&& DECL_ARTIFICIAL (decl
))
1544 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1545 raises
= TREE_CHAIN (raises
))
1547 tree type
= TREE_VALUE (raises
);
1548 if (type
&& !COMPLETE_TYPE_P (type
))
1552 ("call to function `%D' which throws incomplete type `%#T'",
1555 error ("call to function which throws incomplete type `%#T'",
1562 #include "gt-cp-typeck2.h"