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
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 (int, tree *, tree, tree, 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, 0);
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 /* T1 and T2 are arithmetic or enumeration types. Return the type
252 that will result from the "usual arithmetic conversions" on T1 and
253 T2 as described in [expr]. */
256 type_after_usual_arithmetic_conversions (tree t1, tree t2)
258 enum tree_code code1 = TREE_CODE (t1);
259 enum tree_code code2 = TREE_CODE (t2);
262 /* FIXME: Attributes. */
263 gcc_assert (ARITHMETIC_TYPE_P (t1)
264 || TREE_CODE (t1) == VECTOR_TYPE
265 || TREE_CODE (t1) == ENUMERAL_TYPE);
266 gcc_assert (ARITHMETIC_TYPE_P (t2)
267 || TREE_CODE (t2) == VECTOR_TYPE
268 || TREE_CODE (t2) == ENUMERAL_TYPE);
270 /* In what follows, we slightly generalize the rules given in [expr] so
271 as to deal with `long long' and `complex'. First, merge the
273 attributes = (*targetm.merge_type_attributes) (t1, t2);
275 /* If one type is complex, form the common type of the non-complex
276 components, then make that complex. Use T1 or T2 if it is the
278 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
280 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
281 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
283 = type_after_usual_arithmetic_conversions (subtype1, subtype2);
285 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
286 return build_type_attribute_variant (t1, attributes);
287 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
288 return build_type_attribute_variant (t2, attributes);
290 return build_type_attribute_variant (build_complex_type (subtype),
294 if (code1 == VECTOR_TYPE)
296 /* When we get here we should have two vectors of the same size.
297 Just prefer the unsigned one if present. */
298 if (TYPE_UNSIGNED (t1))
299 return build_type_attribute_variant (t1, attributes);
301 return build_type_attribute_variant (t2, attributes);
304 /* If only one is real, use it as the result. */
305 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
306 return build_type_attribute_variant (t1, attributes);
307 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
308 return build_type_attribute_variant (t2, attributes);
310 /* Perform the integral promotions. */
311 if (code1 != REAL_TYPE)
313 t1 = type_promotes_to (t1);
314 t2 = type_promotes_to (t2);
317 /* Both real or both integers; use the one with greater precision. */
318 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
319 return build_type_attribute_variant (t1, attributes);
320 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
321 return build_type_attribute_variant (t2, attributes);
323 /* The types are the same; no need to do anything fancy. */
324 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
325 return build_type_attribute_variant (t1, attributes);
327 if (code1 != REAL_TYPE)
329 /* If one is unsigned long long, then convert the other to unsigned
331 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
332 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
333 return build_type_attribute_variant (long_long_unsigned_type_node,
335 /* If one is a long long, and the other is an unsigned long, and
336 long long can represent all the values of an unsigned long, then
337 convert to a long long. Otherwise, convert to an unsigned long
338 long. Otherwise, if either operand is long long, convert the
341 Since we're here, we know the TYPE_PRECISION is the same;
342 therefore converting to long long cannot represent all the values
343 of an unsigned long, so we choose unsigned long long in that
345 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
346 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
348 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
349 ? long_long_unsigned_type_node
350 : long_long_integer_type_node);
351 return build_type_attribute_variant (t, attributes);
354 /* Go through the same procedure, but for longs. */
355 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
356 || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
357 return build_type_attribute_variant (long_unsigned_type_node,
359 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
360 || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
362 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
363 ? long_unsigned_type_node : long_integer_type_node);
364 return build_type_attribute_variant (t, attributes);
366 /* Otherwise prefer the unsigned one. */
367 if (TYPE_UNSIGNED (t1))
368 return build_type_attribute_variant (t1, attributes);
370 return build_type_attribute_variant (t2, attributes);
374 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
375 || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
376 return build_type_attribute_variant (long_double_type_node,
378 if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
379 || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
380 return build_type_attribute_variant (double_type_node,
382 if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
383 || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
384 return build_type_attribute_variant (float_type_node,
387 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
388 the standard C++ floating-point types. Logic earlier in this
389 function has already eliminated the possibility that
390 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
391 compelling reason to choose one or the other. */
392 return build_type_attribute_variant (t1, attributes);
396 /* Subroutine of composite_pointer_type to implement the recursive
397 case. See that function for documentation fo the parameters. */
400 composite_pointer_type_r (tree t1, tree t2, const char* location,
401 tsubst_flags_t complain)
408 /* Determine the types pointed to by T1 and T2. */
409 if (TREE_CODE (t1) == POINTER_TYPE)
411 pointee1 = TREE_TYPE (t1);
412 pointee2 = TREE_TYPE (t2);
416 pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
417 pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
422 Otherwise, the composite pointer type is a pointer type
423 similar (_conv.qual_) to the type of one of the operands,
424 with a cv-qualification signature (_conv.qual_) that is the
425 union of the cv-qualification signatures of the operand
427 if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
428 result_type = pointee1;
429 else if ((TREE_CODE (pointee1) == POINTER_TYPE
430 && TREE_CODE (pointee2) == POINTER_TYPE)
431 || (TYPE_PTR_TO_MEMBER_P (pointee1)
432 && TYPE_PTR_TO_MEMBER_P (pointee2)))
433 result_type = composite_pointer_type_r (pointee1, pointee2, location,
437 if (complain & tf_error)
438 pedwarn ("%s between distinct pointer types %qT and %qT "
441 result_type = void_type_node;
443 result_type = cp_build_qualified_type (result_type,
444 (cp_type_quals (pointee1)
445 | cp_type_quals (pointee2)));
446 /* If the original types were pointers to members, so is the
448 if (TYPE_PTR_TO_MEMBER_P (t1))
450 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
451 TYPE_PTRMEM_CLASS_TYPE (t2))
452 && (complain & tf_error))
453 pedwarn ("%s between distinct pointer types %qT and %qT "
456 result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
460 result_type = build_pointer_type (result_type);
462 /* Merge the attributes. */
463 attributes = (*targetm.merge_type_attributes) (t1, t2);
464 return build_type_attribute_variant (result_type, attributes);
467 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
468 ARG1 and ARG2 are the values with those types. The LOCATION is a
469 string describing the current location, in case an error occurs.
471 This routine also implements the computation of a common type for
472 pointers-to-members as per [expr.eq]. */
475 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
476 const char* location, tsubst_flags_t complain)
483 If one operand is a null pointer constant, the composite pointer
484 type is the type of the other operand. */
485 if (null_ptr_cst_p (arg1))
487 if (null_ptr_cst_p (arg2))
494 If one of the operands has type "pointer to cv1 void*", then
495 the other has type "pointer to cv2T", and the composite pointer
496 type is "pointer to cv12 void", where cv12 is the union of cv1
499 If either type is a pointer to void, make sure it is T1. */
500 if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
508 /* Now, if T1 is a pointer to void, merge the qualifiers. */
509 if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
514 if (pedantic && TYPE_PTRFN_P (t2) && (complain & tf_error))
515 pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
516 "and pointer-to-function", location);
518 = cp_build_qualified_type (void_type_node,
519 (cp_type_quals (TREE_TYPE (t1))
520 | cp_type_quals (TREE_TYPE (t2))));
521 result_type = build_pointer_type (result_type);
522 /* Merge the attributes. */
523 attributes = (*targetm.merge_type_attributes) (t1, t2);
524 return build_type_attribute_variant (result_type, attributes);
527 if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE
528 && TREE_CODE (t2) == POINTER_TYPE)
530 if (objc_compare_types (t1, t2, -3, NULL_TREE))
534 /* [expr.eq] permits the application of a pointer conversion to
535 bring the pointers to a common type. */
536 if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
537 && CLASS_TYPE_P (TREE_TYPE (t1))
538 && CLASS_TYPE_P (TREE_TYPE (t2))
539 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
542 class1 = TREE_TYPE (t1);
543 class2 = TREE_TYPE (t2);
545 if (DERIVED_FROM_P (class1, class2))
546 t2 = (build_pointer_type
547 (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
548 else if (DERIVED_FROM_P (class2, class1))
549 t1 = (build_pointer_type
550 (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
553 if (complain & tf_error)
554 error ("%s between distinct pointer types %qT and %qT "
555 "lacks a cast", location, t1, t2);
556 return error_mark_node;
559 /* [expr.eq] permits the application of a pointer-to-member
560 conversion to change the class type of one of the types. */
561 else if (TYPE_PTR_TO_MEMBER_P (t1)
562 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
563 TYPE_PTRMEM_CLASS_TYPE (t2)))
565 class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
566 class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
568 if (DERIVED_FROM_P (class1, class2))
569 t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
570 else if (DERIVED_FROM_P (class2, class1))
571 t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
574 if (complain & tf_error)
575 error ("%s between distinct pointer-to-member types %qT and %qT "
576 "lacks a cast", location, t1, t2);
577 return error_mark_node;
581 return composite_pointer_type_r (t1, t2, location, complain);
584 /* Return the merged type of two types.
585 We assume that comptypes has already been done and returned 1;
586 if that isn't so, this may crash.
588 This just combines attributes and default arguments; any other
589 differences would cause the two types to compare unalike. */
592 merge_types (tree t1, tree t2)
594 enum tree_code code1;
595 enum tree_code code2;
598 /* Save time if the two types are the same. */
601 if (original_type (t1) == original_type (t2))
604 /* If one type is nonsense, use the other. */
605 if (t1 == error_mark_node)
607 if (t2 == error_mark_node)
610 /* Merge the attributes. */
611 attributes = (*targetm.merge_type_attributes) (t1, t2);
613 if (TYPE_PTRMEMFUNC_P (t1))
614 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
615 if (TYPE_PTRMEMFUNC_P (t2))
616 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
618 code1 = TREE_CODE (t1);
619 code2 = TREE_CODE (t2);
625 /* For two pointers, do this recursively on the target type. */
627 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
628 int quals = cp_type_quals (t1);
630 if (code1 == POINTER_TYPE)
631 t1 = build_pointer_type (target);
633 t1 = cp_build_reference_type (target, TYPE_REF_IS_RVALUE (t1));
634 t1 = build_type_attribute_variant (t1, attributes);
635 t1 = cp_build_qualified_type (t1, quals);
637 if (TREE_CODE (target) == METHOD_TYPE)
638 t1 = build_ptrmemfunc_type (t1);
647 quals = cp_type_quals (t1);
648 pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
649 TYPE_PTRMEM_POINTED_TO_TYPE (t2));
650 t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
652 t1 = cp_build_qualified_type (t1, quals);
658 tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
659 /* Save space: see if the result is identical to one of the args. */
660 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
661 return build_type_attribute_variant (t1, attributes);
662 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
663 return build_type_attribute_variant (t2, attributes);
664 /* Merge the element types, and have a size if either arg has one. */
665 t1 = build_cplus_array_type
666 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
671 /* Function types: prefer the one that specified arg types.
672 If both do, merge the arg types. Also merge the return types. */
674 tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
675 tree p1 = TYPE_ARG_TYPES (t1);
676 tree p2 = TYPE_ARG_TYPES (t2);
679 /* Save space: see if the result is identical to one of the args. */
680 if (valtype == TREE_TYPE (t1) && ! p2)
681 return cp_build_type_attribute_variant (t1, attributes);
682 if (valtype == TREE_TYPE (t2) && ! p1)
683 return cp_build_type_attribute_variant (t2, attributes);
685 /* Simple way if one arg fails to specify argument types. */
686 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
688 rval = build_function_type (valtype, p2);
689 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
690 rval = build_exception_variant (rval, raises);
691 return cp_build_type_attribute_variant (rval, attributes);
693 raises = TYPE_RAISES_EXCEPTIONS (t1);
694 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
696 rval = build_function_type (valtype, p1);
698 rval = build_exception_variant (rval, raises);
699 return cp_build_type_attribute_variant (rval, attributes);
702 rval = build_function_type (valtype, commonparms (p1, p2));
703 t1 = build_exception_variant (rval, raises);
709 /* Get this value the long way, since TYPE_METHOD_BASETYPE
710 is just the main variant of this. */
711 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
712 tree raises = TYPE_RAISES_EXCEPTIONS (t1);
715 /* If this was a member function type, get back to the
716 original type of type member function (i.e., without
717 the class instance variable up front. */
718 t1 = build_function_type (TREE_TYPE (t1),
719 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
720 t2 = build_function_type (TREE_TYPE (t2),
721 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
722 t3 = merge_types (t1, t2);
723 t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
724 TYPE_ARG_TYPES (t3));
725 t1 = build_exception_variant (t3, raises);
730 /* There is no need to merge attributes into a TYPENAME_TYPE.
731 When the type is instantiated it will have whatever
732 attributes result from the instantiation. */
738 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
740 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
743 return cp_build_type_attribute_variant (t1, attributes);
746 /* Return the common type of two types.
747 We assume that comptypes has already been done and returned 1;
748 if that isn't so, this may crash.
750 This is the type for the result of most arithmetic operations
751 if the operands have the given two types. */
754 common_type (tree t1, tree t2)
756 enum tree_code code1;
757 enum tree_code code2;
759 /* If one type is nonsense, bail. */
760 if (t1 == error_mark_node || t2 == error_mark_node)
761 return error_mark_node;
763 code1 = TREE_CODE (t1);
764 code2 = TREE_CODE (t2);
766 if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
767 || code1 == VECTOR_TYPE)
768 && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
769 || code2 == VECTOR_TYPE))
770 return type_after_usual_arithmetic_conversions (t1, t2);
772 else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
773 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
774 || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
775 return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
776 "conversion", tf_warning_or_error);
781 /* Compare two exception specifier types for exactness or subsetness, if
782 allowed. Returns false for mismatch, true for match (same, or
785 [except.spec] "If a class X ... objects of class X or any class publicly
786 and unambiguously derived from X. Similarly, if a pointer type Y * ...
787 exceptions of type Y * or that are pointers to any type publicly and
788 unambiguously derived from Y. Otherwise a function only allows exceptions
789 that have the same type ..."
790 This does not mention cv qualifiers and is different to what throw
791 [except.throw] and catch [except.catch] will do. They will ignore the
792 top level cv qualifiers, and allow qualifiers in the pointer to class
795 We implement the letter of the standard. */
798 comp_except_types (tree a, tree b, bool exact)
800 if (same_type_p (a, b))
804 if (cp_type_quals (a) || cp_type_quals (b))
807 if (TREE_CODE (a) == POINTER_TYPE
808 && TREE_CODE (b) == POINTER_TYPE)
812 if (cp_type_quals (a) || cp_type_quals (b))
816 if (TREE_CODE (a) != RECORD_TYPE
817 || TREE_CODE (b) != RECORD_TYPE)
820 if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
826 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
827 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
828 otherwise it must be exact. Exception lists are unordered, but
829 we've already filtered out duplicates. Most lists will be in order,
830 we should try to make use of that. */
833 comp_except_specs (const_tree t1, const_tree t2, bool exact)
842 if (t1 == NULL_TREE) /* T1 is ... */
843 return t2 == NULL_TREE || !exact;
844 if (!TREE_VALUE (t1)) /* t1 is EMPTY */
845 return t2 != NULL_TREE && !TREE_VALUE (t2);
846 if (t2 == NULL_TREE) /* T2 is ... */
848 if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
851 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
852 Count how many we find, to determine exactness. For exact matching and
853 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
855 for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
857 for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
859 tree a = TREE_VALUE (probe);
860 tree b = TREE_VALUE (t2);
862 if (comp_except_types (a, b, exact))
864 if (probe == base && exact)
865 base = TREE_CHAIN (probe);
870 if (probe == NULL_TREE)
873 return !exact || base == NULL_TREE || length == list_length (t1);
876 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
877 [] can match [size]. */
880 comp_array_types (const_tree t1, const_tree t2, bool allow_redeclaration)
889 /* The type of the array elements must be the same. */
890 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
893 d1 = TYPE_DOMAIN (t1);
894 d2 = TYPE_DOMAIN (t2);
899 /* If one of the arrays is dimensionless, and the other has a
900 dimension, they are of different types. However, it is valid to
908 declarations for an array object can specify
909 array types that differ by the presence or absence of a major
910 array bound (_dcl.array_). */
912 return allow_redeclaration;
914 /* Check that the dimensions are the same. */
916 if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
918 max1 = TYPE_MAX_VALUE (d1);
919 max2 = TYPE_MAX_VALUE (d2);
920 if (processing_template_decl && !abi_version_at_least (2)
921 && !value_dependent_expression_p (max1)
922 && !value_dependent_expression_p (max2))
924 /* With abi-1 we do not fold non-dependent array bounds, (and
925 consequently mangle them incorrectly). We must therefore
926 fold them here, to verify the domains have the same
932 if (!cp_tree_equal (max1, max2))
938 /* Subroutine in comptypes. */
941 structural_comptypes (tree t1, tree t2, int strict)
946 /* Suppress errors caused by previously reported errors. */
947 if (t1 == error_mark_node || t2 == error_mark_node)
950 gcc_assert (TYPE_P (t1) && TYPE_P (t2));
952 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
953 current instantiation. */
954 if (TREE_CODE (t1) == TYPENAME_TYPE)
955 t1 = resolve_typename_type (t1, /*only_current_p=*/true);
957 if (TREE_CODE (t2) == TYPENAME_TYPE)
958 t2 = resolve_typename_type (t2, /*only_current_p=*/true);
960 if (TYPE_PTRMEMFUNC_P (t1))
961 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
962 if (TYPE_PTRMEMFUNC_P (t2))
963 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
965 /* Different classes of types can't be compatible. */
966 if (TREE_CODE (t1) != TREE_CODE (t2))
969 /* Qualifiers must match. For array types, we will check when we
970 recur on the array element types. */
971 if (TREE_CODE (t1) != ARRAY_TYPE
972 && TYPE_QUALS (t1) != TYPE_QUALS (t2))
974 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
977 /* Allow for two different type nodes which have essentially the same
978 definition. Note that we already checked for equality of the type
979 qualifiers (just above). */
981 if (TREE_CODE (t1) != ARRAY_TYPE
982 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
985 /* Compare the types. Break out if they could be the same. */
986 switch (TREE_CODE (t1))
990 /* All void and bool types are the same. */
994 case FIXED_POINT_TYPE:
996 /* With these nodes, we can't determine type equivalence by
997 looking at what is stored in the nodes themselves, because
998 two nodes might have different TYPE_MAIN_VARIANTs but still
999 represent the same type. For example, wchar_t and int could
1000 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1001 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1002 and are distinct types. On the other hand, int and the
1005 typedef int INT __attribute((may_alias));
1007 have identical properties, different TYPE_MAIN_VARIANTs, but
1008 represent the same type. The canonical type system keeps
1009 track of equivalence in this case, so we fall back on it. */
1010 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1012 case TEMPLATE_TEMPLATE_PARM:
1013 case BOUND_TEMPLATE_TEMPLATE_PARM:
1014 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1015 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1016 || (TEMPLATE_TYPE_PARAMETER_PACK (t1)
1017 != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1019 if (!comp_template_parms
1020 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1021 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1023 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1025 /* Don't check inheritance. */
1026 strict = COMPARE_STRICT;
1031 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1032 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1033 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1034 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1037 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1039 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1045 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1046 strict & ~COMPARE_REDECLARATION))
1048 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1052 case REFERENCE_TYPE:
1053 if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
1055 /* fall through to checks for pointer types */
1058 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1059 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1060 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1066 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1068 if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1073 /* Target types must match incl. qualifiers. */
1074 if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1078 case TEMPLATE_TYPE_PARM:
1079 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1080 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1081 || (TEMPLATE_TYPE_PARAMETER_PACK (t1)
1082 != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1087 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1088 TYPENAME_TYPE_FULLNAME (t2)))
1090 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1094 case UNBOUND_CLASS_TEMPLATE:
1095 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1097 if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1102 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1107 if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1108 || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1112 case TYPE_PACK_EXPANSION:
1113 return same_type_p (PACK_EXPANSION_PATTERN (t1),
1114 PACK_EXPANSION_PATTERN (t2));
1117 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1)
1118 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2)
1119 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1),
1120 DECLTYPE_TYPE_EXPR (t2)))
1128 /* If we get here, we know that from a target independent POV the
1129 types are the same. Make sure the target attributes are also
1131 return targetm.comp_type_attributes (t1, t2);
1134 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1135 is a bitwise-or of the COMPARE_* flags. */
1138 comptypes (tree t1, tree t2, int strict)
1140 if (strict == COMPARE_STRICT)
1145 if (t1 == error_mark_node || t2 == error_mark_node)
1148 if (TYPE_STRUCTURAL_EQUALITY_P (t1) || TYPE_STRUCTURAL_EQUALITY_P (t2))
1149 /* At least one of the types requires structural equality, so
1150 perform a deep check. */
1151 return structural_comptypes (t1, t2, strict);
1153 #ifdef ENABLE_CHECKING
1154 if (USE_CANONICAL_TYPES)
1156 bool result = structural_comptypes (t1, t2, strict);
1158 if (result && TYPE_CANONICAL (t1) != TYPE_CANONICAL (t2))
1159 /* The two types are structurally equivalent, but their
1160 canonical types were different. This is a failure of the
1161 canonical type propagation code.*/
1163 ("canonical types differ for identical types %T and %T",
1165 else if (!result && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
1166 /* Two types are structurally different, but the canonical
1167 types are the same. This means we were over-eager in
1168 assigning canonical types. */
1170 ("same canonical type node for different types %T and %T",
1176 if (USE_CANONICAL_TYPES)
1177 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1180 return structural_comptypes (t1, t2, strict);
1182 else if (strict == COMPARE_STRUCTURAL)
1183 return structural_comptypes (t1, t2, COMPARE_STRICT);
1185 return structural_comptypes (t1, t2, strict);
1188 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1191 at_least_as_qualified_p (const_tree type1, const_tree type2)
1193 int q1 = cp_type_quals (type1);
1194 int q2 = cp_type_quals (type2);
1196 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1197 return (q1 & q2) == q2;
1200 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1201 more cv-qualified that TYPE1, and 0 otherwise. */
1204 comp_cv_qualification (const_tree type1, const_tree type2)
1206 int q1 = cp_type_quals (type1);
1207 int q2 = cp_type_quals (type2);
1212 if ((q1 & q2) == q2)
1214 else if ((q1 & q2) == q1)
1220 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1221 subset of the cv-qualification signature of TYPE2, and the types
1222 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1225 comp_cv_qual_signature (tree type1, tree type2)
1227 if (comp_ptr_ttypes_real (type2, type1, -1))
1229 else if (comp_ptr_ttypes_real (type1, type2, -1))
1235 /* Subroutines of `comptypes'. */
1237 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1238 equivalent in the sense that functions with those parameter types
1239 can have equivalent types. The two lists must be equivalent,
1240 element by element. */
1243 compparms (const_tree parms1, const_tree parms2)
1247 /* An unspecified parmlist matches any specified parmlist
1248 whose argument types don't need default promotions. */
1250 for (t1 = parms1, t2 = parms2;
1252 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1254 /* If one parmlist is shorter than the other,
1255 they fail to match. */
1258 if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1265 /* Process a sizeof or alignof expression where the operand is a
1269 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1274 gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1275 if (type == error_mark_node)
1276 return error_mark_node;
1278 type = non_reference (type);
1279 if (TREE_CODE (type) == METHOD_TYPE)
1281 if (complain && (pedantic || warn_pointer_arith))
1282 pedwarn ("invalid application of %qs to a member function",
1283 operator_name_info[(int) op].name);
1284 value = size_one_node;
1287 dependent_p = dependent_type_p (type);
1289 complete_type (type);
1291 /* VLA types will have a non-constant size. In the body of an
1292 uninstantiated template, we don't need to try to compute the
1293 value, because the sizeof expression is not an integral
1294 constant expression in that case. And, if we do try to
1295 compute the value, we'll likely end up with SAVE_EXPRs, which
1296 the template substitution machinery does not expect to see. */
1297 || (processing_template_decl
1298 && COMPLETE_TYPE_P (type)
1299 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
1301 value = build_min (op, size_type_node, type);
1302 TREE_READONLY (value) = 1;
1306 return c_sizeof_or_alignof_type (complete_type (type),
1311 /* Return the size of the type, without producing any warnings for
1312 types whose size cannot be taken. This routine should be used only
1313 in some other routine that has already produced a diagnostic about
1314 using the size of such a type. */
1316 cxx_sizeof_nowarn (tree type)
1318 if (TREE_CODE (type) == FUNCTION_TYPE
1319 || TREE_CODE (type) == VOID_TYPE
1320 || TREE_CODE (type) == ERROR_MARK)
1321 return size_one_node;
1322 else if (!COMPLETE_TYPE_P (type))
1323 return size_zero_node;
1325 return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false);
1328 /* Process a sizeof expression where the operand is an expression. */
1331 cxx_sizeof_expr (tree e, tsubst_flags_t complain)
1333 if (e == error_mark_node)
1334 return error_mark_node;
1336 if (processing_template_decl)
1338 e = build_min (SIZEOF_EXPR, size_type_node, e);
1339 TREE_SIDE_EFFECTS (e) = 0;
1340 TREE_READONLY (e) = 1;
1345 if (TREE_CODE (e) == COMPONENT_REF
1346 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1347 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1349 if (complain & tf_error)
1350 error ("invalid application of %<sizeof%> to a bit-field");
1352 return error_mark_node;
1355 else if (is_overloaded_fn (e))
1357 if (complain & tf_error)
1358 pedwarn ("ISO C++ forbids applying %<sizeof%> to an expression of "
1361 return error_mark_node;
1364 else if (type_unknown_p (e))
1366 if (complain & tf_error)
1367 cxx_incomplete_type_error (e, TREE_TYPE (e));
1369 return error_mark_node;
1375 return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error);
1378 /* Implement the __alignof keyword: Return the minimum required
1379 alignment of E, measured in bytes. For VAR_DECL's and
1380 FIELD_DECL's return DECL_ALIGN (which can be set from an
1381 "aligned" __attribute__ specification). */
1384 cxx_alignof_expr (tree e, tsubst_flags_t complain)
1388 if (e == error_mark_node)
1389 return error_mark_node;
1391 if (processing_template_decl)
1393 e = build_min (ALIGNOF_EXPR, size_type_node, e);
1394 TREE_SIDE_EFFECTS (e) = 0;
1395 TREE_READONLY (e) = 1;
1400 if (TREE_CODE (e) == VAR_DECL)
1401 t = size_int (DECL_ALIGN_UNIT (e));
1402 else if (TREE_CODE (e) == COMPONENT_REF
1403 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1404 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1406 if (complain & tf_error)
1407 error ("invalid application of %<__alignof%> to a bit-field");
1409 return error_mark_node;
1412 else if (TREE_CODE (e) == COMPONENT_REF
1413 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL)
1414 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1)));
1415 else if (is_overloaded_fn (e))
1417 if (complain & tf_error)
1418 pedwarn ("ISO C++ forbids applying %<__alignof%> to an expression of "
1421 return error_mark_node;
1422 if (TREE_CODE (e) == FUNCTION_DECL)
1423 t = size_int (DECL_ALIGN_UNIT (e));
1427 else if (type_unknown_p (e))
1429 if (complain & tf_error)
1430 cxx_incomplete_type_error (e, TREE_TYPE (e));
1432 return error_mark_node;
1436 return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR,
1437 complain & tf_error);
1439 return fold_convert (size_type_node, t);
1442 /* Process a sizeof or alignof expression E with code OP where the operand
1443 is an expression. */
1446 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain)
1448 if (op == SIZEOF_EXPR)
1449 return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none);
1451 return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none);
1454 /* EXPR is being used in a context that is not a function call.
1459 The expression can be used only as the left-hand operand of a
1460 member function call.
1462 [expr.mptr.operator]
1464 If the result of .* or ->* is a function, then that result can be
1465 used only as the operand for the function call operator ().
1467 by issuing an error message if appropriate. Returns true iff EXPR
1468 violates these rules. */
1471 invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
1473 if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
1475 if (complain & tf_error)
1476 error ("invalid use of non-static member function");
1482 /* If EXP is a reference to a bitfield, and the type of EXP does not
1483 match the declared type of the bitfield, return the declared type
1484 of the bitfield. Otherwise, return NULL_TREE. */
1487 is_bitfield_expr_with_lowered_type (const_tree exp)
1489 switch (TREE_CODE (exp))
1492 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)
1493 ? TREE_OPERAND (exp, 1)
1494 : TREE_OPERAND (exp, 0)))
1496 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2));
1499 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1));
1503 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1509 field = TREE_OPERAND (exp, 1);
1510 if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
1512 if (same_type_ignoring_top_level_qualifiers_p
1513 (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
1515 return DECL_BIT_FIELD_TYPE (field);
1520 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
1521 == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
1522 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1530 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1531 bitfield with a lowered type, the type of EXP is returned, rather
1535 unlowered_expr_type (const_tree exp)
1539 type = is_bitfield_expr_with_lowered_type (exp);
1541 type = TREE_TYPE (exp);
1546 /* Perform the conversions in [expr] that apply when an lvalue appears
1547 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1548 function-to-pointer conversions. In addition, manifest constants
1549 are replaced by their values, and bitfield references are converted
1550 to their declared types.
1552 Although the returned value is being used as an rvalue, this
1553 function does not wrap the returned expression in a
1554 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1555 that the return value is no longer an lvalue. */
1558 decay_conversion (tree exp)
1561 enum tree_code code;
1563 type = TREE_TYPE (exp);
1564 if (type == error_mark_node)
1565 return error_mark_node;
1567 if (type_unknown_p (exp))
1569 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1570 return error_mark_node;
1573 exp = decl_constant_value (exp);
1574 if (error_operand_p (exp))
1575 return error_mark_node;
1577 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1578 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1579 code = TREE_CODE (type);
1580 if (code == VOID_TYPE)
1582 error ("void value not ignored as it ought to be");
1583 return error_mark_node;
1585 if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error))
1586 return error_mark_node;
1587 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1588 return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error);
1589 if (code == ARRAY_TYPE)
1594 if (TREE_CODE (exp) == INDIRECT_REF)
1595 return build_nop (build_pointer_type (TREE_TYPE (type)),
1596 TREE_OPERAND (exp, 0));
1598 if (TREE_CODE (exp) == COMPOUND_EXPR)
1600 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1601 return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1602 TREE_OPERAND (exp, 0), op1);
1606 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1608 error ("invalid use of non-lvalue array");
1609 return error_mark_node;
1612 ptrtype = build_pointer_type (TREE_TYPE (type));
1614 if (TREE_CODE (exp) == VAR_DECL)
1616 if (!cxx_mark_addressable (exp))
1617 return error_mark_node;
1618 adr = build_nop (ptrtype, build_address (exp));
1621 /* This way is better for a COMPONENT_REF since it can
1622 simplify the offset for a component. */
1623 adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
1624 return cp_convert (ptrtype, adr);
1627 /* If a bitfield is used in a context where integral promotion
1628 applies, then the caller is expected to have used
1629 default_conversion. That function promotes bitfields correctly
1630 before calling this function. At this point, if we have a
1631 bitfield referenced, we may assume that is not subject to
1632 promotion, and that, therefore, the type of the resulting rvalue
1633 is the declared type of the bitfield. */
1634 exp = convert_bitfield_to_declared_type (exp);
1636 /* We do not call rvalue() here because we do not want to wrap EXP
1637 in a NON_LVALUE_EXPR. */
1641 Non-class rvalues always have cv-unqualified types. */
1642 type = TREE_TYPE (exp);
1643 if (!CLASS_TYPE_P (type) && cp_type_quals (type))
1644 exp = build_nop (TYPE_MAIN_VARIANT (type), exp);
1649 /* Perform prepatory conversions, as part of the "usual arithmetic
1650 conversions". In particular, as per [expr]:
1652 Whenever an lvalue expression appears as an operand of an
1653 operator that expects the rvalue for that operand, the
1654 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1655 standard conversions are applied to convert the expression to an
1658 In addition, we perform integral promotions here, as those are
1659 applied to both operands to a binary operator before determining
1660 what additional conversions should apply. */
1663 default_conversion (tree exp)
1665 /* Perform the integral promotions first so that bitfield
1666 expressions (which may promote to "int", even if the bitfield is
1667 declared "unsigned") are promoted correctly. */
1668 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1669 exp = perform_integral_promotions (exp);
1670 /* Perform the other conversions. */
1671 exp = decay_conversion (exp);
1676 /* EXPR is an expression with an integral or enumeration type.
1677 Perform the integral promotions in [conv.prom], and return the
1681 perform_integral_promotions (tree expr)
1688 If the bitfield has an enumerated type, it is treated as any
1689 other value of that type for promotion purposes. */
1690 type = is_bitfield_expr_with_lowered_type (expr);
1691 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
1692 type = TREE_TYPE (expr);
1693 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1694 promoted_type = type_promotes_to (type);
1695 if (type != promoted_type)
1696 expr = cp_convert (promoted_type, expr);
1700 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1704 inline_conversion (tree exp)
1706 if (TREE_CODE (exp) == FUNCTION_DECL)
1707 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1712 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1713 decay_conversion to one. */
1716 string_conv_p (const_tree totype, const_tree exp, int warn)
1720 if (TREE_CODE (totype) != POINTER_TYPE)
1723 t = TREE_TYPE (totype);
1724 if (!same_type_p (t, char_type_node)
1725 && !same_type_p (t, char16_type_node)
1726 && !same_type_p (t, char32_type_node)
1727 && !same_type_p (t, wchar_type_node))
1730 if (TREE_CODE (exp) == STRING_CST)
1732 /* Make sure that we don't try to convert between char and wide chars. */
1733 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1738 /* Is this a string constant which has decayed to 'const char *'? */
1739 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1740 if (!same_type_p (TREE_TYPE (exp), t))
1743 if (TREE_CODE (exp) != ADDR_EXPR
1744 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1748 /* This warning is not very useful, as it complains about printf. */
1750 warning (OPT_Wwrite_strings,
1751 "deprecated conversion from string constant to %qT",
1757 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1758 can, for example, use as an lvalue. This code used to be in
1759 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1760 expressions, where we're dealing with aggregates. But now it's again only
1761 called from unary_complex_lvalue. The case (in particular) that led to
1762 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1766 rationalize_conditional_expr (enum tree_code code, tree t,
1767 tsubst_flags_t complain)
1769 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1770 the first operand is always the one to be used if both operands
1771 are equal, so we know what conditional expression this used to be. */
1772 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1774 tree op0 = TREE_OPERAND (t, 0);
1775 tree op1 = TREE_OPERAND (t, 1);
1777 /* The following code is incorrect if either operand side-effects. */
1778 gcc_assert (!TREE_SIDE_EFFECTS (op0)
1779 && !TREE_SIDE_EFFECTS (op1));
1781 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1782 ? LE_EXPR : GE_EXPR),
1783 op0, TREE_CODE (op0),
1784 op1, TREE_CODE (op1),
1785 /*overloaded_p=*/NULL,
1787 cp_build_unary_op (code, op0, 0, complain),
1788 cp_build_unary_op (code, op1, 0, complain),
1793 build_conditional_expr (TREE_OPERAND (t, 0),
1794 cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
1796 cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
1801 /* Given the TYPE of an anonymous union field inside T, return the
1802 FIELD_DECL for the field. If not found return NULL_TREE. Because
1803 anonymous unions can nest, we must also search all anonymous unions
1804 that are directly reachable. */
1807 lookup_anon_field (tree t, tree type)
1811 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1813 if (TREE_STATIC (field))
1815 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1818 /* If we find it directly, return the field. */
1819 if (DECL_NAME (field) == NULL_TREE
1820 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1825 /* Otherwise, it could be nested, search harder. */
1826 if (DECL_NAME (field) == NULL_TREE
1827 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1829 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1837 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1838 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1839 non-NULL, it indicates the path to the base used to name MEMBER.
1840 If PRESERVE_REFERENCE is true, the expression returned will have
1841 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1842 returned will have the type referred to by the reference.
1844 This function does not perform access control; that is either done
1845 earlier by the parser when the name of MEMBER is resolved to MEMBER
1846 itself, or later when overload resolution selects one of the
1847 functions indicated by MEMBER. */
1850 build_class_member_access_expr (tree object, tree member,
1851 tree access_path, bool preserve_reference,
1852 tsubst_flags_t complain)
1856 tree result = NULL_TREE;
1858 if (error_operand_p (object) || error_operand_p (member))
1859 return error_mark_node;
1861 gcc_assert (DECL_P (member) || BASELINK_P (member));
1865 The type of the first expression shall be "class object" (of a
1867 object_type = TREE_TYPE (object);
1868 if (!currently_open_class (object_type)
1869 && !complete_type_or_else (object_type, object))
1870 return error_mark_node;
1871 if (!CLASS_TYPE_P (object_type))
1873 if (complain & tf_error)
1874 error ("request for member %qD in %qE, which is of non-class type %qT",
1875 member, object, object_type);
1876 return error_mark_node;
1879 /* The standard does not seem to actually say that MEMBER must be a
1880 member of OBJECT_TYPE. However, that is clearly what is
1882 if (DECL_P (member))
1884 member_scope = DECL_CLASS_CONTEXT (member);
1886 if (TREE_DEPRECATED (member))
1887 warn_deprecated_use (member);
1890 member_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (member));
1891 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1892 presently be the anonymous union. Go outwards until we find a
1893 type related to OBJECT_TYPE. */
1894 while (ANON_AGGR_TYPE_P (member_scope)
1895 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1897 member_scope = TYPE_CONTEXT (member_scope);
1898 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1900 if (complain & tf_error)
1902 if (TREE_CODE (member) == FIELD_DECL)
1903 error ("invalid use of nonstatic data member %qE", member);
1905 error ("%qD is not a member of %qT", member, object_type);
1907 return error_mark_node;
1910 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1911 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1912 in the front end; only _DECLs and _REFs are lvalues in the back end. */
1914 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1916 object = cp_build_indirect_ref (temp, NULL, complain);
1919 /* In [expr.ref], there is an explicit list of the valid choices for
1920 MEMBER. We check for each of those cases here. */
1921 if (TREE_CODE (member) == VAR_DECL)
1923 /* A static data member. */
1925 /* If OBJECT has side-effects, they are supposed to occur. */
1926 if (TREE_SIDE_EFFECTS (object))
1927 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1929 else if (TREE_CODE (member) == FIELD_DECL)
1931 /* A non-static data member. */
1936 null_object_p = (TREE_CODE (object) == INDIRECT_REF
1937 && integer_zerop (TREE_OPERAND (object, 0)));
1939 /* Convert OBJECT to the type of MEMBER. */
1940 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1941 TYPE_MAIN_VARIANT (member_scope)))
1946 binfo = lookup_base (access_path ? access_path : object_type,
1947 member_scope, ba_unique, &kind);
1948 if (binfo == error_mark_node)
1949 return error_mark_node;
1951 /* It is invalid to try to get to a virtual base of a
1952 NULL object. The most common cause is invalid use of
1954 if (null_object_p && kind == bk_via_virtual)
1956 if (complain & tf_error)
1958 error ("invalid access to non-static data member %qD of "
1961 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
1963 return error_mark_node;
1966 /* Convert to the base. */
1967 object = build_base_path (PLUS_EXPR, object, binfo,
1969 /* If we found the base successfully then we should be able
1970 to convert to it successfully. */
1971 gcc_assert (object != error_mark_node);
1974 /* Complain about other invalid uses of offsetof, even though they will
1975 give the right answer. Note that we complain whether or not they
1976 actually used the offsetof macro, since there's no way to know at this
1977 point. So we just give a warning, instead of a pedwarn. */
1978 /* Do not produce this warning for base class field references, because
1979 we know for a fact that didn't come from offsetof. This does occur
1980 in various testsuite cases where a null object is passed where a
1981 vtable access is required. */
1982 if (null_object_p && warn_invalid_offsetof
1983 && CLASSTYPE_NON_POD_P (object_type)
1984 && !DECL_FIELD_IS_BASE (member)
1986 && (complain & tf_warning))
1988 warning (OPT_Winvalid_offsetof,
1989 "invalid access to non-static data member %qD "
1990 " of NULL object", member);
1991 warning (OPT_Winvalid_offsetof,
1992 "(perhaps the %<offsetof%> macro was used incorrectly)");
1995 /* If MEMBER is from an anonymous aggregate, we have converted
1996 OBJECT so that it refers to the class containing the
1997 anonymous union. Generate a reference to the anonymous union
1998 itself, and recur to find MEMBER. */
1999 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
2000 /* When this code is called from build_field_call, the
2001 object already has the type of the anonymous union.
2002 That is because the COMPONENT_REF was already
2003 constructed, and was then disassembled before calling
2004 build_field_call. After the function-call code is
2005 cleaned up, this waste can be eliminated. */
2006 && (!same_type_ignoring_top_level_qualifiers_p
2007 (TREE_TYPE (object), DECL_CONTEXT (member))))
2009 tree anonymous_union;
2011 anonymous_union = lookup_anon_field (TREE_TYPE (object),
2012 DECL_CONTEXT (member));
2013 object = build_class_member_access_expr (object,
2015 /*access_path=*/NULL_TREE,
2020 /* Compute the type of the field, as described in [expr.ref]. */
2021 type_quals = TYPE_UNQUALIFIED;
2022 member_type = TREE_TYPE (member);
2023 if (TREE_CODE (member_type) != REFERENCE_TYPE)
2025 type_quals = (cp_type_quals (member_type)
2026 | cp_type_quals (object_type));
2028 /* A field is const (volatile) if the enclosing object, or the
2029 field itself, is const (volatile). But, a mutable field is
2030 not const, even within a const object. */
2031 if (DECL_MUTABLE_P (member))
2032 type_quals &= ~TYPE_QUAL_CONST;
2033 member_type = cp_build_qualified_type (member_type, type_quals);
2036 result = build3 (COMPONENT_REF, member_type, object, member,
2038 result = fold_if_not_in_template (result);
2040 /* Mark the expression const or volatile, as appropriate. Even
2041 though we've dealt with the type above, we still have to mark the
2042 expression itself. */
2043 if (type_quals & TYPE_QUAL_CONST)
2044 TREE_READONLY (result) = 1;
2045 if (type_quals & TYPE_QUAL_VOLATILE)
2046 TREE_THIS_VOLATILE (result) = 1;
2048 else if (BASELINK_P (member))
2050 /* The member is a (possibly overloaded) member function. */
2054 /* If the MEMBER is exactly one static member function, then we
2055 know the type of the expression. Otherwise, we must wait
2056 until overload resolution has been performed. */
2057 functions = BASELINK_FUNCTIONS (member);
2058 if (TREE_CODE (functions) == FUNCTION_DECL
2059 && DECL_STATIC_FUNCTION_P (functions))
2060 type = TREE_TYPE (functions);
2062 type = unknown_type_node;
2063 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2064 base. That will happen when the function is called. */
2065 result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
2067 else if (TREE_CODE (member) == CONST_DECL)
2069 /* The member is an enumerator. */
2071 /* If OBJECT has side-effects, they are supposed to occur. */
2072 if (TREE_SIDE_EFFECTS (object))
2073 result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
2078 if (complain & tf_error)
2079 error ("invalid use of %qD", member);
2080 return error_mark_node;
2083 if (!preserve_reference)
2086 If E2 is declared to have type "reference to T", then ... the
2087 type of E1.E2 is T. */
2088 result = convert_from_reference (result);
2093 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
2094 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
2097 lookup_destructor (tree object, tree scope, tree dtor_name)
2099 tree object_type = TREE_TYPE (object);
2100 tree dtor_type = TREE_OPERAND (dtor_name, 0);
2103 if (scope && !check_dtor_name (scope, dtor_type))
2105 error ("qualified type %qT does not match destructor name ~%qT",
2107 return error_mark_node;
2109 if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2111 error ("the type being destroyed is %qT, but the destructor refers to %qT",
2112 TYPE_MAIN_VARIANT (object_type), dtor_type);
2113 return error_mark_node;
2115 expr = lookup_member (dtor_type, complete_dtor_identifier,
2116 /*protect=*/1, /*want_type=*/false);
2117 expr = (adjust_result_of_qualified_name_lookup
2118 (expr, dtor_type, object_type));
2122 /* An expression of the form "A::template B" has been resolved to
2123 DECL. Issue a diagnostic if B is not a template or template
2127 check_template_keyword (tree decl)
2129 /* The standard says:
2133 If a name prefixed by the keyword template is not a member
2134 template, the program is ill-formed.
2136 DR 228 removed the restriction that the template be a member
2139 DR 96, if accepted would add the further restriction that explicit
2140 template arguments must be provided if the template keyword is
2141 used, but, as of 2005-10-16, that DR is still in "drafting". If
2142 this DR is accepted, then the semantic checks here can be
2143 simplified, as the entity named must in fact be a template
2144 specialization, rather than, as at present, a set of overloaded
2145 functions containing at least one template function. */
2146 if (TREE_CODE (decl) != TEMPLATE_DECL
2147 && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2149 if (!is_overloaded_fn (decl))
2150 pedwarn ("%qD is not a template", decl);
2155 if (BASELINK_P (fns))
2156 fns = BASELINK_FUNCTIONS (fns);
2159 tree fn = OVL_CURRENT (fns);
2160 if (TREE_CODE (fn) == TEMPLATE_DECL
2161 || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2163 if (TREE_CODE (fn) == FUNCTION_DECL
2164 && DECL_USE_TEMPLATE (fn)
2165 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2167 fns = OVL_NEXT (fns);
2170 pedwarn ("%qD is not a template", decl);
2175 /* This function is called by the parser to process a class member
2176 access expression of the form OBJECT.NAME. NAME is a node used by
2177 the parser to represent a name; it is not yet a DECL. It may,
2178 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2179 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2180 there is no reason to do the lookup twice, so the parser keeps the
2181 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2182 be a template via the use of the "A::template B" syntax. */
2185 finish_class_member_access_expr (tree object, tree name, bool template_p,
2186 tsubst_flags_t complain)
2191 tree access_path = NULL_TREE;
2192 tree orig_object = object;
2193 tree orig_name = name;
2195 if (object == error_mark_node || name == error_mark_node)
2196 return error_mark_node;
2198 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2199 if (!objc_is_public (object, name))
2200 return error_mark_node;
2202 object_type = TREE_TYPE (object);
2204 if (processing_template_decl)
2206 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2207 dependent_type_p (object_type)
2208 /* If NAME is just an IDENTIFIER_NODE, then the expression
2210 || TREE_CODE (object) == IDENTIFIER_NODE
2211 /* If NAME is "f<args>", where either 'f' or 'args' is
2212 dependent, then the expression is dependent. */
2213 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2214 && dependent_template_id_p (TREE_OPERAND (name, 0),
2215 TREE_OPERAND (name, 1)))
2216 /* If NAME is "T::X" where "T" is dependent, then the
2217 expression is dependent. */
2218 || (TREE_CODE (name) == SCOPE_REF
2219 && TYPE_P (TREE_OPERAND (name, 0))
2220 && dependent_type_p (TREE_OPERAND (name, 0))))
2221 return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2222 object = build_non_dependent_expr (object);
2227 The type of the first expression shall be "class object" (of a
2229 if (!currently_open_class (object_type)
2230 && !complete_type_or_else (object_type, object))
2231 return error_mark_node;
2232 if (!CLASS_TYPE_P (object_type))
2234 if (complain & tf_error)
2235 error ("request for member %qD in %qE, which is of non-class type %qT",
2236 name, object, object_type);
2237 return error_mark_node;
2240 if (BASELINK_P (name))
2241 /* A member function that has already been looked up. */
2245 bool is_template_id = false;
2246 tree template_args = NULL_TREE;
2249 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2251 is_template_id = true;
2252 template_args = TREE_OPERAND (name, 1);
2253 name = TREE_OPERAND (name, 0);
2255 if (TREE_CODE (name) == OVERLOAD)
2256 name = DECL_NAME (get_first_fn (name));
2257 else if (DECL_P (name))
2258 name = DECL_NAME (name);
2261 if (TREE_CODE (name) == SCOPE_REF)
2263 /* A qualified name. The qualifying class or namespace `S'
2264 has already been looked up; it is either a TYPE or a
2266 scope = TREE_OPERAND (name, 0);
2267 name = TREE_OPERAND (name, 1);
2269 /* If SCOPE is a namespace, then the qualified name does not
2270 name a member of OBJECT_TYPE. */
2271 if (TREE_CODE (scope) == NAMESPACE_DECL)
2273 if (complain & tf_error)
2274 error ("%<%D::%D%> is not a member of %qT",
2275 scope, name, object_type);
2276 return error_mark_node;
2279 gcc_assert (CLASS_TYPE_P (scope));
2280 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2281 || TREE_CODE (name) == BIT_NOT_EXPR);
2283 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2284 access_path = lookup_base (object_type, scope, ba_check, NULL);
2285 if (access_path == error_mark_node)
2286 return error_mark_node;
2289 if (complain & tf_error)
2290 error ("%qT is not a base of %qT", scope, object_type);
2291 return error_mark_node;
2297 access_path = object_type;
2300 if (TREE_CODE (name) == BIT_NOT_EXPR)
2301 member = lookup_destructor (object, scope, name);
2304 /* Look up the member. */
2305 member = lookup_member (access_path, name, /*protect=*/1,
2306 /*want_type=*/false);
2307 if (member == NULL_TREE)
2309 if (complain & tf_error)
2310 error ("%qD has no member named %qE", object_type, name);
2311 return error_mark_node;
2313 if (member == error_mark_node)
2314 return error_mark_node;
2319 tree template = member;
2321 if (BASELINK_P (template))
2322 template = lookup_template_function (template, template_args);
2325 if (complain & tf_error)
2326 error ("%qD is not a member template function", name);
2327 return error_mark_node;
2332 if (TREE_DEPRECATED (member))
2333 warn_deprecated_use (member);
2336 check_template_keyword (member);
2338 expr = build_class_member_access_expr (object, member, access_path,
2339 /*preserve_reference=*/false,
2341 if (processing_template_decl && expr != error_mark_node)
2343 if (BASELINK_P (member))
2345 if (TREE_CODE (orig_name) == SCOPE_REF)
2346 BASELINK_QUALIFIED_P (member) = 1;
2349 return build_min_non_dep (COMPONENT_REF, expr,
2350 orig_object, orig_name,
2357 /* Return an expression for the MEMBER_NAME field in the internal
2358 representation of PTRMEM, a pointer-to-member function. (Each
2359 pointer-to-member function type gets its own RECORD_TYPE so it is
2360 more convenient to access the fields by name than by FIELD_DECL.)
2361 This routine converts the NAME to a FIELD_DECL and then creates the
2362 node for the complete expression. */
2365 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2371 /* This code is a stripped down version of
2372 build_class_member_access_expr. It does not work to use that
2373 routine directly because it expects the object to be of class
2375 ptrmem_type = TREE_TYPE (ptrmem);
2376 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2377 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2378 /*want_type=*/false);
2379 member_type = cp_build_qualified_type (TREE_TYPE (member),
2380 cp_type_quals (ptrmem_type));
2381 return fold_build3 (COMPONENT_REF, member_type,
2382 ptrmem, member, NULL_TREE);
2385 /* Given an expression PTR for a pointer, return an expression
2386 for the value pointed to.
2387 ERRORSTRING is the name of the operator to appear in error messages.
2389 This function may need to overload OPERATOR_FNNAME.
2390 Must also handle REFERENCE_TYPEs for C++. */
2393 build_x_indirect_ref (tree expr, const char *errorstring,
2394 tsubst_flags_t complain)
2396 tree orig_expr = expr;
2399 if (processing_template_decl)
2401 if (type_dependent_expression_p (expr))
2402 return build_min_nt (INDIRECT_REF, expr);
2403 expr = build_non_dependent_expr (expr);
2406 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2407 NULL_TREE, /*overloaded_p=*/NULL, complain);
2409 rval = cp_build_indirect_ref (expr, errorstring, complain);
2411 if (processing_template_decl && rval != error_mark_node)
2412 return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2417 /* Helper function called from c-common. */
2419 build_indirect_ref (tree ptr, const char *errorstring)
2421 return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2425 cp_build_indirect_ref (tree ptr, const char *errorstring,
2426 tsubst_flags_t complain)
2430 if (ptr == error_mark_node)
2431 return error_mark_node;
2433 if (ptr == current_class_ptr)
2434 return current_class_ref;
2436 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2437 ? ptr : decay_conversion (ptr));
2438 type = TREE_TYPE (pointer);
2440 if (POINTER_TYPE_P (type))
2444 If the type of the expression is "pointer to T," the type
2445 of the result is "T."
2447 We must use the canonical variant because certain parts of
2448 the back end, like fold, do pointer comparisons between
2450 tree t = canonical_type_variant (TREE_TYPE (type));
2452 if (TREE_CODE (ptr) == CONVERT_EXPR
2453 || TREE_CODE (ptr) == NOP_EXPR
2454 || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2456 /* If a warning is issued, mark it to avoid duplicates from
2457 the backend. This only needs to be done at
2458 warn_strict_aliasing > 2. */
2459 if (warn_strict_aliasing > 2)
2460 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2461 type, TREE_OPERAND (ptr, 0)))
2462 TREE_NO_WARNING (ptr) = 1;
2465 if (VOID_TYPE_P (t))
2467 /* A pointer to incomplete type (other than cv void) can be
2468 dereferenced [expr.unary.op]/1 */
2469 if (complain & tf_error)
2470 error ("%qT is not a pointer-to-object type", type);
2471 return error_mark_node;
2473 else if (TREE_CODE (pointer) == ADDR_EXPR
2474 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2475 /* The POINTER was something like `&x'. We simplify `*&x' to
2477 return TREE_OPERAND (pointer, 0);
2480 tree ref = build1 (INDIRECT_REF, t, pointer);
2482 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2483 so that we get the proper error message if the result is used
2484 to assign to. Also, &* is supposed to be a no-op. */
2485 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2486 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2487 TREE_SIDE_EFFECTS (ref)
2488 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2492 else if (!(complain & tf_error))
2493 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
2495 /* `pointer' won't be an error_mark_node if we were given a
2496 pointer to member, so it's cool to check for this here. */
2497 else if (TYPE_PTR_TO_MEMBER_P (type))
2498 error ("invalid use of %qs on pointer to member", errorstring);
2499 else if (pointer != error_mark_node)
2502 error ("invalid type argument of %qs", errorstring);
2504 error ("invalid type argument");
2506 return error_mark_node;
2509 /* This handles expressions of the form "a[i]", which denotes
2512 This is logically equivalent in C to *(a+i), but we may do it differently.
2513 If A is a variable or a member, we generate a primitive ARRAY_REF.
2514 This avoids forcing the array out of registers, and can work on
2515 arrays that are not lvalues (for example, members of structures returned
2518 If INDEX is of some user-defined type, it must be converted to
2519 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2520 will inherit the type of the array, which will be some pointer type. */
2523 build_array_ref (tree array, tree idx)
2527 error ("subscript missing in array reference");
2528 return error_mark_node;
2531 if (TREE_TYPE (array) == error_mark_node
2532 || TREE_TYPE (idx) == error_mark_node)
2533 return error_mark_node;
2535 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2537 switch (TREE_CODE (array))
2541 tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2542 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2543 TREE_OPERAND (array, 0), value);
2547 return build_conditional_expr
2548 (TREE_OPERAND (array, 0),
2549 build_array_ref (TREE_OPERAND (array, 1), idx),
2550 build_array_ref (TREE_OPERAND (array, 2), idx),
2551 tf_warning_or_error);
2557 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2559 bool has_warned_on_bounds_check = false;
2560 tree rval, type, ref;
2562 warn_array_subscript_with_type_char (idx);
2564 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2566 error ("array subscript is not an integer");
2567 return error_mark_node;
2570 /* Apply integral promotions *after* noticing character types.
2571 (It is unclear why we do these promotions -- the standard
2572 does not say that we should. In fact, the natural thing would
2573 seem to be to convert IDX to ptrdiff_t; we're performing
2574 pointer arithmetic.) */
2575 idx = perform_integral_promotions (idx);
2577 /* Warn about any obvious array bounds errors for fixed size arrays that
2578 are indexed by a constant. */
2579 has_warned_on_bounds_check = warn_array_subscript_range (array, idx);
2581 /* An array that is indexed by a non-constant
2582 cannot be stored in a register; we must be able to do
2583 address arithmetic on its address.
2584 Likewise an array of elements of variable size. */
2585 if (TREE_CODE (idx) != INTEGER_CST
2586 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2587 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2590 if (!cxx_mark_addressable (array))
2591 return error_mark_node;
2594 /* An array that is indexed by a constant value which is not within
2595 the array bounds cannot be stored in a register either; because we
2596 would get a crash in store_bit_field/extract_bit_field when trying
2597 to access a non-existent part of the register. */
2598 if (TREE_CODE (idx) == INTEGER_CST
2599 && TYPE_DOMAIN (TREE_TYPE (array))
2600 && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2602 if (!cxx_mark_addressable (array))
2603 return error_mark_node;
2606 if (pedantic && !lvalue_p (array))
2607 pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2609 /* Note in C++ it is valid to subscript a `register' array, since
2610 it is valid to take the address of something with that
2611 storage specification. */
2615 while (TREE_CODE (foo) == COMPONENT_REF)
2616 foo = TREE_OPERAND (foo, 0);
2617 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2618 warning (OPT_Wextra, "subscripting array declared %<register%>");
2621 type = TREE_TYPE (TREE_TYPE (array));
2622 rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2623 /* Array ref is const/volatile if the array elements are
2624 or if the array is.. */
2625 TREE_READONLY (rval)
2626 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2627 TREE_SIDE_EFFECTS (rval)
2628 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2629 TREE_THIS_VOLATILE (rval)
2630 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2631 ref = require_complete_type (fold_if_not_in_template (rval));
2633 /* Suppress bounds warning in tree-vrp.c if already warned here. */
2634 if (has_warned_on_bounds_check)
2635 TREE_NO_WARNING (ref) = 1;
2640 tree ar = default_conversion (array);
2641 tree ind = default_conversion (idx);
2643 /* Put the integer in IND to simplify error checking. */
2644 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2651 if (ar == error_mark_node)
2654 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2656 error ("subscripted value is neither array nor pointer");
2657 return error_mark_node;
2659 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2661 error ("array subscript is not an integer");
2662 return error_mark_node;
2665 warn_array_subscript_with_type_char (idx);
2667 return cp_build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind,
2668 tf_warning_or_error),
2670 tf_warning_or_error);
2674 /* Resolve a pointer to member function. INSTANCE is the object
2675 instance to use, if the member points to a virtual member.
2677 This used to avoid checking for virtual functions if basetype
2678 has no virtual functions, according to an earlier ANSI draft.
2679 With the final ISO C++ rules, such an optimization is
2680 incorrect: A pointer to a derived member can be static_cast
2681 to pointer-to-base-member, as long as the dynamic object
2682 later has the right member. */
2685 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2687 if (TREE_CODE (function) == OFFSET_REF)
2688 function = TREE_OPERAND (function, 1);
2690 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2692 tree idx, delta, e1, e2, e3, vtbl, basetype;
2693 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2695 tree instance_ptr = *instance_ptrptr;
2696 tree instance_save_expr = 0;
2697 if (instance_ptr == error_mark_node)
2699 if (TREE_CODE (function) == PTRMEM_CST)
2701 /* Extracting the function address from a pmf is only
2702 allowed with -Wno-pmf-conversions. It only works for
2704 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2705 e1 = convert (fntype, e1);
2710 error ("object missing in use of %qE", function);
2711 return error_mark_node;
2715 if (TREE_SIDE_EFFECTS (instance_ptr))
2716 instance_ptr = instance_save_expr = save_expr (instance_ptr);
2718 if (TREE_SIDE_EFFECTS (function))
2719 function = save_expr (function);
2721 /* Start by extracting all the information from the PMF itself. */
2722 e3 = pfn_from_ptrmemfunc (function);
2723 delta = delta_from_ptrmemfunc (function);
2724 idx = build1 (NOP_EXPR, vtable_index_type, e3);
2725 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2727 case ptrmemfunc_vbit_in_pfn:
2728 e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node,
2729 tf_warning_or_error);
2730 idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node,
2731 tf_warning_or_error);
2734 case ptrmemfunc_vbit_in_delta:
2735 e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node,
2736 tf_warning_or_error);
2737 delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node,
2738 tf_warning_or_error);
2745 /* Convert down to the right base before using the instance. A
2746 special case is that in a pointer to member of class C, C may
2747 be incomplete. In that case, the function will of course be
2748 a member of C, and no conversion is required. In fact,
2749 lookup_base will fail in that case, because incomplete
2750 classes do not have BINFOs. */
2751 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2752 if (!same_type_ignoring_top_level_qualifiers_p
2753 (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
2755 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2756 basetype, ba_check, NULL);
2757 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
2759 if (instance_ptr == error_mark_node)
2760 return error_mark_node;
2762 /* ...and then the delta in the PMF. */
2763 instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
2764 instance_ptr, fold_convert (sizetype, delta));
2766 /* Hand back the adjusted 'this' argument to our caller. */
2767 *instance_ptrptr = instance_ptr;
2769 /* Next extract the vtable pointer from the object. */
2770 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2772 vtbl = cp_build_indirect_ref (vtbl, NULL, tf_warning_or_error);
2774 /* Finally, extract the function pointer from the vtable. */
2775 e2 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
2776 fold_convert (sizetype, idx));
2777 e2 = cp_build_indirect_ref (e2, NULL, tf_warning_or_error);
2778 TREE_CONSTANT (e2) = 1;
2780 /* When using function descriptors, the address of the
2781 vtable entry is treated as a function pointer. */
2782 if (TARGET_VTABLE_USES_DESCRIPTORS)
2783 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2784 cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
2785 tf_warning_or_error));
2787 e2 = fold_convert (TREE_TYPE (e3), e2);
2788 e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
2790 /* Make sure this doesn't get evaluated first inside one of the
2791 branches of the COND_EXPR. */
2792 if (instance_save_expr)
2793 e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
2794 instance_save_expr, e1);
2801 /* Used by the C-common bits. */
2803 build_function_call (tree function, tree params)
2805 return cp_build_function_call (function, params, tf_warning_or_error);
2809 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
2811 tree fntype, fndecl;
2812 tree name = NULL_TREE;
2814 tree original = function;
2815 int nargs, parm_types_len;
2819 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2820 expressions, like those used for ObjC messenger dispatches. */
2821 function = objc_rewrite_function_call (function, params);
2823 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2824 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2825 if (TREE_CODE (function) == NOP_EXPR
2826 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2827 function = TREE_OPERAND (function, 0);
2829 if (TREE_CODE (function) == FUNCTION_DECL)
2831 name = DECL_NAME (function);
2833 mark_used (function);
2836 /* Convert anything with function type to a pointer-to-function. */
2837 if (pedantic && DECL_MAIN_P (function) && (complain & tf_error))
2838 pedwarn ("ISO C++ forbids calling %<::main%> from within program");
2840 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2841 (because calling an inline function does not mean the function
2842 needs to be separately compiled). */
2844 if (DECL_INLINE (function))
2845 function = inline_conversion (function);
2847 function = build_addr_func (function);
2853 function = build_addr_func (function);
2856 if (function == error_mark_node)
2857 return error_mark_node;
2859 fntype = TREE_TYPE (function);
2861 if (TYPE_PTRMEMFUNC_P (fntype))
2863 if (complain & tf_error)
2864 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2865 "function in %<%E (...)%>",
2867 return error_mark_node;
2870 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2871 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2873 if (!((TREE_CODE (fntype) == POINTER_TYPE
2874 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2876 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2878 if (complain & tf_error)
2879 error ("%qE cannot be used as a function", original);
2880 return error_mark_node;
2883 /* fntype now gets the type of function pointed to. */
2884 fntype = TREE_TYPE (fntype);
2885 parm_types = TYPE_ARG_TYPES (fntype);
2887 /* Allocate storage for converted arguments. */
2888 parm_types_len = list_length (parm_types);
2889 nargs = list_length (params);
2890 if (parm_types_len > nargs)
2891 nargs = parm_types_len;
2892 argarray = (tree *) alloca (nargs * sizeof (tree));
2894 /* Convert the parameters to the types declared in the
2895 function prototype, or apply default promotions. */
2896 nargs = convert_arguments (nargs, argarray, parm_types,
2897 params, fndecl, LOOKUP_NORMAL,
2900 return error_mark_node;
2902 /* Check that arguments to builtin functions match the expectations. */
2904 && DECL_BUILT_IN (fndecl)
2905 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2906 && !check_builtin_function_arguments (fndecl, nargs, argarray))
2907 return error_mark_node;
2909 /* Check for errors in format strings and inappropriately
2911 check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
2914 return build_cxx_call (function, nargs, argarray);
2917 /* Convert the actual parameter expressions in the list VALUES
2918 to the types in the list TYPELIST.
2919 If parmdecls is exhausted, or when an element has NULL as its type,
2920 perform the default conversions.
2922 Store the converted arguments in ARGARRAY. NARGS is the size of this array.
2924 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2926 This is also where warnings about wrong number of args are generated.
2928 Returns the actual number of arguments processed (which might be less
2929 than NARGS), or -1 on error.
2931 VALUES is a chain of TREE_LIST nodes with the elements of the list
2932 in the TREE_VALUE slots of those nodes.
2934 In C++, unspecified trailing parameters can be filled in with their
2935 default arguments, if such were specified. Do so here. */
2938 convert_arguments (int nargs, tree *argarray,
2939 tree typelist, tree values, tree fndecl, int flags,
2940 tsubst_flags_t complain)
2942 tree typetail, valtail;
2943 const char *called_thing = 0;
2946 /* Argument passing is always copy-initialization. */
2947 flags |= LOOKUP_ONLYCONVERTING;
2951 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2953 if (DECL_NAME (fndecl) == NULL_TREE
2954 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2955 called_thing = "constructor";
2957 called_thing = "member function";
2960 called_thing = "function";
2963 for (valtail = values, typetail = typelist;
2965 valtail = TREE_CHAIN (valtail), i++)
2967 tree type = typetail ? TREE_VALUE (typetail) : 0;
2968 tree val = TREE_VALUE (valtail);
2970 if (val == error_mark_node || type == error_mark_node)
2973 if (type == void_type_node)
2975 if (complain & tf_error)
2979 error ("too many arguments to %s %q+#D",
2980 called_thing, fndecl);
2981 error ("at this point in file");
2984 error ("too many arguments to function");
2991 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2992 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2993 if (TREE_CODE (val) == NOP_EXPR
2994 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2995 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2996 val = TREE_OPERAND (val, 0);
2998 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3000 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3001 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3002 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3003 val = decay_conversion (val);
3006 if (val == error_mark_node)
3011 /* Formal parm type is specified by a function prototype. */
3014 if (!COMPLETE_TYPE_P (complete_type (type)))
3016 if (complain & tf_error)
3019 error ("parameter %P of %qD has incomplete type %qT",
3022 error ("parameter %P has incomplete type %qT", i, type);
3024 parmval = error_mark_node;
3028 parmval = convert_for_initialization
3029 (NULL_TREE, type, val, flags,
3030 "argument passing", fndecl, i, complain);
3031 parmval = convert_for_arg_passing (type, parmval);
3034 if (parmval == error_mark_node)
3037 argarray[i] = parmval;
3041 if (fndecl && DECL_BUILT_IN (fndecl)
3042 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3043 /* Don't do ellipsis conversion for __built_in_constant_p
3044 as this will result in spurious warnings for non-POD
3046 val = require_complete_type (val);
3048 val = convert_arg_to_ellipsis (val);
3054 typetail = TREE_CHAIN (typetail);
3057 if (typetail != 0 && typetail != void_list_node)
3059 /* See if there are default arguments that can be used. Because
3060 we hold default arguments in the FUNCTION_TYPE (which is so
3061 wrong), we can see default parameters here from deduced
3062 contexts (and via typeof) for indirect function calls.
3063 Fortunately we know whether we have a function decl to
3064 provide default arguments in a language conformant
3066 if (fndecl && TREE_PURPOSE (typetail)
3067 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3069 for (; typetail != void_list_node; ++i)
3072 = convert_default_arg (TREE_VALUE (typetail),
3073 TREE_PURPOSE (typetail),
3076 if (parmval == error_mark_node)
3079 argarray[i] = parmval;
3080 typetail = TREE_CHAIN (typetail);
3081 /* ends with `...'. */
3082 if (typetail == NULL_TREE)
3088 if (complain & tf_error)
3092 error ("too few arguments to %s %q+#D",
3093 called_thing, fndecl);
3094 error ("at this point in file");
3097 error ("too few arguments to function");
3103 gcc_assert (i <= nargs);
3107 /* Build a binary-operation expression, after performing default
3108 conversions on the operands. CODE is the kind of expression to
3109 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3110 are the tree codes which correspond to ARG1 and ARG2 when issuing
3111 warnings about possibly misplaced parentheses. They may differ
3112 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3113 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3114 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3115 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3116 ARG2_CODE as ERROR_MARK. */
3119 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3120 tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3121 tsubst_flags_t complain)
3130 if (processing_template_decl)
3132 if (type_dependent_expression_p (arg1)
3133 || type_dependent_expression_p (arg2))
3134 return build_min_nt (code, arg1, arg2);
3135 arg1 = build_non_dependent_expr (arg1);
3136 arg2 = build_non_dependent_expr (arg2);
3139 if (code == DOTSTAR_EXPR)
3140 expr = build_m_component_ref (arg1, arg2);
3142 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3143 overloaded_p, complain);
3145 /* Check for cases such as x+y<<z which users are likely to
3146 misinterpret. But don't warn about obj << x + y, since that is a
3147 common idiom for I/O. */
3148 if (warn_parentheses
3149 && !processing_template_decl
3150 && !error_operand_p (arg1)
3151 && !error_operand_p (arg2)
3152 && (code != LSHIFT_EXPR
3153 || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3154 warn_about_parentheses (code, arg1_code, arg2_code);
3156 if (processing_template_decl && expr != error_mark_node)
3157 return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3162 /* For the c-common bits. */
3164 build_binary_op (enum tree_code code, tree op0, tree op1,
3165 int convert_p ATTRIBUTE_UNUSED)
3167 return cp_build_binary_op(code, op0, op1, tf_warning_or_error);
3171 /* Build a binary-operation expression without default conversions.
3172 CODE is the kind of expression to build.
3173 This function differs from `build' in several ways:
3174 the data type of the result is computed and recorded in it,
3175 warnings are generated if arg data types are invalid,
3176 special handling for addition and subtraction of pointers is known,
3177 and some optimization is done (operations on narrow ints
3178 are done in the narrower type when that gives the same result).
3179 Constant folding is also done before the result is returned.
3181 Note that the operands will never have enumeral types
3182 because either they have just had the default conversions performed
3183 or they have both just been converted to some other type in which
3184 the arithmetic is to be done.
3186 C++: must do special pointer arithmetic when implementing
3187 multiple inheritance, and deal with pointer to member functions. */
3190 cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
3191 tsubst_flags_t complain)
3194 enum tree_code code0, code1;
3196 const char *invalid_op_diag;
3198 /* Expression code to give to the expression when it is built.
3199 Normally this is CODE, which is what the caller asked for,
3200 but in some special cases we change it. */
3201 enum tree_code resultcode = code;
3203 /* Data type in which the computation is to be performed.
3204 In the simplest cases this is the common type of the arguments. */
3205 tree result_type = NULL;
3207 /* Nonzero means operands have already been type-converted
3208 in whatever way is necessary.
3209 Zero means they need to be converted to RESULT_TYPE. */
3212 /* Nonzero means create the expression with this type, rather than
3214 tree build_type = 0;
3216 /* Nonzero means after finally constructing the expression
3217 convert it to this type. */
3218 tree final_type = 0;
3222 /* Nonzero if this is an operation like MIN or MAX which can
3223 safely be computed in short if both args are promoted shorts.
3224 Also implies COMMON.
3225 -1 indicates a bitwise operation; this makes a difference
3226 in the exact conditions for when it is safe to do the operation
3227 in a narrower mode. */
3230 /* Nonzero if this is a comparison operation;
3231 if both args are promoted shorts, compare the original shorts.
3232 Also implies COMMON. */
3233 int short_compare = 0;
3235 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3238 /* True if both operands have arithmetic type. */
3239 bool arithmetic_types_p;
3241 /* Apply default conversions. */
3245 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3246 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3247 || code == TRUTH_XOR_EXPR)
3249 if (!really_overloaded_fn (op0))
3250 op0 = decay_conversion (op0);
3251 if (!really_overloaded_fn (op1))
3252 op1 = decay_conversion (op1);
3256 if (!really_overloaded_fn (op0))
3257 op0 = default_conversion (op0);
3258 if (!really_overloaded_fn (op1))
3259 op1 = default_conversion (op1);
3262 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3263 STRIP_TYPE_NOPS (op0);
3264 STRIP_TYPE_NOPS (op1);
3266 /* DTRT if one side is an overloaded function, but complain about it. */
3267 if (type_unknown_p (op0))
3269 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3270 if (t != error_mark_node)
3272 if (complain & tf_error)
3273 pedwarn ("assuming cast to type %qT from overloaded function",
3278 if (type_unknown_p (op1))
3280 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3281 if (t != error_mark_node)
3283 if (complain & tf_error)
3284 pedwarn ("assuming cast to type %qT from overloaded function",
3290 type0 = TREE_TYPE (op0);
3291 type1 = TREE_TYPE (op1);
3293 /* The expression codes of the data types of the arguments tell us
3294 whether the arguments are integers, floating, pointers, etc. */
3295 code0 = TREE_CODE (type0);
3296 code1 = TREE_CODE (type1);
3298 /* If an error was already reported for one of the arguments,
3299 avoid reporting another error. */
3301 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3302 return error_mark_node;
3304 if ((invalid_op_diag
3305 = targetm.invalid_binary_op (code, type0, type1)))
3307 error (invalid_op_diag);
3308 return error_mark_node;
3314 /* Subtraction of two similar pointers.
3315 We must subtract them as integers, then divide by object size. */
3316 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3317 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3319 return pointer_diff (op0, op1, common_type (type0, type1));
3320 /* In all other cases except pointer - int, the usual arithmetic
3322 else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3327 /* The pointer - int case is just like pointer + int; fall
3330 if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3331 && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3335 ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3336 int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3337 if (processing_template_decl)
3339 result_type = TREE_TYPE (ptr_operand);
3342 return cp_pointer_int_sum (code,
3353 case TRUNC_DIV_EXPR:
3355 case FLOOR_DIV_EXPR:
3356 case ROUND_DIV_EXPR:
3357 case EXACT_DIV_EXPR:
3358 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3359 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3360 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3361 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3363 enum tree_code tcode0 = code0, tcode1 = code1;
3365 warn_for_div_by_zero (op1);
3367 if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3368 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3369 if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3370 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3372 if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3373 resultcode = RDIV_EXPR;
3375 /* When dividing two signed integers, we have to promote to int.
3376 unless we divide by a constant != -1. Note that default
3377 conversion will have been performed on the operands at this
3378 point, so we have to dig out the original type to find out if
3380 shorten = ((TREE_CODE (op0) == NOP_EXPR
3381 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3382 || (TREE_CODE (op1) == INTEGER_CST
3383 && ! integer_all_onesp (op1)));
3392 if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3393 || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3394 && !VECTOR_FLOAT_TYPE_P (type0)
3395 && !VECTOR_FLOAT_TYPE_P (type1)))
3399 case TRUNC_MOD_EXPR:
3400 case FLOOR_MOD_EXPR:
3401 warn_for_div_by_zero (op1);
3403 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3405 /* Although it would be tempting to shorten always here, that loses
3406 on some targets, since the modulo instruction is undefined if the
3407 quotient can't be represented in the computation mode. We shorten
3408 only if unsigned or if dividing by something we know != -1. */
3409 shorten = ((TREE_CODE (op0) == NOP_EXPR
3410 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3411 || (TREE_CODE (op1) == INTEGER_CST
3412 && ! integer_all_onesp (op1)));
3417 case TRUTH_ANDIF_EXPR:
3418 case TRUTH_ORIF_EXPR:
3419 case TRUTH_AND_EXPR:
3421 result_type = boolean_type_node;
3424 /* Shift operations: result has same type as first operand;
3425 always convert second operand to int.
3426 Also set SHORT_SHIFT if shifting rightward. */
3429 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3431 result_type = type0;
3432 if (TREE_CODE (op1) == INTEGER_CST)
3434 if (tree_int_cst_lt (op1, integer_zero_node))
3436 if (complain & tf_warning)
3437 warning (0, "right shift count is negative");
3441 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3442 && (complain & tf_warning))
3443 warning (0, "right shift count >= width of type");
3446 /* Convert the shift-count to an integer, regardless of
3447 size of value being shifted. */
3448 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3449 op1 = cp_convert (integer_type_node, op1);
3450 /* Avoid converting op1 to result_type later. */
3456 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3458 result_type = type0;
3459 if (TREE_CODE (op1) == INTEGER_CST)
3461 if (tree_int_cst_lt (op1, integer_zero_node))
3463 if (complain & tf_warning)
3464 warning (0, "left shift count is negative");
3466 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3468 if (complain & tf_warning)
3469 warning (0, "left shift count >= width of type");
3472 /* Convert the shift-count to an integer, regardless of
3473 size of value being shifted. */
3474 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3475 op1 = cp_convert (integer_type_node, op1);
3476 /* Avoid converting op1 to result_type later. */
3483 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3485 result_type = type0;
3486 if (TREE_CODE (op1) == INTEGER_CST)
3488 if (tree_int_cst_lt (op1, integer_zero_node))
3490 if (complain & tf_warning)
3491 warning (0, (code == LROTATE_EXPR)
3492 ? G_("left rotate count is negative")
3493 : G_("right rotate count is negative"));
3495 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3497 if (complain & tf_warning)
3498 warning (0, (code == LROTATE_EXPR)
3499 ? G_("left rotate count >= width of type")
3500 : G_("right rotate count >= width of type"));
3503 /* Convert the shift-count to an integer, regardless of
3504 size of value being shifted. */
3505 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3506 op1 = cp_convert (integer_type_node, op1);
3512 if ((complain & tf_warning)
3513 && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3514 warning (OPT_Wfloat_equal,
3515 "comparing floating point with == or != is unsafe");
3516 if ((complain & tf_warning)
3517 && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3518 || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3519 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3521 build_type = boolean_type_node;
3522 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3523 || code0 == COMPLEX_TYPE)
3524 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3525 || code1 == COMPLEX_TYPE))
3527 else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3528 || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3529 result_type = composite_pointer_type (type0, type1, op0, op1,
3530 "comparison", complain);
3531 else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3532 && null_ptr_cst_p (op1))
3534 if (TREE_CODE (op0) == ADDR_EXPR
3535 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3537 if (complain & tf_warning)
3538 warning (OPT_Waddress, "the address of %qD will never be NULL",
3539 TREE_OPERAND (op0, 0));
3541 result_type = type0;
3543 else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3544 && null_ptr_cst_p (op0))
3546 if (TREE_CODE (op1) == ADDR_EXPR
3547 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3549 if (complain & tf_warning)
3550 warning (OPT_Waddress, "the address of %qD will never be NULL",
3551 TREE_OPERAND (op1, 0));
3553 result_type = type1;
3555 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3557 result_type = type0;
3558 if (complain & tf_error)
3559 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3561 return error_mark_node;
3563 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3565 result_type = type1;
3566 if (complain & tf_error)
3567 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3569 return error_mark_node;
3571 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3573 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3574 == ptrmemfunc_vbit_in_delta)
3576 tree pfn0 = pfn_from_ptrmemfunc (op0);
3577 tree delta0 = delta_from_ptrmemfunc (op0);
3578 tree e1 = cp_build_binary_op (EQ_EXPR,
3580 fold_convert (TREE_TYPE (pfn0),
3583 tree e2 = cp_build_binary_op (BIT_AND_EXPR,
3587 e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node,
3589 op0 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e2,
3591 op1 = cp_convert (TREE_TYPE (op0), integer_one_node);
3595 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3596 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3598 result_type = TREE_TYPE (op0);
3600 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3601 return cp_build_binary_op (code, op1, op0, complain);
3602 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3605 /* E will be the final comparison. */
3607 /* E1 and E2 are for scratch. */
3615 type = composite_pointer_type (type0, type1, op0, op1, "comparison",
3618 if (!same_type_p (TREE_TYPE (op0), type))
3619 op0 = cp_convert_and_check (type, op0);
3620 if (!same_type_p (TREE_TYPE (op1), type))
3621 op1 = cp_convert_and_check (type, op1);
3623 if (op0 == error_mark_node || op1 == error_mark_node)
3624 return error_mark_node;
3626 if (TREE_SIDE_EFFECTS (op0))
3627 op0 = save_expr (op0);
3628 if (TREE_SIDE_EFFECTS (op1))
3629 op1 = save_expr (op1);
3631 pfn0 = pfn_from_ptrmemfunc (op0);
3632 pfn1 = pfn_from_ptrmemfunc (op1);
3633 delta0 = delta_from_ptrmemfunc (op0);
3634 delta1 = delta_from_ptrmemfunc (op1);
3635 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3636 == ptrmemfunc_vbit_in_delta)
3641 && ((op0.delta == op1.delta)
3642 || (!op0.pfn && op0.delta & 1 == 0
3643 && op1.delta & 1 == 0))
3645 The reason for the `!op0.pfn' bit is that a NULL
3646 pointer-to-member is any member with a zero PFN and
3647 LSB of the DELTA field is 0. */
3649 e1 = cp_build_binary_op (BIT_AND_EXPR,
3653 e1 = cp_build_binary_op (EQ_EXPR, e1, integer_zero_node,
3655 e2 = cp_build_binary_op (BIT_AND_EXPR,
3659 e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node,
3661 e1 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1,
3663 e2 = cp_build_binary_op (EQ_EXPR,
3665 fold_convert (TREE_TYPE (pfn0),
3668 e2 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain);
3669 e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain);
3670 e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain);
3677 && (!op0.pfn || op0.delta == op1.delta))
3679 The reason for the `!op0.pfn' bit is that a NULL
3680 pointer-to-member is any member with a zero PFN; the
3681 DELTA field is unspecified. */
3683 e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain);
3684 e2 = cp_build_binary_op (EQ_EXPR,
3686 fold_convert (TREE_TYPE (pfn0),
3689 e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain);
3691 e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3692 e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain);
3693 if (code == EQ_EXPR)
3695 return cp_build_binary_op (EQ_EXPR, e, integer_zero_node, complain);
3699 gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3700 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3702 gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3703 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3711 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3712 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3714 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3715 result_type = composite_pointer_type (type0, type1, op0, op1,
3716 "comparison", complain);
3723 if (TREE_CODE (orig_op0) == STRING_CST
3724 || TREE_CODE (orig_op1) == STRING_CST)
3726 if (complain & tf_warning)
3727 warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3730 build_type = boolean_type_node;
3731 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3732 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3734 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3735 result_type = composite_pointer_type (type0, type1, op0, op1,
3736 "comparison", complain);
3737 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3738 && integer_zerop (op1))
3739 result_type = type0;
3740 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3741 && integer_zerop (op0))
3742 result_type = type1;
3743 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3745 result_type = type0;
3746 if (complain & tf_error)
3747 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3749 return error_mark_node;
3751 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3753 result_type = type1;
3754 if (complain & tf_error)
3755 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3757 return error_mark_node;
3761 case UNORDERED_EXPR:
3768 build_type = integer_type_node;
3769 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3771 if (complain & tf_error)
3772 error ("unordered comparison on non-floating point argument");
3773 return error_mark_node;
3782 if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3783 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3784 || code1 == COMPLEX_TYPE)))
3785 arithmetic_types_p = 1;
3788 arithmetic_types_p = 0;
3789 /* Vector arithmetic is only allowed when both sides are vectors. */
3790 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
3792 if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
3793 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
3796 binary_op_error (code, type0, type1);
3797 return error_mark_node;
3799 arithmetic_types_p = 1;
3802 /* Determine the RESULT_TYPE, if it is not already known. */
3804 && arithmetic_types_p
3805 && (shorten || common || short_compare))
3806 result_type = common_type (type0, type1);
3810 if (complain & tf_error)
3811 error ("invalid operands of types %qT and %qT to binary %qO",
3812 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3813 return error_mark_node;
3816 /* If we're in a template, the only thing we need to know is the
3818 if (processing_template_decl)
3820 /* Since the middle-end checks the type when doing a build2, we
3821 need to build the tree in pieces. This built tree will never
3822 get out of the front-end as we replace it when instantiating
3824 tree tmp = build2 (resultcode,
3825 build_type ? build_type : result_type,
3827 TREE_OPERAND (tmp, 0) = op0;
3831 if (arithmetic_types_p)
3833 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3835 /* For certain operations (which identify themselves by shorten != 0)
3836 if both args were extended from the same smaller type,
3837 do the arithmetic in that type and then extend.
3839 shorten !=0 and !=1 indicates a bitwise operation.
3840 For them, this optimization is safe only if
3841 both args are zero-extended or both are sign-extended.
3842 Otherwise, we might change the result.
3843 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3844 but calculated in (unsigned short) it would be (unsigned short)-1. */
3846 if (shorten && none_complex)
3848 int unsigned0, unsigned1;
3849 tree arg0 = get_narrower (op0, &unsigned0);
3850 tree arg1 = get_narrower (op1, &unsigned1);
3851 /* UNS is 1 if the operation to be done is an unsigned one. */
3852 int uns = TYPE_UNSIGNED (result_type);
3855 final_type = result_type;
3857 /* Handle the case that OP0 does not *contain* a conversion
3858 but it *requires* conversion to FINAL_TYPE. */
3860 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3861 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3862 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3863 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3865 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3867 /* For bitwise operations, signedness of nominal type
3868 does not matter. Consider only how operands were extended. */
3872 /* Note that in all three cases below we refrain from optimizing
3873 an unsigned operation on sign-extended args.
3874 That would not be valid. */
3876 /* Both args variable: if both extended in same way
3877 from same width, do it in that width.
3878 Do it unsigned if args were zero-extended. */
3879 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3880 < TYPE_PRECISION (result_type))
3881 && (TYPE_PRECISION (TREE_TYPE (arg1))
3882 == TYPE_PRECISION (TREE_TYPE (arg0)))
3883 && unsigned0 == unsigned1
3884 && (unsigned0 || !uns))
3885 result_type = c_common_signed_or_unsigned_type
3886 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3887 else if (TREE_CODE (arg0) == INTEGER_CST
3888 && (unsigned1 || !uns)
3889 && (TYPE_PRECISION (TREE_TYPE (arg1))
3890 < TYPE_PRECISION (result_type))
3891 && (type = c_common_signed_or_unsigned_type
3892 (unsigned1, TREE_TYPE (arg1)),
3893 int_fits_type_p (arg0, type)))
3895 else if (TREE_CODE (arg1) == INTEGER_CST
3896 && (unsigned0 || !uns)
3897 && (TYPE_PRECISION (TREE_TYPE (arg0))
3898 < TYPE_PRECISION (result_type))
3899 && (type = c_common_signed_or_unsigned_type
3900 (unsigned0, TREE_TYPE (arg0)),
3901 int_fits_type_p (arg1, type)))
3905 /* Comparison operations are shortened too but differently.
3906 They identify themselves by setting short_compare = 1. */
3910 /* Don't write &op0, etc., because that would prevent op0
3911 from being kept in a register.
3912 Instead, make copies of the our local variables and
3913 pass the copies by reference, then copy them back afterward. */
3914 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3915 enum tree_code xresultcode = resultcode;
3917 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3919 return cp_convert (boolean_type_node, val);
3920 op0 = xop0, op1 = xop1;
3922 resultcode = xresultcode;
3925 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3926 && warn_sign_compare
3927 /* Do not warn until the template is instantiated; we cannot
3928 bound the ranges of the arguments until that point. */
3929 && !processing_template_decl)
3931 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
3932 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3934 int unsignedp0, unsignedp1;
3935 tree primop0 = get_narrower (op0, &unsignedp0);
3936 tree primop1 = get_narrower (op1, &unsignedp1);
3938 /* Check for comparison of different enum types. */
3939 if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3940 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3941 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3942 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))
3943 && (complain & tf_warning))
3945 warning (OPT_Wsign_compare, "comparison between types %q#T and %q#T",
3946 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3949 /* Give warnings for comparisons between signed and unsigned
3950 quantities that may fail. */
3951 /* Do the checking based on the original operand trees, so that
3952 casts will be considered, but default promotions won't be. */
3954 /* Do not warn if the comparison is being done in a signed type,
3955 since the signed type will only be chosen if it can represent
3956 all the values of the unsigned type. */
3957 if (!TYPE_UNSIGNED (result_type))
3959 /* Do not warn if both operands are unsigned. */
3960 else if (op0_signed == op1_signed)
3962 /* Do not warn if the signed quantity is an unsuffixed
3963 integer literal (or some static constant expression
3964 involving such literals or a conditional expression
3965 involving such literals) and it is non-negative. */
3966 else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3967 || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3969 /* Do not warn if the comparison is an equality operation,
3970 the unsigned quantity is an integral constant and it does
3971 not use the most significant bit of result_type. */
3972 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3973 && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3974 && int_fits_type_p (orig_op1, c_common_signed_type
3976 || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3977 && int_fits_type_p (orig_op0, c_common_signed_type
3980 else if (complain & tf_warning)
3981 warning (OPT_Wsign_compare,
3982 "comparison between signed and unsigned integer expressions");
3984 /* Warn if two unsigned values are being compared in a size
3985 larger than their original size, and one (and only one) is the
3986 result of a `~' operator. This comparison will always fail.
3988 Also warn if one operand is a constant, and the constant does not
3989 have all bits set that are set in the ~ operand when it is
3992 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3993 ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3995 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3996 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3997 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3998 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
4000 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
4003 HOST_WIDE_INT constant, mask;
4007 if (host_integerp (primop0, 0))
4010 unsignedp = unsignedp1;
4011 constant = tree_low_cst (primop0, 0);
4016 unsignedp = unsignedp0;
4017 constant = tree_low_cst (primop1, 0);
4020 bits = TYPE_PRECISION (TREE_TYPE (primop));
4021 if (bits < TYPE_PRECISION (result_type)
4022 && bits < HOST_BITS_PER_LONG && unsignedp)
4024 mask = (~ (HOST_WIDE_INT) 0) << bits;
4025 if ((mask & constant) != mask
4026 && (complain & tf_warning))
4027 warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with constant");
4030 else if (unsignedp0 && unsignedp1
4031 && (TYPE_PRECISION (TREE_TYPE (primop0))
4032 < TYPE_PRECISION (result_type))
4033 && (TYPE_PRECISION (TREE_TYPE (primop1))
4034 < TYPE_PRECISION (result_type))
4035 && (complain & tf_warning))
4036 warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with unsigned");
4041 /* Issue warnings about peculiar, but valid, uses of NULL. */
4042 if ((orig_op0 == null_node || orig_op1 == null_node)
4043 /* It's reasonable to use pointer values as operands of &&
4044 and ||, so NULL is no exception. */
4045 && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR
4046 && ( /* Both are NULL (or 0) and the operation was not a comparison. */
4047 (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1)
4048 && code != EQ_EXPR && code != NE_EXPR)
4049 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
4050 || (!null_ptr_cst_p (orig_op0) && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
4051 || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE))
4052 && (complain & tf_warning))
4053 /* Some sort of arithmetic operation involving NULL was
4054 performed. Note that pointer-difference and pointer-addition
4055 have already been handled above, and so we don't end up here in
4057 warning (OPT_Wpointer_arith, "NULL used in arithmetic");
4060 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4061 Then the expression will be built.
4062 It will be given type FINAL_TYPE if that is nonzero;
4063 otherwise, it will be given type RESULT_TYPE. */
4066 if (TREE_TYPE (op0) != result_type)
4067 op0 = cp_convert_and_check (result_type, op0);
4068 if (TREE_TYPE (op1) != result_type)
4069 op1 = cp_convert_and_check (result_type, op1);
4071 if (op0 == error_mark_node || op1 == error_mark_node)
4072 return error_mark_node;
4075 if (build_type == NULL_TREE)
4076 build_type = result_type;
4078 result = build2 (resultcode, build_type, op0, op1);
4079 result = fold_if_not_in_template (result);
4080 if (final_type != 0)
4081 result = cp_convert (final_type, result);
4083 if (TREE_OVERFLOW_P (result)
4084 && !TREE_OVERFLOW_P (op0)
4085 && !TREE_OVERFLOW_P (op1))
4086 overflow_warning (result);
4091 /* Return a tree for the sum or difference (RESULTCODE says which)
4092 of pointer PTROP and integer INTOP. */
4095 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
4097 tree res_type = TREE_TYPE (ptrop);
4099 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
4100 in certain circumstance (when it's valid to do so). So we need
4101 to make sure it's complete. We don't need to check here, if we
4102 can actually complete it at all, as those checks will be done in
4103 pointer_int_sum() anyway. */
4104 complete_type (TREE_TYPE (res_type));
4106 return pointer_int_sum (resultcode, ptrop,
4107 fold_if_not_in_template (intop));
4110 /* Return a tree for the difference of pointers OP0 and OP1.
4111 The resulting tree has type int. */
4114 pointer_diff (tree op0, tree op1, tree ptrtype)
4117 tree restype = ptrdiff_type_node;
4118 tree target_type = TREE_TYPE (ptrtype);
4120 if (!complete_type_or_else (target_type, NULL_TREE))
4121 return error_mark_node;
4123 if (pedantic || warn_pointer_arith)
4125 if (TREE_CODE (target_type) == VOID_TYPE)
4126 pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
4127 if (TREE_CODE (target_type) == FUNCTION_TYPE)
4128 pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
4129 if (TREE_CODE (target_type) == METHOD_TYPE)
4130 pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
4133 /* First do the subtraction as integers;
4134 then drop through to build the divide operator. */
4136 op0 = cp_build_binary_op (MINUS_EXPR,
4137 cp_convert (restype, op0),
4138 cp_convert (restype, op1),
4139 tf_warning_or_error);
4141 /* This generates an error if op1 is a pointer to an incomplete type. */
4142 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
4143 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4145 op1 = (TYPE_PTROB_P (ptrtype)
4146 ? size_in_bytes (target_type)
4147 : integer_one_node);
4149 /* Do the division. */
4151 result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4152 return fold_if_not_in_template (result);
4155 /* Construct and perhaps optimize a tree representation
4156 for a unary operation. CODE, a tree_code, specifies the operation
4157 and XARG is the operand. */
4160 build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain)
4162 tree orig_expr = xarg;
4166 if (processing_template_decl)
4168 if (type_dependent_expression_p (xarg))
4169 return build_min_nt (code, xarg, NULL_TREE);
4171 xarg = build_non_dependent_expr (xarg);
4176 /* [expr.unary.op] says:
4178 The address of an object of incomplete type can be taken.
4180 (And is just the ordinary address operator, not an overloaded
4181 "operator &".) However, if the type is a template
4182 specialization, we must complete the type at this point so that
4183 an overloaded "operator &" will be available if required. */
4184 if (code == ADDR_EXPR
4185 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4186 && ((CLASS_TYPE_P (TREE_TYPE (xarg))
4187 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
4188 || (TREE_CODE (xarg) == OFFSET_REF)))
4189 /* Don't look for a function. */;
4191 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
4192 /*overloaded_p=*/NULL, complain);
4193 if (!exp && code == ADDR_EXPR)
4195 /* A pointer to member-function can be formed only by saying
4197 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4198 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4200 if (TREE_CODE (xarg) != OFFSET_REF
4201 || !TYPE_P (TREE_OPERAND (xarg, 0)))
4203 error ("invalid use of %qE to form a pointer-to-member-function",
4205 if (TREE_CODE (xarg) != OFFSET_REF)
4206 inform (" a qualified-id is required");
4207 return error_mark_node;
4211 error ("parentheses around %qE cannot be used to form a"
4212 " pointer-to-member-function",
4214 PTRMEM_OK_P (xarg) = 1;
4218 if (TREE_CODE (xarg) == OFFSET_REF)
4220 ptrmem = PTRMEM_OK_P (xarg);
4222 if (!ptrmem && !flag_ms_extensions
4223 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4225 /* A single non-static member, make sure we don't allow a
4226 pointer-to-member. */
4227 xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
4228 TREE_OPERAND (xarg, 0),
4229 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4230 PTRMEM_OK_P (xarg) = ptrmem;
4233 else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning))
4234 warning (0, "taking address of temporary");
4235 exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain);
4238 if (processing_template_decl && exp != error_mark_node)
4239 exp = build_min_non_dep (code, exp, orig_expr,
4240 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
4241 if (TREE_CODE (exp) == ADDR_EXPR)
4242 PTRMEM_OK_P (exp) = ptrmem;
4246 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4247 constants, where a null value is represented by an INTEGER_CST of
4251 cp_truthvalue_conversion (tree expr)
4253 tree type = TREE_TYPE (expr);
4254 if (TYPE_PTRMEM_P (type))
4255 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
4257 return c_common_truthvalue_conversion (expr);
4260 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4263 condition_conversion (tree expr)
4266 if (processing_template_decl)
4268 t = perform_implicit_conversion (boolean_type_node, expr,
4269 tf_warning_or_error);
4270 t = fold_build_cleanup_point_expr (boolean_type_node, t);
4274 /* Return an ADDR_EXPR giving the address of T. This function
4275 attempts no optimizations or simplifications; it is a low-level
4279 build_address (tree t)
4283 if (error_operand_p (t) || !cxx_mark_addressable (t))
4284 return error_mark_node;
4286 addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
4291 /* Return a NOP_EXPR converting EXPR to TYPE. */
4294 build_nop (tree type, tree expr)
4296 if (type == error_mark_node || error_operand_p (expr))
4298 return build1 (NOP_EXPR, type, expr);
4301 /* C++: Must handle pointers to members.
4303 Perhaps type instantiation should be extended to handle conversion
4304 from aggregates to types we don't yet know we want? (Or are those
4305 cases typically errors which should be reported?)
4307 NOCONVERT nonzero suppresses the default promotions
4308 (such as from short to int). */
4311 cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
4312 tsubst_flags_t complain)
4314 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4317 const char *errstring = NULL;
4319 const char *invalid_op_diag;
4321 if (arg == error_mark_node)
4322 return error_mark_node;
4324 if ((invalid_op_diag
4325 = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
4330 error (invalid_op_diag);
4331 return error_mark_node;
4336 case UNARY_PLUS_EXPR:
4339 int flags = WANT_ARITH | WANT_ENUM;
4340 /* Unary plus (but not unary minus) is allowed on pointers. */
4341 if (code == UNARY_PLUS_EXPR)
4342 flags |= WANT_POINTER;
4343 arg = build_expr_type_conversion (flags, arg, true);
4345 errstring = (code == NEGATE_EXPR
4346 ? "wrong type argument to unary minus"
4347 : "wrong type argument to unary plus");
4350 if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4351 arg = perform_integral_promotions (arg);
4353 /* Make sure the result is not an lvalue: a unary plus or minus
4354 expression is always a rvalue. */
4361 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4365 arg = default_conversion (arg);
4367 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
4370 errstring = "wrong type argument to bit-complement";
4371 else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4372 arg = perform_integral_promotions (arg);
4376 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4377 errstring = "wrong type argument to abs";
4378 else if (!noconvert)
4379 arg = default_conversion (arg);
4383 /* Conjugating a real value is a no-op, but allow it anyway. */
4384 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4385 errstring = "wrong type argument to conjugation";
4386 else if (!noconvert)
4387 arg = default_conversion (arg);
4390 case TRUTH_NOT_EXPR:
4391 arg = perform_implicit_conversion (boolean_type_node, arg,
4393 val = invert_truthvalue (arg);
4394 if (arg != error_mark_node)
4396 errstring = "in argument to unary !";
4403 if (TREE_CODE (arg) == COMPLEX_CST)
4404 return TREE_REALPART (arg);
4405 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4407 arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4408 return fold_if_not_in_template (arg);
4414 if (TREE_CODE (arg) == COMPLEX_CST)
4415 return TREE_IMAGPART (arg);
4416 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4418 arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4419 return fold_if_not_in_template (arg);
4422 return cp_convert (TREE_TYPE (arg), integer_zero_node);
4424 case PREINCREMENT_EXPR:
4425 case POSTINCREMENT_EXPR:
4426 case PREDECREMENT_EXPR:
4427 case POSTDECREMENT_EXPR:
4428 /* Handle complex lvalues (when permitted)
4429 by reduction to simpler cases. */
4431 val = unary_complex_lvalue (code, arg);
4435 /* Increment or decrement the real part of the value,
4436 and don't change the imaginary part. */
4437 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4441 arg = stabilize_reference (arg);
4442 real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain);
4443 imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain);
4444 real = cp_build_unary_op (code, real, 1, complain);
4445 if (real == error_mark_node || imag == error_mark_node)
4446 return error_mark_node;
4447 return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4451 /* Report invalid types. */
4453 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4456 if (code == PREINCREMENT_EXPR)
4457 errstring ="no pre-increment operator for type";
4458 else if (code == POSTINCREMENT_EXPR)
4459 errstring ="no post-increment operator for type";
4460 else if (code == PREDECREMENT_EXPR)
4461 errstring ="no pre-decrement operator for type";
4463 errstring ="no post-decrement operator for type";
4466 else if (arg == error_mark_node)
4467 return error_mark_node;
4469 /* Report something read-only. */
4471 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4472 || TREE_READONLY (arg))
4474 if (complain & tf_error)
4475 readonly_error (arg, ((code == PREINCREMENT_EXPR
4476 || code == POSTINCREMENT_EXPR)
4477 ? "increment" : "decrement"));
4479 return error_mark_node;
4485 tree result_type = TREE_TYPE (arg);
4487 declared_type = unlowered_expr_type (arg);
4489 arg = get_unwidened (arg, 0);
4490 argtype = TREE_TYPE (arg);
4492 /* ARM $5.2.5 last annotation says this should be forbidden. */
4493 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4495 if (complain & tf_error)
4496 pedwarn ((code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4497 ? G_("ISO C++ forbids incrementing an enum")
4498 : G_("ISO C++ forbids decrementing an enum"));
4500 return error_mark_node;
4503 /* Compute the increment. */
4505 if (TREE_CODE (argtype) == POINTER_TYPE)
4507 tree type = complete_type (TREE_TYPE (argtype));
4509 if (!COMPLETE_OR_VOID_TYPE_P (type))
4511 if (complain & tf_error)
4512 error (((code == PREINCREMENT_EXPR
4513 || code == POSTINCREMENT_EXPR))
4514 ? G_("cannot increment a pointer to incomplete type %qT")
4515 : G_("cannot decrement a pointer to incomplete type %qT"),
4516 TREE_TYPE (argtype));
4518 return error_mark_node;
4520 else if ((pedantic || warn_pointer_arith)
4521 && !TYPE_PTROB_P (argtype))
4523 if (complain & tf_error)
4524 pedwarn ((code == PREINCREMENT_EXPR
4525 || code == POSTINCREMENT_EXPR)
4526 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4527 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4530 return error_mark_node;
4533 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4536 inc = integer_one_node;
4538 inc = cp_convert (argtype, inc);
4540 /* Complain about anything else that is not a true lvalue. */
4541 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4542 || code == POSTINCREMENT_EXPR)
4543 ? lv_increment : lv_decrement),
4545 return error_mark_node;
4547 /* Forbid using -- on `bool'. */
4548 if (same_type_p (declared_type, boolean_type_node))
4550 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4552 if (complain & tf_error)
4553 error ("invalid use of Boolean expression as operand "
4554 "to %<operator--%>");
4555 return error_mark_node;
4557 val = boolean_increment (code, arg);
4560 val = build2 (code, TREE_TYPE (arg), arg, inc);
4562 TREE_SIDE_EFFECTS (val) = 1;
4563 return cp_convert (result_type, val);
4567 /* Note that this operation never does default_conversion
4568 regardless of NOCONVERT. */
4570 argtype = lvalue_type (arg);
4572 if (TREE_CODE (arg) == OFFSET_REF)
4575 if (TREE_CODE (argtype) == REFERENCE_TYPE)
4577 tree type = build_pointer_type (TREE_TYPE (argtype));
4578 arg = build1 (CONVERT_EXPR, type, arg);
4581 else if (pedantic && DECL_MAIN_P (arg))
4584 if (complain & tf_error)
4585 pedwarn ("ISO C++ forbids taking address of function %<::main%>");
4587 return error_mark_node;
4590 /* Let &* cancel out to simplify resulting code. */
4591 if (TREE_CODE (arg) == INDIRECT_REF)
4593 /* We don't need to have `current_class_ptr' wrapped in a
4594 NON_LVALUE_EXPR node. */
4595 if (arg == current_class_ref)
4596 return current_class_ptr;
4598 arg = TREE_OPERAND (arg, 0);
4599 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4601 tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4602 arg = build1 (CONVERT_EXPR, type, arg);
4605 /* Don't let this be an lvalue. */
4610 /* Uninstantiated types are all functions. Taking the
4611 address of a function is a no-op, so just return the
4614 gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4615 || !IDENTIFIER_OPNAME_P (arg));
4617 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4618 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4620 /* They're trying to take the address of a unique non-static
4621 member function. This is ill-formed (except in MS-land),
4622 but let's try to DTRT.
4623 Note: We only handle unique functions here because we don't
4624 want to complain if there's a static overload; non-unique
4625 cases will be handled by instantiate_type. But we need to
4626 handle this case here to allow casts on the resulting PMF.
4627 We could defer this in non-MS mode, but it's easier to give
4628 a useful error here. */
4630 /* Inside constant member functions, the `this' pointer
4631 contains an extra const qualifier. TYPE_MAIN_VARIANT
4632 is used here to remove this const from the diagnostics
4633 and the created OFFSET_REF. */
4634 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4635 tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4638 if (! flag_ms_extensions)
4640 tree name = DECL_NAME (fn);
4641 if (!(complain & tf_error))
4642 return error_mark_node;
4643 else if (current_class_type
4644 && TREE_OPERAND (arg, 0) == current_class_ref)
4645 /* An expression like &memfn. */
4646 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4647 " or parenthesized non-static member function to form"
4648 " a pointer to member function. Say %<&%T::%D%>",
4651 pedwarn ("ISO C++ forbids taking the address of a bound member"
4652 " function to form a pointer to member function."
4656 arg = build_offset_ref (base, fn, /*address_p=*/true);
4660 if (type_unknown_p (arg))
4661 return build1 (ADDR_EXPR, unknown_type_node, arg);
4663 /* Handle complex lvalues (when permitted)
4664 by reduction to simpler cases. */
4665 val = unary_complex_lvalue (code, arg);
4669 switch (TREE_CODE (arg))
4674 case FIX_TRUNC_EXPR:
4675 /* Even if we're not being pedantic, we cannot allow this
4676 extension when we're instantiating in a SFINAE
4678 if (! lvalue_p (arg) && (pedantic || complain == tf_none))
4680 if (complain & tf_error)
4681 pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4683 return error_mark_node;
4688 arg = BASELINK_FUNCTIONS (arg);
4692 arg = OVL_CURRENT (arg);
4696 /* Turn a reference to a non-static data member into a
4697 pointer-to-member. */
4702 if (!PTRMEM_OK_P (arg))
4703 return cp_build_unary_op (code, arg, 0, complain);
4705 t = TREE_OPERAND (arg, 1);
4706 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4708 if (complain & tf_error)
4709 error ("cannot create pointer to reference member %qD", t);
4710 return error_mark_node;
4713 type = build_ptrmem_type (context_for_name_lookup (t),
4715 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4723 /* Anything not already handled and not a true memory reference
4725 if (TREE_CODE (argtype) != FUNCTION_TYPE
4726 && TREE_CODE (argtype) != METHOD_TYPE
4727 && TREE_CODE (arg) != OFFSET_REF
4728 && !lvalue_or_else (arg, lv_addressof, complain))
4729 return error_mark_node;
4731 if (argtype != error_mark_node)
4732 argtype = build_pointer_type (argtype);
4734 /* In a template, we are processing a non-dependent expression
4735 so we can just form an ADDR_EXPR with the correct type. */
4736 if (processing_template_decl)
4738 val = build_address (arg);
4739 if (TREE_CODE (arg) == OFFSET_REF)
4740 PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4744 if (TREE_CODE (arg) != COMPONENT_REF)
4746 val = build_address (arg);
4747 if (TREE_CODE (arg) == OFFSET_REF)
4748 PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4750 else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4752 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4754 /* We can only get here with a single static member
4756 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4757 && DECL_STATIC_FUNCTION_P (fn));
4759 val = build_address (fn);
4760 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4761 /* Do not lose object's side effects. */
4762 val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4763 TREE_OPERAND (arg, 0), val);
4765 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4767 if (complain & tf_error)
4768 error ("attempt to take address of bit-field structure member %qD",
4769 TREE_OPERAND (arg, 1));
4770 return error_mark_node;
4774 tree object = TREE_OPERAND (arg, 0);
4775 tree field = TREE_OPERAND (arg, 1);
4776 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4777 (TREE_TYPE (object), decl_type_context (field)));
4778 val = build_address (arg);
4781 if (TREE_CODE (argtype) == POINTER_TYPE
4782 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4784 build_ptrmemfunc_type (argtype);
4785 val = build_ptrmemfunc (argtype, val, 0,
4786 /*c_cast_p=*/false);
4798 argtype = TREE_TYPE (arg);
4799 return fold_if_not_in_template (build1 (code, argtype, arg));
4802 if (complain & tf_error)
4803 error ("%s", errstring);
4804 return error_mark_node;
4807 /* Hook for the c-common bits that build a unary op. */
4809 build_unary_op (enum tree_code code, tree xarg, int noconvert)
4811 return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
4814 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4815 for certain kinds of expressions which are not really lvalues
4816 but which we can accept as lvalues.
4818 If ARG is not a kind of expression we can handle, return
4822 unary_complex_lvalue (enum tree_code code, tree arg)
4824 /* Inside a template, making these kinds of adjustments is
4825 pointless; we are only concerned with the type of the
4827 if (processing_template_decl)
4830 /* Handle (a, b) used as an "lvalue". */
4831 if (TREE_CODE (arg) == COMPOUND_EXPR)
4833 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0,
4834 tf_warning_or_error);
4835 return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4836 TREE_OPERAND (arg, 0), real_result);
4839 /* Handle (a ? b : c) used as an "lvalue". */
4840 if (TREE_CODE (arg) == COND_EXPR
4841 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4842 return rationalize_conditional_expr (code, arg, tf_warning_or_error);
4844 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4845 if (TREE_CODE (arg) == MODIFY_EXPR
4846 || TREE_CODE (arg) == PREINCREMENT_EXPR
4847 || TREE_CODE (arg) == PREDECREMENT_EXPR)
4849 tree lvalue = TREE_OPERAND (arg, 0);
4850 if (TREE_SIDE_EFFECTS (lvalue))
4852 lvalue = stabilize_reference (lvalue);
4853 arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4854 lvalue, TREE_OPERAND (arg, 1));
4856 return unary_complex_lvalue
4857 (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4860 if (code != ADDR_EXPR)
4863 /* Handle (a = b) used as an "lvalue" for `&'. */
4864 if (TREE_CODE (arg) == MODIFY_EXPR
4865 || TREE_CODE (arg) == INIT_EXPR)
4867 tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0,
4868 tf_warning_or_error);
4869 arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4871 TREE_NO_WARNING (arg) = 1;
4875 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4876 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4877 || TREE_CODE (arg) == OFFSET_REF)
4880 /* We permit compiler to make function calls returning
4881 objects of aggregate type look like lvalues. */
4885 if (TREE_CODE (targ) == SAVE_EXPR)
4886 targ = TREE_OPERAND (targ, 0);
4888 if (TREE_CODE (targ) == CALL_EXPR && MAYBE_CLASS_TYPE_P (TREE_TYPE (targ)))
4890 if (TREE_CODE (arg) == SAVE_EXPR)
4893 targ = build_cplus_new (TREE_TYPE (arg), arg);
4894 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4897 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4898 return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4899 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4902 /* Don't let anything else be handled specially. */
4906 /* Mark EXP saying that we need to be able to take the
4907 address of it; it should not be allocated in a register.
4908 Value is true if successful.
4910 C++: we do not allow `current_class_ptr' to be addressable. */
4913 cxx_mark_addressable (tree exp)
4918 switch (TREE_CODE (x))
4925 x = TREE_OPERAND (x, 0);
4929 if (x == current_class_ptr)
4931 error ("cannot take the address of %<this%>, which is an rvalue expression");
4932 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
4938 /* Caller should not be trying to mark initialized
4939 constant fields addressable. */
4940 gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4941 || DECL_IN_AGGR_P (x) == 0
4943 || DECL_EXTERNAL (x));
4948 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4949 && !DECL_ARTIFICIAL (x))
4951 if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
4954 ("address of explicit register variable %qD requested", x);
4957 else if (extra_warnings)
4959 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
4961 TREE_ADDRESSABLE (x) = 1;
4965 TREE_ADDRESSABLE (x) = 1;
4969 TREE_ADDRESSABLE (x) = 1;
4973 TREE_ADDRESSABLE (x) = 1;
4974 cxx_mark_addressable (TREE_OPERAND (x, 0));
4982 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4985 build_x_conditional_expr (tree ifexp, tree op1, tree op2,
4986 tsubst_flags_t complain)
4988 tree orig_ifexp = ifexp;
4989 tree orig_op1 = op1;
4990 tree orig_op2 = op2;
4993 if (processing_template_decl)
4995 /* The standard says that the expression is type-dependent if
4996 IFEXP is type-dependent, even though the eventual type of the
4997 expression doesn't dependent on IFEXP. */
4998 if (type_dependent_expression_p (ifexp)
4999 /* As a GNU extension, the middle operand may be omitted. */
5000 || (op1 && type_dependent_expression_p (op1))
5001 || type_dependent_expression_p (op2))
5002 return build_min_nt (COND_EXPR, ifexp, op1, op2);
5003 ifexp = build_non_dependent_expr (ifexp);
5005 op1 = build_non_dependent_expr (op1);
5006 op2 = build_non_dependent_expr (op2);
5009 expr = build_conditional_expr (ifexp, op1, op2, complain);
5010 if (processing_template_decl && expr != error_mark_node)
5011 return build_min_non_dep (COND_EXPR, expr,
5012 orig_ifexp, orig_op1, orig_op2);
5016 /* Given a list of expressions, return a compound expression
5017 that performs them all and returns the value of the last of them. */
5019 tree build_x_compound_expr_from_list (tree list, const char *msg)
5021 tree expr = TREE_VALUE (list);
5023 if (TREE_CHAIN (list))
5026 pedwarn ("%s expression list treated as compound expression", msg);
5028 for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
5029 expr = build_x_compound_expr (expr, TREE_VALUE (list),
5030 tf_warning_or_error);
5036 /* Handle overloading of the ',' operator when needed. */
5039 build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain)
5042 tree orig_op1 = op1;
5043 tree orig_op2 = op2;
5045 if (processing_template_decl)
5047 if (type_dependent_expression_p (op1)
5048 || type_dependent_expression_p (op2))
5049 return build_min_nt (COMPOUND_EXPR, op1, op2);
5050 op1 = build_non_dependent_expr (op1);
5051 op2 = build_non_dependent_expr (op2);
5054 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
5055 /*overloaded_p=*/NULL, complain);
5057 result = cp_build_compound_expr (op1, op2, complain);
5059 if (processing_template_decl && result != error_mark_node)
5060 return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
5065 /* Like cp_build_compound_expr, but for the c-common bits. */
5068 build_compound_expr (tree lhs, tree rhs)
5070 return cp_build_compound_expr (lhs, rhs, tf_warning_or_error);
5073 /* Build a compound expression. */
5076 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
5078 lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
5080 if (lhs == error_mark_node || rhs == error_mark_node)
5081 return error_mark_node;
5083 if (TREE_CODE (rhs) == TARGET_EXPR)
5085 /* If the rhs is a TARGET_EXPR, then build the compound
5086 expression inside the target_expr's initializer. This
5087 helps the compiler to eliminate unnecessary temporaries. */
5088 tree init = TREE_OPERAND (rhs, 1);
5090 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
5091 TREE_OPERAND (rhs, 1) = init;
5096 return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
5099 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
5100 casts away constness. CAST gives the type of cast. */
5103 check_for_casting_away_constness (tree src_type, tree dest_type,
5104 enum tree_code cast)
5106 /* C-style casts are allowed to cast away constness. With
5107 WARN_CAST_QUAL, we still want to issue a warning. */
5108 if (cast == CAST_EXPR && !warn_cast_qual)
5111 if (casts_away_constness (src_type, dest_type))
5115 warning (OPT_Wcast_qual,
5116 "cast from type %qT to type %qT casts away constness",
5117 src_type, dest_type);
5120 case STATIC_CAST_EXPR:
5121 error ("static_cast from type %qT to type %qT casts away constness",
5122 src_type, dest_type);
5125 case REINTERPRET_CAST_EXPR:
5126 error ("reinterpret_cast from type %qT to type %qT casts away constness",
5127 src_type, dest_type);
5134 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
5135 (another pointer-to-member type in the same hierarchy) and return
5136 the converted expression. If ALLOW_INVERSE_P is permitted, a
5137 pointer-to-derived may be converted to pointer-to-base; otherwise,
5138 only the other direction is permitted. If C_CAST_P is true, this
5139 conversion is taking place as part of a C-style cast. */
5142 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
5145 if (TYPE_PTRMEM_P (type))
5149 if (TREE_CODE (expr) == PTRMEM_CST)
5150 expr = cplus_expand_constant (expr);
5151 delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
5152 TYPE_PTRMEM_CLASS_TYPE (type),
5155 if (!integer_zerop (delta))
5157 tree cond, op1, op2;
5159 cond = cp_build_binary_op (EQ_EXPR,
5161 build_int_cst (TREE_TYPE (expr), -1),
5162 tf_warning_or_error);
5163 op1 = build_nop (ptrdiff_type_node, expr);
5164 op2 = cp_build_binary_op (PLUS_EXPR, op1, delta,
5165 tf_warning_or_error);
5167 expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2);
5171 return build_nop (type, expr);
5174 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
5175 allow_inverse_p, c_cast_p);
5178 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5179 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5180 Otherwise, return EXPR unchanged. */
5183 ignore_overflows (tree expr, tree orig)
5185 if (TREE_CODE (expr) == INTEGER_CST
5186 && CONSTANT_CLASS_P (orig)
5187 && TREE_CODE (orig) != STRING_CST
5188 && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
5190 if (!TREE_OVERFLOW (orig))
5191 /* Ensure constant sharing. */
5192 expr = build_int_cst_wide (TREE_TYPE (expr),
5193 TREE_INT_CST_LOW (expr),
5194 TREE_INT_CST_HIGH (expr));
5197 /* Avoid clobbering a shared constant. */
5198 expr = copy_node (expr);
5199 TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
5205 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
5206 this static_cast is being attempted as one of the possible casts
5207 allowed by a C-style cast. (In that case, accessibility of base
5208 classes is not considered, and it is OK to cast away
5209 constness.) Return the result of the cast. *VALID_P is set to
5210 indicate whether or not the cast was valid. */
5213 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
5214 bool *valid_p, tsubst_flags_t complain)
5220 /* Assume the cast is valid. */
5223 intype = TREE_TYPE (expr);
5225 /* Save casted types in the function's used types hash table. */
5226 used_types_insert (type);
5228 /* [expr.static.cast]
5230 An lvalue of type "cv1 B", where B is a class type, can be cast
5231 to type "reference to cv2 D", where D is a class derived (clause
5232 _class.derived_) from B, if a valid standard conversion from
5233 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5234 same cv-qualification as, or greater cv-qualification than, cv1,
5235 and B is not a virtual base class of D. */
5236 /* We check this case before checking the validity of "TYPE t =
5237 EXPR;" below because for this case:
5240 struct D : public B { D(const B&); };
5242 void f() { static_cast<const D&>(b); }
5244 we want to avoid constructing a new D. The standard is not
5245 completely clear about this issue, but our interpretation is
5246 consistent with other compilers. */
5247 if (TREE_CODE (type) == REFERENCE_TYPE
5248 && CLASS_TYPE_P (TREE_TYPE (type))
5249 && CLASS_TYPE_P (intype)
5250 && real_lvalue_p (expr)
5251 && DERIVED_FROM_P (intype, TREE_TYPE (type))
5252 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
5253 build_pointer_type (TYPE_MAIN_VARIANT
5254 (TREE_TYPE (type))))
5256 || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5260 /* There is a standard conversion from "D*" to "B*" even if "B"
5261 is ambiguous or inaccessible. If this is really a
5262 static_cast, then we check both for inaccessibility and
5263 ambiguity. However, if this is a static_cast being performed
5264 because the user wrote a C-style cast, then accessibility is
5266 base = lookup_base (TREE_TYPE (type), intype,
5267 c_cast_p ? ba_unique : ba_check,
5270 /* Convert from "B*" to "D*". This function will check that "B"
5271 is not a virtual base of "D". */
5272 expr = build_base_path (MINUS_EXPR, build_address (expr),
5273 base, /*nonnull=*/false);
5274 /* Convert the pointer to a reference -- but then remember that
5275 there are no expressions with reference type in C++. */
5276 return convert_from_reference (build_nop (type, expr));
5281 /* [expr.static.cast]
5283 An expression e can be explicitly converted to a type T using a
5284 static_cast of the form static_cast<T>(e) if the declaration T
5285 t(e);" is well-formed, for some invented temporary variable
5287 result = perform_direct_initialization_if_possible (type, expr,
5288 c_cast_p, complain);
5291 result = convert_from_reference (result);
5293 /* Ignore any integer overflow caused by the cast. */
5294 result = ignore_overflows (result, orig);
5296 /* [expr.static.cast]
5298 If T is a reference type, the result is an lvalue; otherwise,
5299 the result is an rvalue. */
5300 if (TREE_CODE (type) != REFERENCE_TYPE)
5301 result = rvalue (result);
5305 /* [expr.static.cast]
5307 Any expression can be explicitly converted to type cv void. */
5308 if (TREE_CODE (type) == VOID_TYPE)
5309 return convert_to_void (expr, /*implicit=*/NULL, complain);
5311 /* [expr.static.cast]
5313 The inverse of any standard conversion sequence (clause _conv_),
5314 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5315 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5316 (_conv.bool_) conversions, can be performed explicitly using
5317 static_cast subject to the restriction that the explicit
5318 conversion does not cast away constness (_expr.const.cast_), and
5319 the following additional rules for specific cases: */
5320 /* For reference, the conversions not excluded are: integral
5321 promotions, floating point promotion, integral conversions,
5322 floating point conversions, floating-integral conversions,
5323 pointer conversions, and pointer to member conversions. */
5326 A value of integral _or enumeration_ type can be explicitly
5327 converted to an enumeration type. */
5328 /* The effect of all that is that any conversion between any two
5329 types which are integral, floating, or enumeration types can be
5331 if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
5332 && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
5334 expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
5336 /* Ignore any integer overflow caused by the cast. */
5337 expr = ignore_overflows (expr, orig);
5341 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
5342 && CLASS_TYPE_P (TREE_TYPE (type))
5343 && CLASS_TYPE_P (TREE_TYPE (intype))
5344 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5345 (TREE_TYPE (intype))),
5346 build_pointer_type (TYPE_MAIN_VARIANT
5347 (TREE_TYPE (type)))))
5352 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5353 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
5354 c_cast_p ? ba_unique : ba_check,
5356 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
5359 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5360 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5367 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
5368 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
5370 if (TYPE_PTRMEM_P (type))
5372 t1 = (build_ptrmem_type
5374 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
5375 t2 = (build_ptrmem_type
5377 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
5384 if (can_convert (t1, t2) || can_convert (t2, t1))
5387 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5388 return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
5393 /* [expr.static.cast]
5395 An rvalue of type "pointer to cv void" can be explicitly
5396 converted to a pointer to object type. A value of type pointer
5397 to object converted to "pointer to cv void" and back to the
5398 original pointer type will have its original value. */
5399 if (TREE_CODE (intype) == POINTER_TYPE
5400 && VOID_TYPE_P (TREE_TYPE (intype))
5401 && TYPE_PTROB_P (type))
5404 check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5405 return build_nop (type, expr);
5409 return error_mark_node;
5412 /* Return an expression representing static_cast<TYPE>(EXPR). */
5415 build_static_cast (tree type, tree expr, tsubst_flags_t complain)
5420 if (type == error_mark_node || expr == error_mark_node)
5421 return error_mark_node;
5423 if (processing_template_decl)
5425 expr = build_min (STATIC_CAST_EXPR, type, expr);
5426 /* We don't know if it will or will not have side effects. */
5427 TREE_SIDE_EFFECTS (expr) = 1;
5428 return convert_from_reference (expr);
5431 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5432 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5433 if (TREE_CODE (type) != REFERENCE_TYPE
5434 && TREE_CODE (expr) == NOP_EXPR
5435 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5436 expr = TREE_OPERAND (expr, 0);
5438 result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p,
5443 if (complain & tf_error)
5444 error ("invalid static_cast from type %qT to type %qT",
5445 TREE_TYPE (expr), type);
5446 return error_mark_node;
5449 /* EXPR is an expression with member function or pointer-to-member
5450 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5451 not permitted by ISO C++, but we accept it in some modes. If we
5452 are not in one of those modes, issue a diagnostic. Return the
5453 converted expression. */
5456 convert_member_func_to_ptr (tree type, tree expr)
5461 intype = TREE_TYPE (expr);
5462 gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5463 || TREE_CODE (intype) == METHOD_TYPE);
5465 if (pedantic || warn_pmf2ptr)
5466 pedwarn ("converting from %qT to %qT", intype, type);
5468 if (TREE_CODE (intype) == METHOD_TYPE)
5469 expr = build_addr_func (expr);
5470 else if (TREE_CODE (expr) == PTRMEM_CST)
5471 expr = build_address (PTRMEM_CST_MEMBER (expr));
5474 decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5475 decl = build_address (decl);
5476 expr = get_member_function_from_ptrfunc (&decl, expr);
5479 return build_nop (type, expr);
5482 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5483 If C_CAST_P is true, this reinterpret cast is being done as part of
5484 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5485 indicate whether or not reinterpret_cast was valid. */
5488 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5489 bool *valid_p, tsubst_flags_t complain)
5493 /* Assume the cast is invalid. */
5497 if (type == error_mark_node || error_operand_p (expr))
5498 return error_mark_node;
5500 intype = TREE_TYPE (expr);
5502 /* Save casted types in the function's used types hash table. */
5503 used_types_insert (type);
5505 /* [expr.reinterpret.cast]
5506 An lvalue expression of type T1 can be cast to the type
5507 "reference to T2" if an expression of type "pointer to T1" can be
5508 explicitly converted to the type "pointer to T2" using a
5509 reinterpret_cast. */
5510 if (TREE_CODE (type) == REFERENCE_TYPE)
5512 if (! real_lvalue_p (expr))
5514 if (complain & tf_error)
5515 error ("invalid cast of an rvalue expression of type "
5518 return error_mark_node;
5521 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5522 "B" are related class types; the reinterpret_cast does not
5523 adjust the pointer. */
5524 if (TYPE_PTR_P (intype)
5525 && (complain & tf_warning)
5526 && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5527 COMPARE_BASE | COMPARE_DERIVED)))
5528 warning (0, "casting %qT to %qT does not dereference pointer",
5531 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5532 if (expr != error_mark_node)
5533 expr = build_reinterpret_cast_1
5534 (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5536 if (expr != error_mark_node)
5537 expr = cp_build_indirect_ref (expr, 0, complain);
5541 /* As a G++ extension, we consider conversions from member
5542 functions, and pointers to member functions to
5543 pointer-to-function and pointer-to-void types. If
5544 -Wno-pmf-conversions has not been specified,
5545 convert_member_func_to_ptr will issue an error message. */
5546 if ((TYPE_PTRMEMFUNC_P (intype)
5547 || TREE_CODE (intype) == METHOD_TYPE)
5548 && TYPE_PTR_P (type)
5549 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5550 || VOID_TYPE_P (TREE_TYPE (type))))
5551 return convert_member_func_to_ptr (type, expr);
5553 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5554 array-to-pointer, and function-to-pointer conversions are
5556 expr = decay_conversion (expr);
5558 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5559 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5560 if (TREE_CODE (expr) == NOP_EXPR
5561 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5562 expr = TREE_OPERAND (expr, 0);
5564 if (error_operand_p (expr))
5565 return error_mark_node;
5567 intype = TREE_TYPE (expr);
5569 /* [expr.reinterpret.cast]
5570 A pointer can be converted to any integral type large enough to
5572 if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5574 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5576 if (complain & tf_error)
5577 pedwarn ("cast from %qT to %qT loses precision",
5580 return error_mark_node;
5583 /* [expr.reinterpret.cast]
5584 A value of integral or enumeration type can be explicitly
5585 converted to a pointer. */
5586 else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5589 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5590 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5591 return fold_if_not_in_template (build_nop (type, expr));
5592 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5593 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5598 check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR);
5599 /* Warn about possible alignment problems. */
5600 if (STRICT_ALIGNMENT && warn_cast_align
5601 && (complain & tf_warning)
5602 && !VOID_TYPE_P (type)
5603 && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5604 && COMPLETE_TYPE_P (TREE_TYPE (type))
5605 && COMPLETE_TYPE_P (TREE_TYPE (intype))
5606 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5607 warning (OPT_Wcast_align, "cast from %qT to %qT "
5608 "increases required alignment of target type", intype, type);
5610 /* We need to strip nops here, because the front end likes to
5611 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5613 if (warn_strict_aliasing <= 2)
5614 strict_aliasing_warning (intype, type, sexpr);
5616 return fold_if_not_in_template (build_nop (type, expr));
5618 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5619 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5621 if (pedantic && (complain & tf_warning))
5622 /* Only issue a warning, as we have always supported this
5623 where possible, and it is necessary in some cases. DR 195
5624 addresses this issue, but as of 2004/10/26 is still in
5626 warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5627 return fold_if_not_in_template (build_nop (type, expr));
5629 else if (TREE_CODE (type) == VECTOR_TYPE)
5630 return fold_if_not_in_template (convert_to_vector (type, expr));
5631 else if (TREE_CODE (intype) == VECTOR_TYPE && INTEGRAL_TYPE_P (type))
5632 return fold_if_not_in_template (convert_to_integer (type, expr));
5637 if (complain & tf_error)
5638 error ("invalid cast from type %qT to type %qT", intype, type);
5639 return error_mark_node;
5642 return cp_convert (type, expr);
5646 build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain)
5648 if (type == error_mark_node || expr == error_mark_node)
5649 return error_mark_node;
5651 if (processing_template_decl)
5653 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5655 if (!TREE_SIDE_EFFECTS (t)
5656 && type_dependent_expression_p (expr))
5657 /* There might turn out to be side effects inside expr. */
5658 TREE_SIDE_EFFECTS (t) = 1;
5659 return convert_from_reference (t);
5662 return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5663 /*valid_p=*/NULL, complain);
5666 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5667 return an appropriate expression. Otherwise, return
5668 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5669 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5670 performing a C-style cast, its value upon return will indicate
5671 whether or not the conversion succeeded. */
5674 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5678 tree reference_type;
5680 /* Callers are responsible for handling error_mark_node as a
5681 destination type. */
5682 gcc_assert (dst_type != error_mark_node);
5683 /* In a template, callers should be building syntactic
5684 representations of casts, not using this machinery. */
5685 gcc_assert (!processing_template_decl);
5687 /* Assume the conversion is invalid. */
5691 if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5694 error ("invalid use of const_cast with type %qT, "
5695 "which is not a pointer, "
5696 "reference, nor a pointer-to-data-member type", dst_type);
5697 return error_mark_node;
5700 if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5703 error ("invalid use of const_cast with type %qT, which is a pointer "
5704 "or reference to a function type", dst_type);
5705 return error_mark_node;
5708 /* Save casted types in the function's used types hash table. */
5709 used_types_insert (dst_type);
5711 src_type = TREE_TYPE (expr);
5712 /* Expressions do not really have reference types. */
5713 if (TREE_CODE (src_type) == REFERENCE_TYPE)
5714 src_type = TREE_TYPE (src_type);
5716 /* [expr.const.cast]
5718 An lvalue of type T1 can be explicitly converted to an lvalue of
5719 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5720 types) if a pointer to T1 can be explicitly converted to the type
5721 pointer to T2 using a const_cast. */
5722 if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5724 reference_type = dst_type;
5725 if (! real_lvalue_p (expr))
5728 error ("invalid const_cast of an rvalue of type %qT to type %qT",
5729 src_type, dst_type);
5730 return error_mark_node;
5732 dst_type = build_pointer_type (TREE_TYPE (dst_type));
5733 src_type = build_pointer_type (src_type);
5737 reference_type = NULL_TREE;
5738 /* If the destination type is not a reference type, the
5739 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5740 conversions are performed. */
5741 src_type = type_decays_to (src_type);
5742 if (src_type == error_mark_node)
5743 return error_mark_node;
5746 if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5747 && comp_ptr_ttypes_const (dst_type, src_type))
5752 /* This cast is actually a C-style cast. Issue a warning if
5753 the user is making a potentially unsafe cast. */
5754 check_for_casting_away_constness (src_type, dst_type, CAST_EXPR);
5758 expr = cp_build_unary_op (ADDR_EXPR, expr, 0,
5759 complain? tf_warning_or_error : tf_none);
5760 expr = build_nop (reference_type, expr);
5761 return convert_from_reference (expr);
5765 expr = decay_conversion (expr);
5766 /* build_c_cast puts on a NOP_EXPR to make the result not an
5767 lvalue. Strip such NOP_EXPRs if VALUE is being used in
5768 non-lvalue context. */
5769 if (TREE_CODE (expr) == NOP_EXPR
5770 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5771 expr = TREE_OPERAND (expr, 0);
5772 return build_nop (dst_type, expr);
5777 error ("invalid const_cast from type %qT to type %qT",
5778 src_type, dst_type);
5779 return error_mark_node;
5783 build_const_cast (tree type, tree expr, tsubst_flags_t complain)
5785 if (type == error_mark_node || error_operand_p (expr))
5786 return error_mark_node;
5788 if (processing_template_decl)
5790 tree t = build_min (CONST_CAST_EXPR, type, expr);
5792 if (!TREE_SIDE_EFFECTS (t)
5793 && type_dependent_expression_p (expr))
5794 /* There might turn out to be side effects inside expr. */
5795 TREE_SIDE_EFFECTS (t) = 1;
5796 return convert_from_reference (t);
5799 return build_const_cast_1 (type, expr, complain & tf_error,
5803 /* Like cp_build_c_cast, but for the c-common bits. */
5806 build_c_cast (tree type, tree expr)
5808 return cp_build_c_cast (type, expr, tf_warning_or_error);
5811 /* Build an expression representing an explicit C-style cast to type
5812 TYPE of expression EXPR. */
5815 cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
5821 if (type == error_mark_node || error_operand_p (expr))
5822 return error_mark_node;
5824 if (processing_template_decl)
5826 tree t = build_min (CAST_EXPR, type,
5827 tree_cons (NULL_TREE, value, NULL_TREE));
5828 /* We don't know if it will or will not have side effects. */
5829 TREE_SIDE_EFFECTS (t) = 1;
5830 return convert_from_reference (t);
5833 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5834 'Class') should always be retained, because this information aids
5835 in method lookup. */
5836 if (objc_is_object_ptr (type)
5837 && objc_is_object_ptr (TREE_TYPE (expr)))
5838 return build_nop (type, expr);
5840 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5841 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5842 if (TREE_CODE (type) != REFERENCE_TYPE
5843 && TREE_CODE (value) == NOP_EXPR
5844 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5845 value = TREE_OPERAND (value, 0);
5847 if (TREE_CODE (type) == ARRAY_TYPE)
5849 /* Allow casting from T1* to T2[] because Cfront allows it.
5850 NIHCL uses it. It is not valid ISO C++ however. */
5851 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5853 if (complain & tf_error)
5854 pedwarn ("ISO C++ forbids casting to an array type %qT", type);
5856 return error_mark_node;
5857 type = build_pointer_type (TREE_TYPE (type));
5861 if (complain & tf_error)
5862 error ("ISO C++ forbids casting to an array type %qT", type);
5863 return error_mark_node;
5867 if (TREE_CODE (type) == FUNCTION_TYPE
5868 || TREE_CODE (type) == METHOD_TYPE)
5870 if (complain & tf_error)
5871 error ("invalid cast to function type %qT", type);
5872 return error_mark_node;
5875 /* A C-style cast can be a const_cast. */
5876 result = build_const_cast_1 (type, value, /*complain=*/false,
5881 /* Or a static cast. */
5882 result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5883 &valid_p, complain);
5884 /* Or a reinterpret_cast. */
5886 result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5887 &valid_p, complain);
5888 /* The static_cast or reinterpret_cast may be followed by a
5891 /* A valid cast may result in errors if, for example, a
5892 conversion to am ambiguous base class is required. */
5893 && !error_operand_p (result))
5897 /* Non-class rvalues always have cv-unqualified type. */
5898 if (!CLASS_TYPE_P (type))
5899 type = TYPE_MAIN_VARIANT (type);
5900 result_type = TREE_TYPE (result);
5901 if (!CLASS_TYPE_P (result_type))
5902 result_type = TYPE_MAIN_VARIANT (result_type);
5903 /* If the type of RESULT does not match TYPE, perform a
5904 const_cast to make it match. If the static_cast or
5905 reinterpret_cast succeeded, we will differ by at most
5906 cv-qualification, so the follow-on const_cast is guaranteed
5908 if (!same_type_p (non_reference (type), non_reference (result_type)))
5910 result = build_const_cast_1 (type, result, false, &valid_p);
5911 gcc_assert (valid_p);
5916 return error_mark_node;
5919 /* For use from the C common bits. */
5921 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5923 return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
5926 /* Build an assignment expression of lvalue LHS from value RHS.
5927 MODIFYCODE is the code for a binary operator that we use
5928 to combine the old value of LHS with RHS to get the new value.
5929 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5931 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5934 cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
5935 tsubst_flags_t complain)
5939 tree lhstype = TREE_TYPE (lhs);
5940 tree olhstype = lhstype;
5941 tree olhs = NULL_TREE;
5942 bool plain_assign = (modifycode == NOP_EXPR);
5944 /* Avoid duplicate error messages from operands that had errors. */
5945 if (error_operand_p (lhs) || error_operand_p (rhs))
5946 return error_mark_node;
5948 /* Handle control structure constructs used as "lvalues". */
5949 switch (TREE_CODE (lhs))
5951 /* Handle --foo = 5; as these are valid constructs in C++. */
5952 case PREDECREMENT_EXPR:
5953 case PREINCREMENT_EXPR:
5954 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5955 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5956 stabilize_reference (TREE_OPERAND (lhs, 0)),
5957 TREE_OPERAND (lhs, 1));
5958 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0),
5959 modifycode, rhs, complain);
5960 if (newrhs == error_mark_node)
5961 return error_mark_node;
5962 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5964 /* Handle (a, b) used as an "lvalue". */
5966 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1),
5967 modifycode, rhs, complain);
5968 if (newrhs == error_mark_node)
5969 return error_mark_node;
5970 return build2 (COMPOUND_EXPR, lhstype,
5971 TREE_OPERAND (lhs, 0), newrhs);
5974 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5975 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5976 stabilize_reference (TREE_OPERAND (lhs, 0)),
5977 TREE_OPERAND (lhs, 1));
5978 newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs,
5980 if (newrhs == error_mark_node)
5981 return error_mark_node;
5982 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5986 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5987 when neither operand has side-effects. */
5988 if (!lvalue_or_else (lhs, lv_assign, complain))
5989 return error_mark_node;
5991 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5992 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5994 lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5995 build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5997 TREE_OPERAND (lhs, 0),
5998 TREE_OPERAND (lhs, 1)),
5999 TREE_OPERAND (lhs, 0),
6000 TREE_OPERAND (lhs, 1));
6003 /* Handle (a ? b : c) used as an "lvalue". */
6006 /* Produce (a ? (b = rhs) : (c = rhs))
6007 except that the RHS goes through a save-expr
6008 so the code to compute it is only emitted once. */
6010 tree preeval = NULL_TREE;
6012 if (VOID_TYPE_P (TREE_TYPE (rhs)))
6014 if (complain & tf_error)
6015 error ("void value not ignored as it ought to be");
6016 return error_mark_node;
6019 rhs = stabilize_expr (rhs, &preeval);
6021 /* Check this here to avoid odd errors when trying to convert
6022 a throw to the type of the COND_EXPR. */
6023 if (!lvalue_or_else (lhs, lv_assign, complain))
6024 return error_mark_node;
6026 cond = build_conditional_expr
6027 (TREE_OPERAND (lhs, 0),
6028 cp_build_modify_expr (TREE_OPERAND (lhs, 1),
6029 modifycode, rhs, complain),
6030 cp_build_modify_expr (TREE_OPERAND (lhs, 2),
6031 modifycode, rhs, complain),
6034 if (cond == error_mark_node)
6036 /* Make sure the code to compute the rhs comes out
6037 before the split. */
6039 cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
6047 if (modifycode == INIT_EXPR)
6049 if (TREE_CODE (rhs) == CONSTRUCTOR)
6051 if (! same_type_p (TREE_TYPE (rhs), lhstype))
6052 /* Call convert to generate an error; see PR 11063. */
6053 rhs = convert (lhstype, rhs);
6054 result = build2 (INIT_EXPR, lhstype, lhs, rhs);
6055 TREE_SIDE_EFFECTS (result) = 1;
6058 else if (! MAYBE_CLASS_TYPE_P (lhstype))
6059 /* Do the default thing. */;
6062 result = build_special_member_call (lhs, complete_ctor_identifier,
6063 build_tree_list (NULL_TREE, rhs),
6064 lhstype, LOOKUP_NORMAL,
6066 if (result == NULL_TREE)
6067 return error_mark_node;
6073 lhs = require_complete_type (lhs);
6074 if (lhs == error_mark_node)
6075 return error_mark_node;
6077 if (modifycode == NOP_EXPR)
6079 /* `operator=' is not an inheritable operator. */
6080 if (! MAYBE_CLASS_TYPE_P (lhstype))
6081 /* Do the default thing. */;
6084 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
6085 lhs, rhs, make_node (NOP_EXPR),
6086 /*overloaded_p=*/NULL,
6088 if (result == NULL_TREE)
6089 return error_mark_node;
6096 /* A binary op has been requested. Combine the old LHS
6097 value with the RHS producing the value we should actually
6098 store into the LHS. */
6099 gcc_assert (!((TREE_CODE (lhstype) == REFERENCE_TYPE
6100 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype)))
6101 || MAYBE_CLASS_TYPE_P (lhstype)));
6103 lhs = stabilize_reference (lhs);
6104 newrhs = cp_build_binary_op (modifycode, lhs, rhs,
6106 if (newrhs == error_mark_node)
6108 if (complain & tf_error)
6109 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode,
6110 TREE_TYPE (lhs), TREE_TYPE (rhs));
6111 return error_mark_node;
6114 /* Now it looks like a plain assignment. */
6115 modifycode = NOP_EXPR;
6117 gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
6118 gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
6121 /* The left-hand side must be an lvalue. */
6122 if (!lvalue_or_else (lhs, lv_assign, complain))
6123 return error_mark_node;
6125 /* Warn about modifying something that is `const'. Don't warn if
6126 this is initialization. */
6127 if (modifycode != INIT_EXPR
6128 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
6129 /* Functions are not modifiable, even though they are
6131 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
6132 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
6133 /* If it's an aggregate and any field is const, then it is
6134 effectively const. */
6135 || (CLASS_TYPE_P (lhstype)
6136 && C_TYPE_FIELDS_READONLY (lhstype))))
6138 if (complain & tf_error)
6139 readonly_error (lhs, "assignment");
6141 return error_mark_node;
6144 /* If storing into a structure or union member, it has probably been
6145 given type `int'. Compute the type that would go with the actual
6146 amount of storage the member occupies. */
6148 if (TREE_CODE (lhs) == COMPONENT_REF
6149 && (TREE_CODE (lhstype) == INTEGER_TYPE
6150 || TREE_CODE (lhstype) == REAL_TYPE
6151 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
6153 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
6155 /* If storing in a field that is in actuality a short or narrower
6156 than one, we must store in the field in its actual type. */
6158 if (lhstype != TREE_TYPE (lhs))
6160 /* Avoid warnings converting integral types back into enums for
6162 if (TREE_CODE (lhstype) == INTEGER_TYPE
6163 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
6165 if (TREE_SIDE_EFFECTS (lhs))
6166 lhs = stabilize_reference (lhs);
6169 lhs = copy_node (lhs);
6170 TREE_TYPE (lhs) = lhstype;
6174 /* Convert new value to destination type. */
6176 if (TREE_CODE (lhstype) == ARRAY_TYPE)
6180 if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
6181 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
6183 if (complain & tf_error)
6184 error ("incompatible types in assignment of %qT to %qT",
6185 TREE_TYPE (rhs), lhstype);
6186 return error_mark_node;
6189 /* Allow array assignment in compiler-generated code. */
6190 if (! DECL_ARTIFICIAL (current_function_decl))
6192 /* This routine is used for both initialization and assignment.
6193 Make sure the diagnostic message differentiates the context. */
6194 if (complain & tf_error)
6196 if (modifycode == INIT_EXPR)
6197 error ("array used as initializer");
6199 error ("invalid array assignment");
6201 return error_mark_node;
6204 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6205 ? 1 + (modifycode != INIT_EXPR): 0;
6206 return build_vec_init (lhs, NULL_TREE, newrhs,
6207 /*explicit_default_init_p=*/false,
6208 from_array, complain);
6211 if (modifycode == INIT_EXPR)
6212 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
6213 "initialization", NULL_TREE, 0,
6217 /* Avoid warnings on enum bit fields. */
6218 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
6219 && TREE_CODE (lhstype) == INTEGER_TYPE)
6221 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6222 NULL_TREE, 0, complain);
6223 newrhs = convert_force (lhstype, newrhs, 0);
6226 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
6227 NULL_TREE, 0, complain);
6228 if (TREE_CODE (newrhs) == CALL_EXPR
6229 && TYPE_NEEDS_CONSTRUCTING (lhstype))
6230 newrhs = build_cplus_new (lhstype, newrhs);
6232 /* Can't initialize directly from a TARGET_EXPR, since that would
6233 cause the lhs to be constructed twice, and possibly result in
6234 accidental self-initialization. So we force the TARGET_EXPR to be
6235 expanded without a target. */
6236 if (TREE_CODE (newrhs) == TARGET_EXPR)
6237 newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6238 TREE_OPERAND (newrhs, 0));
6241 if (newrhs == error_mark_node)
6242 return error_mark_node;
6244 if (c_dialect_objc () && flag_objc_gc)
6246 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6252 result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6253 lhstype, lhs, newrhs);
6255 TREE_SIDE_EFFECTS (result) = 1;
6257 TREE_NO_WARNING (result) = 1;
6259 /* If we got the LHS in a different type for storing in,
6260 convert the result back to the nominal type of LHS
6261 so that the value we return always has the same type
6262 as the LHS argument. */
6264 if (olhstype == TREE_TYPE (result))
6268 result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
6269 TREE_NO_WARNING (result) = 1;
6272 return convert_for_assignment (olhstype, result, "assignment",
6273 NULL_TREE, 0, complain);
6277 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6278 tsubst_flags_t complain)
6280 if (processing_template_decl)
6281 return build_min_nt (MODOP_EXPR, lhs,
6282 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6284 if (modifycode != NOP_EXPR)
6286 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6287 make_node (modifycode),
6288 /*overloaded_p=*/NULL,
6292 TREE_NO_WARNING (rval) = 1;
6296 return cp_build_modify_expr (lhs, modifycode, rhs, complain);
6299 /* Helper function for get_delta_difference which assumes FROM is a base
6300 class of TO. Returns a delta for the conversion of pointer-to-member
6301 of FROM to pointer-to-member of TO. If the conversion is invalid,
6302 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
6303 If C_CAST_P is true, this conversion is taking place as part of a C-style
6307 get_delta_difference_1 (tree from, tree to, bool c_cast_p)
6312 binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
6313 if (kind == bk_inaccessible || kind == bk_ambig)
6315 error (" in pointer to member function conversion");
6316 return size_zero_node;
6320 if (kind != bk_via_virtual)
6321 return BINFO_OFFSET (binfo);
6323 /* FROM is a virtual base class of TO. Issue an error or warning
6324 depending on whether or not this is a reinterpret cast. */
6326 error ("pointer to member conversion via virtual base %qT",
6327 BINFO_TYPE (binfo_from_vbase (binfo)));
6329 return size_zero_node;
6336 /* Get difference in deltas for different pointer to member function
6337 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6338 the conversion is invalid, the constant is zero. If
6339 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6340 If C_CAST_P is true this conversion is taking place as part of a
6343 Note that the naming of FROM and TO is kind of backwards; the return
6344 value is what we add to a TO in order to get a FROM. They are named
6345 this way because we call this function to find out how to convert from
6346 a pointer to member of FROM to a pointer to member of TO. */
6349 get_delta_difference (tree from, tree to,
6350 bool allow_inverse_p,
6355 if (same_type_ignoring_top_level_qualifiers_p (from, to))
6356 /* Pointer to member of incomplete class is permitted*/
6357 result = size_zero_node;
6359 result = get_delta_difference_1 (from, to, c_cast_p);
6363 if (!allow_inverse_p)
6365 error_not_base_type (from, to);
6366 error (" in pointer to member conversion");
6367 result = size_zero_node;
6371 result = get_delta_difference_1 (to, from, c_cast_p);
6374 result = size_diffop (size_zero_node, result);
6377 error_not_base_type (from, to);
6378 error (" in pointer to member conversion");
6379 result = size_zero_node;
6384 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
6388 /* Return a constructor for the pointer-to-member-function TYPE using
6389 the other components as specified. */
6392 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
6397 VEC(constructor_elt, gc) *v;
6399 /* Pull the FIELD_DECLs out of the type. */
6400 pfn_field = TYPE_FIELDS (type);
6401 delta_field = TREE_CHAIN (pfn_field);
6403 /* Make sure DELTA has the type we want. */
6404 delta = convert_and_check (delta_type_node, delta);
6406 /* Convert to the correct target type if necessary. */
6407 pfn = fold_convert (TREE_TYPE (pfn_field), pfn);
6409 /* Finish creating the initializer. */
6410 v = VEC_alloc(constructor_elt, gc, 2);
6411 CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
6412 CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
6413 u = build_constructor (type, v);
6414 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
6415 TREE_STATIC (u) = (TREE_CONSTANT (u)
6416 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
6418 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
6423 /* Build a constructor for a pointer to member function. It can be
6424 used to initialize global variables, local variable, or used
6425 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6428 If FORCE is nonzero, then force this conversion, even if
6429 we would rather not do it. Usually set when using an explicit
6430 cast. A C-style cast is being processed iff C_CAST_P is true.
6432 Return error_mark_node, if something goes wrong. */
6435 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
6441 if (error_operand_p (pfn))
6442 return error_mark_node;
6444 pfn_type = TREE_TYPE (pfn);
6445 to_type = build_ptrmemfunc_type (type);
6447 /* Handle multiple conversions of pointer to member functions. */
6448 if (TYPE_PTRMEMFUNC_P (pfn_type))
6450 tree delta = NULL_TREE;
6451 tree npfn = NULL_TREE;
6455 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
6456 error ("invalid conversion to type %qT from type %qT",
6459 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
6460 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
6464 /* We don't have to do any conversion to convert a
6465 pointer-to-member to its own type. But, we don't want to
6466 just return a PTRMEM_CST if there's an explicit cast; that
6467 cast should make the expression an invalid template argument. */
6468 if (TREE_CODE (pfn) != PTRMEM_CST)
6470 if (same_type_p (to_type, pfn_type))
6472 else if (integer_zerop (n))
6473 return build_reinterpret_cast (to_type, pfn,
6474 tf_warning_or_error);
6477 if (TREE_SIDE_EFFECTS (pfn))
6478 pfn = save_expr (pfn);
6480 /* Obtain the function pointer and the current DELTA. */
6481 if (TREE_CODE (pfn) == PTRMEM_CST)
6482 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6485 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6486 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6489 /* Just adjust the DELTA field. */
6490 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6491 (TREE_TYPE (delta), ptrdiff_type_node));
6492 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6493 n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node,
6494 tf_warning_or_error);
6495 delta = cp_build_binary_op (PLUS_EXPR, delta, n, tf_warning_or_error);
6496 return build_ptrmemfunc1 (to_type, delta, npfn);
6499 /* Handle null pointer to member function conversions. */
6500 if (integer_zerop (pfn))
6502 pfn = build_c_cast (type, integer_zero_node);
6503 return build_ptrmemfunc1 (to_type,
6508 if (type_unknown_p (pfn))
6509 return instantiate_type (type, pfn, tf_warning_or_error);
6511 fn = TREE_OPERAND (pfn, 0);
6512 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6513 /* In a template, we will have preserved the
6515 || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6516 return make_ptrmem_cst (to_type, fn);
6519 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6522 ??? There is no consistency as to the types returned for the above
6523 values. Some code acts as if it were a sizetype and some as if it were
6524 integer_type_node. */
6527 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6529 tree type = TREE_TYPE (cst);
6530 tree fn = PTRMEM_CST_MEMBER (cst);
6531 tree ptr_class, fn_class;
6533 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6535 /* The class that the function belongs to. */
6536 fn_class = DECL_CONTEXT (fn);
6538 /* The class that we're creating a pointer to member of. */
6539 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6541 /* First, calculate the adjustment to the function's class. */
6542 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6545 if (!DECL_VIRTUAL_P (fn))
6546 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6549 /* If we're dealing with a virtual function, we have to adjust 'this'
6550 again, to point to the base which provides the vtable entry for
6551 fn; the call will do the opposite adjustment. */
6552 tree orig_class = DECL_CONTEXT (fn);
6553 tree binfo = binfo_or_else (orig_class, fn_class);
6554 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6555 *delta, BINFO_OFFSET (binfo));
6556 *delta = fold_if_not_in_template (*delta);
6558 /* We set PFN to the vtable offset at which the function can be
6559 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6560 case delta is shifted left, and then incremented). */
6561 *pfn = DECL_VINDEX (fn);
6562 *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6563 TYPE_SIZE_UNIT (vtable_entry_type));
6564 *pfn = fold_if_not_in_template (*pfn);
6566 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6568 case ptrmemfunc_vbit_in_pfn:
6569 *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6571 *pfn = fold_if_not_in_template (*pfn);
6574 case ptrmemfunc_vbit_in_delta:
6575 *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6576 *delta, integer_one_node);
6577 *delta = fold_if_not_in_template (*delta);
6578 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6579 *delta, integer_one_node);
6580 *delta = fold_if_not_in_template (*delta);
6587 *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6588 *pfn = fold_if_not_in_template (*pfn);
6592 /* Return an expression for PFN from the pointer-to-member function
6596 pfn_from_ptrmemfunc (tree t)
6598 if (TREE_CODE (t) == PTRMEM_CST)
6603 expand_ptrmemfunc_cst (t, &delta, &pfn);
6608 return build_ptrmemfunc_access_expr (t, pfn_identifier);
6611 /* Return an expression for DELTA from the pointer-to-member function
6615 delta_from_ptrmemfunc (tree t)
6617 if (TREE_CODE (t) == PTRMEM_CST)
6622 expand_ptrmemfunc_cst (t, &delta, &pfn);
6627 return build_ptrmemfunc_access_expr (t, delta_identifier);
6630 /* Convert value RHS to type TYPE as preparation for an assignment to
6631 an lvalue of type TYPE. ERRTYPE is a string to use in error
6632 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6633 are doing the conversion in order to pass the PARMNUMth argument of
6637 convert_for_assignment (tree type, tree rhs,
6638 const char *errtype, tree fndecl, int parmnum,
6639 tsubst_flags_t complain)
6642 enum tree_code coder;
6644 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6645 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6646 rhs = TREE_OPERAND (rhs, 0);
6648 rhstype = TREE_TYPE (rhs);
6649 coder = TREE_CODE (rhstype);
6651 if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6652 && vector_types_convertible_p (type, rhstype, true))
6653 return convert (type, rhs);
6655 if (rhs == error_mark_node || rhstype == error_mark_node)
6656 return error_mark_node;
6657 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6658 return error_mark_node;
6660 /* The RHS of an assignment cannot have void type. */
6661 if (coder == VOID_TYPE)
6663 if (complain & tf_error)
6664 error ("void value not ignored as it ought to be");
6665 return error_mark_node;
6668 /* Simplify the RHS if possible. */
6669 if (TREE_CODE (rhs) == CONST_DECL)
6670 rhs = DECL_INITIAL (rhs);
6672 if (c_dialect_objc ())
6675 tree rname = fndecl;
6677 if (!strcmp (errtype, "assignment"))
6679 else if (!strcmp (errtype, "initialization"))
6683 tree selector = objc_message_selector ();
6687 if (selector && parmno > 1)
6694 if (objc_compare_types (type, rhstype, parmno, rname))
6695 return convert (type, rhs);
6700 The expression is implicitly converted (clause _conv_) to the
6701 cv-unqualified type of the left operand.
6703 We allow bad conversions here because by the time we get to this point
6704 we are committed to doing the conversion. If we end up doing a bad
6705 conversion, convert_like will complain. */
6706 if (!can_convert_arg_bad (type, rhstype, rhs))
6708 /* When -Wno-pmf-conversions is use, we just silently allow
6709 conversions from pointers-to-members to plain pointers. If
6710 the conversion doesn't work, cp_convert will complain. */
6712 && TYPE_PTR_P (type)
6713 && TYPE_PTRMEMFUNC_P (rhstype))
6714 rhs = cp_convert (strip_top_quals (type), rhs);
6717 if (complain & tf_error)
6719 /* If the right-hand side has unknown type, then it is an
6720 overloaded function. Call instantiate_type to get error
6722 if (rhstype == unknown_type_node)
6723 instantiate_type (type, rhs, tf_warning_or_error);
6725 error ("cannot convert %qT to %qT for argument %qP to %qD",
6726 rhstype, type, parmnum, fndecl);
6728 error ("cannot convert %qT to %qT in %s", rhstype, type,
6731 return error_mark_node;
6734 if (warn_missing_format_attribute)
6736 const enum tree_code codel = TREE_CODE (type);
6737 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6739 && check_missing_format_attribute (type, rhstype)
6740 && (complain & tf_warning))
6741 warning (OPT_Wmissing_format_attribute,
6742 "%s might be a candidate for a format attribute",
6746 /* If -Wparentheses, warn about a = b = c when a has type bool and b
6748 if (warn_parentheses
6749 && type == boolean_type_node
6750 && TREE_CODE (rhs) == MODIFY_EXPR
6751 && !TREE_NO_WARNING (rhs)
6752 && TREE_TYPE (rhs) != boolean_type_node
6753 && (complain & tf_warning))
6755 warning (OPT_Wparentheses,
6756 "suggest parentheses around assignment used as truth value");
6757 TREE_NO_WARNING (rhs) = 1;
6760 return perform_implicit_conversion (strip_top_quals (type), rhs, complain);
6763 /* Convert RHS to be of type TYPE.
6764 If EXP is nonzero, it is the target of the initialization.
6765 ERRTYPE is a string to use in error messages.
6767 Two major differences between the behavior of
6768 `convert_for_assignment' and `convert_for_initialization'
6769 are that references are bashed in the former, while
6770 copied in the latter, and aggregates are assigned in
6771 the former (operator=) while initialized in the
6774 If using constructor make sure no conversion operator exists, if one does
6775 exist, an ambiguity exists.
6777 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6780 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
6781 const char *errtype, tree fndecl, int parmnum,
6782 tsubst_flags_t complain)
6784 enum tree_code codel = TREE_CODE (type);
6786 enum tree_code coder;
6788 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6789 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6790 if (TREE_CODE (rhs) == NOP_EXPR
6791 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6792 && codel != REFERENCE_TYPE)
6793 rhs = TREE_OPERAND (rhs, 0);
6795 if (type == error_mark_node
6796 || rhs == error_mark_node
6797 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6798 return error_mark_node;
6800 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6801 && TREE_CODE (type) != ARRAY_TYPE
6802 && (TREE_CODE (type) != REFERENCE_TYPE
6803 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6804 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6805 && (TREE_CODE (type) != REFERENCE_TYPE
6806 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6807 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6808 rhs = decay_conversion (rhs);
6810 rhstype = TREE_TYPE (rhs);
6811 coder = TREE_CODE (rhstype);
6813 if (coder == ERROR_MARK)
6814 return error_mark_node;
6816 /* We accept references to incomplete types, so we can
6817 return here before checking if RHS is of complete type. */
6819 if (codel == REFERENCE_TYPE)
6821 /* This should eventually happen in convert_arguments. */
6822 int savew = 0, savee = 0;
6825 savew = warningcount, savee = errorcount;
6826 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
6830 if (warningcount > savew)
6831 warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
6832 else if (errorcount > savee)
6833 error ("in passing argument %P of %q+D", parmnum, fndecl);
6839 exp = require_complete_type (exp);
6840 if (exp == error_mark_node)
6841 return error_mark_node;
6843 rhstype = non_reference (rhstype);
6845 type = complete_type (type);
6847 if (MAYBE_CLASS_TYPE_P (type))
6848 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6850 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum,
6854 /* If RETVAL is the address of, or a reference to, a local variable or
6855 temporary give an appropriate warning. */
6858 maybe_warn_about_returning_address_of_local (tree retval)
6860 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6861 tree whats_returned = retval;
6865 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6866 whats_returned = TREE_OPERAND (whats_returned, 1);
6867 else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6868 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6869 || TREE_CODE (whats_returned) == NOP_EXPR)
6870 whats_returned = TREE_OPERAND (whats_returned, 0);
6875 if (TREE_CODE (whats_returned) != ADDR_EXPR)
6877 whats_returned = TREE_OPERAND (whats_returned, 0);
6879 if (TREE_CODE (valtype) == REFERENCE_TYPE)
6881 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6882 || TREE_CODE (whats_returned) == TARGET_EXPR)
6884 warning (0, "returning reference to temporary");
6887 if (TREE_CODE (whats_returned) == VAR_DECL
6888 && DECL_NAME (whats_returned)
6889 && TEMP_NAME_P (DECL_NAME (whats_returned)))
6891 warning (0, "reference to non-lvalue returned");
6896 while (TREE_CODE (whats_returned) == COMPONENT_REF
6897 || TREE_CODE (whats_returned) == ARRAY_REF)
6898 whats_returned = TREE_OPERAND (whats_returned, 0);
6900 if (DECL_P (whats_returned)
6901 && DECL_NAME (whats_returned)
6902 && DECL_FUNCTION_SCOPE_P (whats_returned)
6903 && !(TREE_STATIC (whats_returned)
6904 || TREE_PUBLIC (whats_returned)))
6906 if (TREE_CODE (valtype) == REFERENCE_TYPE)
6907 warning (0, "reference to local variable %q+D returned",
6910 warning (0, "address of local variable %q+D returned",
6916 /* Check that returning RETVAL from the current function is valid.
6917 Return an expression explicitly showing all conversions required to
6918 change RETVAL into the function return type, and to assign it to
6919 the DECL_RESULT for the function. Set *NO_WARNING to true if
6920 code reaches end of non-void function warning shouldn't be issued
6921 on this RETURN_EXPR. */
6924 check_return_expr (tree retval, bool *no_warning)
6927 /* The type actually returned by the function, after any
6930 int fn_returns_value_p;
6931 bool named_return_value_okay_p;
6933 *no_warning = false;
6935 /* A `volatile' function is one that isn't supposed to return, ever.
6936 (This is a G++ extension, used to get better code for functions
6937 that call the `volatile' function.) */
6938 if (TREE_THIS_VOLATILE (current_function_decl))
6939 warning (0, "function declared %<noreturn%> has a %<return%> statement");
6941 /* Check for various simple errors. */
6942 if (DECL_DESTRUCTOR_P (current_function_decl))
6945 error ("returning a value from a destructor");
6948 else if (DECL_CONSTRUCTOR_P (current_function_decl))
6950 if (in_function_try_handler)
6951 /* If a return statement appears in a handler of the
6952 function-try-block of a constructor, the program is ill-formed. */
6953 error ("cannot return from a handler of a function-try-block of a constructor");
6955 /* You can't return a value from a constructor. */
6956 error ("returning a value from a constructor");
6960 if (processing_template_decl)
6962 current_function_returns_value = 1;
6963 if (check_for_bare_parameter_packs (retval))
6964 retval = error_mark_node;
6968 /* When no explicit return-value is given in a function with a named
6969 return value, the named return value is used. */
6970 result = DECL_RESULT (current_function_decl);
6971 valtype = TREE_TYPE (result);
6972 gcc_assert (valtype != NULL_TREE);
6973 fn_returns_value_p = !VOID_TYPE_P (valtype);
6974 if (!retval && DECL_NAME (result) && fn_returns_value_p)
6977 /* Check for a return statement with no return value in a function
6978 that's supposed to return a value. */
6979 if (!retval && fn_returns_value_p)
6981 pedwarn ("return-statement with no value, in function returning %qT",
6983 /* Clear this, so finish_function won't say that we reach the
6984 end of a non-void function (which we don't, we gave a
6986 current_function_returns_null = 0;
6987 /* And signal caller that TREE_NO_WARNING should be set on the
6988 RETURN_EXPR to avoid control reaches end of non-void function
6989 warnings in tree-cfg.c. */
6992 /* Check for a return statement with a value in a function that
6993 isn't supposed to return a value. */
6994 else if (retval && !fn_returns_value_p)
6996 if (VOID_TYPE_P (TREE_TYPE (retval)))
6997 /* You can return a `void' value from a function of `void'
6998 type. In that case, we have to evaluate the expression for
6999 its side-effects. */
7000 finish_expr_stmt (retval);
7002 pedwarn ("return-statement with a value, in function "
7003 "returning 'void'");
7005 current_function_returns_null = 1;
7007 /* There's really no value to return, after all. */
7011 /* Remember that this function can sometimes return without a
7013 current_function_returns_null = 1;
7015 /* Remember that this function did return a value. */
7016 current_function_returns_value = 1;
7018 /* Check for erroneous operands -- but after giving ourselves a
7019 chance to provide an error about returning a value from a void
7021 if (error_operand_p (retval))
7023 current_function_return_value = error_mark_node;
7024 return error_mark_node;
7027 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
7028 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
7029 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
7030 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
7032 && retval && null_ptr_cst_p (retval))
7033 warning (0, "%<operator new%> must not return NULL unless it is "
7034 "declared %<throw()%> (or -fcheck-new is in effect)");
7036 /* Effective C++ rule 15. See also start_function. */
7038 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
7042 /* The function return type must be a reference to the current
7044 if (TREE_CODE (valtype) == REFERENCE_TYPE
7045 && same_type_ignoring_top_level_qualifiers_p
7046 (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
7048 /* Returning '*this' is obviously OK. */
7049 if (retval == current_class_ref)
7051 /* If we are calling a function whose return type is the same of
7052 the current class reference, it is ok. */
7053 else if (TREE_CODE (retval) == INDIRECT_REF
7054 && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
7059 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
7062 /* The fabled Named Return Value optimization, as per [class.copy]/15:
7064 [...] For a function with a class return type, if the expression
7065 in the return statement is the name of a local object, and the cv-
7066 unqualified type of the local object is the same as the function
7067 return type, an implementation is permitted to omit creating the tem-
7068 porary object to hold the function return value [...]
7070 So, if this is a value-returning function that always returns the same
7071 local variable, remember it.
7073 It might be nice to be more flexible, and choose the first suitable
7074 variable even if the function sometimes returns something else, but
7075 then we run the risk of clobbering the variable we chose if the other
7076 returned expression uses the chosen variable somehow. And people expect
7077 this restriction, anyway. (jason 2000-11-19)
7079 See finish_function and finalize_nrv for the rest of this optimization. */
7081 named_return_value_okay_p =
7082 (retval != NULL_TREE
7083 /* Must be a local, automatic variable. */
7084 && TREE_CODE (retval) == VAR_DECL
7085 && DECL_CONTEXT (retval) == current_function_decl
7086 && ! TREE_STATIC (retval)
7087 && ! DECL_ANON_UNION_VAR_P (retval)
7088 && (DECL_ALIGN (retval)
7089 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
7090 /* The cv-unqualified type of the returned value must be the
7091 same as the cv-unqualified return type of the
7093 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
7095 (TREE_TYPE (TREE_TYPE (current_function_decl)))))
7096 /* And the returned value must be non-volatile. */
7097 && ! TYPE_VOLATILE (TREE_TYPE (retval)));
7099 if (fn_returns_value_p && flag_elide_constructors)
7101 if (named_return_value_okay_p
7102 && (current_function_return_value == NULL_TREE
7103 || current_function_return_value == retval))
7104 current_function_return_value = retval;
7106 current_function_return_value = error_mark_node;
7109 /* We don't need to do any conversions when there's nothing being
7114 /* Do any required conversions. */
7115 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
7116 /* No conversions are required. */
7120 /* The type the function is declared to return. */
7121 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
7122 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
7124 /* The functype's return type will have been set to void, if it
7125 was an incomplete type. Just treat this as 'return;' */
7126 if (VOID_TYPE_P (functype))
7127 return error_mark_node;
7129 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
7130 treated as an rvalue for the purposes of overload resolution to
7131 favor move constructors over copy constructors. */
7132 if ((cxx_dialect != cxx98)
7133 && named_return_value_okay_p
7134 /* The variable must not have the `volatile' qualifier. */
7135 && !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
7136 /* The return type must be a class type. */
7137 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
7138 flags = flags | LOOKUP_PREFER_RVALUE;
7140 /* First convert the value to the function's return type, then
7141 to the type of return value's location to handle the
7142 case that functype is smaller than the valtype. */
7143 retval = convert_for_initialization
7144 (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0,
7145 tf_warning_or_error);
7146 retval = convert (valtype, retval);
7148 /* If the conversion failed, treat this just like `return;'. */
7149 if (retval == error_mark_node)
7151 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7152 else if (! cfun->returns_struct
7153 && TREE_CODE (retval) == TARGET_EXPR
7154 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
7155 retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
7156 TREE_OPERAND (retval, 0));
7158 maybe_warn_about_returning_address_of_local (retval);
7161 /* Actually copy the value returned into the appropriate location. */
7162 if (retval && retval != result)
7163 retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
7169 /* Returns nonzero if the pointer-type FROM can be converted to the
7170 pointer-type TO via a qualification conversion. If CONSTP is -1,
7171 then we return nonzero if the pointers are similar, and the
7172 cv-qualification signature of FROM is a proper subset of that of TO.
7174 If CONSTP is positive, then all outer pointers have been
7178 comp_ptr_ttypes_real (tree to, tree from, int constp)
7180 bool to_more_cv_qualified = false;
7182 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7184 if (TREE_CODE (to) != TREE_CODE (from))
7187 if (TREE_CODE (from) == OFFSET_TYPE
7188 && !same_type_p (TYPE_OFFSET_BASETYPE (from),
7189 TYPE_OFFSET_BASETYPE (to)))
7192 /* Const and volatile mean something different for function types,
7193 so the usual checks are not appropriate. */
7194 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7196 /* In Objective-C++, some types may have been 'volatilized' by
7197 the compiler for EH; when comparing them here, the volatile
7198 qualification must be ignored. */
7199 bool objc_quals_match = objc_type_quals_match (to, from);
7201 if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
7204 if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
7208 to_more_cv_qualified = true;
7212 constp &= TYPE_READONLY (to);
7215 if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
7216 return ((constp >= 0 || to_more_cv_qualified)
7217 && same_type_ignoring_top_level_qualifiers_p (to, from));
7221 /* When comparing, say, char ** to char const **, this function takes
7222 the 'char *' and 'char const *'. Do not pass non-pointer/reference
7223 types to this function. */
7226 comp_ptr_ttypes (tree to, tree from)
7228 return comp_ptr_ttypes_real (to, from, 1);
7231 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7232 type or inheritance-related types, regardless of cv-quals. */
7235 ptr_reasonably_similar (const_tree to, const_tree from)
7237 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7239 /* Any target type is similar enough to void. */
7240 if (TREE_CODE (to) == VOID_TYPE
7241 || TREE_CODE (from) == VOID_TYPE)
7244 if (TREE_CODE (to) != TREE_CODE (from))
7247 if (TREE_CODE (from) == OFFSET_TYPE
7248 && comptypes (TYPE_OFFSET_BASETYPE (to),
7249 TYPE_OFFSET_BASETYPE (from),
7250 COMPARE_BASE | COMPARE_DERIVED))
7253 if (TREE_CODE (to) == VECTOR_TYPE
7254 && vector_types_convertible_p (to, from, false))
7257 if (TREE_CODE (to) == INTEGER_TYPE
7258 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
7261 if (TREE_CODE (to) == FUNCTION_TYPE)
7264 if (TREE_CODE (to) != POINTER_TYPE)
7266 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7267 COMPARE_BASE | COMPARE_DERIVED);
7271 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7272 pointer-to-member types) are the same, ignoring cv-qualification at
7276 comp_ptr_ttypes_const (tree to, tree from)
7278 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7280 if (TREE_CODE (to) != TREE_CODE (from))
7283 if (TREE_CODE (from) == OFFSET_TYPE
7284 && same_type_p (TYPE_OFFSET_BASETYPE (from),
7285 TYPE_OFFSET_BASETYPE (to)))
7288 if (TREE_CODE (to) != POINTER_TYPE)
7289 return same_type_ignoring_top_level_qualifiers_p (to, from);
7293 /* Returns the type qualifiers for this type, including the qualifiers on the
7294 elements for an array type. */
7297 cp_type_quals (const_tree type)
7299 /* This CONST_CAST is okay because strip_array_types returns it's
7300 argument unmodified and we assign it to a const_tree. */
7301 type = strip_array_types (CONST_CAST_TREE(type));
7302 if (type == error_mark_node)
7303 return TYPE_UNQUALIFIED;
7304 return TYPE_QUALS (type);
7307 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7311 cp_type_readonly (const_tree type)
7313 /* This CONST_CAST is okay because strip_array_types returns it's
7314 argument unmodified and we assign it to a const_tree. */
7315 type = strip_array_types (CONST_CAST_TREE(type));
7316 return TYPE_READONLY (type);
7319 /* Returns nonzero if the TYPE contains a mutable member. */
7322 cp_has_mutable_p (const_tree type)
7324 /* This CONST_CAST is okay because strip_array_types returns it's
7325 argument unmodified and we assign it to a const_tree. */
7326 type = strip_array_types (CONST_CAST_TREE(type));
7328 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
7331 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7332 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7333 approximation. In particular, consider:
7336 struct S { int i; };
7337 const S s = { f(); }
7339 Here, we will make "s" as TREE_READONLY (because it is declared
7340 "const") -- only to reverse ourselves upon seeing that the
7341 initializer is non-constant. */
7344 cp_apply_type_quals_to_decl (int type_quals, tree decl)
7346 tree type = TREE_TYPE (decl);
7348 if (type == error_mark_node)
7351 if (TREE_CODE (type) == FUNCTION_TYPE
7352 && type_quals != TYPE_UNQUALIFIED)
7354 /* This was an error in C++98 (cv-qualifiers cannot be added to
7355 a function type), but DR 295 makes the code well-formed by
7356 dropping the extra qualifiers. */
7359 tree bad_type = build_qualified_type (type, type_quals);
7360 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7364 TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
7368 /* Avoid setting TREE_READONLY incorrectly. */
7369 if (/* If the object has a constructor, the constructor may modify
7371 TYPE_NEEDS_CONSTRUCTING (type)
7372 /* If the type isn't complete, we don't know yet if it will need
7374 || !COMPLETE_TYPE_P (type)
7375 /* If the type has a mutable component, that component might be
7377 || TYPE_HAS_MUTABLE_P (type))
7378 type_quals &= ~TYPE_QUAL_CONST;
7380 c_apply_type_quals_to_decl (type_quals, decl);
7383 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7384 exemplar types such that casting T1 to T2 is casting away constness
7385 if and only if there is no implicit conversion from T1 to T2. */
7388 casts_away_constness_r (tree *t1, tree *t2)
7393 /* [expr.const.cast]
7395 For multi-level pointer to members and multi-level mixed pointers
7396 and pointers to members (conv.qual), the "member" aspect of a
7397 pointer to member level is ignored when determining if a const
7398 cv-qualifier has been cast away. */
7399 /* [expr.const.cast]
7401 For two pointer types:
7403 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7404 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7407 casting from X1 to X2 casts away constness if, for a non-pointer
7408 type T there does not exist an implicit conversion (clause
7411 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7415 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7416 if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
7417 || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
7419 *t1 = cp_build_qualified_type (void_type_node,
7420 cp_type_quals (*t1));
7421 *t2 = cp_build_qualified_type (void_type_node,
7422 cp_type_quals (*t2));
7426 quals1 = cp_type_quals (*t1);
7427 quals2 = cp_type_quals (*t2);
7429 if (TYPE_PTRMEM_P (*t1))
7430 *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
7432 *t1 = TREE_TYPE (*t1);
7433 if (TYPE_PTRMEM_P (*t2))
7434 *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
7436 *t2 = TREE_TYPE (*t2);
7438 casts_away_constness_r (t1, t2);
7439 *t1 = build_pointer_type (*t1);
7440 *t2 = build_pointer_type (*t2);
7441 *t1 = cp_build_qualified_type (*t1, quals1);
7442 *t2 = cp_build_qualified_type (*t2, quals2);
7445 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7449 casts_away_constness (tree t1, tree t2)
7451 if (TREE_CODE (t2) == REFERENCE_TYPE)
7453 /* [expr.const.cast]
7455 Casting from an lvalue of type T1 to an lvalue of type T2
7456 using a reference cast casts away constness if a cast from an
7457 rvalue of type "pointer to T1" to the type "pointer to T2"
7458 casts away constness. */
7459 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
7460 return casts_away_constness (build_pointer_type (t1),
7461 build_pointer_type (TREE_TYPE (t2)));
7464 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
7465 /* [expr.const.cast]
7467 Casting from an rvalue of type "pointer to data member of X
7468 of type T1" to the type "pointer to data member of Y of type
7469 T2" casts away constness if a cast from an rvalue of type
7470 "pointer to T1" to the type "pointer to T2" casts away
7472 return casts_away_constness
7473 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
7474 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
7476 /* Casting away constness is only something that makes sense for
7477 pointer or reference types. */
7478 if (TREE_CODE (t1) != POINTER_TYPE
7479 || TREE_CODE (t2) != POINTER_TYPE)
7482 /* Top-level qualifiers don't matter. */
7483 t1 = TYPE_MAIN_VARIANT (t1);
7484 t2 = TYPE_MAIN_VARIANT (t2);
7485 casts_away_constness_r (&t1, &t2);
7486 if (!can_convert (t2, t1))
7492 /* If T is a REFERENCE_TYPE return the type to which T refers.
7493 Otherwise, return T itself. */
7496 non_reference (tree t)
7498 if (TREE_CODE (t) == REFERENCE_TYPE)
7504 /* Return nonzero if REF is an lvalue valid for this language;
7505 otherwise, print an error message and return zero. USE says
7506 how the lvalue is being used and so selects the error message. */
7509 lvalue_or_else (const_tree ref, enum lvalue_use use, tsubst_flags_t complain)
7511 int win = lvalue_p (ref);
7513 if (!win && (complain & tf_error))