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, 2005, 2006, 2007, 2008
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 3, 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 COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
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. */
32 #include "coretypes.h"
39 #include "diagnostic.h"
42 process_init_constructor (tree type
, tree init
);
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
49 error_not_base_type (tree basetype
, tree type
)
51 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
52 basetype
= DECL_CONTEXT (basetype
);
53 error ("type %qT is not a base type for type %qT", basetype
, type
);
54 return error_mark_node
;
58 binfo_or_else (tree base
, tree type
)
60 tree binfo
= lookup_base (type
, base
, ba_unique
, NULL
);
62 if (binfo
== error_mark_node
)
65 error_not_base_type (base
, type
);
69 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
70 value may not be changed thereafter. */
73 readonly_error (tree arg
, const char* string
)
77 if (TREE_CODE (arg
) == COMPONENT_REF
)
79 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
80 fmt
= "%s of data-member %qD in read-only structure";
82 fmt
= "%s of read-only data-member %qD";
83 error (fmt
, string
, TREE_OPERAND (arg
, 1));
85 else if (TREE_CODE (arg
) == VAR_DECL
)
87 if (DECL_LANG_SPECIFIC (arg
)
88 && DECL_IN_AGGR_P (arg
)
89 && !TREE_STATIC (arg
))
90 fmt
= "%s of constant field %qD";
92 fmt
= "%s of read-only variable %qD";
93 error (fmt
, string
, arg
);
95 else if (TREE_CODE (arg
) == PARM_DECL
)
96 error ("%s of read-only parameter %qD", string
, arg
);
97 else if (TREE_CODE (arg
) == INDIRECT_REF
98 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
99 && (TREE_CODE (TREE_OPERAND (arg
, 0)) == VAR_DECL
100 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
101 error ("%s of read-only reference %qD", string
, TREE_OPERAND (arg
, 0));
102 else if (TREE_CODE (arg
) == RESULT_DECL
)
103 error ("%s of read-only named return value %qD", string
, arg
);
104 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
105 error ("%s of function %qD", string
, arg
);
107 error ("%s of read-only location %qE", string
, arg
);
111 /* Structure that holds information about declarations whose type was
112 incomplete and we could not check whether it was abstract or not. */
114 struct pending_abstract_type
GTY((chain_next ("%h.next")))
116 /* Declaration which we are checking for abstractness. It is either
117 a DECL node, or an IDENTIFIER_NODE if we do not have a full
118 declaration available. */
121 /* Type which will be checked for abstractness. */
124 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
125 because DECLs already carry locus information. */
128 /* Link to the next element in list. */
129 struct pending_abstract_type
* next
;
133 /* Compute the hash value of the node VAL. This function is used by the
134 hash table abstract_pending_vars. */
137 pat_calc_hash (const void* val
)
139 const struct pending_abstract_type
*pat
=
140 (const struct pending_abstract_type
*) val
;
141 return (hashval_t
) TYPE_UID (pat
->type
);
145 /* Compare node VAL1 with the type VAL2. This function is used by the
146 hash table abstract_pending_vars. */
149 pat_compare (const void* val1
, const void* val2
)
151 const struct pending_abstract_type
*const pat1
=
152 (const struct pending_abstract_type
*) val1
;
153 const_tree
const type2
= (const_tree
)val2
;
155 return (pat1
->type
== type2
);
158 /* Hash table that maintains pending_abstract_type nodes, for which we still
159 need to check for type abstractness. The key of the table is the type
160 of the declaration. */
161 static GTY ((param_is (struct pending_abstract_type
)))
162 htab_t abstract_pending_vars
= NULL
;
165 /* This function is called after TYPE is completed, and will check if there
166 are pending declarations for which we still need to verify the abstractness
167 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
168 turned out to be incomplete. */
171 complete_type_check_abstract (tree type
)
174 struct pending_abstract_type
*pat
;
175 location_t cur_loc
= input_location
;
177 gcc_assert (COMPLETE_TYPE_P (type
));
179 if (!abstract_pending_vars
)
182 /* Retrieve the list of pending declarations for this type. */
183 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
184 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
187 pat
= (struct pending_abstract_type
*)*slot
;
190 /* If the type is not abstract, do not do anything. */
191 if (CLASSTYPE_PURE_VIRTUALS (type
))
193 struct pending_abstract_type
*prev
= 0, *next
;
195 /* Reverse the list to emit the errors in top-down order. */
196 for (; pat
; pat
= next
)
204 /* Go through the list, and call abstract_virtuals_error for each
205 element: it will issue a diagnostic if the type is abstract. */
208 gcc_assert (type
== pat
->type
);
210 /* Tweak input_location so that the diagnostic appears at the correct
211 location. Notice that this is only needed if the decl is an
213 input_location
= pat
->locus
;
214 abstract_virtuals_error (pat
->decl
, pat
->type
);
219 htab_clear_slot (abstract_pending_vars
, slot
);
221 input_location
= cur_loc
;
225 /* If TYPE has abstract virtual functions, issue an error about trying
226 to create an object of that type. DECL is the object declared, or
227 NULL_TREE if the declaration is unavailable. Returns 1 if an error
228 occurred; zero if all was well. */
231 abstract_virtuals_error (tree decl
, tree type
)
235 /* This function applies only to classes. Any other entity can never
237 if (!CLASS_TYPE_P (type
))
240 /* If the type is incomplete, we register it within a hash table,
241 so that we can check again once it is completed. This makes sense
242 only for objects for which we have a declaration or at least a
244 if (!COMPLETE_TYPE_P (type
))
247 struct pending_abstract_type
*pat
;
249 gcc_assert (!decl
|| DECL_P (decl
)
250 || TREE_CODE (decl
) == IDENTIFIER_NODE
);
252 if (!abstract_pending_vars
)
253 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
256 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
257 (hashval_t
)TYPE_UID (type
), INSERT
);
259 pat
= GGC_NEW (struct pending_abstract_type
);
262 pat
->locus
= ((decl
&& DECL_P (decl
))
263 ? DECL_SOURCE_LOCATION (decl
)
266 pat
->next
= (struct pending_abstract_type
*) *slot
;
272 if (!TYPE_SIZE (type
))
273 /* TYPE is being defined, and during that time
274 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
277 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
283 if (TREE_CODE (decl
) == RESULT_DECL
)
286 if (TREE_CODE (decl
) == VAR_DECL
)
287 error ("cannot declare variable %q+D to be of abstract "
288 "type %qT", decl
, type
);
289 else if (TREE_CODE (decl
) == PARM_DECL
)
290 error ("cannot declare parameter %q+D to be of abstract type %qT",
292 else if (TREE_CODE (decl
) == FIELD_DECL
)
293 error ("cannot declare field %q+D to be of abstract type %qT",
295 else if (TREE_CODE (decl
) == FUNCTION_DECL
296 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
297 error ("invalid abstract return type for member function %q+#D", decl
);
298 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
299 error ("invalid abstract return type for function %q+#D", decl
);
300 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
301 /* Here we do not have location information. */
302 error ("invalid abstract type %qT for %qE", type
, decl
);
304 error ("invalid abstract type for %q+D", decl
);
307 error ("cannot allocate an object of abstract type %qT", type
);
309 /* Only go through this once. */
310 if (VEC_length (tree
, pure
))
315 inform ("%J because the following virtual functions are pure "
316 "within %qT:", TYPE_MAIN_DECL (type
), type
);
318 for (ix
= 0; VEC_iterate (tree
, pure
, ix
, fn
); ix
++)
319 inform ("\t%+#D", fn
);
320 /* Now truncate the vector. This leaves it non-null, so we know
321 there are pure virtuals, but empty so we don't list them out
323 VEC_truncate (tree
, pure
, 0);
326 inform ("%J since type %qT has pure virtual functions",
327 TYPE_MAIN_DECL (type
), type
);
332 /* Print an error message for invalid use of an incomplete type.
333 VALUE is the expression that was used (or 0 if that isn't known)
334 and TYPE is the type that was invalid. DIAG_TYPE indicates the
335 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
339 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
, int diag_type
)
342 void (*p_msg
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
346 else if (diag_type
== 2)
351 /* Avoid duplicate error message. */
352 if (TREE_CODE (type
) == ERROR_MARK
)
355 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
356 || TREE_CODE (value
) == PARM_DECL
357 || TREE_CODE (value
) == FIELD_DECL
))
359 p_msg ("%q+D has incomplete type", value
);
363 /* We must print an error message. Be clever about what it says. */
365 switch (TREE_CODE (type
))
371 p_msg ("invalid use of incomplete type %q#T", type
);
372 if (!TYPE_TEMPLATE_INFO (type
))
373 p_msg ("forward declaration of %q+#T", type
);
375 p_msg ("declaration of %q+#T", type
);
379 p_msg ("invalid use of %qT", type
);
383 if (TYPE_DOMAIN (type
))
385 type
= TREE_TYPE (type
);
388 p_msg ("invalid use of array with unspecified bounds");
393 p_msg ("invalid use of member (did you forget the %<&%> ?)");
396 case TEMPLATE_TYPE_PARM
:
397 p_msg ("invalid use of template type parameter %qT", type
);
400 case BOUND_TEMPLATE_TEMPLATE_PARM
:
401 p_msg ("invalid use of template template parameter %qT",
406 p_msg ("invalid use of dependent type %qT", type
);
410 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
412 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
413 p_msg ("address of overloaded function with no contextual "
415 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
416 p_msg ("overloaded function with no contextual type information");
418 p_msg ("insufficient contextual information to determine type");
426 /* Backward-compatibility interface to incomplete_type_diagnostic;
427 required by ../tree.c. */
428 #undef cxx_incomplete_type_error
430 cxx_incomplete_type_error (const_tree value
, const_tree type
)
432 cxx_incomplete_type_diagnostic (value
, type
, 0);
436 /* The recursive part of split_nonconstant_init. DEST is an lvalue
437 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
440 split_nonconstant_init_1 (tree dest
, tree init
)
442 unsigned HOST_WIDE_INT idx
;
443 tree field_index
, value
;
444 tree type
= TREE_TYPE (dest
);
445 tree inner_type
= NULL
;
446 bool array_type_p
= false;
448 switch (TREE_CODE (type
))
451 inner_type
= TREE_TYPE (type
);
457 case QUAL_UNION_TYPE
:
458 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
461 /* The current implementation of this algorithm assumes that
462 the field was set for all the elements. This is usually done
463 by process_init_constructor. */
464 gcc_assert (field_index
);
467 inner_type
= TREE_TYPE (field_index
);
469 if (TREE_CODE (value
) == CONSTRUCTOR
)
474 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
475 NULL_TREE
, NULL_TREE
);
477 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
480 split_nonconstant_init_1 (sub
, value
);
482 else if (!initializer_constant_valid_p (value
, inner_type
))
487 /* FIXME: Ordered removal is O(1) so the whole function is
488 worst-case quadratic. This could be fixed using an aside
489 bitmap to record which elements must be removed and remove
490 them all at the same time. Or by merging
491 split_non_constant_init into process_init_constructor_array,
492 that is separating constants from non-constants while building
494 VEC_ordered_remove (constructor_elt
, CONSTRUCTOR_ELTS (init
),
499 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
500 NULL_TREE
, NULL_TREE
);
502 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
505 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
506 code
= build_stmt (EXPR_STMT
, code
);
514 if (!initializer_constant_valid_p (init
, type
))
517 tree cons
= copy_node (init
);
518 CONSTRUCTOR_ELTS (init
) = NULL
;
519 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
520 code
= build_stmt (EXPR_STMT
, code
);
529 /* The rest of the initializer is now a constant. */
530 TREE_CONSTANT (init
) = 1;
533 /* A subroutine of store_init_value. Splits non-constant static
534 initializer INIT into a constant part and generates code to
535 perform the non-constant part of the initialization to DEST.
536 Returns the code for the runtime init. */
539 split_nonconstant_init (tree dest
, tree init
)
543 if (TREE_CODE (init
) == CONSTRUCTOR
)
545 code
= push_stmt_list ();
546 split_nonconstant_init_1 (dest
, init
);
547 code
= pop_stmt_list (code
);
548 DECL_INITIAL (dest
) = init
;
549 TREE_READONLY (dest
) = 0;
552 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
557 /* Perform appropriate conversions on the initial value of a variable,
558 store it in the declaration DECL,
559 and print any error messages that are appropriate.
560 If the init is invalid, store an ERROR_MARK.
562 C++: Note that INIT might be a TREE_LIST, which would mean that it is
563 a base class initializer for some aggregate type, hopefully compatible
564 with DECL. If INIT is a single element, and DECL is an aggregate
565 type, we silently convert INIT into a TREE_LIST, allowing a constructor
568 If INIT is a TREE_LIST and there is no constructor, turn INIT
569 into a CONSTRUCTOR and use standard initialization techniques.
570 Perhaps a warning should be generated?
572 Returns code to be executed if initialization could not be performed
573 for static variable. In that case, caller must emit the code. */
576 store_init_value (tree decl
, tree init
)
580 /* If variable's type was invalidly declared, just ignore it. */
582 type
= TREE_TYPE (decl
);
583 if (TREE_CODE (type
) == ERROR_MARK
)
586 if (MAYBE_CLASS_TYPE_P (type
))
588 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type
)
589 || TREE_CODE (init
) == CONSTRUCTOR
);
591 if (TREE_CODE (init
) == TREE_LIST
)
593 error ("constructor syntax used, but no constructor declared "
594 "for type %qT", type
);
595 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
598 else if (TREE_CODE (init
) == TREE_LIST
599 && TREE_TYPE (init
) != unknown_type_node
)
601 if (TREE_CODE (decl
) == RESULT_DECL
)
602 init
= build_x_compound_expr_from_list (init
,
603 "return value initializer");
604 else if (TREE_CODE (init
) == TREE_LIST
605 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
607 error ("cannot initialize arrays using this syntax");
611 /* We get here with code like `int a (2);' */
612 init
= build_x_compound_expr_from_list (init
, "initializer");
615 /* End of special C++ code. */
617 /* Digest the specified initializer into an expression. */
618 value
= digest_init (type
, init
);
619 /* If the initializer is not a constant, fill in DECL_INITIAL with
620 the bits that are constant, and then return an expression that
621 will perform the dynamic initialization. */
622 if (value
!= error_mark_node
623 && (TREE_SIDE_EFFECTS (value
)
624 || ! initializer_constant_valid_p (value
, TREE_TYPE (value
))))
625 return split_nonconstant_init (decl
, value
);
626 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
627 is an automatic variable, the middle end will turn this into a
628 dynamic initialization later. */
629 DECL_INITIAL (decl
) = value
;
634 /* Process the initializer INIT for a variable of type TYPE, emitting
635 diagnostics for invalid initializers and converting the initializer as
638 For aggregate types, it assumes that reshape_init has already run, thus the
639 initializer will have the right shape (brace elision has been undone). */
642 digest_init (tree type
, tree init
)
644 enum tree_code code
= TREE_CODE (type
);
646 if (init
== error_mark_node
)
647 return error_mark_node
;
651 /* We must strip the outermost array type when completing the type,
652 because the its bounds might be incomplete at the moment. */
653 if (!complete_type_or_else (TREE_CODE (type
) == ARRAY_TYPE
654 ? TREE_TYPE (type
) : type
, NULL_TREE
))
655 return error_mark_node
;
657 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
658 (g++.old-deja/g++.law/casts2.C). */
659 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
660 init
= TREE_OPERAND (init
, 0);
662 /* Initialization of an array of chars from a string constant. The initializer
663 can be optionally enclosed in braces, but reshape_init has already removed
664 them if they were present. */
665 if (code
== ARRAY_TYPE
)
667 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
668 if (char_type_p (typ1
)
670 && TREE_CODE (init
) == STRING_CST
)
672 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
674 if (char_type
!= char_type_node
675 && TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
677 error ("char-array initialized from wide string");
678 return error_mark_node
;
680 if (char_type
== char_type_node
681 && TYPE_PRECISION (typ1
) != BITS_PER_UNIT
)
683 error ("int-array initialized from non-wide string");
684 return error_mark_node
;
687 TREE_TYPE (init
) = type
;
688 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
690 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
691 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
692 /* In C it is ok to subtract 1 from the length of the string
693 because it's ok to ignore the terminating null char that is
694 counted in the length of the constant, but in C++ this would
696 if (size
< TREE_STRING_LENGTH (init
))
697 pedwarn ("initializer-string for array of chars is too long");
703 /* Handle scalar types (including conversions) and references. */
704 if (TREE_CODE (type
) != COMPLEX_TYPE
705 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
709 init
= convert_for_initialization (0, type
, init
, LOOKUP_NORMAL
,
710 "initialization", NULL_TREE
, 0,
711 tf_warning_or_error
);
714 /* Skip any conversions since we'll be outputting the underlying
716 while (CONVERT_EXPR_P (*exp
)
717 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
718 exp
= &TREE_OPERAND (*exp
, 0);
720 *exp
= cplus_expand_constant (*exp
);
725 /* Come here only for aggregates: records, arrays, unions, complex numbers
727 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
728 || TREE_CODE (type
) == VECTOR_TYPE
729 || TREE_CODE (type
) == RECORD_TYPE
730 || TREE_CODE (type
) == UNION_TYPE
731 || TREE_CODE (type
) == COMPLEX_TYPE
);
733 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
734 return process_init_constructor (type
, init
);
737 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
739 error ("cannot initialize aggregate of type %qT with "
740 "a compound literal", type
);
742 return error_mark_node
;
745 if (TREE_CODE (type
) == ARRAY_TYPE
746 && TREE_CODE (init
) != CONSTRUCTOR
)
748 error ("array must be initialized with a brace-enclosed"
750 return error_mark_node
;
753 return convert_for_initialization (NULL_TREE
, type
, init
,
754 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
755 "initialization", NULL_TREE
, 0,
756 tf_warning_or_error
);
761 /* Set of flags used within process_init_constructor to describe the
763 #define PICFLAG_ERRONEOUS 1
764 #define PICFLAG_NOT_ALL_CONSTANT 2
765 #define PICFLAG_NOT_ALL_SIMPLE 4
767 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
771 picflag_from_initializer (tree init
)
773 if (init
== error_mark_node
)
774 return PICFLAG_ERRONEOUS
;
775 else if (!TREE_CONSTANT (init
))
776 return PICFLAG_NOT_ALL_CONSTANT
;
777 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
778 return PICFLAG_NOT_ALL_SIMPLE
;
782 /* Subroutine of process_init_constructor, which will process an initializer
783 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
784 which describe the initializers. */
787 process_init_constructor_array (tree type
, tree init
)
789 unsigned HOST_WIDE_INT i
, len
= 0;
791 bool unbounded
= false;
793 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
795 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
796 || TREE_CODE (type
) == VECTOR_TYPE
);
798 if (TREE_CODE (type
) == ARRAY_TYPE
)
800 tree domain
= TYPE_DOMAIN (type
);
802 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
803 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
806 unbounded
= true; /* Take as many as there are. */
809 /* Vectors are like simple fixed-size arrays. */
810 len
= TYPE_VECTOR_SUBPARTS (type
);
812 /* There cannot be more initializers than needed as otherwise
813 reshape_init would have already rejected the initializer. */
815 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
817 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
821 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
822 if (compare_tree_int (ce
->index
, i
) != 0)
824 ce
->value
= error_mark_node
;
825 sorry ("non-trivial designated initializers not supported");
829 ce
->index
= size_int (i
);
830 gcc_assert (ce
->value
);
831 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
833 if (ce
->value
!= error_mark_node
)
834 gcc_assert (same_type_ignoring_top_level_qualifiers_p
835 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
837 flags
|= picflag_from_initializer (ce
->value
);
840 /* No more initializers. If the array is unbounded, we are done. Otherwise,
841 we must add initializers ourselves. */
847 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
849 /* If this type needs constructors run for default-initialization,
850 we can't rely on the back end to do it for us, so build up
851 TARGET_EXPRs. If the type in question is a class, just build
852 one up; if it's an array, recurse. */
853 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
854 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
,
855 tf_warning_or_error
);
857 next
= build_constructor (NULL_TREE
, NULL
);
858 next
= digest_init (TREE_TYPE (type
), next
);
860 else if (!zero_init_p (TREE_TYPE (type
)))
861 next
= build_zero_init (TREE_TYPE (type
),
863 /*static_storage_p=*/false);
865 /* The default zero-initialization is fine for us; don't
866 add anything to the CONSTRUCTOR. */
869 flags
|= picflag_from_initializer (next
);
870 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
873 CONSTRUCTOR_ELTS (init
) = v
;
877 /* Subroutine of process_init_constructor, which will process an initializer
878 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
882 process_init_constructor_record (tree type
, tree init
)
884 VEC(constructor_elt
,gc
) *v
= NULL
;
887 unsigned HOST_WIDE_INT idx
= 0;
889 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
890 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
891 gcc_assert (!TYPE_BINFO (type
)
892 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
893 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
895 /* Generally, we will always have an index for each initializer (which is
896 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
897 reshape_init. So we need to handle both cases. */
898 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
902 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
904 flags
|= picflag_from_initializer (integer_zero_node
);
905 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
909 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
912 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
914 constructor_elt
*ce
= VEC_index (constructor_elt
,
915 CONSTRUCTOR_ELTS (init
), idx
);
918 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
919 latter case can happen in templates where lookup has to be
921 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
922 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
923 if (ce
->index
!= field
924 && ce
->index
!= DECL_NAME (field
))
926 ce
->value
= error_mark_node
;
927 sorry ("non-trivial designated initializers not supported");
931 gcc_assert (ce
->value
);
932 next
= digest_init (TREE_TYPE (field
), ce
->value
);
935 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
937 /* If this type needs constructors run for
938 default-initialization, we can't rely on the back end to do it
939 for us, so build up TARGET_EXPRs. If the type in question is
940 a class, just build one up; if it's an array, recurse. */
941 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field
)))
942 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
,
943 tf_warning_or_error
);
945 next
= build_constructor (NULL_TREE
, NULL
);
947 next
= digest_init (TREE_TYPE (field
), next
);
949 /* Warn when some struct elements are implicitly initialized. */
950 warning (OPT_Wmissing_field_initializers
,
951 "missing initializer for member %qD", field
);
955 if (TREE_READONLY (field
))
956 error ("uninitialized const member %qD", field
);
957 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
958 error ("member %qD with uninitialized const fields", field
);
959 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
960 error ("member %qD is uninitialized reference", field
);
962 /* Warn when some struct elements are implicitly initialized
964 warning (OPT_Wmissing_field_initializers
,
965 "missing initializer for member %qD", field
);
967 if (!zero_init_p (TREE_TYPE (field
)))
968 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
969 /*static_storage_p=*/false);
971 /* The default zero-initialization is fine for us; don't
972 add anything to the CONSTRUCTOR. */
976 flags
|= picflag_from_initializer (next
);
977 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
980 CONSTRUCTOR_ELTS (init
) = v
;
984 /* Subroutine of process_init_constructor, which will process a single
985 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
986 which describe the initializer. */
989 process_init_constructor_union (tree type
, tree init
)
993 /* If the initializer was empty, use default zero initialization. */
994 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
997 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
998 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
1000 /* If this element specifies a field, initialize via that field. */
1003 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1005 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
1007 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1008 tree name
= ce
->index
;
1010 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1011 if (DECL_NAME (field
) == name
)
1015 error ("no field %qD found in union being initialized", field
);
1016 ce
->value
= error_mark_node
;
1022 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1023 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1024 error ("index value instead of field name in union initializer");
1025 ce
->value
= error_mark_node
;
1030 /* Find the first named field. ANSI decided in September 1990
1031 that only named fields count here. */
1032 tree field
= TYPE_FIELDS (type
);
1033 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1034 field
= TREE_CHAIN (field
);
1039 if (ce
->value
&& ce
->value
!= error_mark_node
)
1040 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1042 return picflag_from_initializer (ce
->value
);
1045 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1046 constructor is a brace-enclosed initializer, and will be modified in-place.
1048 Each element is converted to the right type through digest_init, and
1049 missing initializers are added following the language rules (zero-padding,
1052 After the execution, the initializer will have TREE_CONSTANT if all elts are
1053 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1054 constants that the assembler and linker can compute them.
1056 The function returns the initializer itself, or error_mark_node in case
1060 process_init_constructor (tree type
, tree init
)
1064 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1066 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1067 flags
= process_init_constructor_array (type
, init
);
1068 else if (TREE_CODE (type
) == RECORD_TYPE
)
1069 flags
= process_init_constructor_record (type
, init
);
1070 else if (TREE_CODE (type
) == UNION_TYPE
)
1071 flags
= process_init_constructor_union (type
, init
);
1075 if (flags
& PICFLAG_ERRONEOUS
)
1076 return error_mark_node
;
1078 TREE_TYPE (init
) = type
;
1079 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1080 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1081 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1083 TREE_CONSTANT (init
) = 1;
1084 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1085 TREE_STATIC (init
) = 1;
1090 /* Given a structure or union value DATUM, construct and return
1091 the structure or union component which results from narrowing
1092 that value to the base specified in BASETYPE. For example, given the
1095 class L { int ii; };
1096 class A : L { ... };
1097 class B : L { ... };
1098 class C : A, B { ... };
1106 x.A::ii refers to the ii member of the L part of
1107 the A part of the C object named by X. In this case,
1108 DATUM would be x, and BASETYPE would be A.
1110 I used to think that this was nonconformant, that the standard specified
1111 that first we look up ii in A, then convert x to an L& and pull out the
1112 ii part. But in fact, it does say that we convert x to an A&; A here
1113 is known as the "naming class". (jason 2000-12-19)
1115 BINFO_P points to a variable initialized either to NULL_TREE or to the
1116 binfo for the specific base subobject we want to convert to. */
1119 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1123 if (datum
== error_mark_node
)
1124 return error_mark_node
;
1128 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1130 if (!binfo
|| binfo
== error_mark_node
)
1132 *binfo_p
= NULL_TREE
;
1134 error_not_base_type (basetype
, TREE_TYPE (datum
));
1135 return error_mark_node
;
1139 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1142 /* Build a reference to an object specified by the C++ `->' operator.
1143 Usually this just involves dereferencing the object, but if the
1144 `->' operator is overloaded, then such overloads must be
1145 performed until an object which does not have the `->' operator
1146 overloaded is found. An error is reported when circular pointer
1147 delegation is detected. */
1150 build_x_arrow (tree expr
)
1152 tree orig_expr
= expr
;
1153 tree types_memoized
= NULL_TREE
;
1154 tree type
= TREE_TYPE (expr
);
1155 tree last_rval
= NULL_TREE
;
1157 if (type
== error_mark_node
)
1158 return error_mark_node
;
1160 if (processing_template_decl
)
1162 if (type_dependent_expression_p (expr
))
1163 return build_min_nt (ARROW_EXPR
, expr
);
1164 expr
= build_non_dependent_expr (expr
);
1167 if (MAYBE_CLASS_TYPE_P (type
))
1169 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1170 NULL_TREE
, NULL_TREE
,
1171 /*overloaded_p=*/NULL
,
1172 tf_warning_or_error
)))
1174 if (expr
== error_mark_node
)
1175 return error_mark_node
;
1177 if (value_member (TREE_TYPE (expr
), types_memoized
))
1179 error ("circular pointer delegation detected");
1180 return error_mark_node
;
1184 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1190 if (last_rval
== NULL_TREE
)
1192 error ("base operand of %<->%> has non-pointer type %qT", type
);
1193 return error_mark_node
;
1196 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1197 last_rval
= convert_from_reference (last_rval
);
1200 last_rval
= decay_conversion (expr
);
1202 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1204 if (processing_template_decl
)
1206 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1207 /* It will be dereferenced. */
1208 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1212 return cp_build_indirect_ref (last_rval
, NULL
, tf_warning_or_error
);
1216 error ("result of %<operator->()%> yields non-pointer result");
1218 error ("base operand of %<->%> is not a pointer");
1219 return error_mark_node
;
1222 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1223 already been checked out to be of aggregate type. */
1226 build_m_component_ref (tree datum
, tree component
)
1234 if (error_operand_p (datum
) || error_operand_p (component
))
1235 return error_mark_node
;
1237 ptrmem_type
= TREE_TYPE (component
);
1238 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1240 error ("%qE cannot be used as a member pointer, since it is of "
1242 component
, ptrmem_type
);
1243 return error_mark_node
;
1246 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1247 if (! MAYBE_CLASS_TYPE_P (objtype
))
1249 error ("cannot apply member pointer %qE to %qE, which is of "
1250 "non-class type %qT",
1251 component
, datum
, objtype
);
1252 return error_mark_node
;
1255 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1256 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1258 if (!COMPLETE_TYPE_P (ctype
))
1260 if (!same_type_p (ctype
, objtype
))
1266 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1271 error ("pointer to member type %qT incompatible with object "
1274 return error_mark_node
;
1276 else if (binfo
== error_mark_node
)
1277 return error_mark_node
;
1280 if (TYPE_PTRMEM_P (ptrmem_type
))
1284 /* Compute the type of the field, as described in [expr.ref].
1285 There's no such thing as a mutable pointer-to-member, so
1286 things are not as complex as they are for references to
1287 non-static data members. */
1288 type
= cp_build_qualified_type (type
,
1289 (cp_type_quals (type
)
1290 | cp_type_quals (TREE_TYPE (datum
))));
1292 datum
= build_address (datum
);
1294 /* Convert object to the correct base. */
1296 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1298 /* Build an expression for "object + offset" where offset is the
1299 value stored in the pointer-to-data-member. */
1300 ptype
= build_pointer_type (type
);
1301 datum
= build2 (POINTER_PLUS_EXPR
, ptype
,
1302 fold_convert (ptype
, datum
),
1303 build_nop (sizetype
, component
));
1304 return cp_build_indirect_ref (datum
, 0, tf_warning_or_error
);
1307 return build2 (OFFSET_REF
, type
, datum
, component
);
1310 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1313 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1315 /* This is either a call to a constructor,
1316 or a C cast in C++'s `functional' notation. */
1318 /* The type to which we are casting. */
1321 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1322 return error_mark_node
;
1324 if (TREE_CODE (exp
) == TYPE_DECL
)
1325 type
= TREE_TYPE (exp
);
1329 if (processing_template_decl
)
1331 tree t
= build_min (CAST_EXPR
, type
, parms
);
1332 /* We don't know if it will or will not have side effects. */
1333 TREE_SIDE_EFFECTS (t
) = 1;
1337 if (! MAYBE_CLASS_TYPE_P (type
))
1339 if (parms
== NULL_TREE
)
1340 return cp_convert (type
, integer_zero_node
);
1342 /* This must build a C cast. */
1343 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1344 return cp_build_c_cast (type
, parms
, complain
);
1347 /* Prepare to evaluate as a call to a constructor. If this expression
1348 is actually used, for example,
1350 return X (arg1, arg2, ...);
1352 then the slot being initialized will be filled in. */
1354 if (!complete_type_or_else (type
, NULL_TREE
))
1355 return error_mark_node
;
1356 if (abstract_virtuals_error (NULL_TREE
, type
))
1357 return error_mark_node
;
1361 If the expression list is a single-expression, the type
1362 conversion is equivalent (in definedness, and if defined in
1363 meaning) to the corresponding cast expression. */
1364 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1365 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1369 The expression T(), where T is a simple-type-specifier for a
1370 non-array complete object type or the (possibly cv-qualified)
1371 void type, creates an rvalue of the specified type, which is
1372 value-initialized. */
1374 if (parms
== NULL_TREE
1375 /* If there's a user-defined constructor, value-initialization is
1376 just calling the constructor, so fall through. */
1377 && !TYPE_HAS_USER_CONSTRUCTOR (type
))
1379 exp
= build_value_init (type
);
1380 return get_target_expr (exp
);
1383 /* Call the constructor. */
1384 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1385 type
, LOOKUP_NORMAL
, complain
);
1387 if (exp
== error_mark_node
)
1388 return error_mark_node
;
1390 return build_cplus_new (type
, exp
);
1394 /* Add new exception specifier SPEC, to the LIST we currently have.
1395 If it's already in LIST then do nothing.
1396 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1397 know what we're doing. */
1400 add_exception_specifier (tree list
, tree spec
, int complain
)
1405 int diag_type
= -1; /* none */
1407 if (spec
== error_mark_node
)
1410 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1412 /* [except.spec] 1, type in an exception specifier shall not be
1413 incomplete, or pointer or ref to incomplete other than pointer
1415 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1416 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1417 core
= TREE_TYPE (core
);
1420 else if (VOID_TYPE_P (core
))
1422 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1424 else if (processing_template_decl
)
1429 /* 15.4/1 says that types in an exception specifier must be complete,
1430 but it seems more reasonable to only require this on definitions
1431 and calls. So just give a pedwarn at this point; we will give an
1432 error later if we hit one of those two cases. */
1433 if (!COMPLETE_TYPE_P (complete_type (core
)))
1434 diag_type
= 2; /* pedwarn */
1441 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1442 if (same_type_p (TREE_VALUE (probe
), spec
))
1445 list
= tree_cons (NULL_TREE
, spec
, list
);
1448 diag_type
= 0; /* error */
1450 if (diag_type
>= 0 && complain
)
1451 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1456 /* Combine the two exceptions specifier lists LIST and ADD, and return
1460 merge_exception_specifiers (tree list
, tree add
)
1464 else if (!TREE_VALUE (list
))
1466 else if (!TREE_VALUE (add
))
1470 tree orig_list
= list
;
1472 for (; add
; add
= TREE_CHAIN (add
))
1474 tree spec
= TREE_VALUE (add
);
1477 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1478 if (same_type_p (TREE_VALUE (probe
), spec
))
1482 spec
= build_tree_list (NULL_TREE
, spec
);
1483 TREE_CHAIN (spec
) = list
;
1491 /* Subroutine of build_call. Ensure that each of the types in the
1492 exception specification is complete. Technically, 15.4/1 says that
1493 they need to be complete when we see a declaration of the function,
1494 but we should be able to get away with only requiring this when the
1495 function is defined or called. See also add_exception_specifier. */
1498 require_complete_eh_spec_types (tree fntype
, tree decl
)
1501 /* Don't complain about calls to op new. */
1502 if (decl
&& DECL_ARTIFICIAL (decl
))
1504 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1505 raises
= TREE_CHAIN (raises
))
1507 tree type
= TREE_VALUE (raises
);
1508 if (type
&& !COMPLETE_TYPE_P (type
))
1512 ("call to function %qD which throws incomplete type %q#T",
1515 error ("call to function which throws incomplete type %q#T",
1522 #include "gt-cp-typeck2.h"