1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* This file is part of the C++ front end.
25 It contains routines to build C++ expressions given their operands,
26 including computing the types of the result, C and C++ specific error
27 checks, and some optimization. */
31 #include "coretypes.h"
41 #include "diagnostic.h"
48 static tree pfn_from_ptrmemfunc (tree);
49 static tree delta_from_ptrmemfunc (tree);
50 static tree convert_for_assignment (tree, tree, const char *, tree, int,
52 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
53 static tree rationalize_conditional_expr (enum tree_code, tree,
55 static int comp_ptr_ttypes_real (tree, tree, int);
56 static bool comp_except_types (tree, tree, bool);
57 static bool comp_array_types (const_tree, const_tree, bool);
58 static tree pointer_diff (tree, tree, tree);
59 static tree get_delta_difference (tree, tree, bool, bool);
60 static void casts_away_constness_r (tree *, tree *);
61 static bool casts_away_constness (tree, tree);
62 static void maybe_warn_about_returning_address_of_local (tree);
63 static tree lookup_destructor (tree, tree, tree);
64 static int convert_arguments (tree, VEC(tree,gc) **, tree, int,
67 /* Do `exp = require_complete_type (exp);' to make sure exp
68 does not have an incomplete type. (That includes void types.)
69 Returns the error_mark_node if the VALUE does not have
70 complete type when this function returns. */
73 require_complete_type (tree value)
77 if (processing_template_decl || value == error_mark_node)
80 if (TREE_CODE (value) == OVERLOAD)
81 type = unknown_type_node;
83 type = TREE_TYPE (value);
85 if (type == error_mark_node)
86 return error_mark_node;
88 /* First, detect a valid value with a complete type. */
89 if (COMPLETE_TYPE_P (type))
92 if (complete_type_or_else (type, value))
95 return error_mark_node;
98 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
99 a template instantiation, do the instantiation. Returns TYPE,
100 whether or not it could be completed, unless something goes
101 horribly wrong, in which case the error_mark_node is returned. */
104 complete_type (tree type)
106 if (type == NULL_TREE)
107 /* Rather than crash, we return something sure to cause an error
109 return error_mark_node;
111 if (type == error_mark_node || COMPLETE_TYPE_P (type))
113 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
115 tree t = complete_type (TREE_TYPE (type));
116 unsigned int needs_constructing, has_nontrivial_dtor;
117 if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
120 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
122 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
123 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
125 TYPE_NEEDS_CONSTRUCTING (t) = needs_constructing;
126 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = has_nontrivial_dtor;
129 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
130 instantiate_class_template (TYPE_MAIN_VARIANT (type));
135 /* Like complete_type, but issue an error if the TYPE cannot be completed.
136 VALUE is used for informative diagnostics.
137 Returns NULL_TREE if the type cannot be made complete. */
140 complete_type_or_else (tree type, tree value)
142 type = complete_type (type);
143 if (type == error_mark_node)
144 /* We already issued an error. */
146 else if (!COMPLETE_TYPE_P (type))
148 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
155 /* Return truthvalue of whether type of EXP is instantiated. */
158 type_unknown_p (const_tree exp)
160 return (TREE_CODE (exp) == TREE_LIST
161 || TREE_TYPE (exp) == unknown_type_node);
165 /* Return the common type of two parameter lists.
166 We assume that comptypes has already been done and returned 1;
167 if that isn't so, this may crash.
169 As an optimization, free the space we allocate if the parameter
170 lists are already common. */
173 commonparms (tree p1, tree p2)
175 tree oldargs = p1, newargs, n;
179 len = list_length (p1);
180 newargs = tree_last (p1);
182 if (newargs == void_list_node)
191 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
196 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
198 if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
200 TREE_PURPOSE (n) = TREE_PURPOSE (p1);
203 else if (! TREE_PURPOSE (p1))
205 if (TREE_PURPOSE (p2))
207 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
213 if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
215 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
217 if (TREE_VALUE (p1) != TREE_VALUE (p2))
220 TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
223 TREE_VALUE (n) = TREE_VALUE (p1);
231 /* Given a type, perhaps copied for a typedef,
232 find the "original" version of it. */
234 original_type (tree t)
236 int quals = cp_type_quals (t);
237 while (t != error_mark_node
238 && TYPE_NAME (t) != NULL_TREE)
240 tree x = TYPE_NAME (t);
241 if (TREE_CODE (x) != TYPE_DECL)
243 x = DECL_ORIGINAL_TYPE (x);
248 return cp_build_qualified_type (t, quals);
251 /* Return the common type for two arithmetic types T1 and T2 under the
252 usual arithmetic conversions. The default conversions have already
253 been applied, and enumerated types converted to their compatible
257 cp_common_type (tree t1, tree t2)
259 enum tree_code code1 = TREE_CODE (t1);
260 enum tree_code code2 = TREE_CODE (t2);
263 /* In what follows, we slightly generalize the rules given in [expr] so
264 as to deal with `long long' and `complex'. First, merge the
266 attributes = (*targetm.merge_type_attributes) (t1, t2);
268 if (SCOPED_ENUM_P (t1) || SCOPED_ENUM_P (t2))
270 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
271 return build_type_attribute_variant (t1, attributes);
276 /* FIXME: Attributes. */
277 gcc_assert (ARITHMETIC_TYPE_P (t1)
278 || TREE_CODE (t1) == VECTOR_TYPE
279 || UNSCOPED_ENUM_P (t1));
280 gcc_assert (ARITHMETIC_TYPE_P (t2)
281 || TREE_CODE (t2) == VECTOR_TYPE
282 || UNSCOPED_ENUM_P (t2));
284 /* If one type is complex, form the common type of the non-complex
285 components, then make that complex. Use T1 or T2 if it is the
287 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
289 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
290 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
292 = type_after_usual_arithmetic_conversions (subtype1, subtype2);
294 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
295 return build_type_attribute_variant (t1, attributes);
296 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
297 return build_type_attribute_variant (t2, attributes);
299 return build_type_attribute_variant (build_complex_type (subtype),
303 if (code1 == VECTOR_TYPE)
305 /* When we get here we should have two vectors of the same size.
306 Just prefer the unsigned one if present. */
307 if (TYPE_UNSIGNED (t1))
308 return build_type_attribute_variant (t1, attributes);
310 return build_type_attribute_variant (t2, attributes);
313 /* If only one is real, use it as the result. */
314 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
315 return build_type_attribute_variant (t1, attributes);
316 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
317 return build_type_attribute_variant (t2, attributes);
319 /* Both real or both integers; use the one with greater precision. */
320 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
321 return build_type_attribute_variant (t1, attributes);
322 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
323 return build_type_attribute_variant (t2, attributes);
325 /* The types are the same; no need to do anything fancy. */
326 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
327 return build_type_attribute_variant (t1, attributes);
329 if (code1 != REAL_TYPE)
331 /* If one is unsigned long long, then convert the other to unsigned
333 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
334 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
335 return build_type_attribute_variant (long_long_unsigned_type_node,
337 /* If one is a long long, and the other is an unsigned long, and
338 long long can represent all the values of an unsigned long, then
339 convert to a long long. Otherwise, convert to an unsigned long
340 long. Otherwise, if either operand is long long, convert the
343 Since we're here, we know the TYPE_PRECISION is the same;
344 therefore converting to long long cannot represent all the values
345 of an unsigned long, so we choose unsigned long long in that
347 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
348 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
350 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
351 ? long_long_unsigned_type_node
352 : long_long_integer_type_node);
353 return build_type_attribute_variant (t, attributes);
356 /* Go through the same procedure, but for longs. */
357 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
358 || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
359 return build_type_attribute_variant (long_unsigned_type_node,
361 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
362 || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
364 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
365 ? long_unsigned_type_node : long_integer_type_node);
366 return build_type_attribute_variant (t, attributes);
368 /* Otherwise prefer the unsigned one. */
369 if (TYPE_UNSIGNED (t1))
370 return build_type_attribute_variant (t1, attributes);
372 return build_type_attribute_variant (t2, attributes);
376 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
377 || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
378 return build_type_attribute_variant (long_double_type_node,
380 if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
381 || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
382 return build_type_attribute_variant (double_type_node,
384 if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
385 || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
386 return build_type_attribute_variant (float_type_node,
389 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
390 the standard C++ floating-point types. Logic earlier in this
391 function has already eliminated the possibility that
392 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
393 compelling reason to choose one or the other. */
394 return build_type_attribute_variant (t1, attributes);
398 /* T1 and T2 are arithmetic or enumeration types. Return the type
399 that will result from the "usual arithmetic conversions" on T1 and
400 T2 as described in [expr]. */
403 type_after_usual_arithmetic_conversions (tree t1, tree t2)
405 gcc_assert (ARITHMETIC_TYPE_P (t1)
406 || TREE_CODE (t1) == VECTOR_TYPE
407 || UNSCOPED_ENUM_P (t1));
408 gcc_assert (ARITHMETIC_TYPE_P (t2)
409 || TREE_CODE (t2) == VECTOR_TYPE
410 || UNSCOPED_ENUM_P (t2));
412 /* Perform the integral promotions. We do not promote real types here. */
413 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t1)
414 && INTEGRAL_OR_ENUMERATION_TYPE_P (t2))
416 t1 = type_promotes_to (t1);
417 t2 = type_promotes_to (t2);
420 return cp_common_type (t1, t2);
423 /* Subroutine of composite_pointer_type to implement the recursive
424 case. See that function for documentation of the parameters. */
427 composite_pointer_type_r (tree t1, tree t2,
428 composite_pointer_operation operation,
429 tsubst_flags_t complain)
436 /* Determine the types pointed to by T1 and T2. */
437 if (TREE_CODE (t1) == POINTER_TYPE)
439 pointee1 = TREE_TYPE (t1);
440 pointee2 = TREE_TYPE (t2);
444 pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
445 pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
450 Otherwise, the composite pointer type is a pointer type
451 similar (_conv.qual_) to the type of one of the operands,
452 with a cv-qualification signature (_conv.qual_) that is the
453 union of the cv-qualification signatures of the operand
455 if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
456 result_type = pointee1;
457 else if ((TREE_CODE (pointee1) == POINTER_TYPE
458 && TREE_CODE (pointee2) == POINTER_TYPE)
459 || (TYPE_PTR_TO_MEMBER_P (pointee1)
460 && TYPE_PTR_TO_MEMBER_P (pointee2)))
461 result_type = composite_pointer_type_r (pointee1, pointee2, operation,
465 if (complain & tf_error)
470 permerror (input_location, "comparison between "
471 "distinct pointer types %qT and %qT lacks a cast",
475 permerror (input_location, "conversion between "
476 "distinct pointer types %qT and %qT lacks a cast",
479 case CPO_CONDITIONAL_EXPR:
480 permerror (input_location, "conditional expression between "
481 "distinct pointer types %qT and %qT lacks a cast",
488 result_type = void_type_node;
490 result_type = cp_build_qualified_type (result_type,
491 (cp_type_quals (pointee1)
492 | cp_type_quals (pointee2)));
493 /* If the original types were pointers to members, so is the
495 if (TYPE_PTR_TO_MEMBER_P (t1))
497 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
498 TYPE_PTRMEM_CLASS_TYPE (t2))
499 && (complain & tf_error))
504 permerror (input_location, "comparison between "
505 "distinct pointer types %qT and %qT lacks a cast",
509 permerror (input_location, "conversion between "
510 "distinct pointer types %qT and %qT lacks a cast",
513 case CPO_CONDITIONAL_EXPR:
514 permerror (input_location, "conditional expression between "
515 "distinct pointer types %qT and %qT lacks a cast",
522 result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
526 result_type = build_pointer_type (result_type);
528 /* Merge the attributes. */
529 attributes = (*targetm.merge_type_attributes) (t1, t2);
530 return build_type_attribute_variant (result_type, attributes);
533 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
534 ARG1 and ARG2 are the values with those types. The OPERATION is to
535 describe the operation between the pointer types,
536 in case an error occurs.
538 This routine also implements the computation of a common type for
539 pointers-to-members as per [expr.eq]. */
542 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
543 composite_pointer_operation operation,
544 tsubst_flags_t complain)
551 If one operand is a null pointer constant, the composite pointer
552 type is the type of the other operand. */
553 if (null_ptr_cst_p (arg1))
555 if (null_ptr_cst_p (arg2))
562 If one of the operands has type "pointer to cv1 void*", then
563 the other has type "pointer to cv2T", and the composite pointer
564 type is "pointer to cv12 void", where cv12 is the union of cv1
567 If either type is a pointer to void, make sure it is T1. */
568 if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
576 /* Now, if T1 is a pointer to void, merge the qualifiers. */
577 if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
582 if (TYPE_PTRFN_P (t2) && (complain & tf_error))
587 pedwarn (input_location, OPT_pedantic,
588 "ISO C++ forbids comparison between "
589 "pointer of type %<void *%> and pointer-to-function");
592 pedwarn (input_location, OPT_pedantic,
593 "ISO C++ forbids conversion between "
594 "pointer of type %<void *%> and pointer-to-function");
596 case CPO_CONDITIONAL_EXPR:
597 pedwarn (input_location, OPT_pedantic,
598 "ISO C++ forbids conditional expression between "
599 "pointer of type %<void *%> and pointer-to-function");
606 = cp_build_qualified_type (void_type_node,
607 (cp_type_quals (TREE_TYPE (t1))
608 | cp_type_quals (TREE_TYPE (t2))));
609 result_type = build_pointer_type (result_type);
610 /* Merge the attributes. */
611 attributes = (*targetm.merge_type_attributes) (t1, t2);
612 return build_type_attribute_variant (result_type, attributes);
615 if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE
616 && TREE_CODE (t2) == POINTER_TYPE)
618 if (objc_compare_types (t1, t2, -3, NULL_TREE))
622 /* [expr.eq] permits the application of a pointer conversion to
623 bring the pointers to a common type. */
624 if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
625 && CLASS_TYPE_P (TREE_TYPE (t1))
626 && CLASS_TYPE_P (TREE_TYPE (t2))
627 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
630 class1 = TREE_TYPE (t1);
631 class2 = TREE_TYPE (t2);
633 if (DERIVED_FROM_P (class1, class2))
634 t2 = (build_pointer_type
635 (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
636 else if (DERIVED_FROM_P (class2, class1))
637 t1 = (build_pointer_type
638 (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
641 if (complain & tf_error)
645 error ("comparison between distinct "
646 "pointer types %qT and %qT lacks a cast", t1, t2);
649 error ("conversion between distinct "
650 "pointer types %qT and %qT lacks a cast", t1, t2);
652 case CPO_CONDITIONAL_EXPR:
653 error ("conditional expression between distinct "
654 "pointer types %qT and %qT lacks a cast", t1, t2);
659 return error_mark_node;
662 /* [expr.eq] permits the application of a pointer-to-member
663 conversion to change the class type of one of the types. */
664 else if (TYPE_PTR_TO_MEMBER_P (t1)
665 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
666 TYPE_PTRMEM_CLASS_TYPE (t2)))
668 class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
669 class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
671 if (DERIVED_FROM_P (class1, class2))
672 t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
673 else if (DERIVED_FROM_P (class2, class1))
674 t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
677 if (complain & tf_error)
681 error ("comparison between distinct "
682 "pointer-to-member types %qT and %qT lacks a cast",
686 error ("conversion between distinct "
687 "pointer-to-member types %qT and %qT lacks a cast",
690 case CPO_CONDITIONAL_EXPR:
691 error ("conditional expression between distinct "
692 "pointer-to-member types %qT and %qT lacks a cast",
698 return error_mark_node;
702 return composite_pointer_type_r (t1, t2, operation, complain);
705 /* Return the merged type of two types.
706 We assume that comptypes has already been done and returned 1;
707 if that isn't so, this may crash.
709 This just combines attributes and default arguments; any other
710 differences would cause the two types to compare unalike. */
713 merge_types (tree t1, tree t2)
715 enum tree_code code1;
716 enum tree_code code2;
719 /* Save time if the two types are the same. */
722 if (original_type (t1) == original_type (t2))
725 /* If one type is nonsense, use the other. */
726 if (t1 == error_mark_node)
728 if (t2 == error_mark_node)
731 /* Merge the attributes. */
732 attributes = (*targetm.merge_type_attributes) (t1, t2);
734 if (TYPE_PTRMEMFUNC_P (t1))
735 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
736 if (TYPE_PTRMEMFUNC_P (t2))
737 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
739 code1 = TREE_CODE (t1);
740 code2 = TREE_CODE (t2);
743 gcc_assert (code1 == TYPENAME_TYPE || code2 == TYPENAME_TYPE);
744 if (code1 == TYPENAME_TYPE)
746 t1 = resolve_typename_type (t1, /*only_current_p=*/true);
747 code1 = TREE_CODE (t1);
751 t2 = resolve_typename_type (t2, /*only_current_p=*/true);
752 code2 = TREE_CODE (t2);
760 /* For two pointers, do this recursively on the target type. */
762 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
763 int quals = cp_type_quals (t1);
765 if (code1 == POINTER_TYPE)
766 t1 = build_pointer_type (target);
768 t1 = cp_build_reference_type (target, TYPE_REF_IS_RVALUE (t1));
769 t1 = build_type_attribute_variant (t1, attributes);
770 t1 = cp_build_qualified_type (t1, quals);
772 if (TREE_CODE (target) == METHOD_TYPE)
773 t1 = build_ptrmemfunc_type (t1);
782 quals = cp_type_quals (t1);
783 pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
784 TYPE_PTRMEM_POINTED_TO_TYPE (t2));
785 t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
787 t1 = cp_build_qualified_type (t1, quals);
793 tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
794 /* Save space: see if the result is identical to one of the args. */
795 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
796 return build_type_attribute_variant (t1, attributes);
797 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
798 return build_type_attribute_variant (t2, attributes);
799 /* Merge the element types, and have a size if either arg has one. */
800 t1 = build_cplus_array_type
801 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
806 /* Function types: prefer the one that specified arg types.
807 If both do, merge the arg types. Also merge the return types. */
809 tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
810 tree p1 = TYPE_ARG_TYPES (t1);
811 tree p2 = TYPE_ARG_TYPES (t2);
814 /* Save space: see if the result is identical to one of the args. */
815 if (valtype == TREE_TYPE (t1) && ! p2)
816 return cp_build_type_attribute_variant (t1, attributes);
817 if (valtype == TREE_TYPE (t2) && ! p1)
818 return cp_build_type_attribute_variant (t2, attributes);
820 /* Simple way if one arg fails to specify argument types. */
821 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
823 rval = build_function_type (valtype, p2);
824 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
825 rval = build_exception_variant (rval, raises);
826 return cp_build_type_attribute_variant (rval, attributes);
828 raises = TYPE_RAISES_EXCEPTIONS (t1);
829 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
831 rval = build_function_type (valtype, p1);
833 rval = build_exception_variant (rval, raises);
834 return cp_build_type_attribute_variant (rval, attributes);
837 rval = build_function_type (valtype, commonparms (p1, p2));
838 t1 = build_exception_variant (rval, raises);
844 /* Get this value the long way, since TYPE_METHOD_BASETYPE
845 is just the main variant of this. */
846 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
847 tree raises = TYPE_RAISES_EXCEPTIONS (t1);
850 /* If this was a member function type, get back to the
851 original type of type member function (i.e., without
852 the class instance variable up front. */
853 t1 = build_function_type (TREE_TYPE (t1),
854 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
855 t2 = build_function_type (TREE_TYPE (t2),
856 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
857 t3 = merge_types (t1, t2);
858 t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
859 TYPE_ARG_TYPES (t3));
860 t1 = build_exception_variant (t3, raises);
865 /* There is no need to merge attributes into a TYPENAME_TYPE.
866 When the type is instantiated it will have whatever
867 attributes result from the instantiation. */
873 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
875 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
878 return cp_build_type_attribute_variant (t1, attributes);
881 /* Wrapper around cp_common_type that is used by c-common.c and other
882 front end optimizations that remove promotions.
884 Return the common type for two arithmetic types T1 and T2 under the
885 usual arithmetic conversions. The default conversions have already
886 been applied, and enumerated types converted to their compatible
890 common_type (tree t1, tree t2)
892 /* If one type is nonsense, use the other */
893 if (t1 == error_mark_node)
895 if (t2 == error_mark_node)
898 return cp_common_type (t1, t2);
901 /* Return the common type of two pointer types T1 and T2. This is the
902 type for the result of most arithmetic operations if the operands
903 have the given two types.
905 We assume that comp_target_types has already been done and returned
906 nonzero; if that isn't so, this may crash. */
909 common_pointer_type (tree t1, tree t2)
911 gcc_assert ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
912 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
913 || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)));
915 return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
916 CPO_CONVERSION, tf_warning_or_error);
919 /* Compare two exception specifier types for exactness or subsetness, if
920 allowed. Returns false for mismatch, true for match (same, or
923 [except.spec] "If a class X ... objects of class X or any class publicly
924 and unambiguously derived from X. Similarly, if a pointer type Y * ...
925 exceptions of type Y * or that are pointers to any type publicly and
926 unambiguously derived from Y. Otherwise a function only allows exceptions
927 that have the same type ..."
928 This does not mention cv qualifiers and is different to what throw
929 [except.throw] and catch [except.catch] will do. They will ignore the
930 top level cv qualifiers, and allow qualifiers in the pointer to class
933 We implement the letter of the standard. */
936 comp_except_types (tree a, tree b, bool exact)
938 if (same_type_p (a, b))
942 if (cp_type_quals (a) || cp_type_quals (b))
945 if (TREE_CODE (a) == POINTER_TYPE
946 && TREE_CODE (b) == POINTER_TYPE)
950 if (cp_type_quals (a) || cp_type_quals (b))
954 if (TREE_CODE (a) != RECORD_TYPE
955 || TREE_CODE (b) != RECORD_TYPE)
958 if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
964 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
965 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
966 otherwise it must be exact. Exception lists are unordered, but
967 we've already filtered out duplicates. Most lists will be in order,
968 we should try to make use of that. */
971 comp_except_specs (const_tree t1, const_tree t2, bool exact)
980 if (t1 == NULL_TREE) /* T1 is ... */
981 return t2 == NULL_TREE || !exact;
982 if (!TREE_VALUE (t1)) /* t1 is EMPTY */
983 return t2 != NULL_TREE && !TREE_VALUE (t2);
984 if (t2 == NULL_TREE) /* T2 is ... */
986 if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
989 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
990 Count how many we find, to determine exactness. For exact matching and
991 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
993 for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
995 for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
997 tree a = TREE_VALUE (probe);
998 tree b = TREE_VALUE (t2);
1000 if (comp_except_types (a, b, exact))
1002 if (probe == base && exact)
1003 base = TREE_CHAIN (probe);
1008 if (probe == NULL_TREE)
1011 return !exact || base == NULL_TREE || length == list_length (t1);
1014 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
1015 [] can match [size]. */
1018 comp_array_types (const_tree t1, const_tree t2, bool allow_redeclaration)
1027 /* The type of the array elements must be the same. */
1028 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1031 d1 = TYPE_DOMAIN (t1);
1032 d2 = TYPE_DOMAIN (t2);
1037 /* If one of the arrays is dimensionless, and the other has a
1038 dimension, they are of different types. However, it is valid to
1046 declarations for an array object can specify
1047 array types that differ by the presence or absence of a major
1048 array bound (_dcl.array_). */
1050 return allow_redeclaration;
1052 /* Check that the dimensions are the same. */
1054 if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
1056 max1 = TYPE_MAX_VALUE (d1);
1057 max2 = TYPE_MAX_VALUE (d2);
1058 if (processing_template_decl && !abi_version_at_least (2)
1059 && !value_dependent_expression_p (max1)
1060 && !value_dependent_expression_p (max2))
1062 /* With abi-1 we do not fold non-dependent array bounds, (and
1063 consequently mangle them incorrectly). We must therefore
1064 fold them here, to verify the domains have the same
1070 if (!cp_tree_equal (max1, max2))
1076 /* Compare the relative position of T1 and T2 into their respective
1077 template parameter list.
1078 T1 and T2 must be template parameter types.
1079 Return TRUE if T1 and T2 have the same position, FALSE otherwise. */
1082 comp_template_parms_position (tree t1, tree t2)
1084 gcc_assert (t1 && t2
1085 && TREE_CODE (t1) == TREE_CODE (t2)
1086 && (TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM
1087 || TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM
1088 || TREE_CODE (t1) == TEMPLATE_TYPE_PARM));
1090 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1091 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1092 || (TEMPLATE_TYPE_PARAMETER_PACK (t1)
1093 != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1099 /* Subroutine of incompatible_dependent_types_p.
1100 Return the template parameter of the dependent type T.
1101 If T is a typedef, return the template parameters of
1102 the _decl_ of the typedef. T must be a dependent type. */
1105 get_template_parms_of_dependent_type (tree t)
1107 tree tinfo = NULL_TREE, tparms = NULL_TREE;
1109 /* If T1 is a typedef or whatever has a template info associated
1110 to its context, get the template parameters from that context. */
1111 if (typedef_variant_p (t)
1112 && DECL_CONTEXT (TYPE_NAME (t))
1113 && !NAMESPACE_SCOPE_P (TYPE_NAME (t)))
1114 tinfo = get_template_info (DECL_CONTEXT (TYPE_NAME (t)));
1115 else if (TYPE_CONTEXT (t)
1116 && !NAMESPACE_SCOPE_P (t))
1117 tinfo = get_template_info (TYPE_CONTEXT (t));
1120 tparms = DECL_TEMPLATE_PARMS (TI_TEMPLATE (tinfo));
1121 /* If T is a template type parameter, get the template parameter
1122 set it is part of. */
1123 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
1124 && DECL_CONTEXT (TYPE_NAME (t)))
1125 tparms = DECL_TEMPLATE_PARMS (DECL_CONTEXT (TYPE_NAME (t)));
1126 /* If T is a TYPENAME_TYPE which context is a template type
1127 parameter, get the template parameters from that context. */
1128 else if (TYPE_CONTEXT (t)
1129 && TREE_CODE (TYPE_CONTEXT (t)) == TEMPLATE_TYPE_PARM)
1130 tparms = get_template_parms_of_dependent_type (TYPE_CONTEXT (t));
1135 /* Subroutine of structural_comptypes.
1136 Compare the dependent types T1 and T2.
1137 Return TRUE if we are sure they can't be equal, FALSE otherwise.
1138 The whole point of this function is to support cases where either T1 or
1139 T2 is a typedef. In those cases, we need to compare the template parameters
1140 of the _decl_ of the typedef. If those don't match then we know T1
1141 and T2 cannot be equal. */
1144 incompatible_dependent_types_p (tree t1, tree t2)
1146 tree tparms1 = NULL_TREE, tparms2 = NULL_TREE;
1148 if (!uses_template_parms (t1) || !uses_template_parms (t2))
1151 if (TREE_CODE (t1) == TEMPLATE_TYPE_PARM)
1153 /* If T1 and T2 don't have the same relative position in their
1154 template parameters set, they can't be equal. */
1155 if (!comp_template_parms_position (t1, t2))
1159 /* Either T1 or T2 must be a typedef. */
1160 if (!typedef_variant_p (t1) && !typedef_variant_p (t2))
1163 /* So if we reach this point, it means either T1 or T2 is a typedef variant.
1164 Let's compare their template parameters. */
1166 tparms1 = get_template_parms_of_dependent_type (t1);
1167 tparms2 = get_template_parms_of_dependent_type (t2);
1169 if (tparms1 == NULL_TREE
1170 || tparms2 == NULL_TREE
1171 || tparms1 == tparms2)
1174 /* And now compare the mighty template parms! */
1175 return !comp_template_parms (tparms1, tparms2);
1178 /* Subroutine in comptypes. */
1181 structural_comptypes (tree t1, tree t2, int strict)
1186 /* Suppress errors caused by previously reported errors. */
1187 if (t1 == error_mark_node || t2 == error_mark_node)
1190 gcc_assert (TYPE_P (t1) && TYPE_P (t2));
1192 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1193 current instantiation. */
1194 if (TREE_CODE (t1) == TYPENAME_TYPE)
1195 t1 = resolve_typename_type (t1, /*only_current_p=*/true);
1197 if (TREE_CODE (t2) == TYPENAME_TYPE)
1198 t2 = resolve_typename_type (t2, /*only_current_p=*/true);
1200 if (TYPE_PTRMEMFUNC_P (t1))
1201 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
1202 if (TYPE_PTRMEMFUNC_P (t2))
1203 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
1205 /* Different classes of types can't be compatible. */
1206 if (TREE_CODE (t1) != TREE_CODE (t2))
1209 /* Qualifiers must match. For array types, we will check when we
1210 recur on the array element types. */
1211 if (TREE_CODE (t1) != ARRAY_TYPE
1212 && TYPE_QUALS (t1) != TYPE_QUALS (t2))
1214 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
1217 /* Allow for two different type nodes which have essentially the same
1218 definition. Note that we already checked for equality of the type
1219 qualifiers (just above). */
1221 if (TREE_CODE (t1) != ARRAY_TYPE
1222 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1225 /* If T1 and T2 are dependent typedefs then check upfront that
1226 the template parameters of their typedef DECLs match before
1227 going down checking their subtypes. */
1228 if (incompatible_dependent_types_p (t1, t2))
1231 /* Compare the types. Break out if they could be the same. */
1232 switch (TREE_CODE (t1))
1236 /* All void and bool types are the same. */
1240 case FIXED_POINT_TYPE:
1242 /* With these nodes, we can't determine type equivalence by
1243 looking at what is stored in the nodes themselves, because
1244 two nodes might have different TYPE_MAIN_VARIANTs but still
1245 represent the same type. For example, wchar_t and int could
1246 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1247 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1248 and are distinct types. On the other hand, int and the
1251 typedef int INT __attribute((may_alias));
1253 have identical properties, different TYPE_MAIN_VARIANTs, but
1254 represent the same type. The canonical type system keeps
1255 track of equivalence in this case, so we fall back on it. */
1256 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1258 case TEMPLATE_TEMPLATE_PARM:
1259 case BOUND_TEMPLATE_TEMPLATE_PARM:
1260 if (!comp_template_parms_position (t1, t2))
1262 if (!comp_template_parms
1263 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1264 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1266 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1268 /* Don't check inheritance. */
1269 strict = COMPARE_STRICT;
1274 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1275 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1276 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1277 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1280 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1282 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1288 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1289 strict & ~COMPARE_REDECLARATION))
1291 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1295 case REFERENCE_TYPE:
1296 if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
1298 /* fall through to checks for pointer types */
1301 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1302 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1303 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1309 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1311 if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1316 /* Target types must match incl. qualifiers. */
1317 if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1321 case TEMPLATE_TYPE_PARM:
1322 /* If incompatible_dependent_types_p called earlier didn't decide
1323 T1 and T2 were different, they might be equal. */
1327 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1328 TYPENAME_TYPE_FULLNAME (t2)))
1330 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1334 case UNBOUND_CLASS_TEMPLATE:
1335 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1337 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1342 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1347 if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1348 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1352 case TYPE_PACK_EXPANSION:
1353 return same_type_p (PACK_EXPANSION_PATTERN (t1),
1354 PACK_EXPANSION_PATTERN (t2));
1357 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1)
1358 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2)
1359 || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1)
1360 != DECLTYPE_FOR_LAMBDA_CAPTURE (t2))
1361 || (DECLTYPE_FOR_LAMBDA_RETURN (t1)
1362 != DECLTYPE_FOR_LAMBDA_RETURN (t2))
1363 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1),
1364 DECLTYPE_TYPE_EXPR (t2)))
1372 /* If we get here, we know that from a target independent POV the
1373 types are the same. Make sure the target attributes are also
1375 return targetm.comp_type_attributes (t1, t2);
1378 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1379 is a bitwise-or of the COMPARE_* flags. */
1382 comptypes (tree t1, tree t2, int strict)
1384 if (strict == COMPARE_STRICT)
1389 if (t1 == error_mark_node || t2 == error_mark_node)
1392 if (TYPE_STRUCTURAL_EQUALITY_P (t1) || TYPE_STRUCTURAL_EQUALITY_P (t2))
1393 /* At least one of the types requires structural equality, so
1394 perform a deep check. */
1395 return structural_comptypes (t1, t2, strict);
1397 #ifdef ENABLE_CHECKING
1398 if (USE_CANONICAL_TYPES)
1400 bool result = structural_comptypes (t1, t2, strict);
1402 if (result && TYPE_CANONICAL (t1) != TYPE_CANONICAL (t2))
1403 /* The two types are structurally equivalent, but their
1404 canonical types were different. This is a failure of the
1405 canonical type propagation code.*/
1407 ("canonical types differ for identical types %T and %T",
1409 else if (!result && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
1410 /* Two types are structurally different, but the canonical
1411 types are the same. This means we were over-eager in
1412 assigning canonical types. */
1414 ("same canonical type node for different types %T and %T",
1420 if (USE_CANONICAL_TYPES)
1421 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1424 return structural_comptypes (t1, t2, strict);
1426 else if (strict == COMPARE_STRUCTURAL)
1427 return structural_comptypes (t1, t2, COMPARE_STRICT);
1429 return structural_comptypes (t1, t2, strict);
1432 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1435 at_least_as_qualified_p (const_tree type1, const_tree type2)
1437 int q1 = cp_type_quals (type1);
1438 int q2 = cp_type_quals (type2);
1440 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1441 return (q1 & q2) == q2;
1444 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1445 more cv-qualified that TYPE1, and 0 otherwise. */
1448 comp_cv_qualification (const_tree type1, const_tree type2)
1450 int q1 = cp_type_quals (type1);
1451 int q2 = cp_type_quals (type2);
1456 if ((q1 & q2) == q2)
1458 else if ((q1 & q2) == q1)
1464 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1465 subset of the cv-qualification signature of TYPE2, and the types
1466 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1469 comp_cv_qual_signature (tree type1, tree type2)
1471 if (comp_ptr_ttypes_real (type2, type1, -1))
1473 else if (comp_ptr_ttypes_real (type1, type2, -1))
1479 /* Subroutines of `comptypes'. */
1481 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1482 equivalent in the sense that functions with those parameter types
1483 can have equivalent types. The two lists must be equivalent,
1484 element by element. */
1487 compparms (const_tree parms1, const_tree parms2)
1491 /* An unspecified parmlist matches any specified parmlist
1492 whose argument types don't need default promotions. */
1494 for (t1 = parms1, t2 = parms2;
1496 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1498 /* If one parmlist is shorter than the other,
1499 they fail to match. */
1502 if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1509 /* Process a sizeof or alignof expression where the operand is a
1513 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1518 gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1519 if (type == error_mark_node)
1520 return error_mark_node;
1522 type = non_reference (type);
1523 if (TREE_CODE (type) == METHOD_TYPE)
1526 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
1527 "invalid application of %qs to a member function",
1528 operator_name_info[(int) op].name);
1529 value = size_one_node;
1532 dependent_p = dependent_type_p (type);
1534 complete_type (type);
1536 /* VLA types will have a non-constant size. In the body of an
1537 uninstantiated template, we don't need to try to compute the
1538 value, because the sizeof expression is not an integral
1539 constant expression in that case. And, if we do try to
1540 compute the value, we'll likely end up with SAVE_EXPRs, which
1541 the template substitution machinery does not expect to see. */
1542 || (processing_template_decl
1543 && COMPLETE_TYPE_P (type)
1544 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
1546 value = build_min (op, size_type_node, type);
1547 TREE_READONLY (value) = 1;
1551 return c_sizeof_or_alignof_type (input_location, complete_type (type),
1556 /* Return the size of the type, without producing any warnings for
1557 types whose size cannot be taken. This routine should be used only
1558 in some other routine that has already produced a diagnostic about
1559 using the size of such a type. */
1561 cxx_sizeof_nowarn (tree type)
1563 if (TREE_CODE (type) == FUNCTION_TYPE
1564 || TREE_CODE (type) == VOID_TYPE
1565 || TREE_CODE (type) == ERROR_MARK)
1566 return size_one_node;
1567 else if (!COMPLETE_TYPE_P (type))
1568 return size_zero_node;
1570 return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false);
1573 /* Process a sizeof expression where the operand is an expression. */
1576 cxx_sizeof_expr (tree e, tsubst_flags_t complain)
1578 if (e == error_mark_node)
1579 return error_mark_node;
1581 if (processing_template_decl)
1583 e = build_min (SIZEOF_EXPR, size_type_node, e);
1584 TREE_SIDE_EFFECTS (e) = 0;
1585 TREE_READONLY (e) = 1;
1590 if (TREE_CODE (e) == COMPONENT_REF
1591 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1592 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1594 if (complain & tf_error)
1595 error ("invalid application of %<sizeof%> to a bit-field");
1597 return error_mark_node;
1600 else if (is_overloaded_fn (e))
1602 if (complain & tf_error)
1603 permerror (input_location, "ISO C++ forbids applying %<sizeof%> to an expression of "
1606 return error_mark_node;
1609 else if (type_unknown_p (e))
1611 if (complain & tf_error)
1612 cxx_incomplete_type_error (e, TREE_TYPE (e));
1614 return error_mark_node;
1620 return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error);
1623 /* Implement the __alignof keyword: Return the minimum required
1624 alignment of E, measured in bytes. For VAR_DECL's and
1625 FIELD_DECL's return DECL_ALIGN (which can be set from an
1626 "aligned" __attribute__ specification). */
1629 cxx_alignof_expr (tree e, tsubst_flags_t complain)
1633 if (e == error_mark_node)
1634 return error_mark_node;
1636 if (processing_template_decl)
1638 e = build_min (ALIGNOF_EXPR, size_type_node, e);
1639 TREE_SIDE_EFFECTS (e) = 0;
1640 TREE_READONLY (e) = 1;
1645 if (TREE_CODE (e) == VAR_DECL)
1646 t = size_int (DECL_ALIGN_UNIT (e));
1647 else if (TREE_CODE (e) == COMPONENT_REF
1648 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1649 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1651 if (complain & tf_error)
1652 error ("invalid application of %<__alignof%> to a bit-field");
1654 return error_mark_node;
1657 else if (TREE_CODE (e) == COMPONENT_REF
1658 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL)
1659 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1)));
1660 else if (is_overloaded_fn (e))
1662 if (complain & tf_error)
1663 permerror (input_location, "ISO C++ forbids applying %<__alignof%> to an expression of "
1666 return error_mark_node;
1667 if (TREE_CODE (e) == FUNCTION_DECL)
1668 t = size_int (DECL_ALIGN_UNIT (e));
1672 else if (type_unknown_p (e))
1674 if (complain & tf_error)
1675 cxx_incomplete_type_error (e, TREE_TYPE (e));
1677 return error_mark_node;
1681 return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR,
1682 complain & tf_error);
1684 return fold_convert (size_type_node, t);
1687 /* Process a sizeof or alignof expression E with code OP where the operand
1688 is an expression. */
1691 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain)
1693 if (op == SIZEOF_EXPR)
1694 return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none);
1696 return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none);
1699 /* EXPR is being used in a context that is not a function call.
1704 The expression can be used only as the left-hand operand of a
1705 member function call.
1707 [expr.mptr.operator]
1709 If the result of .* or ->* is a function, then that result can be
1710 used only as the operand for the function call operator ().
1712 by issuing an error message if appropriate. Returns true iff EXPR
1713 violates these rules. */
1716 invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
1718 if (expr && DECL_NONSTATIC_MEMBER_FUNCTION_P (expr))
1720 if (complain & tf_error)
1721 error ("invalid use of non-static member function");
1727 /* If EXP is a reference to a bitfield, and the type of EXP does not
1728 match the declared type of the bitfield, return the declared type
1729 of the bitfield. Otherwise, return NULL_TREE. */
1732 is_bitfield_expr_with_lowered_type (const_tree exp)
1734 switch (TREE_CODE (exp))
1737 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)
1738 ? TREE_OPERAND (exp, 1)
1739 : TREE_OPERAND (exp, 0)))
1741 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2));
1744 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1));
1748 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1754 field = TREE_OPERAND (exp, 1);
1755 if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
1757 if (same_type_ignoring_top_level_qualifiers_p
1758 (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
1760 return DECL_BIT_FIELD_TYPE (field);
1764 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
1765 == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
1766 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1774 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1775 bitfield with a lowered type, the type of EXP is returned, rather
1779 unlowered_expr_type (const_tree exp)
1783 type = is_bitfield_expr_with_lowered_type (exp);
1785 type = TREE_TYPE (exp);
1790 /* Perform the conversions in [expr] that apply when an lvalue appears
1791 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1792 function-to-pointer conversions. In addition, manifest constants
1793 are replaced by their values, and bitfield references are converted
1794 to their declared types.
1796 Although the returned value is being used as an rvalue, this
1797 function does not wrap the returned expression in a
1798 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1799 that the return value is no longer an lvalue. */
1802 decay_conversion (tree exp)
1805 enum tree_code code;
1807 type = TREE_TYPE (exp);
1808 if (type == error_mark_node)
1809 return error_mark_node;
1811 exp = resolve_nondeduced_context (exp);
1812 if (type_unknown_p (exp))
1814 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1815 return error_mark_node;
1818 exp = decl_constant_value (exp);
1819 if (error_operand_p (exp))
1820 return error_mark_node;
1822 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1823 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1824 code = TREE_CODE (type);
1825 if (code == VOID_TYPE)
1827 error ("void value not ignored as it ought to be");
1828 return error_mark_node;
1830 if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error))
1831 return error_mark_node;
1832 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1833 return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error);
1834 if (code == ARRAY_TYPE)
1839 if (TREE_CODE (exp) == INDIRECT_REF)
1840 return build_nop (build_pointer_type (TREE_TYPE (type)),
1841 TREE_OPERAND (exp, 0));
1843 if (TREE_CODE (exp) == COMPOUND_EXPR)
1845 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1846 return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1847 TREE_OPERAND (exp, 0), op1);
1851 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1853 error ("invalid use of non-lvalue array");
1854 return error_mark_node;
1857 ptrtype = build_pointer_type (TREE_TYPE (type));
1859 if (TREE_CODE (exp) == VAR_DECL)
1861 if (!cxx_mark_addressable (exp))
1862 return error_mark_node;
1863 adr = build_nop (ptrtype, build_address (exp));
1866 /* This way is better for a COMPONENT_REF since it can
1867 simplify the offset for a component. */
1868 adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
1869 return cp_convert (ptrtype, adr);
1872 /* If a bitfield is used in a context where integral promotion
1873 applies, then the caller is expected to have used
1874 default_conversion. That function promotes bitfields correctly
1875 before calling this function. At this point, if we have a
1876 bitfield referenced, we may assume that is not subject to
1877 promotion, and that, therefore, the type of the resulting rvalue
1878 is the declared type of the bitfield. */
1879 exp = convert_bitfield_to_declared_type (exp);
1881 /* We do not call rvalue() here because we do not want to wrap EXP
1882 in a NON_LVALUE_EXPR. */
1886 Non-class rvalues always have cv-unqualified types. */
1887 type = TREE_TYPE (exp);
1888 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
1889 exp = build_nop (cv_unqualified (type), exp);
1894 /* Perform preparatory conversions, as part of the "usual arithmetic
1895 conversions". In particular, as per [expr]:
1897 Whenever an lvalue expression appears as an operand of an
1898 operator that expects the rvalue for that operand, the
1899 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1900 standard conversions are applied to convert the expression to an
1903 In addition, we perform integral promotions here, as those are
1904 applied to both operands to a binary operator before determining
1905 what additional conversions should apply. */
1908 default_conversion (tree exp)
1910 /* Check for target-specific promotions. */
1911 tree promoted_type = targetm.promoted_type (TREE_TYPE (exp));
1913 exp = cp_convert (promoted_type, exp);
1914 /* Perform the integral promotions first so that bitfield
1915 expressions (which may promote to "int", even if the bitfield is
1916 declared "unsigned") are promoted correctly. */
1917 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1918 exp = perform_integral_promotions (exp);
1919 /* Perform the other conversions. */
1920 exp = decay_conversion (exp);
1925 /* EXPR is an expression with an integral or enumeration type.
1926 Perform the integral promotions in [conv.prom], and return the
1930 perform_integral_promotions (tree expr)
1937 If the bitfield has an enumerated type, it is treated as any
1938 other value of that type for promotion purposes. */
1939 type = is_bitfield_expr_with_lowered_type (expr);
1940 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
1941 type = TREE_TYPE (expr);
1942 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1943 promoted_type = type_promotes_to (type);
1944 if (type != promoted_type)
1945 expr = cp_convert (promoted_type, expr);
1949 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1950 decay_conversion to one. */
1953 string_conv_p (const_tree totype, const_tree exp, int warn)
1957 if (TREE_CODE (totype) != POINTER_TYPE)
1960 t = TREE_TYPE (totype);
1961 if (!same_type_p (t, char_type_node)
1962 && !same_type_p (t, char16_type_node)
1963 && !same_type_p (t, char32_type_node)
1964 && !same_type_p (t, wchar_type_node))
1967 if (TREE_CODE (exp) == STRING_CST)
1969 /* Make sure that we don't try to convert between char and wide chars. */
1970 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1975 /* Is this a string constant which has decayed to 'const char *'? */
1976 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1977 if (!same_type_p (TREE_TYPE (exp), t))
1980 if (TREE_CODE (exp) != ADDR_EXPR
1981 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1985 /* This warning is not very useful, as it complains about printf. */
1987 warning (OPT_Wwrite_strings,
1988 "deprecated conversion from string constant to %qT",
1994 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1995 can, for example, use as an lvalue. This code used to be in
1996 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1997 expressions, where we're dealing with aggregates. But now it's again only
1998 called from unary_complex_lvalue. The case (in particular) that led to
1999 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
2003 rationalize_conditional_expr (enum tree_code code, tree t,
2004 tsubst_flags_t complain)
2006 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
2007 the first operand is always the one to be used if both operands
2008 are equal, so we know what conditional expression this used to be. */
2009 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
2011 tree op0 = TREE_OPERAND (t, 0);
2012 tree op1 = TREE_OPERAND (t, 1);
2014 /* The following code is incorrect if either operand side-effects. */
2015 gcc_assert (!TREE_SIDE_EFFECTS (op0)
2016 && !TREE_SIDE_EFFECTS (op1));
2018 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
2019 ? LE_EXPR : GE_EXPR),
2020 op0, TREE_CODE (op0),
2021 op1, TREE_CODE (op1),
2022 /*overloaded_p=*/NULL,
2024 cp_build_unary_op (code, op0, 0, complain),
2025 cp_build_unary_op (code, op1, 0, complain),
2030 build_conditional_expr (TREE_OPERAND (t, 0),
2031 cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
2033 cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
2038 /* Given the TYPE of an anonymous union field inside T, return the
2039 FIELD_DECL for the field. If not found return NULL_TREE. Because
2040 anonymous unions can nest, we must also search all anonymous unions
2041 that are directly reachable. */
2044 lookup_anon_field (tree t, tree type)
2048 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2050 if (TREE_STATIC (field))
2052 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
2055 /* If we find it directly, return the field. */
2056 if (DECL_NAME (field) == NULL_TREE
2057 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
2062 /* Otherwise, it could be nested, search harder. */
2063 if (DECL_NAME (field) == NULL_TREE
2064 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2066 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
2074 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
2075 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
2076 non-NULL, it indicates the path to the base used to name MEMBER.
2077 If PRESERVE_REFERENCE is true, the expression returned will have
2078 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
2079 returned will have the type referred to by the reference.
2081 This function does not perform access control; that is either done
2082 earlier by the parser when the name of MEMBER is resolved to MEMBER
2083 itself, or later when overload resolution selects one of the
2084 functions indicated by MEMBER. */
2087 build_class_member_access_expr (tree object, tree member,
2088 tree access_path, bool preserve_reference,
2089 tsubst_flags_t complain)
2093 tree result = NULL_TREE;
2095 if (error_operand_p (object) || error_operand_p (member))
2096 return error_mark_node;
2098 gcc_assert (DECL_P (member) || BASELINK_P (member));
2102 The type of the first expression shall be "class object" (of a
2104 object_type = TREE_TYPE (object);
2105 if (!currently_open_class (object_type)
2106 && !complete_type_or_else (object_type, object))
2107 return error_mark_node;
2108 if (!CLASS_TYPE_P (object_type))
2110 if (complain & tf_error)
2111 error ("request for member %qD in %qE, which is of non-class type %qT",
2112 member, object, object_type);
2113 return error_mark_node;
2116 /* The standard does not seem to actually say that MEMBER must be a
2117 member of OBJECT_TYPE. However, that is clearly what is
2119 if (DECL_P (member))
2121 member_scope = DECL_CLASS_CONTEXT (member);
2123 if (TREE_DEPRECATED (member))
2124 warn_deprecated_use (member, NULL_TREE);
2127 member_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (member));
2128 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2129 presently be the anonymous union. Go outwards until we find a
2130 type related to OBJECT_TYPE. */
2131 while (ANON_AGGR_TYPE_P (member_scope)
2132 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
2134 member_scope = TYPE_CONTEXT (member_scope);
2135 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
2137 if (complain & tf_error)
2139 if (TREE_CODE (member) == FIELD_DECL)
2140 error ("invalid use of nonstatic data member %qE", member);
2142 error ("%qD is not a member of %qT", member, object_type);
2144 return error_mark_node;
2147 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2148 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
2149 in the front end; only _DECLs and _REFs are lvalues in the back end. */
2151 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
2153 object = cp_build_indirect_ref (temp, RO_NULL, complain);
2156 /* In [expr.ref], there is an explicit list of the valid choices for
2157 MEMBER. We check for each of those cases here. */
2158 if (TREE_CODE (member) == VAR_DECL)
2160 /* A static data member. */
2162 /* If OBJECT has side-effects, they are supposed to occur. */
2163 if (TREE_SIDE_EFFECTS (object))
2164 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
2166 else if (TREE_CODE (member) == FIELD_DECL)
2168 /* A non-static data member. */
2173 null_object_p = (TREE_CODE (object) == INDIRECT_REF
2174 && integer_zerop (TREE_OPERAND (object, 0)));
2176 /* Convert OBJECT to the type of MEMBER. */
2177 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
2178 TYPE_MAIN_VARIANT (member_scope)))
2183 binfo = lookup_base (access_path ? access_path : object_type,
2184 member_scope, ba_unique, &kind);
2185 if (binfo == error_mark_node)
2186 return error_mark_node;
2188 /* It is invalid to try to get to a virtual base of a
2189 NULL object. The most common cause is invalid use of
2191 if (null_object_p && kind == bk_via_virtual)
2193 if (complain & tf_error)
2195 error ("invalid access to non-static data member %qD of "
2198 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
2200 return error_mark_node;
2203 /* Convert to the base. */
2204 object = build_base_path (PLUS_EXPR, object, binfo,
2206 /* If we found the base successfully then we should be able
2207 to convert to it successfully. */
2208 gcc_assert (object != error_mark_node);
2211 /* Complain about other invalid uses of offsetof, even though they will
2212 give the right answer. Note that we complain whether or not they
2213 actually used the offsetof macro, since there's no way to know at this
2214 point. So we just give a warning, instead of a pedwarn. */
2215 /* Do not produce this warning for base class field references, because
2216 we know for a fact that didn't come from offsetof. This does occur
2217 in various testsuite cases where a null object is passed where a
2218 vtable access is required. */
2219 if (null_object_p && warn_invalid_offsetof
2220 && CLASSTYPE_NON_STD_LAYOUT (object_type)
2221 && !DECL_FIELD_IS_BASE (member)
2222 && cp_unevaluated_operand == 0
2223 && (complain & tf_warning))
2225 warning (OPT_Winvalid_offsetof,
2226 "invalid access to non-static data member %qD "
2227 " of NULL object", member);
2228 warning (OPT_Winvalid_offsetof,
2229 "(perhaps the %<offsetof%> macro was used incorrectly)");
2232 /* If MEMBER is from an anonymous aggregate, we have converted
2233 OBJECT so that it refers to the class containing the
2234 anonymous union. Generate a reference to the anonymous union
2235 itself, and recur to find MEMBER. */
2236 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
2237 /* When this code is called from build_field_call, the
2238 object already has the type of the anonymous union.
2239 That is because the COMPONENT_REF was already
2240 constructed, and was then disassembled before calling
2241 build_field_call. After the function-call code is
2242 cleaned up, this waste can be eliminated. */
2243 && (!same_type_ignoring_top_level_qualifiers_p
2244 (TREE_TYPE (object), DECL_CONTEXT (member))))
2246 tree anonymous_union;
2248 anonymous_union = lookup_anon_field (TREE_TYPE (object),
2249 DECL_CONTEXT (member));
2250 object = build_class_member_access_expr (object,
2252 /*access_path=*/NULL_TREE,
2257 /* Compute the type of the field, as described in [expr.ref]. */
2258 type_quals = TYPE_UNQUALIFIED;
2259 member_type = TREE_TYPE (member);
2260 if (TREE_CODE (member_type) != REFERENCE_TYPE)
2262 type_quals = (cp_type_quals (member_type)
2263 | cp_type_quals (object_type));
2265 /* A field is const (volatile) if the enclosing object, or the
2266 field itself, is const (volatile). But, a mutable field is
2267 not const, even within a const object. */
2268 if (DECL_MUTABLE_P (member))
2269 type_quals &= ~TYPE_QUAL_CONST;
2270 member_type = cp_build_qualified_type (member_type, type_quals);
2273 result = build3 (COMPONENT_REF, member_type, object, member,
2275 result = fold_if_not_in_template (result);
2277 /* Mark the expression const or volatile, as appropriate. Even
2278 though we've dealt with the type above, we still have to mark the
2279 expression itself. */
2280 if (type_quals & TYPE_QUAL_CONST)
2281 TREE_READONLY (result) = 1;
2282 if (type_quals & TYPE_QUAL_VOLATILE)
2283 TREE_THIS_VOLATILE (result) = 1;
2285 else if (BASELINK_P (member))
2287 /* The member is a (possibly overloaded) member function. */
2291 /* If the MEMBER is exactly one static member function, then we
2292 know the type of the expression. Otherwise, we must wait
2293 until overload resolution has been performed. */
2294 functions = BASELINK_FUNCTIONS (member);
2295 if (TREE_CODE (functions) == FUNCTION_DECL
2296 && DECL_STATIC_FUNCTION_P (functions))
2297 type = TREE_TYPE (functions);
2299 type = unknown_type_node;
2300 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2301 base. That will happen when the function is called. */
2302 result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
2304 else if (TREE_CODE (member) == CONST_DECL)
2306 /* The member is an enumerator. */
2308 /* If OBJECT has side-effects, they are supposed to occur. */
2309 if (TREE_SIDE_EFFECTS (object))
2310 result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
2315 if (complain & tf_error)
2316 error ("invalid use of %qD", member);
2317 return error_mark_node;
2320 if (!preserve_reference)
2323 If E2 is declared to have type "reference to T", then ... the
2324 type of E1.E2 is T. */
2325 result = convert_from_reference (result);
2330 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2331 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
2334 lookup_destructor (tree object, tree scope, tree dtor_name)
2336 tree object_type = TREE_TYPE (object);
2337 tree dtor_type = TREE_OPERAND (dtor_name, 0);
2340 if (scope && !check_dtor_name (scope, dtor_type))
2342 error ("qualified type %qT does not match destructor name ~%qT",
2344 return error_mark_node;
2346 if (TREE_CODE (dtor_type) == IDENTIFIER_NODE)
2348 /* In a template, names we can't find a match for are still accepted
2349 destructor names, and we check them here. */
2350 if (check_dtor_name (object_type, dtor_type))
2351 dtor_type = object_type;
2354 error ("object type %qT does not match destructor name ~%qT",
2355 object_type, dtor_type);
2356 return error_mark_node;
2360 else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2362 error ("the type being destroyed is %qT, but the destructor refers to %qT",
2363 TYPE_MAIN_VARIANT (object_type), dtor_type);
2364 return error_mark_node;
2366 expr = lookup_member (dtor_type, complete_dtor_identifier,
2367 /*protect=*/1, /*want_type=*/false);
2368 expr = (adjust_result_of_qualified_name_lookup
2369 (expr, dtor_type, object_type));
2373 /* An expression of the form "A::template B" has been resolved to
2374 DECL. Issue a diagnostic if B is not a template or template
2378 check_template_keyword (tree decl)
2380 /* The standard says:
2384 If a name prefixed by the keyword template is not a member
2385 template, the program is ill-formed.
2387 DR 228 removed the restriction that the template be a member
2390 DR 96, if accepted would add the further restriction that explicit
2391 template arguments must be provided if the template keyword is
2392 used, but, as of 2005-10-16, that DR is still in "drafting". If
2393 this DR is accepted, then the semantic checks here can be
2394 simplified, as the entity named must in fact be a template
2395 specialization, rather than, as at present, a set of overloaded
2396 functions containing at least one template function. */
2397 if (TREE_CODE (decl) != TEMPLATE_DECL
2398 && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2400 if (!is_overloaded_fn (decl))
2401 permerror (input_location, "%qD is not a template", decl);
2406 if (BASELINK_P (fns))
2407 fns = BASELINK_FUNCTIONS (fns);
2410 tree fn = OVL_CURRENT (fns);
2411 if (TREE_CODE (fn) == TEMPLATE_DECL
2412 || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2414 if (TREE_CODE (fn) == FUNCTION_DECL
2415 && DECL_USE_TEMPLATE (fn)
2416 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2418 fns = OVL_NEXT (fns);
2421 permerror (input_location, "%qD is not a template", decl);
2426 /* This function is called by the parser to process a class member
2427 access expression of the form OBJECT.NAME. NAME is a node used by
2428 the parser to represent a name; it is not yet a DECL. It may,
2429 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2430 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2431 there is no reason to do the lookup twice, so the parser keeps the
2432 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2433 be a template via the use of the "A::template B" syntax. */
2436 finish_class_member_access_expr (tree object, tree name, bool template_p,
2437 tsubst_flags_t complain)
2442 tree access_path = NULL_TREE;
2443 tree orig_object = object;
2444 tree orig_name = name;
2446 if (object == error_mark_node || name == error_mark_node)
2447 return error_mark_node;
2449 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2450 if (!objc_is_public (object, name))
2451 return error_mark_node;
2453 object_type = TREE_TYPE (object);
2455 if (processing_template_decl)
2457 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2458 dependent_type_p (object_type)
2459 /* If NAME is just an IDENTIFIER_NODE, then the expression
2461 || TREE_CODE (object) == IDENTIFIER_NODE
2462 /* If NAME is "f<args>", where either 'f' or 'args' is
2463 dependent, then the expression is dependent. */
2464 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2465 && dependent_template_id_p (TREE_OPERAND (name, 0),
2466 TREE_OPERAND (name, 1)))
2467 /* If NAME is "T::X" where "T" is dependent, then the
2468 expression is dependent. */
2469 || (TREE_CODE (name) == SCOPE_REF
2470 && TYPE_P (TREE_OPERAND (name, 0))
2471 && dependent_type_p (TREE_OPERAND (name, 0))))
2472 return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2473 object = build_non_dependent_expr (object);
2478 The type of the first expression shall be "class object" (of a
2480 if (!currently_open_class (object_type)
2481 && !complete_type_or_else (object_type, object))
2482 return error_mark_node;
2483 if (!CLASS_TYPE_P (object_type))
2485 if (complain & tf_error)
2486 error ("request for member %qD in %qE, which is of non-class type %qT",
2487 name, object, object_type);
2488 return error_mark_node;
2491 if (BASELINK_P (name))
2492 /* A member function that has already been looked up. */
2496 bool is_template_id = false;
2497 tree template_args = NULL_TREE;
2500 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2502 is_template_id = true;
2503 template_args = TREE_OPERAND (name, 1);
2504 name = TREE_OPERAND (name, 0);
2506 if (TREE_CODE (name) == OVERLOAD)
2507 name = DECL_NAME (get_first_fn (name));
2508 else if (DECL_P (name))
2509 name = DECL_NAME (name);
2512 if (TREE_CODE (name) == SCOPE_REF)
2514 /* A qualified name. The qualifying class or namespace `S'
2515 has already been looked up; it is either a TYPE or a
2517 scope = TREE_OPERAND (name, 0);
2518 name = TREE_OPERAND (name, 1);
2520 /* If SCOPE is a namespace, then the qualified name does not
2521 name a member of OBJECT_TYPE. */
2522 if (TREE_CODE (scope) == NAMESPACE_DECL)
2524 if (complain & tf_error)
2525 error ("%<%D::%D%> is not a member of %qT",
2526 scope, name, object_type);
2527 return error_mark_node;
2530 gcc_assert (CLASS_TYPE_P (scope));
2531 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2532 || TREE_CODE (name) == BIT_NOT_EXPR);
2534 if (constructor_name_p (name, scope))
2536 if (complain & tf_error)
2537 error ("cannot call constructor %<%T::%D%> directly",
2539 return error_mark_node;
2542 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2543 access_path = lookup_base (object_type, scope, ba_check, NULL);
2544 if (access_path == error_mark_node)
2545 return error_mark_node;
2548 if (complain & tf_error)
2549 error ("%qT is not a base of %qT", scope, object_type);
2550 return error_mark_node;
2556 access_path = object_type;
2559 if (TREE_CODE (name) == BIT_NOT_EXPR)
2560 member = lookup_destructor (object, scope, name);
2563 /* Look up the member. */
2564 member = lookup_member (access_path, name, /*protect=*/1,
2565 /*want_type=*/false);
2566 if (member == NULL_TREE)
2568 if (complain & tf_error)
2569 error ("%qD has no member named %qE", object_type, name);
2570 return error_mark_node;
2572 if (member == error_mark_node)
2573 return error_mark_node;
2578 tree templ = member;
2580 if (BASELINK_P (templ))
2581 templ = lookup_template_function (templ, template_args);
2584 if (complain & tf_error)
2585 error ("%qD is not a member template function", name);
2586 return error_mark_node;
2591 if (TREE_DEPRECATED (member))
2592 warn_deprecated_use (member, NULL_TREE);
2595 check_template_keyword (member);
2597 expr = build_class_member_access_expr (object, member, access_path,
2598 /*preserve_reference=*/false,
2600 if (processing_template_decl && expr != error_mark_node)
2602 if (BASELINK_P (member))
2604 if (TREE_CODE (orig_name) == SCOPE_REF)
2605 BASELINK_QUALIFIED_P (member) = 1;
2608 return build_min_non_dep (COMPONENT_REF, expr,
2609 orig_object, orig_name,
2616 /* Return an expression for the MEMBER_NAME field in the internal
2617 representation of PTRMEM, a pointer-to-member function. (Each
2618 pointer-to-member function type gets its own RECORD_TYPE so it is
2619 more convenient to access the fields by name than by FIELD_DECL.)
2620 This routine converts the NAME to a FIELD_DECL and then creates the
2621 node for the complete expression. */
2624 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2630 /* This code is a stripped down version of
2631 build_class_member_access_expr. It does not work to use that
2632 routine directly because it expects the object to be of class
2634 ptrmem_type = TREE_TYPE (ptrmem);
2635 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2636 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2637 /*want_type=*/false);
2638 member_type = cp_build_qualified_type (TREE_TYPE (member),
2639 cp_type_quals (ptrmem_type));
2640 return fold_build3_loc (input_location,
2641 COMPONENT_REF, member_type,
2642 ptrmem, member, NULL_TREE);
2645 /* Given an expression PTR for a pointer, return an expression
2646 for the value pointed to.
2647 ERRORSTRING is the name of the operator to appear in error messages.
2649 This function may need to overload OPERATOR_FNNAME.
2650 Must also handle REFERENCE_TYPEs for C++. */
2653 build_x_indirect_ref (tree expr, ref_operator errorstring,
2654 tsubst_flags_t complain)
2656 tree orig_expr = expr;
2659 if (processing_template_decl)
2661 /* Retain the type if we know the operand is a pointer so that
2662 describable_type doesn't make auto deduction break. */
2663 if (TREE_TYPE (expr) && POINTER_TYPE_P (TREE_TYPE (expr)))
2664 return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
2665 if (type_dependent_expression_p (expr))
2666 return build_min_nt (INDIRECT_REF, expr);
2667 expr = build_non_dependent_expr (expr);
2670 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2671 NULL_TREE, /*overloaded_p=*/NULL, complain);
2673 rval = cp_build_indirect_ref (expr, errorstring, complain);
2675 if (processing_template_decl && rval != error_mark_node)
2676 return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2681 /* Helper function called from c-common. */
2683 build_indirect_ref (location_t loc __attribute__ ((__unused__)),
2684 tree ptr, ref_operator errorstring)
2686 return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2690 cp_build_indirect_ref (tree ptr, ref_operator errorstring,
2691 tsubst_flags_t complain)
2695 if (ptr == error_mark_node)
2696 return error_mark_node;
2698 if (ptr == current_class_ptr)
2699 return current_class_ref;
2701 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2702 ? ptr : decay_conversion (ptr));
2703 type = TREE_TYPE (pointer);
2705 if (POINTER_TYPE_P (type))
2709 If the type of the expression is "pointer to T," the type
2710 of the result is "T." */
2711 tree t = TREE_TYPE (type);
2713 if (CONVERT_EXPR_P (ptr)
2714 || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2716 /* If a warning is issued, mark it to avoid duplicates from
2717 the backend. This only needs to be done at
2718 warn_strict_aliasing > 2. */
2719 if (warn_strict_aliasing > 2)
2720 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2721 type, TREE_OPERAND (ptr, 0)))
2722 TREE_NO_WARNING (ptr) = 1;
2725 if (VOID_TYPE_P (t))
2727 /* A pointer to incomplete type (other than cv void) can be
2728 dereferenced [expr.unary.op]/1 */
2729 if (complain & tf_error)
2730 error ("%qT is not a pointer-to-object type", type);
2731 return error_mark_node;
2733 else if (TREE_CODE (pointer) == ADDR_EXPR
2734 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2735 /* The POINTER was something like `&x'. We simplify `*&x' to
2737 return TREE_OPERAND (pointer, 0);
2740 tree ref = build1 (INDIRECT_REF, t, pointer);
2742 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2743 so that we get the proper error message if the result is used
2744 to assign to. Also, &* is supposed to be a no-op. */
2745 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2746 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2747 TREE_SIDE_EFFECTS (ref)
2748 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2752 else if (!(complain & tf_error))
2753 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
2755 /* `pointer' won't be an error_mark_node if we were given a
2756 pointer to member, so it's cool to check for this here. */
2757 else if (TYPE_PTR_TO_MEMBER_P (type))
2758 switch (errorstring)
2760 case RO_ARRAY_INDEXING:
2761 error ("invalid use of array indexing on pointer to member");
2764 error ("invalid use of unary %<*%> on pointer to member");
2766 case RO_IMPLICIT_CONVERSION:
2767 error ("invalid use of implicit conversion on pointer to member");
2772 else if (pointer != error_mark_node)
2773 switch (errorstring)
2776 error ("invalid type argument");
2778 case RO_ARRAY_INDEXING:
2779 error ("invalid type argument of array indexing");
2782 error ("invalid type argument of unary %<*%>");
2784 case RO_IMPLICIT_CONVERSION:
2785 error ("invalid type argument of implicit conversion");
2790 return error_mark_node;
2793 /* This handles expressions of the form "a[i]", which denotes
2796 This is logically equivalent in C to *(a+i), but we may do it differently.
2797 If A is a variable or a member, we generate a primitive ARRAY_REF.
2798 This avoids forcing the array out of registers, and can work on
2799 arrays that are not lvalues (for example, members of structures returned
2802 If INDEX is of some user-defined type, it must be converted to
2803 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2804 will inherit the type of the array, which will be some pointer type.
2806 LOC is the location to use in building the array reference. */
2809 build_array_ref (location_t loc, tree array, tree idx)
2815 error_at (loc, "subscript missing in array reference");
2816 return error_mark_node;
2819 if (TREE_TYPE (array) == error_mark_node
2820 || TREE_TYPE (idx) == error_mark_node)
2821 return error_mark_node;
2823 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2825 switch (TREE_CODE (array))
2829 tree value = build_array_ref (loc, TREE_OPERAND (array, 1), idx);
2830 ret = build2 (COMPOUND_EXPR, TREE_TYPE (value),
2831 TREE_OPERAND (array, 0), value);
2832 SET_EXPR_LOCATION (ret, loc);
2837 ret = build_conditional_expr
2838 (TREE_OPERAND (array, 0),
2839 build_array_ref (loc, TREE_OPERAND (array, 1), idx),
2840 build_array_ref (loc, TREE_OPERAND (array, 2), idx),
2841 tf_warning_or_error);
2842 protected_set_expr_location (ret, loc);
2849 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2853 warn_array_subscript_with_type_char (idx);
2855 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2857 error_at (loc, "array subscript is not an integer");
2858 return error_mark_node;
2861 /* Apply integral promotions *after* noticing character types.
2862 (It is unclear why we do these promotions -- the standard
2863 does not say that we should. In fact, the natural thing would
2864 seem to be to convert IDX to ptrdiff_t; we're performing
2865 pointer arithmetic.) */
2866 idx = perform_integral_promotions (idx);
2868 /* An array that is indexed by a non-constant
2869 cannot be stored in a register; we must be able to do
2870 address arithmetic on its address.
2871 Likewise an array of elements of variable size. */
2872 if (TREE_CODE (idx) != INTEGER_CST
2873 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2874 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2877 if (!cxx_mark_addressable (array))
2878 return error_mark_node;
2881 /* An array that is indexed by a constant value which is not within
2882 the array bounds cannot be stored in a register either; because we
2883 would get a crash in store_bit_field/extract_bit_field when trying
2884 to access a non-existent part of the register. */
2885 if (TREE_CODE (idx) == INTEGER_CST
2886 && TYPE_DOMAIN (TREE_TYPE (array))
2887 && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2889 if (!cxx_mark_addressable (array))
2890 return error_mark_node;
2893 if (!lvalue_p (array))
2894 pedwarn (loc, OPT_pedantic,
2895 "ISO C++ forbids subscripting non-lvalue array");
2897 /* Note in C++ it is valid to subscript a `register' array, since
2898 it is valid to take the address of something with that
2899 storage specification. */
2903 while (TREE_CODE (foo) == COMPONENT_REF)
2904 foo = TREE_OPERAND (foo, 0);
2905 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2906 warning_at (loc, OPT_Wextra,
2907 "subscripting array declared %<register%>");
2910 type = TREE_TYPE (TREE_TYPE (array));
2911 rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2912 /* Array ref is const/volatile if the array elements are
2913 or if the array is.. */
2914 TREE_READONLY (rval)
2915 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2916 TREE_SIDE_EFFECTS (rval)
2917 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2918 TREE_THIS_VOLATILE (rval)
2919 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2920 ret = require_complete_type (fold_if_not_in_template (rval));
2921 protected_set_expr_location (ret, loc);
2926 tree ar = default_conversion (array);
2927 tree ind = default_conversion (idx);
2929 /* Put the integer in IND to simplify error checking. */
2930 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2937 if (ar == error_mark_node)
2940 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2942 error_at (loc, "subscripted value is neither array nor pointer");
2943 return error_mark_node;
2945 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2947 error_at (loc, "array subscript is not an integer");
2948 return error_mark_node;
2951 warn_array_subscript_with_type_char (idx);
2953 ret = cp_build_indirect_ref (cp_build_binary_op (input_location,
2955 tf_warning_or_error),
2957 tf_warning_or_error);
2958 protected_set_expr_location (ret, loc);
2963 /* Resolve a pointer to member function. INSTANCE is the object
2964 instance to use, if the member points to a virtual member.
2966 This used to avoid checking for virtual functions if basetype
2967 has no virtual functions, according to an earlier ANSI draft.
2968 With the final ISO C++ rules, such an optimization is
2969 incorrect: A pointer to a derived member can be static_cast
2970 to pointer-to-base-member, as long as the dynamic object
2971 later has the right member. */
2974 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2976 if (TREE_CODE (function) == OFFSET_REF)
2977 function = TREE_OPERAND (function, 1);
2979 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2981 tree idx, delta, e1, e2, e3, vtbl, basetype;
2982 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2984 tree instance_ptr = *instance_ptrptr;
2985 tree instance_save_expr = 0;
2986 if (instance_ptr == error_mark_node)
2988 if (TREE_CODE (function) == PTRMEM_CST)
2990 /* Extracting the function address from a pmf is only
2991 allowed with -Wno-pmf-conversions. It only works for
2993 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2994 e1 = convert (fntype, e1);
2999 error ("object missing in use of %qE", function);
3000 return error_mark_node;
3004 if (TREE_SIDE_EFFECTS (instance_ptr))
3005 instance_ptr = instance_save_expr = save_expr (instance_ptr);
3007 if (TREE_SIDE_EFFECTS (function))
3008 function = save_expr (function);
3010 /* Start by extracting all the information from the PMF itself. */
3011 e3 = pfn_from_ptrmemfunc (function);
3012 delta = delta_from_ptrmemfunc (function);
3013 idx = build1 (NOP_EXPR, vtable_index_type, e3);
3014 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
3016 case ptrmemfunc_vbit_in_pfn:
3017 e1 = cp_build_binary_op (input_location,
3018 BIT_AND_EXPR, idx, integer_one_node,
3019 tf_warning_or_error);
3020 idx = cp_build_binary_op (input_location,
3021 MINUS_EXPR, idx, integer_one_node,
3022 tf_warning_or_error);
3025 case ptrmemfunc_vbit_in_delta:
3026 e1 = cp_build_binary_op (input_location,
3027 BIT_AND_EXPR, delta, integer_one_node,
3028 tf_warning_or_error);
3029 delta = cp_build_binary_op (input_location,
3030 RSHIFT_EXPR, delta, integer_one_node,
3031 tf_warning_or_error);
3038 /* Convert down to the right base before using the instance. A
3039 special case is that in a pointer to member of class C, C may
3040 be incomplete. In that case, the function will of course be
3041 a member of C, and no conversion is required. In fact,
3042 lookup_base will fail in that case, because incomplete
3043 classes do not have BINFOs. */
3044 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
3045 if (!same_type_ignoring_top_level_qualifiers_p
3046 (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
3048 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
3049 basetype, ba_check, NULL);
3050 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
3052 if (instance_ptr == error_mark_node)
3053 return error_mark_node;
3055 /* ...and then the delta in the PMF. */
3056 instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
3057 instance_ptr, fold_convert (sizetype, delta));
3059 /* Hand back the adjusted 'this' argument to our caller. */
3060 *instance_ptrptr = instance_ptr;
3062 /* Next extract the vtable pointer from the object. */
3063 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
3065 vtbl = cp_build_indirect_ref (vtbl, RO_NULL, tf_warning_or_error);
3066 /* If the object is not dynamic the access invokes undefined
3067 behavior. As it is not executed in this case silence the
3068 spurious warnings it may provoke. */
3069 TREE_NO_WARNING (vtbl) = 1;
3071 /* Finally, extract the function pointer from the vtable. */
3072 e2 = fold_build2_loc (input_location,
3073 POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
3074 fold_convert (sizetype, idx));
3075 e2 = cp_build_indirect_ref (e2, RO_NULL, tf_warning_or_error);
3076 TREE_CONSTANT (e2) = 1;
3078 /* When using function descriptors, the address of the
3079 vtable entry is treated as a function pointer. */
3080 if (TARGET_VTABLE_USES_DESCRIPTORS)
3081 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
3082 cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
3083 tf_warning_or_error));
3085 e2 = fold_convert (TREE_TYPE (e3), e2);
3086 e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
3088 /* Make sure this doesn't get evaluated first inside one of the
3089 branches of the COND_EXPR. */
3090 if (instance_save_expr)
3091 e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
3092 instance_save_expr, e1);
3099 /* Used by the C-common bits. */
3101 build_function_call (location_t loc ATTRIBUTE_UNUSED,
3102 tree function, tree params)
3104 return cp_build_function_call (function, params, tf_warning_or_error);
3107 /* Used by the C-common bits. */
3109 build_function_call_vec (location_t loc ATTRIBUTE_UNUSED,
3110 tree function, VEC(tree,gc) *params,
3111 VEC(tree,gc) *origtypes ATTRIBUTE_UNUSED)
3113 VEC(tree,gc) *orig_params = params;
3114 tree ret = cp_build_function_call_vec (function, ¶ms,
3115 tf_warning_or_error);
3117 /* cp_build_function_call_vec can reallocate PARAMS by adding
3118 default arguments. That should never happen here. Verify
3120 gcc_assert (params == orig_params);
3125 /* Build a function call using a tree list of arguments. */
3128 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
3133 vec = make_tree_vector ();
3134 for (; params != NULL_TREE; params = TREE_CHAIN (params))
3135 VEC_safe_push (tree, gc, vec, TREE_VALUE (params));
3136 ret = cp_build_function_call_vec (function, &vec, complain);
3137 release_tree_vector (vec);
3141 /* Build a function call using a vector of arguments. PARAMS may be
3142 NULL if there are no parameters. This changes the contents of
3146 cp_build_function_call_vec (tree function, VEC(tree,gc) **params,
3147 tsubst_flags_t complain)
3149 tree fntype, fndecl;
3151 tree original = function;
3155 VEC(tree,gc) *allocated = NULL;
3158 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3159 expressions, like those used for ObjC messenger dispatches. */
3160 if (params != NULL && !VEC_empty (tree, *params))
3161 function = objc_rewrite_function_call (function,
3162 VEC_index (tree, *params, 0));
3164 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3165 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
3166 if (TREE_CODE (function) == NOP_EXPR
3167 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
3168 function = TREE_OPERAND (function, 0);
3170 if (TREE_CODE (function) == FUNCTION_DECL)
3172 mark_used (function);
3175 /* Convert anything with function type to a pointer-to-function. */
3176 if (DECL_MAIN_P (function) && (complain & tf_error))
3177 pedwarn (input_location, OPT_pedantic,
3178 "ISO C++ forbids calling %<::main%> from within program");
3180 function = build_addr_func (function);
3186 function = build_addr_func (function);
3189 if (function == error_mark_node)
3190 return error_mark_node;
3192 fntype = TREE_TYPE (function);
3194 if (TYPE_PTRMEMFUNC_P (fntype))
3196 if (complain & tf_error)
3197 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
3198 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
3199 original, original);
3200 return error_mark_node;
3203 is_method = (TREE_CODE (fntype) == POINTER_TYPE
3204 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
3206 if (!((TREE_CODE (fntype) == POINTER_TYPE
3207 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
3209 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
3211 if (complain & tf_error)
3212 error ("%qE cannot be used as a function", original);
3213 return error_mark_node;
3216 /* fntype now gets the type of function pointed to. */
3217 fntype = TREE_TYPE (fntype);
3218 parm_types = TYPE_ARG_TYPES (fntype);
3222 allocated = make_tree_vector ();
3223 params = &allocated;
3226 nargs = convert_arguments (parm_types, params, fndecl, LOOKUP_NORMAL,
3229 return error_mark_node;
3231 argarray = VEC_address (tree, *params);
3233 /* Check for errors in format strings and inappropriately
3235 check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
3238 ret = build_cxx_call (function, nargs, argarray);
3240 if (allocated != NULL)
3241 release_tree_vector (allocated);
3246 /* Convert the actual parameter expressions in the list VALUES to the
3247 types in the list TYPELIST. The converted expressions are stored
3248 back in the VALUES vector.
3249 If parmdecls is exhausted, or when an element has NULL as its type,
3250 perform the default conversions.
3252 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
3254 This is also where warnings about wrong number of args are generated.
3256 Returns the actual number of arguments processed (which might be less
3257 than the length of the vector), or -1 on error.
3259 In C++, unspecified trailing parameters can be filled in with their
3260 default arguments, if such were specified. Do so here. */
3263 convert_arguments (tree typelist, VEC(tree,gc) **values, tree fndecl,
3264 int flags, tsubst_flags_t complain)
3267 const char *called_thing = 0;
3270 /* Argument passing is always copy-initialization. */
3271 flags |= LOOKUP_ONLYCONVERTING;
3275 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
3277 if (DECL_NAME (fndecl) == NULL_TREE
3278 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
3279 called_thing = "constructor";
3281 called_thing = "member function";
3284 called_thing = "function";
3287 for (i = 0, typetail = typelist;
3288 i < VEC_length (tree, *values);
3291 tree type = typetail ? TREE_VALUE (typetail) : 0;
3292 tree val = VEC_index (tree, *values, i);
3294 if (val == error_mark_node || type == error_mark_node)
3297 if (type == void_type_node)
3299 if (complain & tf_error)
3303 error ("too many arguments to %s %q+#D",
3304 called_thing, fndecl);
3305 error ("at this point in file");
3308 error ("too many arguments to function");
3315 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3316 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3317 if (TREE_CODE (val) == NOP_EXPR
3318 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3319 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3320 val = TREE_OPERAND (val, 0);
3322 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3324 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3325 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3326 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3327 val = decay_conversion (val);
3330 if (val == error_mark_node)
3335 /* Formal parm type is specified by a function prototype. */
3338 if (!COMPLETE_TYPE_P (complete_type (type)))
3340 if (complain & tf_error)
3343 error ("parameter %P of %qD has incomplete type %qT",
3346 error ("parameter %P has incomplete type %qT", i, type);
3348 parmval = error_mark_node;
3352 parmval = convert_for_initialization
3353 (NULL_TREE, type, val, flags,
3354 "argument passing", fndecl, i, complain);
3355 parmval = convert_for_arg_passing (type, parmval);
3358 if (parmval == error_mark_node)
3361 VEC_replace (tree, *values, i, parmval);
3365 if (fndecl && DECL_BUILT_IN (fndecl)
3366 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3367 /* Don't do ellipsis conversion for __built_in_constant_p
3368 as this will result in spurious errors for non-trivial
3370 val = require_complete_type (val);
3372 val = convert_arg_to_ellipsis (val);
3374 VEC_replace (tree, *values, i, val);
3378 typetail = TREE_CHAIN (typetail);
3381 if (typetail != 0 && typetail != void_list_node)
3383 /* See if there are default arguments that can be used. Because
3384 we hold default arguments in the FUNCTION_TYPE (which is so
3385 wrong), we can see default parameters here from deduced
3386 contexts (and via typeof) for indirect function calls.
3387 Fortunately we know whether we have a function decl to
3388 provide default arguments in a language conformant
3390 if (fndecl && TREE_PURPOSE (typetail)
3391 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3393 for (; typetail != void_list_node; ++i)
3396 = convert_default_arg (TREE_VALUE (typetail),
3397 TREE_PURPOSE (typetail),
3400 if (parmval == error_mark_node)
3403 VEC_safe_push (tree, gc, *values, parmval);
3404 typetail = TREE_CHAIN (typetail);
3405 /* ends with `...'. */
3406 if (typetail == NULL_TREE)
3412 if (complain & tf_error)
3416 error ("too few arguments to %s %q+#D",
3417 called_thing, fndecl);
3418 error ("at this point in file");
3421 error ("too few arguments to function");
3430 /* Build a binary-operation expression, after performing default
3431 conversions on the operands. CODE is the kind of expression to
3432 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3433 are the tree codes which correspond to ARG1 and ARG2 when issuing
3434 warnings about possibly misplaced parentheses. They may differ
3435 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3436 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3437 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3438 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3439 ARG2_CODE as ERROR_MARK. */
3442 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3443 tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3444 tsubst_flags_t complain)
3453 if (processing_template_decl)
3455 if (type_dependent_expression_p (arg1)
3456 || type_dependent_expression_p (arg2))
3457 return build_min_nt (code, arg1, arg2);
3458 arg1 = build_non_dependent_expr (arg1);
3459 arg2 = build_non_dependent_expr (arg2);
3462 if (code == DOTSTAR_EXPR)
3463 expr = build_m_component_ref (arg1, arg2);
3465 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3466 overloaded_p, complain);
3468 /* Check for cases such as x+y<<z which users are likely to
3469 misinterpret. But don't warn about obj << x + y, since that is a
3470 common idiom for I/O. */
3471 if (warn_parentheses
3472 && (complain & tf_warning)
3473 && !processing_template_decl
3474 && !error_operand_p (arg1)
3475 && !error_operand_p (arg2)
3476 && (code != LSHIFT_EXPR
3477 || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3478 warn_about_parentheses (code, arg1_code, orig_arg1, arg2_code, orig_arg2);
3480 if (processing_template_decl && expr != error_mark_node)
3481 return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3486 /* Build and return an ARRAY_REF expression. */
3489 build_x_array_ref (tree arg1, tree arg2, tsubst_flags_t complain)
3491 tree orig_arg1 = arg1;
3492 tree orig_arg2 = arg2;
3495 if (processing_template_decl)
3497 if (type_dependent_expression_p (arg1)
3498 || type_dependent_expression_p (arg2))
3499 return build_min_nt (ARRAY_REF, arg1, arg2,
3500 NULL_TREE, NULL_TREE);
3501 arg1 = build_non_dependent_expr (arg1);
3502 arg2 = build_non_dependent_expr (arg2);
3505 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3506 /*overloaded_p=*/NULL, complain);
3508 if (processing_template_decl && expr != error_mark_node)
3509 return build_min_non_dep (ARRAY_REF, expr, orig_arg1, orig_arg2,
3510 NULL_TREE, NULL_TREE);
3514 /* For the c-common bits. */
3516 build_binary_op (location_t location, enum tree_code code, tree op0, tree op1,
3517 int convert_p ATTRIBUTE_UNUSED)
3519 return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error);
3523 /* Build a binary-operation expression without default conversions.
3524 CODE is the kind of expression to build.
3525 LOCATION is the location_t of the operator in the source code.
3526 This function differs from `build' in several ways:
3527 the data type of the result is computed and recorded in it,
3528 warnings are generated if arg data types are invalid,
3529 special handling for addition and subtraction of pointers is known,
3530 and some optimization is done (operations on narrow ints
3531 are done in the narrower type when that gives the same result).
3532 Constant folding is also done before the result is returned.
3534 Note that the operands will never have enumeral types
3535 because either they have just had the default conversions performed
3536 or they have both just been converted to some other type in which
3537 the arithmetic is to be done.
3539 C++: must do special pointer arithmetic when implementing
3540 multiple inheritance, and deal with pointer to member functions. */
3543 cp_build_binary_op (location_t location,
3544 enum tree_code code, tree orig_op0, tree orig_op1,
3545 tsubst_flags_t complain)
3548 enum tree_code code0, code1;
3550 const char *invalid_op_diag;
3552 /* Expression code to give to the expression when it is built.
3553 Normally this is CODE, which is what the caller asked for,
3554 but in some special cases we change it. */
3555 enum tree_code resultcode = code;
3557 /* Data type in which the computation is to be performed.
3558 In the simplest cases this is the common type of the arguments. */
3559 tree result_type = NULL;
3561 /* Nonzero means operands have already been type-converted
3562 in whatever way is necessary.
3563 Zero means they need to be converted to RESULT_TYPE. */
3566 /* Nonzero means create the expression with this type, rather than
3568 tree build_type = 0;
3570 /* Nonzero means after finally constructing the expression
3571 convert it to this type. */
3572 tree final_type = 0;
3576 /* Nonzero if this is an operation like MIN or MAX which can
3577 safely be computed in short if both args are promoted shorts.
3578 Also implies COMMON.
3579 -1 indicates a bitwise operation; this makes a difference
3580 in the exact conditions for when it is safe to do the operation
3581 in a narrower mode. */
3584 /* Nonzero if this is a comparison operation;
3585 if both args are promoted shorts, compare the original shorts.
3586 Also implies COMMON. */
3587 int short_compare = 0;
3589 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3592 /* True if both operands have arithmetic type. */
3593 bool arithmetic_types_p;
3595 /* Apply default conversions. */
3599 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3600 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3601 || code == TRUTH_XOR_EXPR)
3603 if (!really_overloaded_fn (op0))
3604 op0 = decay_conversion (op0);
3605 if (!really_overloaded_fn (op1))
3606 op1 = decay_conversion (op1);
3610 if (!really_overloaded_fn (op0))
3611 op0 = default_conversion (op0);
3612 if (!really_overloaded_fn (op1))
3613 op1 = default_conversion (op1);
3616 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3617 STRIP_TYPE_NOPS (op0);
3618 STRIP_TYPE_NOPS (op1);
3620 /* DTRT if one side is an overloaded function, but complain about it. */
3621 if (type_unknown_p (op0))
3623 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3624 if (t != error_mark_node)
3626 if (complain & tf_error)
3627 permerror (input_location, "assuming cast to type %qT from overloaded function",
3632 if (type_unknown_p (op1))
3634 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3635 if (t != error_mark_node)
3637 if (complain & tf_error)
3638 permerror (input_location, "assuming cast to type %qT from overloaded function",
3644 type0 = TREE_TYPE (op0);
3645 type1 = TREE_TYPE (op1);
3647 /* The expression codes of the data types of the arguments tell us
3648 whether the arguments are integers, floating, pointers, etc. */
3649 code0 = TREE_CODE (type0);
3650 code1 = TREE_CODE (type1);
3652 /* If an error was already reported for one of the arguments,
3653 avoid reporting another error. */
3654 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3655 return error_mark_node;
3657 if ((invalid_op_diag
3658 = targetm.invalid_binary_op (code, type0, type1)))
3660 error (invalid_op_diag);
3661 return error_mark_node;
3664 /* Issue warnings about peculiar, but valid, uses of NULL. */
3665 if ((orig_op0 == null_node || orig_op1 == null_node)
3666 /* It's reasonable to use pointer values as operands of &&
3667 and ||, so NULL is no exception. */
3668 && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR
3669 && ( /* Both are NULL (or 0) and the operation was not a
3670 comparison or a pointer subtraction. */
3671 (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1)
3672 && code != EQ_EXPR && code != NE_EXPR && code != MINUS_EXPR)
3673 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
3674 || (!null_ptr_cst_p (orig_op0)
3675 && !TYPE_PTR_P (type0) && !TYPE_PTR_TO_MEMBER_P (type0))
3676 || (!null_ptr_cst_p (orig_op1)
3677 && !TYPE_PTR_P (type1) && !TYPE_PTR_TO_MEMBER_P (type1)))
3678 && (complain & tf_warning))
3679 /* Some sort of arithmetic operation involving NULL was
3681 warning (OPT_Wpointer_arith, "NULL used in arithmetic");
3686 /* Subtraction of two similar pointers.
3687 We must subtract them as integers, then divide by object size. */
3688 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3689 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3691 return pointer_diff (op0, op1, common_pointer_type (type0, type1));
3692 /* In all other cases except pointer - int, the usual arithmetic
3694 else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3699 /* The pointer - int case is just like pointer + int; fall
3702 if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3703 && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3707 ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3708 int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3709 if (processing_template_decl)
3711 result_type = TREE_TYPE (ptr_operand);
3714 return cp_pointer_int_sum (code,
3725 case TRUNC_DIV_EXPR:
3727 case FLOOR_DIV_EXPR:
3728 case ROUND_DIV_EXPR:
3729 case EXACT_DIV_EXPR:
3730 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3731 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3732 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3733 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3735 enum tree_code tcode0 = code0, tcode1 = code1;
3737 warn_for_div_by_zero (location, op1);
3739 if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3740 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3741 if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3742 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3744 if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3745 resultcode = RDIV_EXPR;
3747 /* When dividing two signed integers, we have to promote to int.
3748 unless we divide by a constant != -1. Note that default
3749 conversion will have been performed on the operands at this
3750 point, so we have to dig out the original type to find out if
3752 shorten = ((TREE_CODE (op0) == NOP_EXPR
3753 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3754 || (TREE_CODE (op1) == INTEGER_CST
3755 && ! integer_all_onesp (op1)));
3764 if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3765 || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3766 && !VECTOR_FLOAT_TYPE_P (type0)
3767 && !VECTOR_FLOAT_TYPE_P (type1)))
3771 case TRUNC_MOD_EXPR:
3772 case FLOOR_MOD_EXPR:
3773 warn_for_div_by_zero (location, op1);
3775 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3776 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
3777 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
3779 else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3781 /* Although it would be tempting to shorten always here, that loses
3782 on some targets, since the modulo instruction is undefined if the
3783 quotient can't be represented in the computation mode. We shorten
3784 only if unsigned or if dividing by something we know != -1. */
3785 shorten = ((TREE_CODE (op0) == NOP_EXPR
3786 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3787 || (TREE_CODE (op1) == INTEGER_CST
3788 && ! integer_all_onesp (op1)));
3793 case TRUTH_ANDIF_EXPR:
3794 case TRUTH_ORIF_EXPR:
3795 case TRUTH_AND_EXPR:
3797 result_type = boolean_type_node;
3800 /* Shift operations: result has same type as first operand;
3801 always convert second operand to int.
3802 Also set SHORT_SHIFT if shifting rightward. */
3805 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3807 result_type = type0;
3808 if (TREE_CODE (op1) == INTEGER_CST)
3810 if (tree_int_cst_lt (op1, integer_zero_node))
3812 if ((complain & tf_warning)
3813 && c_inhibit_evaluation_warnings == 0)
3814 warning (0, "right shift count is negative");
3818 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3819 && (complain & tf_warning)
3820 && c_inhibit_evaluation_warnings == 0)
3821 warning (0, "right shift count >= width of type");
3824 /* Convert the shift-count to an integer, regardless of
3825 size of value being shifted. */
3826 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3827 op1 = cp_convert (integer_type_node, op1);
3828 /* Avoid converting op1 to result_type later. */
3834 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3836 result_type = type0;
3837 if (TREE_CODE (op1) == INTEGER_CST)
3839 if (tree_int_cst_lt (op1, integer_zero_node))
3841 if ((complain & tf_warning)
3842 && c_inhibit_evaluation_warnings == 0)
3843 warning (0, "left shift count is negative");
3845 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3847 if ((complain & tf_warning)
3848 && c_inhibit_evaluation_warnings == 0)
3849 warning (0, "left shift count >= width of type");
3852 /* Convert the shift-count to an integer, regardless of
3853 size of value being shifted. */
3854 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3855 op1 = cp_convert (integer_type_node, op1);
3856 /* Avoid converting op1 to result_type later. */
3863 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3865 result_type = type0;
3866 if (TREE_CODE (op1) == INTEGER_CST)
3868 if (tree_int_cst_lt (op1, integer_zero_node))
3870 if (complain & tf_warning)
3871 warning (0, (code == LROTATE_EXPR)
3872 ? G_("left rotate count is negative")
3873 : G_("right rotate count is negative"));
3875 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3877 if (complain & tf_warning)
3878 warning (0, (code == LROTATE_EXPR)
3879 ? G_("left rotate count >= width of type")
3880 : G_("right rotate count >= width of type"));
3883 /* Convert the shift-count to an integer, regardless of
3884 size of value being shifted. */
3885 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3886 op1 = cp_convert (integer_type_node, op1);
3892 if ((complain & tf_warning)
3893 && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3894 warning (OPT_Wfloat_equal,
3895 "comparing floating point with == or != is unsafe");
3896 if ((complain & tf_warning)
3897 && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3898 || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3899 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3901 build_type = boolean_type_node;
3902 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3903 || code0 == COMPLEX_TYPE || code0 == ENUMERAL_TYPE)
3904 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3905 || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE))
3907 else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3908 || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3909 result_type = composite_pointer_type (type0, type1, op0, op1,
3910 CPO_COMPARISON, complain);
3911 else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3912 && null_ptr_cst_p (op1))
3914 if (TREE_CODE (op0) == ADDR_EXPR
3915 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3917 if (complain & tf_warning)
3918 warning (OPT_Waddress, "the address of %qD will never be NULL",
3919 TREE_OPERAND (op0, 0));
3921 result_type = type0;
3923 else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3924 && null_ptr_cst_p (op0))
3926 if (TREE_CODE (op1) == ADDR_EXPR
3927 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3929 if (complain & tf_warning)
3930 warning (OPT_Waddress, "the address of %qD will never be NULL",
3931 TREE_OPERAND (op1, 0));
3933 result_type = type1;
3935 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3937 result_type = type0;
3938 if (complain & tf_error)
3939 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3941 return error_mark_node;
3943 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3945 result_type = type1;
3946 if (complain & tf_error)
3947 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3949 return error_mark_node;
3951 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3953 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3954 == ptrmemfunc_vbit_in_delta)
3956 tree pfn0 = pfn_from_ptrmemfunc (op0);
3957 tree delta0 = delta_from_ptrmemfunc (op0);
3958 tree e1 = cp_build_binary_op (location,
3961 fold_convert (TREE_TYPE (pfn0),
3964 tree e2 = cp_build_binary_op (location,
3969 e2 = cp_build_binary_op (location,
3970 EQ_EXPR, e2, integer_zero_node,
3972 op0 = cp_build_binary_op (location,
3973 TRUTH_ANDIF_EXPR, e1, e2,
3975 op1 = cp_convert (TREE_TYPE (op0), integer_one_node);
3979 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3980 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3982 result_type = TREE_TYPE (op0);
3984 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3985 return cp_build_binary_op (location, code, op1, op0, complain);
3986 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3989 /* E will be the final comparison. */
3991 /* E1 and E2 are for scratch. */
3999 type = composite_pointer_type (type0, type1, op0, op1,
4000 CPO_COMPARISON, complain);
4002 if (!same_type_p (TREE_TYPE (op0), type))
4003 op0 = cp_convert_and_check (type, op0);
4004 if (!same_type_p (TREE_TYPE (op1), type))
4005 op1 = cp_convert_and_check (type, op1);
4007 if (op0 == error_mark_node || op1 == error_mark_node)
4008 return error_mark_node;
4010 if (TREE_SIDE_EFFECTS (op0))
4011 op0 = save_expr (op0);
4012 if (TREE_SIDE_EFFECTS (op1))
4013 op1 = save_expr (op1);
4015 pfn0 = pfn_from_ptrmemfunc (op0);
4016 pfn1 = pfn_from_ptrmemfunc (op1);
4017 delta0 = delta_from_ptrmemfunc (op0);
4018 delta1 = delta_from_ptrmemfunc (op1);
4019 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
4020 == ptrmemfunc_vbit_in_delta)
4025 && ((op0.delta == op1.delta)
4026 || (!op0.pfn && op0.delta & 1 == 0
4027 && op1.delta & 1 == 0))
4029 The reason for the `!op0.pfn' bit is that a NULL
4030 pointer-to-member is any member with a zero PFN and
4031 LSB of the DELTA field is 0. */
4033 e1 = cp_build_binary_op (location, BIT_AND_EXPR,
4037 e1 = cp_build_binary_op (location,
4038 EQ_EXPR, e1, integer_zero_node,
4040 e2 = cp_build_binary_op (location, BIT_AND_EXPR,
4044 e2 = cp_build_binary_op (location,
4045 EQ_EXPR, e2, integer_zero_node,
4047 e1 = cp_build_binary_op (location,
4048 TRUTH_ANDIF_EXPR, e2, e1,
4050 e2 = cp_build_binary_op (location, EQ_EXPR,
4052 fold_convert (TREE_TYPE (pfn0),
4055 e2 = cp_build_binary_op (location,
4056 TRUTH_ANDIF_EXPR, e2, e1, complain);
4057 e1 = cp_build_binary_op (location,
4058 EQ_EXPR, delta0, delta1, complain);
4059 e1 = cp_build_binary_op (location,
4060 TRUTH_ORIF_EXPR, e1, e2, complain);
4067 && (!op0.pfn || op0.delta == op1.delta))
4069 The reason for the `!op0.pfn' bit is that a NULL
4070 pointer-to-member is any member with a zero PFN; the
4071 DELTA field is unspecified. */
4073 e1 = cp_build_binary_op (location,
4074 EQ_EXPR, delta0, delta1, complain);
4075 e2 = cp_build_binary_op (location,
4078 fold_convert (TREE_TYPE (pfn0),
4081 e1 = cp_build_binary_op (location,
4082 TRUTH_ORIF_EXPR, e1, e2, complain);
4084 e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
4085 e = cp_build_binary_op (location,
4086 TRUTH_ANDIF_EXPR, e2, e1, complain);
4087 if (code == EQ_EXPR)
4089 return cp_build_binary_op (location,
4090 EQ_EXPR, e, integer_zero_node, complain);
4094 gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
4095 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
4097 gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
4098 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
4106 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
4107 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
4109 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
4110 result_type = composite_pointer_type (type0, type1, op0, op1,
4111 CPO_COMPARISON, complain);
4118 if (TREE_CODE (orig_op0) == STRING_CST
4119 || TREE_CODE (orig_op1) == STRING_CST)
4121 if (complain & tf_warning)
4122 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
4125 build_type = boolean_type_node;
4126 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
4127 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
4129 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
4130 result_type = composite_pointer_type (type0, type1, op0, op1,
4131 CPO_COMPARISON, complain);
4132 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
4133 && integer_zerop (op1))
4134 result_type = type0;
4135 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
4136 && integer_zerop (op0))
4137 result_type = type1;
4138 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
4140 result_type = type0;
4141 if (complain & tf_error)
4142 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
4144 return error_mark_node;
4146 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
4148 result_type = type1;
4149 if (complain & tf_error)
4150 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
4152 return error_mark_node;
4156 case UNORDERED_EXPR:
4163 build_type = integer_type_node;
4164 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
4166 if (complain & tf_error)
4167 error ("unordered comparison on non-floating point argument");
4168 return error_mark_node;
4177 if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
4178 || code0 == ENUMERAL_TYPE)
4179 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4180 || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE)))
4181 arithmetic_types_p = 1;
4184 arithmetic_types_p = 0;
4185 /* Vector arithmetic is only allowed when both sides are vectors. */
4186 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
4188 if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
4189 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
4192 binary_op_error (location, code, type0, type1);
4193 return error_mark_node;
4195 arithmetic_types_p = 1;
4198 /* Determine the RESULT_TYPE, if it is not already known. */
4200 && arithmetic_types_p
4201 && (shorten || common || short_compare))
4202 result_type = cp_common_type (type0, type1);
4206 if (complain & tf_error)
4207 error ("invalid operands of types %qT and %qT to binary %qO",
4208 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
4209 return error_mark_node;
4212 /* If we're in a template, the only thing we need to know is the
4214 if (processing_template_decl)
4216 /* Since the middle-end checks the type when doing a build2, we
4217 need to build the tree in pieces. This built tree will never
4218 get out of the front-end as we replace it when instantiating
4220 tree tmp = build2 (resultcode,
4221 build_type ? build_type : result_type,
4223 TREE_OPERAND (tmp, 0) = op0;
4227 if (arithmetic_types_p)
4229 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
4231 /* For certain operations (which identify themselves by shorten != 0)
4232 if both args were extended from the same smaller type,
4233 do the arithmetic in that type and then extend.
4235 shorten !=0 and !=1 indicates a bitwise operation.
4236 For them, this optimization is safe only if
4237 both args are zero-extended or both are sign-extended.
4238 Otherwise, we might change the result.
4239 E.g., (short)-1 | (unsigned short)-1 is (int)-1
4240 but calculated in (unsigned short) it would be (unsigned short)-1. */
4242 if (shorten && none_complex)
4244 final_type = result_type;
4245 result_type = shorten_binary_op (result_type, op0, op1,
4249 /* Comparison operations are shortened too but differently.
4250 They identify themselves by setting short_compare = 1. */
4254 /* Don't write &op0, etc., because that would prevent op0
4255 from being kept in a register.
4256 Instead, make copies of the our local variables and
4257 pass the copies by reference, then copy them back afterward. */
4258 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
4259 enum tree_code xresultcode = resultcode;
4261 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
4263 return cp_convert (boolean_type_node, val);
4264 op0 = xop0, op1 = xop1;
4266 resultcode = xresultcode;
4269 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
4270 && warn_sign_compare
4271 && !TREE_NO_WARNING (orig_op0)
4272 && !TREE_NO_WARNING (orig_op1)
4273 /* Do not warn until the template is instantiated; we cannot
4274 bound the ranges of the arguments until that point. */
4275 && !processing_template_decl
4276 && (complain & tf_warning)
4277 && c_inhibit_evaluation_warnings == 0)
4279 warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1,
4280 result_type, resultcode);
4284 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4285 Then the expression will be built.
4286 It will be given type FINAL_TYPE if that is nonzero;
4287 otherwise, it will be given type RESULT_TYPE. */
4290 if (TREE_TYPE (op0) != result_type)
4291 op0 = cp_convert_and_check (result_type, op0);
4292 if (TREE_TYPE (op1) != result_type)
4293 op1 = cp_convert_and_check (result_type, op1);
4295 if (op0 == error_mark_node || op1 == error_mark_node)
4296 return error_mark_node;
4299 if (build_type == NULL_TREE)
4300 build_type = result_type;
4302 result = build2 (resultcode, build_type, op0, op1);
4303 result = fold_if_not_in_template (result);
4304 if (final_type != 0)
4305 result = cp_convert (final_type, result);
4307 if (TREE_OVERFLOW_P (result)
4308 && !TREE_OVERFLOW_P (op0)
4309 && !TREE_OVERFLOW_P (op1))
4310 overflow_warning (location, result);
4315 /* Return a tree for the sum or difference (RESULTCODE says which)
4316 of pointer PTROP and integer INTOP. */
4319 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
4321 tree res_type = TREE_TYPE (ptrop);
4323 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
4324 in certain circumstance (when it's valid to do so). So we need
4325 to make sure it's complete. We don't need to check here, if we
4326 can actually complete it at all, as those checks will be done in
4327 pointer_int_sum() anyway. */
4328 complete_type (TREE_TYPE (res_type));
4330 return pointer_int_sum (input_location, resultcode, ptrop,
4331 fold_if_not_in_template (intop));
4334 /* Return a tree for the difference of pointers OP0 and OP1.
4335 The resulting tree has type int. */
4338 pointer_diff (tree op0, tree op1, tree ptrtype)
4341 tree restype = ptrdiff_type_node;
4342 tree target_type = TREE_TYPE (ptrtype);
4344 if (!complete_type_or_else (target_type, NULL_TREE))
4345 return error_mark_node;
4347 if (TREE_CODE (target_type) == VOID_TYPE)
4348 permerror (input_location, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
4349 if (TREE_CODE (target_type) == FUNCTION_TYPE)
4350 permerror (input_location, "ISO C++ forbids using pointer to a function in subtraction");
4351 if (TREE_CODE (target_type) == METHOD_TYPE)
4352 permerror (input_location, "ISO C++ forbids using pointer to a method in subtraction");
4354 /* First do the subtraction as integers;
4355 then drop through to build the divide operator. */
4357 op0 = cp_build_binary_op (input_location,
4359 cp_convert (restype, op0),
4360 cp_convert (restype, op1),
4361 tf_warning_or_error);
4363 /* This generates an error if op1 is a pointer to an incomplete type. */
4364 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
4365 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4367 op1 = (TYPE_PTROB_P (ptrtype)
4368 ? size_in_bytes (target_type)
4369 : integer_one_node);
4371 /* Do the division. */
4373 result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4374 return fold_if_not_in_template (result);
4377 /* Construct and perhaps optimize a tree representation
4378 for a unary operation. CODE, a tree_code, specifies the operation
4379 and XARG is the operand. */
4382 build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain)
4384 tree orig_expr = xarg;
4388 if (processing_template_decl)
4390 if (type_dependent_expression_p (xarg))
4391 return build_min_nt (code, xarg, NULL_TREE);
4393 xarg = build_non_dependent_expr (xarg);
4398 /* [expr.unary.op] says:
4400 The address of an object of incomplete type can be taken.
4402 (And is just the ordinary address operator, not an overloaded
4403 "operator &".) However, if the type is a template
4404 specialization, we must complete the type at this point so that
4405 an overloaded "operator &" will be available if required. */
4406 if (code == ADDR_EXPR
4407 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4408 && ((CLASS_TYPE_P (TREE_TYPE (xarg))
4409 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
4410 || (TREE_CODE (xarg) == OFFSET_REF)))
4411 /* Don't look for a function. */;
4413 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
4414 /*overloaded_p=*/NULL, complain);
4415 if (!exp && code == ADDR_EXPR)
4417 if (is_overloaded_fn (xarg))
4419 tree fn = get_first_fn (xarg);
4420 if (DECL_CONSTRUCTOR_P (fn) || DECL_DESTRUCTOR_P (fn))
4422 error (DECL_CONSTRUCTOR_P (fn)
4423 ? G_("taking address of constructor %qE")
4424 : G_("taking address of destructor %qE"),
4426 return error_mark_node;
4430 /* A pointer to member-function can be formed only by saying
4432 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4433 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4435 if (TREE_CODE (xarg) != OFFSET_REF
4436 || !TYPE_P (TREE_OPERAND (xarg, 0)))
4438 error ("invalid use of %qE to form a pointer-to-member-function",
4440 if (TREE_CODE (xarg) != OFFSET_REF)
4441 inform (input_location, " a qualified-id is required");
4442 return error_mark_node;
4446 error ("parentheses around %qE cannot be used to form a"
4447 " pointer-to-member-function",
4449 PTRMEM_OK_P (xarg) = 1;
4453 if (TREE_CODE (xarg) == OFFSET_REF)
4455 ptrmem = PTRMEM_OK_P (xarg);
4457 if (!ptrmem && !flag_ms_extensions
4458 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4460 /* A single non-static member, make sure we don't allow a
4461 pointer-to-member. */
4462 xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
4463 TREE_OPERAND (xarg, 0),
4464 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4465 PTRMEM_OK_P (xarg) = ptrmem;
4468 else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning))
4469 warning (0, "taking address of temporary");
4470 exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain);
4473 if (processing_template_decl && exp != error_mark_node)
4474 exp = build_min_non_dep (code, exp, orig_expr,
4475 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
4476 if (TREE_CODE (exp) == ADDR_EXPR)
4477 PTRMEM_OK_P (exp) = ptrmem;
4481 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4482 constants, where a null value is represented by an INTEGER_CST of
4486 cp_truthvalue_conversion (tree expr)
4488 tree type = TREE_TYPE (expr);
4489 if (TYPE_PTRMEM_P (type))
4490 return build_binary_op (EXPR_LOCATION (expr),
4491 NE_EXPR, expr, integer_zero_node, 1);
4493 return c_common_truthvalue_conversion (input_location, expr);
4496 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4499 condition_conversion (tree expr)
4502 if (processing_template_decl)
4504 t = perform_implicit_conversion_flags (boolean_type_node, expr,
4505 tf_warning_or_error, LOOKUP_NORMAL);
4506 t = fold_build_cleanup_point_expr (boolean_type_node, t);
4510 /* Returns the address of T. This function will fold away
4511 ADDR_EXPR of INDIRECT_REF. */
4514 build_address (tree t)
4516 if (error_operand_p (t) || !cxx_mark_addressable (t))
4517 return error_mark_node;
4518 t = build_fold_addr_expr (t);
4519 if (TREE_CODE (t) != ADDR_EXPR)
4524 /* Returns the address of T with type TYPE. */
4527 build_typed_address (tree t, tree type)
4529 if (error_operand_p (t) || !cxx_mark_addressable (t))
4530 return error_mark_node;
4531 t = build_fold_addr_expr_with_type (t, type);
4532 if (TREE_CODE (t) != ADDR_EXPR)
4537 /* Return a NOP_EXPR converting EXPR to TYPE. */
4540 build_nop (tree type, tree expr)
4542 if (type == error_mark_node || error_operand_p (expr))
4544 return build1 (NOP_EXPR, type, expr);
4547 /* C++: Must handle pointers to members.
4549 Perhaps type instantiation should be extended to handle conversion
4550 from aggregates to types we don't yet know we want? (Or are those
4551 cases typically errors which should be reported?)
4553 NOCONVERT nonzero suppresses the default promotions
4554 (such as from short to int). */
4557 cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
4558 tsubst_flags_t complain)
4560 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4563 const char *errstring = NULL;
4565 const char *invalid_op_diag;
4567 if (error_operand_p (arg))
4568 return error_mark_node;
4570 if ((invalid_op_diag
4571 = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
4576 error (invalid_op_diag);
4577 return error_mark_node;
4582 case UNARY_PLUS_EXPR:
4585 int flags = WANT_ARITH | WANT_ENUM;
4586 /* Unary plus (but not unary minus) is allowed on pointers. */
4587 if (code == UNARY_PLUS_EXPR)
4588 flags |= WANT_POINTER;
4589 arg = build_expr_type_conversion (flags, arg, true);
4591 errstring = (code == NEGATE_EXPR
4592 ? _("wrong type argument to unary minus")
4593 : _("wrong type argument to unary plus"));
4596 if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4597 arg = perform_integral_promotions (arg);
4599 /* Make sure the result is not an lvalue: a unary plus or minus
4600 expression is always a rvalue. */
4607 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4611 arg = default_conversion (arg);
4613 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
4616 errstring = _("wrong type argument to bit-complement");
4617 else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4618 arg = perform_integral_promotions (arg);
4622 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4623 errstring = _("wrong type argument to abs");
4624 else if (!noconvert)
4625 arg = default_conversion (arg);
4629 /* Conjugating a real value is a no-op, but allow it anyway. */
4630 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4631 errstring = _("wrong type argument to conjugation");
4632 else if (!noconvert)
4633 arg = default_conversion (arg);
4636 case TRUTH_NOT_EXPR:
4637 arg = perform_implicit_conversion (boolean_type_node, arg,
4639 val = invert_truthvalue_loc (input_location, arg);
4640 if (arg != error_mark_node)
4642 errstring = _("in argument to unary !");
4649 if (TREE_CODE (arg) == COMPLEX_CST)
4650 return TREE_REALPART (arg);
4651 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4653 arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4654 return fold_if_not_in_template (arg);
4660 if (TREE_CODE (arg) == COMPLEX_CST)
4661 return TREE_IMAGPART (arg);
4662 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4664 arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4665 return fold_if_not_in_template (arg);
4668 return cp_convert (TREE_TYPE (arg), integer_zero_node);
4670 case PREINCREMENT_EXPR:
4671 case POSTINCREMENT_EXPR:
4672 case PREDECREMENT_EXPR:
4673 case POSTDECREMENT_EXPR:
4674 /* Handle complex lvalues (when permitted)
4675 by reduction to simpler cases. */
4677 val = unary_complex_lvalue (code, arg);
4681 /* Increment or decrement the real part of the value,
4682 and don't change the imaginary part. */
4683 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4687 arg = stabilize_reference (arg);
4688 real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain);
4689 imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain);
4690 real = cp_build_unary_op (code, real, 1, complain);
4691 if (real == error_mark_node || imag == error_mark_node)
4692 return error_mark_node;
4693 return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4697 /* Report invalid types. */
4699 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4702 if (code == PREINCREMENT_EXPR)
4703 errstring = _("no pre-increment operator for type");
4704 else if (code == POSTINCREMENT_EXPR)
4705 errstring = _("no post-increment operator for type");
4706 else if (code == PREDECREMENT_EXPR)
4707 errstring = _("no pre-decrement operator for type");
4709 errstring = _("no post-decrement operator for type");
4712 else if (arg == error_mark_node)
4713 return error_mark_node;
4715 /* Report something read-only. */
4717 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4718 || TREE_READONLY (arg))
4720 if (complain & tf_error)
4721 readonly_error (arg, ((code == PREINCREMENT_EXPR
4722 || code == POSTINCREMENT_EXPR)
4723 ? REK_INCREMENT : REK_DECREMENT));
4725 return error_mark_node;
4730 tree declared_type = unlowered_expr_type (arg);
4732 argtype = TREE_TYPE (arg);
4734 /* ARM $5.2.5 last annotation says this should be forbidden. */
4735 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4737 if (complain & tf_error)
4738 permerror (input_location, (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4739 ? G_("ISO C++ forbids incrementing an enum")
4740 : G_("ISO C++ forbids decrementing an enum"));
4742 return error_mark_node;
4745 /* Compute the increment. */
4747 if (TREE_CODE (argtype) == POINTER_TYPE)
4749 tree type = complete_type (TREE_TYPE (argtype));
4751 if (!COMPLETE_OR_VOID_TYPE_P (type))
4753 if (complain & tf_error)
4754 error (((code == PREINCREMENT_EXPR
4755 || code == POSTINCREMENT_EXPR))
4756 ? G_("cannot increment a pointer to incomplete type %qT")
4757 : G_("cannot decrement a pointer to incomplete type %qT"),
4758 TREE_TYPE (argtype));
4760 return error_mark_node;
4762 else if ((pedantic || warn_pointer_arith)
4763 && !TYPE_PTROB_P (argtype))
4765 if (complain & tf_error)
4766 permerror (input_location, (code == PREINCREMENT_EXPR
4767 || code == POSTINCREMENT_EXPR)
4768 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4769 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4772 return error_mark_node;
4775 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4778 inc = integer_one_node;
4780 inc = cp_convert (argtype, inc);
4782 /* Complain about anything else that is not a true lvalue. */
4783 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4784 || code == POSTINCREMENT_EXPR)
4785 ? lv_increment : lv_decrement),
4787 return error_mark_node;
4789 /* Forbid using -- on `bool'. */
4790 if (TREE_CODE (declared_type) == BOOLEAN_TYPE)
4792 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4794 if (complain & tf_error)
4795 error ("invalid use of Boolean expression as operand "
4796 "to %<operator--%>");
4797 return error_mark_node;
4799 val = boolean_increment (code, arg);
4802 val = build2 (code, TREE_TYPE (arg), arg, inc);
4804 TREE_SIDE_EFFECTS (val) = 1;
4809 /* Note that this operation never does default_conversion
4810 regardless of NOCONVERT. */
4812 argtype = lvalue_type (arg);
4814 if (TREE_CODE (arg) == OFFSET_REF)
4817 if (TREE_CODE (argtype) == REFERENCE_TYPE)
4819 tree type = build_pointer_type (TREE_TYPE (argtype));
4820 arg = build1 (CONVERT_EXPR, type, arg);
4823 else if (pedantic && DECL_MAIN_P (arg))
4826 /* Apparently a lot of autoconf scripts for C++ packages do this,
4827 so only complain if -pedantic. */
4828 if (complain & (flag_pedantic_errors ? tf_error : tf_warning))
4829 pedwarn (input_location, OPT_pedantic,
4830 "ISO C++ forbids taking address of function %<::main%>");
4831 else if (flag_pedantic_errors)
4832 return error_mark_node;
4835 /* Let &* cancel out to simplify resulting code. */
4836 if (TREE_CODE (arg) == INDIRECT_REF)
4838 /* We don't need to have `current_class_ptr' wrapped in a
4839 NON_LVALUE_EXPR node. */
4840 if (arg == current_class_ref)
4841 return current_class_ptr;
4843 arg = TREE_OPERAND (arg, 0);
4844 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4846 tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4847 arg = build1 (CONVERT_EXPR, type, arg);
4850 /* Don't let this be an lvalue. */
4855 /* Uninstantiated types are all functions. Taking the
4856 address of a function is a no-op, so just return the
4859 gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4860 || !IDENTIFIER_OPNAME_P (arg));
4862 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4863 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4865 /* They're trying to take the address of a unique non-static
4866 member function. This is ill-formed (except in MS-land),
4867 but let's try to DTRT.
4868 Note: We only handle unique functions here because we don't
4869 want to complain if there's a static overload; non-unique
4870 cases will be handled by instantiate_type. But we need to
4871 handle this case here to allow casts on the resulting PMF.
4872 We could defer this in non-MS mode, but it's easier to give
4873 a useful error here. */
4875 /* Inside constant member functions, the `this' pointer
4876 contains an extra const qualifier. TYPE_MAIN_VARIANT
4877 is used here to remove this const from the diagnostics
4878 and the created OFFSET_REF. */
4879 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4880 tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4883 if (! flag_ms_extensions)
4885 tree name = DECL_NAME (fn);
4886 if (!(complain & tf_error))
4887 return error_mark_node;
4888 else if (current_class_type
4889 && TREE_OPERAND (arg, 0) == current_class_ref)
4890 /* An expression like &memfn. */
4891 permerror (input_location, "ISO C++ forbids taking the address of an unqualified"
4892 " or parenthesized non-static member function to form"
4893 " a pointer to member function. Say %<&%T::%D%>",
4896 permerror (input_location, "ISO C++ forbids taking the address of a bound member"
4897 " function to form a pointer to member function."
4901 arg = build_offset_ref (base, fn, /*address_p=*/true);
4905 if (type_unknown_p (arg))
4906 return build1 (ADDR_EXPR, unknown_type_node, arg);
4908 /* Handle complex lvalues (when permitted)
4909 by reduction to simpler cases. */
4910 val = unary_complex_lvalue (code, arg);
4914 switch (TREE_CODE (arg))
4918 case FIX_TRUNC_EXPR:
4919 /* Even if we're not being pedantic, we cannot allow this
4920 extension when we're instantiating in a SFINAE
4922 if (! lvalue_p (arg) && complain == tf_none)
4924 if (complain & tf_error)
4925 permerror (input_location, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4927 return error_mark_node;
4932 arg = BASELINK_FUNCTIONS (arg);
4936 arg = OVL_CURRENT (arg);
4940 /* Turn a reference to a non-static data member into a
4941 pointer-to-member. */
4946 if (!PTRMEM_OK_P (arg))
4947 return cp_build_unary_op (code, arg, 0, complain);
4949 t = TREE_OPERAND (arg, 1);
4950 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4952 if (complain & tf_error)
4953 error ("cannot create pointer to reference member %qD", t);
4954 return error_mark_node;
4957 type = build_ptrmem_type (context_for_name_lookup (t),
4959 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4967 /* Anything not already handled and not a true memory reference
4969 if (TREE_CODE (argtype) != FUNCTION_TYPE
4970 && TREE_CODE (argtype) != METHOD_TYPE
4971 && TREE_CODE (arg) != OFFSET_REF
4972 && !lvalue_or_else (arg, lv_addressof, complain))
4973 return error_mark_node;
4975 if (argtype != error_mark_node)
4976 argtype = build_pointer_type (argtype);
4978 /* In a template, we are processing a non-dependent expression
4979 so we can just form an ADDR_EXPR with the correct type. */
4980 if (processing_template_decl || TREE_CODE (arg) != COMPONENT_REF)
4982 val = build_address (arg);
4983 if (TREE_CODE (arg) == OFFSET_REF)
4984 PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4986 else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4988 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4990 /* We can only get here with a single static member
4992 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4993 && DECL_STATIC_FUNCTION_P (fn));
4995 val = build_address (fn);
4996 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4997 /* Do not lose object's side effects. */
4998 val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4999 TREE_OPERAND (arg, 0), val);
5001 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
5003 if (complain & tf_error)
5004 error ("attempt to take address of bit-field structure member %qD",
5005 TREE_OPERAND (arg, 1));
5006 return error_mark_node;
5010 tree object = TREE_OPERAND (arg, 0);
5011 tree field = TREE_OPERAND (arg, 1);
5012 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5013 (TREE_TYPE (object), decl_type_context (field)));
5014 val = build_address (arg);
5017 if (TREE_CODE (argtype) == POINTER_TYPE
5018 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
5020 build_ptrmemfunc_type (argtype);
5021 val = build_ptrmemfunc (argtype, val, 0,
5022 /*c_cast_p=*/false);
5034 argtype = TREE_TYPE (arg);
5035 return fold_if_not_in_template (build1 (code, argtype, arg));
5038 if (complain & tf_error)
5039 error ("%s", errstring);
5040 return error_mark_node;
5043 /* Hook for the c-common bits that build a unary op. */
5045 build_unary_op (location_t location ATTRIBUTE_UNUSED,
5046 enum tree_code code, tree xarg, int noconvert)
5048 return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
5051 /* Apply unary lvalue-demanding operator CODE to the expression ARG
5052 for certain kinds of expressions which are not really lvalues
5053 but which we can accept as lvalues.
5055 If ARG is not a kind of expression we can handle, return
5059 unary_complex_lvalue (enum tree_code code, tree arg)
5061 /* Inside a template, making these kinds of adjustments is
5062 pointless; we are only concerned with the type of the
5064 if (processing_template_decl)
5067 /* Handle (a, b) used as an "lvalue". */
5068 if (TREE_CODE (arg) == COMPOUND_EXPR)
5070 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0,
5071 tf_warning_or_error);
5072 return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
5073 TREE_OPERAND (arg, 0), real_result);
5076 /* Handle (a ? b : c) used as an "lvalue". */
5077 if (TREE_CODE (arg) == COND_EXPR
5078 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
5079 return rationalize_conditional_expr (code, arg, tf_warning_or_error);
5081 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
5082 if (TREE_CODE (arg) == MODIFY_EXPR
5083 || TREE_CODE (arg) == PREINCREMENT_EXPR
5084 || TREE_CODE (arg) == PREDECREMENT_EXPR)
5086 tree lvalue = TREE_OPERAND (arg, 0);
5087 if (TREE_SIDE_EFFECTS (lvalue))
5089 lvalue = stabilize_reference (lvalue);
5090 arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
5091 lvalue, TREE_OPERAND (arg, 1));
5093 return unary_complex_lvalue
5094 (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
5097 if (code != ADDR_EXPR)
5100 /* Handle (a = b) used as an "lvalue" for `&'. */
5101 if (TREE_CODE (arg) == MODIFY_EXPR
5102 || TREE_CODE (arg) == INIT_EXPR)
5104 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0,
5105 tf_warning_or_error);
5106 arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
5108 TREE_NO_WARNING (arg) = 1;
5112 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
5113 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
5114 || TREE_CODE (arg) == OFFSET_REF)
5117 /* We permit compiler to make function calls returning
5118 objects of aggregate type look like lvalues. */
5122 if (TREE_CODE (targ) == SAVE_EXPR)
5123 targ = TREE_OPERAND (targ, 0);
5125 if (TREE_CODE (targ) == CALL_EXPR && MAYBE_CLASS_TYPE_P (TREE_TYPE (targ)))
5127 if (TREE_CODE (arg) == SAVE_EXPR)
5130 targ = build_cplus_new (TREE_TYPE (arg), arg);
5131 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
5134 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
5135 return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
5136 TREE_OPERAND (targ, 0), current_function_decl, NULL);
5139 /* Don't let anything else be handled specially. */
5143 /* Mark EXP saying that we need to be able to take the
5144 address of it; it should not be allocated in a register.
5145 Value is true if successful.
5147 C++: we do not allow `current_class_ptr' to be addressable. */
5150 cxx_mark_addressable (tree exp)
5155 switch (TREE_CODE (x))
5162 x = TREE_OPERAND (x, 0);
5166 if (x == current_class_ptr)
5168 error ("cannot take the address of %<this%>, which is an rvalue expression");
5169 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
5175 /* Caller should not be trying to mark initialized
5176 constant fields addressable. */
5177 gcc_assert (DECL_LANG_SPECIFIC (x) == 0
5178 || DECL_IN_AGGR_P (x) == 0
5180 || DECL_EXTERNAL (x));
5185 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
5186 && !DECL_ARTIFICIAL (x))
5188 if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
5191 ("address of explicit register variable %qD requested", x);
5194 else if (extra_warnings)
5196 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
5198 TREE_ADDRESSABLE (x) = 1;
5202 TREE_ADDRESSABLE (x) = 1;
5206 TREE_ADDRESSABLE (x) = 1;
5210 TREE_ADDRESSABLE (x) = 1;
5211 cxx_mark_addressable (TREE_OPERAND (x, 0));
5219 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
5222 build_x_conditional_expr (tree ifexp, tree op1, tree op2,
5223 tsubst_flags_t complain)
5225 tree orig_ifexp = ifexp;
5226 tree orig_op1 = op1;
5227 tree orig_op2 = op2;
5230 if (processing_template_decl)
5232 /* The standard says that the expression is type-dependent if
5233 IFEXP is type-dependent, even though the eventual type of the
5234 expression doesn't dependent on IFEXP. */
5235 if (type_dependent_expression_p (ifexp)
5236 /* As a GNU extension, the middle operand may be omitted. */
5237 || (op1 && type_dependent_expression_p (op1))
5238 || type_dependent_expression_p (op2))
5239 return build_min_nt (COND_EXPR, ifexp, op1, op2);
5240 ifexp = build_non_dependent_expr (ifexp);
5242 op1 = build_non_dependent_expr (op1);
5243 op2 = build_non_dependent_expr (op2);
5246 expr = build_conditional_expr (ifexp, op1, op2, complain);
5247 if (processing_template_decl && expr != error_mark_node)
5248 return build_min_non_dep (COND_EXPR, expr,
5249 orig_ifexp, orig_op1, orig_op2);
5253 /* Given a list of expressions, return a compound expression
5254 that performs them all and returns the value of the last of them. */
5256 tree build_x_compound_expr_from_list (tree list, const char *msg)
5258 tree expr = TREE_VALUE (list);
5260 if (TREE_CHAIN (list))
5263 permerror (input_location, "%s expression list treated as compound expression", msg);
5265 for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
5266 expr = build_x_compound_expr (expr, TREE_VALUE (list),
5267 tf_warning_or_error);
5273 /* Like build_x_compound_expr_from_list, but using a VEC. */
5276 build_x_compound_expr_from_vec (VEC(tree,gc) *vec, const char *msg)
5278 if (VEC_empty (tree, vec))
5280 else if (VEC_length (tree, vec) == 1)
5281 return VEC_index (tree, vec, 0);
5289 permerror (input_location,
5290 "%s expression list treated as compound expression",
5293 expr = VEC_index (tree, vec, 0);
5294 for (ix = 1; VEC_iterate (tree, vec, ix, t); ++ix)
5295 expr = build_x_compound_expr (expr, t, tf_warning_or_error);
5301 /* Handle overloading of the ',' operator when needed. */
5304 build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain)
5307 tree orig_op1 = op1;
5308 tree orig_op2 = op2;
5310 if (processing_template_decl)
5312 if (type_dependent_expression_p (op1)
5313 || type_dependent_expression_p (op2))
5314 return build_min_nt (COMPOUND_EXPR, op1, op2);
5315 op1 = build_non_dependent_expr (op1);
5316 op2 = build_non_dependent_expr (op2);
5319 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
5320 /*overloaded_p=*/NULL, complain);
5322 result = cp_build_compound_expr (op1, op2, complain);
5324 if (processing_template_decl && result != error_mark_node)
5325 return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
5330 /* Like cp_build_compound_expr, but for the c-common bits. */
5333 build_compound_expr (location_t loc ATTRIBUTE_UNUSED, tree lhs, tree rhs)
5335 return cp_build_compound_expr (lhs, rhs, tf_warning_or_error);
5338 /* Build a compound expression. */
5341 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
5343 lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
5345 if (lhs == error_mark_node || rhs == error_mark_node)
5346 return error_mark_node;
5348 if (TREE_CODE (rhs) == TARGET_EXPR)
5350 /* If the rhs is a TARGET_EXPR, then build the compound
5351 expression inside the target_expr's initializer. This
5352 helps the compiler to eliminate unnecessary temporaries. */
5353 tree init = TREE_OPERAND (rhs, 1);
5355 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
5356 TREE_OPERAND (rhs, 1) = init;
5361 if (type_unknown_p (rhs))
5363 error ("no context to resolve type of %qE", rhs);
5364 return error_mark_node;
5367 return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
5370 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
5371 casts away constness. CAST gives the type of cast.
5373 ??? This function warns for casting away any qualifier not just
5374 const. We would like to specify exactly what qualifiers are casted
5379 check_for_casting_away_constness (tree src_type, tree dest_type,
5380 enum tree_code cast)
5382 /* C-style casts are allowed to cast away constness. With
5383 WARN_CAST_QUAL, we still want to issue a warning. */
5384 if (cast == CAST_EXPR && !warn_cast_qual)
5387 if (!casts_away_constness (src_type, dest_type))
5393 warning (OPT_Wcast_qual,
5394 "cast from type %qT to type %qT casts away qualifiers",
5395 src_type, dest_type);
5398 case STATIC_CAST_EXPR:
5399 error ("static_cast from type %qT to type %qT casts away qualifiers",
5400 src_type, dest_type);
5403 case REINTERPRET_CAST_EXPR:
5404 error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
5405 src_type, dest_type);
5412 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
5413 (another pointer-to-member type in the same hierarchy) and return
5414 the converted expression. If ALLOW_INVERSE_P is permitted, a
5415 pointer-to-derived may be converted to pointer-to-base; otherwise,
5416 only the other direction is permitted. If C_CAST_P is true, this
5417 conversion is taking place as part of a C-style cast. */
5420 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
5423 if (TYPE_PTRMEM_P (type))
5427 if (TREE_CODE (expr) == PTRMEM_CST)
5428 expr = cplus_expand_constant (expr);
5429 delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
5430 TYPE_PTRMEM_CLASS_TYPE (type),
5433 if (!integer_zerop (delta))
5435 tree cond, op1, op2;
5437 cond = cp_build_binary_op (input_location,
5440 build_int_cst (TREE_TYPE (expr), -1),
5441 tf_warning_or_error);
5442 op1 = build_nop (ptrdiff_type_node, expr);
5443 op2 = cp_build_binary_op (input_location,
5444 PLUS_EXPR, op1, delta,
5445 tf_warning_or_error);
5447 expr = fold_build3_loc (input_location,
5448 COND_EXPR, ptrdiff_type_node, cond, op1, op2);
5452 return build_nop (type, expr);
5455 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
5456 allow_inverse_p, c_cast_p);
5459 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5460 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5461 Otherwise, return EXPR unchanged. */
5464 ignore_overflows (tree expr, tree orig)
5466 if (TREE_CODE (expr) == INTEGER_CST
5467 && CONSTANT_CLASS_P (orig)
5468 && TREE_CODE (orig) != STRING_CST
5469 && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
5471 if (!TREE_OVERFLOW (orig))
5472 /* Ensure constant sharing. */
5473 expr = build_int_cst_wide (TREE_TYPE (expr),
5474 TREE_INT_CST_LOW (expr),
5475 TREE_INT_CST_HIGH (expr));
5478 /* Avoid clobbering a shared constant. */
5479 expr = copy_node (expr);
5480 TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
5486 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
5487 this static_cast is being attempted as one of the possible casts
5488 allowed by a C-style cast. (In that case, accessibility of base
5489 classes is not considered, and it is OK to cast away
5490 constness.) Return the result of the cast. *VALID_P is set to
5491 indicate whether or not the cast was valid. */
5494 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
5495 bool *valid_p, tsubst_flags_t complain)
5501 /* Assume the cast is valid. */
5504 intype = TREE_TYPE (expr);
5506 /* Save casted types in the function's used types hash table. */
5507 used_types_insert (type);
5509 /* [expr.static.cast]
5511 An lvalue of type "cv1 B", where B is a class type, can be cast
5512 to type "reference to cv2 D", where D is a class derived (clause
5513 _class.derived_) from B, if a valid standard conversion from
5514 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5515 same cv-qualification as, or greater cv-qualification than, cv1,
5516 and B is not a virtual base class of D. */
5517 /* We check this case before checking the validity of "TYPE t =
5518 EXPR;" below because for this case:
5521 struct D : public B { D(const B&); };
5523 void f() { static_cast<const D&>(b); }
5525 we want to avoid constructing a new D. The standard is not
5526 completely clear about this issue, but our interpretation is
5527 consistent with other compilers. */
5528 if (TREE_CODE (type) == REFERENCE_TYPE
5529 && CLASS_TYPE_P (TREE_TYPE (type))
5530 && CLASS_TYPE_P (intype)
5531 && (TYPE_REF_IS_RVALUE (type) || real_lvalue_p (expr))
5532 && DERIVED_FROM_P (intype, TREE_TYPE (type))
5533 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
5534 build_pointer_type (TYPE_MAIN_VARIANT
5535 (TREE_TYPE (type))))
5537 || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5541 /* There is a standard conversion from "D*" to "B*" even if "B"
5542 is ambiguous or inaccessible. If this is really a
5543 static_cast, then we check both for inaccessibility and
5544 ambiguity. However, if this is a static_cast being performed
5545 because the user wrote a C-style cast, then accessibility is
5547 base = lookup_base (TREE_TYPE (type), intype,
5548 c_cast_p ? ba_unique : ba_check,
5551 /* Convert from "B*" to "D*". This function will check that "B"
5552 is not a virtual base of "D". */
5553 expr = build_base_path (MINUS_EXPR, build_address (expr),
5554 base, /*nonnull=*/false);
5555 /* Convert the pointer to a reference -- but then remember that
5556 there are no expressions with reference type in C++. */
5557 return convert_from_reference (cp_fold_convert (type, expr));
5560 /* "An lvalue of type cv1 T1 can be cast to type rvalue reference to
5561 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
5562 if (TREE_CODE (type) == REFERENCE_TYPE
5563 && TYPE_REF_IS_RVALUE (type)
5564 && real_lvalue_p (expr)
5565 && reference_related_p (TREE_TYPE (type), intype)
5566 && (c_cast_p || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5568 expr = build_typed_address (expr, type);
5569 return convert_from_reference (expr);
5574 /* Resolve overloaded address here rather than once in
5575 implicit_conversion and again in the inverse code below. */
5576 if (TYPE_PTRMEMFUNC_P (type) && type_unknown_p (expr))
5578 expr = instantiate_type (type, expr, complain);
5579 intype = TREE_TYPE (expr);
5582 /* [expr.static.cast]
5584 An expression e can be explicitly converted to a type T using a
5585 static_cast of the form static_cast<T>(e) if the declaration T
5586 t(e);" is well-formed, for some invented temporary variable
5588 result = perform_direct_initialization_if_possible (type, expr,
5589 c_cast_p, complain);
5592 result = convert_from_reference (result);
5594 /* Ignore any integer overflow caused by the cast. */
5595 result = ignore_overflows (result, orig);
5597 /* [expr.static.cast]
5599 If T is a reference type, the result is an lvalue; otherwise,
5600 the result is an rvalue. */
5601 if (TREE_CODE (type) != REFERENCE_TYPE)
5602 result = rvalue (result);
5606 /* [expr.static.cast]
5608 Any expression can be explicitly converted to type cv void. */
5609 if (TREE_CODE (type) == VOID_TYPE)
5610 return convert_to_void (expr, /*implicit=*/NULL, complain);
5612 /* [expr.static.cast]
5614 The inverse of any standard conversion sequence (clause _conv_),
5615 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5616 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5617 (_conv.bool_) conversions, can be performed explicitly using
5618 static_cast subject to the restriction that the explicit
5619 conversion does not cast away constness (_expr.const.cast_), and
5620 the following additional rules for specific cases: */
5621 /* For reference, the conversions not excluded are: integral
5622 promotions, floating point promotion, integral conversions,
5623 floating point conversions, floating-integral conversions,
5624 pointer conversions, and pointer to member conversions. */
5627 A value of integral _or enumeration_ type can be explicitly
5628 converted to an enumeration type. */
5629 /* The effect of all that is that any conversion between any two
5630 types which are integral, floating, or enumeration types can be
5632 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type)
5633 || SCALAR_FLOAT_TYPE_P (type))
5634 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
5635 || SCALAR_FLOAT_TYPE_P (intype)))
5637 expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
5639 /* Ignore any integer overflow caused by the cast. */
5640 expr = ignore_overflows (expr, orig);
5644 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
5645 && CLASS_TYPE_P (TREE_TYPE (type))
5646 && CLASS_TYPE_P (TREE_TYPE (intype))
5647 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5648 (TREE_TYPE (intype))),
5649 build_pointer_type (TYPE_MAIN_VARIANT
5650 (TREE_TYPE (type)))))
5655 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5656 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
5657 c_cast_p ? ba_unique : ba_check,
5659 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
5662 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5663 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5670 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
5671 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
5673 if (TYPE_PTRMEM_P (type))
5675 t1 = (build_ptrmem_type
5677 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
5678 t2 = (build_ptrmem_type
5680 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
5687 if (can_convert (t1, t2) || can_convert (t2, t1))
5690 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5691 return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
5696 /* [expr.static.cast]
5698 An rvalue of type "pointer to cv void" can be explicitly
5699 converted to a pointer to object type. A value of type pointer
5700 to object converted to "pointer to cv void" and back to the
5701 original pointer type will have its original value. */
5702 if (TREE_CODE (intype) == POINTER_TYPE
5703 && VOID_TYPE_P (TREE_TYPE (intype))
5704 && TYPE_PTROB_P (type))
5707 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5708 return build_nop (type, expr);
5712 return error_mark_node;
5715 /* Return an expression representing static_cast<TYPE>(EXPR). */
5718 build_static_cast (tree type, tree expr, tsubst_flags_t complain)
5723 if (type == error_mark_node || expr == error_mark_node)
5724 return error_mark_node;
5726 if (processing_template_decl)
5728 expr = build_min (STATIC_CAST_EXPR, type, expr);
5729 /* We don't know if it will or will not have side effects. */
5730 TREE_SIDE_EFFECTS (expr) = 1;
5731 return convert_from_reference (expr);
5734 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5735 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5736 if (TREE_CODE (type) != REFERENCE_TYPE
5737 && TREE_CODE (expr) == NOP_EXPR
5738 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5739 expr = TREE_OPERAND (expr, 0);
5741 result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p,
5746 if (complain & tf_error)
5747 error ("invalid static_cast from type %qT to type %qT",
5748 TREE_TYPE (expr), type);
5749 return error_mark_node;
5752 /* EXPR is an expression with member function or pointer-to-member
5753 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5754 not permitted by ISO C++, but we accept it in some modes. If we
5755 are not in one of those modes, issue a diagnostic. Return the
5756 converted expression. */
5759 convert_member_func_to_ptr (tree type, tree expr)
5764 intype = TREE_TYPE (expr);
5765 gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5766 || TREE_CODE (intype) == METHOD_TYPE);
5768 if (pedantic || warn_pmf2ptr)
5769 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpmf_conversions,
5770 "converting from %qT to %qT", intype, type);
5772 if (TREE_CODE (intype) == METHOD_TYPE)
5773 expr = build_addr_func (expr);
5774 else if (TREE_CODE (expr) == PTRMEM_CST)
5775 expr = build_address (PTRMEM_CST_MEMBER (expr));
5778 decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5779 decl = build_address (decl);
5780 expr = get_member_function_from_ptrfunc (&decl, expr);
5783 return build_nop (type, expr);
5786 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5787 If C_CAST_P is true, this reinterpret cast is being done as part of
5788 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5789 indicate whether or not reinterpret_cast was valid. */
5792 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5793 bool *valid_p, tsubst_flags_t complain)
5797 /* Assume the cast is invalid. */
5801 if (type == error_mark_node || error_operand_p (expr))
5802 return error_mark_node;
5804 intype = TREE_TYPE (expr);
5806 /* Save casted types in the function's used types hash table. */
5807 used_types_insert (type);
5809 /* [expr.reinterpret.cast]
5810 An lvalue expression of type T1 can be cast to the type
5811 "reference to T2" if an expression of type "pointer to T1" can be
5812 explicitly converted to the type "pointer to T2" using a
5813 reinterpret_cast. */
5814 if (TREE_CODE (type) == REFERENCE_TYPE)
5816 if (! real_lvalue_p (expr))
5818 if (complain & tf_error)
5819 error ("invalid cast of an rvalue expression of type "
5822 return error_mark_node;
5825 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5826 "B" are related class types; the reinterpret_cast does not
5827 adjust the pointer. */
5828 if (TYPE_PTR_P (intype)
5829 && (complain & tf_warning)
5830 && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5831 COMPARE_BASE | COMPARE_DERIVED)))
5832 warning (0, "casting %qT to %qT does not dereference pointer",
5835 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5837 if (warn_strict_aliasing > 2)
5838 strict_aliasing_warning (TREE_TYPE (expr), type, expr);
5840 if (expr != error_mark_node)
5841 expr = build_reinterpret_cast_1
5842 (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5844 if (expr != error_mark_node)
5845 /* cp_build_indirect_ref isn't right for rvalue refs. */
5846 expr = convert_from_reference (fold_convert (type, expr));
5850 /* As a G++ extension, we consider conversions from member
5851 functions, and pointers to member functions to
5852 pointer-to-function and pointer-to-void types. If
5853 -Wno-pmf-conversions has not been specified,
5854 convert_member_func_to_ptr will issue an error message. */
5855 if ((TYPE_PTRMEMFUNC_P (intype)
5856 || TREE_CODE (intype) == METHOD_TYPE)
5857 && TYPE_PTR_P (type)
5858 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5859 || VOID_TYPE_P (TREE_TYPE (type))))
5860 return convert_member_func_to_ptr (type, expr);
5862 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5863 array-to-pointer, and function-to-pointer conversions are
5865 expr = decay_conversion (expr);
5867 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5868 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5869 if (TREE_CODE (expr) == NOP_EXPR
5870 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5871 expr = TREE_OPERAND (expr, 0);
5873 if (error_operand_p (expr))
5874 return error_mark_node;
5876 intype = TREE_TYPE (expr);
5878 /* [expr.reinterpret.cast]
5879 A pointer can be converted to any integral type large enough to
5881 if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5883 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5885 if (complain & tf_error)
5886 permerror (input_location, "cast from %qT to %qT loses precision",
5889 return error_mark_node;
5892 /* [expr.reinterpret.cast]
5893 A value of integral or enumeration type can be explicitly
5894 converted to a pointer. */
5895 else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5898 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5899 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5900 return fold_if_not_in_template (build_nop (type, expr));
5901 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5902 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5907 check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR);
5908 /* Warn about possible alignment problems. */
5909 if (STRICT_ALIGNMENT && warn_cast_align
5910 && (complain & tf_warning)
5911 && !VOID_TYPE_P (type)
5912 && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5913 && COMPLETE_TYPE_P (TREE_TYPE (type))
5914 && COMPLETE_TYPE_P (TREE_TYPE (intype))
5915 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5916 warning (OPT_Wcast_align, "cast from %qT to %qT "
5917 "increases required alignment of target type", intype, type);
5919 /* We need to strip nops here, because the front end likes to
5920 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5922 if (warn_strict_aliasing <= 2)
5923 strict_aliasing_warning (intype, type, sexpr);
5925 return fold_if_not_in_template (build_nop (type, expr));
5927 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5928 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5930 if (pedantic && (complain & tf_warning))
5931 /* Only issue a warning, as we have always supported this
5932 where possible, and it is necessary in some cases. DR 195
5933 addresses this issue, but as of 2004/10/26 is still in
5935 warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5936 return fold_if_not_in_template (build_nop (type, expr));
5938 else if (TREE_CODE (type) == VECTOR_TYPE)
5939 return fold_if_not_in_template (convert_to_vector (type, expr));
5940 else if (TREE_CODE (intype) == VECTOR_TYPE
5941 && INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5942 return fold_if_not_in_template (convert_to_integer (type, expr));
5947 if (complain & tf_error)
5948 error ("invalid cast from type %qT to type %qT", intype, type);
5949 return error_mark_node;
5952 return cp_convert (type, expr);
5956 build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain)
5958 if (type == error_mark_node || expr == error_mark_node)
5959 return error_mark_node;
5961 if (processing_template_decl)
5963 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5965 if (!TREE_SIDE_EFFECTS (t)
5966 && type_dependent_expression_p (expr))
5967 /* There might turn out to be side effects inside expr. */
5968 TREE_SIDE_EFFECTS (t) = 1;
5969 return convert_from_reference (t);
5972 return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5973 /*valid_p=*/NULL, complain);
5976 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5977 return an appropriate expression. Otherwise, return
5978 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5979 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5980 performing a C-style cast, its value upon return will indicate
5981 whether or not the conversion succeeded. */
5984 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5988 tree reference_type;
5990 /* Callers are responsible for handling error_mark_node as a
5991 destination type. */
5992 gcc_assert (dst_type != error_mark_node);
5993 /* In a template, callers should be building syntactic
5994 representations of casts, not using this machinery. */
5995 gcc_assert (!processing_template_decl);
5997 /* Assume the conversion is invalid. */
6001 if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
6004 error ("invalid use of const_cast with type %qT, "
6005 "which is not a pointer, "
6006 "reference, nor a pointer-to-data-member type", dst_type);
6007 return error_mark_node;
6010 if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
6013 error ("invalid use of const_cast with type %qT, which is a pointer "
6014 "or reference to a function type", dst_type);
6015 return error_mark_node;
6018 /* Save casted types in the function's used types hash table. */
6019 used_types_insert (dst_type);
6021 src_type = TREE_TYPE (expr);
6022 /* Expressions do not really have reference types. */
6023 if (TREE_CODE (src_type) == REFERENCE_TYPE)
6024 src_type = TREE_TYPE (src_type);
6026 /* [expr.const.cast]
6028 An lvalue of type T1 can be explicitly converted to an lvalue of
6029 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
6030 types) if a pointer to T1 can be explicitly converted to the type
6031 pointer to T2 using a const_cast. */
6032 if (TREE_CODE (dst_type) == REFERENCE_TYPE)
6034 reference_type = dst_type;
6035 if (! real_lvalue_p (expr))
6038 error ("invalid const_cast of an rvalue of type %qT to type %qT",
6039 src_type, dst_type);
6040 return error_mark_node;
6042 dst_type = build_pointer_type (TREE_TYPE (dst_type));
6043 src_type = build_pointer_type (src_type);
6047 reference_type = NULL_TREE;
6048 /* If the destination type is not a reference type, the
6049 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6050 conversions are performed. */
6051 src_type = type_decays_to (src_type);
6052 if (src_type == error_mark_node)
6053 return error_mark_node;
6056 if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
6057 && comp_ptr_ttypes_const (dst_type, src_type))
6062 /* This cast is actually a C-style cast. Issue a warning if
6063 the user is making a potentially unsafe cast. */
6064 check_for_casting_away_constness (src_type, dst_type, CAST_EXPR);
6068 expr = cp_build_unary_op (ADDR_EXPR, expr, 0,
6069 complain? tf_warning_or_error : tf_none);
6070 expr = build_nop (reference_type, expr);
6071 return convert_from_reference (expr);
6075 expr = decay_conversion (expr);
6076 /* build_c_cast puts on a NOP_EXPR to make the result not an
6077 lvalue. Strip such NOP_EXPRs if VALUE is being used in
6078 non-lvalue context. */
6079 if (TREE_CODE (expr) == NOP_EXPR
6080 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
6081 expr = TREE_OPERAND (expr, 0);
6082 return build_nop (dst_type, expr);
6087 error ("invalid const_cast from type %qT to type %qT",
6088 src_type, dst_type);
6089 return error_mark_node;
6093 build_const_cast (tree type, tree expr, tsubst_flags_t complain)
6095 if (type == error_mark_node || error_operand_p (expr))
6096 return error_mark_node;
6098 if (processing_template_decl)
6100 tree t = build_min (CONST_CAST_EXPR, type, expr);
6102 if (!TREE_SIDE_EFFECTS (t)
6103 && type_dependent_expression_p (expr))
6104 /* There might turn out to be side effects inside expr. */
6105 TREE_SIDE_EFFECTS (t) = 1;
6106 return convert_from_reference (t);
6109 return build_const_cast_1 (type, expr, complain & tf_error,
6113 /* Like cp_build_c_cast, but for the c-common bits. */
6116 build_c_cast (location_t loc ATTRIBUTE_UNUSED, tree type, tree expr)
6118 return cp_build_c_cast (type, expr, tf_warning_or_error);
6121 /* Build an expression representing an explicit C-style cast to type
6122 TYPE of expression EXPR. */
6125 cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
6131 if (type == error_mark_node || error_operand_p (expr))
6132 return error_mark_node;
6134 if (processing_template_decl)
6136 tree t = build_min (CAST_EXPR, type,
6137 tree_cons (NULL_TREE, value, NULL_TREE));
6138 /* We don't know if it will or will not have side effects. */
6139 TREE_SIDE_EFFECTS (t) = 1;
6140 return convert_from_reference (t);
6143 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
6144 'Class') should always be retained, because this information aids
6145 in method lookup. */
6146 if (objc_is_object_ptr (type)
6147 && objc_is_object_ptr (TREE_TYPE (expr)))
6148 return build_nop (type, expr);
6150 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6151 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
6152 if (TREE_CODE (type) != REFERENCE_TYPE
6153 && TREE_CODE (value) == NOP_EXPR
6154 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
6155 value = TREE_OPERAND (value, 0);
6157 if (TREE_CODE (type) == ARRAY_TYPE)
6159 /* Allow casting from T1* to T2[] because Cfront allows it.
6160 NIHCL uses it. It is not valid ISO C++ however. */
6161 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
6163 if (complain & tf_error)
6164 permerror (input_location, "ISO C++ forbids casting to an array type %qT", type);
6166 return error_mark_node;
6167 type = build_pointer_type (TREE_TYPE (type));
6171 if (complain & tf_error)
6172 error ("ISO C++ forbids casting to an array type %qT", type);
6173 return error_mark_node;
6177 if (TREE_CODE (type) == FUNCTION_TYPE
6178 || TREE_CODE (type) == METHOD_TYPE)
6180 if (complain & tf_error)
6181 error ("invalid cast to function type %qT", type);
6182 return error_mark_node;
6185 /* A C-style cast can be a const_cast. */
6186 result = build_const_cast_1 (type, value, /*complain=*/false,
6191 /* Or a static cast. */
6192 result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
6193 &valid_p, complain);
6194 /* Or a reinterpret_cast. */
6196 result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
6197 &valid_p, complain);
6198 /* The static_cast or reinterpret_cast may be followed by a
6201 /* A valid cast may result in errors if, for example, a
6202 conversion to am ambiguous base class is required. */
6203 && !error_operand_p (result))
6207 /* Non-class rvalues always have cv-unqualified type. */
6208 if (!CLASS_TYPE_P (type))
6209 type = TYPE_MAIN_VARIANT (type);
6210 result_type = TREE_TYPE (result);
6211 if (!CLASS_TYPE_P (result_type))
6212 result_type = TYPE_MAIN_VARIANT (result_type);
6213 /* If the type of RESULT does not match TYPE, perform a
6214 const_cast to make it match. If the static_cast or
6215 reinterpret_cast succeeded, we will differ by at most
6216 cv-qualification, so the follow-on const_cast is guaranteed
6218 if (!same_type_p (non_reference (type), non_reference (result_type)))
6220 result = build_const_cast_1 (type, result, false, &valid_p);
6221 gcc_assert (valid_p);
6226 return error_mark_node;
6229 /* For use from the C common bits. */
6231 build_modify_expr (location_t location ATTRIBUTE_UNUSED,
6232 tree lhs, tree lhs_origtype ATTRIBUTE_UNUSED,
6233 enum tree_code modifycode,
6234 location_t rhs_location ATTRIBUTE_UNUSED, tree rhs,
6235 tree rhs_origtype ATTRIBUTE_UNUSED)
6237 return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
6240 /* Build an assignment expression of lvalue LHS from value RHS.
6241 MODIFYCODE is the code for a binary operator that we use
6242 to combine the old value of LHS with RHS to get the new value.
6243 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
6245 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
6248 cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6249 tsubst_flags_t complain)
6253 tree lhstype = TREE_TYPE (lhs);
6254 tree olhstype = lhstype;
6255 bool plain_assign = (modifycode == NOP_EXPR);
6257 /* Avoid duplicate error messages from operands that had errors. */
6258 if (error_operand_p (lhs) || error_operand_p (rhs))
6259 return error_mark_node;
6261 /* Handle control structure constructs used as "lvalues". */
6262 switch (TREE_CODE (lhs))
6264 /* Handle --foo = 5; as these are valid constructs in C++. */
6265 case PREDECREMENT_EXPR:
6266 case PREINCREMENT_EXPR:
6267 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
6268 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
6269 stabilize_reference (TREE_OPERAND (lhs, 0)),
6270 TREE_OPERAND (lhs, 1));
6271 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0),
6272 modifycode, rhs, complain);
6273 if (newrhs == error_mark_node)
6274 return error_mark_node;
6275 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
6277 /* Handle (a, b) used as an "lvalue". */
6279 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1),
6280 modifycode, rhs, complain);
6281 if (newrhs == error_mark_node)
6282 return error_mark_node;
6283 return build2 (COMPOUND_EXPR, lhstype,
6284 TREE_OPERAND (lhs, 0), newrhs);
6287 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
6288 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
6289 stabilize_reference (TREE_OPERAND (lhs, 0)),
6290 TREE_OPERAND (lhs, 1));
6291 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs,
6293 if (newrhs == error_mark_node)
6294 return error_mark_node;
6295 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
6299 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
6300 when neither operand has side-effects. */
6301 if (!lvalue_or_else (lhs, lv_assign, complain))
6302 return error_mark_node;
6304 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
6305 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
6307 lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
6308 build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
6310 TREE_OPERAND (lhs, 0),
6311 TREE_OPERAND (lhs, 1)),
6312 TREE_OPERAND (lhs, 0),
6313 TREE_OPERAND (lhs, 1));
6316 /* Handle (a ? b : c) used as an "lvalue". */
6319 /* Produce (a ? (b = rhs) : (c = rhs))
6320 except that the RHS goes through a save-expr
6321 so the code to compute it is only emitted once. */
6323 tree preeval = NULL_TREE;
6325 if (VOID_TYPE_P (TREE_TYPE (rhs)))
6327 if (complain & tf_error)
6328 error ("void value not ignored as it ought to be");
6329 return error_mark_node;
6332 rhs = stabilize_expr (rhs, &preeval);
6334 /* Check this here to avoid odd errors when trying to convert
6335 a throw to the type of the COND_EXPR. */
6336 if (!lvalue_or_else (lhs, lv_assign, complain))
6337 return error_mark_node;
6339 cond = build_conditional_expr
6340 (TREE_OPERAND (lhs, 0),
6341 cp_build_modify_expr (TREE_OPERAND (lhs, 1),
6342 modifycode, rhs, complain),
6343 cp_build_modify_expr (TREE_OPERAND (lhs, 2),
6344 modifycode, rhs, complain),
6347 if (cond == error_mark_node)
6349 /* Make sure the code to compute the rhs comes out
6350 before the split. */
6352 cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
6360 if (modifycode == INIT_EXPR)
6362 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
6363 /* Do the default thing. */;
6364 else if (TREE_CODE (rhs) == CONSTRUCTOR)
6366 /* Compound literal. */
6367 if (! same_type_p (TREE_TYPE (rhs), lhstype))
6368 /* Call convert to generate an error; see PR 11063. */
6369 rhs = convert (lhstype, rhs);
6370 result = build2 (INIT_EXPR, lhstype, lhs, rhs);
6371 TREE_SIDE_EFFECTS (result) = 1;
6374 else if (! MAYBE_CLASS_TYPE_P (lhstype))
6375 /* Do the default thing. */;
6378 VEC(tree,gc) *rhs_vec = make_tree_vector_single (rhs);
6379 result = build_special_member_call (lhs, complete_ctor_identifier,
6380 &rhs_vec, lhstype, LOOKUP_NORMAL,
6382 release_tree_vector (rhs_vec);
6383 if (result == NULL_TREE)
6384 return error_mark_node;
6390 lhs = require_complete_type (lhs);
6391 if (lhs == error_mark_node)
6392 return error_mark_node;
6394 if (modifycode == NOP_EXPR)
6396 /* `operator=' is not an inheritable operator. */
6397 if (! MAYBE_CLASS_TYPE_P (lhstype))
6398 /* Do the default thing. */;
6401 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
6402 lhs, rhs, make_node (NOP_EXPR),
6403 /*overloaded_p=*/NULL,
6405 if (result == NULL_TREE)
6406 return error_mark_node;
6413 /* A binary op has been requested. Combine the old LHS
6414 value with the RHS producing the value we should actually
6415 store into the LHS. */
6416 gcc_assert (!((TREE_CODE (lhstype) == REFERENCE_TYPE
6417 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype)))
6418 || MAYBE_CLASS_TYPE_P (lhstype)));
6420 lhs = stabilize_reference (lhs);
6421 newrhs = cp_build_binary_op (input_location,
6422 modifycode, lhs, rhs,
6424 if (newrhs == error_mark_node)
6426 if (complain & tf_error)
6427 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode,
6428 TREE_TYPE (lhs), TREE_TYPE (rhs));
6429 return error_mark_node;
6432 /* Now it looks like a plain assignment. */
6433 modifycode = NOP_EXPR;
6435 gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
6436 gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
6439 /* The left-hand side must be an lvalue. */
6440 if (!lvalue_or_else (lhs, lv_assign, complain))
6441 return error_mark_node;
6443 /* Warn about modifying something that is `const'. Don't warn if
6444 this is initialization. */
6445 if (modifycode != INIT_EXPR
6446 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
6447 /* Functions are not modifiable, even though they are
6449 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
6450 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
6451 /* If it's an aggregate and any field is const, then it is
6452 effectively const. */
6453 || (CLASS_TYPE_P (lhstype)
6454 && C_TYPE_FIELDS_READONLY (lhstype))))
6456 if (complain & tf_error)
6457 readonly_error (lhs, REK_ASSIGNMENT);
6459 return error_mark_node;
6462 /* If storing into a structure or union member, it may have been given a
6463 lowered bitfield type. We need to convert to the declared type first,
6464 so retrieve it now. */
6466 olhstype = unlowered_expr_type (lhs);
6468 /* Convert new value to destination type. */
6470 if (TREE_CODE (lhstype) == ARRAY_TYPE)
6474 if (BRACE_ENCLOSED_INITIALIZER_P (newrhs))
6476 if (check_array_initializer (lhs, lhstype, newrhs))
6477 return error_mark_node;
6478 newrhs = digest_init (lhstype, newrhs);
6481 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
6482 TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))))
6484 if (complain & tf_error)
6485 error ("incompatible types in assignment of %qT to %qT",
6486 TREE_TYPE (rhs), lhstype);
6487 return error_mark_node;
6490 /* Allow array assignment in compiler-generated code. */
6491 else if (!current_function_decl
6492 || !DECL_ARTIFICIAL (current_function_decl))
6494 /* This routine is used for both initialization and assignment.
6495 Make sure the diagnostic message differentiates the context. */
6496 if (complain & tf_error)
6498 if (modifycode == INIT_EXPR)
6499 error ("array used as initializer");
6501 error ("invalid array assignment");
6503 return error_mark_node;
6506 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6507 ? 1 + (modifycode != INIT_EXPR): 0;
6508 return build_vec_init (lhs, NULL_TREE, newrhs,
6509 /*explicit_value_init_p=*/false,
6510 from_array, complain);
6513 if (modifycode == INIT_EXPR)
6514 /* Calls with INIT_EXPR are all direct-initialization, so don't set
6515 LOOKUP_ONLYCONVERTING. */
6516 newrhs = convert_for_initialization (lhs, olhstype, newrhs, LOOKUP_NORMAL,
6517 "initialization", NULL_TREE, 0,
6520 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6521 NULL_TREE, 0, complain, LOOKUP_IMPLICIT);
6523 if (!same_type_p (lhstype, olhstype))
6524 newrhs = cp_convert_and_check (lhstype, newrhs);
6526 if (modifycode != INIT_EXPR)
6528 if (TREE_CODE (newrhs) == CALL_EXPR
6529 && TYPE_NEEDS_CONSTRUCTING (lhstype))
6530 newrhs = build_cplus_new (lhstype, newrhs);
6532 /* Can't initialize directly from a TARGET_EXPR, since that would
6533 cause the lhs to be constructed twice, and possibly result in
6534 accidental self-initialization. So we force the TARGET_EXPR to be
6535 expanded without a target. */
6536 if (TREE_CODE (newrhs) == TARGET_EXPR)
6537 newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6538 TREE_OPERAND (newrhs, 0));
6541 if (newrhs == error_mark_node)
6542 return error_mark_node;
6544 if (c_dialect_objc () && flag_objc_gc)
6546 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6552 result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6553 lhstype, lhs, newrhs);
6555 TREE_SIDE_EFFECTS (result) = 1;
6557 TREE_NO_WARNING (result) = 1;
6563 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6564 tsubst_flags_t complain)
6566 if (processing_template_decl)
6567 return build_min_nt (MODOP_EXPR, lhs,
6568 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6570 if (modifycode != NOP_EXPR)
6572 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6573 make_node (modifycode),
6574 /*overloaded_p=*/NULL,
6578 TREE_NO_WARNING (rval) = 1;
6582 return cp_build_modify_expr (lhs, modifycode, rhs, complain);
6585 /* Helper function for get_delta_difference which assumes FROM is a base
6586 class of TO. Returns a delta for the conversion of pointer-to-member
6587 of FROM to pointer-to-member of TO. If the conversion is invalid,
6588 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
6589 If C_CAST_P is true, this conversion is taking place as part of a C-style
6593 get_delta_difference_1 (tree from, tree to, bool c_cast_p)
6598 binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
6599 if (kind == bk_inaccessible || kind == bk_ambig)
6601 error (" in pointer to member function conversion");
6602 return size_zero_node;
6606 if (kind != bk_via_virtual)
6607 return BINFO_OFFSET (binfo);
6609 /* FROM is a virtual base class of TO. Issue an error or warning
6610 depending on whether or not this is a reinterpret cast. */
6612 error ("pointer to member conversion via virtual base %qT",
6613 BINFO_TYPE (binfo_from_vbase (binfo)));
6615 return size_zero_node;
6622 /* Get difference in deltas for different pointer to member function
6623 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6624 the conversion is invalid, the constant is zero. If
6625 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6626 If C_CAST_P is true this conversion is taking place as part of a
6629 Note that the naming of FROM and TO is kind of backwards; the return
6630 value is what we add to a TO in order to get a FROM. They are named
6631 this way because we call this function to find out how to convert from
6632 a pointer to member of FROM to a pointer to member of TO. */
6635 get_delta_difference (tree from, tree to,
6636 bool allow_inverse_p,
6641 if (same_type_ignoring_top_level_qualifiers_p (from, to))
6642 /* Pointer to member of incomplete class is permitted*/
6643 result = size_zero_node;
6645 result = get_delta_difference_1 (from, to, c_cast_p);
6649 if (!allow_inverse_p)
6651 error_not_base_type (from, to);
6652 error (" in pointer to member conversion");
6653 result = size_zero_node;
6657 result = get_delta_difference_1 (to, from, c_cast_p);
6660 result = size_diffop_loc (input_location,
6661 size_zero_node, result);
6664 error_not_base_type (from, to);
6665 error (" in pointer to member conversion");
6666 result = size_zero_node;
6671 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
6675 /* Return a constructor for the pointer-to-member-function TYPE using
6676 the other components as specified. */
6679 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
6684 VEC(constructor_elt, gc) *v;
6686 /* Pull the FIELD_DECLs out of the type. */
6687 pfn_field = TYPE_FIELDS (type);
6688 delta_field = TREE_CHAIN (pfn_field);
6690 /* Make sure DELTA has the type we want. */
6691 delta = convert_and_check (delta_type_node, delta);
6693 /* Convert to the correct target type if necessary. */
6694 pfn = fold_convert (TREE_TYPE (pfn_field), pfn);
6696 /* Finish creating the initializer. */
6697 v = VEC_alloc(constructor_elt, gc, 2);
6698 CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
6699 CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
6700 u = build_constructor (type, v);
6701 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
6702 TREE_STATIC (u) = (TREE_CONSTANT (u)
6703 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
6705 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
6710 /* Build a constructor for a pointer to member function. It can be
6711 used to initialize global variables, local variable, or used
6712 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6715 If FORCE is nonzero, then force this conversion, even if
6716 we would rather not do it. Usually set when using an explicit
6717 cast. A C-style cast is being processed iff C_CAST_P is true.
6719 Return error_mark_node, if something goes wrong. */
6722 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
6728 if (error_operand_p (pfn))
6729 return error_mark_node;
6731 pfn_type = TREE_TYPE (pfn);
6732 to_type = build_ptrmemfunc_type (type);
6734 /* Handle multiple conversions of pointer to member functions. */
6735 if (TYPE_PTRMEMFUNC_P (pfn_type))
6737 tree delta = NULL_TREE;
6738 tree npfn = NULL_TREE;
6742 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
6743 error ("invalid conversion to type %qT from type %qT",
6746 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
6747 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
6751 /* We don't have to do any conversion to convert a
6752 pointer-to-member to its own type. But, we don't want to
6753 just return a PTRMEM_CST if there's an explicit cast; that
6754 cast should make the expression an invalid template argument. */
6755 if (TREE_CODE (pfn) != PTRMEM_CST)
6757 if (same_type_p (to_type, pfn_type))
6759 else if (integer_zerop (n))
6760 return build_reinterpret_cast (to_type, pfn,
6761 tf_warning_or_error);
6764 if (TREE_SIDE_EFFECTS (pfn))
6765 pfn = save_expr (pfn);
6767 /* Obtain the function pointer and the current DELTA. */
6768 if (TREE_CODE (pfn) == PTRMEM_CST)
6769 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6772 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6773 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6776 /* Just adjust the DELTA field. */
6777 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6778 (TREE_TYPE (delta), ptrdiff_type_node));
6779 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6780 n = cp_build_binary_op (input_location,
6781 LSHIFT_EXPR, n, integer_one_node,
6782 tf_warning_or_error);
6783 delta = cp_build_binary_op (input_location,
6784 PLUS_EXPR, delta, n, tf_warning_or_error);
6785 return build_ptrmemfunc1 (to_type, delta, npfn);
6788 /* Handle null pointer to member function conversions. */
6789 if (integer_zerop (pfn))
6791 pfn = build_c_cast (input_location, type, integer_zero_node);
6792 return build_ptrmemfunc1 (to_type,
6797 if (type_unknown_p (pfn))
6798 return instantiate_type (type, pfn, tf_warning_or_error);
6800 fn = TREE_OPERAND (pfn, 0);
6801 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6802 /* In a template, we will have preserved the
6804 || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6805 return make_ptrmem_cst (to_type, fn);
6808 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6811 ??? There is no consistency as to the types returned for the above
6812 values. Some code acts as if it were a sizetype and some as if it were
6813 integer_type_node. */
6816 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6818 tree type = TREE_TYPE (cst);
6819 tree fn = PTRMEM_CST_MEMBER (cst);
6820 tree ptr_class, fn_class;
6822 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6824 /* The class that the function belongs to. */
6825 fn_class = DECL_CONTEXT (fn);
6827 /* The class that we're creating a pointer to member of. */
6828 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6830 /* First, calculate the adjustment to the function's class. */
6831 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6834 if (!DECL_VIRTUAL_P (fn))
6835 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6838 /* If we're dealing with a virtual function, we have to adjust 'this'
6839 again, to point to the base which provides the vtable entry for
6840 fn; the call will do the opposite adjustment. */
6841 tree orig_class = DECL_CONTEXT (fn);
6842 tree binfo = binfo_or_else (orig_class, fn_class);
6843 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6844 *delta, BINFO_OFFSET (binfo));
6845 *delta = fold_if_not_in_template (*delta);
6847 /* We set PFN to the vtable offset at which the function can be
6848 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6849 case delta is shifted left, and then incremented). */
6850 *pfn = DECL_VINDEX (fn);
6851 *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6852 TYPE_SIZE_UNIT (vtable_entry_type));
6853 *pfn = fold_if_not_in_template (*pfn);
6855 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6857 case ptrmemfunc_vbit_in_pfn:
6858 *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6860 *pfn = fold_if_not_in_template (*pfn);
6863 case ptrmemfunc_vbit_in_delta:
6864 *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6865 *delta, integer_one_node);
6866 *delta = fold_if_not_in_template (*delta);
6867 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6868 *delta, integer_one_node);
6869 *delta = fold_if_not_in_template (*delta);
6876 *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6877 *pfn = fold_if_not_in_template (*pfn);
6881 /* Return an expression for PFN from the pointer-to-member function
6885 pfn_from_ptrmemfunc (tree t)
6887 if (TREE_CODE (t) == PTRMEM_CST)
6892 expand_ptrmemfunc_cst (t, &delta, &pfn);
6897 return build_ptrmemfunc_access_expr (t, pfn_identifier);
6900 /* Return an expression for DELTA from the pointer-to-member function
6904 delta_from_ptrmemfunc (tree t)
6906 if (TREE_CODE (t) == PTRMEM_CST)
6911 expand_ptrmemfunc_cst (t, &delta, &pfn);
6916 return build_ptrmemfunc_access_expr (t, delta_identifier);
6919 /* Convert value RHS to type TYPE as preparation for an assignment to
6920 an lvalue of type TYPE. ERRTYPE is a string to use in error
6921 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6922 are doing the conversion in order to pass the PARMNUMth argument of
6926 convert_for_assignment (tree type, tree rhs,
6927 const char *errtype, tree fndecl, int parmnum,
6928 tsubst_flags_t complain, int flags)
6931 enum tree_code coder;
6933 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6934 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6935 rhs = TREE_OPERAND (rhs, 0);
6937 rhstype = TREE_TYPE (rhs);
6938 coder = TREE_CODE (rhstype);
6940 if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6941 && vector_types_convertible_p (type, rhstype, true))
6942 return convert (type, rhs);
6944 if (rhs == error_mark_node || rhstype == error_mark_node)
6945 return error_mark_node;
6946 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6947 return error_mark_node;
6949 /* The RHS of an assignment cannot have void type. */
6950 if (coder == VOID_TYPE)
6952 if (complain & tf_error)
6953 error ("void value not ignored as it ought to be");
6954 return error_mark_node;
6957 /* Simplify the RHS if possible. */
6958 if (TREE_CODE (rhs) == CONST_DECL)
6959 rhs = DECL_INITIAL (rhs);
6961 if (c_dialect_objc ())
6964 tree rname = fndecl;
6966 if (!strcmp (errtype, "assignment"))
6968 else if (!strcmp (errtype, "initialization"))
6972 tree selector = objc_message_selector ();
6976 if (selector && parmno > 1)
6983 if (objc_compare_types (type, rhstype, parmno, rname))
6984 return convert (type, rhs);
6989 The expression is implicitly converted (clause _conv_) to the
6990 cv-unqualified type of the left operand.
6992 We allow bad conversions here because by the time we get to this point
6993 we are committed to doing the conversion. If we end up doing a bad
6994 conversion, convert_like will complain. */
6995 if (!can_convert_arg_bad (type, rhstype, rhs, flags))
6997 /* When -Wno-pmf-conversions is use, we just silently allow
6998 conversions from pointers-to-members to plain pointers. If
6999 the conversion doesn't work, cp_convert will complain. */
7001 && TYPE_PTR_P (type)
7002 && TYPE_PTRMEMFUNC_P (rhstype))
7003 rhs = cp_convert (strip_top_quals (type), rhs);
7006 if (complain & tf_error)
7008 /* If the right-hand side has unknown type, then it is an
7009 overloaded function. Call instantiate_type to get error
7011 if (rhstype == unknown_type_node)
7012 instantiate_type (type, rhs, tf_warning_or_error);
7014 error ("cannot convert %qT to %qT for argument %qP to %qD",
7015 rhstype, type, parmnum, fndecl);
7017 error ("cannot convert %qT to %qT in %s", rhstype, type,
7020 return error_mark_node;
7023 if (warn_missing_format_attribute)
7025 const enum tree_code codel = TREE_CODE (type);
7026 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
7028 && check_missing_format_attribute (type, rhstype)
7029 && (complain & tf_warning))
7030 warning (OPT_Wmissing_format_attribute,
7031 "%s might be a candidate for a format attribute",
7035 /* If -Wparentheses, warn about a = b = c when a has type bool and b
7037 if (warn_parentheses
7038 && TREE_CODE (type) == BOOLEAN_TYPE
7039 && TREE_CODE (rhs) == MODIFY_EXPR
7040 && !TREE_NO_WARNING (rhs)
7041 && TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE
7042 && (complain & tf_warning))
7044 location_t loc = EXPR_HAS_LOCATION (rhs)
7045 ? EXPR_LOCATION (rhs) : input_location;
7047 warning_at (loc, OPT_Wparentheses,
7048 "suggest parentheses around assignment used as truth value");
7049 TREE_NO_WARNING (rhs) = 1;
7052 return perform_implicit_conversion_flags (strip_top_quals (type), rhs,
7056 /* Convert RHS to be of type TYPE.
7057 If EXP is nonzero, it is the target of the initialization.
7058 ERRTYPE is a string to use in error messages.
7060 Two major differences between the behavior of
7061 `convert_for_assignment' and `convert_for_initialization'
7062 are that references are bashed in the former, while
7063 copied in the latter, and aggregates are assigned in
7064 the former (operator=) while initialized in the
7067 If using constructor make sure no conversion operator exists, if one does
7068 exist, an ambiguity exists.
7070 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
7073 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
7074 const char *errtype, tree fndecl, int parmnum,
7075 tsubst_flags_t complain)
7077 enum tree_code codel = TREE_CODE (type);
7079 enum tree_code coder;
7081 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
7082 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
7083 if (TREE_CODE (rhs) == NOP_EXPR
7084 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
7085 && codel != REFERENCE_TYPE)
7086 rhs = TREE_OPERAND (rhs, 0);
7088 if (type == error_mark_node
7089 || rhs == error_mark_node
7090 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
7091 return error_mark_node;
7093 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
7094 && TREE_CODE (type) != ARRAY_TYPE
7095 && (TREE_CODE (type) != REFERENCE_TYPE
7096 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
7097 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
7098 && (TREE_CODE (type) != REFERENCE_TYPE
7099 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
7100 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
7101 rhs = decay_conversion (rhs);
7103 rhstype = TREE_TYPE (rhs);
7104 coder = TREE_CODE (rhstype);
7106 if (coder == ERROR_MARK)
7107 return error_mark_node;
7109 /* We accept references to incomplete types, so we can
7110 return here before checking if RHS is of complete type. */
7112 if (codel == REFERENCE_TYPE)
7114 /* This should eventually happen in convert_arguments. */
7115 int savew = 0, savee = 0;
7118 savew = warningcount, savee = errorcount;
7119 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
7120 /*cleanup=*/NULL, complain);
7123 if (warningcount > savew)
7124 warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
7125 else if (errorcount > savee)
7126 error ("in passing argument %P of %q+D", parmnum, fndecl);
7132 exp = require_complete_type (exp);
7133 if (exp == error_mark_node)
7134 return error_mark_node;
7136 rhstype = non_reference (rhstype);
7138 type = complete_type (type);
7140 if (DIRECT_INIT_EXPR_P (type, rhs))
7141 /* Don't try to do copy-initialization if we already have
7142 direct-initialization. */
7145 if (MAYBE_CLASS_TYPE_P (type))
7146 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
7148 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum,
7152 /* If RETVAL is the address of, or a reference to, a local variable or
7153 temporary give an appropriate warning. */
7156 maybe_warn_about_returning_address_of_local (tree retval)
7158 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
7159 tree whats_returned = retval;
7163 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
7164 whats_returned = TREE_OPERAND (whats_returned, 1);
7165 else if (CONVERT_EXPR_P (whats_returned)
7166 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR)
7167 whats_returned = TREE_OPERAND (whats_returned, 0);
7172 if (TREE_CODE (whats_returned) != ADDR_EXPR)
7174 whats_returned = TREE_OPERAND (whats_returned, 0);
7176 if (TREE_CODE (valtype) == REFERENCE_TYPE)
7178 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
7179 || TREE_CODE (whats_returned) == TARGET_EXPR)
7181 warning (0, "returning reference to temporary");
7184 if (TREE_CODE (whats_returned) == VAR_DECL
7185 && DECL_NAME (whats_returned)
7186 && TEMP_NAME_P (DECL_NAME (whats_returned)))
7188 warning (0, "reference to non-lvalue returned");
7193 while (TREE_CODE (whats_returned) == COMPONENT_REF
7194 || TREE_CODE (whats_returned) == ARRAY_REF)
7195 whats_returned = TREE_OPERAND (whats_returned, 0);
7197 if (DECL_P (whats_returned)
7198 && DECL_NAME (whats_returned)
7199 && DECL_FUNCTION_SCOPE_P (whats_returned)
7200 && !(TREE_STATIC (whats_returned)
7201 || TREE_PUBLIC (whats_returned)))
7203 if (TREE_CODE (valtype) == REFERENCE_TYPE)
7204 warning (0, "reference to local variable %q+D returned",
7207 warning (0, "address of local variable %q+D returned",
7213 /* Check that returning RETVAL from the current function is valid.
7214 Return an expression explicitly showing all conversions required to
7215 change RETVAL into the function return type, and to assign it to
7216 the DECL_RESULT for the function. Set *NO_WARNING to true if
7217 code reaches end of non-void function warning shouldn't be issued
7218 on this RETURN_EXPR. */
7221 check_return_expr (tree retval, bool *no_warning)
7224 /* The type actually returned by the function, after any
7227 int fn_returns_value_p;
7228 bool named_return_value_okay_p;
7230 *no_warning = false;
7232 /* A `volatile' function is one that isn't supposed to return, ever.
7233 (This is a G++ extension, used to get better code for functions
7234 that call the `volatile' function.) */
7235 if (TREE_THIS_VOLATILE (current_function_decl))
7236 warning (0, "function declared %<noreturn%> has a %<return%> statement");
7238 /* Check for various simple errors. */
7239 if (DECL_DESTRUCTOR_P (current_function_decl))
7242 error ("returning a value from a destructor");
7245 else if (DECL_CONSTRUCTOR_P (current_function_decl))
7247 if (in_function_try_handler)
7248 /* If a return statement appears in a handler of the
7249 function-try-block of a constructor, the program is ill-formed. */
7250 error ("cannot return from a handler of a function-try-block of a constructor");
7252 /* You can't return a value from a constructor. */
7253 error ("returning a value from a constructor");
7257 /* As an extension, deduce lambda return type from a return statement
7258 anywhere in the body. */
7259 if (retval && LAMBDA_FUNCTION_P (current_function_decl))
7261 tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
7262 if (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda))
7264 tree type = lambda_return_type (retval);
7265 tree oldtype = LAMBDA_EXPR_RETURN_TYPE (lambda);
7267 if (VOID_TYPE_P (type))
7269 else if (oldtype == NULL_TREE)
7271 pedwarn (input_location, OPT_pedantic, "lambda return type "
7272 "can only be deduced when the return statement is "
7273 "the only statement in the function body");
7274 apply_lambda_return_type (lambda, type);
7276 else if (!same_type_p (type, oldtype))
7277 error ("inconsistent types %qT and %qT deduced for "
7278 "lambda return type", type, oldtype);
7282 if (processing_template_decl)
7284 current_function_returns_value = 1;
7285 if (check_for_bare_parameter_packs (retval))
7286 retval = error_mark_node;
7290 /* When no explicit return-value is given in a function with a named
7291 return value, the named return value is used. */
7292 result = DECL_RESULT (current_function_decl);
7293 valtype = TREE_TYPE (result);
7294 gcc_assert (valtype != NULL_TREE);
7295 fn_returns_value_p = !VOID_TYPE_P (valtype);
7296 if (!retval && DECL_NAME (result) && fn_returns_value_p)
7299 /* Check for a return statement with no return value in a function
7300 that's supposed to return a value. */
7301 if (!retval && fn_returns_value_p)
7303 permerror (input_location, "return-statement with no value, in function returning %qT",
7305 /* Clear this, so finish_function won't say that we reach the
7306 end of a non-void function (which we don't, we gave a
7308 current_function_returns_null = 0;
7309 /* And signal caller that TREE_NO_WARNING should be set on the
7310 RETURN_EXPR to avoid control reaches end of non-void function
7311 warnings in tree-cfg.c. */
7314 /* Check for a return statement with a value in a function that
7315 isn't supposed to return a value. */
7316 else if (retval && !fn_returns_value_p)
7318 if (VOID_TYPE_P (TREE_TYPE (retval)))
7319 /* You can return a `void' value from a function of `void'
7320 type. In that case, we have to evaluate the expression for
7321 its side-effects. */
7322 finish_expr_stmt (retval);
7324 permerror (input_location, "return-statement with a value, in function "
7325 "returning 'void'");
7326 current_function_returns_null = 1;
7328 /* There's really no value to return, after all. */
7332 /* Remember that this function can sometimes return without a
7334 current_function_returns_null = 1;
7336 /* Remember that this function did return a value. */
7337 current_function_returns_value = 1;
7339 /* Check for erroneous operands -- but after giving ourselves a
7340 chance to provide an error about returning a value from a void
7342 if (error_operand_p (retval))
7344 current_function_return_value = error_mark_node;
7345 return error_mark_node;
7348 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
7349 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
7350 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
7351 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
7353 && retval && null_ptr_cst_p (retval))
7354 warning (0, "%<operator new%> must not return NULL unless it is "
7355 "declared %<throw()%> (or -fcheck-new is in effect)");
7357 /* Effective C++ rule 15. See also start_function. */
7359 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
7363 /* The function return type must be a reference to the current
7365 if (TREE_CODE (valtype) == REFERENCE_TYPE
7366 && same_type_ignoring_top_level_qualifiers_p
7367 (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
7369 /* Returning '*this' is obviously OK. */
7370 if (retval == current_class_ref)
7372 /* If we are calling a function whose return type is the same of
7373 the current class reference, it is ok. */
7374 else if (TREE_CODE (retval) == INDIRECT_REF
7375 && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
7380 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
7383 /* The fabled Named Return Value optimization, as per [class.copy]/15:
7385 [...] For a function with a class return type, if the expression
7386 in the return statement is the name of a local object, and the cv-
7387 unqualified type of the local object is the same as the function
7388 return type, an implementation is permitted to omit creating the tem-
7389 porary object to hold the function return value [...]
7391 So, if this is a value-returning function that always returns the same
7392 local variable, remember it.
7394 It might be nice to be more flexible, and choose the first suitable
7395 variable even if the function sometimes returns something else, but
7396 then we run the risk of clobbering the variable we chose if the other
7397 returned expression uses the chosen variable somehow. And people expect
7398 this restriction, anyway. (jason 2000-11-19)
7400 See finish_function and finalize_nrv for the rest of this optimization. */
7402 named_return_value_okay_p =
7403 (retval != NULL_TREE
7404 /* Must be a local, automatic variable. */
7405 && TREE_CODE (retval) == VAR_DECL
7406 && DECL_CONTEXT (retval) == current_function_decl
7407 && ! TREE_STATIC (retval)
7408 && ! DECL_ANON_UNION_VAR_P (retval)
7409 && (DECL_ALIGN (retval)
7410 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
7411 /* The cv-unqualified type of the returned value must be the
7412 same as the cv-unqualified return type of the
7414 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
7416 (TREE_TYPE (TREE_TYPE (current_function_decl)))))
7417 /* And the returned value must be non-volatile. */
7418 && ! TYPE_VOLATILE (TREE_TYPE (retval)));
7420 if (fn_returns_value_p && flag_elide_constructors)
7422 if (named_return_value_okay_p
7423 && (current_function_return_value == NULL_TREE
7424 || current_function_return_value == retval))
7425 current_function_return_value = retval;
7427 current_function_return_value = error_mark_node;
7430 /* We don't need to do any conversions when there's nothing being
7435 /* Do any required conversions. */
7436 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
7437 /* No conversions are required. */
7441 /* The type the function is declared to return. */
7442 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
7443 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
7445 /* The functype's return type will have been set to void, if it
7446 was an incomplete type. Just treat this as 'return;' */
7447 if (VOID_TYPE_P (functype))
7448 return error_mark_node;
7450 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
7451 treated as an rvalue for the purposes of overload resolution to
7452 favor move constructors over copy constructors. */
7453 if ((cxx_dialect != cxx98)
7454 && named_return_value_okay_p
7455 /* The variable must not have the `volatile' qualifier. */
7456 && !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
7457 /* The return type must be a class type. */
7458 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
7459 flags = flags | LOOKUP_PREFER_RVALUE;
7461 /* First convert the value to the function's return type, then
7462 to the type of return value's location to handle the
7463 case that functype is smaller than the valtype. */
7464 retval = convert_for_initialization
7465 (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0,
7466 tf_warning_or_error);
7467 retval = convert (valtype, retval);
7469 /* If the conversion failed, treat this just like `return;'. */
7470 if (retval == error_mark_node)
7472 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7473 else if (! cfun->returns_struct
7474 && TREE_CODE (retval) == TARGET_EXPR
7475 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
7476 retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
7477 TREE_OPERAND (retval, 0));
7479 maybe_warn_about_returning_address_of_local (retval);
7482 /* Actually copy the value returned into the appropriate location. */
7483 if (retval && retval != result)
7484 retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
7490 /* Returns nonzero if the pointer-type FROM can be converted to the
7491 pointer-type TO via a qualification conversion. If CONSTP is -1,
7492 then we return nonzero if the pointers are similar, and the
7493 cv-qualification signature of FROM is a proper subset of that of TO.
7495 If CONSTP is positive, then all outer pointers have been
7499 comp_ptr_ttypes_real (tree to, tree from, int constp)
7501 bool to_more_cv_qualified = false;
7502 bool is_opaque_pointer = false;
7504 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7506 if (TREE_CODE (to) != TREE_CODE (from))
7509 if (TREE_CODE (from) == OFFSET_TYPE
7510 && !same_type_p (TYPE_OFFSET_BASETYPE (from),
7511 TYPE_OFFSET_BASETYPE (to)))
7514 /* Const and volatile mean something different for function types,
7515 so the usual checks are not appropriate. */
7516 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7518 /* In Objective-C++, some types may have been 'volatilized' by
7519 the compiler for EH; when comparing them here, the volatile
7520 qualification must be ignored. */
7521 bool objc_quals_match = objc_type_quals_match (to, from);
7523 if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
7526 if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
7530 to_more_cv_qualified = true;
7534 constp &= TYPE_READONLY (to);
7537 if (TREE_CODE (to) == VECTOR_TYPE)
7538 is_opaque_pointer = vector_targets_convertible_p (to, from);
7540 if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
7541 return ((constp >= 0 || to_more_cv_qualified)
7542 && (is_opaque_pointer
7543 || same_type_ignoring_top_level_qualifiers_p (to, from)));
7547 /* When comparing, say, char ** to char const **, this function takes
7548 the 'char *' and 'char const *'. Do not pass non-pointer/reference
7549 types to this function. */
7552 comp_ptr_ttypes (tree to, tree from)
7554 return comp_ptr_ttypes_real (to, from, 1);
7557 /* Returns true iff FNTYPE is a non-class type that involves
7558 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
7559 if a parameter type is ill-formed. */
7562 error_type_p (const_tree type)
7566 switch (TREE_CODE (type))
7572 case REFERENCE_TYPE:
7574 return error_type_p (TREE_TYPE (type));
7578 if (error_type_p (TREE_TYPE (type)))
7580 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7581 if (error_type_p (TREE_VALUE (t)))
7586 if (TYPE_PTRMEMFUNC_P (type))
7587 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type));
7595 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7596 type or inheritance-related types, regardless of cv-quals. */
7599 ptr_reasonably_similar (const_tree to, const_tree from)
7601 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7603 /* Any target type is similar enough to void. */
7604 if (TREE_CODE (to) == VOID_TYPE)
7605 return !error_type_p (from);
7606 if (TREE_CODE (from) == VOID_TYPE)
7607 return !error_type_p (to);
7609 if (TREE_CODE (to) != TREE_CODE (from))
7612 if (TREE_CODE (from) == OFFSET_TYPE
7613 && comptypes (TYPE_OFFSET_BASETYPE (to),
7614 TYPE_OFFSET_BASETYPE (from),
7615 COMPARE_BASE | COMPARE_DERIVED))
7618 if (TREE_CODE (to) == VECTOR_TYPE
7619 && vector_types_convertible_p (to, from, false))
7622 if (TREE_CODE (to) == INTEGER_TYPE
7623 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
7626 if (TREE_CODE (to) == FUNCTION_TYPE)
7627 return !error_type_p (to) && !error_type_p (from);
7629 if (TREE_CODE (to) != POINTER_TYPE)
7631 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7632 COMPARE_BASE | COMPARE_DERIVED);
7636 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7637 pointer-to-member types) are the same, ignoring cv-qualification at
7641 comp_ptr_ttypes_const (tree to, tree from)
7643 bool is_opaque_pointer = false;
7645 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7647 if (TREE_CODE (to) != TREE_CODE (from))
7650 if (TREE_CODE (from) == OFFSET_TYPE
7651 && same_type_p (TYPE_OFFSET_BASETYPE (from),
7652 TYPE_OFFSET_BASETYPE (to)))
7655 if (TREE_CODE (to) == VECTOR_TYPE)
7656 is_opaque_pointer = vector_targets_convertible_p (to, from);
7658 if (TREE_CODE (to) != POINTER_TYPE)
7659 return (is_opaque_pointer
7660 || same_type_ignoring_top_level_qualifiers_p (to, from));
7664 /* Returns the type qualifiers for this type, including the qualifiers on the
7665 elements for an array type. */
7668 cp_type_quals (const_tree type)
7670 /* This CONST_CAST is okay because strip_array_types returns its
7671 argument unmodified and we assign it to a const_tree. */
7672 type = strip_array_types (CONST_CAST_TREE(type));
7673 if (type == error_mark_node)
7674 return TYPE_UNQUALIFIED;
7675 return TYPE_QUALS (type);
7678 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7682 cp_type_readonly (const_tree type)
7684 /* This CONST_CAST is okay because strip_array_types returns its
7685 argument unmodified and we assign it to a const_tree. */
7686 type = strip_array_types (CONST_CAST_TREE(type));
7687 return TYPE_READONLY (type);
7690 /* Returns nonzero if TYPE is const or volatile. */
7693 cv_qualified_p (const_tree type)
7695 int quals = cp_type_quals (type);
7696 return (quals & (TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE)) != 0;
7699 /* Returns nonzero if the TYPE contains a mutable member. */
7702 cp_has_mutable_p (const_tree type)
7704 /* This CONST_CAST is okay because strip_array_types returns its
7705 argument unmodified and we assign it to a const_tree. */
7706 type = strip_array_types (CONST_CAST_TREE(type));
7708 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
7711 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7712 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7713 approximation. In particular, consider:
7716 struct S { int i; };
7717 const S s = { f(); }
7719 Here, we will make "s" as TREE_READONLY (because it is declared
7720 "const") -- only to reverse ourselves upon seeing that the
7721 initializer is non-constant. */
7724 cp_apply_type_quals_to_decl (int type_quals, tree decl)
7726 tree type = TREE_TYPE (decl);
7728 if (type == error_mark_node)
7731 if (TREE_CODE (decl) == TYPE_DECL)
7734 if (TREE_CODE (type) == FUNCTION_TYPE
7735 && type_quals != TYPE_UNQUALIFIED)
7737 /* This was an error in C++98 (cv-qualifiers cannot be added to
7738 a function type), but DR 295 makes the code well-formed by
7739 dropping the extra qualifiers. */
7742 tree bad_type = build_qualified_type (type, type_quals);
7743 pedwarn (input_location, OPT_pedantic,
7744 "ignoring %qV qualifiers added to function type %qT",
7748 TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
7752 /* Avoid setting TREE_READONLY incorrectly. */
7753 if (/* If the object has a constructor, the constructor may modify
7755 TYPE_NEEDS_CONSTRUCTING (type)
7756 /* If the type isn't complete, we don't know yet if it will need
7758 || !COMPLETE_TYPE_P (type)
7759 /* If the type has a mutable component, that component might be
7761 || TYPE_HAS_MUTABLE_P (type))
7762 type_quals &= ~TYPE_QUAL_CONST;
7764 c_apply_type_quals_to_decl (type_quals, decl);
7767 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7768 exemplar types such that casting T1 to T2 is casting away constness
7769 if and only if there is no implicit conversion from T1 to T2. */
7772 casts_away_constness_r (tree *t1, tree *t2)
7777 /* [expr.const.cast]
7779 For multi-level pointer to members and multi-level mixed pointers
7780 and pointers to members (conv.qual), the "member" aspect of a
7781 pointer to member level is ignored when determining if a const
7782 cv-qualifier has been cast away. */
7783 /* [expr.const.cast]
7785 For two pointer types:
7787 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7788 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7791 casting from X1 to X2 casts away constness if, for a non-pointer
7792 type T there does not exist an implicit conversion (clause
7795 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7799 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7800 if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
7801 || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
7803 *t1 = cp_build_qualified_type (void_type_node,
7804 cp_type_quals (*t1));
7805 *t2 = cp_build_qualified_type (void_type_node,
7806 cp_type_quals (*t2));
7810 quals1 = cp_type_quals (*t1);
7811 quals2 = cp_type_quals (*t2);
7813 if (TYPE_PTRMEM_P (*t1))
7814 *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
7816 *t1 = TREE_TYPE (*t1);
7817 if (TYPE_PTRMEM_P (*t2))
7818 *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
7820 *t2 = TREE_TYPE (*t2);
7822 casts_away_constness_r (t1, t2);
7823 *t1 = build_pointer_type (*t1);
7824 *t2 = build_pointer_type (*t2);
7825 *t1 = cp_build_qualified_type (*t1, quals1);
7826 *t2 = cp_build_qualified_type (*t2, quals2);
7829 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7832 ??? This function returns non-zero if casting away qualifiers not
7833 just const. We would like to return to the caller exactly which
7834 qualifiers are casted away to give more accurate diagnostics.
7838 casts_away_constness (tree t1, tree t2)
7840 if (TREE_CODE (t2) == REFERENCE_TYPE)
7842 /* [expr.const.cast]
7844 Casting from an lvalue of type T1 to an lvalue of type T2
7845 using a reference cast casts away constness if a cast from an
7846 rvalue of type "pointer to T1" to the type "pointer to T2"
7847 casts away constness. */
7848 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
7849 return casts_away_constness (build_pointer_type (t1),
7850 build_pointer_type (TREE_TYPE (t2)));
7853 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
7854 /* [expr.const.cast]
7856 Casting from an rvalue of type "pointer to data member of X
7857 of type T1" to the type "pointer to data member of Y of type
7858 T2" casts away constness if a cast from an rvalue of type
7859 "pointer to T1" to the type "pointer to T2" casts away
7861 return casts_away_constness
7862 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
7863 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
7865 /* Casting away constness is only something that makes sense for
7866 pointer or reference types. */
7867 if (TREE_CODE (t1) != POINTER_TYPE
7868 || TREE_CODE (t2) != POINTER_TYPE)
7871 /* Top-level qualifiers don't matter. */
7872 t1 = TYPE_MAIN_VARIANT (t1);
7873 t2 = TYPE_MAIN_VARIANT (t2);
7874 casts_away_constness_r (&t1, &t2);
7875 if (!can_convert (t2, t1))
7881 /* If T is a REFERENCE_TYPE return the type to which T refers.
7882 Otherwise, return T itself. */
7885 non_reference (tree t)
7887 if (TREE_CODE (t) == REFERENCE_TYPE)
7893 /* Return nonzero if REF is an lvalue valid for this language;
7894 otherwise, print an error message and return zero. USE says
7895 how the lvalue is being used and so selects the error message. */
7898 lvalue_or_else (tree ref, enum lvalue_use use, tsubst_flags_t complain)
7900 int win = lvalue_p (ref);
7902 if (!win && (complain & tf_error))