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
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 (IS_AGGR_TYPE (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);
713 /* Skip any conversions since we'll be outputting the underlying
715 while (TREE_CODE (*exp
) == NOP_EXPR
|| TREE_CODE (*exp
) == CONVERT_EXPR
716 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
717 exp
= &TREE_OPERAND (*exp
, 0);
719 *exp
= cplus_expand_constant (*exp
);
724 /* Come here only for aggregates: records, arrays, unions, complex numbers
726 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
727 || TREE_CODE (type
) == VECTOR_TYPE
728 || TREE_CODE (type
) == RECORD_TYPE
729 || TREE_CODE (type
) == UNION_TYPE
730 || TREE_CODE (type
) == COMPLEX_TYPE
);
732 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
733 return process_init_constructor (type
, init
);
736 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
738 error ("cannot initialize aggregate of type %qT with "
739 "a compound literal", type
);
741 return error_mark_node
;
744 if (TREE_CODE (type
) == ARRAY_TYPE
745 && TREE_CODE (init
) != CONSTRUCTOR
)
747 error ("array must be initialized with a brace-enclosed"
749 return error_mark_node
;
752 return convert_for_initialization (NULL_TREE
, type
, init
,
753 LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
,
754 "initialization", NULL_TREE
, 0);
759 /* Set of flags used within process_init_constructor to describe the
761 #define PICFLAG_ERRONEOUS 1
762 #define PICFLAG_NOT_ALL_CONSTANT 2
763 #define PICFLAG_NOT_ALL_SIMPLE 4
765 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
769 picflag_from_initializer (tree init
)
771 if (init
== error_mark_node
)
772 return PICFLAG_ERRONEOUS
;
773 else if (!TREE_CONSTANT (init
))
774 return PICFLAG_NOT_ALL_CONSTANT
;
775 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
776 return PICFLAG_NOT_ALL_SIMPLE
;
780 /* Subroutine of process_init_constructor, which will process an initializer
781 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
782 which describe the initializers. */
785 process_init_constructor_array (tree type
, tree init
)
787 unsigned HOST_WIDE_INT i
, len
= 0;
789 bool unbounded
= false;
791 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (init
);
793 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
794 || TREE_CODE (type
) == VECTOR_TYPE
);
796 if (TREE_CODE (type
) == ARRAY_TYPE
)
798 tree domain
= TYPE_DOMAIN (type
);
800 len
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
))
801 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
))
804 unbounded
= true; /* Take as many as there are. */
807 /* Vectors are like simple fixed-size arrays. */
808 len
= TYPE_VECTOR_SUBPARTS (type
);
810 /* There cannot be more initializers than needed as otherwise
811 reshape_init would have already rejected the initializer. */
813 gcc_assert (VEC_length (constructor_elt
, v
) <= len
);
815 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
819 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
820 if (compare_tree_int (ce
->index
, i
) != 0)
822 ce
->value
= error_mark_node
;
823 sorry ("non-trivial designated initializers not supported");
827 ce
->index
= size_int (i
);
828 gcc_assert (ce
->value
);
829 ce
->value
= digest_init (TREE_TYPE (type
), ce
->value
);
831 if (ce
->value
!= error_mark_node
)
832 gcc_assert (same_type_ignoring_top_level_qualifiers_p
833 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
835 flags
|= picflag_from_initializer (ce
->value
);
838 /* No more initializers. If the array is unbounded, we are done. Otherwise,
839 we must add initializers ourselves. */
845 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type
)))
847 /* If this type needs constructors run for default-initialization,
848 we can't rely on the back end to do it for us, so build up
849 TARGET_EXPRs. If the type in question is a class, just build
850 one up; if it's an array, recurse. */
851 if (IS_AGGR_TYPE (TREE_TYPE (type
)))
852 next
= build_functional_cast (TREE_TYPE (type
), NULL_TREE
);
854 next
= build_constructor (NULL_TREE
, NULL
);
855 next
= digest_init (TREE_TYPE (type
), next
);
857 else if (!zero_init_p (TREE_TYPE (type
)))
858 next
= build_zero_init (TREE_TYPE (type
),
860 /*static_storage_p=*/false);
862 /* The default zero-initialization is fine for us; don't
863 add anything to the CONSTRUCTOR. */
866 flags
|= picflag_from_initializer (next
);
867 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
870 CONSTRUCTOR_ELTS (init
) = v
;
874 /* Subroutine of process_init_constructor, which will process an initializer
875 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
879 process_init_constructor_record (tree type
, tree init
)
881 VEC(constructor_elt
,gc
) *v
= NULL
;
884 unsigned HOST_WIDE_INT idx
= 0;
886 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
887 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
888 gcc_assert (!TYPE_BINFO (type
)
889 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
890 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
892 /* Generally, we will always have an index for each initializer (which is
893 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
894 reshape_init. So we need to handle both cases. */
895 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
899 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
901 flags
|= picflag_from_initializer (integer_zero_node
);
902 CONSTRUCTOR_APPEND_ELT (v
, field
, integer_zero_node
);
906 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
909 if (idx
< VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
911 constructor_elt
*ce
= VEC_index (constructor_elt
,
912 CONSTRUCTOR_ELTS (init
), idx
);
915 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
916 latter case can happen in templates where lookup has to be
918 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
919 || TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
920 if (ce
->index
!= field
921 && ce
->index
!= DECL_NAME (field
))
923 ce
->value
= error_mark_node
;
924 sorry ("non-trivial designated initializers not supported");
928 gcc_assert (ce
->value
);
929 next
= digest_init (TREE_TYPE (field
), ce
->value
);
932 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
934 /* If this type needs constructors run for
935 default-initialization, we can't rely on the back end to do it
936 for us, so build up TARGET_EXPRs. If the type in question is
937 a class, just build one up; if it's an array, recurse. */
938 if (IS_AGGR_TYPE (TREE_TYPE (field
)))
939 next
= build_functional_cast (TREE_TYPE (field
), NULL_TREE
);
941 next
= build_constructor (NULL_TREE
, NULL
);
943 next
= digest_init (TREE_TYPE (field
), next
);
945 /* Warn when some struct elements are implicitly initialized. */
946 warning (OPT_Wmissing_field_initializers
,
947 "missing initializer for member %qD", field
);
951 if (TREE_READONLY (field
))
952 error ("uninitialized const member %qD", field
);
953 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
954 error ("member %qD with uninitialized const fields", field
);
955 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
956 error ("member %qD is uninitialized reference", field
);
958 /* Warn when some struct elements are implicitly initialized
960 warning (OPT_Wmissing_field_initializers
,
961 "missing initializer for member %qD", field
);
963 if (!zero_init_p (TREE_TYPE (field
)))
964 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
965 /*static_storage_p=*/false);
967 /* The default zero-initialization is fine for us; don't
968 add anything to the CONSTRUCTOR. */
972 flags
|= picflag_from_initializer (next
);
973 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
976 CONSTRUCTOR_ELTS (init
) = v
;
980 /* Subroutine of process_init_constructor, which will process a single
981 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
982 which describe the initializer. */
985 process_init_constructor_union (tree type
, tree init
)
989 /* If the initializer was empty, use default zero initialization. */
990 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
993 gcc_assert (VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
)) == 1);
994 ce
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (init
), 0);
996 /* If this element specifies a field, initialize via that field. */
999 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1001 else if (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
)
1003 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1004 tree name
= ce
->index
;
1006 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1007 if (DECL_NAME (field
) == name
)
1011 error ("no field %qD found in union being initialized", field
);
1012 ce
->value
= error_mark_node
;
1018 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1019 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1020 error ("index value instead of field name in union initializer");
1021 ce
->value
= error_mark_node
;
1026 /* Find the first named field. ANSI decided in September 1990
1027 that only named fields count here. */
1028 tree field
= TYPE_FIELDS (type
);
1029 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1030 field
= TREE_CHAIN (field
);
1035 if (ce
->value
&& ce
->value
!= error_mark_node
)
1036 ce
->value
= digest_init (TREE_TYPE (ce
->index
), ce
->value
);
1038 return picflag_from_initializer (ce
->value
);
1041 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1042 constructor is a brace-enclosed initializer, and will be modified in-place.
1044 Each element is converted to the right type through digest_init, and
1045 missing initializers are added following the language rules (zero-padding,
1048 After the execution, the initializer will have TREE_CONSTANT if all elts are
1049 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1050 constants that the assembler and linker can compute them.
1052 The function returns the initializer itself, or error_mark_node in case
1056 process_init_constructor (tree type
, tree init
)
1060 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1062 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1063 flags
= process_init_constructor_array (type
, init
);
1064 else if (TREE_CODE (type
) == RECORD_TYPE
)
1065 flags
= process_init_constructor_record (type
, init
);
1066 else if (TREE_CODE (type
) == UNION_TYPE
)
1067 flags
= process_init_constructor_union (type
, init
);
1071 if (flags
& PICFLAG_ERRONEOUS
)
1072 return error_mark_node
;
1074 TREE_TYPE (init
) = type
;
1075 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1076 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1077 if (!(flags
& PICFLAG_NOT_ALL_CONSTANT
))
1079 TREE_CONSTANT (init
) = 1;
1080 TREE_INVARIANT (init
) = 1;
1081 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1082 TREE_STATIC (init
) = 1;
1087 /* Given a structure or union value DATUM, construct and return
1088 the structure or union component which results from narrowing
1089 that value to the base specified in BASETYPE. For example, given the
1092 class L { int ii; };
1093 class A : L { ... };
1094 class B : L { ... };
1095 class C : A, B { ... };
1103 x.A::ii refers to the ii member of the L part of
1104 the A part of the C object named by X. In this case,
1105 DATUM would be x, and BASETYPE would be A.
1107 I used to think that this was nonconformant, that the standard specified
1108 that first we look up ii in A, then convert x to an L& and pull out the
1109 ii part. But in fact, it does say that we convert x to an A&; A here
1110 is known as the "naming class". (jason 2000-12-19)
1112 BINFO_P points to a variable initialized either to NULL_TREE or to the
1113 binfo for the specific base subobject we want to convert to. */
1116 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1120 if (datum
== error_mark_node
)
1121 return error_mark_node
;
1125 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
, NULL
);
1127 if (!binfo
|| binfo
== error_mark_node
)
1129 *binfo_p
= NULL_TREE
;
1131 error_not_base_type (basetype
, TREE_TYPE (datum
));
1132 return error_mark_node
;
1136 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1139 /* Build a reference to an object specified by the C++ `->' operator.
1140 Usually this just involves dereferencing the object, but if the
1141 `->' operator is overloaded, then such overloads must be
1142 performed until an object which does not have the `->' operator
1143 overloaded is found. An error is reported when circular pointer
1144 delegation is detected. */
1147 build_x_arrow (tree expr
)
1149 tree orig_expr
= expr
;
1150 tree types_memoized
= NULL_TREE
;
1151 tree type
= TREE_TYPE (expr
);
1152 tree last_rval
= NULL_TREE
;
1154 if (type
== error_mark_node
)
1155 return error_mark_node
;
1157 if (processing_template_decl
)
1159 if (type_dependent_expression_p (expr
))
1160 return build_min_nt (ARROW_EXPR
, expr
);
1161 expr
= build_non_dependent_expr (expr
);
1164 if (IS_AGGR_TYPE (type
))
1166 while ((expr
= build_new_op (COMPONENT_REF
, LOOKUP_NORMAL
, expr
,
1167 NULL_TREE
, NULL_TREE
,
1168 /*overloaded_p=*/NULL
)))
1170 if (expr
== error_mark_node
)
1171 return error_mark_node
;
1173 if (value_member (TREE_TYPE (expr
), types_memoized
))
1175 error ("circular pointer delegation detected");
1176 return error_mark_node
;
1180 types_memoized
= tree_cons (NULL_TREE
, TREE_TYPE (expr
),
1186 if (last_rval
== NULL_TREE
)
1188 error ("base operand of %<->%> has non-pointer type %qT", type
);
1189 return error_mark_node
;
1192 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1193 last_rval
= convert_from_reference (last_rval
);
1196 last_rval
= decay_conversion (expr
);
1198 if (TREE_CODE (TREE_TYPE (last_rval
)) == POINTER_TYPE
)
1200 if (processing_template_decl
)
1202 expr
= build_min_non_dep (ARROW_EXPR
, last_rval
, orig_expr
);
1203 /* It will be dereferenced. */
1204 TREE_TYPE (expr
) = TREE_TYPE (TREE_TYPE (last_rval
));
1208 return build_indirect_ref (last_rval
, NULL
);
1212 error ("result of %<operator->()%> yields non-pointer result");
1214 error ("base operand of %<->%> is not a pointer");
1215 return error_mark_node
;
1218 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1219 already been checked out to be of aggregate type. */
1222 build_m_component_ref (tree datum
, tree component
)
1230 if (error_operand_p (datum
) || error_operand_p (component
))
1231 return error_mark_node
;
1233 ptrmem_type
= TREE_TYPE (component
);
1234 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type
))
1236 error ("%qE cannot be used as a member pointer, since it is of "
1238 component
, ptrmem_type
);
1239 return error_mark_node
;
1242 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1243 if (! IS_AGGR_TYPE (objtype
))
1245 error ("cannot apply member pointer %qE to %qE, which is of "
1246 "non-class type %qT",
1247 component
, datum
, objtype
);
1248 return error_mark_node
;
1251 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1252 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1254 if (!COMPLETE_TYPE_P (ctype
))
1256 if (!same_type_p (ctype
, objtype
))
1262 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
);
1267 error ("pointer to member type %qT incompatible with object "
1270 return error_mark_node
;
1272 else if (binfo
== error_mark_node
)
1273 return error_mark_node
;
1276 if (TYPE_PTRMEM_P (ptrmem_type
))
1280 /* Compute the type of the field, as described in [expr.ref].
1281 There's no such thing as a mutable pointer-to-member, so
1282 things are not as complex as they are for references to
1283 non-static data members. */
1284 type
= cp_build_qualified_type (type
,
1285 (cp_type_quals (type
)
1286 | cp_type_quals (TREE_TYPE (datum
))));
1288 datum
= build_address (datum
);
1290 /* Convert object to the correct base. */
1292 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1);
1294 /* Build an expression for "object + offset" where offset is the
1295 value stored in the pointer-to-data-member. */
1296 ptype
= build_pointer_type (type
);
1297 datum
= build2 (POINTER_PLUS_EXPR
, ptype
,
1298 fold_convert (ptype
, datum
),
1299 build_nop (sizetype
, component
));
1300 return build_indirect_ref (datum
, 0);
1303 return build2 (OFFSET_REF
, type
, datum
, component
);
1306 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1309 build_functional_cast (tree exp
, tree parms
)
1311 /* This is either a call to a constructor,
1312 or a C cast in C++'s `functional' notation. */
1315 if (exp
== error_mark_node
|| parms
== error_mark_node
)
1316 return error_mark_node
;
1318 if (TREE_CODE (exp
) == TYPE_DECL
)
1319 type
= TREE_TYPE (exp
);
1323 if (processing_template_decl
)
1325 tree t
= build_min (CAST_EXPR
, type
, parms
);
1326 /* We don't know if it will or will not have side effects. */
1327 TREE_SIDE_EFFECTS (t
) = 1;
1331 if (! IS_AGGR_TYPE (type
))
1333 if (parms
== NULL_TREE
)
1334 return cp_convert (type
, integer_zero_node
);
1336 /* This must build a C cast. */
1337 parms
= build_x_compound_expr_from_list (parms
, "functional cast");
1338 return build_c_cast (type
, parms
);
1341 /* Prepare to evaluate as a call to a constructor. If this expression
1342 is actually used, for example,
1344 return X (arg1, arg2, ...);
1346 then the slot being initialized will be filled in. */
1348 if (!complete_type_or_else (type
, NULL_TREE
))
1349 return error_mark_node
;
1350 if (abstract_virtuals_error (NULL_TREE
, type
))
1351 return error_mark_node
;
1353 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1354 return build_c_cast (type
, TREE_VALUE (parms
));
1356 /* We need to zero-initialize POD types. */
1357 if (parms
== NULL_TREE
1358 && !CLASSTYPE_NON_POD_P (type
)
1359 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
1361 exp
= build_zero_init (type
,
1362 /*nelts=*/NULL_TREE
,
1363 /*static_storage_p=*/false);
1364 return get_target_expr (exp
);
1367 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
, parms
,
1368 type
, LOOKUP_NORMAL
);
1370 if (exp
== error_mark_node
)
1371 return error_mark_node
;
1373 return build_cplus_new (type
, exp
);
1377 /* Add new exception specifier SPEC, to the LIST we currently have.
1378 If it's already in LIST then do nothing.
1379 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1380 know what we're doing. */
1383 add_exception_specifier (tree list
, tree spec
, int complain
)
1388 int diag_type
= -1; /* none */
1390 if (spec
== error_mark_node
)
1393 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1395 /* [except.spec] 1, type in an exception specifier shall not be
1396 incomplete, or pointer or ref to incomplete other than pointer
1398 is_ptr
= TREE_CODE (core
) == POINTER_TYPE
;
1399 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1400 core
= TREE_TYPE (core
);
1403 else if (VOID_TYPE_P (core
))
1405 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1407 else if (processing_template_decl
)
1412 /* 15.4/1 says that types in an exception specifier must be complete,
1413 but it seems more reasonable to only require this on definitions
1414 and calls. So just give a pedwarn at this point; we will give an
1415 error later if we hit one of those two cases. */
1416 if (!COMPLETE_TYPE_P (complete_type (core
)))
1417 diag_type
= 2; /* pedwarn */
1424 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1425 if (same_type_p (TREE_VALUE (probe
), spec
))
1428 list
= tree_cons (NULL_TREE
, spec
, list
);
1431 diag_type
= 0; /* error */
1433 if (diag_type
>= 0 && complain
)
1434 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1439 /* Combine the two exceptions specifier lists LIST and ADD, and return
1443 merge_exception_specifiers (tree list
, tree add
)
1447 else if (!TREE_VALUE (list
))
1449 else if (!TREE_VALUE (add
))
1453 tree orig_list
= list
;
1455 for (; add
; add
= TREE_CHAIN (add
))
1457 tree spec
= TREE_VALUE (add
);
1460 for (probe
= orig_list
; probe
; probe
= TREE_CHAIN (probe
))
1461 if (same_type_p (TREE_VALUE (probe
), spec
))
1465 spec
= build_tree_list (NULL_TREE
, spec
);
1466 TREE_CHAIN (spec
) = list
;
1474 /* Subroutine of build_call. Ensure that each of the types in the
1475 exception specification is complete. Technically, 15.4/1 says that
1476 they need to be complete when we see a declaration of the function,
1477 but we should be able to get away with only requiring this when the
1478 function is defined or called. See also add_exception_specifier. */
1481 require_complete_eh_spec_types (tree fntype
, tree decl
)
1484 /* Don't complain about calls to op new. */
1485 if (decl
&& DECL_ARTIFICIAL (decl
))
1487 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
1488 raises
= TREE_CHAIN (raises
))
1490 tree type
= TREE_VALUE (raises
);
1491 if (type
&& !COMPLETE_TYPE_P (type
))
1495 ("call to function %qD which throws incomplete type %q#T",
1498 error ("call to function which throws incomplete type %q#T",
1505 #include "gt-cp-typeck2.h"