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 /* Subroutine of structural_comptypes.
1077 Compare the template parameters of the
1078 typedef decl of T1 and T2.
1079 Return TRUE if the template parameters of the typedef decls of T1 and T2 are
1080 different, FALSE otherwise. */
1083 incompatible_dependent_typedefs_p (tree t1, tree t2)
1088 if (!typedef_variant_p (t1)
1089 || !typedef_variant_p (t2)
1090 || !dependent_type_p (t1)
1091 || !dependent_type_p (t2))
1094 decl1 = TYPE_NAME (t1);
1095 decl2 = TYPE_NAME (t2);
1099 tinfo1 = get_template_info (decl1);
1101 tinfo1 = get_template_info (DECL_CONTEXT (decl1));
1103 tinfo2 = get_template_info (decl2);
1105 tinfo2 = get_template_info (DECL_CONTEXT (decl2));
1107 gcc_assert (tinfo1 != NULL_TREE
1108 && tinfo2 != NULL_TREE);
1110 if (tinfo1 == tinfo2)
1113 return !comp_template_parms (DECL_TEMPLATE_PARMS (TI_TEMPLATE (tinfo1)),
1114 DECL_TEMPLATE_PARMS (TI_TEMPLATE (tinfo2)));
1117 /* Subroutine in comptypes. */
1120 structural_comptypes (tree t1, tree t2, int strict)
1125 /* Suppress errors caused by previously reported errors. */
1126 if (t1 == error_mark_node || t2 == error_mark_node)
1129 gcc_assert (TYPE_P (t1) && TYPE_P (t2));
1131 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1132 current instantiation. */
1133 if (TREE_CODE (t1) == TYPENAME_TYPE)
1134 t1 = resolve_typename_type (t1, /*only_current_p=*/true);
1136 if (TREE_CODE (t2) == TYPENAME_TYPE)
1137 t2 = resolve_typename_type (t2, /*only_current_p=*/true);
1139 if (TYPE_PTRMEMFUNC_P (t1))
1140 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
1141 if (TYPE_PTRMEMFUNC_P (t2))
1142 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
1144 /* Different classes of types can't be compatible. */
1145 if (TREE_CODE (t1) != TREE_CODE (t2))
1148 /* Qualifiers must match. For array types, we will check when we
1149 recur on the array element types. */
1150 if (TREE_CODE (t1) != ARRAY_TYPE
1151 && TYPE_QUALS (t1) != TYPE_QUALS (t2))
1153 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
1156 /* Allow for two different type nodes which have essentially the same
1157 definition. Note that we already checked for equality of the type
1158 qualifiers (just above). */
1160 if (TREE_CODE (t1) != ARRAY_TYPE
1161 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1164 if (incompatible_dependent_typedefs_p (t1, t2))
1167 /* Compare the types. Break out if they could be the same. */
1168 switch (TREE_CODE (t1))
1172 /* All void and bool types are the same. */
1176 case FIXED_POINT_TYPE:
1178 /* With these nodes, we can't determine type equivalence by
1179 looking at what is stored in the nodes themselves, because
1180 two nodes might have different TYPE_MAIN_VARIANTs but still
1181 represent the same type. For example, wchar_t and int could
1182 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1183 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1184 and are distinct types. On the other hand, int and the
1187 typedef int INT __attribute((may_alias));
1189 have identical properties, different TYPE_MAIN_VARIANTs, but
1190 represent the same type. The canonical type system keeps
1191 track of equivalence in this case, so we fall back on it. */
1192 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1194 case TEMPLATE_TEMPLATE_PARM:
1195 case BOUND_TEMPLATE_TEMPLATE_PARM:
1196 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1197 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1198 || (TEMPLATE_TYPE_PARAMETER_PACK (t1)
1199 != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1201 if (!comp_template_parms
1202 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1203 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1205 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1207 /* Don't check inheritance. */
1208 strict = COMPARE_STRICT;
1213 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1214 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1215 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1216 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1219 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1221 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1227 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1228 strict & ~COMPARE_REDECLARATION))
1230 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1234 case REFERENCE_TYPE:
1235 if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
1237 /* fall through to checks for pointer types */
1240 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1241 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1242 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1248 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1250 if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1255 /* Target types must match incl. qualifiers. */
1256 if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1260 case TEMPLATE_TYPE_PARM:
1261 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1262 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1263 || (TEMPLATE_TYPE_PARAMETER_PACK (t1)
1264 != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1269 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1270 TYPENAME_TYPE_FULLNAME (t2)))
1272 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1276 case UNBOUND_CLASS_TEMPLATE:
1277 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1279 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1284 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1289 if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1290 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1294 case TYPE_PACK_EXPANSION:
1295 return same_type_p (PACK_EXPANSION_PATTERN (t1),
1296 PACK_EXPANSION_PATTERN (t2));
1299 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1)
1300 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2)
1301 || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1)
1302 != DECLTYPE_FOR_LAMBDA_CAPTURE (t2))
1303 || (DECLTYPE_FOR_LAMBDA_RETURN (t1)
1304 != DECLTYPE_FOR_LAMBDA_RETURN (t2))
1305 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1),
1306 DECLTYPE_TYPE_EXPR (t2)))
1314 /* If we get here, we know that from a target independent POV the
1315 types are the same. Make sure the target attributes are also
1317 return targetm.comp_type_attributes (t1, t2);
1320 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1321 is a bitwise-or of the COMPARE_* flags. */
1324 comptypes (tree t1, tree t2, int strict)
1326 if (strict == COMPARE_STRICT)
1331 if (t1 == error_mark_node || t2 == error_mark_node)
1334 if (TYPE_STRUCTURAL_EQUALITY_P (t1) || TYPE_STRUCTURAL_EQUALITY_P (t2))
1335 /* At least one of the types requires structural equality, so
1336 perform a deep check. */
1337 return structural_comptypes (t1, t2, strict);
1339 #ifdef ENABLE_CHECKING
1340 if (USE_CANONICAL_TYPES)
1342 bool result = structural_comptypes (t1, t2, strict);
1344 if (result && TYPE_CANONICAL (t1) != TYPE_CANONICAL (t2))
1345 /* The two types are structurally equivalent, but their
1346 canonical types were different. This is a failure of the
1347 canonical type propagation code.*/
1349 ("canonical types differ for identical types %T and %T",
1351 else if (!result && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
1352 /* Two types are structurally different, but the canonical
1353 types are the same. This means we were over-eager in
1354 assigning canonical types. */
1356 ("same canonical type node for different types %T and %T",
1362 if (USE_CANONICAL_TYPES)
1363 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1366 return structural_comptypes (t1, t2, strict);
1368 else if (strict == COMPARE_STRUCTURAL)
1369 return structural_comptypes (t1, t2, COMPARE_STRICT);
1371 return structural_comptypes (t1, t2, strict);
1374 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1377 at_least_as_qualified_p (const_tree type1, const_tree type2)
1379 int q1 = cp_type_quals (type1);
1380 int q2 = cp_type_quals (type2);
1382 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1383 return (q1 & q2) == q2;
1386 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1387 more cv-qualified that TYPE1, and 0 otherwise. */
1390 comp_cv_qualification (const_tree type1, const_tree type2)
1392 int q1 = cp_type_quals (type1);
1393 int q2 = cp_type_quals (type2);
1398 if ((q1 & q2) == q2)
1400 else if ((q1 & q2) == q1)
1406 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1407 subset of the cv-qualification signature of TYPE2, and the types
1408 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1411 comp_cv_qual_signature (tree type1, tree type2)
1413 if (comp_ptr_ttypes_real (type2, type1, -1))
1415 else if (comp_ptr_ttypes_real (type1, type2, -1))
1421 /* Subroutines of `comptypes'. */
1423 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1424 equivalent in the sense that functions with those parameter types
1425 can have equivalent types. The two lists must be equivalent,
1426 element by element. */
1429 compparms (const_tree parms1, const_tree parms2)
1433 /* An unspecified parmlist matches any specified parmlist
1434 whose argument types don't need default promotions. */
1436 for (t1 = parms1, t2 = parms2;
1438 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1440 /* If one parmlist is shorter than the other,
1441 they fail to match. */
1444 if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1451 /* Process a sizeof or alignof expression where the operand is a
1455 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1460 gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1461 if (type == error_mark_node)
1462 return error_mark_node;
1464 type = non_reference (type);
1465 if (TREE_CODE (type) == METHOD_TYPE)
1468 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
1469 "invalid application of %qs to a member function",
1470 operator_name_info[(int) op].name);
1471 value = size_one_node;
1474 dependent_p = dependent_type_p (type);
1476 complete_type (type);
1478 /* VLA types will have a non-constant size. In the body of an
1479 uninstantiated template, we don't need to try to compute the
1480 value, because the sizeof expression is not an integral
1481 constant expression in that case. And, if we do try to
1482 compute the value, we'll likely end up with SAVE_EXPRs, which
1483 the template substitution machinery does not expect to see. */
1484 || (processing_template_decl
1485 && COMPLETE_TYPE_P (type)
1486 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
1488 value = build_min (op, size_type_node, type);
1489 TREE_READONLY (value) = 1;
1493 return c_sizeof_or_alignof_type (input_location, complete_type (type),
1498 /* Return the size of the type, without producing any warnings for
1499 types whose size cannot be taken. This routine should be used only
1500 in some other routine that has already produced a diagnostic about
1501 using the size of such a type. */
1503 cxx_sizeof_nowarn (tree type)
1505 if (TREE_CODE (type) == FUNCTION_TYPE
1506 || TREE_CODE (type) == VOID_TYPE
1507 || TREE_CODE (type) == ERROR_MARK)
1508 return size_one_node;
1509 else if (!COMPLETE_TYPE_P (type))
1510 return size_zero_node;
1512 return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false);
1515 /* Process a sizeof expression where the operand is an expression. */
1518 cxx_sizeof_expr (tree e, tsubst_flags_t complain)
1520 if (e == error_mark_node)
1521 return error_mark_node;
1523 if (processing_template_decl)
1525 e = build_min (SIZEOF_EXPR, size_type_node, e);
1526 TREE_SIDE_EFFECTS (e) = 0;
1527 TREE_READONLY (e) = 1;
1532 if (TREE_CODE (e) == COMPONENT_REF
1533 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1534 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1536 if (complain & tf_error)
1537 error ("invalid application of %<sizeof%> to a bit-field");
1539 return error_mark_node;
1542 else if (is_overloaded_fn (e))
1544 if (complain & tf_error)
1545 permerror (input_location, "ISO C++ forbids applying %<sizeof%> to an expression of "
1548 return error_mark_node;
1551 else if (type_unknown_p (e))
1553 if (complain & tf_error)
1554 cxx_incomplete_type_error (e, TREE_TYPE (e));
1556 return error_mark_node;
1562 return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error);
1565 /* Implement the __alignof keyword: Return the minimum required
1566 alignment of E, measured in bytes. For VAR_DECL's and
1567 FIELD_DECL's return DECL_ALIGN (which can be set from an
1568 "aligned" __attribute__ specification). */
1571 cxx_alignof_expr (tree e, tsubst_flags_t complain)
1575 if (e == error_mark_node)
1576 return error_mark_node;
1578 if (processing_template_decl)
1580 e = build_min (ALIGNOF_EXPR, size_type_node, e);
1581 TREE_SIDE_EFFECTS (e) = 0;
1582 TREE_READONLY (e) = 1;
1587 if (TREE_CODE (e) == VAR_DECL)
1588 t = size_int (DECL_ALIGN_UNIT (e));
1589 else if (TREE_CODE (e) == COMPONENT_REF
1590 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1591 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1593 if (complain & tf_error)
1594 error ("invalid application of %<__alignof%> to a bit-field");
1596 return error_mark_node;
1599 else if (TREE_CODE (e) == COMPONENT_REF
1600 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL)
1601 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1)));
1602 else if (is_overloaded_fn (e))
1604 if (complain & tf_error)
1605 permerror (input_location, "ISO C++ forbids applying %<__alignof%> to an expression of "
1608 return error_mark_node;
1609 if (TREE_CODE (e) == FUNCTION_DECL)
1610 t = size_int (DECL_ALIGN_UNIT (e));
1614 else if (type_unknown_p (e))
1616 if (complain & tf_error)
1617 cxx_incomplete_type_error (e, TREE_TYPE (e));
1619 return error_mark_node;
1623 return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR,
1624 complain & tf_error);
1626 return fold_convert (size_type_node, t);
1629 /* Process a sizeof or alignof expression E with code OP where the operand
1630 is an expression. */
1633 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain)
1635 if (op == SIZEOF_EXPR)
1636 return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none);
1638 return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none);
1641 /* EXPR is being used in a context that is not a function call.
1646 The expression can be used only as the left-hand operand of a
1647 member function call.
1649 [expr.mptr.operator]
1651 If the result of .* or ->* is a function, then that result can be
1652 used only as the operand for the function call operator ().
1654 by issuing an error message if appropriate. Returns true iff EXPR
1655 violates these rules. */
1658 invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
1660 if (expr && DECL_NONSTATIC_MEMBER_FUNCTION_P (expr))
1662 if (complain & tf_error)
1663 error ("invalid use of non-static member function");
1669 /* If EXP is a reference to a bitfield, and the type of EXP does not
1670 match the declared type of the bitfield, return the declared type
1671 of the bitfield. Otherwise, return NULL_TREE. */
1674 is_bitfield_expr_with_lowered_type (const_tree exp)
1676 switch (TREE_CODE (exp))
1679 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)
1680 ? TREE_OPERAND (exp, 1)
1681 : TREE_OPERAND (exp, 0)))
1683 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2));
1686 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1));
1690 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1696 field = TREE_OPERAND (exp, 1);
1697 if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
1699 if (same_type_ignoring_top_level_qualifiers_p
1700 (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
1702 return DECL_BIT_FIELD_TYPE (field);
1706 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
1707 == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
1708 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1716 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1717 bitfield with a lowered type, the type of EXP is returned, rather
1721 unlowered_expr_type (const_tree exp)
1725 type = is_bitfield_expr_with_lowered_type (exp);
1727 type = TREE_TYPE (exp);
1732 /* Perform the conversions in [expr] that apply when an lvalue appears
1733 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1734 function-to-pointer conversions. In addition, manifest constants
1735 are replaced by their values, and bitfield references are converted
1736 to their declared types.
1738 Although the returned value is being used as an rvalue, this
1739 function does not wrap the returned expression in a
1740 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1741 that the return value is no longer an lvalue. */
1744 decay_conversion (tree exp)
1747 enum tree_code code;
1749 type = TREE_TYPE (exp);
1750 if (type == error_mark_node)
1751 return error_mark_node;
1753 exp = resolve_nondeduced_context (exp);
1754 if (type_unknown_p (exp))
1756 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1757 return error_mark_node;
1760 exp = decl_constant_value (exp);
1761 if (error_operand_p (exp))
1762 return error_mark_node;
1764 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1765 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1766 code = TREE_CODE (type);
1767 if (code == VOID_TYPE)
1769 error ("void value not ignored as it ought to be");
1770 return error_mark_node;
1772 if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error))
1773 return error_mark_node;
1774 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1775 return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error);
1776 if (code == ARRAY_TYPE)
1781 if (TREE_CODE (exp) == INDIRECT_REF)
1782 return build_nop (build_pointer_type (TREE_TYPE (type)),
1783 TREE_OPERAND (exp, 0));
1785 if (TREE_CODE (exp) == COMPOUND_EXPR)
1787 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1788 return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1789 TREE_OPERAND (exp, 0), op1);
1793 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1795 error ("invalid use of non-lvalue array");
1796 return error_mark_node;
1799 ptrtype = build_pointer_type (TREE_TYPE (type));
1801 if (TREE_CODE (exp) == VAR_DECL)
1803 if (!cxx_mark_addressable (exp))
1804 return error_mark_node;
1805 adr = build_nop (ptrtype, build_address (exp));
1808 /* This way is better for a COMPONENT_REF since it can
1809 simplify the offset for a component. */
1810 adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
1811 return cp_convert (ptrtype, adr);
1814 /* If a bitfield is used in a context where integral promotion
1815 applies, then the caller is expected to have used
1816 default_conversion. That function promotes bitfields correctly
1817 before calling this function. At this point, if we have a
1818 bitfield referenced, we may assume that is not subject to
1819 promotion, and that, therefore, the type of the resulting rvalue
1820 is the declared type of the bitfield. */
1821 exp = convert_bitfield_to_declared_type (exp);
1823 /* We do not call rvalue() here because we do not want to wrap EXP
1824 in a NON_LVALUE_EXPR. */
1828 Non-class rvalues always have cv-unqualified types. */
1829 type = TREE_TYPE (exp);
1830 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
1831 exp = build_nop (cv_unqualified (type), exp);
1836 /* Perform preparatory conversions, as part of the "usual arithmetic
1837 conversions". In particular, as per [expr]:
1839 Whenever an lvalue expression appears as an operand of an
1840 operator that expects the rvalue for that operand, the
1841 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1842 standard conversions are applied to convert the expression to an
1845 In addition, we perform integral promotions here, as those are
1846 applied to both operands to a binary operator before determining
1847 what additional conversions should apply. */
1850 default_conversion (tree exp)
1852 /* Check for target-specific promotions. */
1853 tree promoted_type = targetm.promoted_type (TREE_TYPE (exp));
1855 exp = cp_convert (promoted_type, exp);
1856 /* Perform the integral promotions first so that bitfield
1857 expressions (which may promote to "int", even if the bitfield is
1858 declared "unsigned") are promoted correctly. */
1859 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1860 exp = perform_integral_promotions (exp);
1861 /* Perform the other conversions. */
1862 exp = decay_conversion (exp);
1867 /* EXPR is an expression with an integral or enumeration type.
1868 Perform the integral promotions in [conv.prom], and return the
1872 perform_integral_promotions (tree expr)
1879 If the bitfield has an enumerated type, it is treated as any
1880 other value of that type for promotion purposes. */
1881 type = is_bitfield_expr_with_lowered_type (expr);
1882 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
1883 type = TREE_TYPE (expr);
1884 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1885 promoted_type = type_promotes_to (type);
1886 if (type != promoted_type)
1887 expr = cp_convert (promoted_type, expr);
1891 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1892 decay_conversion to one. */
1895 string_conv_p (const_tree totype, const_tree exp, int warn)
1899 if (TREE_CODE (totype) != POINTER_TYPE)
1902 t = TREE_TYPE (totype);
1903 if (!same_type_p (t, char_type_node)
1904 && !same_type_p (t, char16_type_node)
1905 && !same_type_p (t, char32_type_node)
1906 && !same_type_p (t, wchar_type_node))
1909 if (TREE_CODE (exp) == STRING_CST)
1911 /* Make sure that we don't try to convert between char and wide chars. */
1912 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1917 /* Is this a string constant which has decayed to 'const char *'? */
1918 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1919 if (!same_type_p (TREE_TYPE (exp), t))
1922 if (TREE_CODE (exp) != ADDR_EXPR
1923 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1927 /* This warning is not very useful, as it complains about printf. */
1929 warning (OPT_Wwrite_strings,
1930 "deprecated conversion from string constant to %qT",
1936 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1937 can, for example, use as an lvalue. This code used to be in
1938 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1939 expressions, where we're dealing with aggregates. But now it's again only
1940 called from unary_complex_lvalue. The case (in particular) that led to
1941 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1945 rationalize_conditional_expr (enum tree_code code, tree t,
1946 tsubst_flags_t complain)
1948 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1949 the first operand is always the one to be used if both operands
1950 are equal, so we know what conditional expression this used to be. */
1951 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1953 tree op0 = TREE_OPERAND (t, 0);
1954 tree op1 = TREE_OPERAND (t, 1);
1956 /* The following code is incorrect if either operand side-effects. */
1957 gcc_assert (!TREE_SIDE_EFFECTS (op0)
1958 && !TREE_SIDE_EFFECTS (op1));
1960 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1961 ? LE_EXPR : GE_EXPR),
1962 op0, TREE_CODE (op0),
1963 op1, TREE_CODE (op1),
1964 /*overloaded_p=*/NULL,
1966 cp_build_unary_op (code, op0, 0, complain),
1967 cp_build_unary_op (code, op1, 0, complain),
1972 build_conditional_expr (TREE_OPERAND (t, 0),
1973 cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
1975 cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
1980 /* Given the TYPE of an anonymous union field inside T, return the
1981 FIELD_DECL for the field. If not found return NULL_TREE. Because
1982 anonymous unions can nest, we must also search all anonymous unions
1983 that are directly reachable. */
1986 lookup_anon_field (tree t, tree type)
1990 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1992 if (TREE_STATIC (field))
1994 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1997 /* If we find it directly, return the field. */
1998 if (DECL_NAME (field) == NULL_TREE
1999 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
2004 /* Otherwise, it could be nested, search harder. */
2005 if (DECL_NAME (field) == NULL_TREE
2006 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2008 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
2016 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
2017 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
2018 non-NULL, it indicates the path to the base used to name MEMBER.
2019 If PRESERVE_REFERENCE is true, the expression returned will have
2020 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
2021 returned will have the type referred to by the reference.
2023 This function does not perform access control; that is either done
2024 earlier by the parser when the name of MEMBER is resolved to MEMBER
2025 itself, or later when overload resolution selects one of the
2026 functions indicated by MEMBER. */
2029 build_class_member_access_expr (tree object, tree member,
2030 tree access_path, bool preserve_reference,
2031 tsubst_flags_t complain)
2035 tree result = NULL_TREE;
2037 if (error_operand_p (object) || error_operand_p (member))
2038 return error_mark_node;
2040 gcc_assert (DECL_P (member) || BASELINK_P (member));
2044 The type of the first expression shall be "class object" (of a
2046 object_type = TREE_TYPE (object);
2047 if (!currently_open_class (object_type)
2048 && !complete_type_or_else (object_type, object))
2049 return error_mark_node;
2050 if (!CLASS_TYPE_P (object_type))
2052 if (complain & tf_error)
2053 error ("request for member %qD in %qE, which is of non-class type %qT",
2054 member, object, object_type);
2055 return error_mark_node;
2058 /* The standard does not seem to actually say that MEMBER must be a
2059 member of OBJECT_TYPE. However, that is clearly what is
2061 if (DECL_P (member))
2063 member_scope = DECL_CLASS_CONTEXT (member);
2065 if (TREE_DEPRECATED (member))
2066 warn_deprecated_use (member, NULL_TREE);
2069 member_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (member));
2070 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2071 presently be the anonymous union. Go outwards until we find a
2072 type related to OBJECT_TYPE. */
2073 while (ANON_AGGR_TYPE_P (member_scope)
2074 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
2076 member_scope = TYPE_CONTEXT (member_scope);
2077 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
2079 if (complain & tf_error)
2081 if (TREE_CODE (member) == FIELD_DECL)
2082 error ("invalid use of nonstatic data member %qE", member);
2084 error ("%qD is not a member of %qT", member, object_type);
2086 return error_mark_node;
2089 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2090 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
2091 in the front end; only _DECLs and _REFs are lvalues in the back end. */
2093 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
2095 object = cp_build_indirect_ref (temp, RO_NULL, complain);
2098 /* In [expr.ref], there is an explicit list of the valid choices for
2099 MEMBER. We check for each of those cases here. */
2100 if (TREE_CODE (member) == VAR_DECL)
2102 /* A static data member. */
2104 /* If OBJECT has side-effects, they are supposed to occur. */
2105 if (TREE_SIDE_EFFECTS (object))
2106 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
2108 else if (TREE_CODE (member) == FIELD_DECL)
2110 /* A non-static data member. */
2115 null_object_p = (TREE_CODE (object) == INDIRECT_REF
2116 && integer_zerop (TREE_OPERAND (object, 0)));
2118 /* Convert OBJECT to the type of MEMBER. */
2119 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
2120 TYPE_MAIN_VARIANT (member_scope)))
2125 binfo = lookup_base (access_path ? access_path : object_type,
2126 member_scope, ba_unique, &kind);
2127 if (binfo == error_mark_node)
2128 return error_mark_node;
2130 /* It is invalid to try to get to a virtual base of a
2131 NULL object. The most common cause is invalid use of
2133 if (null_object_p && kind == bk_via_virtual)
2135 if (complain & tf_error)
2137 error ("invalid access to non-static data member %qD of "
2140 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
2142 return error_mark_node;
2145 /* Convert to the base. */
2146 object = build_base_path (PLUS_EXPR, object, binfo,
2148 /* If we found the base successfully then we should be able
2149 to convert to it successfully. */
2150 gcc_assert (object != error_mark_node);
2153 /* Complain about other invalid uses of offsetof, even though they will
2154 give the right answer. Note that we complain whether or not they
2155 actually used the offsetof macro, since there's no way to know at this
2156 point. So we just give a warning, instead of a pedwarn. */
2157 /* Do not produce this warning for base class field references, because
2158 we know for a fact that didn't come from offsetof. This does occur
2159 in various testsuite cases where a null object is passed where a
2160 vtable access is required. */
2161 if (null_object_p && warn_invalid_offsetof
2162 && CLASSTYPE_NON_STD_LAYOUT (object_type)
2163 && !DECL_FIELD_IS_BASE (member)
2164 && cp_unevaluated_operand == 0
2165 && (complain & tf_warning))
2167 warning (OPT_Winvalid_offsetof,
2168 "invalid access to non-static data member %qD "
2169 " of NULL object", member);
2170 warning (OPT_Winvalid_offsetof,
2171 "(perhaps the %<offsetof%> macro was used incorrectly)");
2174 /* If MEMBER is from an anonymous aggregate, we have converted
2175 OBJECT so that it refers to the class containing the
2176 anonymous union. Generate a reference to the anonymous union
2177 itself, and recur to find MEMBER. */
2178 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
2179 /* When this code is called from build_field_call, the
2180 object already has the type of the anonymous union.
2181 That is because the COMPONENT_REF was already
2182 constructed, and was then disassembled before calling
2183 build_field_call. After the function-call code is
2184 cleaned up, this waste can be eliminated. */
2185 && (!same_type_ignoring_top_level_qualifiers_p
2186 (TREE_TYPE (object), DECL_CONTEXT (member))))
2188 tree anonymous_union;
2190 anonymous_union = lookup_anon_field (TREE_TYPE (object),
2191 DECL_CONTEXT (member));
2192 object = build_class_member_access_expr (object,
2194 /*access_path=*/NULL_TREE,
2199 /* Compute the type of the field, as described in [expr.ref]. */
2200 type_quals = TYPE_UNQUALIFIED;
2201 member_type = TREE_TYPE (member);
2202 if (TREE_CODE (member_type) != REFERENCE_TYPE)
2204 type_quals = (cp_type_quals (member_type)
2205 | cp_type_quals (object_type));
2207 /* A field is const (volatile) if the enclosing object, or the
2208 field itself, is const (volatile). But, a mutable field is
2209 not const, even within a const object. */
2210 if (DECL_MUTABLE_P (member))
2211 type_quals &= ~TYPE_QUAL_CONST;
2212 member_type = cp_build_qualified_type (member_type, type_quals);
2215 result = build3 (COMPONENT_REF, member_type, object, member,
2217 result = fold_if_not_in_template (result);
2219 /* Mark the expression const or volatile, as appropriate. Even
2220 though we've dealt with the type above, we still have to mark the
2221 expression itself. */
2222 if (type_quals & TYPE_QUAL_CONST)
2223 TREE_READONLY (result) = 1;
2224 if (type_quals & TYPE_QUAL_VOLATILE)
2225 TREE_THIS_VOLATILE (result) = 1;
2227 else if (BASELINK_P (member))
2229 /* The member is a (possibly overloaded) member function. */
2233 /* If the MEMBER is exactly one static member function, then we
2234 know the type of the expression. Otherwise, we must wait
2235 until overload resolution has been performed. */
2236 functions = BASELINK_FUNCTIONS (member);
2237 if (TREE_CODE (functions) == FUNCTION_DECL
2238 && DECL_STATIC_FUNCTION_P (functions))
2239 type = TREE_TYPE (functions);
2241 type = unknown_type_node;
2242 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2243 base. That will happen when the function is called. */
2244 result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
2246 else if (TREE_CODE (member) == CONST_DECL)
2248 /* The member is an enumerator. */
2250 /* If OBJECT has side-effects, they are supposed to occur. */
2251 if (TREE_SIDE_EFFECTS (object))
2252 result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
2257 if (complain & tf_error)
2258 error ("invalid use of %qD", member);
2259 return error_mark_node;
2262 if (!preserve_reference)
2265 If E2 is declared to have type "reference to T", then ... the
2266 type of E1.E2 is T. */
2267 result = convert_from_reference (result);
2272 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2273 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
2276 lookup_destructor (tree object, tree scope, tree dtor_name)
2278 tree object_type = TREE_TYPE (object);
2279 tree dtor_type = TREE_OPERAND (dtor_name, 0);
2282 if (scope && !check_dtor_name (scope, dtor_type))
2284 error ("qualified type %qT does not match destructor name ~%qT",
2286 return error_mark_node;
2288 if (TREE_CODE (dtor_type) == IDENTIFIER_NODE)
2290 /* In a template, names we can't find a match for are still accepted
2291 destructor names, and we check them here. */
2292 if (check_dtor_name (object_type, dtor_type))
2293 dtor_type = object_type;
2296 error ("object type %qT does not match destructor name ~%qT",
2297 object_type, dtor_type);
2298 return error_mark_node;
2302 else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2304 error ("the type being destroyed is %qT, but the destructor refers to %qT",
2305 TYPE_MAIN_VARIANT (object_type), dtor_type);
2306 return error_mark_node;
2308 expr = lookup_member (dtor_type, complete_dtor_identifier,
2309 /*protect=*/1, /*want_type=*/false);
2310 expr = (adjust_result_of_qualified_name_lookup
2311 (expr, dtor_type, object_type));
2315 /* An expression of the form "A::template B" has been resolved to
2316 DECL. Issue a diagnostic if B is not a template or template
2320 check_template_keyword (tree decl)
2322 /* The standard says:
2326 If a name prefixed by the keyword template is not a member
2327 template, the program is ill-formed.
2329 DR 228 removed the restriction that the template be a member
2332 DR 96, if accepted would add the further restriction that explicit
2333 template arguments must be provided if the template keyword is
2334 used, but, as of 2005-10-16, that DR is still in "drafting". If
2335 this DR is accepted, then the semantic checks here can be
2336 simplified, as the entity named must in fact be a template
2337 specialization, rather than, as at present, a set of overloaded
2338 functions containing at least one template function. */
2339 if (TREE_CODE (decl) != TEMPLATE_DECL
2340 && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2342 if (!is_overloaded_fn (decl))
2343 permerror (input_location, "%qD is not a template", decl);
2348 if (BASELINK_P (fns))
2349 fns = BASELINK_FUNCTIONS (fns);
2352 tree fn = OVL_CURRENT (fns);
2353 if (TREE_CODE (fn) == TEMPLATE_DECL
2354 || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2356 if (TREE_CODE (fn) == FUNCTION_DECL
2357 && DECL_USE_TEMPLATE (fn)
2358 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2360 fns = OVL_NEXT (fns);
2363 permerror (input_location, "%qD is not a template", decl);
2368 /* This function is called by the parser to process a class member
2369 access expression of the form OBJECT.NAME. NAME is a node used by
2370 the parser to represent a name; it is not yet a DECL. It may,
2371 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2372 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2373 there is no reason to do the lookup twice, so the parser keeps the
2374 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2375 be a template via the use of the "A::template B" syntax. */
2378 finish_class_member_access_expr (tree object, tree name, bool template_p,
2379 tsubst_flags_t complain)
2384 tree access_path = NULL_TREE;
2385 tree orig_object = object;
2386 tree orig_name = name;
2388 if (object == error_mark_node || name == error_mark_node)
2389 return error_mark_node;
2391 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2392 if (!objc_is_public (object, name))
2393 return error_mark_node;
2395 object_type = TREE_TYPE (object);
2397 if (processing_template_decl)
2399 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2400 dependent_type_p (object_type)
2401 /* If NAME is just an IDENTIFIER_NODE, then the expression
2403 || TREE_CODE (object) == IDENTIFIER_NODE
2404 /* If NAME is "f<args>", where either 'f' or 'args' is
2405 dependent, then the expression is dependent. */
2406 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2407 && dependent_template_id_p (TREE_OPERAND (name, 0),
2408 TREE_OPERAND (name, 1)))
2409 /* If NAME is "T::X" where "T" is dependent, then the
2410 expression is dependent. */
2411 || (TREE_CODE (name) == SCOPE_REF
2412 && TYPE_P (TREE_OPERAND (name, 0))
2413 && dependent_type_p (TREE_OPERAND (name, 0))))
2414 return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2415 object = build_non_dependent_expr (object);
2420 The type of the first expression shall be "class object" (of a
2422 if (!currently_open_class (object_type)
2423 && !complete_type_or_else (object_type, object))
2424 return error_mark_node;
2425 if (!CLASS_TYPE_P (object_type))
2427 if (complain & tf_error)
2428 error ("request for member %qD in %qE, which is of non-class type %qT",
2429 name, object, object_type);
2430 return error_mark_node;
2433 if (BASELINK_P (name))
2434 /* A member function that has already been looked up. */
2438 bool is_template_id = false;
2439 tree template_args = NULL_TREE;
2442 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2444 is_template_id = true;
2445 template_args = TREE_OPERAND (name, 1);
2446 name = TREE_OPERAND (name, 0);
2448 if (TREE_CODE (name) == OVERLOAD)
2449 name = DECL_NAME (get_first_fn (name));
2450 else if (DECL_P (name))
2451 name = DECL_NAME (name);
2454 if (TREE_CODE (name) == SCOPE_REF)
2456 /* A qualified name. The qualifying class or namespace `S'
2457 has already been looked up; it is either a TYPE or a
2459 scope = TREE_OPERAND (name, 0);
2460 name = TREE_OPERAND (name, 1);
2462 /* If SCOPE is a namespace, then the qualified name does not
2463 name a member of OBJECT_TYPE. */
2464 if (TREE_CODE (scope) == NAMESPACE_DECL)
2466 if (complain & tf_error)
2467 error ("%<%D::%D%> is not a member of %qT",
2468 scope, name, object_type);
2469 return error_mark_node;
2472 gcc_assert (CLASS_TYPE_P (scope));
2473 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2474 || TREE_CODE (name) == BIT_NOT_EXPR);
2476 if (constructor_name_p (name, scope))
2478 if (complain & tf_error)
2479 error ("cannot call constructor %<%T::%D%> directly",
2481 return error_mark_node;
2484 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2485 access_path = lookup_base (object_type, scope, ba_check, NULL);
2486 if (access_path == error_mark_node)
2487 return error_mark_node;
2490 if (complain & tf_error)
2491 error ("%qT is not a base of %qT", scope, object_type);
2492 return error_mark_node;
2498 access_path = object_type;
2501 if (TREE_CODE (name) == BIT_NOT_EXPR)
2502 member = lookup_destructor (object, scope, name);
2505 /* Look up the member. */
2506 member = lookup_member (access_path, name, /*protect=*/1,
2507 /*want_type=*/false);
2508 if (member == NULL_TREE)
2510 if (complain & tf_error)
2511 error ("%qD has no member named %qE", object_type, name);
2512 return error_mark_node;
2514 if (member == error_mark_node)
2515 return error_mark_node;
2520 tree templ = member;
2522 if (BASELINK_P (templ))
2523 templ = lookup_template_function (templ, template_args);
2526 if (complain & tf_error)
2527 error ("%qD is not a member template function", name);
2528 return error_mark_node;
2533 if (TREE_DEPRECATED (member))
2534 warn_deprecated_use (member, NULL_TREE);
2537 check_template_keyword (member);
2539 expr = build_class_member_access_expr (object, member, access_path,
2540 /*preserve_reference=*/false,
2542 if (processing_template_decl && expr != error_mark_node)
2544 if (BASELINK_P (member))
2546 if (TREE_CODE (orig_name) == SCOPE_REF)
2547 BASELINK_QUALIFIED_P (member) = 1;
2550 return build_min_non_dep (COMPONENT_REF, expr,
2551 orig_object, orig_name,
2558 /* Return an expression for the MEMBER_NAME field in the internal
2559 representation of PTRMEM, a pointer-to-member function. (Each
2560 pointer-to-member function type gets its own RECORD_TYPE so it is
2561 more convenient to access the fields by name than by FIELD_DECL.)
2562 This routine converts the NAME to a FIELD_DECL and then creates the
2563 node for the complete expression. */
2566 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2572 /* This code is a stripped down version of
2573 build_class_member_access_expr. It does not work to use that
2574 routine directly because it expects the object to be of class
2576 ptrmem_type = TREE_TYPE (ptrmem);
2577 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2578 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2579 /*want_type=*/false);
2580 member_type = cp_build_qualified_type (TREE_TYPE (member),
2581 cp_type_quals (ptrmem_type));
2582 return fold_build3_loc (input_location,
2583 COMPONENT_REF, member_type,
2584 ptrmem, member, NULL_TREE);
2587 /* Given an expression PTR for a pointer, return an expression
2588 for the value pointed to.
2589 ERRORSTRING is the name of the operator to appear in error messages.
2591 This function may need to overload OPERATOR_FNNAME.
2592 Must also handle REFERENCE_TYPEs for C++. */
2595 build_x_indirect_ref (tree expr, ref_operator errorstring,
2596 tsubst_flags_t complain)
2598 tree orig_expr = expr;
2601 if (processing_template_decl)
2603 /* Retain the type if we know the operand is a pointer so that
2604 describable_type doesn't make auto deduction break. */
2605 if (TREE_TYPE (expr) && POINTER_TYPE_P (TREE_TYPE (expr)))
2606 return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
2607 if (type_dependent_expression_p (expr))
2608 return build_min_nt (INDIRECT_REF, expr);
2609 expr = build_non_dependent_expr (expr);
2612 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2613 NULL_TREE, /*overloaded_p=*/NULL, complain);
2615 rval = cp_build_indirect_ref (expr, errorstring, complain);
2617 if (processing_template_decl && rval != error_mark_node)
2618 return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2623 /* Helper function called from c-common. */
2625 build_indirect_ref (location_t loc __attribute__ ((__unused__)),
2626 tree ptr, ref_operator errorstring)
2628 return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2632 cp_build_indirect_ref (tree ptr, ref_operator errorstring,
2633 tsubst_flags_t complain)
2637 if (ptr == error_mark_node)
2638 return error_mark_node;
2640 if (ptr == current_class_ptr)
2641 return current_class_ref;
2643 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2644 ? ptr : decay_conversion (ptr));
2645 type = TREE_TYPE (pointer);
2647 if (POINTER_TYPE_P (type))
2651 If the type of the expression is "pointer to T," the type
2652 of the result is "T." */
2653 tree t = TREE_TYPE (type);
2655 if (CONVERT_EXPR_P (ptr)
2656 || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2658 /* If a warning is issued, mark it to avoid duplicates from
2659 the backend. This only needs to be done at
2660 warn_strict_aliasing > 2. */
2661 if (warn_strict_aliasing > 2)
2662 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2663 type, TREE_OPERAND (ptr, 0)))
2664 TREE_NO_WARNING (ptr) = 1;
2667 if (VOID_TYPE_P (t))
2669 /* A pointer to incomplete type (other than cv void) can be
2670 dereferenced [expr.unary.op]/1 */
2671 if (complain & tf_error)
2672 error ("%qT is not a pointer-to-object type", type);
2673 return error_mark_node;
2675 else if (TREE_CODE (pointer) == ADDR_EXPR
2676 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2677 /* The POINTER was something like `&x'. We simplify `*&x' to
2679 return TREE_OPERAND (pointer, 0);
2682 tree ref = build1 (INDIRECT_REF, t, pointer);
2684 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2685 so that we get the proper error message if the result is used
2686 to assign to. Also, &* is supposed to be a no-op. */
2687 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2688 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2689 TREE_SIDE_EFFECTS (ref)
2690 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2694 else if (!(complain & tf_error))
2695 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
2697 /* `pointer' won't be an error_mark_node if we were given a
2698 pointer to member, so it's cool to check for this here. */
2699 else if (TYPE_PTR_TO_MEMBER_P (type))
2700 switch (errorstring)
2702 case RO_ARRAY_INDEXING:
2703 error ("invalid use of array indexing on pointer to member");
2706 error ("invalid use of unary %<*%> on pointer to member");
2708 case RO_IMPLICIT_CONVERSION:
2709 error ("invalid use of implicit conversion on pointer to member");
2714 else if (pointer != error_mark_node)
2715 switch (errorstring)
2718 error ("invalid type argument");
2720 case RO_ARRAY_INDEXING:
2721 error ("invalid type argument of array indexing");
2724 error ("invalid type argument of unary %<*%>");
2726 case RO_IMPLICIT_CONVERSION:
2727 error ("invalid type argument of implicit conversion");
2732 return error_mark_node;
2735 /* This handles expressions of the form "a[i]", which denotes
2738 This is logically equivalent in C to *(a+i), but we may do it differently.
2739 If A is a variable or a member, we generate a primitive ARRAY_REF.
2740 This avoids forcing the array out of registers, and can work on
2741 arrays that are not lvalues (for example, members of structures returned
2744 If INDEX is of some user-defined type, it must be converted to
2745 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2746 will inherit the type of the array, which will be some pointer type.
2748 LOC is the location to use in building the array reference. */
2751 build_array_ref (location_t loc, tree array, tree idx)
2757 error_at (loc, "subscript missing in array reference");
2758 return error_mark_node;
2761 if (TREE_TYPE (array) == error_mark_node
2762 || TREE_TYPE (idx) == error_mark_node)
2763 return error_mark_node;
2765 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2767 switch (TREE_CODE (array))
2771 tree value = build_array_ref (loc, TREE_OPERAND (array, 1), idx);
2772 ret = build2 (COMPOUND_EXPR, TREE_TYPE (value),
2773 TREE_OPERAND (array, 0), value);
2774 SET_EXPR_LOCATION (ret, loc);
2779 ret = build_conditional_expr
2780 (TREE_OPERAND (array, 0),
2781 build_array_ref (loc, TREE_OPERAND (array, 1), idx),
2782 build_array_ref (loc, TREE_OPERAND (array, 2), idx),
2783 tf_warning_or_error);
2784 protected_set_expr_location (ret, loc);
2791 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2795 warn_array_subscript_with_type_char (idx);
2797 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2799 error_at (loc, "array subscript is not an integer");
2800 return error_mark_node;
2803 /* Apply integral promotions *after* noticing character types.
2804 (It is unclear why we do these promotions -- the standard
2805 does not say that we should. In fact, the natural thing would
2806 seem to be to convert IDX to ptrdiff_t; we're performing
2807 pointer arithmetic.) */
2808 idx = perform_integral_promotions (idx);
2810 /* An array that is indexed by a non-constant
2811 cannot be stored in a register; we must be able to do
2812 address arithmetic on its address.
2813 Likewise an array of elements of variable size. */
2814 if (TREE_CODE (idx) != INTEGER_CST
2815 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2816 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2819 if (!cxx_mark_addressable (array))
2820 return error_mark_node;
2823 /* An array that is indexed by a constant value which is not within
2824 the array bounds cannot be stored in a register either; because we
2825 would get a crash in store_bit_field/extract_bit_field when trying
2826 to access a non-existent part of the register. */
2827 if (TREE_CODE (idx) == INTEGER_CST
2828 && TYPE_DOMAIN (TREE_TYPE (array))
2829 && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2831 if (!cxx_mark_addressable (array))
2832 return error_mark_node;
2835 if (!lvalue_p (array))
2836 pedwarn (loc, OPT_pedantic,
2837 "ISO C++ forbids subscripting non-lvalue array");
2839 /* Note in C++ it is valid to subscript a `register' array, since
2840 it is valid to take the address of something with that
2841 storage specification. */
2845 while (TREE_CODE (foo) == COMPONENT_REF)
2846 foo = TREE_OPERAND (foo, 0);
2847 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2848 warning_at (loc, OPT_Wextra,
2849 "subscripting array declared %<register%>");
2852 type = TREE_TYPE (TREE_TYPE (array));
2853 rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2854 /* Array ref is const/volatile if the array elements are
2855 or if the array is.. */
2856 TREE_READONLY (rval)
2857 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2858 TREE_SIDE_EFFECTS (rval)
2859 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2860 TREE_THIS_VOLATILE (rval)
2861 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2862 ret = require_complete_type (fold_if_not_in_template (rval));
2863 protected_set_expr_location (ret, loc);
2868 tree ar = default_conversion (array);
2869 tree ind = default_conversion (idx);
2871 /* Put the integer in IND to simplify error checking. */
2872 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2879 if (ar == error_mark_node)
2882 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2884 error_at (loc, "subscripted value is neither array nor pointer");
2885 return error_mark_node;
2887 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2889 error_at (loc, "array subscript is not an integer");
2890 return error_mark_node;
2893 warn_array_subscript_with_type_char (idx);
2895 ret = cp_build_indirect_ref (cp_build_binary_op (input_location,
2897 tf_warning_or_error),
2899 tf_warning_or_error);
2900 protected_set_expr_location (ret, loc);
2905 /* Resolve a pointer to member function. INSTANCE is the object
2906 instance to use, if the member points to a virtual member.
2908 This used to avoid checking for virtual functions if basetype
2909 has no virtual functions, according to an earlier ANSI draft.
2910 With the final ISO C++ rules, such an optimization is
2911 incorrect: A pointer to a derived member can be static_cast
2912 to pointer-to-base-member, as long as the dynamic object
2913 later has the right member. */
2916 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2918 if (TREE_CODE (function) == OFFSET_REF)
2919 function = TREE_OPERAND (function, 1);
2921 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2923 tree idx, delta, e1, e2, e3, vtbl, basetype;
2924 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2926 tree instance_ptr = *instance_ptrptr;
2927 tree instance_save_expr = 0;
2928 if (instance_ptr == error_mark_node)
2930 if (TREE_CODE (function) == PTRMEM_CST)
2932 /* Extracting the function address from a pmf is only
2933 allowed with -Wno-pmf-conversions. It only works for
2935 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2936 e1 = convert (fntype, e1);
2941 error ("object missing in use of %qE", function);
2942 return error_mark_node;
2946 if (TREE_SIDE_EFFECTS (instance_ptr))
2947 instance_ptr = instance_save_expr = save_expr (instance_ptr);
2949 if (TREE_SIDE_EFFECTS (function))
2950 function = save_expr (function);
2952 /* Start by extracting all the information from the PMF itself. */
2953 e3 = pfn_from_ptrmemfunc (function);
2954 delta = delta_from_ptrmemfunc (function);
2955 idx = build1 (NOP_EXPR, vtable_index_type, e3);
2956 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2958 case ptrmemfunc_vbit_in_pfn:
2959 e1 = cp_build_binary_op (input_location,
2960 BIT_AND_EXPR, idx, integer_one_node,
2961 tf_warning_or_error);
2962 idx = cp_build_binary_op (input_location,
2963 MINUS_EXPR, idx, integer_one_node,
2964 tf_warning_or_error);
2967 case ptrmemfunc_vbit_in_delta:
2968 e1 = cp_build_binary_op (input_location,
2969 BIT_AND_EXPR, delta, integer_one_node,
2970 tf_warning_or_error);
2971 delta = cp_build_binary_op (input_location,
2972 RSHIFT_EXPR, delta, integer_one_node,
2973 tf_warning_or_error);
2980 /* Convert down to the right base before using the instance. A
2981 special case is that in a pointer to member of class C, C may
2982 be incomplete. In that case, the function will of course be
2983 a member of C, and no conversion is required. In fact,
2984 lookup_base will fail in that case, because incomplete
2985 classes do not have BINFOs. */
2986 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2987 if (!same_type_ignoring_top_level_qualifiers_p
2988 (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
2990 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2991 basetype, ba_check, NULL);
2992 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
2994 if (instance_ptr == error_mark_node)
2995 return error_mark_node;
2997 /* ...and then the delta in the PMF. */
2998 instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
2999 instance_ptr, fold_convert (sizetype, delta));
3001 /* Hand back the adjusted 'this' argument to our caller. */
3002 *instance_ptrptr = instance_ptr;
3004 /* Next extract the vtable pointer from the object. */
3005 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
3007 vtbl = cp_build_indirect_ref (vtbl, RO_NULL, tf_warning_or_error);
3008 /* If the object is not dynamic the access invokes undefined
3009 behavior. As it is not executed in this case silence the
3010 spurious warnings it may provoke. */
3011 TREE_NO_WARNING (vtbl) = 1;
3013 /* Finally, extract the function pointer from the vtable. */
3014 e2 = fold_build2_loc (input_location,
3015 POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
3016 fold_convert (sizetype, idx));
3017 e2 = cp_build_indirect_ref (e2, RO_NULL, tf_warning_or_error);
3018 TREE_CONSTANT (e2) = 1;
3020 /* When using function descriptors, the address of the
3021 vtable entry is treated as a function pointer. */
3022 if (TARGET_VTABLE_USES_DESCRIPTORS)
3023 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
3024 cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
3025 tf_warning_or_error));
3027 e2 = fold_convert (TREE_TYPE (e3), e2);
3028 e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
3030 /* Make sure this doesn't get evaluated first inside one of the
3031 branches of the COND_EXPR. */
3032 if (instance_save_expr)
3033 e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
3034 instance_save_expr, e1);
3041 /* Used by the C-common bits. */
3043 build_function_call (location_t loc ATTRIBUTE_UNUSED,
3044 tree function, tree params)
3046 return cp_build_function_call (function, params, tf_warning_or_error);
3049 /* Used by the C-common bits. */
3051 build_function_call_vec (location_t loc ATTRIBUTE_UNUSED,
3052 tree function, VEC(tree,gc) *params,
3053 VEC(tree,gc) *origtypes ATTRIBUTE_UNUSED)
3055 VEC(tree,gc) *orig_params = params;
3056 tree ret = cp_build_function_call_vec (function, ¶ms,
3057 tf_warning_or_error);
3059 /* cp_build_function_call_vec can reallocate PARAMS by adding
3060 default arguments. That should never happen here. Verify
3062 gcc_assert (params == orig_params);
3067 /* Build a function call using a tree list of arguments. */
3070 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
3075 vec = make_tree_vector ();
3076 for (; params != NULL_TREE; params = TREE_CHAIN (params))
3077 VEC_safe_push (tree, gc, vec, TREE_VALUE (params));
3078 ret = cp_build_function_call_vec (function, &vec, complain);
3079 release_tree_vector (vec);
3083 /* Build a function call using a vector of arguments. PARAMS may be
3084 NULL if there are no parameters. This changes the contents of
3088 cp_build_function_call_vec (tree function, VEC(tree,gc) **params,
3089 tsubst_flags_t complain)
3091 tree fntype, fndecl;
3093 tree original = function;
3097 VEC(tree,gc) *allocated = NULL;
3100 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3101 expressions, like those used for ObjC messenger dispatches. */
3102 if (params != NULL && !VEC_empty (tree, *params))
3103 function = objc_rewrite_function_call (function,
3104 VEC_index (tree, *params, 0));
3106 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3107 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
3108 if (TREE_CODE (function) == NOP_EXPR
3109 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
3110 function = TREE_OPERAND (function, 0);
3112 if (TREE_CODE (function) == FUNCTION_DECL)
3114 mark_used (function);
3117 /* Convert anything with function type to a pointer-to-function. */
3118 if (DECL_MAIN_P (function) && (complain & tf_error))
3119 pedwarn (input_location, OPT_pedantic,
3120 "ISO C++ forbids calling %<::main%> from within program");
3122 function = build_addr_func (function);
3128 function = build_addr_func (function);
3131 if (function == error_mark_node)
3132 return error_mark_node;
3134 fntype = TREE_TYPE (function);
3136 if (TYPE_PTRMEMFUNC_P (fntype))
3138 if (complain & tf_error)
3139 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
3140 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
3141 original, original);
3142 return error_mark_node;
3145 is_method = (TREE_CODE (fntype) == POINTER_TYPE
3146 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
3148 if (!((TREE_CODE (fntype) == POINTER_TYPE
3149 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
3151 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
3153 if (complain & tf_error)
3154 error ("%qE cannot be used as a function", original);
3155 return error_mark_node;
3158 /* fntype now gets the type of function pointed to. */
3159 fntype = TREE_TYPE (fntype);
3160 parm_types = TYPE_ARG_TYPES (fntype);
3164 allocated = make_tree_vector ();
3165 params = &allocated;
3168 nargs = convert_arguments (parm_types, params, fndecl, LOOKUP_NORMAL,
3171 return error_mark_node;
3173 argarray = VEC_address (tree, *params);
3175 /* Check for errors in format strings and inappropriately
3177 check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
3180 ret = build_cxx_call (function, nargs, argarray);
3182 if (allocated != NULL)
3183 release_tree_vector (allocated);
3188 /* Convert the actual parameter expressions in the list VALUES to the
3189 types in the list TYPELIST. The converted expressions are stored
3190 back in the VALUES vector.
3191 If parmdecls is exhausted, or when an element has NULL as its type,
3192 perform the default conversions.
3194 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
3196 This is also where warnings about wrong number of args are generated.
3198 Returns the actual number of arguments processed (which might be less
3199 than the length of the vector), or -1 on error.
3201 In C++, unspecified trailing parameters can be filled in with their
3202 default arguments, if such were specified. Do so here. */
3205 convert_arguments (tree typelist, VEC(tree,gc) **values, tree fndecl,
3206 int flags, tsubst_flags_t complain)
3209 const char *called_thing = 0;
3212 /* Argument passing is always copy-initialization. */
3213 flags |= LOOKUP_ONLYCONVERTING;
3217 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
3219 if (DECL_NAME (fndecl) == NULL_TREE
3220 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
3221 called_thing = "constructor";
3223 called_thing = "member function";
3226 called_thing = "function";
3229 for (i = 0, typetail = typelist;
3230 i < VEC_length (tree, *values);
3233 tree type = typetail ? TREE_VALUE (typetail) : 0;
3234 tree val = VEC_index (tree, *values, i);
3236 if (val == error_mark_node || type == error_mark_node)
3239 if (type == void_type_node)
3241 if (complain & tf_error)
3245 error ("too many arguments to %s %q+#D",
3246 called_thing, fndecl);
3247 error ("at this point in file");
3250 error ("too many arguments to function");
3257 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3258 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3259 if (TREE_CODE (val) == NOP_EXPR
3260 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3261 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3262 val = TREE_OPERAND (val, 0);
3264 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3266 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3267 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3268 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3269 val = decay_conversion (val);
3272 if (val == error_mark_node)
3277 /* Formal parm type is specified by a function prototype. */
3280 if (!COMPLETE_TYPE_P (complete_type (type)))
3282 if (complain & tf_error)
3285 error ("parameter %P of %qD has incomplete type %qT",
3288 error ("parameter %P has incomplete type %qT", i, type);
3290 parmval = error_mark_node;
3294 parmval = convert_for_initialization
3295 (NULL_TREE, type, val, flags,
3296 "argument passing", fndecl, i, complain);
3297 parmval = convert_for_arg_passing (type, parmval);
3300 if (parmval == error_mark_node)
3303 VEC_replace (tree, *values, i, parmval);
3307 if (fndecl && DECL_BUILT_IN (fndecl)
3308 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3309 /* Don't do ellipsis conversion for __built_in_constant_p
3310 as this will result in spurious errors for non-trivial
3312 val = require_complete_type (val);
3314 val = convert_arg_to_ellipsis (val);
3316 VEC_replace (tree, *values, i, val);
3320 typetail = TREE_CHAIN (typetail);
3323 if (typetail != 0 && typetail != void_list_node)
3325 /* See if there are default arguments that can be used. Because
3326 we hold default arguments in the FUNCTION_TYPE (which is so
3327 wrong), we can see default parameters here from deduced
3328 contexts (and via typeof) for indirect function calls.
3329 Fortunately we know whether we have a function decl to
3330 provide default arguments in a language conformant
3332 if (fndecl && TREE_PURPOSE (typetail)
3333 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3335 for (; typetail != void_list_node; ++i)
3338 = convert_default_arg (TREE_VALUE (typetail),
3339 TREE_PURPOSE (typetail),
3342 if (parmval == error_mark_node)
3345 VEC_safe_push (tree, gc, *values, parmval);
3346 typetail = TREE_CHAIN (typetail);
3347 /* ends with `...'. */
3348 if (typetail == NULL_TREE)
3354 if (complain & tf_error)
3358 error ("too few arguments to %s %q+#D",
3359 called_thing, fndecl);
3360 error ("at this point in file");
3363 error ("too few arguments to function");
3372 /* Build a binary-operation expression, after performing default
3373 conversions on the operands. CODE is the kind of expression to
3374 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3375 are the tree codes which correspond to ARG1 and ARG2 when issuing
3376 warnings about possibly misplaced parentheses. They may differ
3377 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3378 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3379 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3380 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3381 ARG2_CODE as ERROR_MARK. */
3384 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3385 tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3386 tsubst_flags_t complain)
3395 if (processing_template_decl)
3397 if (type_dependent_expression_p (arg1)
3398 || type_dependent_expression_p (arg2))
3399 return build_min_nt (code, arg1, arg2);
3400 arg1 = build_non_dependent_expr (arg1);
3401 arg2 = build_non_dependent_expr (arg2);
3404 if (code == DOTSTAR_EXPR)
3405 expr = build_m_component_ref (arg1, arg2);
3407 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3408 overloaded_p, complain);
3410 /* Check for cases such as x+y<<z which users are likely to
3411 misinterpret. But don't warn about obj << x + y, since that is a
3412 common idiom for I/O. */
3413 if (warn_parentheses
3414 && (complain & tf_warning)
3415 && !processing_template_decl
3416 && !error_operand_p (arg1)
3417 && !error_operand_p (arg2)
3418 && (code != LSHIFT_EXPR
3419 || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3420 warn_about_parentheses (code, arg1_code, orig_arg1, arg2_code, orig_arg2);
3422 if (processing_template_decl && expr != error_mark_node)
3423 return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3428 /* Build and return an ARRAY_REF expression. */
3431 build_x_array_ref (tree arg1, tree arg2, tsubst_flags_t complain)
3433 tree orig_arg1 = arg1;
3434 tree orig_arg2 = arg2;
3437 if (processing_template_decl)
3439 if (type_dependent_expression_p (arg1)
3440 || type_dependent_expression_p (arg2))
3441 return build_min_nt (ARRAY_REF, arg1, arg2,
3442 NULL_TREE, NULL_TREE);
3443 arg1 = build_non_dependent_expr (arg1);
3444 arg2 = build_non_dependent_expr (arg2);
3447 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3448 /*overloaded_p=*/NULL, complain);
3450 if (processing_template_decl && expr != error_mark_node)
3451 return build_min_non_dep (ARRAY_REF, expr, orig_arg1, orig_arg2,
3452 NULL_TREE, NULL_TREE);
3456 /* For the c-common bits. */
3458 build_binary_op (location_t location, enum tree_code code, tree op0, tree op1,
3459 int convert_p ATTRIBUTE_UNUSED)
3461 return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error);
3465 /* Build a binary-operation expression without default conversions.
3466 CODE is the kind of expression to build.
3467 LOCATION is the location_t of the operator in the source code.
3468 This function differs from `build' in several ways:
3469 the data type of the result is computed and recorded in it,
3470 warnings are generated if arg data types are invalid,
3471 special handling for addition and subtraction of pointers is known,
3472 and some optimization is done (operations on narrow ints
3473 are done in the narrower type when that gives the same result).
3474 Constant folding is also done before the result is returned.
3476 Note that the operands will never have enumeral types
3477 because either they have just had the default conversions performed
3478 or they have both just been converted to some other type in which
3479 the arithmetic is to be done.
3481 C++: must do special pointer arithmetic when implementing
3482 multiple inheritance, and deal with pointer to member functions. */
3485 cp_build_binary_op (location_t location,
3486 enum tree_code code, tree orig_op0, tree orig_op1,
3487 tsubst_flags_t complain)
3490 enum tree_code code0, code1;
3492 const char *invalid_op_diag;
3494 /* Expression code to give to the expression when it is built.
3495 Normally this is CODE, which is what the caller asked for,
3496 but in some special cases we change it. */
3497 enum tree_code resultcode = code;
3499 /* Data type in which the computation is to be performed.
3500 In the simplest cases this is the common type of the arguments. */
3501 tree result_type = NULL;
3503 /* Nonzero means operands have already been type-converted
3504 in whatever way is necessary.
3505 Zero means they need to be converted to RESULT_TYPE. */
3508 /* Nonzero means create the expression with this type, rather than
3510 tree build_type = 0;
3512 /* Nonzero means after finally constructing the expression
3513 convert it to this type. */
3514 tree final_type = 0;
3518 /* Nonzero if this is an operation like MIN or MAX which can
3519 safely be computed in short if both args are promoted shorts.
3520 Also implies COMMON.
3521 -1 indicates a bitwise operation; this makes a difference
3522 in the exact conditions for when it is safe to do the operation
3523 in a narrower mode. */
3526 /* Nonzero if this is a comparison operation;
3527 if both args are promoted shorts, compare the original shorts.
3528 Also implies COMMON. */
3529 int short_compare = 0;
3531 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3534 /* True if both operands have arithmetic type. */
3535 bool arithmetic_types_p;
3537 /* Apply default conversions. */
3541 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3542 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3543 || code == TRUTH_XOR_EXPR)
3545 if (!really_overloaded_fn (op0))
3546 op0 = decay_conversion (op0);
3547 if (!really_overloaded_fn (op1))
3548 op1 = decay_conversion (op1);
3552 if (!really_overloaded_fn (op0))
3553 op0 = default_conversion (op0);
3554 if (!really_overloaded_fn (op1))
3555 op1 = default_conversion (op1);
3558 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3559 STRIP_TYPE_NOPS (op0);
3560 STRIP_TYPE_NOPS (op1);
3562 /* DTRT if one side is an overloaded function, but complain about it. */
3563 if (type_unknown_p (op0))
3565 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3566 if (t != error_mark_node)
3568 if (complain & tf_error)
3569 permerror (input_location, "assuming cast to type %qT from overloaded function",
3574 if (type_unknown_p (op1))
3576 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3577 if (t != error_mark_node)
3579 if (complain & tf_error)
3580 permerror (input_location, "assuming cast to type %qT from overloaded function",
3586 type0 = TREE_TYPE (op0);
3587 type1 = TREE_TYPE (op1);
3589 /* The expression codes of the data types of the arguments tell us
3590 whether the arguments are integers, floating, pointers, etc. */
3591 code0 = TREE_CODE (type0);
3592 code1 = TREE_CODE (type1);
3594 /* If an error was already reported for one of the arguments,
3595 avoid reporting another error. */
3596 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3597 return error_mark_node;
3599 if ((invalid_op_diag
3600 = targetm.invalid_binary_op (code, type0, type1)))
3602 error (invalid_op_diag);
3603 return error_mark_node;
3606 /* Issue warnings about peculiar, but valid, uses of NULL. */
3607 if ((orig_op0 == null_node || orig_op1 == null_node)
3608 /* It's reasonable to use pointer values as operands of &&
3609 and ||, so NULL is no exception. */
3610 && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR
3611 && ( /* Both are NULL (or 0) and the operation was not a
3612 comparison or a pointer subtraction. */
3613 (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1)
3614 && code != EQ_EXPR && code != NE_EXPR && code != MINUS_EXPR)
3615 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
3616 || (!null_ptr_cst_p (orig_op0)
3617 && !TYPE_PTR_P (type0) && !TYPE_PTR_TO_MEMBER_P (type0))
3618 || (!null_ptr_cst_p (orig_op1)
3619 && !TYPE_PTR_P (type1) && !TYPE_PTR_TO_MEMBER_P (type1)))
3620 && (complain & tf_warning))
3621 /* Some sort of arithmetic operation involving NULL was
3623 warning (OPT_Wpointer_arith, "NULL used in arithmetic");
3628 /* Subtraction of two similar pointers.
3629 We must subtract them as integers, then divide by object size. */
3630 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3631 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3633 return pointer_diff (op0, op1, common_pointer_type (type0, type1));
3634 /* In all other cases except pointer - int, the usual arithmetic
3636 else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3641 /* The pointer - int case is just like pointer + int; fall
3644 if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3645 && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3649 ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3650 int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3651 if (processing_template_decl)
3653 result_type = TREE_TYPE (ptr_operand);
3656 return cp_pointer_int_sum (code,
3667 case TRUNC_DIV_EXPR:
3669 case FLOOR_DIV_EXPR:
3670 case ROUND_DIV_EXPR:
3671 case EXACT_DIV_EXPR:
3672 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3673 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3674 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3675 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3677 enum tree_code tcode0 = code0, tcode1 = code1;
3679 warn_for_div_by_zero (location, op1);
3681 if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3682 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3683 if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3684 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3686 if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3687 resultcode = RDIV_EXPR;
3689 /* When dividing two signed integers, we have to promote to int.
3690 unless we divide by a constant != -1. Note that default
3691 conversion will have been performed on the operands at this
3692 point, so we have to dig out the original type to find out if
3694 shorten = ((TREE_CODE (op0) == NOP_EXPR
3695 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3696 || (TREE_CODE (op1) == INTEGER_CST
3697 && ! integer_all_onesp (op1)));
3706 if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3707 || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3708 && !VECTOR_FLOAT_TYPE_P (type0)
3709 && !VECTOR_FLOAT_TYPE_P (type1)))
3713 case TRUNC_MOD_EXPR:
3714 case FLOOR_MOD_EXPR:
3715 warn_for_div_by_zero (location, op1);
3717 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3718 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
3719 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
3721 else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3723 /* Although it would be tempting to shorten always here, that loses
3724 on some targets, since the modulo instruction is undefined if the
3725 quotient can't be represented in the computation mode. We shorten
3726 only if unsigned or if dividing by something we know != -1. */
3727 shorten = ((TREE_CODE (op0) == NOP_EXPR
3728 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3729 || (TREE_CODE (op1) == INTEGER_CST
3730 && ! integer_all_onesp (op1)));
3735 case TRUTH_ANDIF_EXPR:
3736 case TRUTH_ORIF_EXPR:
3737 case TRUTH_AND_EXPR:
3739 result_type = boolean_type_node;
3742 /* Shift operations: result has same type as first operand;
3743 always convert second operand to int.
3744 Also set SHORT_SHIFT if shifting rightward. */
3747 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3749 result_type = type0;
3750 if (TREE_CODE (op1) == INTEGER_CST)
3752 if (tree_int_cst_lt (op1, integer_zero_node))
3754 if ((complain & tf_warning)
3755 && c_inhibit_evaluation_warnings == 0)
3756 warning (0, "right shift count is negative");
3760 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3761 && (complain & tf_warning)
3762 && c_inhibit_evaluation_warnings == 0)
3763 warning (0, "right shift count >= width of type");
3766 /* Convert the shift-count to an integer, regardless of
3767 size of value being shifted. */
3768 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3769 op1 = cp_convert (integer_type_node, op1);
3770 /* Avoid converting op1 to result_type later. */
3776 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3778 result_type = type0;
3779 if (TREE_CODE (op1) == INTEGER_CST)
3781 if (tree_int_cst_lt (op1, integer_zero_node))
3783 if ((complain & tf_warning)
3784 && c_inhibit_evaluation_warnings == 0)
3785 warning (0, "left shift count is negative");
3787 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3789 if ((complain & tf_warning)
3790 && c_inhibit_evaluation_warnings == 0)
3791 warning (0, "left shift count >= width of type");
3794 /* Convert the shift-count to an integer, regardless of
3795 size of value being shifted. */
3796 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3797 op1 = cp_convert (integer_type_node, op1);
3798 /* Avoid converting op1 to result_type later. */
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 warning (0, (code == LROTATE_EXPR)
3814 ? G_("left rotate count is negative")
3815 : G_("right rotate count is negative"));
3817 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3819 if (complain & tf_warning)
3820 warning (0, (code == LROTATE_EXPR)
3821 ? G_("left rotate count >= width of type")
3822 : G_("right rotate count >= width of type"));
3825 /* Convert the shift-count to an integer, regardless of
3826 size of value being shifted. */
3827 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3828 op1 = cp_convert (integer_type_node, op1);
3834 if ((complain & tf_warning)
3835 && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3836 warning (OPT_Wfloat_equal,
3837 "comparing floating point with == or != is unsafe");
3838 if ((complain & tf_warning)
3839 && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3840 || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3841 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3843 build_type = boolean_type_node;
3844 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3845 || code0 == COMPLEX_TYPE || code0 == ENUMERAL_TYPE)
3846 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3847 || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE))
3849 else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3850 || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3851 result_type = composite_pointer_type (type0, type1, op0, op1,
3852 CPO_COMPARISON, complain);
3853 else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3854 && null_ptr_cst_p (op1))
3856 if (TREE_CODE (op0) == ADDR_EXPR
3857 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3859 if (complain & tf_warning)
3860 warning (OPT_Waddress, "the address of %qD will never be NULL",
3861 TREE_OPERAND (op0, 0));
3863 result_type = type0;
3865 else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3866 && null_ptr_cst_p (op0))
3868 if (TREE_CODE (op1) == ADDR_EXPR
3869 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3871 if (complain & tf_warning)
3872 warning (OPT_Waddress, "the address of %qD will never be NULL",
3873 TREE_OPERAND (op1, 0));
3875 result_type = type1;
3877 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3879 result_type = type0;
3880 if (complain & tf_error)
3881 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3883 return error_mark_node;
3885 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3887 result_type = type1;
3888 if (complain & tf_error)
3889 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3891 return error_mark_node;
3893 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3895 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3896 == ptrmemfunc_vbit_in_delta)
3898 tree pfn0 = pfn_from_ptrmemfunc (op0);
3899 tree delta0 = delta_from_ptrmemfunc (op0);
3900 tree e1 = cp_build_binary_op (location,
3903 fold_convert (TREE_TYPE (pfn0),
3906 tree e2 = cp_build_binary_op (location,
3911 e2 = cp_build_binary_op (location,
3912 EQ_EXPR, e2, integer_zero_node,
3914 op0 = cp_build_binary_op (location,
3915 TRUTH_ANDIF_EXPR, e1, e2,
3917 op1 = cp_convert (TREE_TYPE (op0), integer_one_node);
3921 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3922 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3924 result_type = TREE_TYPE (op0);
3926 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3927 return cp_build_binary_op (location, code, op1, op0, complain);
3928 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3931 /* E will be the final comparison. */
3933 /* E1 and E2 are for scratch. */
3941 type = composite_pointer_type (type0, type1, op0, op1,
3942 CPO_COMPARISON, complain);
3944 if (!same_type_p (TREE_TYPE (op0), type))
3945 op0 = cp_convert_and_check (type, op0);
3946 if (!same_type_p (TREE_TYPE (op1), type))
3947 op1 = cp_convert_and_check (type, op1);
3949 if (op0 == error_mark_node || op1 == error_mark_node)
3950 return error_mark_node;
3952 if (TREE_SIDE_EFFECTS (op0))
3953 op0 = save_expr (op0);
3954 if (TREE_SIDE_EFFECTS (op1))
3955 op1 = save_expr (op1);
3957 pfn0 = pfn_from_ptrmemfunc (op0);
3958 pfn1 = pfn_from_ptrmemfunc (op1);
3959 delta0 = delta_from_ptrmemfunc (op0);
3960 delta1 = delta_from_ptrmemfunc (op1);
3961 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3962 == ptrmemfunc_vbit_in_delta)
3967 && ((op0.delta == op1.delta)
3968 || (!op0.pfn && op0.delta & 1 == 0
3969 && op1.delta & 1 == 0))
3971 The reason for the `!op0.pfn' bit is that a NULL
3972 pointer-to-member is any member with a zero PFN and
3973 LSB of the DELTA field is 0. */
3975 e1 = cp_build_binary_op (location, BIT_AND_EXPR,
3979 e1 = cp_build_binary_op (location,
3980 EQ_EXPR, e1, integer_zero_node,
3982 e2 = cp_build_binary_op (location, BIT_AND_EXPR,
3986 e2 = cp_build_binary_op (location,
3987 EQ_EXPR, e2, integer_zero_node,
3989 e1 = cp_build_binary_op (location,
3990 TRUTH_ANDIF_EXPR, e2, e1,
3992 e2 = cp_build_binary_op (location, EQ_EXPR,
3994 fold_convert (TREE_TYPE (pfn0),
3997 e2 = cp_build_binary_op (location,
3998 TRUTH_ANDIF_EXPR, e2, e1, complain);
3999 e1 = cp_build_binary_op (location,
4000 EQ_EXPR, delta0, delta1, complain);
4001 e1 = cp_build_binary_op (location,
4002 TRUTH_ORIF_EXPR, e1, e2, complain);
4009 && (!op0.pfn || op0.delta == op1.delta))
4011 The reason for the `!op0.pfn' bit is that a NULL
4012 pointer-to-member is any member with a zero PFN; the
4013 DELTA field is unspecified. */
4015 e1 = cp_build_binary_op (location,
4016 EQ_EXPR, delta0, delta1, complain);
4017 e2 = cp_build_binary_op (location,
4020 fold_convert (TREE_TYPE (pfn0),
4023 e1 = cp_build_binary_op (location,
4024 TRUTH_ORIF_EXPR, e1, e2, complain);
4026 e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
4027 e = cp_build_binary_op (location,
4028 TRUTH_ANDIF_EXPR, e2, e1, complain);
4029 if (code == EQ_EXPR)
4031 return cp_build_binary_op (location,
4032 EQ_EXPR, e, integer_zero_node, complain);
4036 gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
4037 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
4039 gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
4040 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
4048 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
4049 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
4051 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
4052 result_type = composite_pointer_type (type0, type1, op0, op1,
4053 CPO_COMPARISON, complain);
4060 if (TREE_CODE (orig_op0) == STRING_CST
4061 || TREE_CODE (orig_op1) == STRING_CST)
4063 if (complain & tf_warning)
4064 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
4067 build_type = boolean_type_node;
4068 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
4069 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
4071 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
4072 result_type = composite_pointer_type (type0, type1, op0, op1,
4073 CPO_COMPARISON, complain);
4074 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
4075 && integer_zerop (op1))
4076 result_type = type0;
4077 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
4078 && integer_zerop (op0))
4079 result_type = type1;
4080 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
4082 result_type = type0;
4083 if (complain & tf_error)
4084 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
4086 return error_mark_node;
4088 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
4090 result_type = type1;
4091 if (complain & tf_error)
4092 permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
4094 return error_mark_node;
4098 case UNORDERED_EXPR:
4105 build_type = integer_type_node;
4106 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
4108 if (complain & tf_error)
4109 error ("unordered comparison on non-floating point argument");
4110 return error_mark_node;
4119 if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
4120 || code0 == ENUMERAL_TYPE)
4121 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4122 || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE)))
4123 arithmetic_types_p = 1;
4126 arithmetic_types_p = 0;
4127 /* Vector arithmetic is only allowed when both sides are vectors. */
4128 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
4130 if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
4131 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
4134 binary_op_error (location, code, type0, type1);
4135 return error_mark_node;
4137 arithmetic_types_p = 1;
4140 /* Determine the RESULT_TYPE, if it is not already known. */
4142 && arithmetic_types_p
4143 && (shorten || common || short_compare))
4144 result_type = cp_common_type (type0, type1);
4148 if (complain & tf_error)
4149 error ("invalid operands of types %qT and %qT to binary %qO",
4150 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
4151 return error_mark_node;
4154 /* If we're in a template, the only thing we need to know is the
4156 if (processing_template_decl)
4158 /* Since the middle-end checks the type when doing a build2, we
4159 need to build the tree in pieces. This built tree will never
4160 get out of the front-end as we replace it when instantiating
4162 tree tmp = build2 (resultcode,
4163 build_type ? build_type : result_type,
4165 TREE_OPERAND (tmp, 0) = op0;
4169 if (arithmetic_types_p)
4171 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
4173 /* For certain operations (which identify themselves by shorten != 0)
4174 if both args were extended from the same smaller type,
4175 do the arithmetic in that type and then extend.
4177 shorten !=0 and !=1 indicates a bitwise operation.
4178 For them, this optimization is safe only if
4179 both args are zero-extended or both are sign-extended.
4180 Otherwise, we might change the result.
4181 E.g., (short)-1 | (unsigned short)-1 is (int)-1
4182 but calculated in (unsigned short) it would be (unsigned short)-1. */
4184 if (shorten && none_complex)
4186 final_type = result_type;
4187 result_type = shorten_binary_op (result_type, op0, op1,
4191 /* Comparison operations are shortened too but differently.
4192 They identify themselves by setting short_compare = 1. */
4196 /* Don't write &op0, etc., because that would prevent op0
4197 from being kept in a register.
4198 Instead, make copies of the our local variables and
4199 pass the copies by reference, then copy them back afterward. */
4200 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
4201 enum tree_code xresultcode = resultcode;
4203 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
4205 return cp_convert (boolean_type_node, val);
4206 op0 = xop0, op1 = xop1;
4208 resultcode = xresultcode;
4211 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
4212 && warn_sign_compare
4213 && !TREE_NO_WARNING (orig_op0)
4214 && !TREE_NO_WARNING (orig_op1)
4215 /* Do not warn until the template is instantiated; we cannot
4216 bound the ranges of the arguments until that point. */
4217 && !processing_template_decl
4218 && (complain & tf_warning)
4219 && c_inhibit_evaluation_warnings == 0)
4221 warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1,
4222 result_type, resultcode);
4226 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4227 Then the expression will be built.
4228 It will be given type FINAL_TYPE if that is nonzero;
4229 otherwise, it will be given type RESULT_TYPE. */
4232 if (TREE_TYPE (op0) != result_type)
4233 op0 = cp_convert_and_check (result_type, op0);
4234 if (TREE_TYPE (op1) != result_type)
4235 op1 = cp_convert_and_check (result_type, op1);
4237 if (op0 == error_mark_node || op1 == error_mark_node)
4238 return error_mark_node;
4241 if (build_type == NULL_TREE)
4242 build_type = result_type;
4244 result = build2 (resultcode, build_type, op0, op1);
4245 result = fold_if_not_in_template (result);
4246 if (final_type != 0)
4247 result = cp_convert (final_type, result);
4249 if (TREE_OVERFLOW_P (result)
4250 && !TREE_OVERFLOW_P (op0)
4251 && !TREE_OVERFLOW_P (op1))
4252 overflow_warning (location, result);
4257 /* Return a tree for the sum or difference (RESULTCODE says which)
4258 of pointer PTROP and integer INTOP. */
4261 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
4263 tree res_type = TREE_TYPE (ptrop);
4265 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
4266 in certain circumstance (when it's valid to do so). So we need
4267 to make sure it's complete. We don't need to check here, if we
4268 can actually complete it at all, as those checks will be done in
4269 pointer_int_sum() anyway. */
4270 complete_type (TREE_TYPE (res_type));
4272 return pointer_int_sum (input_location, resultcode, ptrop,
4273 fold_if_not_in_template (intop));
4276 /* Return a tree for the difference of pointers OP0 and OP1.
4277 The resulting tree has type int. */
4280 pointer_diff (tree op0, tree op1, tree ptrtype)
4283 tree restype = ptrdiff_type_node;
4284 tree target_type = TREE_TYPE (ptrtype);
4286 if (!complete_type_or_else (target_type, NULL_TREE))
4287 return error_mark_node;
4289 if (TREE_CODE (target_type) == VOID_TYPE)
4290 permerror (input_location, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
4291 if (TREE_CODE (target_type) == FUNCTION_TYPE)
4292 permerror (input_location, "ISO C++ forbids using pointer to a function in subtraction");
4293 if (TREE_CODE (target_type) == METHOD_TYPE)
4294 permerror (input_location, "ISO C++ forbids using pointer to a method in subtraction");
4296 /* First do the subtraction as integers;
4297 then drop through to build the divide operator. */
4299 op0 = cp_build_binary_op (input_location,
4301 cp_convert (restype, op0),
4302 cp_convert (restype, op1),
4303 tf_warning_or_error);
4305 /* This generates an error if op1 is a pointer to an incomplete type. */
4306 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
4307 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4309 op1 = (TYPE_PTROB_P (ptrtype)
4310 ? size_in_bytes (target_type)
4311 : integer_one_node);
4313 /* Do the division. */
4315 result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4316 return fold_if_not_in_template (result);
4319 /* Construct and perhaps optimize a tree representation
4320 for a unary operation. CODE, a tree_code, specifies the operation
4321 and XARG is the operand. */
4324 build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain)
4326 tree orig_expr = xarg;
4330 if (processing_template_decl)
4332 if (type_dependent_expression_p (xarg))
4333 return build_min_nt (code, xarg, NULL_TREE);
4335 xarg = build_non_dependent_expr (xarg);
4340 /* [expr.unary.op] says:
4342 The address of an object of incomplete type can be taken.
4344 (And is just the ordinary address operator, not an overloaded
4345 "operator &".) However, if the type is a template
4346 specialization, we must complete the type at this point so that
4347 an overloaded "operator &" will be available if required. */
4348 if (code == ADDR_EXPR
4349 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4350 && ((CLASS_TYPE_P (TREE_TYPE (xarg))
4351 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
4352 || (TREE_CODE (xarg) == OFFSET_REF)))
4353 /* Don't look for a function. */;
4355 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
4356 /*overloaded_p=*/NULL, complain);
4357 if (!exp && code == ADDR_EXPR)
4359 if (is_overloaded_fn (xarg))
4361 tree fn = get_first_fn (xarg);
4362 if (DECL_CONSTRUCTOR_P (fn) || DECL_DESTRUCTOR_P (fn))
4365 (DECL_CONSTRUCTOR_P (fn) ? "constructor" : "destructor");
4366 error ("taking address of %s %qE", type, xarg);
4367 return error_mark_node;
4371 /* A pointer to member-function can be formed only by saying
4373 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4374 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4376 if (TREE_CODE (xarg) != OFFSET_REF
4377 || !TYPE_P (TREE_OPERAND (xarg, 0)))
4379 error ("invalid use of %qE to form a pointer-to-member-function",
4381 if (TREE_CODE (xarg) != OFFSET_REF)
4382 inform (input_location, " a qualified-id is required");
4383 return error_mark_node;
4387 error ("parentheses around %qE cannot be used to form a"
4388 " pointer-to-member-function",
4390 PTRMEM_OK_P (xarg) = 1;
4394 if (TREE_CODE (xarg) == OFFSET_REF)
4396 ptrmem = PTRMEM_OK_P (xarg);
4398 if (!ptrmem && !flag_ms_extensions
4399 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4401 /* A single non-static member, make sure we don't allow a
4402 pointer-to-member. */
4403 xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
4404 TREE_OPERAND (xarg, 0),
4405 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4406 PTRMEM_OK_P (xarg) = ptrmem;
4409 else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning))
4410 warning (0, "taking address of temporary");
4411 exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain);
4414 if (processing_template_decl && exp != error_mark_node)
4415 exp = build_min_non_dep (code, exp, orig_expr,
4416 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
4417 if (TREE_CODE (exp) == ADDR_EXPR)
4418 PTRMEM_OK_P (exp) = ptrmem;
4422 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4423 constants, where a null value is represented by an INTEGER_CST of
4427 cp_truthvalue_conversion (tree expr)
4429 tree type = TREE_TYPE (expr);
4430 if (TYPE_PTRMEM_P (type))
4431 return build_binary_op (EXPR_LOCATION (expr),
4432 NE_EXPR, expr, integer_zero_node, 1);
4434 return c_common_truthvalue_conversion (input_location, expr);
4437 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4440 condition_conversion (tree expr)
4443 if (processing_template_decl)
4445 t = perform_implicit_conversion_flags (boolean_type_node, expr,
4446 tf_warning_or_error, LOOKUP_NORMAL);
4447 t = fold_build_cleanup_point_expr (boolean_type_node, t);
4451 /* Returns the address of T. This function will fold away
4452 ADDR_EXPR of INDIRECT_REF. */
4455 build_address (tree t)
4457 if (error_operand_p (t) || !cxx_mark_addressable (t))
4458 return error_mark_node;
4459 t = build_fold_addr_expr (t);
4460 if (TREE_CODE (t) != ADDR_EXPR)
4465 /* Returns the address of T with type TYPE. */
4468 build_typed_address (tree t, tree type)
4470 if (error_operand_p (t) || !cxx_mark_addressable (t))
4471 return error_mark_node;
4472 t = build_fold_addr_expr_with_type (t, type);
4473 if (TREE_CODE (t) != ADDR_EXPR)
4478 /* Return a NOP_EXPR converting EXPR to TYPE. */
4481 build_nop (tree type, tree expr)
4483 if (type == error_mark_node || error_operand_p (expr))
4485 return build1 (NOP_EXPR, type, expr);
4488 /* C++: Must handle pointers to members.
4490 Perhaps type instantiation should be extended to handle conversion
4491 from aggregates to types we don't yet know we want? (Or are those
4492 cases typically errors which should be reported?)
4494 NOCONVERT nonzero suppresses the default promotions
4495 (such as from short to int). */
4498 cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
4499 tsubst_flags_t complain)
4501 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4504 const char *errstring = NULL;
4506 const char *invalid_op_diag;
4508 if (error_operand_p (arg))
4509 return error_mark_node;
4511 if ((invalid_op_diag
4512 = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
4517 error (invalid_op_diag);
4518 return error_mark_node;
4523 case UNARY_PLUS_EXPR:
4526 int flags = WANT_ARITH | WANT_ENUM;
4527 /* Unary plus (but not unary minus) is allowed on pointers. */
4528 if (code == UNARY_PLUS_EXPR)
4529 flags |= WANT_POINTER;
4530 arg = build_expr_type_conversion (flags, arg, true);
4532 errstring = (code == NEGATE_EXPR
4533 ? _("wrong type argument to unary minus")
4534 : _("wrong type argument to unary plus"));
4537 if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4538 arg = perform_integral_promotions (arg);
4540 /* Make sure the result is not an lvalue: a unary plus or minus
4541 expression is always a rvalue. */
4548 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4552 arg = default_conversion (arg);
4554 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
4557 errstring = _("wrong type argument to bit-complement");
4558 else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4559 arg = perform_integral_promotions (arg);
4563 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4564 errstring = _("wrong type argument to abs");
4565 else if (!noconvert)
4566 arg = default_conversion (arg);
4570 /* Conjugating a real value is a no-op, but allow it anyway. */
4571 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4572 errstring = _("wrong type argument to conjugation");
4573 else if (!noconvert)
4574 arg = default_conversion (arg);
4577 case TRUTH_NOT_EXPR:
4578 arg = perform_implicit_conversion (boolean_type_node, arg,
4580 val = invert_truthvalue_loc (input_location, arg);
4581 if (arg != error_mark_node)
4583 errstring = _("in argument to unary !");
4590 if (TREE_CODE (arg) == COMPLEX_CST)
4591 return TREE_REALPART (arg);
4592 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4594 arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4595 return fold_if_not_in_template (arg);
4601 if (TREE_CODE (arg) == COMPLEX_CST)
4602 return TREE_IMAGPART (arg);
4603 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4605 arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4606 return fold_if_not_in_template (arg);
4609 return cp_convert (TREE_TYPE (arg), integer_zero_node);
4611 case PREINCREMENT_EXPR:
4612 case POSTINCREMENT_EXPR:
4613 case PREDECREMENT_EXPR:
4614 case POSTDECREMENT_EXPR:
4615 /* Handle complex lvalues (when permitted)
4616 by reduction to simpler cases. */
4618 val = unary_complex_lvalue (code, arg);
4622 /* Increment or decrement the real part of the value,
4623 and don't change the imaginary part. */
4624 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4628 arg = stabilize_reference (arg);
4629 real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain);
4630 imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain);
4631 real = cp_build_unary_op (code, real, 1, complain);
4632 if (real == error_mark_node || imag == error_mark_node)
4633 return error_mark_node;
4634 return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4638 /* Report invalid types. */
4640 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4643 if (code == PREINCREMENT_EXPR)
4644 errstring = _("no pre-increment operator for type");
4645 else if (code == POSTINCREMENT_EXPR)
4646 errstring = _("no post-increment operator for type");
4647 else if (code == PREDECREMENT_EXPR)
4648 errstring = _("no pre-decrement operator for type");
4650 errstring = _("no post-decrement operator for type");
4653 else if (arg == error_mark_node)
4654 return error_mark_node;
4656 /* Report something read-only. */
4658 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4659 || TREE_READONLY (arg))
4661 if (complain & tf_error)
4662 readonly_error (arg, ((code == PREINCREMENT_EXPR
4663 || code == POSTINCREMENT_EXPR)
4664 ? REK_INCREMENT : REK_DECREMENT));
4666 return error_mark_node;
4671 tree declared_type = unlowered_expr_type (arg);
4673 argtype = TREE_TYPE (arg);
4675 /* ARM $5.2.5 last annotation says this should be forbidden. */
4676 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4678 if (complain & tf_error)
4679 permerror (input_location, (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4680 ? G_("ISO C++ forbids incrementing an enum")
4681 : G_("ISO C++ forbids decrementing an enum"));
4683 return error_mark_node;
4686 /* Compute the increment. */
4688 if (TREE_CODE (argtype) == POINTER_TYPE)
4690 tree type = complete_type (TREE_TYPE (argtype));
4692 if (!COMPLETE_OR_VOID_TYPE_P (type))
4694 if (complain & tf_error)
4695 error (((code == PREINCREMENT_EXPR
4696 || code == POSTINCREMENT_EXPR))
4697 ? G_("cannot increment a pointer to incomplete type %qT")
4698 : G_("cannot decrement a pointer to incomplete type %qT"),
4699 TREE_TYPE (argtype));
4701 return error_mark_node;
4703 else if ((pedantic || warn_pointer_arith)
4704 && !TYPE_PTROB_P (argtype))
4706 if (complain & tf_error)
4707 permerror (input_location, (code == PREINCREMENT_EXPR
4708 || code == POSTINCREMENT_EXPR)
4709 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4710 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4713 return error_mark_node;
4716 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4719 inc = integer_one_node;
4721 inc = cp_convert (argtype, inc);
4723 /* Complain about anything else that is not a true lvalue. */
4724 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4725 || code == POSTINCREMENT_EXPR)
4726 ? lv_increment : lv_decrement),
4728 return error_mark_node;
4730 /* Forbid using -- on `bool'. */
4731 if (TREE_CODE (declared_type) == BOOLEAN_TYPE)
4733 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4735 if (complain & tf_error)
4736 error ("invalid use of Boolean expression as operand "
4737 "to %<operator--%>");
4738 return error_mark_node;
4740 val = boolean_increment (code, arg);
4743 val = build2 (code, TREE_TYPE (arg), arg, inc);
4745 TREE_SIDE_EFFECTS (val) = 1;
4750 /* Note that this operation never does default_conversion
4751 regardless of NOCONVERT. */
4753 argtype = lvalue_type (arg);
4755 if (TREE_CODE (arg) == OFFSET_REF)
4758 if (TREE_CODE (argtype) == REFERENCE_TYPE)
4760 tree type = build_pointer_type (TREE_TYPE (argtype));
4761 arg = build1 (CONVERT_EXPR, type, arg);
4764 else if (pedantic && DECL_MAIN_P (arg))
4767 /* Apparently a lot of autoconf scripts for C++ packages do this,
4768 so only complain if -pedantic. */
4769 if (complain & (flag_pedantic_errors ? tf_error : tf_warning))
4770 pedwarn (input_location, OPT_pedantic,
4771 "ISO C++ forbids taking address of function %<::main%>");
4772 else if (flag_pedantic_errors)
4773 return error_mark_node;
4776 /* Let &* cancel out to simplify resulting code. */
4777 if (TREE_CODE (arg) == INDIRECT_REF)
4779 /* We don't need to have `current_class_ptr' wrapped in a
4780 NON_LVALUE_EXPR node. */
4781 if (arg == current_class_ref)
4782 return current_class_ptr;
4784 arg = TREE_OPERAND (arg, 0);
4785 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4787 tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4788 arg = build1 (CONVERT_EXPR, type, arg);
4791 /* Don't let this be an lvalue. */
4796 /* Uninstantiated types are all functions. Taking the
4797 address of a function is a no-op, so just return the
4800 gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4801 || !IDENTIFIER_OPNAME_P (arg));
4803 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4804 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4806 /* They're trying to take the address of a unique non-static
4807 member function. This is ill-formed (except in MS-land),
4808 but let's try to DTRT.
4809 Note: We only handle unique functions here because we don't
4810 want to complain if there's a static overload; non-unique
4811 cases will be handled by instantiate_type. But we need to
4812 handle this case here to allow casts on the resulting PMF.
4813 We could defer this in non-MS mode, but it's easier to give
4814 a useful error here. */
4816 /* Inside constant member functions, the `this' pointer
4817 contains an extra const qualifier. TYPE_MAIN_VARIANT
4818 is used here to remove this const from the diagnostics
4819 and the created OFFSET_REF. */
4820 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4821 tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4824 if (! flag_ms_extensions)
4826 tree name = DECL_NAME (fn);
4827 if (!(complain & tf_error))
4828 return error_mark_node;
4829 else if (current_class_type
4830 && TREE_OPERAND (arg, 0) == current_class_ref)
4831 /* An expression like &memfn. */
4832 permerror (input_location, "ISO C++ forbids taking the address of an unqualified"
4833 " or parenthesized non-static member function to form"
4834 " a pointer to member function. Say %<&%T::%D%>",
4837 permerror (input_location, "ISO C++ forbids taking the address of a bound member"
4838 " function to form a pointer to member function."
4842 arg = build_offset_ref (base, fn, /*address_p=*/true);
4846 if (type_unknown_p (arg))
4847 return build1 (ADDR_EXPR, unknown_type_node, arg);
4849 /* Handle complex lvalues (when permitted)
4850 by reduction to simpler cases. */
4851 val = unary_complex_lvalue (code, arg);
4855 switch (TREE_CODE (arg))
4859 case FIX_TRUNC_EXPR:
4860 /* Even if we're not being pedantic, we cannot allow this
4861 extension when we're instantiating in a SFINAE
4863 if (! lvalue_p (arg) && complain == tf_none)
4865 if (complain & tf_error)
4866 permerror (input_location, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4868 return error_mark_node;
4873 arg = BASELINK_FUNCTIONS (arg);
4877 arg = OVL_CURRENT (arg);
4881 /* Turn a reference to a non-static data member into a
4882 pointer-to-member. */
4887 if (!PTRMEM_OK_P (arg))
4888 return cp_build_unary_op (code, arg, 0, complain);
4890 t = TREE_OPERAND (arg, 1);
4891 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4893 if (complain & tf_error)
4894 error ("cannot create pointer to reference member %qD", t);
4895 return error_mark_node;
4898 type = build_ptrmem_type (context_for_name_lookup (t),
4900 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4908 /* Anything not already handled and not a true memory reference
4910 if (TREE_CODE (argtype) != FUNCTION_TYPE
4911 && TREE_CODE (argtype) != METHOD_TYPE
4912 && TREE_CODE (arg) != OFFSET_REF
4913 && !lvalue_or_else (arg, lv_addressof, complain))
4914 return error_mark_node;
4916 if (argtype != error_mark_node)
4917 argtype = build_pointer_type (argtype);
4919 /* In a template, we are processing a non-dependent expression
4920 so we can just form an ADDR_EXPR with the correct type. */
4921 if (processing_template_decl || TREE_CODE (arg) != COMPONENT_REF)
4923 val = build_address (arg);
4924 if (TREE_CODE (arg) == OFFSET_REF)
4925 PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4927 else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4929 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4931 /* We can only get here with a single static member
4933 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4934 && DECL_STATIC_FUNCTION_P (fn));
4936 val = build_address (fn);
4937 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4938 /* Do not lose object's side effects. */
4939 val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4940 TREE_OPERAND (arg, 0), val);
4942 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4944 if (complain & tf_error)
4945 error ("attempt to take address of bit-field structure member %qD",
4946 TREE_OPERAND (arg, 1));
4947 return error_mark_node;
4951 tree object = TREE_OPERAND (arg, 0);
4952 tree field = TREE_OPERAND (arg, 1);
4953 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4954 (TREE_TYPE (object), decl_type_context (field)));
4955 val = build_address (arg);
4958 if (TREE_CODE (argtype) == POINTER_TYPE
4959 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4961 build_ptrmemfunc_type (argtype);
4962 val = build_ptrmemfunc (argtype, val, 0,
4963 /*c_cast_p=*/false);
4975 argtype = TREE_TYPE (arg);
4976 return fold_if_not_in_template (build1 (code, argtype, arg));
4979 if (complain & tf_error)
4980 error ("%s", errstring);
4981 return error_mark_node;
4984 /* Hook for the c-common bits that build a unary op. */
4986 build_unary_op (location_t location ATTRIBUTE_UNUSED,
4987 enum tree_code code, tree xarg, int noconvert)
4989 return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
4992 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4993 for certain kinds of expressions which are not really lvalues
4994 but which we can accept as lvalues.
4996 If ARG is not a kind of expression we can handle, return
5000 unary_complex_lvalue (enum tree_code code, tree arg)
5002 /* Inside a template, making these kinds of adjustments is
5003 pointless; we are only concerned with the type of the
5005 if (processing_template_decl)
5008 /* Handle (a, b) used as an "lvalue". */
5009 if (TREE_CODE (arg) == COMPOUND_EXPR)
5011 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0,
5012 tf_warning_or_error);
5013 return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
5014 TREE_OPERAND (arg, 0), real_result);
5017 /* Handle (a ? b : c) used as an "lvalue". */
5018 if (TREE_CODE (arg) == COND_EXPR
5019 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
5020 return rationalize_conditional_expr (code, arg, tf_warning_or_error);
5022 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
5023 if (TREE_CODE (arg) == MODIFY_EXPR
5024 || TREE_CODE (arg) == PREINCREMENT_EXPR
5025 || TREE_CODE (arg) == PREDECREMENT_EXPR)
5027 tree lvalue = TREE_OPERAND (arg, 0);
5028 if (TREE_SIDE_EFFECTS (lvalue))
5030 lvalue = stabilize_reference (lvalue);
5031 arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
5032 lvalue, TREE_OPERAND (arg, 1));
5034 return unary_complex_lvalue
5035 (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
5038 if (code != ADDR_EXPR)
5041 /* Handle (a = b) used as an "lvalue" for `&'. */
5042 if (TREE_CODE (arg) == MODIFY_EXPR
5043 || TREE_CODE (arg) == INIT_EXPR)
5045 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0,
5046 tf_warning_or_error);
5047 arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
5049 TREE_NO_WARNING (arg) = 1;
5053 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
5054 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
5055 || TREE_CODE (arg) == OFFSET_REF)
5058 /* We permit compiler to make function calls returning
5059 objects of aggregate type look like lvalues. */
5063 if (TREE_CODE (targ) == SAVE_EXPR)
5064 targ = TREE_OPERAND (targ, 0);
5066 if (TREE_CODE (targ) == CALL_EXPR && MAYBE_CLASS_TYPE_P (TREE_TYPE (targ)))
5068 if (TREE_CODE (arg) == SAVE_EXPR)
5071 targ = build_cplus_new (TREE_TYPE (arg), arg);
5072 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
5075 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
5076 return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
5077 TREE_OPERAND (targ, 0), current_function_decl, NULL);
5080 /* Don't let anything else be handled specially. */
5084 /* Mark EXP saying that we need to be able to take the
5085 address of it; it should not be allocated in a register.
5086 Value is true if successful.
5088 C++: we do not allow `current_class_ptr' to be addressable. */
5091 cxx_mark_addressable (tree exp)
5096 switch (TREE_CODE (x))
5103 x = TREE_OPERAND (x, 0);
5107 if (x == current_class_ptr)
5109 error ("cannot take the address of %<this%>, which is an rvalue expression");
5110 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
5116 /* Caller should not be trying to mark initialized
5117 constant fields addressable. */
5118 gcc_assert (DECL_LANG_SPECIFIC (x) == 0
5119 || DECL_IN_AGGR_P (x) == 0
5121 || DECL_EXTERNAL (x));
5126 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
5127 && !DECL_ARTIFICIAL (x))
5129 if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
5132 ("address of explicit register variable %qD requested", x);
5135 else if (extra_warnings)
5137 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
5139 TREE_ADDRESSABLE (x) = 1;
5143 TREE_ADDRESSABLE (x) = 1;
5147 TREE_ADDRESSABLE (x) = 1;
5151 TREE_ADDRESSABLE (x) = 1;
5152 cxx_mark_addressable (TREE_OPERAND (x, 0));
5160 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
5163 build_x_conditional_expr (tree ifexp, tree op1, tree op2,
5164 tsubst_flags_t complain)
5166 tree orig_ifexp = ifexp;
5167 tree orig_op1 = op1;
5168 tree orig_op2 = op2;
5171 if (processing_template_decl)
5173 /* The standard says that the expression is type-dependent if
5174 IFEXP is type-dependent, even though the eventual type of the
5175 expression doesn't dependent on IFEXP. */
5176 if (type_dependent_expression_p (ifexp)
5177 /* As a GNU extension, the middle operand may be omitted. */
5178 || (op1 && type_dependent_expression_p (op1))
5179 || type_dependent_expression_p (op2))
5180 return build_min_nt (COND_EXPR, ifexp, op1, op2);
5181 ifexp = build_non_dependent_expr (ifexp);
5183 op1 = build_non_dependent_expr (op1);
5184 op2 = build_non_dependent_expr (op2);
5187 expr = build_conditional_expr (ifexp, op1, op2, complain);
5188 if (processing_template_decl && expr != error_mark_node)
5189 return build_min_non_dep (COND_EXPR, expr,
5190 orig_ifexp, orig_op1, orig_op2);
5194 /* Given a list of expressions, return a compound expression
5195 that performs them all and returns the value of the last of them. */
5197 tree build_x_compound_expr_from_list (tree list, const char *msg)
5199 tree expr = TREE_VALUE (list);
5201 if (TREE_CHAIN (list))
5204 permerror (input_location, "%s expression list treated as compound expression", msg);
5206 for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
5207 expr = build_x_compound_expr (expr, TREE_VALUE (list),
5208 tf_warning_or_error);
5214 /* Like build_x_compound_expr_from_list, but using a VEC. */
5217 build_x_compound_expr_from_vec (VEC(tree,gc) *vec, const char *msg)
5219 if (VEC_empty (tree, vec))
5221 else if (VEC_length (tree, vec) == 1)
5222 return VEC_index (tree, vec, 0);
5230 permerror (input_location,
5231 "%s expression list treated as compound expression",
5234 expr = VEC_index (tree, vec, 0);
5235 for (ix = 1; VEC_iterate (tree, vec, ix, t); ++ix)
5236 expr = build_x_compound_expr (expr, t, tf_warning_or_error);
5242 /* Handle overloading of the ',' operator when needed. */
5245 build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain)
5248 tree orig_op1 = op1;
5249 tree orig_op2 = op2;
5251 if (processing_template_decl)
5253 if (type_dependent_expression_p (op1)
5254 || type_dependent_expression_p (op2))
5255 return build_min_nt (COMPOUND_EXPR, op1, op2);
5256 op1 = build_non_dependent_expr (op1);
5257 op2 = build_non_dependent_expr (op2);
5260 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
5261 /*overloaded_p=*/NULL, complain);
5263 result = cp_build_compound_expr (op1, op2, complain);
5265 if (processing_template_decl && result != error_mark_node)
5266 return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
5271 /* Like cp_build_compound_expr, but for the c-common bits. */
5274 build_compound_expr (location_t loc ATTRIBUTE_UNUSED, tree lhs, tree rhs)
5276 return cp_build_compound_expr (lhs, rhs, tf_warning_or_error);
5279 /* Build a compound expression. */
5282 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
5284 lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
5286 if (lhs == error_mark_node || rhs == error_mark_node)
5287 return error_mark_node;
5289 if (TREE_CODE (rhs) == TARGET_EXPR)
5291 /* If the rhs is a TARGET_EXPR, then build the compound
5292 expression inside the target_expr's initializer. This
5293 helps the compiler to eliminate unnecessary temporaries. */
5294 tree init = TREE_OPERAND (rhs, 1);
5296 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
5297 TREE_OPERAND (rhs, 1) = init;
5302 if (type_unknown_p (rhs))
5304 error ("no context to resolve type of %qE", rhs);
5305 return error_mark_node;
5308 return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
5311 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
5312 casts away constness. CAST gives the type of cast.
5314 ??? This function warns for casting away any qualifier not just
5315 const. We would like to specify exactly what qualifiers are casted
5320 check_for_casting_away_constness (tree src_type, tree dest_type,
5321 enum tree_code cast)
5323 /* C-style casts are allowed to cast away constness. With
5324 WARN_CAST_QUAL, we still want to issue a warning. */
5325 if (cast == CAST_EXPR && !warn_cast_qual)
5328 if (!casts_away_constness (src_type, dest_type))
5334 warning (OPT_Wcast_qual,
5335 "cast from type %qT to type %qT casts away qualifiers",
5336 src_type, dest_type);
5339 case STATIC_CAST_EXPR:
5340 error ("static_cast from type %qT to type %qT casts away qualifiers",
5341 src_type, dest_type);
5344 case REINTERPRET_CAST_EXPR:
5345 error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
5346 src_type, dest_type);
5353 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
5354 (another pointer-to-member type in the same hierarchy) and return
5355 the converted expression. If ALLOW_INVERSE_P is permitted, a
5356 pointer-to-derived may be converted to pointer-to-base; otherwise,
5357 only the other direction is permitted. If C_CAST_P is true, this
5358 conversion is taking place as part of a C-style cast. */
5361 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
5364 if (TYPE_PTRMEM_P (type))
5368 if (TREE_CODE (expr) == PTRMEM_CST)
5369 expr = cplus_expand_constant (expr);
5370 delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
5371 TYPE_PTRMEM_CLASS_TYPE (type),
5374 if (!integer_zerop (delta))
5376 tree cond, op1, op2;
5378 cond = cp_build_binary_op (input_location,
5381 build_int_cst (TREE_TYPE (expr), -1),
5382 tf_warning_or_error);
5383 op1 = build_nop (ptrdiff_type_node, expr);
5384 op2 = cp_build_binary_op (input_location,
5385 PLUS_EXPR, op1, delta,
5386 tf_warning_or_error);
5388 expr = fold_build3_loc (input_location,
5389 COND_EXPR, ptrdiff_type_node, cond, op1, op2);
5393 return build_nop (type, expr);
5396 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
5397 allow_inverse_p, c_cast_p);
5400 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5401 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5402 Otherwise, return EXPR unchanged. */
5405 ignore_overflows (tree expr, tree orig)
5407 if (TREE_CODE (expr) == INTEGER_CST
5408 && CONSTANT_CLASS_P (orig)
5409 && TREE_CODE (orig) != STRING_CST
5410 && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
5412 if (!TREE_OVERFLOW (orig))
5413 /* Ensure constant sharing. */
5414 expr = build_int_cst_wide (TREE_TYPE (expr),
5415 TREE_INT_CST_LOW (expr),
5416 TREE_INT_CST_HIGH (expr));
5419 /* Avoid clobbering a shared constant. */
5420 expr = copy_node (expr);
5421 TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
5427 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
5428 this static_cast is being attempted as one of the possible casts
5429 allowed by a C-style cast. (In that case, accessibility of base
5430 classes is not considered, and it is OK to cast away
5431 constness.) Return the result of the cast. *VALID_P is set to
5432 indicate whether or not the cast was valid. */
5435 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
5436 bool *valid_p, tsubst_flags_t complain)
5442 /* Assume the cast is valid. */
5445 intype = TREE_TYPE (expr);
5447 /* Save casted types in the function's used types hash table. */
5448 used_types_insert (type);
5450 /* [expr.static.cast]
5452 An lvalue of type "cv1 B", where B is a class type, can be cast
5453 to type "reference to cv2 D", where D is a class derived (clause
5454 _class.derived_) from B, if a valid standard conversion from
5455 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5456 same cv-qualification as, or greater cv-qualification than, cv1,
5457 and B is not a virtual base class of D. */
5458 /* We check this case before checking the validity of "TYPE t =
5459 EXPR;" below because for this case:
5462 struct D : public B { D(const B&); };
5464 void f() { static_cast<const D&>(b); }
5466 we want to avoid constructing a new D. The standard is not
5467 completely clear about this issue, but our interpretation is
5468 consistent with other compilers. */
5469 if (TREE_CODE (type) == REFERENCE_TYPE
5470 && CLASS_TYPE_P (TREE_TYPE (type))
5471 && CLASS_TYPE_P (intype)
5472 && (TYPE_REF_IS_RVALUE (type) || real_lvalue_p (expr))
5473 && DERIVED_FROM_P (intype, TREE_TYPE (type))
5474 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
5475 build_pointer_type (TYPE_MAIN_VARIANT
5476 (TREE_TYPE (type))))
5478 || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5482 /* There is a standard conversion from "D*" to "B*" even if "B"
5483 is ambiguous or inaccessible. If this is really a
5484 static_cast, then we check both for inaccessibility and
5485 ambiguity. However, if this is a static_cast being performed
5486 because the user wrote a C-style cast, then accessibility is
5488 base = lookup_base (TREE_TYPE (type), intype,
5489 c_cast_p ? ba_unique : ba_check,
5492 /* Convert from "B*" to "D*". This function will check that "B"
5493 is not a virtual base of "D". */
5494 expr = build_base_path (MINUS_EXPR, build_address (expr),
5495 base, /*nonnull=*/false);
5496 /* Convert the pointer to a reference -- but then remember that
5497 there are no expressions with reference type in C++. */
5498 return convert_from_reference (cp_fold_convert (type, expr));
5501 /* "An lvalue of type cv1 T1 can be cast to type rvalue reference to
5502 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
5503 if (TREE_CODE (type) == REFERENCE_TYPE
5504 && TYPE_REF_IS_RVALUE (type)
5505 && real_lvalue_p (expr)
5506 && reference_related_p (TREE_TYPE (type), intype)
5507 && (c_cast_p || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5509 expr = build_typed_address (expr, type);
5510 return convert_from_reference (expr);
5515 /* Resolve overloaded address here rather than once in
5516 implicit_conversion and again in the inverse code below. */
5517 if (TYPE_PTRMEMFUNC_P (type) && type_unknown_p (expr))
5519 expr = instantiate_type (type, expr, complain);
5520 intype = TREE_TYPE (expr);
5523 /* [expr.static.cast]
5525 An expression e can be explicitly converted to a type T using a
5526 static_cast of the form static_cast<T>(e) if the declaration T
5527 t(e);" is well-formed, for some invented temporary variable
5529 result = perform_direct_initialization_if_possible (type, expr,
5530 c_cast_p, complain);
5533 result = convert_from_reference (result);
5535 /* Ignore any integer overflow caused by the cast. */
5536 result = ignore_overflows (result, orig);
5538 /* [expr.static.cast]
5540 If T is a reference type, the result is an lvalue; otherwise,
5541 the result is an rvalue. */
5542 if (TREE_CODE (type) != REFERENCE_TYPE)
5543 result = rvalue (result);
5547 /* [expr.static.cast]
5549 Any expression can be explicitly converted to type cv void. */
5550 if (TREE_CODE (type) == VOID_TYPE)
5551 return convert_to_void (expr, /*implicit=*/NULL, complain);
5553 /* [expr.static.cast]
5555 The inverse of any standard conversion sequence (clause _conv_),
5556 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5557 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5558 (_conv.bool_) conversions, can be performed explicitly using
5559 static_cast subject to the restriction that the explicit
5560 conversion does not cast away constness (_expr.const.cast_), and
5561 the following additional rules for specific cases: */
5562 /* For reference, the conversions not excluded are: integral
5563 promotions, floating point promotion, integral conversions,
5564 floating point conversions, floating-integral conversions,
5565 pointer conversions, and pointer to member conversions. */
5568 A value of integral _or enumeration_ type can be explicitly
5569 converted to an enumeration type. */
5570 /* The effect of all that is that any conversion between any two
5571 types which are integral, floating, or enumeration types can be
5573 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type)
5574 || SCALAR_FLOAT_TYPE_P (type))
5575 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
5576 || SCALAR_FLOAT_TYPE_P (intype)))
5578 expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
5580 /* Ignore any integer overflow caused by the cast. */
5581 expr = ignore_overflows (expr, orig);
5585 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
5586 && CLASS_TYPE_P (TREE_TYPE (type))
5587 && CLASS_TYPE_P (TREE_TYPE (intype))
5588 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5589 (TREE_TYPE (intype))),
5590 build_pointer_type (TYPE_MAIN_VARIANT
5591 (TREE_TYPE (type)))))
5596 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5597 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
5598 c_cast_p ? ba_unique : ba_check,
5600 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
5603 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5604 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5611 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
5612 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
5614 if (TYPE_PTRMEM_P (type))
5616 t1 = (build_ptrmem_type
5618 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
5619 t2 = (build_ptrmem_type
5621 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
5628 if (can_convert (t1, t2) || can_convert (t2, t1))
5631 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5632 return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
5637 /* [expr.static.cast]
5639 An rvalue of type "pointer to cv void" can be explicitly
5640 converted to a pointer to object type. A value of type pointer
5641 to object converted to "pointer to cv void" and back to the
5642 original pointer type will have its original value. */
5643 if (TREE_CODE (intype) == POINTER_TYPE
5644 && VOID_TYPE_P (TREE_TYPE (intype))
5645 && TYPE_PTROB_P (type))
5648 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5649 return build_nop (type, expr);
5653 return error_mark_node;
5656 /* Return an expression representing static_cast<TYPE>(EXPR). */
5659 build_static_cast (tree type, tree expr, tsubst_flags_t complain)
5664 if (type == error_mark_node || expr == error_mark_node)
5665 return error_mark_node;
5667 if (processing_template_decl)
5669 expr = build_min (STATIC_CAST_EXPR, type, expr);
5670 /* We don't know if it will or will not have side effects. */
5671 TREE_SIDE_EFFECTS (expr) = 1;
5672 return convert_from_reference (expr);
5675 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5676 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5677 if (TREE_CODE (type) != REFERENCE_TYPE
5678 && TREE_CODE (expr) == NOP_EXPR
5679 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5680 expr = TREE_OPERAND (expr, 0);
5682 result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p,
5687 if (complain & tf_error)
5688 error ("invalid static_cast from type %qT to type %qT",
5689 TREE_TYPE (expr), type);
5690 return error_mark_node;
5693 /* EXPR is an expression with member function or pointer-to-member
5694 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5695 not permitted by ISO C++, but we accept it in some modes. If we
5696 are not in one of those modes, issue a diagnostic. Return the
5697 converted expression. */
5700 convert_member_func_to_ptr (tree type, tree expr)
5705 intype = TREE_TYPE (expr);
5706 gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5707 || TREE_CODE (intype) == METHOD_TYPE);
5709 if (pedantic || warn_pmf2ptr)
5710 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpmf_conversions,
5711 "converting from %qT to %qT", intype, type);
5713 if (TREE_CODE (intype) == METHOD_TYPE)
5714 expr = build_addr_func (expr);
5715 else if (TREE_CODE (expr) == PTRMEM_CST)
5716 expr = build_address (PTRMEM_CST_MEMBER (expr));
5719 decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5720 decl = build_address (decl);
5721 expr = get_member_function_from_ptrfunc (&decl, expr);
5724 return build_nop (type, expr);
5727 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5728 If C_CAST_P is true, this reinterpret cast is being done as part of
5729 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5730 indicate whether or not reinterpret_cast was valid. */
5733 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5734 bool *valid_p, tsubst_flags_t complain)
5738 /* Assume the cast is invalid. */
5742 if (type == error_mark_node || error_operand_p (expr))
5743 return error_mark_node;
5745 intype = TREE_TYPE (expr);
5747 /* Save casted types in the function's used types hash table. */
5748 used_types_insert (type);
5750 /* [expr.reinterpret.cast]
5751 An lvalue expression of type T1 can be cast to the type
5752 "reference to T2" if an expression of type "pointer to T1" can be
5753 explicitly converted to the type "pointer to T2" using a
5754 reinterpret_cast. */
5755 if (TREE_CODE (type) == REFERENCE_TYPE)
5757 if (! real_lvalue_p (expr))
5759 if (complain & tf_error)
5760 error ("invalid cast of an rvalue expression of type "
5763 return error_mark_node;
5766 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5767 "B" are related class types; the reinterpret_cast does not
5768 adjust the pointer. */
5769 if (TYPE_PTR_P (intype)
5770 && (complain & tf_warning)
5771 && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5772 COMPARE_BASE | COMPARE_DERIVED)))
5773 warning (0, "casting %qT to %qT does not dereference pointer",
5776 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5778 if (warn_strict_aliasing > 2)
5779 strict_aliasing_warning (TREE_TYPE (expr), type, expr);
5781 if (expr != error_mark_node)
5782 expr = build_reinterpret_cast_1
5783 (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5785 if (expr != error_mark_node)
5786 /* cp_build_indirect_ref isn't right for rvalue refs. */
5787 expr = convert_from_reference (fold_convert (type, expr));
5791 /* As a G++ extension, we consider conversions from member
5792 functions, and pointers to member functions to
5793 pointer-to-function and pointer-to-void types. If
5794 -Wno-pmf-conversions has not been specified,
5795 convert_member_func_to_ptr will issue an error message. */
5796 if ((TYPE_PTRMEMFUNC_P (intype)
5797 || TREE_CODE (intype) == METHOD_TYPE)
5798 && TYPE_PTR_P (type)
5799 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5800 || VOID_TYPE_P (TREE_TYPE (type))))
5801 return convert_member_func_to_ptr (type, expr);
5803 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5804 array-to-pointer, and function-to-pointer conversions are
5806 expr = decay_conversion (expr);
5808 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5809 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5810 if (TREE_CODE (expr) == NOP_EXPR
5811 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5812 expr = TREE_OPERAND (expr, 0);
5814 if (error_operand_p (expr))
5815 return error_mark_node;
5817 intype = TREE_TYPE (expr);
5819 /* [expr.reinterpret.cast]
5820 A pointer can be converted to any integral type large enough to
5822 if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5824 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5826 if (complain & tf_error)
5827 permerror (input_location, "cast from %qT to %qT loses precision",
5830 return error_mark_node;
5833 /* [expr.reinterpret.cast]
5834 A value of integral or enumeration type can be explicitly
5835 converted to a pointer. */
5836 else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5839 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5840 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5841 return fold_if_not_in_template (build_nop (type, expr));
5842 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5843 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5848 check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR);
5849 /* Warn about possible alignment problems. */
5850 if (STRICT_ALIGNMENT && warn_cast_align
5851 && (complain & tf_warning)
5852 && !VOID_TYPE_P (type)
5853 && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5854 && COMPLETE_TYPE_P (TREE_TYPE (type))
5855 && COMPLETE_TYPE_P (TREE_TYPE (intype))
5856 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5857 warning (OPT_Wcast_align, "cast from %qT to %qT "
5858 "increases required alignment of target type", intype, type);
5860 /* We need to strip nops here, because the front end likes to
5861 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5863 if (warn_strict_aliasing <= 2)
5864 strict_aliasing_warning (intype, type, sexpr);
5866 return fold_if_not_in_template (build_nop (type, expr));
5868 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5869 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5871 if (pedantic && (complain & tf_warning))
5872 /* Only issue a warning, as we have always supported this
5873 where possible, and it is necessary in some cases. DR 195
5874 addresses this issue, but as of 2004/10/26 is still in
5876 warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5877 return fold_if_not_in_template (build_nop (type, expr));
5879 else if (TREE_CODE (type) == VECTOR_TYPE)
5880 return fold_if_not_in_template (convert_to_vector (type, expr));
5881 else if (TREE_CODE (intype) == VECTOR_TYPE
5882 && INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5883 return fold_if_not_in_template (convert_to_integer (type, expr));
5888 if (complain & tf_error)
5889 error ("invalid cast from type %qT to type %qT", intype, type);
5890 return error_mark_node;
5893 return cp_convert (type, expr);
5897 build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain)
5899 if (type == error_mark_node || expr == error_mark_node)
5900 return error_mark_node;
5902 if (processing_template_decl)
5904 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5906 if (!TREE_SIDE_EFFECTS (t)
5907 && type_dependent_expression_p (expr))
5908 /* There might turn out to be side effects inside expr. */
5909 TREE_SIDE_EFFECTS (t) = 1;
5910 return convert_from_reference (t);
5913 return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5914 /*valid_p=*/NULL, complain);
5917 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5918 return an appropriate expression. Otherwise, return
5919 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5920 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5921 performing a C-style cast, its value upon return will indicate
5922 whether or not the conversion succeeded. */
5925 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5929 tree reference_type;
5931 /* Callers are responsible for handling error_mark_node as a
5932 destination type. */
5933 gcc_assert (dst_type != error_mark_node);
5934 /* In a template, callers should be building syntactic
5935 representations of casts, not using this machinery. */
5936 gcc_assert (!processing_template_decl);
5938 /* Assume the conversion is invalid. */
5942 if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5945 error ("invalid use of const_cast with type %qT, "
5946 "which is not a pointer, "
5947 "reference, nor a pointer-to-data-member type", dst_type);
5948 return error_mark_node;
5951 if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5954 error ("invalid use of const_cast with type %qT, which is a pointer "
5955 "or reference to a function type", dst_type);
5956 return error_mark_node;
5959 /* Save casted types in the function's used types hash table. */
5960 used_types_insert (dst_type);
5962 src_type = TREE_TYPE (expr);
5963 /* Expressions do not really have reference types. */
5964 if (TREE_CODE (src_type) == REFERENCE_TYPE)
5965 src_type = TREE_TYPE (src_type);
5967 /* [expr.const.cast]
5969 An lvalue of type T1 can be explicitly converted to an lvalue of
5970 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5971 types) if a pointer to T1 can be explicitly converted to the type
5972 pointer to T2 using a const_cast. */
5973 if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5975 reference_type = dst_type;
5976 if (! real_lvalue_p (expr))
5979 error ("invalid const_cast of an rvalue of type %qT to type %qT",
5980 src_type, dst_type);
5981 return error_mark_node;
5983 dst_type = build_pointer_type (TREE_TYPE (dst_type));
5984 src_type = build_pointer_type (src_type);
5988 reference_type = NULL_TREE;
5989 /* If the destination type is not a reference type, the
5990 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5991 conversions are performed. */
5992 src_type = type_decays_to (src_type);
5993 if (src_type == error_mark_node)
5994 return error_mark_node;
5997 if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5998 && comp_ptr_ttypes_const (dst_type, src_type))
6003 /* This cast is actually a C-style cast. Issue a warning if
6004 the user is making a potentially unsafe cast. */
6005 check_for_casting_away_constness (src_type, dst_type, CAST_EXPR);
6009 expr = cp_build_unary_op (ADDR_EXPR, expr, 0,
6010 complain? tf_warning_or_error : tf_none);
6011 expr = build_nop (reference_type, expr);
6012 return convert_from_reference (expr);
6016 expr = decay_conversion (expr);
6017 /* build_c_cast puts on a NOP_EXPR to make the result not an
6018 lvalue. Strip such NOP_EXPRs if VALUE is being used in
6019 non-lvalue context. */
6020 if (TREE_CODE (expr) == NOP_EXPR
6021 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
6022 expr = TREE_OPERAND (expr, 0);
6023 return build_nop (dst_type, expr);
6028 error ("invalid const_cast from type %qT to type %qT",
6029 src_type, dst_type);
6030 return error_mark_node;
6034 build_const_cast (tree type, tree expr, tsubst_flags_t complain)
6036 if (type == error_mark_node || error_operand_p (expr))
6037 return error_mark_node;
6039 if (processing_template_decl)
6041 tree t = build_min (CONST_CAST_EXPR, type, expr);
6043 if (!TREE_SIDE_EFFECTS (t)
6044 && type_dependent_expression_p (expr))
6045 /* There might turn out to be side effects inside expr. */
6046 TREE_SIDE_EFFECTS (t) = 1;
6047 return convert_from_reference (t);
6050 return build_const_cast_1 (type, expr, complain & tf_error,
6054 /* Like cp_build_c_cast, but for the c-common bits. */
6057 build_c_cast (location_t loc ATTRIBUTE_UNUSED, tree type, tree expr)
6059 return cp_build_c_cast (type, expr, tf_warning_or_error);
6062 /* Build an expression representing an explicit C-style cast to type
6063 TYPE of expression EXPR. */
6066 cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
6072 if (type == error_mark_node || error_operand_p (expr))
6073 return error_mark_node;
6075 if (processing_template_decl)
6077 tree t = build_min (CAST_EXPR, type,
6078 tree_cons (NULL_TREE, value, NULL_TREE));
6079 /* We don't know if it will or will not have side effects. */
6080 TREE_SIDE_EFFECTS (t) = 1;
6081 return convert_from_reference (t);
6084 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
6085 'Class') should always be retained, because this information aids
6086 in method lookup. */
6087 if (objc_is_object_ptr (type)
6088 && objc_is_object_ptr (TREE_TYPE (expr)))
6089 return build_nop (type, expr);
6091 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6092 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
6093 if (TREE_CODE (type) != REFERENCE_TYPE
6094 && TREE_CODE (value) == NOP_EXPR
6095 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
6096 value = TREE_OPERAND (value, 0);
6098 if (TREE_CODE (type) == ARRAY_TYPE)
6100 /* Allow casting from T1* to T2[] because Cfront allows it.
6101 NIHCL uses it. It is not valid ISO C++ however. */
6102 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
6104 if (complain & tf_error)
6105 permerror (input_location, "ISO C++ forbids casting to an array type %qT", type);
6107 return error_mark_node;
6108 type = build_pointer_type (TREE_TYPE (type));
6112 if (complain & tf_error)
6113 error ("ISO C++ forbids casting to an array type %qT", type);
6114 return error_mark_node;
6118 if (TREE_CODE (type) == FUNCTION_TYPE
6119 || TREE_CODE (type) == METHOD_TYPE)
6121 if (complain & tf_error)
6122 error ("invalid cast to function type %qT", type);
6123 return error_mark_node;
6126 /* A C-style cast can be a const_cast. */
6127 result = build_const_cast_1 (type, value, /*complain=*/false,
6132 /* Or a static cast. */
6133 result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
6134 &valid_p, complain);
6135 /* Or a reinterpret_cast. */
6137 result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
6138 &valid_p, complain);
6139 /* The static_cast or reinterpret_cast may be followed by a
6142 /* A valid cast may result in errors if, for example, a
6143 conversion to am ambiguous base class is required. */
6144 && !error_operand_p (result))
6148 /* Non-class rvalues always have cv-unqualified type. */
6149 if (!CLASS_TYPE_P (type))
6150 type = TYPE_MAIN_VARIANT (type);
6151 result_type = TREE_TYPE (result);
6152 if (!CLASS_TYPE_P (result_type))
6153 result_type = TYPE_MAIN_VARIANT (result_type);
6154 /* If the type of RESULT does not match TYPE, perform a
6155 const_cast to make it match. If the static_cast or
6156 reinterpret_cast succeeded, we will differ by at most
6157 cv-qualification, so the follow-on const_cast is guaranteed
6159 if (!same_type_p (non_reference (type), non_reference (result_type)))
6161 result = build_const_cast_1 (type, result, false, &valid_p);
6162 gcc_assert (valid_p);
6167 return error_mark_node;
6170 /* For use from the C common bits. */
6172 build_modify_expr (location_t location ATTRIBUTE_UNUSED,
6173 tree lhs, tree lhs_origtype ATTRIBUTE_UNUSED,
6174 enum tree_code modifycode,
6175 location_t rhs_location ATTRIBUTE_UNUSED, tree rhs,
6176 tree rhs_origtype ATTRIBUTE_UNUSED)
6178 return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
6181 /* Build an assignment expression of lvalue LHS from value RHS.
6182 MODIFYCODE is the code for a binary operator that we use
6183 to combine the old value of LHS with RHS to get the new value.
6184 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
6186 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
6189 cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6190 tsubst_flags_t complain)
6194 tree lhstype = TREE_TYPE (lhs);
6195 tree olhstype = lhstype;
6196 bool plain_assign = (modifycode == NOP_EXPR);
6198 /* Avoid duplicate error messages from operands that had errors. */
6199 if (error_operand_p (lhs) || error_operand_p (rhs))
6200 return error_mark_node;
6202 /* Handle control structure constructs used as "lvalues". */
6203 switch (TREE_CODE (lhs))
6205 /* Handle --foo = 5; as these are valid constructs in C++. */
6206 case PREDECREMENT_EXPR:
6207 case PREINCREMENT_EXPR:
6208 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
6209 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
6210 stabilize_reference (TREE_OPERAND (lhs, 0)),
6211 TREE_OPERAND (lhs, 1));
6212 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0),
6213 modifycode, rhs, complain);
6214 if (newrhs == error_mark_node)
6215 return error_mark_node;
6216 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
6218 /* Handle (a, b) used as an "lvalue". */
6220 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1),
6221 modifycode, rhs, complain);
6222 if (newrhs == error_mark_node)
6223 return error_mark_node;
6224 return build2 (COMPOUND_EXPR, lhstype,
6225 TREE_OPERAND (lhs, 0), newrhs);
6228 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
6229 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
6230 stabilize_reference (TREE_OPERAND (lhs, 0)),
6231 TREE_OPERAND (lhs, 1));
6232 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs,
6234 if (newrhs == error_mark_node)
6235 return error_mark_node;
6236 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
6240 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
6241 when neither operand has side-effects. */
6242 if (!lvalue_or_else (lhs, lv_assign, complain))
6243 return error_mark_node;
6245 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
6246 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
6248 lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
6249 build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
6251 TREE_OPERAND (lhs, 0),
6252 TREE_OPERAND (lhs, 1)),
6253 TREE_OPERAND (lhs, 0),
6254 TREE_OPERAND (lhs, 1));
6257 /* Handle (a ? b : c) used as an "lvalue". */
6260 /* Produce (a ? (b = rhs) : (c = rhs))
6261 except that the RHS goes through a save-expr
6262 so the code to compute it is only emitted once. */
6264 tree preeval = NULL_TREE;
6266 if (VOID_TYPE_P (TREE_TYPE (rhs)))
6268 if (complain & tf_error)
6269 error ("void value not ignored as it ought to be");
6270 return error_mark_node;
6273 rhs = stabilize_expr (rhs, &preeval);
6275 /* Check this here to avoid odd errors when trying to convert
6276 a throw to the type of the COND_EXPR. */
6277 if (!lvalue_or_else (lhs, lv_assign, complain))
6278 return error_mark_node;
6280 cond = build_conditional_expr
6281 (TREE_OPERAND (lhs, 0),
6282 cp_build_modify_expr (TREE_OPERAND (lhs, 1),
6283 modifycode, rhs, complain),
6284 cp_build_modify_expr (TREE_OPERAND (lhs, 2),
6285 modifycode, rhs, complain),
6288 if (cond == error_mark_node)
6290 /* Make sure the code to compute the rhs comes out
6291 before the split. */
6293 cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
6301 if (modifycode == INIT_EXPR)
6303 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
6304 /* Do the default thing. */;
6305 else if (TREE_CODE (rhs) == CONSTRUCTOR)
6307 /* Compound literal. */
6308 if (! same_type_p (TREE_TYPE (rhs), lhstype))
6309 /* Call convert to generate an error; see PR 11063. */
6310 rhs = convert (lhstype, rhs);
6311 result = build2 (INIT_EXPR, lhstype, lhs, rhs);
6312 TREE_SIDE_EFFECTS (result) = 1;
6315 else if (! MAYBE_CLASS_TYPE_P (lhstype))
6316 /* Do the default thing. */;
6319 VEC(tree,gc) *rhs_vec = make_tree_vector_single (rhs);
6320 result = build_special_member_call (lhs, complete_ctor_identifier,
6321 &rhs_vec, lhstype, LOOKUP_NORMAL,
6323 release_tree_vector (rhs_vec);
6324 if (result == NULL_TREE)
6325 return error_mark_node;
6331 lhs = require_complete_type (lhs);
6332 if (lhs == error_mark_node)
6333 return error_mark_node;
6335 if (modifycode == NOP_EXPR)
6337 /* `operator=' is not an inheritable operator. */
6338 if (! MAYBE_CLASS_TYPE_P (lhstype))
6339 /* Do the default thing. */;
6342 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
6343 lhs, rhs, make_node (NOP_EXPR),
6344 /*overloaded_p=*/NULL,
6346 if (result == NULL_TREE)
6347 return error_mark_node;
6354 /* A binary op has been requested. Combine the old LHS
6355 value with the RHS producing the value we should actually
6356 store into the LHS. */
6357 gcc_assert (!((TREE_CODE (lhstype) == REFERENCE_TYPE
6358 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype)))
6359 || MAYBE_CLASS_TYPE_P (lhstype)));
6361 lhs = stabilize_reference (lhs);
6362 newrhs = cp_build_binary_op (input_location,
6363 modifycode, lhs, rhs,
6365 if (newrhs == error_mark_node)
6367 if (complain & tf_error)
6368 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode,
6369 TREE_TYPE (lhs), TREE_TYPE (rhs));
6370 return error_mark_node;
6373 /* Now it looks like a plain assignment. */
6374 modifycode = NOP_EXPR;
6376 gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
6377 gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
6380 /* The left-hand side must be an lvalue. */
6381 if (!lvalue_or_else (lhs, lv_assign, complain))
6382 return error_mark_node;
6384 /* Warn about modifying something that is `const'. Don't warn if
6385 this is initialization. */
6386 if (modifycode != INIT_EXPR
6387 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
6388 /* Functions are not modifiable, even though they are
6390 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
6391 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
6392 /* If it's an aggregate and any field is const, then it is
6393 effectively const. */
6394 || (CLASS_TYPE_P (lhstype)
6395 && C_TYPE_FIELDS_READONLY (lhstype))))
6397 if (complain & tf_error)
6398 readonly_error (lhs, REK_ASSIGNMENT);
6400 return error_mark_node;
6403 /* If storing into a structure or union member, it may have been given a
6404 lowered bitfield type. We need to convert to the declared type first,
6405 so retrieve it now. */
6407 olhstype = unlowered_expr_type (lhs);
6409 /* Convert new value to destination type. */
6411 if (TREE_CODE (lhstype) == ARRAY_TYPE)
6415 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
6417 if (check_array_initializer (lhs, lhstype, rhs))
6418 return error_mark_node;
6419 rhs = digest_init (lhstype, rhs);
6422 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
6423 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
6425 if (complain & tf_error)
6426 error ("incompatible types in assignment of %qT to %qT",
6427 TREE_TYPE (rhs), lhstype);
6428 return error_mark_node;
6431 /* Allow array assignment in compiler-generated code. */
6432 else if (!current_function_decl
6433 || !DECL_ARTIFICIAL (current_function_decl))
6435 /* This routine is used for both initialization and assignment.
6436 Make sure the diagnostic message differentiates the context. */
6437 if (complain & tf_error)
6439 if (modifycode == INIT_EXPR)
6440 error ("array used as initializer");
6442 error ("invalid array assignment");
6444 return error_mark_node;
6447 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6448 ? 1 + (modifycode != INIT_EXPR): 0;
6449 return build_vec_init (lhs, NULL_TREE, newrhs,
6450 /*explicit_value_init_p=*/false,
6451 from_array, complain);
6454 if (modifycode == INIT_EXPR)
6455 /* Calls with INIT_EXPR are all direct-initialization, so don't set
6456 LOOKUP_ONLYCONVERTING. */
6457 newrhs = convert_for_initialization (lhs, olhstype, newrhs, LOOKUP_NORMAL,
6458 "initialization", NULL_TREE, 0,
6461 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6462 NULL_TREE, 0, complain, LOOKUP_IMPLICIT);
6464 if (!same_type_p (lhstype, olhstype))
6465 newrhs = cp_convert_and_check (lhstype, newrhs);
6467 if (modifycode != INIT_EXPR)
6469 if (TREE_CODE (newrhs) == CALL_EXPR
6470 && TYPE_NEEDS_CONSTRUCTING (lhstype))
6471 newrhs = build_cplus_new (lhstype, newrhs);
6473 /* Can't initialize directly from a TARGET_EXPR, since that would
6474 cause the lhs to be constructed twice, and possibly result in
6475 accidental self-initialization. So we force the TARGET_EXPR to be
6476 expanded without a target. */
6477 if (TREE_CODE (newrhs) == TARGET_EXPR)
6478 newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6479 TREE_OPERAND (newrhs, 0));
6482 if (newrhs == error_mark_node)
6483 return error_mark_node;
6485 if (c_dialect_objc () && flag_objc_gc)
6487 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6493 result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6494 lhstype, lhs, newrhs);
6496 TREE_SIDE_EFFECTS (result) = 1;
6498 TREE_NO_WARNING (result) = 1;
6504 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6505 tsubst_flags_t complain)
6507 if (processing_template_decl)
6508 return build_min_nt (MODOP_EXPR, lhs,
6509 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6511 if (modifycode != NOP_EXPR)
6513 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6514 make_node (modifycode),
6515 /*overloaded_p=*/NULL,
6519 TREE_NO_WARNING (rval) = 1;
6523 return cp_build_modify_expr (lhs, modifycode, rhs, complain);
6526 /* Helper function for get_delta_difference which assumes FROM is a base
6527 class of TO. Returns a delta for the conversion of pointer-to-member
6528 of FROM to pointer-to-member of TO. If the conversion is invalid,
6529 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
6530 If C_CAST_P is true, this conversion is taking place as part of a C-style
6534 get_delta_difference_1 (tree from, tree to, bool c_cast_p)
6539 binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
6540 if (kind == bk_inaccessible || kind == bk_ambig)
6542 error (" in pointer to member function conversion");
6543 return size_zero_node;
6547 if (kind != bk_via_virtual)
6548 return BINFO_OFFSET (binfo);
6550 /* FROM is a virtual base class of TO. Issue an error or warning
6551 depending on whether or not this is a reinterpret cast. */
6553 error ("pointer to member conversion via virtual base %qT",
6554 BINFO_TYPE (binfo_from_vbase (binfo)));
6556 return size_zero_node;
6563 /* Get difference in deltas for different pointer to member function
6564 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6565 the conversion is invalid, the constant is zero. If
6566 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6567 If C_CAST_P is true this conversion is taking place as part of a
6570 Note that the naming of FROM and TO is kind of backwards; the return
6571 value is what we add to a TO in order to get a FROM. They are named
6572 this way because we call this function to find out how to convert from
6573 a pointer to member of FROM to a pointer to member of TO. */
6576 get_delta_difference (tree from, tree to,
6577 bool allow_inverse_p,
6582 if (same_type_ignoring_top_level_qualifiers_p (from, to))
6583 /* Pointer to member of incomplete class is permitted*/
6584 result = size_zero_node;
6586 result = get_delta_difference_1 (from, to, c_cast_p);
6590 if (!allow_inverse_p)
6592 error_not_base_type (from, to);
6593 error (" in pointer to member conversion");
6594 result = size_zero_node;
6598 result = get_delta_difference_1 (to, from, c_cast_p);
6601 result = size_diffop_loc (input_location,
6602 size_zero_node, result);
6605 error_not_base_type (from, to);
6606 error (" in pointer to member conversion");
6607 result = size_zero_node;
6612 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
6616 /* Return a constructor for the pointer-to-member-function TYPE using
6617 the other components as specified. */
6620 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
6625 VEC(constructor_elt, gc) *v;
6627 /* Pull the FIELD_DECLs out of the type. */
6628 pfn_field = TYPE_FIELDS (type);
6629 delta_field = TREE_CHAIN (pfn_field);
6631 /* Make sure DELTA has the type we want. */
6632 delta = convert_and_check (delta_type_node, delta);
6634 /* Convert to the correct target type if necessary. */
6635 pfn = fold_convert (TREE_TYPE (pfn_field), pfn);
6637 /* Finish creating the initializer. */
6638 v = VEC_alloc(constructor_elt, gc, 2);
6639 CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
6640 CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
6641 u = build_constructor (type, v);
6642 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
6643 TREE_STATIC (u) = (TREE_CONSTANT (u)
6644 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
6646 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
6651 /* Build a constructor for a pointer to member function. It can be
6652 used to initialize global variables, local variable, or used
6653 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6656 If FORCE is nonzero, then force this conversion, even if
6657 we would rather not do it. Usually set when using an explicit
6658 cast. A C-style cast is being processed iff C_CAST_P is true.
6660 Return error_mark_node, if something goes wrong. */
6663 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
6669 if (error_operand_p (pfn))
6670 return error_mark_node;
6672 pfn_type = TREE_TYPE (pfn);
6673 to_type = build_ptrmemfunc_type (type);
6675 /* Handle multiple conversions of pointer to member functions. */
6676 if (TYPE_PTRMEMFUNC_P (pfn_type))
6678 tree delta = NULL_TREE;
6679 tree npfn = NULL_TREE;
6683 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
6684 error ("invalid conversion to type %qT from type %qT",
6687 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
6688 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
6692 /* We don't have to do any conversion to convert a
6693 pointer-to-member to its own type. But, we don't want to
6694 just return a PTRMEM_CST if there's an explicit cast; that
6695 cast should make the expression an invalid template argument. */
6696 if (TREE_CODE (pfn) != PTRMEM_CST)
6698 if (same_type_p (to_type, pfn_type))
6700 else if (integer_zerop (n))
6701 return build_reinterpret_cast (to_type, pfn,
6702 tf_warning_or_error);
6705 if (TREE_SIDE_EFFECTS (pfn))
6706 pfn = save_expr (pfn);
6708 /* Obtain the function pointer and the current DELTA. */
6709 if (TREE_CODE (pfn) == PTRMEM_CST)
6710 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6713 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6714 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6717 /* Just adjust the DELTA field. */
6718 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6719 (TREE_TYPE (delta), ptrdiff_type_node));
6720 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6721 n = cp_build_binary_op (input_location,
6722 LSHIFT_EXPR, n, integer_one_node,
6723 tf_warning_or_error);
6724 delta = cp_build_binary_op (input_location,
6725 PLUS_EXPR, delta, n, tf_warning_or_error);
6726 return build_ptrmemfunc1 (to_type, delta, npfn);
6729 /* Handle null pointer to member function conversions. */
6730 if (integer_zerop (pfn))
6732 pfn = build_c_cast (input_location, type, integer_zero_node);
6733 return build_ptrmemfunc1 (to_type,
6738 if (type_unknown_p (pfn))
6739 return instantiate_type (type, pfn, tf_warning_or_error);
6741 fn = TREE_OPERAND (pfn, 0);
6742 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6743 /* In a template, we will have preserved the
6745 || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6746 return make_ptrmem_cst (to_type, fn);
6749 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6752 ??? There is no consistency as to the types returned for the above
6753 values. Some code acts as if it were a sizetype and some as if it were
6754 integer_type_node. */
6757 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6759 tree type = TREE_TYPE (cst);
6760 tree fn = PTRMEM_CST_MEMBER (cst);
6761 tree ptr_class, fn_class;
6763 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6765 /* The class that the function belongs to. */
6766 fn_class = DECL_CONTEXT (fn);
6768 /* The class that we're creating a pointer to member of. */
6769 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6771 /* First, calculate the adjustment to the function's class. */
6772 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6775 if (!DECL_VIRTUAL_P (fn))
6776 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6779 /* If we're dealing with a virtual function, we have to adjust 'this'
6780 again, to point to the base which provides the vtable entry for
6781 fn; the call will do the opposite adjustment. */
6782 tree orig_class = DECL_CONTEXT (fn);
6783 tree binfo = binfo_or_else (orig_class, fn_class);
6784 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6785 *delta, BINFO_OFFSET (binfo));
6786 *delta = fold_if_not_in_template (*delta);
6788 /* We set PFN to the vtable offset at which the function can be
6789 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6790 case delta is shifted left, and then incremented). */
6791 *pfn = DECL_VINDEX (fn);
6792 *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6793 TYPE_SIZE_UNIT (vtable_entry_type));
6794 *pfn = fold_if_not_in_template (*pfn);
6796 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6798 case ptrmemfunc_vbit_in_pfn:
6799 *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6801 *pfn = fold_if_not_in_template (*pfn);
6804 case ptrmemfunc_vbit_in_delta:
6805 *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6806 *delta, integer_one_node);
6807 *delta = fold_if_not_in_template (*delta);
6808 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6809 *delta, integer_one_node);
6810 *delta = fold_if_not_in_template (*delta);
6817 *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6818 *pfn = fold_if_not_in_template (*pfn);
6822 /* Return an expression for PFN from the pointer-to-member function
6826 pfn_from_ptrmemfunc (tree t)
6828 if (TREE_CODE (t) == PTRMEM_CST)
6833 expand_ptrmemfunc_cst (t, &delta, &pfn);
6838 return build_ptrmemfunc_access_expr (t, pfn_identifier);
6841 /* Return an expression for DELTA from the pointer-to-member function
6845 delta_from_ptrmemfunc (tree t)
6847 if (TREE_CODE (t) == PTRMEM_CST)
6852 expand_ptrmemfunc_cst (t, &delta, &pfn);
6857 return build_ptrmemfunc_access_expr (t, delta_identifier);
6860 /* Convert value RHS to type TYPE as preparation for an assignment to
6861 an lvalue of type TYPE. ERRTYPE is a string to use in error
6862 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6863 are doing the conversion in order to pass the PARMNUMth argument of
6867 convert_for_assignment (tree type, tree rhs,
6868 const char *errtype, tree fndecl, int parmnum,
6869 tsubst_flags_t complain, int flags)
6872 enum tree_code coder;
6874 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6875 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6876 rhs = TREE_OPERAND (rhs, 0);
6878 rhstype = TREE_TYPE (rhs);
6879 coder = TREE_CODE (rhstype);
6881 if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6882 && vector_types_convertible_p (type, rhstype, true))
6883 return convert (type, rhs);
6885 if (rhs == error_mark_node || rhstype == error_mark_node)
6886 return error_mark_node;
6887 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6888 return error_mark_node;
6890 /* The RHS of an assignment cannot have void type. */
6891 if (coder == VOID_TYPE)
6893 if (complain & tf_error)
6894 error ("void value not ignored as it ought to be");
6895 return error_mark_node;
6898 /* Simplify the RHS if possible. */
6899 if (TREE_CODE (rhs) == CONST_DECL)
6900 rhs = DECL_INITIAL (rhs);
6902 if (c_dialect_objc ())
6905 tree rname = fndecl;
6907 if (!strcmp (errtype, "assignment"))
6909 else if (!strcmp (errtype, "initialization"))
6913 tree selector = objc_message_selector ();
6917 if (selector && parmno > 1)
6924 if (objc_compare_types (type, rhstype, parmno, rname))
6925 return convert (type, rhs);
6930 The expression is implicitly converted (clause _conv_) to the
6931 cv-unqualified type of the left operand.
6933 We allow bad conversions here because by the time we get to this point
6934 we are committed to doing the conversion. If we end up doing a bad
6935 conversion, convert_like will complain. */
6936 if (!can_convert_arg_bad (type, rhstype, rhs, flags))
6938 /* When -Wno-pmf-conversions is use, we just silently allow
6939 conversions from pointers-to-members to plain pointers. If
6940 the conversion doesn't work, cp_convert will complain. */
6942 && TYPE_PTR_P (type)
6943 && TYPE_PTRMEMFUNC_P (rhstype))
6944 rhs = cp_convert (strip_top_quals (type), rhs);
6947 if (complain & tf_error)
6949 /* If the right-hand side has unknown type, then it is an
6950 overloaded function. Call instantiate_type to get error
6952 if (rhstype == unknown_type_node)
6953 instantiate_type (type, rhs, tf_warning_or_error);
6955 error ("cannot convert %qT to %qT for argument %qP to %qD",
6956 rhstype, type, parmnum, fndecl);
6958 error ("cannot convert %qT to %qT in %s", rhstype, type,
6961 return error_mark_node;
6964 if (warn_missing_format_attribute)
6966 const enum tree_code codel = TREE_CODE (type);
6967 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6969 && check_missing_format_attribute (type, rhstype)
6970 && (complain & tf_warning))
6971 warning (OPT_Wmissing_format_attribute,
6972 "%s might be a candidate for a format attribute",
6976 /* If -Wparentheses, warn about a = b = c when a has type bool and b
6978 if (warn_parentheses
6979 && TREE_CODE (type) == BOOLEAN_TYPE
6980 && TREE_CODE (rhs) == MODIFY_EXPR
6981 && !TREE_NO_WARNING (rhs)
6982 && TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE
6983 && (complain & tf_warning))
6985 location_t loc = EXPR_HAS_LOCATION (rhs)
6986 ? EXPR_LOCATION (rhs) : input_location;
6988 warning_at (loc, OPT_Wparentheses,
6989 "suggest parentheses around assignment used as truth value");
6990 TREE_NO_WARNING (rhs) = 1;
6993 return perform_implicit_conversion_flags (strip_top_quals (type), rhs,
6997 /* Convert RHS to be of type TYPE.
6998 If EXP is nonzero, it is the target of the initialization.
6999 ERRTYPE is a string to use in error messages.
7001 Two major differences between the behavior of
7002 `convert_for_assignment' and `convert_for_initialization'
7003 are that references are bashed in the former, while
7004 copied in the latter, and aggregates are assigned in
7005 the former (operator=) while initialized in the
7008 If using constructor make sure no conversion operator exists, if one does
7009 exist, an ambiguity exists.
7011 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
7014 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
7015 const char *errtype, tree fndecl, int parmnum,
7016 tsubst_flags_t complain)
7018 enum tree_code codel = TREE_CODE (type);
7020 enum tree_code coder;
7022 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
7023 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
7024 if (TREE_CODE (rhs) == NOP_EXPR
7025 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
7026 && codel != REFERENCE_TYPE)
7027 rhs = TREE_OPERAND (rhs, 0);
7029 if (type == error_mark_node
7030 || rhs == error_mark_node
7031 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
7032 return error_mark_node;
7034 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
7035 && TREE_CODE (type) != ARRAY_TYPE
7036 && (TREE_CODE (type) != REFERENCE_TYPE
7037 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
7038 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
7039 && (TREE_CODE (type) != REFERENCE_TYPE
7040 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
7041 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
7042 rhs = decay_conversion (rhs);
7044 rhstype = TREE_TYPE (rhs);
7045 coder = TREE_CODE (rhstype);
7047 if (coder == ERROR_MARK)
7048 return error_mark_node;
7050 /* We accept references to incomplete types, so we can
7051 return here before checking if RHS is of complete type. */
7053 if (codel == REFERENCE_TYPE)
7055 /* This should eventually happen in convert_arguments. */
7056 int savew = 0, savee = 0;
7059 savew = warningcount, savee = errorcount;
7060 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
7061 /*cleanup=*/NULL, complain);
7064 if (warningcount > savew)
7065 warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
7066 else if (errorcount > savee)
7067 error ("in passing argument %P of %q+D", parmnum, fndecl);
7073 exp = require_complete_type (exp);
7074 if (exp == error_mark_node)
7075 return error_mark_node;
7077 rhstype = non_reference (rhstype);
7079 type = complete_type (type);
7081 if (DIRECT_INIT_EXPR_P (type, rhs))
7082 /* Don't try to do copy-initialization if we already have
7083 direct-initialization. */
7086 if (MAYBE_CLASS_TYPE_P (type))
7087 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
7089 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum,
7093 /* If RETVAL is the address of, or a reference to, a local variable or
7094 temporary give an appropriate warning. */
7097 maybe_warn_about_returning_address_of_local (tree retval)
7099 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
7100 tree whats_returned = retval;
7104 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
7105 whats_returned = TREE_OPERAND (whats_returned, 1);
7106 else if (CONVERT_EXPR_P (whats_returned)
7107 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR)
7108 whats_returned = TREE_OPERAND (whats_returned, 0);
7113 if (TREE_CODE (whats_returned) != ADDR_EXPR)
7115 whats_returned = TREE_OPERAND (whats_returned, 0);
7117 if (TREE_CODE (valtype) == REFERENCE_TYPE)
7119 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
7120 || TREE_CODE (whats_returned) == TARGET_EXPR)
7122 warning (0, "returning reference to temporary");
7125 if (TREE_CODE (whats_returned) == VAR_DECL
7126 && DECL_NAME (whats_returned)
7127 && TEMP_NAME_P (DECL_NAME (whats_returned)))
7129 warning (0, "reference to non-lvalue returned");
7134 while (TREE_CODE (whats_returned) == COMPONENT_REF
7135 || TREE_CODE (whats_returned) == ARRAY_REF)
7136 whats_returned = TREE_OPERAND (whats_returned, 0);
7138 if (DECL_P (whats_returned)
7139 && DECL_NAME (whats_returned)
7140 && DECL_FUNCTION_SCOPE_P (whats_returned)
7141 && !(TREE_STATIC (whats_returned)
7142 || TREE_PUBLIC (whats_returned)))
7144 if (TREE_CODE (valtype) == REFERENCE_TYPE)
7145 warning (0, "reference to local variable %q+D returned",
7148 warning (0, "address of local variable %q+D returned",
7154 /* Check that returning RETVAL from the current function is valid.
7155 Return an expression explicitly showing all conversions required to
7156 change RETVAL into the function return type, and to assign it to
7157 the DECL_RESULT for the function. Set *NO_WARNING to true if
7158 code reaches end of non-void function warning shouldn't be issued
7159 on this RETURN_EXPR. */
7162 check_return_expr (tree retval, bool *no_warning)
7165 /* The type actually returned by the function, after any
7168 int fn_returns_value_p;
7169 bool named_return_value_okay_p;
7171 *no_warning = false;
7173 /* A `volatile' function is one that isn't supposed to return, ever.
7174 (This is a G++ extension, used to get better code for functions
7175 that call the `volatile' function.) */
7176 if (TREE_THIS_VOLATILE (current_function_decl))
7177 warning (0, "function declared %<noreturn%> has a %<return%> statement");
7179 /* Check for various simple errors. */
7180 if (DECL_DESTRUCTOR_P (current_function_decl))
7183 error ("returning a value from a destructor");
7186 else if (DECL_CONSTRUCTOR_P (current_function_decl))
7188 if (in_function_try_handler)
7189 /* If a return statement appears in a handler of the
7190 function-try-block of a constructor, the program is ill-formed. */
7191 error ("cannot return from a handler of a function-try-block of a constructor");
7193 /* You can't return a value from a constructor. */
7194 error ("returning a value from a constructor");
7198 /* As an extension, deduce lambda return type from a return statement
7199 anywhere in the body. */
7200 if (retval && LAMBDA_FUNCTION_P (current_function_decl))
7202 tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
7203 if (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda))
7205 tree type = lambda_return_type (retval);
7206 tree oldtype = LAMBDA_EXPR_RETURN_TYPE (lambda);
7208 if (VOID_TYPE_P (type))
7210 else if (oldtype == NULL_TREE)
7212 pedwarn (input_location, OPT_pedantic, "lambda return type "
7213 "can only be deduced when the return statement is "
7214 "the only statement in the function body");
7215 apply_lambda_return_type (lambda, type);
7217 else if (!same_type_p (type, oldtype))
7218 error ("inconsistent types %qT and %qT deduced for "
7219 "lambda return type", type, oldtype);
7223 if (processing_template_decl)
7225 current_function_returns_value = 1;
7226 if (check_for_bare_parameter_packs (retval))
7227 retval = error_mark_node;
7231 /* When no explicit return-value is given in a function with a named
7232 return value, the named return value is used. */
7233 result = DECL_RESULT (current_function_decl);
7234 valtype = TREE_TYPE (result);
7235 gcc_assert (valtype != NULL_TREE);
7236 fn_returns_value_p = !VOID_TYPE_P (valtype);
7237 if (!retval && DECL_NAME (result) && fn_returns_value_p)
7240 /* Check for a return statement with no return value in a function
7241 that's supposed to return a value. */
7242 if (!retval && fn_returns_value_p)
7244 permerror (input_location, "return-statement with no value, in function returning %qT",
7246 /* Clear this, so finish_function won't say that we reach the
7247 end of a non-void function (which we don't, we gave a
7249 current_function_returns_null = 0;
7250 /* And signal caller that TREE_NO_WARNING should be set on the
7251 RETURN_EXPR to avoid control reaches end of non-void function
7252 warnings in tree-cfg.c. */
7255 /* Check for a return statement with a value in a function that
7256 isn't supposed to return a value. */
7257 else if (retval && !fn_returns_value_p)
7259 if (VOID_TYPE_P (TREE_TYPE (retval)))
7260 /* You can return a `void' value from a function of `void'
7261 type. In that case, we have to evaluate the expression for
7262 its side-effects. */
7263 finish_expr_stmt (retval);
7265 permerror (input_location, "return-statement with a value, in function "
7266 "returning 'void'");
7267 current_function_returns_null = 1;
7269 /* There's really no value to return, after all. */
7273 /* Remember that this function can sometimes return without a
7275 current_function_returns_null = 1;
7277 /* Remember that this function did return a value. */
7278 current_function_returns_value = 1;
7280 /* Check for erroneous operands -- but after giving ourselves a
7281 chance to provide an error about returning a value from a void
7283 if (error_operand_p (retval))
7285 current_function_return_value = error_mark_node;
7286 return error_mark_node;
7289 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
7290 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
7291 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
7292 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
7294 && retval && null_ptr_cst_p (retval))
7295 warning (0, "%<operator new%> must not return NULL unless it is "
7296 "declared %<throw()%> (or -fcheck-new is in effect)");
7298 /* Effective C++ rule 15. See also start_function. */
7300 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
7304 /* The function return type must be a reference to the current
7306 if (TREE_CODE (valtype) == REFERENCE_TYPE
7307 && same_type_ignoring_top_level_qualifiers_p
7308 (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
7310 /* Returning '*this' is obviously OK. */
7311 if (retval == current_class_ref)
7313 /* If we are calling a function whose return type is the same of
7314 the current class reference, it is ok. */
7315 else if (TREE_CODE (retval) == INDIRECT_REF
7316 && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
7321 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
7324 /* The fabled Named Return Value optimization, as per [class.copy]/15:
7326 [...] For a function with a class return type, if the expression
7327 in the return statement is the name of a local object, and the cv-
7328 unqualified type of the local object is the same as the function
7329 return type, an implementation is permitted to omit creating the tem-
7330 porary object to hold the function return value [...]
7332 So, if this is a value-returning function that always returns the same
7333 local variable, remember it.
7335 It might be nice to be more flexible, and choose the first suitable
7336 variable even if the function sometimes returns something else, but
7337 then we run the risk of clobbering the variable we chose if the other
7338 returned expression uses the chosen variable somehow. And people expect
7339 this restriction, anyway. (jason 2000-11-19)
7341 See finish_function and finalize_nrv for the rest of this optimization. */
7343 named_return_value_okay_p =
7344 (retval != NULL_TREE
7345 /* Must be a local, automatic variable. */
7346 && TREE_CODE (retval) == VAR_DECL
7347 && DECL_CONTEXT (retval) == current_function_decl
7348 && ! TREE_STATIC (retval)
7349 && ! DECL_ANON_UNION_VAR_P (retval)
7350 && (DECL_ALIGN (retval)
7351 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
7352 /* The cv-unqualified type of the returned value must be the
7353 same as the cv-unqualified return type of the
7355 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
7357 (TREE_TYPE (TREE_TYPE (current_function_decl)))))
7358 /* And the returned value must be non-volatile. */
7359 && ! TYPE_VOLATILE (TREE_TYPE (retval)));
7361 if (fn_returns_value_p && flag_elide_constructors)
7363 if (named_return_value_okay_p
7364 && (current_function_return_value == NULL_TREE
7365 || current_function_return_value == retval))
7366 current_function_return_value = retval;
7368 current_function_return_value = error_mark_node;
7371 /* We don't need to do any conversions when there's nothing being
7376 /* Do any required conversions. */
7377 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
7378 /* No conversions are required. */
7382 /* The type the function is declared to return. */
7383 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
7384 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
7386 /* The functype's return type will have been set to void, if it
7387 was an incomplete type. Just treat this as 'return;' */
7388 if (VOID_TYPE_P (functype))
7389 return error_mark_node;
7391 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
7392 treated as an rvalue for the purposes of overload resolution to
7393 favor move constructors over copy constructors. */
7394 if ((cxx_dialect != cxx98)
7395 && named_return_value_okay_p
7396 /* The variable must not have the `volatile' qualifier. */
7397 && !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
7398 /* The return type must be a class type. */
7399 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
7400 flags = flags | LOOKUP_PREFER_RVALUE;
7402 /* First convert the value to the function's return type, then
7403 to the type of return value's location to handle the
7404 case that functype is smaller than the valtype. */
7405 retval = convert_for_initialization
7406 (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0,
7407 tf_warning_or_error);
7408 retval = convert (valtype, retval);
7410 /* If the conversion failed, treat this just like `return;'. */
7411 if (retval == error_mark_node)
7413 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7414 else if (! cfun->returns_struct
7415 && TREE_CODE (retval) == TARGET_EXPR
7416 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
7417 retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
7418 TREE_OPERAND (retval, 0));
7420 maybe_warn_about_returning_address_of_local (retval);
7423 /* Actually copy the value returned into the appropriate location. */
7424 if (retval && retval != result)
7425 retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
7431 /* Returns nonzero if the pointer-type FROM can be converted to the
7432 pointer-type TO via a qualification conversion. If CONSTP is -1,
7433 then we return nonzero if the pointers are similar, and the
7434 cv-qualification signature of FROM is a proper subset of that of TO.
7436 If CONSTP is positive, then all outer pointers have been
7440 comp_ptr_ttypes_real (tree to, tree from, int constp)
7442 bool to_more_cv_qualified = false;
7443 bool is_opaque_pointer = false;
7445 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7447 if (TREE_CODE (to) != TREE_CODE (from))
7450 if (TREE_CODE (from) == OFFSET_TYPE
7451 && !same_type_p (TYPE_OFFSET_BASETYPE (from),
7452 TYPE_OFFSET_BASETYPE (to)))
7455 /* Const and volatile mean something different for function types,
7456 so the usual checks are not appropriate. */
7457 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7459 /* In Objective-C++, some types may have been 'volatilized' by
7460 the compiler for EH; when comparing them here, the volatile
7461 qualification must be ignored. */
7462 bool objc_quals_match = objc_type_quals_match (to, from);
7464 if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
7467 if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
7471 to_more_cv_qualified = true;
7475 constp &= TYPE_READONLY (to);
7478 if (TREE_CODE (to) == VECTOR_TYPE)
7479 is_opaque_pointer = vector_targets_convertible_p (to, from);
7481 if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
7482 return ((constp >= 0 || to_more_cv_qualified)
7483 && (is_opaque_pointer
7484 || same_type_ignoring_top_level_qualifiers_p (to, from)));
7488 /* When comparing, say, char ** to char const **, this function takes
7489 the 'char *' and 'char const *'. Do not pass non-pointer/reference
7490 types to this function. */
7493 comp_ptr_ttypes (tree to, tree from)
7495 return comp_ptr_ttypes_real (to, from, 1);
7498 /* Returns true iff FNTYPE is a non-class type that involves
7499 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
7500 if a parameter type is ill-formed. */
7503 error_type_p (const_tree type)
7507 switch (TREE_CODE (type))
7513 case REFERENCE_TYPE:
7515 return error_type_p (TREE_TYPE (type));
7519 if (error_type_p (TREE_TYPE (type)))
7521 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7522 if (error_type_p (TREE_VALUE (t)))
7527 if (TYPE_PTRMEMFUNC_P (type))
7528 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type));
7536 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7537 type or inheritance-related types, regardless of cv-quals. */
7540 ptr_reasonably_similar (const_tree to, const_tree from)
7542 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7544 /* Any target type is similar enough to void. */
7545 if (TREE_CODE (to) == VOID_TYPE)
7546 return !error_type_p (from);
7547 if (TREE_CODE (from) == VOID_TYPE)
7548 return !error_type_p (to);
7550 if (TREE_CODE (to) != TREE_CODE (from))
7553 if (TREE_CODE (from) == OFFSET_TYPE
7554 && comptypes (TYPE_OFFSET_BASETYPE (to),
7555 TYPE_OFFSET_BASETYPE (from),
7556 COMPARE_BASE | COMPARE_DERIVED))
7559 if (TREE_CODE (to) == VECTOR_TYPE
7560 && vector_types_convertible_p (to, from, false))
7563 if (TREE_CODE (to) == INTEGER_TYPE
7564 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
7567 if (TREE_CODE (to) == FUNCTION_TYPE)
7568 return !error_type_p (to) && !error_type_p (from);
7570 if (TREE_CODE (to) != POINTER_TYPE)
7572 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7573 COMPARE_BASE | COMPARE_DERIVED);
7577 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7578 pointer-to-member types) are the same, ignoring cv-qualification at
7582 comp_ptr_ttypes_const (tree to, tree from)
7584 bool is_opaque_pointer = false;
7586 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7588 if (TREE_CODE (to) != TREE_CODE (from))
7591 if (TREE_CODE (from) == OFFSET_TYPE
7592 && same_type_p (TYPE_OFFSET_BASETYPE (from),
7593 TYPE_OFFSET_BASETYPE (to)))
7596 if (TREE_CODE (to) == VECTOR_TYPE)
7597 is_opaque_pointer = vector_targets_convertible_p (to, from);
7599 if (TREE_CODE (to) != POINTER_TYPE)
7600 return (is_opaque_pointer
7601 || same_type_ignoring_top_level_qualifiers_p (to, from));
7605 /* Returns the type qualifiers for this type, including the qualifiers on the
7606 elements for an array type. */
7609 cp_type_quals (const_tree type)
7611 /* This CONST_CAST is okay because strip_array_types returns its
7612 argument unmodified and we assign it to a const_tree. */
7613 type = strip_array_types (CONST_CAST_TREE(type));
7614 if (type == error_mark_node)
7615 return TYPE_UNQUALIFIED;
7616 return TYPE_QUALS (type);
7619 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7623 cp_type_readonly (const_tree type)
7625 /* This CONST_CAST is okay because strip_array_types returns its
7626 argument unmodified and we assign it to a const_tree. */
7627 type = strip_array_types (CONST_CAST_TREE(type));
7628 return TYPE_READONLY (type);
7631 /* Returns nonzero if TYPE is const or volatile. */
7634 cv_qualified_p (const_tree type)
7636 int quals = cp_type_quals (type);
7637 return (quals & (TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE)) != 0;
7640 /* Returns nonzero if the TYPE contains a mutable member. */
7643 cp_has_mutable_p (const_tree type)
7645 /* This CONST_CAST is okay because strip_array_types returns its
7646 argument unmodified and we assign it to a const_tree. */
7647 type = strip_array_types (CONST_CAST_TREE(type));
7649 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
7652 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7653 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7654 approximation. In particular, consider:
7657 struct S { int i; };
7658 const S s = { f(); }
7660 Here, we will make "s" as TREE_READONLY (because it is declared
7661 "const") -- only to reverse ourselves upon seeing that the
7662 initializer is non-constant. */
7665 cp_apply_type_quals_to_decl (int type_quals, tree decl)
7667 tree type = TREE_TYPE (decl);
7669 if (type == error_mark_node)
7672 if (TREE_CODE (decl) == TYPE_DECL)
7675 if (TREE_CODE (type) == FUNCTION_TYPE
7676 && type_quals != TYPE_UNQUALIFIED)
7678 /* This was an error in C++98 (cv-qualifiers cannot be added to
7679 a function type), but DR 295 makes the code well-formed by
7680 dropping the extra qualifiers. */
7683 tree bad_type = build_qualified_type (type, type_quals);
7684 pedwarn (input_location, OPT_pedantic,
7685 "ignoring %qV qualifiers added to function type %qT",
7689 TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
7693 /* Avoid setting TREE_READONLY incorrectly. */
7694 if (/* If the object has a constructor, the constructor may modify
7696 TYPE_NEEDS_CONSTRUCTING (type)
7697 /* If the type isn't complete, we don't know yet if it will need
7699 || !COMPLETE_TYPE_P (type)
7700 /* If the type has a mutable component, that component might be
7702 || TYPE_HAS_MUTABLE_P (type))
7703 type_quals &= ~TYPE_QUAL_CONST;
7705 c_apply_type_quals_to_decl (type_quals, decl);
7708 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7709 exemplar types such that casting T1 to T2 is casting away constness
7710 if and only if there is no implicit conversion from T1 to T2. */
7713 casts_away_constness_r (tree *t1, tree *t2)
7718 /* [expr.const.cast]
7720 For multi-level pointer to members and multi-level mixed pointers
7721 and pointers to members (conv.qual), the "member" aspect of a
7722 pointer to member level is ignored when determining if a const
7723 cv-qualifier has been cast away. */
7724 /* [expr.const.cast]
7726 For two pointer types:
7728 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7729 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7732 casting from X1 to X2 casts away constness if, for a non-pointer
7733 type T there does not exist an implicit conversion (clause
7736 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7740 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7741 if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
7742 || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
7744 *t1 = cp_build_qualified_type (void_type_node,
7745 cp_type_quals (*t1));
7746 *t2 = cp_build_qualified_type (void_type_node,
7747 cp_type_quals (*t2));
7751 quals1 = cp_type_quals (*t1);
7752 quals2 = cp_type_quals (*t2);
7754 if (TYPE_PTRMEM_P (*t1))
7755 *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
7757 *t1 = TREE_TYPE (*t1);
7758 if (TYPE_PTRMEM_P (*t2))
7759 *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
7761 *t2 = TREE_TYPE (*t2);
7763 casts_away_constness_r (t1, t2);
7764 *t1 = build_pointer_type (*t1);
7765 *t2 = build_pointer_type (*t2);
7766 *t1 = cp_build_qualified_type (*t1, quals1);
7767 *t2 = cp_build_qualified_type (*t2, quals2);
7770 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7773 ??? This function returns non-zero if casting away qualifiers not
7774 just const. We would like to return to the caller exactly which
7775 qualifiers are casted away to give more accurate diagnostics.
7779 casts_away_constness (tree t1, tree t2)
7781 if (TREE_CODE (t2) == REFERENCE_TYPE)
7783 /* [expr.const.cast]
7785 Casting from an lvalue of type T1 to an lvalue of type T2
7786 using a reference cast casts away constness if a cast from an
7787 rvalue of type "pointer to T1" to the type "pointer to T2"
7788 casts away constness. */
7789 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
7790 return casts_away_constness (build_pointer_type (t1),
7791 build_pointer_type (TREE_TYPE (t2)));
7794 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
7795 /* [expr.const.cast]
7797 Casting from an rvalue of type "pointer to data member of X
7798 of type T1" to the type "pointer to data member of Y of type
7799 T2" casts away constness if a cast from an rvalue of type
7800 "pointer to T1" to the type "pointer to T2" casts away
7802 return casts_away_constness
7803 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
7804 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
7806 /* Casting away constness is only something that makes sense for
7807 pointer or reference types. */
7808 if (TREE_CODE (t1) != POINTER_TYPE
7809 || TREE_CODE (t2) != POINTER_TYPE)
7812 /* Top-level qualifiers don't matter. */
7813 t1 = TYPE_MAIN_VARIANT (t1);
7814 t2 = TYPE_MAIN_VARIANT (t2);
7815 casts_away_constness_r (&t1, &t2);
7816 if (!can_convert (t2, t1))
7822 /* If T is a REFERENCE_TYPE return the type to which T refers.
7823 Otherwise, return T itself. */
7826 non_reference (tree t)
7828 if (TREE_CODE (t) == REFERENCE_TYPE)
7834 /* Return nonzero if REF is an lvalue valid for this language;
7835 otherwise, print an error message and return zero. USE says
7836 how the lvalue is being used and so selects the error message. */
7839 lvalue_or_else (tree ref, enum lvalue_use use, tsubst_flags_t complain)
7841 int win = lvalue_p (ref);
7843 if (!win && (complain & tf_error))