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, 2009
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"
43 process_init_constructor (tree type, tree init);
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
50 error_not_base_type (tree basetype, tree type)
52 if (TREE_CODE (basetype) == FUNCTION_DECL)
53 basetype = DECL_CONTEXT (basetype);
54 error ("type %qT is not a base type for type %qT", basetype, type);
55 return error_mark_node;
59 binfo_or_else (tree base, tree type)
61 tree binfo = lookup_base (type, base, ba_unique, NULL);
63 if (binfo == error_mark_node)
66 error_not_base_type (base, type);
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. */
74 readonly_error (tree arg, const char* string)
78 if (TREE_CODE (arg) == COMPONENT_REF)
80 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
81 fmt = "%s of data-member %qD in read-only structure";
83 fmt = "%s of read-only data-member %qD";
84 error (fmt, string, TREE_OPERAND (arg, 1));
86 else if (TREE_CODE (arg) == VAR_DECL)
88 if (DECL_LANG_SPECIFIC (arg)
89 && DECL_IN_AGGR_P (arg)
90 && !TREE_STATIC (arg))
91 fmt = "%s of constant field %qD";
93 fmt = "%s of read-only variable %qD";
94 error (fmt, string, arg);
96 else if (TREE_CODE (arg) == PARM_DECL)
97 error ("%s of read-only parameter %qD", string, arg);
98 else if (TREE_CODE (arg) == INDIRECT_REF
99 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
100 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
101 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
102 error ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
103 else if (TREE_CODE (arg) == RESULT_DECL)
104 error ("%s of read-only named return value %qD", string, arg);
105 else if (TREE_CODE (arg) == FUNCTION_DECL)
106 error ("%s of function %qD", string, arg);
108 error ("%s of read-only location %qE", string, arg);
112 /* Structure that holds information about declarations whose type was
113 incomplete and we could not check whether it was abstract or not. */
115 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
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 (input_location, "%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 (input_location, "\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 (input_location, "%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_KIND indicates the
335 type of diagnostic (see diagnostic.def). */
338 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
339 diagnostic_t diag_kind)
343 gcc_assert (diag_kind == DK_WARNING
344 || diag_kind == DK_PEDWARN
345 || diag_kind == DK_ERROR);
347 /* Avoid duplicate error message. */
348 if (TREE_CODE (type) == ERROR_MARK)
351 if (value != 0 && (TREE_CODE (value) == VAR_DECL
352 || TREE_CODE (value) == PARM_DECL
353 || TREE_CODE (value) == FIELD_DECL))
355 emit_diagnostic (diag_kind, input_location, 0,
356 "%q+D has incomplete type", value);
360 /* We must print an error message. Be clever about what it says. */
362 switch (TREE_CODE (type))
368 emit_diagnostic (diag_kind, input_location, 0,
369 "invalid use of incomplete type %q#T", type);
370 if (!TYPE_TEMPLATE_INFO (type))
371 emit_diagnostic (diag_kind, input_location, 0,
372 "forward declaration of %q+#T", type);
374 emit_diagnostic (diag_kind, input_location, 0,
375 "declaration of %q+#T", type);
379 emit_diagnostic (diag_kind, input_location, 0,
380 "invalid use of %qT", type);
384 if (TYPE_DOMAIN (type))
386 type = TREE_TYPE (type);
389 emit_diagnostic (diag_kind, input_location, 0,
390 "invalid use of array with unspecified bounds");
395 emit_diagnostic (diag_kind, input_location, 0,
396 "invalid use of member (did you forget the %<&%> ?)");
399 case TEMPLATE_TYPE_PARM:
401 emit_diagnostic (diag_kind, input_location, 0,
402 "invalid use of %<auto%>");
404 emit_diagnostic (diag_kind, input_location, 0,
405 "invalid use of template type parameter %qT", type);
408 case BOUND_TEMPLATE_TEMPLATE_PARM:
409 emit_diagnostic (diag_kind, input_location, 0,
410 "invalid use of template template parameter %qT",
415 emit_diagnostic (diag_kind, input_location, 0,
416 "invalid use of dependent type %qT", type);
420 if (value && TREE_CODE (value) == COMPONENT_REF)
422 else if (value && TREE_CODE (value) == ADDR_EXPR)
423 emit_diagnostic (diag_kind, input_location, 0,
424 "address of overloaded function with no contextual "
426 else if (value && TREE_CODE (value) == OVERLOAD)
427 emit_diagnostic (diag_kind, input_location, 0,
428 "overloaded function with no contextual type information");
430 emit_diagnostic (diag_kind, input_location, 0,
431 "insufficient contextual information to determine type");
439 /* Backward-compatibility interface to incomplete_type_diagnostic;
440 required by ../tree.c. */
441 #undef cxx_incomplete_type_error
443 cxx_incomplete_type_error (const_tree value, const_tree type)
445 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
449 /* The recursive part of split_nonconstant_init. DEST is an lvalue
450 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
453 split_nonconstant_init_1 (tree dest, tree init)
455 unsigned HOST_WIDE_INT idx;
456 tree field_index, value;
457 tree type = TREE_TYPE (dest);
458 tree inner_type = NULL;
459 bool array_type_p = false;
461 switch (TREE_CODE (type))
464 inner_type = TREE_TYPE (type);
470 case QUAL_UNION_TYPE:
471 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
474 /* The current implementation of this algorithm assumes that
475 the field was set for all the elements. This is usually done
476 by process_init_constructor. */
477 gcc_assert (field_index);
480 inner_type = TREE_TYPE (field_index);
482 if (TREE_CODE (value) == CONSTRUCTOR)
487 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
488 NULL_TREE, NULL_TREE);
490 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
493 split_nonconstant_init_1 (sub, value);
495 else if (!initializer_constant_valid_p (value, inner_type))
500 /* FIXME: Ordered removal is O(1) so the whole function is
501 worst-case quadratic. This could be fixed using an aside
502 bitmap to record which elements must be removed and remove
503 them all at the same time. Or by merging
504 split_non_constant_init into process_init_constructor_array,
505 that is separating constants from non-constants while building
507 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
512 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
513 NULL_TREE, NULL_TREE);
515 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
518 code = build2 (INIT_EXPR, inner_type, sub, value);
519 code = build_stmt (EXPR_STMT, code);
527 if (!initializer_constant_valid_p (init, type))
530 tree cons = copy_node (init);
531 CONSTRUCTOR_ELTS (init) = NULL;
532 code = build2 (MODIFY_EXPR, type, dest, cons);
533 code = build_stmt (EXPR_STMT, code);
542 /* The rest of the initializer is now a constant. */
543 TREE_CONSTANT (init) = 1;
546 /* A subroutine of store_init_value. Splits non-constant static
547 initializer INIT into a constant part and generates code to
548 perform the non-constant part of the initialization to DEST.
549 Returns the code for the runtime init. */
552 split_nonconstant_init (tree dest, tree init)
556 if (TREE_CODE (init) == CONSTRUCTOR)
558 code = push_stmt_list ();
559 split_nonconstant_init_1 (dest, init);
560 code = pop_stmt_list (code);
561 DECL_INITIAL (dest) = init;
562 TREE_READONLY (dest) = 0;
565 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
570 /* Perform appropriate conversions on the initial value of a variable,
571 store it in the declaration DECL,
572 and print any error messages that are appropriate.
573 If the init is invalid, store an ERROR_MARK.
575 C++: Note that INIT might be a TREE_LIST, which would mean that it is
576 a base class initializer for some aggregate type, hopefully compatible
577 with DECL. If INIT is a single element, and DECL is an aggregate
578 type, we silently convert INIT into a TREE_LIST, allowing a constructor
581 If INIT is a TREE_LIST and there is no constructor, turn INIT
582 into a CONSTRUCTOR and use standard initialization techniques.
583 Perhaps a warning should be generated?
585 Returns code to be executed if initialization could not be performed
586 for static variable. In that case, caller must emit the code. */
589 store_init_value (tree decl, tree init)
593 /* If variable's type was invalidly declared, just ignore it. */
595 type = TREE_TYPE (decl);
596 if (TREE_CODE (type) == ERROR_MARK)
599 if (MAYBE_CLASS_TYPE_P (type))
601 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
602 || TREE_CODE (init) == CONSTRUCTOR);
604 if (TREE_CODE (init) == TREE_LIST)
606 error ("constructor syntax used, but no constructor declared "
607 "for type %qT", type);
608 init = build_constructor_from_list (init_list_type_node, nreverse (init));
611 else if (TREE_CODE (init) == TREE_LIST
612 && TREE_TYPE (init) != unknown_type_node)
614 if (TREE_CODE (decl) == RESULT_DECL)
615 init = build_x_compound_expr_from_list (init,
616 "return value initializer");
617 else if (TREE_CODE (init) == TREE_LIST
618 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
620 error ("cannot initialize arrays using this syntax");
624 /* We get here with code like `int a (2);' */
625 init = build_x_compound_expr_from_list (init, "initializer");
628 /* End of special C++ code. */
630 /* Digest the specified initializer into an expression. */
631 value = digest_init (type, init);
632 /* If the initializer is not a constant, fill in DECL_INITIAL with
633 the bits that are constant, and then return an expression that
634 will perform the dynamic initialization. */
635 if (value != error_mark_node
636 && (TREE_SIDE_EFFECTS (value)
637 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
638 return split_nonconstant_init (decl, value);
639 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
640 is an automatic variable, the middle end will turn this into a
641 dynamic initialization later. */
642 DECL_INITIAL (decl) = value;
647 /* Give errors about narrowing conversions within { }. */
650 check_narrowing (tree type, tree init)
652 tree ftype = unlowered_expr_type (init);
655 bool was_decl = false;
660 init = decl_constant_value (init);
663 if (TREE_CODE (type) == INTEGER_TYPE
664 && TREE_CODE (ftype) == REAL_TYPE)
666 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
667 && CP_INTEGRAL_TYPE_P (type))
669 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
670 && (TREE_CODE (init) != INTEGER_CST
671 || !int_fits_type_p (init, type)))
674 else if (TREE_CODE (ftype) == REAL_TYPE
675 && TREE_CODE (type) == REAL_TYPE)
677 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
679 if (TREE_CODE (init) == REAL_CST)
681 /* Issue 703: Loss of precision is OK as long as the value is
682 within the representable range of the new type. */
684 d = TREE_REAL_CST (init);
685 real_convert (&r, TYPE_MODE (type), &d);
693 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
694 && TREE_CODE (type) == REAL_TYPE)
697 if (TREE_CODE (init) == INTEGER_CST)
699 d = real_value_from_int_cst (0, init);
700 if (exact_real_truncate (TYPE_MODE (type), &d))
706 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
710 /* Process the initializer INIT for a variable of type TYPE, emitting
711 diagnostics for invalid initializers and converting the initializer as
714 For aggregate types, it assumes that reshape_init has already run, thus the
715 initializer will have the right shape (brace elision has been undone).
717 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
720 digest_init_r (tree type, tree init, bool nested)
722 enum tree_code code = TREE_CODE (type);
724 if (init == error_mark_node)
725 return error_mark_node;
729 /* We must strip the outermost array type when completing the type,
730 because the its bounds might be incomplete at the moment. */
731 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
732 ? TREE_TYPE (type) : type, NULL_TREE))
733 return error_mark_node;
735 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
736 (g++.old-deja/g++.law/casts2.C). */
737 if (TREE_CODE (init) == NON_LVALUE_EXPR)
738 init = TREE_OPERAND (init, 0);
740 /* Initialization of an array of chars from a string constant. The initializer
741 can be optionally enclosed in braces, but reshape_init has already removed
742 them if they were present. */
743 if (code == ARRAY_TYPE)
745 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
746 if (char_type_p (typ1)
748 && TREE_CODE (init) == STRING_CST)
750 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
752 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
754 if (char_type != char_type_node)
756 error ("char-array initialized from wide string");
757 return error_mark_node;
762 if (char_type == char_type_node)
764 error ("int-array initialized from non-wide string");
765 return error_mark_node;
767 else if (char_type != typ1)
769 error ("int-array initialized from incompatible wide string");
770 return error_mark_node;
774 TREE_TYPE (init) = type;
775 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
777 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
778 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
779 /* In C it is ok to subtract 1 from the length of the string
780 because it's ok to ignore the terminating null char that is
781 counted in the length of the constant, but in C++ this would
783 if (size < TREE_STRING_LENGTH (init))
784 permerror (input_location, "initializer-string for array of chars is too long");
790 /* Handle scalar types (including conversions) and references. */
791 if ((TREE_CODE (type) != COMPLEX_TYPE
792 || BRACE_ENCLOSED_INITIALIZER_P (init))
793 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
797 if (cxx_dialect != cxx98 && nested)
798 check_narrowing (type, init);
799 init = convert_for_initialization (0, type, init, LOOKUP_NORMAL,
800 "initialization", NULL_TREE, 0,
801 tf_warning_or_error);
804 /* Skip any conversions since we'll be outputting the underlying
806 while (CONVERT_EXPR_P (*exp)
807 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
808 exp = &TREE_OPERAND (*exp, 0);
810 *exp = cplus_expand_constant (*exp);
815 /* Come here only for aggregates: records, arrays, unions, complex numbers
817 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
818 || TREE_CODE (type) == VECTOR_TYPE
819 || TREE_CODE (type) == RECORD_TYPE
820 || TREE_CODE (type) == UNION_TYPE
821 || TREE_CODE (type) == COMPLEX_TYPE);
823 if (BRACE_ENCLOSED_INITIALIZER_P (init)
824 && !TYPE_NON_AGGREGATE_CLASS (type))
825 return process_init_constructor (type, init);
828 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
830 error ("cannot initialize aggregate of type %qT with "
831 "a compound literal", type);
833 return error_mark_node;
836 if (TREE_CODE (type) == ARRAY_TYPE
837 && TREE_CODE (init) != CONSTRUCTOR)
839 error ("array must be initialized with a brace-enclosed"
841 return error_mark_node;
844 return convert_for_initialization (NULL_TREE, type, init,
845 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING,
846 "initialization", NULL_TREE, 0,
847 tf_warning_or_error);
852 digest_init (tree type, tree init)
854 return digest_init_r (type, init, false);
857 /* Set of flags used within process_init_constructor to describe the
859 #define PICFLAG_ERRONEOUS 1
860 #define PICFLAG_NOT_ALL_CONSTANT 2
861 #define PICFLAG_NOT_ALL_SIMPLE 4
863 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
867 picflag_from_initializer (tree init)
869 if (init == error_mark_node)
870 return PICFLAG_ERRONEOUS;
871 else if (!TREE_CONSTANT (init))
872 return PICFLAG_NOT_ALL_CONSTANT;
873 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
874 return PICFLAG_NOT_ALL_SIMPLE;
878 /* Subroutine of process_init_constructor, which will process an initializer
879 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
880 which describe the initializers. */
883 process_init_constructor_array (tree type, tree init)
885 unsigned HOST_WIDE_INT i, len = 0;
887 bool unbounded = false;
889 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
891 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
892 || TREE_CODE (type) == VECTOR_TYPE);
894 if (TREE_CODE (type) == ARRAY_TYPE)
896 tree domain = TYPE_DOMAIN (type);
898 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
899 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
902 unbounded = true; /* Take as many as there are. */
905 /* Vectors are like simple fixed-size arrays. */
906 len = TYPE_VECTOR_SUBPARTS (type);
908 /* There cannot be more initializers than needed as otherwise
909 reshape_init would have already rejected the initializer. */
911 gcc_assert (VEC_length (constructor_elt, v) <= len);
913 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
917 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
918 if (compare_tree_int (ce->index, i) != 0)
920 ce->value = error_mark_node;
921 sorry ("non-trivial designated initializers not supported");
925 ce->index = size_int (i);
926 gcc_assert (ce->value);
927 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true);
929 if (ce->value != error_mark_node)
930 gcc_assert (same_type_ignoring_top_level_qualifiers_p
931 (TREE_TYPE (type), TREE_TYPE (ce->value)));
933 flags |= picflag_from_initializer (ce->value);
936 /* No more initializers. If the array is unbounded, we are done. Otherwise,
937 we must add initializers ourselves. */
943 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
945 /* If this type needs constructors run for default-initialization,
946 we can't rely on the back end to do it for us, so build up
947 TARGET_EXPRs. If the type in question is a class, just build
948 one up; if it's an array, recurse. */
949 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
950 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
951 tf_warning_or_error);
953 next = build_constructor (init_list_type_node, NULL);
954 next = digest_init (TREE_TYPE (type), next);
956 else if (!zero_init_p (TREE_TYPE (type)))
957 next = build_zero_init (TREE_TYPE (type),
959 /*static_storage_p=*/false);
961 /* The default zero-initialization is fine for us; don't
962 add anything to the CONSTRUCTOR. */
965 flags |= picflag_from_initializer (next);
966 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
969 CONSTRUCTOR_ELTS (init) = v;
973 /* Subroutine of process_init_constructor, which will process an initializer
974 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
978 process_init_constructor_record (tree type, tree init)
980 VEC(constructor_elt,gc) *v = NULL;
983 unsigned HOST_WIDE_INT idx = 0;
985 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
986 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
987 gcc_assert (!TYPE_BINFO (type)
988 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
989 gcc_assert (!TYPE_POLYMORPHIC_P (type));
991 /* Generally, we will always have an index for each initializer (which is
992 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
993 reshape_init. So we need to handle both cases. */
994 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
999 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1001 flags |= picflag_from_initializer (integer_zero_node);
1002 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1006 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1009 /* If this is a bitfield, first convert to the declared type. */
1010 type = TREE_TYPE (field);
1011 if (DECL_BIT_FIELD_TYPE (field))
1012 type = DECL_BIT_FIELD_TYPE (field);
1014 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1016 constructor_elt *ce = VEC_index (constructor_elt,
1017 CONSTRUCTOR_ELTS (init), idx);
1020 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1021 latter case can happen in templates where lookup has to be
1023 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1024 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1025 if (ce->index != field
1026 && ce->index != DECL_NAME (field))
1028 ce->value = error_mark_node;
1029 sorry ("non-trivial designated initializers not supported");
1033 gcc_assert (ce->value);
1034 next = digest_init_r (type, ce->value, true);
1037 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1039 /* If this type needs constructors run for
1040 default-initialization, we can't rely on the back end to do it
1041 for us, so build up TARGET_EXPRs. If the type in question is
1042 a class, just build one up; if it's an array, recurse. */
1043 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1044 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1045 tf_warning_or_error);
1047 next = build_constructor (init_list_type_node, NULL);
1049 next = digest_init_r (TREE_TYPE (field), next, true);
1051 /* Warn when some struct elements are implicitly initialized. */
1052 warning (OPT_Wmissing_field_initializers,
1053 "missing initializer for member %qD", field);
1057 if (TREE_READONLY (field))
1058 error ("uninitialized const member %qD", field);
1059 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1060 error ("member %qD with uninitialized const fields", field);
1061 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1062 error ("member %qD is uninitialized reference", field);
1064 /* Warn when some struct elements are implicitly initialized
1066 warning (OPT_Wmissing_field_initializers,
1067 "missing initializer for member %qD", field);
1069 if (!zero_init_p (TREE_TYPE (field)))
1070 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1071 /*static_storage_p=*/false);
1073 /* The default zero-initialization is fine for us; don't
1074 add anything to the CONSTRUCTOR. */
1078 /* If this is a bitfield, now convert to the lowered type. */
1079 if (type != TREE_TYPE (field))
1080 next = cp_convert_and_check (TREE_TYPE (field), next);
1081 flags |= picflag_from_initializer (next);
1082 CONSTRUCTOR_APPEND_ELT (v, field, next);
1085 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1086 error ("too many initializers for %qT", type);
1088 CONSTRUCTOR_ELTS (init) = v;
1092 /* Subroutine of process_init_constructor, which will process a single
1093 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1094 which describe the initializer. */
1097 process_init_constructor_union (tree type, tree init)
1099 constructor_elt *ce;
1102 /* If the initializer was empty, use default zero initialization. */
1103 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1106 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1109 error ("too many initializers for %qT", type);
1110 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1113 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1115 /* If this element specifies a field, initialize via that field. */
1118 if (TREE_CODE (ce->index) == FIELD_DECL)
1120 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1122 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1123 tree name = ce->index;
1125 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1126 if (DECL_NAME (field) == name)
1130 error ("no field %qD found in union being initialized", field);
1131 ce->value = error_mark_node;
1137 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1138 || TREE_CODE (ce->index) == RANGE_EXPR);
1139 error ("index value instead of field name in union initializer");
1140 ce->value = error_mark_node;
1145 /* Find the first named field. ANSI decided in September 1990
1146 that only named fields count here. */
1147 tree field = TYPE_FIELDS (type);
1148 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1149 field = TREE_CHAIN (field);
1150 if (field == NULL_TREE)
1152 error ("too many initializers for %qT", type);
1153 ce->value = error_mark_node;
1158 if (ce->value && ce->value != error_mark_node)
1159 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true);
1161 return picflag_from_initializer (ce->value);
1164 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1165 constructor is a brace-enclosed initializer, and will be modified in-place.
1167 Each element is converted to the right type through digest_init, and
1168 missing initializers are added following the language rules (zero-padding,
1171 After the execution, the initializer will have TREE_CONSTANT if all elts are
1172 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1173 constants that the assembler and linker can compute them.
1175 The function returns the initializer itself, or error_mark_node in case
1179 process_init_constructor (tree type, tree init)
1183 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1185 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1186 flags = process_init_constructor_array (type, init);
1187 else if (TREE_CODE (type) == RECORD_TYPE)
1188 flags = process_init_constructor_record (type, init);
1189 else if (TREE_CODE (type) == UNION_TYPE)
1190 flags = process_init_constructor_union (type, init);
1194 if (flags & PICFLAG_ERRONEOUS)
1195 return error_mark_node;
1197 TREE_TYPE (init) = type;
1198 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1199 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1200 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1202 TREE_CONSTANT (init) = 1;
1203 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1204 TREE_STATIC (init) = 1;
1209 /* Given a structure or union value DATUM, construct and return
1210 the structure or union component which results from narrowing
1211 that value to the base specified in BASETYPE. For example, given the
1214 class L { int ii; };
1215 class A : L { ... };
1216 class B : L { ... };
1217 class C : A, B { ... };
1225 x.A::ii refers to the ii member of the L part of
1226 the A part of the C object named by X. In this case,
1227 DATUM would be x, and BASETYPE would be A.
1229 I used to think that this was nonconformant, that the standard specified
1230 that first we look up ii in A, then convert x to an L& and pull out the
1231 ii part. But in fact, it does say that we convert x to an A&; A here
1232 is known as the "naming class". (jason 2000-12-19)
1234 BINFO_P points to a variable initialized either to NULL_TREE or to the
1235 binfo for the specific base subobject we want to convert to. */
1238 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1242 if (datum == error_mark_node)
1243 return error_mark_node;
1247 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1249 if (!binfo || binfo == error_mark_node)
1251 *binfo_p = NULL_TREE;
1253 error_not_base_type (basetype, TREE_TYPE (datum));
1254 return error_mark_node;
1258 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1261 /* Build a reference to an object specified by the C++ `->' operator.
1262 Usually this just involves dereferencing the object, but if the
1263 `->' operator is overloaded, then such overloads must be
1264 performed until an object which does not have the `->' operator
1265 overloaded is found. An error is reported when circular pointer
1266 delegation is detected. */
1269 build_x_arrow (tree expr)
1271 tree orig_expr = expr;
1272 tree types_memoized = NULL_TREE;
1273 tree type = TREE_TYPE (expr);
1274 tree last_rval = NULL_TREE;
1276 if (type == error_mark_node)
1277 return error_mark_node;
1279 if (processing_template_decl)
1281 if (type_dependent_expression_p (expr))
1282 return build_min_nt (ARROW_EXPR, expr);
1283 expr = build_non_dependent_expr (expr);
1286 if (MAYBE_CLASS_TYPE_P (type))
1288 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1289 NULL_TREE, NULL_TREE,
1290 /*overloaded_p=*/NULL,
1291 tf_warning_or_error)))
1293 if (expr == error_mark_node)
1294 return error_mark_node;
1296 if (value_member (TREE_TYPE (expr), types_memoized))
1298 error ("circular pointer delegation detected");
1299 return error_mark_node;
1303 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1309 if (last_rval == NULL_TREE)
1311 error ("base operand of %<->%> has non-pointer type %qT", type);
1312 return error_mark_node;
1315 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1316 last_rval = convert_from_reference (last_rval);
1319 last_rval = decay_conversion (expr);
1321 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1323 if (processing_template_decl)
1325 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1326 /* It will be dereferenced. */
1327 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1331 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1335 error ("result of %<operator->()%> yields non-pointer result");
1337 error ("base operand of %<->%> is not a pointer");
1338 return error_mark_node;
1341 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1342 already been checked out to be of aggregate type. */
1345 build_m_component_ref (tree datum, tree component)
1353 if (error_operand_p (datum) || error_operand_p (component))
1354 return error_mark_node;
1356 ptrmem_type = TREE_TYPE (component);
1357 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1359 error ("%qE cannot be used as a member pointer, since it is of "
1361 component, ptrmem_type);
1362 return error_mark_node;
1365 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1366 if (! MAYBE_CLASS_TYPE_P (objtype))
1368 error ("cannot apply member pointer %qE to %qE, which is of "
1369 "non-class type %qT",
1370 component, datum, objtype);
1371 return error_mark_node;
1374 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1375 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1377 if (!COMPLETE_TYPE_P (ctype))
1379 if (!same_type_p (ctype, objtype))
1385 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1390 error ("pointer to member type %qT incompatible with object "
1393 return error_mark_node;
1395 else if (binfo == error_mark_node)
1396 return error_mark_node;
1399 if (TYPE_PTRMEM_P (ptrmem_type))
1403 /* Compute the type of the field, as described in [expr.ref].
1404 There's no such thing as a mutable pointer-to-member, so
1405 things are not as complex as they are for references to
1406 non-static data members. */
1407 type = cp_build_qualified_type (type,
1408 (cp_type_quals (type)
1409 | cp_type_quals (TREE_TYPE (datum))));
1411 datum = build_address (datum);
1413 /* Convert object to the correct base. */
1415 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1417 /* Build an expression for "object + offset" where offset is the
1418 value stored in the pointer-to-data-member. */
1419 ptype = build_pointer_type (type);
1420 datum = build2 (POINTER_PLUS_EXPR, ptype,
1421 fold_convert (ptype, datum),
1422 build_nop (sizetype, component));
1423 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1426 return build2 (OFFSET_REF, type, datum, component);
1429 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1432 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1434 /* This is either a call to a constructor,
1435 or a C cast in C++'s `functional' notation. */
1437 /* The type to which we are casting. */
1440 if (exp == error_mark_node || parms == error_mark_node)
1441 return error_mark_node;
1443 if (TREE_CODE (exp) == TYPE_DECL)
1444 type = TREE_TYPE (exp);
1448 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1450 error ("invalid value-initialization of reference types");
1451 return error_mark_node;
1454 if (processing_template_decl)
1456 tree t = build_min (CAST_EXPR, type, parms);
1457 /* We don't know if it will or will not have side effects. */
1458 TREE_SIDE_EFFECTS (t) = 1;
1462 if (! MAYBE_CLASS_TYPE_P (type))
1464 if (parms == NULL_TREE)
1465 return cp_convert (type, integer_zero_node);
1467 /* This must build a C cast. */
1468 parms = build_x_compound_expr_from_list (parms, "functional cast");
1469 return cp_build_c_cast (type, parms, complain);
1472 /* Prepare to evaluate as a call to a constructor. If this expression
1473 is actually used, for example,
1475 return X (arg1, arg2, ...);
1477 then the slot being initialized will be filled in. */
1479 if (!complete_type_or_else (type, NULL_TREE))
1480 return error_mark_node;
1481 if (abstract_virtuals_error (NULL_TREE, type))
1482 return error_mark_node;
1486 If the expression list is a single-expression, the type
1487 conversion is equivalent (in definedness, and if defined in
1488 meaning) to the corresponding cast expression. */
1489 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1490 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1494 The expression T(), where T is a simple-type-specifier for a
1495 non-array complete object type or the (possibly cv-qualified)
1496 void type, creates an rvalue of the specified type, which is
1497 value-initialized. */
1499 if (parms == NULL_TREE
1500 /* If there's a user-defined constructor, value-initialization is
1501 just calling the constructor, so fall through. */
1502 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1504 exp = build_value_init (type);
1505 return get_target_expr (exp);
1508 /* Call the constructor. */
1509 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1510 type, LOOKUP_NORMAL, complain);
1512 if (exp == error_mark_node)
1513 return error_mark_node;
1515 return build_cplus_new (type, exp);
1519 /* Add new exception specifier SPEC, to the LIST we currently have.
1520 If it's already in LIST then do nothing.
1521 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1522 know what we're doing. */
1525 add_exception_specifier (tree list, tree spec, int complain)
1530 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1532 if (spec == error_mark_node)
1535 gcc_assert (spec && (!list || TREE_VALUE (list)));
1537 /* [except.spec] 1, type in an exception specifier shall not be
1538 incomplete, or pointer or ref to incomplete other than pointer
1540 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1541 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1542 core = TREE_TYPE (core);
1545 else if (VOID_TYPE_P (core))
1547 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1549 else if (processing_template_decl)
1554 /* 15.4/1 says that types in an exception specifier must be complete,
1555 but it seems more reasonable to only require this on definitions
1556 and calls. So just give a pedwarn at this point; we will give an
1557 error later if we hit one of those two cases. */
1558 if (!COMPLETE_TYPE_P (complete_type (core)))
1559 diag_type = DK_PEDWARN; /* pedwarn */
1566 for (probe = list; probe; probe = TREE_CHAIN (probe))
1567 if (same_type_p (TREE_VALUE (probe), spec))
1570 list = tree_cons (NULL_TREE, spec, list);
1573 diag_type = DK_ERROR; /* error */
1575 if (diag_type != DK_UNSPECIFIED && complain)
1576 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1581 /* Combine the two exceptions specifier lists LIST and ADD, and return
1585 merge_exception_specifiers (tree list, tree add)
1589 else if (!TREE_VALUE (list))
1591 else if (!TREE_VALUE (add))
1595 tree orig_list = list;
1597 for (; add; add = TREE_CHAIN (add))
1599 tree spec = TREE_VALUE (add);
1602 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1603 if (same_type_p (TREE_VALUE (probe), spec))
1607 spec = build_tree_list (NULL_TREE, spec);
1608 TREE_CHAIN (spec) = list;
1616 /* Subroutine of build_call. Ensure that each of the types in the
1617 exception specification is complete. Technically, 15.4/1 says that
1618 they need to be complete when we see a declaration of the function,
1619 but we should be able to get away with only requiring this when the
1620 function is defined or called. See also add_exception_specifier. */
1623 require_complete_eh_spec_types (tree fntype, tree decl)
1626 /* Don't complain about calls to op new. */
1627 if (decl && DECL_ARTIFICIAL (decl))
1629 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1630 raises = TREE_CHAIN (raises))
1632 tree type = TREE_VALUE (raises);
1633 if (type && !COMPLETE_TYPE_P (type))
1637 ("call to function %qD which throws incomplete type %q#T",
1640 error ("call to function which throws incomplete type %q#T",
1647 #include "gt-cp-typeck2.h"