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 (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
316 " because the following virtual functions are pure within %qT:",
319 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
320 inform (input_location, "\t%+#D", fn);
321 /* Now truncate the vector. This leaves it non-null, so we know
322 there are pure virtuals, but empty so we don't list them out
324 VEC_truncate (tree, pure, 0);
327 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
328 " since type %qT has pure virtual functions",
334 /* Print an error message for invalid use of an incomplete type.
335 VALUE is the expression that was used (or 0 if that isn't known)
336 and TYPE is the type that was invalid. DIAG_KIND indicates the
337 type of diagnostic (see diagnostic.def). */
340 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
341 diagnostic_t diag_kind)
345 gcc_assert (diag_kind == DK_WARNING
346 || diag_kind == DK_PEDWARN
347 || diag_kind == DK_ERROR);
349 /* Avoid duplicate error message. */
350 if (TREE_CODE (type) == ERROR_MARK)
353 if (value != 0 && (TREE_CODE (value) == VAR_DECL
354 || TREE_CODE (value) == PARM_DECL
355 || TREE_CODE (value) == FIELD_DECL))
357 emit_diagnostic (diag_kind, input_location, 0,
358 "%q+D has incomplete type", value);
362 /* We must print an error message. Be clever about what it says. */
364 switch (TREE_CODE (type))
370 emit_diagnostic (diag_kind, input_location, 0,
371 "invalid use of incomplete type %q#T", type);
372 if (!TYPE_TEMPLATE_INFO (type))
373 emit_diagnostic (diag_kind, input_location, 0,
374 "forward declaration of %q+#T", type);
376 emit_diagnostic (diag_kind, input_location, 0,
377 "declaration of %q+#T", type);
381 emit_diagnostic (diag_kind, input_location, 0,
382 "invalid use of %qT", type);
386 if (TYPE_DOMAIN (type))
388 type = TREE_TYPE (type);
391 emit_diagnostic (diag_kind, input_location, 0,
392 "invalid use of array with unspecified bounds");
397 emit_diagnostic (diag_kind, input_location, 0,
398 "invalid use of member (did you forget the %<&%> ?)");
401 case TEMPLATE_TYPE_PARM:
403 emit_diagnostic (diag_kind, input_location, 0,
404 "invalid use of %<auto%>");
406 emit_diagnostic (diag_kind, input_location, 0,
407 "invalid use of template type parameter %qT", type);
410 case BOUND_TEMPLATE_TEMPLATE_PARM:
411 emit_diagnostic (diag_kind, input_location, 0,
412 "invalid use of template template parameter %qT",
417 emit_diagnostic (diag_kind, input_location, 0,
418 "invalid use of dependent type %qT", type);
422 if (value && TREE_CODE (value) == COMPONENT_REF)
424 else if (value && TREE_CODE (value) == ADDR_EXPR)
425 emit_diagnostic (diag_kind, input_location, 0,
426 "address of overloaded function with no contextual "
428 else if (value && TREE_CODE (value) == OVERLOAD)
429 emit_diagnostic (diag_kind, input_location, 0,
430 "overloaded function with no contextual type information");
432 emit_diagnostic (diag_kind, input_location, 0,
433 "insufficient contextual information to determine type");
441 /* Backward-compatibility interface to incomplete_type_diagnostic;
442 required by ../tree.c. */
443 #undef cxx_incomplete_type_error
445 cxx_incomplete_type_error (const_tree value, const_tree type)
447 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
451 /* The recursive part of split_nonconstant_init. DEST is an lvalue
452 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
455 split_nonconstant_init_1 (tree dest, tree init)
457 unsigned HOST_WIDE_INT idx;
458 tree field_index, value;
459 tree type = TREE_TYPE (dest);
460 tree inner_type = NULL;
461 bool array_type_p = false;
463 switch (TREE_CODE (type))
466 inner_type = TREE_TYPE (type);
472 case QUAL_UNION_TYPE:
473 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
476 /* The current implementation of this algorithm assumes that
477 the field was set for all the elements. This is usually done
478 by process_init_constructor. */
479 gcc_assert (field_index);
482 inner_type = TREE_TYPE (field_index);
484 if (TREE_CODE (value) == CONSTRUCTOR)
489 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
490 NULL_TREE, NULL_TREE);
492 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
495 split_nonconstant_init_1 (sub, value);
497 else if (!initializer_constant_valid_p (value, inner_type))
502 /* FIXME: Ordered removal is O(1) so the whole function is
503 worst-case quadratic. This could be fixed using an aside
504 bitmap to record which elements must be removed and remove
505 them all at the same time. Or by merging
506 split_non_constant_init into process_init_constructor_array,
507 that is separating constants from non-constants while building
509 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
514 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
515 NULL_TREE, NULL_TREE);
517 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
520 code = build2 (INIT_EXPR, inner_type, sub, value);
521 code = build_stmt (input_location, EXPR_STMT, code);
529 if (!initializer_constant_valid_p (init, type))
532 tree cons = copy_node (init);
533 CONSTRUCTOR_ELTS (init) = NULL;
534 code = build2 (MODIFY_EXPR, type, dest, cons);
535 code = build_stmt (input_location, EXPR_STMT, code);
544 /* The rest of the initializer is now a constant. */
545 TREE_CONSTANT (init) = 1;
548 /* A subroutine of store_init_value. Splits non-constant static
549 initializer INIT into a constant part and generates code to
550 perform the non-constant part of the initialization to DEST.
551 Returns the code for the runtime init. */
554 split_nonconstant_init (tree dest, tree init)
558 if (TREE_CODE (init) == CONSTRUCTOR)
560 code = push_stmt_list ();
561 split_nonconstant_init_1 (dest, init);
562 code = pop_stmt_list (code);
563 DECL_INITIAL (dest) = init;
564 TREE_READONLY (dest) = 0;
567 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
572 /* Perform appropriate conversions on the initial value of a variable,
573 store it in the declaration DECL,
574 and print any error messages that are appropriate.
575 If the init is invalid, store an ERROR_MARK.
577 C++: Note that INIT might be a TREE_LIST, which would mean that it is
578 a base class initializer for some aggregate type, hopefully compatible
579 with DECL. If INIT is a single element, and DECL is an aggregate
580 type, we silently convert INIT into a TREE_LIST, allowing a constructor
583 If INIT is a TREE_LIST and there is no constructor, turn INIT
584 into a CONSTRUCTOR and use standard initialization techniques.
585 Perhaps a warning should be generated?
587 Returns code to be executed if initialization could not be performed
588 for static variable. In that case, caller must emit the code. */
591 store_init_value (tree decl, tree init, int flags)
595 /* If variable's type was invalidly declared, just ignore it. */
597 type = TREE_TYPE (decl);
598 if (TREE_CODE (type) == ERROR_MARK)
601 if (MAYBE_CLASS_TYPE_P (type))
603 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
604 || TREE_CODE (init) == CONSTRUCTOR);
606 if (TREE_CODE (init) == TREE_LIST)
608 error ("constructor syntax used, but no constructor declared "
609 "for type %qT", type);
610 init = build_constructor_from_list (init_list_type_node, nreverse (init));
613 else if (TREE_CODE (init) == TREE_LIST
614 && TREE_TYPE (init) != unknown_type_node)
616 if (TREE_CODE (decl) == RESULT_DECL)
617 init = build_x_compound_expr_from_list (init,
618 "return value initializer");
619 else if (TREE_CODE (init) == TREE_LIST
620 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
622 error ("cannot initialize arrays using this syntax");
626 /* We get here with code like `int a (2);' */
627 init = build_x_compound_expr_from_list (init, "initializer");
630 /* End of special C++ code. */
632 /* Digest the specified initializer into an expression. */
633 value = digest_init_flags (type, init, flags);
634 /* If the initializer is not a constant, fill in DECL_INITIAL with
635 the bits that are constant, and then return an expression that
636 will perform the dynamic initialization. */
637 if (value != error_mark_node
638 && (TREE_SIDE_EFFECTS (value)
639 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
640 return split_nonconstant_init (decl, value);
641 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
642 is an automatic variable, the middle end will turn this into a
643 dynamic initialization later. */
644 DECL_INITIAL (decl) = value;
649 /* Give errors about narrowing conversions within { }. */
652 check_narrowing (tree type, tree init)
654 tree ftype = unlowered_expr_type (init);
657 bool was_decl = false;
662 init = decl_constant_value (init);
665 if (TREE_CODE (type) == INTEGER_TYPE
666 && TREE_CODE (ftype) == REAL_TYPE)
668 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
669 && CP_INTEGRAL_TYPE_P (type))
671 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
672 && (TREE_CODE (init) != INTEGER_CST
673 || !int_fits_type_p (init, type)))
676 else if (TREE_CODE (ftype) == REAL_TYPE
677 && TREE_CODE (type) == REAL_TYPE)
679 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
681 if (TREE_CODE (init) == REAL_CST)
683 /* Issue 703: Loss of precision is OK as long as the value is
684 within the representable range of the new type. */
686 d = TREE_REAL_CST (init);
687 real_convert (&r, TYPE_MODE (type), &d);
695 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
696 && TREE_CODE (type) == REAL_TYPE)
699 if (TREE_CODE (init) == INTEGER_CST)
701 d = real_value_from_int_cst (0, init);
702 if (exact_real_truncate (TYPE_MODE (type), &d))
708 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
712 /* Process the initializer INIT for a variable of type TYPE, emitting
713 diagnostics for invalid initializers and converting the initializer as
716 For aggregate types, it assumes that reshape_init has already run, thus the
717 initializer will have the right shape (brace elision has been undone).
719 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
722 digest_init_r (tree type, tree init, bool nested, int flags)
724 enum tree_code code = TREE_CODE (type);
726 if (init == error_mark_node)
727 return error_mark_node;
731 /* We must strip the outermost array type when completing the type,
732 because the its bounds might be incomplete at the moment. */
733 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
734 ? TREE_TYPE (type) : type, NULL_TREE))
735 return error_mark_node;
737 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
738 (g++.old-deja/g++.law/casts2.C). */
739 if (TREE_CODE (init) == NON_LVALUE_EXPR)
740 init = TREE_OPERAND (init, 0);
742 /* Initialization of an array of chars from a string constant. The initializer
743 can be optionally enclosed in braces, but reshape_init has already removed
744 them if they were present. */
745 if (code == ARRAY_TYPE)
747 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
748 if (char_type_p (typ1)
750 && TREE_CODE (init) == STRING_CST)
752 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
754 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
756 if (char_type != char_type_node)
758 error ("char-array initialized from wide string");
759 return error_mark_node;
764 if (char_type == char_type_node)
766 error ("int-array initialized from non-wide string");
767 return error_mark_node;
769 else if (char_type != typ1)
771 error ("int-array initialized from incompatible wide string");
772 return error_mark_node;
776 TREE_TYPE (init) = type;
777 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
779 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
780 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
781 /* In C it is ok to subtract 1 from the length of the string
782 because it's ok to ignore the terminating null char that is
783 counted in the length of the constant, but in C++ this would
785 if (size < TREE_STRING_LENGTH (init))
786 permerror (input_location, "initializer-string for array of chars is too long");
792 /* Handle scalar types (including conversions) and references. */
793 if ((TREE_CODE (type) != COMPLEX_TYPE
794 || BRACE_ENCLOSED_INITIALIZER_P (init))
795 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
799 if (cxx_dialect != cxx98 && nested)
800 check_narrowing (type, init);
801 init = convert_for_initialization (0, type, init, flags,
802 "initialization", NULL_TREE, 0,
803 tf_warning_or_error);
806 /* Skip any conversions since we'll be outputting the underlying
808 while (CONVERT_EXPR_P (*exp)
809 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
810 exp = &TREE_OPERAND (*exp, 0);
812 *exp = cplus_expand_constant (*exp);
817 /* Come here only for aggregates: records, arrays, unions, complex numbers
819 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
820 || TREE_CODE (type) == VECTOR_TYPE
821 || TREE_CODE (type) == RECORD_TYPE
822 || TREE_CODE (type) == UNION_TYPE
823 || TREE_CODE (type) == COMPLEX_TYPE);
825 if (BRACE_ENCLOSED_INITIALIZER_P (init)
826 && !TYPE_NON_AGGREGATE_CLASS (type))
827 return process_init_constructor (type, init);
830 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
832 error ("cannot initialize aggregate of type %qT with "
833 "a compound literal", type);
835 return error_mark_node;
838 if (TREE_CODE (type) == ARRAY_TYPE
839 && TREE_CODE (init) != CONSTRUCTOR)
841 error ("array must be initialized with a brace-enclosed"
843 return error_mark_node;
846 return convert_for_initialization (NULL_TREE, type, init,
848 "initialization", NULL_TREE, 0,
849 tf_warning_or_error);
854 digest_init (tree type, tree init)
856 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
860 digest_init_flags (tree type, tree init, int flags)
862 return digest_init_r (type, init, false, flags);
865 /* Set of flags used within process_init_constructor to describe the
867 #define PICFLAG_ERRONEOUS 1
868 #define PICFLAG_NOT_ALL_CONSTANT 2
869 #define PICFLAG_NOT_ALL_SIMPLE 4
871 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
875 picflag_from_initializer (tree init)
877 if (init == error_mark_node)
878 return PICFLAG_ERRONEOUS;
879 else if (!TREE_CONSTANT (init))
880 return PICFLAG_NOT_ALL_CONSTANT;
881 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
882 return PICFLAG_NOT_ALL_SIMPLE;
886 /* Subroutine of process_init_constructor, which will process an initializer
887 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
888 which describe the initializers. */
891 process_init_constructor_array (tree type, tree init)
893 unsigned HOST_WIDE_INT i, len = 0;
895 bool unbounded = false;
897 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
899 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
900 || TREE_CODE (type) == VECTOR_TYPE);
902 if (TREE_CODE (type) == ARRAY_TYPE)
904 tree domain = TYPE_DOMAIN (type);
906 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
907 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
910 unbounded = true; /* Take as many as there are. */
913 /* Vectors are like simple fixed-size arrays. */
914 len = TYPE_VECTOR_SUBPARTS (type);
916 /* There must not be more initializers than needed. */
917 if (!unbounded && VEC_length (constructor_elt, v) > len)
918 error ("too many initializers for %qT", type);
920 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
924 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
925 if (compare_tree_int (ce->index, i) != 0)
927 ce->value = error_mark_node;
928 sorry ("non-trivial designated initializers not supported");
932 ce->index = size_int (i);
933 gcc_assert (ce->value);
934 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
936 if (ce->value != error_mark_node)
937 gcc_assert (same_type_ignoring_top_level_qualifiers_p
938 (TREE_TYPE (type), TREE_TYPE (ce->value)));
940 flags |= picflag_from_initializer (ce->value);
943 /* No more initializers. If the array is unbounded, we are done. Otherwise,
944 we must add initializers ourselves. */
950 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
952 /* If this type needs constructors run for default-initialization,
953 we can't rely on the back end to do it for us, so build up
954 TARGET_EXPRs. If the type in question is a class, just build
955 one up; if it's an array, recurse. */
956 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
957 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
958 tf_warning_or_error);
960 next = build_constructor (init_list_type_node, NULL);
961 next = digest_init (TREE_TYPE (type), next);
963 else if (!zero_init_p (TREE_TYPE (type)))
964 next = build_zero_init (TREE_TYPE (type),
966 /*static_storage_p=*/false);
968 /* The default zero-initialization is fine for us; don't
969 add anything to the CONSTRUCTOR. */
972 flags |= picflag_from_initializer (next);
973 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
976 CONSTRUCTOR_ELTS (init) = v;
980 /* Subroutine of process_init_constructor, which will process an initializer
981 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
985 process_init_constructor_record (tree type, tree init)
987 VEC(constructor_elt,gc) *v = NULL;
990 unsigned HOST_WIDE_INT idx = 0;
992 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
993 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
994 gcc_assert (!TYPE_BINFO (type)
995 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
996 gcc_assert (!TYPE_POLYMORPHIC_P (type));
998 /* Generally, we will always have an index for each initializer (which is
999 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1000 reshape_init. So we need to handle both cases. */
1001 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1006 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1008 flags |= picflag_from_initializer (integer_zero_node);
1009 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1013 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1016 /* If this is a bitfield, first convert to the declared type. */
1017 type = TREE_TYPE (field);
1018 if (DECL_BIT_FIELD_TYPE (field))
1019 type = DECL_BIT_FIELD_TYPE (field);
1021 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1023 constructor_elt *ce = VEC_index (constructor_elt,
1024 CONSTRUCTOR_ELTS (init), idx);
1027 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1028 latter case can happen in templates where lookup has to be
1030 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1031 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1032 if (ce->index != field
1033 && ce->index != DECL_NAME (field))
1035 ce->value = error_mark_node;
1036 sorry ("non-trivial designated initializers not supported");
1040 gcc_assert (ce->value);
1041 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1044 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1046 /* If this type needs constructors run for
1047 default-initialization, we can't rely on the back end to do it
1048 for us, so build up TARGET_EXPRs. If the type in question is
1049 a class, just build one up; if it's an array, recurse. */
1050 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1051 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1052 tf_warning_or_error);
1054 next = build_constructor (init_list_type_node, NULL);
1056 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1058 /* Warn when some struct elements are implicitly initialized. */
1059 warning (OPT_Wmissing_field_initializers,
1060 "missing initializer for member %qD", field);
1064 if (TREE_READONLY (field))
1065 error ("uninitialized const member %qD", field);
1066 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1067 error ("member %qD with uninitialized const fields", field);
1068 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1069 error ("member %qD is uninitialized reference", field);
1071 /* Warn when some struct elements are implicitly initialized
1073 warning (OPT_Wmissing_field_initializers,
1074 "missing initializer for member %qD", field);
1076 if (!zero_init_p (TREE_TYPE (field)))
1077 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1078 /*static_storage_p=*/false);
1080 /* The default zero-initialization is fine for us; don't
1081 add anything to the CONSTRUCTOR. */
1085 /* If this is a bitfield, now convert to the lowered type. */
1086 if (type != TREE_TYPE (field))
1087 next = cp_convert_and_check (TREE_TYPE (field), next);
1088 flags |= picflag_from_initializer (next);
1089 CONSTRUCTOR_APPEND_ELT (v, field, next);
1092 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1093 error ("too many initializers for %qT", type);
1095 CONSTRUCTOR_ELTS (init) = v;
1099 /* Subroutine of process_init_constructor, which will process a single
1100 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1101 which describe the initializer. */
1104 process_init_constructor_union (tree type, tree init)
1106 constructor_elt *ce;
1109 /* If the initializer was empty, use default zero initialization. */
1110 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1113 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1116 error ("too many initializers for %qT", type);
1117 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1120 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1122 /* If this element specifies a field, initialize via that field. */
1125 if (TREE_CODE (ce->index) == FIELD_DECL)
1127 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1129 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1130 tree name = ce->index;
1132 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1133 if (DECL_NAME (field) == name)
1137 error ("no field %qD found in union being initialized", field);
1138 ce->value = error_mark_node;
1144 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1145 || TREE_CODE (ce->index) == RANGE_EXPR);
1146 error ("index value instead of field name in union initializer");
1147 ce->value = error_mark_node;
1152 /* Find the first named field. ANSI decided in September 1990
1153 that only named fields count here. */
1154 tree field = TYPE_FIELDS (type);
1155 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1156 field = TREE_CHAIN (field);
1157 if (field == NULL_TREE)
1159 error ("too many initializers for %qT", type);
1160 ce->value = error_mark_node;
1165 if (ce->value && ce->value != error_mark_node)
1166 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1168 return picflag_from_initializer (ce->value);
1171 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1172 constructor is a brace-enclosed initializer, and will be modified in-place.
1174 Each element is converted to the right type through digest_init, and
1175 missing initializers are added following the language rules (zero-padding,
1178 After the execution, the initializer will have TREE_CONSTANT if all elts are
1179 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1180 constants that the assembler and linker can compute them.
1182 The function returns the initializer itself, or error_mark_node in case
1186 process_init_constructor (tree type, tree init)
1190 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1192 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1193 flags = process_init_constructor_array (type, init);
1194 else if (TREE_CODE (type) == RECORD_TYPE)
1195 flags = process_init_constructor_record (type, init);
1196 else if (TREE_CODE (type) == UNION_TYPE)
1197 flags = process_init_constructor_union (type, init);
1201 if (flags & PICFLAG_ERRONEOUS)
1202 return error_mark_node;
1204 TREE_TYPE (init) = type;
1205 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1206 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1207 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1209 TREE_CONSTANT (init) = 1;
1210 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1211 TREE_STATIC (init) = 1;
1216 /* Given a structure or union value DATUM, construct and return
1217 the structure or union component which results from narrowing
1218 that value to the base specified in BASETYPE. For example, given the
1221 class L { int ii; };
1222 class A : L { ... };
1223 class B : L { ... };
1224 class C : A, B { ... };
1232 x.A::ii refers to the ii member of the L part of
1233 the A part of the C object named by X. In this case,
1234 DATUM would be x, and BASETYPE would be A.
1236 I used to think that this was nonconformant, that the standard specified
1237 that first we look up ii in A, then convert x to an L& and pull out the
1238 ii part. But in fact, it does say that we convert x to an A&; A here
1239 is known as the "naming class". (jason 2000-12-19)
1241 BINFO_P points to a variable initialized either to NULL_TREE or to the
1242 binfo for the specific base subobject we want to convert to. */
1245 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1249 if (datum == error_mark_node)
1250 return error_mark_node;
1254 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1256 if (!binfo || binfo == error_mark_node)
1258 *binfo_p = NULL_TREE;
1260 error_not_base_type (basetype, TREE_TYPE (datum));
1261 return error_mark_node;
1265 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1268 /* Build a reference to an object specified by the C++ `->' operator.
1269 Usually this just involves dereferencing the object, but if the
1270 `->' operator is overloaded, then such overloads must be
1271 performed until an object which does not have the `->' operator
1272 overloaded is found. An error is reported when circular pointer
1273 delegation is detected. */
1276 build_x_arrow (tree expr)
1278 tree orig_expr = expr;
1279 tree types_memoized = NULL_TREE;
1280 tree type = TREE_TYPE (expr);
1281 tree last_rval = NULL_TREE;
1283 if (type == error_mark_node)
1284 return error_mark_node;
1286 if (processing_template_decl)
1288 if (type_dependent_expression_p (expr))
1289 return build_min_nt (ARROW_EXPR, expr);
1290 expr = build_non_dependent_expr (expr);
1293 if (MAYBE_CLASS_TYPE_P (type))
1295 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1296 NULL_TREE, NULL_TREE,
1297 /*overloaded_p=*/NULL,
1298 tf_warning_or_error)))
1300 if (expr == error_mark_node)
1301 return error_mark_node;
1303 if (value_member (TREE_TYPE (expr), types_memoized))
1305 error ("circular pointer delegation detected");
1306 return error_mark_node;
1310 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1316 if (last_rval == NULL_TREE)
1318 error ("base operand of %<->%> has non-pointer type %qT", type);
1319 return error_mark_node;
1322 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1323 last_rval = convert_from_reference (last_rval);
1326 last_rval = decay_conversion (expr);
1328 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1330 if (processing_template_decl)
1332 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1333 /* It will be dereferenced. */
1334 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1338 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1342 error ("result of %<operator->()%> yields non-pointer result");
1344 error ("base operand of %<->%> is not a pointer");
1345 return error_mark_node;
1348 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1349 already been checked out to be of aggregate type. */
1352 build_m_component_ref (tree datum, tree component)
1360 if (error_operand_p (datum) || error_operand_p (component))
1361 return error_mark_node;
1363 ptrmem_type = TREE_TYPE (component);
1364 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1366 error ("%qE cannot be used as a member pointer, since it is of "
1368 component, ptrmem_type);
1369 return error_mark_node;
1372 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1373 if (! MAYBE_CLASS_TYPE_P (objtype))
1375 error ("cannot apply member pointer %qE to %qE, which is of "
1376 "non-class type %qT",
1377 component, datum, objtype);
1378 return error_mark_node;
1381 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1382 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1384 if (!COMPLETE_TYPE_P (ctype))
1386 if (!same_type_p (ctype, objtype))
1392 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1397 error ("pointer to member type %qT incompatible with object "
1400 return error_mark_node;
1402 else if (binfo == error_mark_node)
1403 return error_mark_node;
1406 if (TYPE_PTRMEM_P (ptrmem_type))
1410 /* Compute the type of the field, as described in [expr.ref].
1411 There's no such thing as a mutable pointer-to-member, so
1412 things are not as complex as they are for references to
1413 non-static data members. */
1414 type = cp_build_qualified_type (type,
1415 (cp_type_quals (type)
1416 | cp_type_quals (TREE_TYPE (datum))));
1418 datum = build_address (datum);
1420 /* Convert object to the correct base. */
1422 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1424 /* Build an expression for "object + offset" where offset is the
1425 value stored in the pointer-to-data-member. */
1426 ptype = build_pointer_type (type);
1427 datum = build2 (POINTER_PLUS_EXPR, ptype,
1428 fold_convert (ptype, datum),
1429 build_nop (sizetype, component));
1430 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1433 return build2 (OFFSET_REF, type, datum, component);
1436 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1439 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1441 /* This is either a call to a constructor,
1442 or a C cast in C++'s `functional' notation. */
1444 /* The type to which we are casting. */
1446 VEC(tree,gc) *parmvec;
1448 if (exp == error_mark_node || parms == error_mark_node)
1449 return error_mark_node;
1451 if (TREE_CODE (exp) == TYPE_DECL)
1452 type = TREE_TYPE (exp);
1456 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1458 error ("invalid value-initialization of reference types");
1459 return error_mark_node;
1462 if (processing_template_decl)
1464 tree t = build_min (CAST_EXPR, type, parms);
1465 /* We don't know if it will or will not have side effects. */
1466 TREE_SIDE_EFFECTS (t) = 1;
1470 if (! MAYBE_CLASS_TYPE_P (type))
1472 if (parms == NULL_TREE)
1473 return cp_convert (type, integer_zero_node);
1475 /* This must build a C cast. */
1476 parms = build_x_compound_expr_from_list (parms, "functional cast");
1477 return cp_build_c_cast (type, parms, complain);
1480 /* Prepare to evaluate as a call to a constructor. If this expression
1481 is actually used, for example,
1483 return X (arg1, arg2, ...);
1485 then the slot being initialized will be filled in. */
1487 if (!complete_type_or_else (type, NULL_TREE))
1488 return error_mark_node;
1489 if (abstract_virtuals_error (NULL_TREE, type))
1490 return error_mark_node;
1494 If the expression list is a single-expression, the type
1495 conversion is equivalent (in definedness, and if defined in
1496 meaning) to the corresponding cast expression. */
1497 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1498 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1502 The expression T(), where T is a simple-type-specifier for a
1503 non-array complete object type or the (possibly cv-qualified)
1504 void type, creates an rvalue of the specified type, which is
1505 value-initialized. */
1507 if (parms == NULL_TREE
1508 /* If there's a user-defined constructor, value-initialization is
1509 just calling the constructor, so fall through. */
1510 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1512 exp = build_value_init (type);
1513 return get_target_expr (exp);
1516 /* Call the constructor. */
1517 parmvec = make_tree_vector ();
1518 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1519 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1520 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1521 &parmvec, type, LOOKUP_NORMAL, complain);
1522 release_tree_vector (parmvec);
1524 if (exp == error_mark_node)
1525 return error_mark_node;
1527 return build_cplus_new (type, exp);
1531 /* Add new exception specifier SPEC, to the LIST we currently have.
1532 If it's already in LIST then do nothing.
1533 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1534 know what we're doing. */
1537 add_exception_specifier (tree list, tree spec, int complain)
1542 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1544 if (spec == error_mark_node)
1547 gcc_assert (spec && (!list || TREE_VALUE (list)));
1549 /* [except.spec] 1, type in an exception specifier shall not be
1550 incomplete, or pointer or ref to incomplete other than pointer
1552 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1553 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1554 core = TREE_TYPE (core);
1557 else if (VOID_TYPE_P (core))
1559 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1561 else if (processing_template_decl)
1566 /* 15.4/1 says that types in an exception specifier must be complete,
1567 but it seems more reasonable to only require this on definitions
1568 and calls. So just give a pedwarn at this point; we will give an
1569 error later if we hit one of those two cases. */
1570 if (!COMPLETE_TYPE_P (complete_type (core)))
1571 diag_type = DK_PEDWARN; /* pedwarn */
1578 for (probe = list; probe; probe = TREE_CHAIN (probe))
1579 if (same_type_p (TREE_VALUE (probe), spec))
1582 list = tree_cons (NULL_TREE, spec, list);
1585 diag_type = DK_ERROR; /* error */
1587 if (diag_type != DK_UNSPECIFIED && complain)
1588 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1593 /* Combine the two exceptions specifier lists LIST and ADD, and return
1597 merge_exception_specifiers (tree list, tree add)
1601 else if (!TREE_VALUE (list))
1603 else if (!TREE_VALUE (add))
1607 tree orig_list = list;
1609 for (; add; add = TREE_CHAIN (add))
1611 tree spec = TREE_VALUE (add);
1614 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1615 if (same_type_p (TREE_VALUE (probe), spec))
1619 spec = build_tree_list (NULL_TREE, spec);
1620 TREE_CHAIN (spec) = list;
1628 /* Subroutine of build_call. Ensure that each of the types in the
1629 exception specification is complete. Technically, 15.4/1 says that
1630 they need to be complete when we see a declaration of the function,
1631 but we should be able to get away with only requiring this when the
1632 function is defined or called. See also add_exception_specifier. */
1635 require_complete_eh_spec_types (tree fntype, tree decl)
1638 /* Don't complain about calls to op new. */
1639 if (decl && DECL_ARTIFICIAL (decl))
1641 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1642 raises = TREE_CHAIN (raises))
1644 tree type = TREE_VALUE (raises);
1645 if (type && !COMPLETE_TYPE_P (type))
1649 ("call to function %qD which throws incomplete type %q#T",
1652 error ("call to function which throws incomplete type %q#T",
1659 #include "gt-cp-typeck2.h"