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 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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"
46 static tree convert_for_assignment (tree, tree, const char *, tree, int);
47 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
48 static tree rationalize_conditional_expr (enum tree_code, tree);
49 static int comp_ptr_ttypes_real (tree, tree, int);
50 static int comp_ptr_ttypes_const (tree, tree);
51 static bool comp_except_types (tree, tree, bool);
52 static bool comp_array_types (tree, tree, bool);
53 static tree common_base_type (tree, tree);
54 static tree pointer_diff (tree, tree, tree);
55 static tree get_delta_difference (tree, tree, bool, bool);
56 static void casts_away_constness_r (tree *, tree *);
57 static bool casts_away_constness (tree, tree);
58 static void maybe_warn_about_returning_address_of_local (tree);
59 static tree lookup_destructor (tree, tree, tree);
60 static tree convert_arguments (tree, tree, tree, int);
62 /* Do `exp = require_complete_type (exp);' to make sure exp
63 does not have an incomplete type. (That includes void types.)
64 Returns the error_mark_node if the VALUE does not have
65 complete type when this function returns. */
68 require_complete_type (tree value)
72 if (processing_template_decl || value == error_mark_node)
75 if (TREE_CODE (value) == OVERLOAD)
76 type = unknown_type_node;
78 type = TREE_TYPE (value);
80 if (type == error_mark_node)
81 return error_mark_node;
83 /* First, detect a valid value with a complete type. */
84 if (COMPLETE_TYPE_P (type))
87 if (complete_type_or_else (type, value))
90 return error_mark_node;
93 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
94 a template instantiation, do the instantiation. Returns TYPE,
95 whether or not it could be completed, unless something goes
96 horribly wrong, in which case the error_mark_node is returned. */
99 complete_type (tree type)
101 if (type == NULL_TREE)
102 /* Rather than crash, we return something sure to cause an error
104 return error_mark_node;
106 if (type == error_mark_node || COMPLETE_TYPE_P (type))
108 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
110 tree t = complete_type (TREE_TYPE (type));
111 if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
113 TYPE_NEEDS_CONSTRUCTING (type)
114 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
115 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
116 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
118 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
119 instantiate_class_template (TYPE_MAIN_VARIANT (type));
124 /* Like complete_type, but issue an error if the TYPE cannot be completed.
125 VALUE is used for informative diagnostics.
126 Returns NULL_TREE if the type cannot be made complete. */
129 complete_type_or_else (tree type, tree value)
131 type = complete_type (type);
132 if (type == error_mark_node)
133 /* We already issued an error. */
135 else if (!COMPLETE_TYPE_P (type))
137 cxx_incomplete_type_diagnostic (value, type, 0);
144 /* Return truthvalue of whether type of EXP is instantiated. */
147 type_unknown_p (tree exp)
149 return (TREE_CODE (exp) == TREE_LIST
150 || TREE_TYPE (exp) == unknown_type_node);
154 /* Return the common type of two parameter lists.
155 We assume that comptypes has already been done and returned 1;
156 if that isn't so, this may crash.
158 As an optimization, free the space we allocate if the parameter
159 lists are already common. */
162 commonparms (tree p1, tree p2)
164 tree oldargs = p1, newargs, n;
168 len = list_length (p1);
169 newargs = tree_last (p1);
171 if (newargs == void_list_node)
180 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
185 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
187 if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
189 TREE_PURPOSE (n) = TREE_PURPOSE (p1);
192 else if (! TREE_PURPOSE (p1))
194 if (TREE_PURPOSE (p2))
196 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
202 if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
204 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
206 if (TREE_VALUE (p1) != TREE_VALUE (p2))
209 TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
212 TREE_VALUE (n) = TREE_VALUE (p1);
220 /* Given a type, perhaps copied for a typedef,
221 find the "original" version of it. */
223 original_type (tree t)
225 while (TYPE_NAME (t) != NULL_TREE)
227 tree x = TYPE_NAME (t);
228 if (TREE_CODE (x) != TYPE_DECL)
230 x = DECL_ORIGINAL_TYPE (x);
238 /* T1 and T2 are arithmetic or enumeration types. Return the type
239 that will result from the "usual arithmetic conversions" on T1 and
240 T2 as described in [expr]. */
243 type_after_usual_arithmetic_conversions (tree t1, tree t2)
245 enum tree_code code1 = TREE_CODE (t1);
246 enum tree_code code2 = TREE_CODE (t2);
249 /* FIXME: Attributes. */
250 gcc_assert (ARITHMETIC_TYPE_P (t1)
251 || TREE_CODE (t1) == COMPLEX_TYPE
252 || TREE_CODE (t1) == ENUMERAL_TYPE);
253 gcc_assert (ARITHMETIC_TYPE_P (t2)
254 || TREE_CODE (t2) == COMPLEX_TYPE
255 || TREE_CODE (t2) == ENUMERAL_TYPE);
257 /* In what follows, we slightly generalize the rules given in [expr] so
258 as to deal with `long long' and `complex'. First, merge the
260 attributes = (*targetm.merge_type_attributes) (t1, t2);
262 /* If one type is complex, form the common type of the non-complex
263 components, then make that complex. Use T1 or T2 if it is the
265 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
267 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
268 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
270 = type_after_usual_arithmetic_conversions (subtype1, subtype2);
272 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
273 return build_type_attribute_variant (t1, attributes);
274 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
275 return build_type_attribute_variant (t2, attributes);
277 return build_type_attribute_variant (build_complex_type (subtype),
281 /* If only one is real, use it as the result. */
282 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
283 return build_type_attribute_variant (t1, attributes);
284 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
285 return build_type_attribute_variant (t2, attributes);
287 /* Perform the integral promotions. */
288 if (code1 != REAL_TYPE)
290 t1 = type_promotes_to (t1);
291 t2 = type_promotes_to (t2);
294 /* Both real or both integers; use the one with greater precision. */
295 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
296 return build_type_attribute_variant (t1, attributes);
297 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
298 return build_type_attribute_variant (t2, attributes);
300 /* The types are the same; no need to do anything fancy. */
301 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
302 return build_type_attribute_variant (t1, attributes);
304 if (code1 != REAL_TYPE)
306 /* If one is a sizetype, use it so size_binop doesn't blow up. */
307 if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
308 return build_type_attribute_variant (t1, attributes);
309 if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
310 return build_type_attribute_variant (t2, attributes);
312 /* If one is unsigned long long, then convert the other to unsigned
314 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
315 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
316 return build_type_attribute_variant (long_long_unsigned_type_node,
318 /* If one is a long long, and the other is an unsigned long, and
319 long long can represent all the values of an unsigned long, then
320 convert to a long long. Otherwise, convert to an unsigned long
321 long. Otherwise, if either operand is long long, convert the
324 Since we're here, we know the TYPE_PRECISION is the same;
325 therefore converting to long long cannot represent all the values
326 of an unsigned long, so we choose unsigned long long in that
328 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
329 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
331 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
332 ? long_long_unsigned_type_node
333 : long_long_integer_type_node);
334 return build_type_attribute_variant (t, attributes);
337 /* Go through the same procedure, but for longs. */
338 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
339 || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
340 return build_type_attribute_variant (long_unsigned_type_node,
342 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
343 || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
345 tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
346 ? long_unsigned_type_node : long_integer_type_node);
347 return build_type_attribute_variant (t, attributes);
349 /* Otherwise prefer the unsigned one. */
350 if (TYPE_UNSIGNED (t1))
351 return build_type_attribute_variant (t1, attributes);
353 return build_type_attribute_variant (t2, attributes);
357 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
358 || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
359 return build_type_attribute_variant (long_double_type_node,
361 if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
362 || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
363 return build_type_attribute_variant (double_type_node,
365 if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
366 || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
367 return build_type_attribute_variant (float_type_node,
370 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
371 the standard C++ floating-point types. Logic earlier in this
372 function has already eliminated the possibility that
373 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
374 compelling reason to choose one or the other. */
375 return build_type_attribute_variant (t1, attributes);
379 /* Subroutine of composite_pointer_type to implement the recursive
380 case. See that function for documentation fo the parameters. */
383 composite_pointer_type_r (tree t1, tree t2, const char* location)
390 /* Determine the types pointed to by T1 and T2. */
391 if (TREE_CODE (t1) == POINTER_TYPE)
393 pointee1 = TREE_TYPE (t1);
394 pointee2 = TREE_TYPE (t2);
398 pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
399 pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
404 Otherwise, the composite pointer type is a pointer type
405 similar (_conv.qual_) to the type of one of the operands,
406 with a cv-qualification signature (_conv.qual_) that is the
407 union of the cv-qualification signatures of the operand
409 if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
410 result_type = pointee1;
411 else if ((TREE_CODE (pointee1) == POINTER_TYPE
412 && TREE_CODE (pointee2) == POINTER_TYPE)
413 || (TYPE_PTR_TO_MEMBER_P (pointee1)
414 && TYPE_PTR_TO_MEMBER_P (pointee2)))
415 result_type = composite_pointer_type_r (pointee1, pointee2, location);
418 pedwarn ("%s between distinct pointer types %qT and %qT "
421 result_type = void_type_node;
423 result_type = cp_build_qualified_type (result_type,
424 (cp_type_quals (pointee1)
425 | cp_type_quals (pointee2)));
426 /* If the original types were pointers to members, so is the
428 if (TYPE_PTR_TO_MEMBER_P (t1))
430 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
431 TYPE_PTRMEM_CLASS_TYPE (t2)))
432 pedwarn ("%s between distinct pointer types %qT and %qT "
435 result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
439 result_type = build_pointer_type (result_type);
441 /* Merge the attributes. */
442 attributes = (*targetm.merge_type_attributes) (t1, t2);
443 return build_type_attribute_variant (result_type, attributes);
446 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
447 ARG1 and ARG2 are the values with those types. The LOCATION is a
448 string describing the current location, in case an error occurs.
450 This routine also implements the computation of a common type for
451 pointers-to-members as per [expr.eq]. */
454 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
455 const char* location)
462 If one operand is a null pointer constant, the composite pointer
463 type is the type of the other operand. */
464 if (null_ptr_cst_p (arg1))
466 if (null_ptr_cst_p (arg2))
473 If one of the operands has type "pointer to cv1 void*", then
474 the other has type "pointer to cv2T", and the composite pointer
475 type is "pointer to cv12 void", where cv12 is the union of cv1
478 If either type is a pointer to void, make sure it is T1. */
479 if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
487 /* Now, if T1 is a pointer to void, merge the qualifiers. */
488 if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
493 if (pedantic && TYPE_PTRFN_P (t2))
494 pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
495 "and pointer-to-function", location);
497 = cp_build_qualified_type (void_type_node,
498 (cp_type_quals (TREE_TYPE (t1))
499 | cp_type_quals (TREE_TYPE (t2))));
500 result_type = build_pointer_type (result_type);
501 /* Merge the attributes. */
502 attributes = (*targetm.merge_type_attributes) (t1, t2);
503 return build_type_attribute_variant (result_type, attributes);
506 /* [expr.eq] permits the application of a pointer conversion to
507 bring the pointers to a common type. */
508 if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
509 && CLASS_TYPE_P (TREE_TYPE (t1))
510 && CLASS_TYPE_P (TREE_TYPE (t2))
511 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
514 class1 = TREE_TYPE (t1);
515 class2 = TREE_TYPE (t2);
517 if (DERIVED_FROM_P (class1, class2))
518 t2 = (build_pointer_type
519 (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
520 else if (DERIVED_FROM_P (class2, class1))
521 t1 = (build_pointer_type
522 (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
525 error ("%s between distinct pointer types %qT and %qT "
526 "lacks a cast", location, t1, t2);
527 return error_mark_node;
530 /* [expr.eq] permits the application of a pointer-to-member
531 conversion to change the class type of one of the types. */
532 else if (TYPE_PTR_TO_MEMBER_P (t1)
533 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
534 TYPE_PTRMEM_CLASS_TYPE (t2)))
536 class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
537 class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
539 if (DERIVED_FROM_P (class1, class2))
540 t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
541 else if (DERIVED_FROM_P (class2, class1))
542 t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
545 error ("%s between distinct pointer-to-member types %qT and %qT "
546 "lacks a cast", location, t1, t2);
547 return error_mark_node;
551 return composite_pointer_type_r (t1, t2, location);
554 /* Return the merged type of two types.
555 We assume that comptypes has already been done and returned 1;
556 if that isn't so, this may crash.
558 This just combines attributes and default arguments; any other
559 differences would cause the two types to compare unalike. */
562 merge_types (tree t1, tree t2)
564 enum tree_code code1;
565 enum tree_code code2;
568 /* Save time if the two types are the same. */
571 if (original_type (t1) == original_type (t2))
574 /* If one type is nonsense, use the other. */
575 if (t1 == error_mark_node)
577 if (t2 == error_mark_node)
580 /* Merge the attributes. */
581 attributes = (*targetm.merge_type_attributes) (t1, t2);
583 if (TYPE_PTRMEMFUNC_P (t1))
584 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
585 if (TYPE_PTRMEMFUNC_P (t2))
586 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
588 code1 = TREE_CODE (t1);
589 code2 = TREE_CODE (t2);
595 /* For two pointers, do this recursively on the target type. */
597 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
598 int quals = cp_type_quals (t1);
600 if (code1 == POINTER_TYPE)
601 t1 = build_pointer_type (target);
603 t1 = build_reference_type (target);
604 t1 = build_type_attribute_variant (t1, attributes);
605 t1 = cp_build_qualified_type (t1, quals);
607 if (TREE_CODE (target) == METHOD_TYPE)
608 t1 = build_ptrmemfunc_type (t1);
617 quals = cp_type_quals (t1);
618 pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
619 TYPE_PTRMEM_POINTED_TO_TYPE (t2));
620 t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
622 t1 = cp_build_qualified_type (t1, quals);
628 tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
629 /* Save space: see if the result is identical to one of the args. */
630 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
631 return build_type_attribute_variant (t1, attributes);
632 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
633 return build_type_attribute_variant (t2, attributes);
634 /* Merge the element types, and have a size if either arg has one. */
635 t1 = build_cplus_array_type
636 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
641 /* Function types: prefer the one that specified arg types.
642 If both do, merge the arg types. Also merge the return types. */
644 tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
645 tree p1 = TYPE_ARG_TYPES (t1);
646 tree p2 = TYPE_ARG_TYPES (t2);
649 /* Save space: see if the result is identical to one of the args. */
650 if (valtype == TREE_TYPE (t1) && ! p2)
651 return cp_build_type_attribute_variant (t1, attributes);
652 if (valtype == TREE_TYPE (t2) && ! p1)
653 return cp_build_type_attribute_variant (t2, attributes);
655 /* Simple way if one arg fails to specify argument types. */
656 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
658 rval = build_function_type (valtype, p2);
659 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
660 rval = build_exception_variant (rval, raises);
661 return cp_build_type_attribute_variant (rval, attributes);
663 raises = TYPE_RAISES_EXCEPTIONS (t1);
664 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
666 rval = build_function_type (valtype, p1);
668 rval = build_exception_variant (rval, raises);
669 return cp_build_type_attribute_variant (rval, attributes);
672 rval = build_function_type (valtype, commonparms (p1, p2));
673 t1 = build_exception_variant (rval, raises);
679 /* Get this value the long way, since TYPE_METHOD_BASETYPE
680 is just the main variant of this. */
681 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
682 tree raises = TYPE_RAISES_EXCEPTIONS (t1);
685 /* If this was a member function type, get back to the
686 original type of type member function (i.e., without
687 the class instance variable up front. */
688 t1 = build_function_type (TREE_TYPE (t1),
689 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
690 t2 = build_function_type (TREE_TYPE (t2),
691 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
692 t3 = merge_types (t1, t2);
693 t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
694 TYPE_ARG_TYPES (t3));
695 t1 = build_exception_variant (t3, raises);
700 /* There is no need to merge attributes into a TYPENAME_TYPE.
701 When the type is instantiated it will have whatever
702 attributes result from the instantiation. */
707 return cp_build_type_attribute_variant (t1, attributes);
710 /* Return the common type of two types.
711 We assume that comptypes has already been done and returned 1;
712 if that isn't so, this may crash.
714 This is the type for the result of most arithmetic operations
715 if the operands have the given two types. */
718 common_type (tree t1, tree t2)
720 enum tree_code code1;
721 enum tree_code code2;
723 /* If one type is nonsense, bail. */
724 if (t1 == error_mark_node || t2 == error_mark_node)
725 return error_mark_node;
727 code1 = TREE_CODE (t1);
728 code2 = TREE_CODE (t2);
730 if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
731 || code1 == COMPLEX_TYPE)
732 && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
733 || code2 == COMPLEX_TYPE))
734 return type_after_usual_arithmetic_conversions (t1, t2);
736 else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
737 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
738 || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
739 return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
745 /* Compare two exception specifier types for exactness or subsetness, if
746 allowed. Returns false for mismatch, true for match (same, or
749 [except.spec] "If a class X ... objects of class X or any class publicly
750 and unambiguously derived from X. Similarly, if a pointer type Y * ...
751 exceptions of type Y * or that are pointers to any type publicly and
752 unambiguously derived from Y. Otherwise a function only allows exceptions
753 that have the same type ..."
754 This does not mention cv qualifiers and is different to what throw
755 [except.throw] and catch [except.catch] will do. They will ignore the
756 top level cv qualifiers, and allow qualifiers in the pointer to class
759 We implement the letter of the standard. */
762 comp_except_types (tree a, tree b, bool exact)
764 if (same_type_p (a, b))
768 if (cp_type_quals (a) || cp_type_quals (b))
771 if (TREE_CODE (a) == POINTER_TYPE
772 && TREE_CODE (b) == POINTER_TYPE)
776 if (cp_type_quals (a) || cp_type_quals (b))
780 if (TREE_CODE (a) != RECORD_TYPE
781 || TREE_CODE (b) != RECORD_TYPE)
784 if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
790 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
791 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
792 otherwise it must be exact. Exception lists are unordered, but
793 we've already filtered out duplicates. Most lists will be in order,
794 we should try to make use of that. */
797 comp_except_specs (tree t1, tree t2, bool exact)
806 if (t1 == NULL_TREE) /* T1 is ... */
807 return t2 == NULL_TREE || !exact;
808 if (!TREE_VALUE (t1)) /* t1 is EMPTY */
809 return t2 != NULL_TREE && !TREE_VALUE (t2);
810 if (t2 == NULL_TREE) /* T2 is ... */
812 if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
815 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
816 Count how many we find, to determine exactness. For exact matching and
817 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
819 for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
821 for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
823 tree a = TREE_VALUE (probe);
824 tree b = TREE_VALUE (t2);
826 if (comp_except_types (a, b, exact))
828 if (probe == base && exact)
829 base = TREE_CHAIN (probe);
834 if (probe == NULL_TREE)
837 return !exact || base == NULL_TREE || length == list_length (t1);
840 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
841 [] can match [size]. */
844 comp_array_types (tree t1, tree t2, bool allow_redeclaration)
853 /* The type of the array elements must be the same. */
854 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
857 d1 = TYPE_DOMAIN (t1);
858 d2 = TYPE_DOMAIN (t2);
863 /* If one of the arrays is dimensionless, and the other has a
864 dimension, they are of different types. However, it is valid to
872 declarations for an array object can specify
873 array types that differ by the presence or absence of a major
874 array bound (_dcl.array_). */
876 return allow_redeclaration;
878 /* Check that the dimensions are the same. */
880 if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
882 max1 = TYPE_MAX_VALUE (d1);
883 max2 = TYPE_MAX_VALUE (d2);
884 if (processing_template_decl && !abi_version_at_least (2)
885 && !value_dependent_expression_p (max1)
886 && !value_dependent_expression_p (max2))
888 /* With abi-1 we do not fold non-dependent array bounds, (and
889 consequently mangle them incorrectly). We must therefore
890 fold them here, to verify the domains have the same
896 if (!cp_tree_equal (max1, max2))
902 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
903 is a bitwise-or of the COMPARE_* flags. */
906 comptypes (tree t1, tree t2, int strict)
913 /* Suppress errors caused by previously reported errors. */
914 if (t1 == error_mark_node || t2 == error_mark_node)
917 gcc_assert (TYPE_P (t1) && TYPE_P (t2));
919 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
920 current instantiation. */
921 if (TREE_CODE (t1) == TYPENAME_TYPE)
923 tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
925 if (resolved != error_mark_node)
929 if (TREE_CODE (t2) == TYPENAME_TYPE)
931 tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
933 if (resolved != error_mark_node)
937 /* If either type is the internal version of sizetype, use the
939 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
940 && TYPE_ORIG_SIZE_TYPE (t1))
941 t1 = TYPE_ORIG_SIZE_TYPE (t1);
943 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
944 && TYPE_ORIG_SIZE_TYPE (t2))
945 t2 = TYPE_ORIG_SIZE_TYPE (t2);
947 if (TYPE_PTRMEMFUNC_P (t1))
948 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
949 if (TYPE_PTRMEMFUNC_P (t2))
950 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
952 /* Different classes of types can't be compatible. */
953 if (TREE_CODE (t1) != TREE_CODE (t2))
956 /* Qualifiers must match. For array types, we will check when we
957 recur on the array element types. */
958 if (TREE_CODE (t1) != ARRAY_TYPE
959 && TYPE_QUALS (t1) != TYPE_QUALS (t2))
961 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
964 /* Allow for two different type nodes which have essentially the same
965 definition. Note that we already checked for equality of the type
966 qualifiers (just above). */
968 if (TREE_CODE (t1) != ARRAY_TYPE
969 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
972 if (!(*targetm.comp_type_attributes) (t1, t2))
975 switch (TREE_CODE (t1))
977 case TEMPLATE_TEMPLATE_PARM:
978 case BOUND_TEMPLATE_TEMPLATE_PARM:
979 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
980 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
982 if (!comp_template_parms
983 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
984 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
986 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
988 /* Don't check inheritance. */
989 strict = COMPARE_STRICT;
994 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
995 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
996 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
997 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1000 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1002 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1005 /* We may be dealing with Objective-C instances... */
1006 if (TREE_CODE (t1) == RECORD_TYPE
1007 && ((retval = objc_comptypes (t1, t2, 0)) >= 0))
1009 /* ...but fall through if we are not. */
1014 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1015 strict & ~COMPARE_REDECLARATION))
1017 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1020 case REFERENCE_TYPE:
1021 return TYPE_MODE (t1) == TYPE_MODE (t2)
1022 && TYPE_REF_CAN_ALIAS_ALL (t1) == TYPE_REF_CAN_ALIAS_ALL (t2)
1023 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1027 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1029 return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
1032 /* Target types must match incl. qualifiers. */
1033 return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION));
1035 case TEMPLATE_TYPE_PARM:
1036 return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
1037 && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2));
1040 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1041 TYPENAME_TYPE_FULLNAME (t2)))
1043 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1045 case UNBOUND_CLASS_TEMPLATE:
1046 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1048 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1051 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1054 return TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1055 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1064 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1067 at_least_as_qualified_p (tree type1, tree type2)
1069 int q1 = cp_type_quals (type1);
1070 int q2 = cp_type_quals (type2);
1072 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1073 return (q1 & q2) == q2;
1076 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1077 more cv-qualified that TYPE1, and 0 otherwise. */
1080 comp_cv_qualification (tree type1, tree type2)
1082 int q1 = cp_type_quals (type1);
1083 int q2 = cp_type_quals (type2);
1088 if ((q1 & q2) == q2)
1090 else if ((q1 & q2) == q1)
1096 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1097 subset of the cv-qualification signature of TYPE2, and the types
1098 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1101 comp_cv_qual_signature (tree type1, tree type2)
1103 if (comp_ptr_ttypes_real (type2, type1, -1))
1105 else if (comp_ptr_ttypes_real (type1, type2, -1))
1111 /* If two types share a common base type, return that basetype.
1112 If there is not a unique most-derived base type, this function
1113 returns ERROR_MARK_NODE. */
1116 common_base_type (tree tt1, tree tt2)
1118 tree best = NULL_TREE;
1121 /* If one is a baseclass of another, that's good enough. */
1122 if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1124 if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1127 /* Otherwise, try to find a unique baseclass of TT1
1128 that is shared by TT2, and follow that down. */
1129 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt1))-1; i >= 0; i--)
1131 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt1), i));
1132 tree trial = common_base_type (basetype, tt2);
1136 if (trial == error_mark_node)
1138 if (best == NULL_TREE)
1140 else if (best != trial)
1141 return error_mark_node;
1146 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt2))-1; i >= 0; i--)
1148 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt2), i));
1149 tree trial = common_base_type (tt1, basetype);
1153 if (trial == error_mark_node)
1155 if (best == NULL_TREE)
1157 else if (best != trial)
1158 return error_mark_node;
1164 /* Subroutines of `comptypes'. */
1166 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1167 equivalent in the sense that functions with those parameter types
1168 can have equivalent types. The two lists must be equivalent,
1169 element by element. */
1172 compparms (tree parms1, tree parms2)
1176 /* An unspecified parmlist matches any specified parmlist
1177 whose argument types don't need default promotions. */
1179 for (t1 = parms1, t2 = parms2;
1181 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1183 /* If one parmlist is shorter than the other,
1184 they fail to match. */
1187 if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1194 /* Process a sizeof or alignof expression where the operand is a
1198 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1200 enum tree_code type_code;
1202 const char *op_name;
1204 gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1205 if (type == error_mark_node)
1206 return error_mark_node;
1208 if (processing_template_decl)
1210 value = build_min (op, size_type_node, type);
1211 TREE_READONLY (value) = 1;
1215 op_name = operator_name_info[(int) op].name;
1217 type = non_reference (type);
1218 type_code = TREE_CODE (type);
1220 if (type_code == METHOD_TYPE)
1222 if (complain && (pedantic || warn_pointer_arith))
1223 pedwarn ("invalid application of %qs to a member function", op_name);
1224 value = size_one_node;
1227 value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
1232 /* Process a sizeof or alignof expression where the operand is an
1236 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
1238 const char *op_name = operator_name_info[(int) op].name;
1240 if (e == error_mark_node)
1241 return error_mark_node;
1243 if (processing_template_decl)
1245 e = build_min (op, size_type_node, e);
1246 TREE_SIDE_EFFECTS (e) = 0;
1247 TREE_READONLY (e) = 1;
1252 if (TREE_CODE (e) == COMPONENT_REF
1253 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1254 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1256 error ("invalid application of %qs to a bit-field", op_name);
1259 else if (is_overloaded_fn (e))
1261 pedwarn ("ISO C++ forbids applying %qs to an expression of "
1262 "function type", op_name);
1265 else if (type_unknown_p (e))
1267 cxx_incomplete_type_error (e, TREE_TYPE (e));
1273 return cxx_sizeof_or_alignof_type (e, op, true);
1277 /* EXPR is being used in a context that is not a function call.
1282 The expression can be used only as the left-hand operand of a
1283 member function call.
1285 [expr.mptr.operator]
1287 If the result of .* or ->* is a function, then that result can be
1288 used only as the operand for the function call operator ().
1290 by issuing an error message if appropriate. Returns true iff EXPR
1291 violates these rules. */
1294 invalid_nonstatic_memfn_p (tree expr)
1296 if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
1298 error ("invalid use of non-static member function");
1304 /* Perform the conversions in [expr] that apply when an lvalue appears
1305 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1306 function-to-pointer conversions.
1308 In addition manifest constants are replaced by their values. */
1311 decay_conversion (tree exp)
1314 enum tree_code code;
1316 type = TREE_TYPE (exp);
1317 code = TREE_CODE (type);
1319 if (type == error_mark_node)
1320 return error_mark_node;
1322 if (type_unknown_p (exp))
1324 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1325 return error_mark_node;
1328 exp = integral_constant_value (exp);
1330 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1331 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1333 if (code == VOID_TYPE)
1335 error ("void value not ignored as it ought to be");
1336 return error_mark_node;
1338 if (invalid_nonstatic_memfn_p (exp))
1339 return error_mark_node;
1340 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1341 return build_unary_op (ADDR_EXPR, exp, 0);
1342 if (code == ARRAY_TYPE)
1347 if (TREE_CODE (exp) == INDIRECT_REF)
1348 return build_nop (build_pointer_type (TREE_TYPE (type)),
1349 TREE_OPERAND (exp, 0));
1351 if (TREE_CODE (exp) == COMPOUND_EXPR)
1353 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1354 return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1355 TREE_OPERAND (exp, 0), op1);
1359 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1361 error ("invalid use of non-lvalue array");
1362 return error_mark_node;
1365 ptrtype = build_pointer_type (TREE_TYPE (type));
1367 if (TREE_CODE (exp) == VAR_DECL)
1369 if (!cxx_mark_addressable (exp))
1370 return error_mark_node;
1371 adr = build_nop (ptrtype, build_address (exp));
1374 /* This way is better for a COMPONENT_REF since it can
1375 simplify the offset for a component. */
1376 adr = build_unary_op (ADDR_EXPR, exp, 1);
1377 return cp_convert (ptrtype, adr);
1380 /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1381 rvalues always have cv-unqualified types. */
1382 if (! CLASS_TYPE_P (type))
1383 exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1389 default_conversion (tree exp)
1391 exp = decay_conversion (exp);
1393 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1394 exp = perform_integral_promotions (exp);
1399 /* EXPR is an expression with an integral or enumeration type.
1400 Perform the integral promotions in [conv.prom], and return the
1404 perform_integral_promotions (tree expr)
1409 type = TREE_TYPE (expr);
1410 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1411 promoted_type = type_promotes_to (type);
1412 if (type != promoted_type)
1413 expr = cp_convert (promoted_type, expr);
1417 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1421 inline_conversion (tree exp)
1423 if (TREE_CODE (exp) == FUNCTION_DECL)
1424 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1429 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1430 decay_conversion to one. */
1433 string_conv_p (tree totype, tree exp, int warn)
1437 if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1440 t = TREE_TYPE (totype);
1441 if (!same_type_p (t, char_type_node)
1442 && !same_type_p (t, wchar_type_node))
1445 if (TREE_CODE (exp) == STRING_CST)
1447 /* Make sure that we don't try to convert between char and wchar_t. */
1448 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1453 /* Is this a string constant which has decayed to 'const char *'? */
1454 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1455 if (!same_type_p (TREE_TYPE (exp), t))
1458 if (TREE_CODE (exp) != ADDR_EXPR
1459 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1463 /* This warning is not very useful, as it complains about printf. */
1464 if (warn && warn_write_strings)
1465 warning ("deprecated conversion from string constant to %qT'", totype);
1470 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1471 can, for example, use as an lvalue. This code used to be in
1472 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1473 expressions, where we're dealing with aggregates. But now it's again only
1474 called from unary_complex_lvalue. The case (in particular) that led to
1475 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1479 rationalize_conditional_expr (enum tree_code code, tree t)
1481 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1482 the first operand is always the one to be used if both operands
1483 are equal, so we know what conditional expression this used to be. */
1484 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1486 /* The following code is incorrect if either operand side-effects. */
1487 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
1488 && !TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)));
1490 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1491 ? LE_EXPR : GE_EXPR),
1492 TREE_OPERAND (t, 0),
1493 TREE_OPERAND (t, 1),
1494 /*overloaded_p=*/NULL),
1495 build_unary_op (code, TREE_OPERAND (t, 0), 0),
1496 build_unary_op (code, TREE_OPERAND (t, 1), 0));
1500 build_conditional_expr (TREE_OPERAND (t, 0),
1501 build_unary_op (code, TREE_OPERAND (t, 1), 0),
1502 build_unary_op (code, TREE_OPERAND (t, 2), 0));
1505 /* Given the TYPE of an anonymous union field inside T, return the
1506 FIELD_DECL for the field. If not found return NULL_TREE. Because
1507 anonymous unions can nest, we must also search all anonymous unions
1508 that are directly reachable. */
1511 lookup_anon_field (tree t, tree type)
1515 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1517 if (TREE_STATIC (field))
1519 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1522 /* If we find it directly, return the field. */
1523 if (DECL_NAME (field) == NULL_TREE
1524 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1529 /* Otherwise, it could be nested, search harder. */
1530 if (DECL_NAME (field) == NULL_TREE
1531 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1533 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1541 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1542 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1543 non-NULL, it indicates the path to the base used to name MEMBER.
1544 If PRESERVE_REFERENCE is true, the expression returned will have
1545 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1546 returned will have the type referred to by the reference.
1548 This function does not perform access control; that is either done
1549 earlier by the parser when the name of MEMBER is resolved to MEMBER
1550 itself, or later when overload resolution selects one of the
1551 functions indicated by MEMBER. */
1554 build_class_member_access_expr (tree object, tree member,
1555 tree access_path, bool preserve_reference)
1559 tree result = NULL_TREE;
1561 if (object == error_mark_node || member == error_mark_node)
1562 return error_mark_node;
1564 gcc_assert (DECL_P (member) || BASELINK_P (member));
1568 The type of the first expression shall be "class object" (of a
1570 object_type = TREE_TYPE (object);
1571 if (!currently_open_class (object_type)
1572 && !complete_type_or_else (object_type, object))
1573 return error_mark_node;
1574 if (!CLASS_TYPE_P (object_type))
1576 error ("request for member %qD in %qE, which is of non-class type %qT",
1577 member, object, object_type);
1578 return error_mark_node;
1581 /* The standard does not seem to actually say that MEMBER must be a
1582 member of OBJECT_TYPE. However, that is clearly what is
1584 if (DECL_P (member))
1586 member_scope = DECL_CLASS_CONTEXT (member);
1588 if (TREE_DEPRECATED (member))
1589 warn_deprecated_use (member);
1592 member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1593 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1594 presently be the anonymous union. Go outwards until we find a
1595 type related to OBJECT_TYPE. */
1596 while (ANON_AGGR_TYPE_P (member_scope)
1597 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1599 member_scope = TYPE_CONTEXT (member_scope);
1600 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1602 if (TREE_CODE (member) == FIELD_DECL)
1603 error ("invalid use of nonstatic data member %qE", member);
1605 error ("%qD is not a member of %qT", member, object_type);
1606 return error_mark_node;
1609 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1610 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1611 in the frontend; only _DECLs and _REFs are lvalues in the backend. */
1613 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1615 object = build_indirect_ref (temp, NULL);
1618 /* In [expr.ref], there is an explicit list of the valid choices for
1619 MEMBER. We check for each of those cases here. */
1620 if (TREE_CODE (member) == VAR_DECL)
1622 /* A static data member. */
1624 /* If OBJECT has side-effects, they are supposed to occur. */
1625 if (TREE_SIDE_EFFECTS (object))
1626 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1628 else if (TREE_CODE (member) == FIELD_DECL)
1630 /* A non-static data member. */
1635 null_object_p = (TREE_CODE (object) == INDIRECT_REF
1636 && integer_zerop (TREE_OPERAND (object, 0)));
1638 /* Convert OBJECT to the type of MEMBER. */
1639 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1640 TYPE_MAIN_VARIANT (member_scope)))
1645 binfo = lookup_base (access_path ? access_path : object_type,
1646 member_scope, ba_unique, &kind);
1647 if (binfo == error_mark_node)
1648 return error_mark_node;
1650 /* It is invalid to try to get to a virtual base of a
1651 NULL object. The most common cause is invalid use of
1653 if (null_object_p && kind == bk_via_virtual)
1655 error ("invalid access to non-static data member %qD of "
1658 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
1659 return error_mark_node;
1662 /* Convert to the base. */
1663 object = build_base_path (PLUS_EXPR, object, binfo,
1665 /* If we found the base successfully then we should be able
1666 to convert to it successfully. */
1667 gcc_assert (object != error_mark_node);
1670 /* Complain about other invalid uses of offsetof, even though they will
1671 give the right answer. Note that we complain whether or not they
1672 actually used the offsetof macro, since there's no way to know at this
1673 point. So we just give a warning, instead of a pedwarn. */
1674 /* Do not produce this warning for base class field references, because
1675 we know for a fact that didn't come from offsetof. This does occur
1676 in various testsuite cases where a null object is passed where a
1677 vtable access is required. */
1678 if (null_object_p && warn_invalid_offsetof
1679 && CLASSTYPE_NON_POD_P (object_type)
1680 && !DECL_FIELD_IS_BASE (member)
1681 && !skip_evaluation)
1683 warning ("invalid access to non-static data member %qD of NULL object",
1685 warning ("(perhaps the %<offsetof%> macro was used incorrectly)");
1688 /* If MEMBER is from an anonymous aggregate, we have converted
1689 OBJECT so that it refers to the class containing the
1690 anonymous union. Generate a reference to the anonymous union
1691 itself, and recur to find MEMBER. */
1692 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1693 /* When this code is called from build_field_call, the
1694 object already has the type of the anonymous union.
1695 That is because the COMPONENT_REF was already
1696 constructed, and was then disassembled before calling
1697 build_field_call. After the function-call code is
1698 cleaned up, this waste can be eliminated. */
1699 && (!same_type_ignoring_top_level_qualifiers_p
1700 (TREE_TYPE (object), DECL_CONTEXT (member))))
1702 tree anonymous_union;
1704 anonymous_union = lookup_anon_field (TREE_TYPE (object),
1705 DECL_CONTEXT (member));
1706 object = build_class_member_access_expr (object,
1708 /*access_path=*/NULL_TREE,
1709 preserve_reference);
1712 /* Compute the type of the field, as described in [expr.ref]. */
1713 type_quals = TYPE_UNQUALIFIED;
1714 member_type = TREE_TYPE (member);
1715 if (TREE_CODE (member_type) != REFERENCE_TYPE)
1717 type_quals = (cp_type_quals (member_type)
1718 | cp_type_quals (object_type));
1720 /* A field is const (volatile) if the enclosing object, or the
1721 field itself, is const (volatile). But, a mutable field is
1722 not const, even within a const object. */
1723 if (DECL_MUTABLE_P (member))
1724 type_quals &= ~TYPE_QUAL_CONST;
1725 member_type = cp_build_qualified_type (member_type, type_quals);
1728 result = build3 (COMPONENT_REF, member_type, object, member,
1730 result = fold_if_not_in_template (result);
1732 /* Mark the expression const or volatile, as appropriate. Even
1733 though we've dealt with the type above, we still have to mark the
1734 expression itself. */
1735 if (type_quals & TYPE_QUAL_CONST)
1736 TREE_READONLY (result) = 1;
1737 if (type_quals & TYPE_QUAL_VOLATILE)
1738 TREE_THIS_VOLATILE (result) = 1;
1740 else if (BASELINK_P (member))
1742 /* The member is a (possibly overloaded) member function. */
1746 /* If the MEMBER is exactly one static member function, then we
1747 know the type of the expression. Otherwise, we must wait
1748 until overload resolution has been performed. */
1749 functions = BASELINK_FUNCTIONS (member);
1750 if (TREE_CODE (functions) == FUNCTION_DECL
1751 && DECL_STATIC_FUNCTION_P (functions))
1752 type = TREE_TYPE (functions);
1754 type = unknown_type_node;
1755 /* Note that we do not convert OBJECT to the BASELINK_BINFO
1756 base. That will happen when the function is called. */
1757 result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
1759 else if (TREE_CODE (member) == CONST_DECL)
1761 /* The member is an enumerator. */
1763 /* If OBJECT has side-effects, they are supposed to occur. */
1764 if (TREE_SIDE_EFFECTS (object))
1765 result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
1770 error ("invalid use of %qD", member);
1771 return error_mark_node;
1774 if (!preserve_reference)
1777 If E2 is declared to have type "reference to T", then ... the
1778 type of E1.E2 is T. */
1779 result = convert_from_reference (result);
1784 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
1785 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
1788 lookup_destructor (tree object, tree scope, tree dtor_name)
1790 tree object_type = TREE_TYPE (object);
1791 tree dtor_type = TREE_OPERAND (dtor_name, 0);
1794 if (scope && !check_dtor_name (scope, dtor_name))
1796 error ("qualified type %qT does not match destructor name ~%qT",
1798 return error_mark_node;
1800 if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
1802 error ("the type being destroyed is %qT, but the destructor refers to %qT",
1803 TYPE_MAIN_VARIANT (object_type), dtor_type);
1804 return error_mark_node;
1806 expr = lookup_member (dtor_type, complete_dtor_identifier,
1807 /*protect=*/1, /*want_type=*/false);
1808 expr = (adjust_result_of_qualified_name_lookup
1809 (expr, dtor_type, object_type));
1813 /* This function is called by the parser to process a class member
1814 access expression of the form OBJECT.NAME. NAME is a node used by
1815 the parser to represent a name; it is not yet a DECL. It may,
1816 however, be a BASELINK where the BASELINK_FUNCTIONS is a
1817 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
1818 there is no reason to do the lookup twice, so the parser keeps the
1822 finish_class_member_access_expr (tree object, tree name)
1827 tree access_path = NULL_TREE;
1828 tree orig_object = object;
1829 tree orig_name = name;
1831 if (object == error_mark_node || name == error_mark_node)
1832 return error_mark_node;
1834 object_type = TREE_TYPE (object);
1836 if (processing_template_decl)
1838 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
1839 dependent_type_p (object_type)
1840 /* If NAME is just an IDENTIFIER_NODE, then the expression
1842 || TREE_CODE (object) == IDENTIFIER_NODE
1843 /* If NAME is "f<args>", where either 'f' or 'args' is
1844 dependent, then the expression is dependent. */
1845 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
1846 && dependent_template_id_p (TREE_OPERAND (name, 0),
1847 TREE_OPERAND (name, 1)))
1848 /* If NAME is "T::X" where "T" is dependent, then the
1849 expression is dependent. */
1850 || (TREE_CODE (name) == SCOPE_REF
1851 && TYPE_P (TREE_OPERAND (name, 0))
1852 && dependent_type_p (TREE_OPERAND (name, 0))))
1853 return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
1854 object = build_non_dependent_expr (object);
1859 The type of the first expression shall be "class object" (of a
1861 if (!currently_open_class (object_type)
1862 && !complete_type_or_else (object_type, object))
1863 return error_mark_node;
1864 if (!CLASS_TYPE_P (object_type))
1866 error ("request for member %qD in %qE, which is of non-class type %qT",
1867 name, object, object_type);
1868 return error_mark_node;
1871 if (BASELINK_P (name))
1873 /* A member function that has already been looked up. */
1874 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name)) == TEMPLATE_ID_EXPR);
1879 bool is_template_id = false;
1880 tree template_args = NULL_TREE;
1883 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1885 is_template_id = true;
1886 template_args = TREE_OPERAND (name, 1);
1887 name = TREE_OPERAND (name, 0);
1889 if (TREE_CODE (name) == OVERLOAD)
1890 name = DECL_NAME (get_first_fn (name));
1891 else if (DECL_P (name))
1892 name = DECL_NAME (name);
1895 if (TREE_CODE (name) == SCOPE_REF)
1897 /* A qualified name. The qualifying class or namespace `S' has
1898 already been looked up; it is either a TYPE or a
1899 NAMESPACE_DECL. The member name is either an IDENTIFIER_NODE
1900 or a BIT_NOT_EXPR. */
1901 scope = TREE_OPERAND (name, 0);
1902 name = TREE_OPERAND (name, 1);
1903 gcc_assert (CLASS_TYPE_P (scope)
1904 || TREE_CODE (scope) == NAMESPACE_DECL);
1905 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
1906 || TREE_CODE (name) == BIT_NOT_EXPR);
1908 /* If SCOPE is a namespace, then the qualified name does not
1909 name a member of OBJECT_TYPE. */
1910 if (TREE_CODE (scope) == NAMESPACE_DECL)
1912 error ("%<%D::%D%> is not a member of %qT",
1913 scope, name, object_type);
1914 return error_mark_node;
1917 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
1918 access_path = lookup_base (object_type, scope, ba_check, NULL);
1919 if (access_path == error_mark_node)
1920 return error_mark_node;
1923 error ("%qT is not a base of %qT", scope, object_type);
1924 return error_mark_node;
1930 access_path = object_type;
1933 if (TREE_CODE (name) == BIT_NOT_EXPR)
1934 member = lookup_destructor (object, scope, name);
1937 /* Look up the member. */
1938 member = lookup_member (access_path, name, /*protect=*/1,
1939 /*want_type=*/false);
1940 if (member == NULL_TREE)
1942 error ("%qD has no member named %qE", object_type, name);
1943 return error_mark_node;
1945 if (member == error_mark_node)
1946 return error_mark_node;
1951 tree template = member;
1953 if (BASELINK_P (template))
1954 template = lookup_template_function (template, template_args);
1957 error ("%qD is not a member template function", name);
1958 return error_mark_node;
1963 if (TREE_DEPRECATED (member))
1964 warn_deprecated_use (member);
1966 expr = build_class_member_access_expr (object, member, access_path,
1967 /*preserve_reference=*/false);
1968 if (processing_template_decl && expr != error_mark_node)
1969 return build_min_non_dep (COMPONENT_REF, expr,
1970 orig_object, orig_name, NULL_TREE);
1974 /* Return an expression for the MEMBER_NAME field in the internal
1975 representation of PTRMEM, a pointer-to-member function. (Each
1976 pointer-to-member function type gets its own RECORD_TYPE so it is
1977 more convenient to access the fields by name than by FIELD_DECL.)
1978 This routine converts the NAME to a FIELD_DECL and then creates the
1979 node for the complete expression. */
1982 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
1988 /* This code is a stripped down version of
1989 build_class_member_access_expr. It does not work to use that
1990 routine directly because it expects the object to be of class
1992 ptrmem_type = TREE_TYPE (ptrmem);
1993 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
1994 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
1995 /*want_type=*/false);
1996 member_type = cp_build_qualified_type (TREE_TYPE (member),
1997 cp_type_quals (ptrmem_type));
1998 return fold (build3 (COMPONENT_REF, member_type,
1999 ptrmem, member, NULL_TREE));
2002 /* Given an expression PTR for a pointer, return an expression
2003 for the value pointed to.
2004 ERRORSTRING is the name of the operator to appear in error messages.
2006 This function may need to overload OPERATOR_FNNAME.
2007 Must also handle REFERENCE_TYPEs for C++. */
2010 build_x_indirect_ref (tree expr, const char *errorstring)
2012 tree orig_expr = expr;
2015 if (processing_template_decl)
2017 if (type_dependent_expression_p (expr))
2018 return build_min_nt (INDIRECT_REF, expr);
2019 expr = build_non_dependent_expr (expr);
2022 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2023 NULL_TREE, /*overloaded_p=*/NULL);
2025 rval = build_indirect_ref (expr, errorstring);
2027 if (processing_template_decl && rval != error_mark_node)
2028 return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2034 build_indirect_ref (tree ptr, const char *errorstring)
2038 if (ptr == error_mark_node)
2039 return error_mark_node;
2041 if (ptr == current_class_ptr)
2042 return current_class_ref;
2044 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2045 ? ptr : decay_conversion (ptr));
2046 type = TREE_TYPE (pointer);
2048 if (POINTER_TYPE_P (type))
2052 If the type of the expression is "pointer to T," the type
2053 of the result is "T."
2055 We must use the canonical variant because certain parts of
2056 the back end, like fold, do pointer comparisons between
2058 tree t = canonical_type_variant (TREE_TYPE (type));
2060 if (VOID_TYPE_P (t))
2062 /* A pointer to incomplete type (other than cv void) can be
2063 dereferenced [expr.unary.op]/1 */
2064 error ("%qT is not a pointer-to-object type", type);
2065 return error_mark_node;
2067 else if (TREE_CODE (pointer) == ADDR_EXPR
2068 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2069 /* The POINTER was something like `&x'. We simplify `*&x' to
2071 return TREE_OPERAND (pointer, 0);
2074 tree ref = build1 (INDIRECT_REF, t, pointer);
2076 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2077 so that we get the proper error message if the result is used
2078 to assign to. Also, &* is supposed to be a no-op. */
2079 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2080 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2081 TREE_SIDE_EFFECTS (ref)
2082 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2086 /* `pointer' won't be an error_mark_node if we were given a
2087 pointer to member, so it's cool to check for this here. */
2088 else if (TYPE_PTR_TO_MEMBER_P (type))
2089 error ("invalid use of %qs on pointer to member", errorstring);
2090 else if (pointer != error_mark_node)
2093 error ("invalid type argument of %qs", errorstring);
2095 error ("invalid type argument");
2097 return error_mark_node;
2100 /* This handles expressions of the form "a[i]", which denotes
2103 This is logically equivalent in C to *(a+i), but we may do it differently.
2104 If A is a variable or a member, we generate a primitive ARRAY_REF.
2105 This avoids forcing the array out of registers, and can work on
2106 arrays that are not lvalues (for example, members of structures returned
2109 If INDEX is of some user-defined type, it must be converted to
2110 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2111 will inherit the type of the array, which will be some pointer type. */
2114 build_array_ref (tree array, tree idx)
2118 error ("subscript missing in array reference");
2119 return error_mark_node;
2122 if (TREE_TYPE (array) == error_mark_node
2123 || TREE_TYPE (idx) == error_mark_node)
2124 return error_mark_node;
2126 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2128 switch (TREE_CODE (array))
2132 tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2133 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2134 TREE_OPERAND (array, 0), value);
2138 return build_conditional_expr
2139 (TREE_OPERAND (array, 0),
2140 build_array_ref (TREE_OPERAND (array, 1), idx),
2141 build_array_ref (TREE_OPERAND (array, 2), idx));
2147 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2151 /* Subscripting with type char is likely to lose
2152 on a machine where chars are signed.
2153 So warn on any machine, but optionally.
2154 Don't warn for unsigned char since that type is safe.
2155 Don't warn for signed char because anyone who uses that
2156 must have done so deliberately. */
2157 if (warn_char_subscripts
2158 && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2159 warning ("array subscript has type %<char%>");
2161 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2163 error ("array subscript is not an integer");
2164 return error_mark_node;
2167 /* Apply integral promotions *after* noticing character types.
2168 (It is unclear why we do these promotions -- the standard
2169 does not say that we should. In fact, the natural thing would
2170 seem to be to convert IDX to ptrdiff_t; we're performing
2171 pointer arithmetic.) */
2172 idx = perform_integral_promotions (idx);
2174 /* An array that is indexed by a non-constant
2175 cannot be stored in a register; we must be able to do
2176 address arithmetic on its address.
2177 Likewise an array of elements of variable size. */
2178 if (TREE_CODE (idx) != INTEGER_CST
2179 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2180 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2183 if (!cxx_mark_addressable (array))
2184 return error_mark_node;
2187 /* An array that is indexed by a constant value which is not within
2188 the array bounds cannot be stored in a register either; because we
2189 would get a crash in store_bit_field/extract_bit_field when trying
2190 to access a non-existent part of the register. */
2191 if (TREE_CODE (idx) == INTEGER_CST
2192 && TYPE_DOMAIN (TREE_TYPE (array))
2193 && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2195 if (!cxx_mark_addressable (array))
2196 return error_mark_node;
2199 if (pedantic && !lvalue_p (array))
2200 pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2202 /* Note in C++ it is valid to subscript a `register' array, since
2203 it is valid to take the address of something with that
2204 storage specification. */
2208 while (TREE_CODE (foo) == COMPONENT_REF)
2209 foo = TREE_OPERAND (foo, 0);
2210 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2211 warning ("subscripting array declared %<register%>");
2214 type = TREE_TYPE (TREE_TYPE (array));
2215 rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2216 /* Array ref is const/volatile if the array elements are
2217 or if the array is.. */
2218 TREE_READONLY (rval)
2219 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2220 TREE_SIDE_EFFECTS (rval)
2221 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2222 TREE_THIS_VOLATILE (rval)
2223 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2224 return require_complete_type (fold_if_not_in_template (rval));
2228 tree ar = default_conversion (array);
2229 tree ind = default_conversion (idx);
2231 /* Put the integer in IND to simplify error checking. */
2232 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2239 if (ar == error_mark_node)
2242 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2244 error ("subscripted value is neither array nor pointer");
2245 return error_mark_node;
2247 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2249 error ("array subscript is not an integer");
2250 return error_mark_node;
2253 return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2258 /* Resolve a pointer to member function. INSTANCE is the object
2259 instance to use, if the member points to a virtual member.
2261 This used to avoid checking for virtual functions if basetype
2262 has no virtual functions, according to an earlier ANSI draft.
2263 With the final ISO C++ rules, such an optimization is
2264 incorrect: A pointer to a derived member can be static_cast
2265 to pointer-to-base-member, as long as the dynamic object
2266 later has the right member. */
2269 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2271 if (TREE_CODE (function) == OFFSET_REF)
2272 function = TREE_OPERAND (function, 1);
2274 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2276 tree idx, delta, e1, e2, e3, vtbl, basetype;
2277 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2279 tree instance_ptr = *instance_ptrptr;
2280 tree instance_save_expr = 0;
2281 if (instance_ptr == error_mark_node)
2283 if (TREE_CODE (function) == PTRMEM_CST)
2285 /* Extracting the function address from a pmf is only
2286 allowed with -Wno-pmf-conversions. It only works for
2288 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2289 e1 = convert (fntype, e1);
2294 error ("object missing in use of %qE", function);
2295 return error_mark_node;
2299 if (TREE_SIDE_EFFECTS (instance_ptr))
2300 instance_ptr = instance_save_expr = save_expr (instance_ptr);
2302 if (TREE_SIDE_EFFECTS (function))
2303 function = save_expr (function);
2305 /* Start by extracting all the information from the PMF itself. */
2306 e3 = pfn_from_ptrmemfunc (function);
2307 delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2308 idx = build1 (NOP_EXPR, vtable_index_type, e3);
2309 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2311 case ptrmemfunc_vbit_in_pfn:
2312 e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2313 idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2316 case ptrmemfunc_vbit_in_delta:
2317 e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2318 delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2325 /* Convert down to the right base before using the instance. First
2327 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2328 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2329 basetype, ba_check, NULL);
2330 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2331 if (instance_ptr == error_mark_node)
2332 return error_mark_node;
2333 /* ...and then the delta in the PMF. */
2334 instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr),
2335 instance_ptr, delta);
2337 /* Hand back the adjusted 'this' argument to our caller. */
2338 *instance_ptrptr = instance_ptr;
2340 /* Next extract the vtable pointer from the object. */
2341 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2343 vtbl = build_indirect_ref (vtbl, NULL);
2345 /* Finally, extract the function pointer from the vtable. */
2346 e2 = fold (build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
2347 e2 = build_indirect_ref (e2, NULL);
2348 TREE_CONSTANT (e2) = 1;
2349 TREE_INVARIANT (e2) = 1;
2351 /* When using function descriptors, the address of the
2352 vtable entry is treated as a function pointer. */
2353 if (TARGET_VTABLE_USES_DESCRIPTORS)
2354 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2355 build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2357 TREE_TYPE (e2) = TREE_TYPE (e3);
2358 e1 = build_conditional_expr (e1, e2, e3);
2360 /* Make sure this doesn't get evaluated first inside one of the
2361 branches of the COND_EXPR. */
2362 if (instance_save_expr)
2363 e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
2364 instance_save_expr, e1);
2372 build_function_call (tree function, tree params)
2374 tree fntype, fndecl;
2375 tree coerced_params;
2376 tree name = NULL_TREE;
2378 tree original = function;
2380 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2381 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2382 if (TREE_CODE (function) == NOP_EXPR
2383 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2384 function = TREE_OPERAND (function, 0);
2386 if (TREE_CODE (function) == FUNCTION_DECL)
2388 name = DECL_NAME (function);
2390 mark_used (function);
2393 /* Convert anything with function type to a pointer-to-function. */
2394 if (pedantic && DECL_MAIN_P (function))
2395 pedwarn ("ISO C++ forbids calling %<::main%> from within program");
2397 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2398 (because calling an inline function does not mean the function
2399 needs to be separately compiled). */
2401 if (DECL_INLINE (function))
2402 function = inline_conversion (function);
2404 function = build_addr_func (function);
2410 function = build_addr_func (function);
2413 if (function == error_mark_node)
2414 return error_mark_node;
2416 fntype = TREE_TYPE (function);
2418 if (TYPE_PTRMEMFUNC_P (fntype))
2420 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2421 "function in %<%E (...)%>",
2423 return error_mark_node;
2426 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2427 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2429 if (!((TREE_CODE (fntype) == POINTER_TYPE
2430 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2432 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2434 error ("%qE cannot be used as a function", original);
2435 return error_mark_node;
2438 /* fntype now gets the type of function pointed to. */
2439 fntype = TREE_TYPE (fntype);
2441 /* Convert the parameters to the types declared in the
2442 function prototype, or apply default promotions. */
2444 coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2445 params, fndecl, LOOKUP_NORMAL);
2446 if (coerced_params == error_mark_node)
2447 return error_mark_node;
2449 /* Check for errors in format strings and inappropriately
2452 check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
2454 return build_cxx_call (function, coerced_params);
2457 /* Convert the actual parameter expressions in the list VALUES
2458 to the types in the list TYPELIST.
2459 If parmdecls is exhausted, or when an element has NULL as its type,
2460 perform the default conversions.
2462 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2464 This is also where warnings about wrong number of args are generated.
2466 Return a list of expressions for the parameters as converted.
2468 Both VALUES and the returned value are chains of TREE_LIST nodes
2469 with the elements of the list in the TREE_VALUE slots of those nodes.
2471 In C++, unspecified trailing parameters can be filled in with their
2472 default arguments, if such were specified. Do so here. */
2475 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2477 tree typetail, valtail;
2478 tree result = NULL_TREE;
2479 const char *called_thing = 0;
2482 /* Argument passing is always copy-initialization. */
2483 flags |= LOOKUP_ONLYCONVERTING;
2487 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2489 if (DECL_NAME (fndecl) == NULL_TREE
2490 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2491 called_thing = "constructor";
2493 called_thing = "member function";
2496 called_thing = "function";
2499 for (valtail = values, typetail = typelist;
2501 valtail = TREE_CHAIN (valtail), i++)
2503 tree type = typetail ? TREE_VALUE (typetail) : 0;
2504 tree val = TREE_VALUE (valtail);
2506 if (val == error_mark_node)
2507 return error_mark_node;
2509 if (type == void_type_node)
2513 cp_error_at ("too many arguments to %s %q+#D", called_thing,
2515 error ("at this point in file");
2518 error ("too many arguments to function");
2519 /* In case anybody wants to know if this argument
2522 TREE_TYPE (tree_last (result)) = error_mark_node;
2526 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2527 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2528 if (TREE_CODE (val) == NOP_EXPR
2529 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2530 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2531 val = TREE_OPERAND (val, 0);
2533 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2535 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2536 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2537 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2538 val = decay_conversion (val);
2541 if (val == error_mark_node)
2542 return error_mark_node;
2546 /* Formal parm type is specified by a function prototype. */
2549 if (!COMPLETE_TYPE_P (complete_type (type)))
2552 error ("parameter %P of %qD has incomplete type %qT",
2555 error ("parameter %P has incomplete type %qT", i, type);
2556 parmval = error_mark_node;
2560 parmval = convert_for_initialization
2561 (NULL_TREE, type, val, flags,
2562 "argument passing", fndecl, i);
2563 parmval = convert_for_arg_passing (type, parmval);
2566 if (parmval == error_mark_node)
2567 return error_mark_node;
2569 result = tree_cons (NULL_TREE, parmval, result);
2573 if (fndecl && DECL_BUILT_IN (fndecl)
2574 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2575 /* Don't do ellipsis conversion for __built_in_constant_p
2576 as this will result in spurious warnings for non-POD
2578 val = require_complete_type (val);
2580 val = convert_arg_to_ellipsis (val);
2582 result = tree_cons (NULL_TREE, val, result);
2586 typetail = TREE_CHAIN (typetail);
2589 if (typetail != 0 && typetail != void_list_node)
2591 /* See if there are default arguments that can be used. */
2592 if (TREE_PURPOSE (typetail)
2593 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2595 for (; typetail != void_list_node; ++i)
2598 = convert_default_arg (TREE_VALUE (typetail),
2599 TREE_PURPOSE (typetail),
2602 if (parmval == error_mark_node)
2603 return error_mark_node;
2605 result = tree_cons (0, parmval, result);
2606 typetail = TREE_CHAIN (typetail);
2607 /* ends with `...'. */
2608 if (typetail == NULL_TREE)
2616 cp_error_at ("too few arguments to %s %q+#D",
2617 called_thing, fndecl);
2618 error ("at this point in file");
2621 error ("too few arguments to function");
2622 return error_mark_list;
2626 return nreverse (result);
2629 /* Build a binary-operation expression, after performing default
2630 conversions on the operands. CODE is the kind of expression to build. */
2633 build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
2643 if (processing_template_decl)
2645 if (type_dependent_expression_p (arg1)
2646 || type_dependent_expression_p (arg2))
2647 return build_min_nt (code, arg1, arg2);
2648 arg1 = build_non_dependent_expr (arg1);
2649 arg2 = build_non_dependent_expr (arg2);
2652 if (code == DOTSTAR_EXPR)
2653 expr = build_m_component_ref (arg1, arg2);
2655 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
2658 if (processing_template_decl && expr != error_mark_node)
2659 return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
2664 /* Build a binary-operation expression without default conversions.
2665 CODE is the kind of expression to build.
2666 This function differs from `build' in several ways:
2667 the data type of the result is computed and recorded in it,
2668 warnings are generated if arg data types are invalid,
2669 special handling for addition and subtraction of pointers is known,
2670 and some optimization is done (operations on narrow ints
2671 are done in the narrower type when that gives the same result).
2672 Constant folding is also done before the result is returned.
2674 Note that the operands will never have enumeral types
2675 because either they have just had the default conversions performed
2676 or they have both just been converted to some other type in which
2677 the arithmetic is to be done.
2679 C++: must do special pointer arithmetic when implementing
2680 multiple inheritance, and deal with pointer to member functions. */
2683 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2684 int convert_p ATTRIBUTE_UNUSED)
2687 enum tree_code code0, code1;
2690 /* Expression code to give to the expression when it is built.
2691 Normally this is CODE, which is what the caller asked for,
2692 but in some special cases we change it. */
2693 enum tree_code resultcode = code;
2695 /* Data type in which the computation is to be performed.
2696 In the simplest cases this is the common type of the arguments. */
2697 tree result_type = NULL;
2699 /* Nonzero means operands have already been type-converted
2700 in whatever way is necessary.
2701 Zero means they need to be converted to RESULT_TYPE. */
2704 /* Nonzero means create the expression with this type, rather than
2706 tree build_type = 0;
2708 /* Nonzero means after finally constructing the expression
2709 convert it to this type. */
2710 tree final_type = 0;
2714 /* Nonzero if this is an operation like MIN or MAX which can
2715 safely be computed in short if both args are promoted shorts.
2716 Also implies COMMON.
2717 -1 indicates a bitwise operation; this makes a difference
2718 in the exact conditions for when it is safe to do the operation
2719 in a narrower mode. */
2722 /* Nonzero if this is a comparison operation;
2723 if both args are promoted shorts, compare the original shorts.
2724 Also implies COMMON. */
2725 int short_compare = 0;
2727 /* Nonzero if this is a right-shift operation, which can be computed on the
2728 original short and then promoted if the operand is a promoted short. */
2729 int short_shift = 0;
2731 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2734 /* True if both operands have arithmetic type. */
2735 bool arithmetic_types_p;
2737 /* Apply default conversions. */
2741 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2742 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2743 || code == TRUTH_XOR_EXPR)
2745 if (!really_overloaded_fn (op0))
2746 op0 = decay_conversion (op0);
2747 if (!really_overloaded_fn (op1))
2748 op1 = decay_conversion (op1);
2752 if (!really_overloaded_fn (op0))
2753 op0 = default_conversion (op0);
2754 if (!really_overloaded_fn (op1))
2755 op1 = default_conversion (op1);
2758 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2759 STRIP_TYPE_NOPS (op0);
2760 STRIP_TYPE_NOPS (op1);
2762 /* DTRT if one side is an overloaded function, but complain about it. */
2763 if (type_unknown_p (op0))
2765 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2766 if (t != error_mark_node)
2768 pedwarn ("assuming cast to type %qT from overloaded function",
2773 if (type_unknown_p (op1))
2775 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2776 if (t != error_mark_node)
2778 pedwarn ("assuming cast to type %qT from overloaded function",
2784 type0 = TREE_TYPE (op0);
2785 type1 = TREE_TYPE (op1);
2787 /* The expression codes of the data types of the arguments tell us
2788 whether the arguments are integers, floating, pointers, etc. */
2789 code0 = TREE_CODE (type0);
2790 code1 = TREE_CODE (type1);
2792 /* If an error was already reported for one of the arguments,
2793 avoid reporting another error. */
2795 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2796 return error_mark_node;
2801 /* Handle the pointer + int case. */
2802 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2803 return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
2804 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2805 return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
2811 /* Subtraction of two similar pointers.
2812 We must subtract them as integers, then divide by object size. */
2813 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2814 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
2816 return pointer_diff (op0, op1, common_type (type0, type1));
2817 /* Handle pointer minus int. Just like pointer plus int. */
2818 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2819 return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
2828 case TRUNC_DIV_EXPR:
2830 case FLOOR_DIV_EXPR:
2831 case ROUND_DIV_EXPR:
2832 case EXACT_DIV_EXPR:
2833 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2834 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2835 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2836 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
2838 if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
2839 warning ("division by zero in %<%E / 0%>", op0);
2840 else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
2841 warning ("division by zero in %<%E / 0.%>", op0);
2843 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2844 code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
2845 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
2846 code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
2848 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2849 resultcode = RDIV_EXPR;
2851 /* When dividing two signed integers, we have to promote to int.
2852 unless we divide by a constant != -1. Note that default
2853 conversion will have been performed on the operands at this
2854 point, so we have to dig out the original type to find out if
2856 shorten = ((TREE_CODE (op0) == NOP_EXPR
2857 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2858 || (TREE_CODE (op1) == INTEGER_CST
2859 && ! integer_all_onesp (op1)));
2868 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2872 case TRUNC_MOD_EXPR:
2873 case FLOOR_MOD_EXPR:
2874 if (code1 == INTEGER_TYPE && integer_zerop (op1))
2875 warning ("division by zero in %<%E %% 0%>", op0);
2876 else if (code1 == REAL_TYPE && real_zerop (op1))
2877 warning ("division by zero in %<%E %% 0.%>", op0);
2879 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2881 /* Although it would be tempting to shorten always here, that loses
2882 on some targets, since the modulo instruction is undefined if the
2883 quotient can't be represented in the computation mode. We shorten
2884 only if unsigned or if dividing by something we know != -1. */
2885 shorten = ((TREE_CODE (op0) == NOP_EXPR
2886 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2887 || (TREE_CODE (op1) == INTEGER_CST
2888 && ! integer_all_onesp (op1)));
2893 case TRUTH_ANDIF_EXPR:
2894 case TRUTH_ORIF_EXPR:
2895 case TRUTH_AND_EXPR:
2897 result_type = boolean_type_node;
2900 /* Shift operations: result has same type as first operand;
2901 always convert second operand to int.
2902 Also set SHORT_SHIFT if shifting rightward. */
2905 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2907 result_type = type0;
2908 if (TREE_CODE (op1) == INTEGER_CST)
2910 if (tree_int_cst_lt (op1, integer_zero_node))
2911 warning ("right shift count is negative");
2914 if (! integer_zerop (op1))
2916 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2917 warning ("right shift count >= width of type");
2920 /* Convert the shift-count to an integer, regardless of
2921 size of value being shifted. */
2922 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2923 op1 = cp_convert (integer_type_node, op1);
2924 /* Avoid converting op1 to result_type later. */
2930 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2932 result_type = type0;
2933 if (TREE_CODE (op1) == INTEGER_CST)
2935 if (tree_int_cst_lt (op1, integer_zero_node))
2936 warning ("left shift count is negative");
2937 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2938 warning ("left shift count >= width of type");
2940 /* Convert the shift-count to an integer, regardless of
2941 size of value being shifted. */
2942 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2943 op1 = cp_convert (integer_type_node, op1);
2944 /* Avoid converting op1 to result_type later. */
2951 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2953 result_type = type0;
2954 if (TREE_CODE (op1) == INTEGER_CST)
2956 if (tree_int_cst_lt (op1, integer_zero_node))
2957 warning ("%s rotate count is negative",
2958 (code == LROTATE_EXPR) ? "left" : "right");
2959 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2960 warning ("%s rotate count >= width of type",
2961 (code == LROTATE_EXPR) ? "left" : "right");
2963 /* Convert the shift-count to an integer, regardless of
2964 size of value being shifted. */
2965 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2966 op1 = cp_convert (integer_type_node, op1);
2972 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2973 warning ("comparing floating point with == or != is unsafe");
2975 build_type = boolean_type_node;
2976 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2977 || code0 == COMPLEX_TYPE)
2978 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2979 || code1 == COMPLEX_TYPE))
2981 else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2982 || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
2983 result_type = composite_pointer_type (type0, type1, op0, op1,
2985 else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
2986 && null_ptr_cst_p (op1))
2987 result_type = type0;
2988 else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
2989 && null_ptr_cst_p (op0))
2990 result_type = type1;
2991 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2993 result_type = type0;
2994 error ("ISO C++ forbids comparison between pointer and integer");
2996 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2998 result_type = type1;
2999 error ("ISO C++ forbids comparison between pointer and integer");
3001 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3003 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3004 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3005 result_type = TREE_TYPE (op0);
3007 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3008 return cp_build_binary_op (code, op1, op0);
3009 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3010 && same_type_p (type0, type1))
3012 /* E will be the final comparison. */
3014 /* E1 and E2 are for scratch. */
3022 if (TREE_SIDE_EFFECTS (op0))
3023 op0 = save_expr (op0);
3024 if (TREE_SIDE_EFFECTS (op1))
3025 op1 = save_expr (op1);
3030 && (!op0.pfn || op0.delta == op1.delta))
3032 The reason for the `!op0.pfn' bit is that a NULL
3033 pointer-to-member is any member with a zero PFN; the
3034 DELTA field is unspecified. */
3035 pfn0 = pfn_from_ptrmemfunc (op0);
3036 pfn1 = pfn_from_ptrmemfunc (op1);
3037 delta0 = build_ptrmemfunc_access_expr (op0,
3039 delta1 = build_ptrmemfunc_access_expr (op1,
3041 e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3042 e2 = cp_build_binary_op (EQ_EXPR,
3044 cp_convert (TREE_TYPE (pfn0),
3045 integer_zero_node));
3046 e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3047 e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3048 e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3049 if (code == EQ_EXPR)
3051 return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3055 gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3056 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3058 gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3059 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3067 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3068 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3070 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3071 result_type = composite_pointer_type (type0, type1, op0, op1,
3079 build_type = boolean_type_node;
3080 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3081 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3083 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3084 result_type = composite_pointer_type (type0, type1, op0, op1,
3086 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3087 && integer_zerop (op1))
3088 result_type = type0;
3089 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3090 && integer_zerop (op0))
3091 result_type = type1;
3092 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3094 result_type = type0;
3095 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3097 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3099 result_type = type1;
3100 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3104 case UNORDERED_EXPR:
3111 build_type = integer_type_node;
3112 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3114 error ("unordered comparison on non-floating point argument");
3115 return error_mark_node;
3124 arithmetic_types_p =
3125 ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3126 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3127 || code1 == COMPLEX_TYPE));
3128 /* Determine the RESULT_TYPE, if it is not already known. */
3130 && arithmetic_types_p
3131 && (shorten || common || short_compare))
3132 result_type = common_type (type0, type1);
3136 error ("invalid operands of types %qT and %qT to binary %qO",
3137 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3138 return error_mark_node;
3141 /* If we're in a template, the only thing we need to know is the
3143 if (processing_template_decl)
3144 return build2 (resultcode,
3145 build_type ? build_type : result_type,
3148 if (arithmetic_types_p)
3150 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3152 /* For certain operations (which identify themselves by shorten != 0)
3153 if both args were extended from the same smaller type,
3154 do the arithmetic in that type and then extend.
3156 shorten !=0 and !=1 indicates a bitwise operation.
3157 For them, this optimization is safe only if
3158 both args are zero-extended or both are sign-extended.
3159 Otherwise, we might change the result.
3160 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3161 but calculated in (unsigned short) it would be (unsigned short)-1. */
3163 if (shorten && none_complex)
3165 int unsigned0, unsigned1;
3166 tree arg0 = get_narrower (op0, &unsigned0);
3167 tree arg1 = get_narrower (op1, &unsigned1);
3168 /* UNS is 1 if the operation to be done is an unsigned one. */
3169 int uns = TYPE_UNSIGNED (result_type);
3172 final_type = result_type;
3174 /* Handle the case that OP0 does not *contain* a conversion
3175 but it *requires* conversion to FINAL_TYPE. */
3177 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3178 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3179 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3180 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3182 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3184 /* For bitwise operations, signedness of nominal type
3185 does not matter. Consider only how operands were extended. */
3189 /* Note that in all three cases below we refrain from optimizing
3190 an unsigned operation on sign-extended args.
3191 That would not be valid. */
3193 /* Both args variable: if both extended in same way
3194 from same width, do it in that width.
3195 Do it unsigned if args were zero-extended. */
3196 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3197 < TYPE_PRECISION (result_type))
3198 && (TYPE_PRECISION (TREE_TYPE (arg1))
3199 == TYPE_PRECISION (TREE_TYPE (arg0)))
3200 && unsigned0 == unsigned1
3201 && (unsigned0 || !uns))
3202 result_type = c_common_signed_or_unsigned_type
3203 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3204 else if (TREE_CODE (arg0) == INTEGER_CST
3205 && (unsigned1 || !uns)
3206 && (TYPE_PRECISION (TREE_TYPE (arg1))
3207 < TYPE_PRECISION (result_type))
3208 && (type = c_common_signed_or_unsigned_type
3209 (unsigned1, TREE_TYPE (arg1)),
3210 int_fits_type_p (arg0, type)))
3212 else if (TREE_CODE (arg1) == INTEGER_CST
3213 && (unsigned0 || !uns)
3214 && (TYPE_PRECISION (TREE_TYPE (arg0))
3215 < TYPE_PRECISION (result_type))
3216 && (type = c_common_signed_or_unsigned_type
3217 (unsigned0, TREE_TYPE (arg0)),
3218 int_fits_type_p (arg1, type)))
3222 /* Shifts can be shortened if shifting right. */
3227 tree arg0 = get_narrower (op0, &unsigned_arg);
3229 final_type = result_type;
3231 if (arg0 == op0 && final_type == TREE_TYPE (op0))
3232 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
3234 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3235 /* We can shorten only if the shift count is less than the
3236 number of bits in the smaller type size. */
3237 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3238 /* If arg is sign-extended and then unsigned-shifted,
3239 we can simulate this with a signed shift in arg's type
3240 only if the extended result is at least twice as wide
3241 as the arg. Otherwise, the shift could use up all the
3242 ones made by sign-extension and bring in zeros.
3243 We can't optimize that case at all, but in most machines
3244 it never happens because available widths are 2**N. */
3245 && (!TYPE_UNSIGNED (final_type)
3247 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3248 <= TYPE_PRECISION (result_type))))
3250 /* Do an unsigned shift if the operand was zero-extended. */
3252 = c_common_signed_or_unsigned_type (unsigned_arg,
3254 /* Convert value-to-be-shifted to that type. */
3255 if (TREE_TYPE (op0) != result_type)
3256 op0 = cp_convert (result_type, op0);
3261 /* Comparison operations are shortened too but differently.
3262 They identify themselves by setting short_compare = 1. */
3266 /* Don't write &op0, etc., because that would prevent op0
3267 from being kept in a register.
3268 Instead, make copies of the our local variables and
3269 pass the copies by reference, then copy them back afterward. */
3270 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3271 enum tree_code xresultcode = resultcode;
3273 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3275 return cp_convert (boolean_type_node, val);
3276 op0 = xop0, op1 = xop1;
3278 resultcode = xresultcode;
3281 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3282 && warn_sign_compare
3283 /* Do not warn until the template is instantiated; we cannot
3284 bound the ranges of the arguments until that point. */
3285 && !processing_template_decl)
3287 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
3288 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3290 int unsignedp0, unsignedp1;
3291 tree primop0 = get_narrower (op0, &unsignedp0);
3292 tree primop1 = get_narrower (op1, &unsignedp1);
3294 /* Check for comparison of different enum types. */
3295 if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3296 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3297 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3298 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3300 warning ("comparison between types %q#T and %q#T",
3301 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3304 /* Give warnings for comparisons between signed and unsigned
3305 quantities that may fail. */
3306 /* Do the checking based on the original operand trees, so that
3307 casts will be considered, but default promotions won't be. */
3309 /* Do not warn if the comparison is being done in a signed type,
3310 since the signed type will only be chosen if it can represent
3311 all the values of the unsigned type. */
3312 if (!TYPE_UNSIGNED (result_type))
3314 /* Do not warn if both operands are unsigned. */
3315 else if (op0_signed == op1_signed)
3317 /* Do not warn if the signed quantity is an unsuffixed
3318 integer literal (or some static constant expression
3319 involving such literals or a conditional expression
3320 involving such literals) and it is non-negative. */
3321 else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3322 || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3324 /* Do not warn if the comparison is an equality operation,
3325 the unsigned quantity is an integral constant and it does
3326 not use the most significant bit of result_type. */
3327 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3328 && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3329 && int_fits_type_p (orig_op1, c_common_signed_type
3331 || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3332 && int_fits_type_p (orig_op0, c_common_signed_type
3336 warning ("comparison between signed and unsigned integer expressions");
3338 /* Warn if two unsigned values are being compared in a size
3339 larger than their original size, and one (and only one) is the
3340 result of a `~' operator. This comparison will always fail.
3342 Also warn if one operand is a constant, and the constant does not
3343 have all bits set that are set in the ~ operand when it is
3346 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3347 ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3349 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3350 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3351 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3352 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3354 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3357 HOST_WIDE_INT constant, mask;
3361 if (host_integerp (primop0, 0))
3364 unsignedp = unsignedp1;
3365 constant = tree_low_cst (primop0, 0);
3370 unsignedp = unsignedp0;
3371 constant = tree_low_cst (primop1, 0);
3374 bits = TYPE_PRECISION (TREE_TYPE (primop));
3375 if (bits < TYPE_PRECISION (result_type)
3376 && bits < HOST_BITS_PER_LONG && unsignedp)
3378 mask = (~ (HOST_WIDE_INT) 0) << bits;
3379 if ((mask & constant) != mask)
3380 warning ("comparison of promoted ~unsigned with constant");
3383 else if (unsignedp0 && unsignedp1
3384 && (TYPE_PRECISION (TREE_TYPE (primop0))
3385 < TYPE_PRECISION (result_type))
3386 && (TYPE_PRECISION (TREE_TYPE (primop1))
3387 < TYPE_PRECISION (result_type)))
3388 warning ("comparison of promoted ~unsigned with unsigned");
3393 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3394 Then the expression will be built.
3395 It will be given type FINAL_TYPE if that is nonzero;
3396 otherwise, it will be given type RESULT_TYPE. */
3398 /* Issue warnings about peculiar, but valid, uses of NULL. */
3399 if (/* It's reasonable to use pointer values as operands of &&
3400 and ||, so NULL is no exception. */
3401 !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3402 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3403 (orig_op0 == null_node
3404 && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3405 /* Or vice versa. */
3406 || (orig_op1 == null_node
3407 && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3408 /* Or, both are NULL and the operation was not a comparison. */
3409 || (orig_op0 == null_node && orig_op1 == null_node
3410 && code != EQ_EXPR && code != NE_EXPR)))
3411 /* Some sort of arithmetic operation involving NULL was
3412 performed. Note that pointer-difference and pointer-addition
3413 have already been handled above, and so we don't end up here in
3415 warning ("NULL used in arithmetic");
3419 if (TREE_TYPE (op0) != result_type)
3420 op0 = cp_convert (result_type, op0);
3421 if (TREE_TYPE (op1) != result_type)
3422 op1 = cp_convert (result_type, op1);
3424 if (op0 == error_mark_node || op1 == error_mark_node)
3425 return error_mark_node;
3428 if (build_type == NULL_TREE)
3429 build_type = result_type;
3431 result = build2 (resultcode, build_type, op0, op1);
3432 result = fold_if_not_in_template (result);
3433 if (final_type != 0)
3434 result = cp_convert (final_type, result);
3438 /* Return a tree for the sum or difference (RESULTCODE says which)
3439 of pointer PTROP and integer INTOP. */
3442 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3444 tree res_type = TREE_TYPE (ptrop);
3446 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3447 in certain circumstance (when it's valid to do so). So we need
3448 to make sure it's complete. We don't need to check here, if we
3449 can actually complete it at all, as those checks will be done in
3450 pointer_int_sum() anyway. */
3451 complete_type (TREE_TYPE (res_type));
3453 return pointer_int_sum (resultcode, ptrop,
3454 fold_if_not_in_template (intop));
3457 /* Return a tree for the difference of pointers OP0 and OP1.
3458 The resulting tree has type int. */
3461 pointer_diff (tree op0, tree op1, tree ptrtype)
3464 tree restype = ptrdiff_type_node;
3465 tree target_type = TREE_TYPE (ptrtype);
3467 if (!complete_type_or_else (target_type, NULL_TREE))
3468 return error_mark_node;
3470 if (pedantic || warn_pointer_arith)
3472 if (TREE_CODE (target_type) == VOID_TYPE)
3473 pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
3474 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3475 pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3476 if (TREE_CODE (target_type) == METHOD_TYPE)
3477 pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3480 /* First do the subtraction as integers;
3481 then drop through to build the divide operator. */
3483 op0 = cp_build_binary_op (MINUS_EXPR,
3484 cp_convert (restype, op0),
3485 cp_convert (restype, op1));
3487 /* This generates an error if op1 is a pointer to an incomplete type. */
3488 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3489 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3491 op1 = (TYPE_PTROB_P (ptrtype)
3492 ? size_in_bytes (target_type)
3493 : integer_one_node);
3495 /* Do the division. */
3497 result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3498 return fold_if_not_in_template (result);
3501 /* Construct and perhaps optimize a tree representation
3502 for a unary operation. CODE, a tree_code, specifies the operation
3503 and XARG is the operand. */
3506 build_x_unary_op (enum tree_code code, tree xarg)
3508 tree orig_expr = xarg;
3512 if (processing_template_decl)
3514 if (type_dependent_expression_p (xarg))
3515 return build_min_nt (code, xarg, NULL_TREE);
3517 xarg = build_non_dependent_expr (xarg);
3522 /* [expr.unary.op] says:
3524 The address of an object of incomplete type can be taken.
3526 (And is just the ordinary address operator, not an overloaded
3527 "operator &".) However, if the type is a template
3528 specialization, we must complete the type at this point so that
3529 an overloaded "operator &" will be available if required. */
3530 if (code == ADDR_EXPR
3531 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3532 && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3533 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3534 || (TREE_CODE (xarg) == OFFSET_REF)))
3535 /* Don't look for a function. */;
3537 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3538 /*overloaded_p=*/NULL);
3539 if (!exp && code == ADDR_EXPR)
3541 /* A pointer to member-function can be formed only by saying
3543 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3544 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3546 if (TREE_CODE (xarg) != OFFSET_REF)
3548 error ("invalid use of %qE to form a pointer-to-member-function."
3549 " Use a qualified-id.",
3551 return error_mark_node;
3555 error ("parenthesis around %qE cannot be used to form a"
3556 " pointer-to-member-function",
3558 PTRMEM_OK_P (xarg) = 1;
3562 if (TREE_CODE (xarg) == OFFSET_REF)
3564 ptrmem = PTRMEM_OK_P (xarg);
3566 if (!ptrmem && !flag_ms_extensions
3567 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3569 /* A single non-static member, make sure we don't allow a
3570 pointer-to-member. */
3571 xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
3572 TREE_OPERAND (xarg, 0),
3573 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3574 PTRMEM_OK_P (xarg) = ptrmem;
3577 else if (TREE_CODE (xarg) == TARGET_EXPR)
3578 warning ("taking address of temporary");
3579 exp = build_unary_op (ADDR_EXPR, xarg, 0);
3582 if (processing_template_decl && exp != error_mark_node)
3583 exp = build_min_non_dep (code, exp, orig_expr,
3584 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3585 if (TREE_CODE (exp) == ADDR_EXPR)
3586 PTRMEM_OK_P (exp) = ptrmem;
3590 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3591 constants, where a null value is represented by an INTEGER_CST of
3595 cp_truthvalue_conversion (tree expr)
3597 tree type = TREE_TYPE (expr);
3598 if (TYPE_PTRMEM_P (type))
3599 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3601 return c_common_truthvalue_conversion (expr);
3604 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
3607 condition_conversion (tree expr)
3610 if (processing_template_decl)
3612 t = perform_implicit_conversion (boolean_type_node, expr);
3613 t = fold_build_cleanup_point_expr (boolean_type_node, t);
3617 /* Return an ADDR_EXPR giving the address of T. This function
3618 attempts no optimizations or simplifications; it is a low-level
3622 build_address (tree t)
3626 if (error_operand_p (t) || !cxx_mark_addressable (t))
3627 return error_mark_node;
3629 addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3634 /* Return a NOP_EXPR converting EXPR to TYPE. */
3637 build_nop (tree type, tree expr)
3639 if (type == error_mark_node || error_operand_p (expr))
3641 return build1 (NOP_EXPR, type, expr);
3644 /* C++: Must handle pointers to members.
3646 Perhaps type instantiation should be extended to handle conversion
3647 from aggregates to types we don't yet know we want? (Or are those
3648 cases typically errors which should be reported?)
3650 NOCONVERT nonzero suppresses the default promotions
3651 (such as from short to int). */
3654 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3656 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3659 const char *errstring = NULL;
3662 if (arg == error_mark_node)
3663 return error_mark_node;
3667 /* CONVERT_EXPR stands for unary plus in this context. */
3671 int flags = WANT_ARITH | WANT_ENUM;
3672 /* Unary plus (but not unary minus) is allowed on pointers. */
3673 if (code == CONVERT_EXPR)
3674 flags |= WANT_POINTER;
3675 arg = build_expr_type_conversion (flags, arg, true);
3677 errstring = (code == NEGATE_EXPR
3678 ? "wrong type argument to unary minus"
3679 : "wrong type argument to unary plus");
3682 if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3683 arg = perform_integral_promotions (arg);
3685 /* Make sure the result is not a lvalue: a unary plus or minus
3686 expression is always a rvalue. */
3687 if (real_lvalue_p (arg))
3688 arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3694 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3698 arg = default_conversion (arg);
3700 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3702 errstring = "wrong type argument to bit-complement";
3703 else if (!noconvert)
3704 arg = perform_integral_promotions (arg);
3708 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3709 errstring = "wrong type argument to abs";
3710 else if (!noconvert)
3711 arg = default_conversion (arg);
3715 /* Conjugating a real value is a no-op, but allow it anyway. */
3716 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3717 errstring = "wrong type argument to conjugation";
3718 else if (!noconvert)
3719 arg = default_conversion (arg);
3722 case TRUTH_NOT_EXPR:
3723 arg = perform_implicit_conversion (boolean_type_node, arg);
3724 val = invert_truthvalue (arg);
3725 if (arg != error_mark_node)
3727 errstring = "in argument to unary !";
3734 if (TREE_CODE (arg) == COMPLEX_CST)
3735 return TREE_REALPART (arg);
3736 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3738 arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3739 return fold_if_not_in_template (arg);
3745 if (TREE_CODE (arg) == COMPLEX_CST)
3746 return TREE_IMAGPART (arg);
3747 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3749 arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3750 return fold_if_not_in_template (arg);
3753 return cp_convert (TREE_TYPE (arg), integer_zero_node);
3755 case PREINCREMENT_EXPR:
3756 case POSTINCREMENT_EXPR:
3757 case PREDECREMENT_EXPR:
3758 case POSTDECREMENT_EXPR:
3759 /* Handle complex lvalues (when permitted)
3760 by reduction to simpler cases. */
3762 val = unary_complex_lvalue (code, arg);
3766 /* Increment or decrement the real part of the value,
3767 and don't change the imaginary part. */
3768 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3772 arg = stabilize_reference (arg);
3773 real = build_unary_op (REALPART_EXPR, arg, 1);
3774 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3775 return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3776 build_unary_op (code, real, 1), imag);
3779 /* Report invalid types. */
3781 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3784 if (code == PREINCREMENT_EXPR)
3785 errstring ="no pre-increment operator for type";
3786 else if (code == POSTINCREMENT_EXPR)
3787 errstring ="no post-increment operator for type";
3788 else if (code == PREDECREMENT_EXPR)
3789 errstring ="no pre-decrement operator for type";
3791 errstring ="no post-decrement operator for type";
3795 /* Report something read-only. */
3797 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3798 || TREE_READONLY (arg))
3799 readonly_error (arg, ((code == PREINCREMENT_EXPR
3800 || code == POSTINCREMENT_EXPR)
3801 ? "increment" : "decrement"),
3806 tree result_type = TREE_TYPE (arg);
3808 arg = get_unwidened (arg, 0);
3809 argtype = TREE_TYPE (arg);
3811 /* ARM $5.2.5 last annotation says this should be forbidden. */
3812 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3813 pedwarn ("ISO C++ forbids %sing an enum",
3814 (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3815 ? "increment" : "decrement");
3817 /* Compute the increment. */
3819 if (TREE_CODE (argtype) == POINTER_TYPE)
3821 tree type = complete_type (TREE_TYPE (argtype));
3823 if (!COMPLETE_OR_VOID_TYPE_P (type))
3824 error ("cannot %s a pointer to incomplete type %qT",
3825 ((code == PREINCREMENT_EXPR
3826 || code == POSTINCREMENT_EXPR)
3827 ? "increment" : "decrement"), TREE_TYPE (argtype));
3828 else if ((pedantic || warn_pointer_arith)
3829 && !TYPE_PTROB_P (argtype))
3830 pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
3831 ((code == PREINCREMENT_EXPR
3832 || code == POSTINCREMENT_EXPR)
3833 ? "increment" : "decrement"), argtype);
3834 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3837 inc = integer_one_node;
3839 inc = cp_convert (argtype, inc);
3841 /* Handle incrementing a cast-expression. */
3843 switch (TREE_CODE (arg))
3848 case FIX_TRUNC_EXPR:
3849 case FIX_FLOOR_EXPR:
3850 case FIX_ROUND_EXPR:
3853 tree incremented, modify, value, compound;
3854 if (! lvalue_p (arg) && pedantic)
3855 pedwarn ("cast to non-reference type used as lvalue");
3856 arg = stabilize_reference (arg);
3857 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3860 value = save_expr (arg);
3861 incremented = build2 (((code == PREINCREMENT_EXPR
3862 || code == POSTINCREMENT_EXPR)
3863 ? PLUS_EXPR : MINUS_EXPR),
3864 argtype, value, inc);
3866 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3867 compound = build2 (COMPOUND_EXPR, TREE_TYPE (arg),
3870 /* Eliminate warning about unused result of + or -. */
3871 TREE_NO_WARNING (compound) = 1;
3879 /* Complain about anything else that is not a true lvalue. */
3880 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3881 || code == POSTINCREMENT_EXPR)
3882 ? lv_increment : lv_decrement)))
3883 return error_mark_node;
3885 /* Forbid using -- on `bool'. */
3886 if (TREE_TYPE (arg) == boolean_type_node)
3888 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
3890 error ("invalid use of %<--%> on bool variable %qD", arg);
3891 return error_mark_node;
3893 val = boolean_increment (code, arg);
3896 val = build2 (code, TREE_TYPE (arg), arg, inc);
3898 TREE_SIDE_EFFECTS (val) = 1;
3899 return cp_convert (result_type, val);
3903 /* Note that this operation never does default_conversion
3904 regardless of NOCONVERT. */
3906 argtype = lvalue_type (arg);
3908 if (TREE_CODE (arg) == OFFSET_REF)
3911 if (TREE_CODE (argtype) == REFERENCE_TYPE)
3913 tree type = build_pointer_type (TREE_TYPE (argtype));
3914 arg = build1 (CONVERT_EXPR, type, arg);
3917 else if (pedantic && DECL_MAIN_P (arg))
3919 pedwarn ("ISO C++ forbids taking address of function %<::main%>");
3921 /* Let &* cancel out to simplify resulting code. */
3922 if (TREE_CODE (arg) == INDIRECT_REF)
3924 /* We don't need to have `current_class_ptr' wrapped in a
3925 NON_LVALUE_EXPR node. */
3926 if (arg == current_class_ref)
3927 return current_class_ptr;
3929 arg = TREE_OPERAND (arg, 0);
3930 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3932 tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
3933 arg = build1 (CONVERT_EXPR, type, arg);
3935 else if (lvalue_p (arg))
3936 /* Don't let this be an lvalue. */
3937 return non_lvalue (arg);
3941 /* Uninstantiated types are all functions. Taking the
3942 address of a function is a no-op, so just return the
3945 gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
3946 || !IDENTIFIER_OPNAME_P (arg));
3948 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
3949 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
3951 /* They're trying to take the address of a unique non-static
3952 member function. This is ill-formed (except in MS-land),
3953 but let's try to DTRT.
3954 Note: We only handle unique functions here because we don't
3955 want to complain if there's a static overload; non-unique
3956 cases will be handled by instantiate_type. But we need to
3957 handle this case here to allow casts on the resulting PMF.
3958 We could defer this in non-MS mode, but it's easier to give
3959 a useful error here. */
3961 /* Inside constant member functions, the `this' pointer
3962 contains an extra const qualifier. TYPE_MAIN_VARIANT
3963 is used here to remove this const from the diagnostics
3964 and the created OFFSET_REF. */
3965 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
3966 tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
3968 if (! flag_ms_extensions)
3970 if (current_class_type
3971 && TREE_OPERAND (arg, 0) == current_class_ref)
3972 /* An expression like &memfn. */
3973 pedwarn ("ISO C++ forbids taking the address of an unqualified"
3974 " or parenthesized non-static member function to form"
3975 " a pointer to member function. Say %<&%T::%D%>",
3978 pedwarn ("ISO C++ forbids taking the address of a bound member"
3979 " function to form a pointer to member function."
3983 arg = build_offset_ref (base, name, /*address_p=*/true);
3987 if (type_unknown_p (arg))
3988 return build1 (ADDR_EXPR, unknown_type_node, arg);
3990 /* Handle complex lvalues (when permitted)
3991 by reduction to simpler cases. */
3992 val = unary_complex_lvalue (code, arg);
3996 switch (TREE_CODE (arg))
4001 case FIX_TRUNC_EXPR:
4002 case FIX_FLOOR_EXPR:
4003 case FIX_ROUND_EXPR:
4005 if (! lvalue_p (arg) && pedantic)
4006 pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4010 arg = OVL_CURRENT (arg);
4017 /* Allow the address of a constructor if all the elements
4019 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4020 && TREE_CONSTANT (arg))
4022 /* Anything not already handled and not a true memory reference
4024 else if (TREE_CODE (argtype) != FUNCTION_TYPE
4025 && TREE_CODE (argtype) != METHOD_TYPE
4026 && TREE_CODE (arg) != OFFSET_REF
4027 && !lvalue_or_else (arg, lv_addressof))
4028 return error_mark_node;
4030 if (argtype != error_mark_node)
4031 argtype = build_pointer_type (argtype);
4036 if (TREE_CODE (arg) != COMPONENT_REF
4037 /* Inside a template, we are processing a non-dependent
4038 expression so we can just form an ADDR_EXPR with the
4040 || processing_template_decl)
4042 addr = build_address (arg);
4043 if (TREE_CODE (arg) == OFFSET_REF)
4044 PTRMEM_OK_P (addr) = PTRMEM_OK_P (arg);
4046 else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4048 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4050 /* We can only get here with a single static member
4052 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4053 && DECL_STATIC_FUNCTION_P (fn));
4055 addr = build_address (fn);
4056 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4057 /* Do not lose object's side effects. */
4058 addr = build2 (COMPOUND_EXPR, TREE_TYPE (addr),
4059 TREE_OPERAND (arg, 0), addr);
4061 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4063 error ("attempt to take address of bit-field structure member %qD",
4064 TREE_OPERAND (arg, 1));
4065 return error_mark_node;
4069 tree field = TREE_OPERAND (arg, 1);
4070 tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4071 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
4072 decl_type_context (field),
4075 rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
4077 TREE_OPERAND (arg, 0) = build_indirect_ref (rval, NULL);
4078 addr = build_address (arg);
4081 if (TREE_CODE (argtype) == POINTER_TYPE
4082 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4084 build_ptrmemfunc_type (argtype);
4085 addr = build_ptrmemfunc (argtype, addr, 0,
4086 /*c_cast_p=*/false);
4099 argtype = TREE_TYPE (arg);
4100 return fold_if_not_in_template (build1 (code, argtype, arg));
4103 error ("%s", errstring);
4104 return error_mark_node;
4107 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4108 for certain kinds of expressions which are not really lvalues
4109 but which we can accept as lvalues.
4111 If ARG is not a kind of expression we can handle, return
4115 unary_complex_lvalue (enum tree_code code, tree arg)
4117 /* Inside a template, making these kinds of adjustments is
4118 pointless; we are only concerned with the type of the
4120 if (processing_template_decl)
4123 /* Handle (a, b) used as an "lvalue". */
4124 if (TREE_CODE (arg) == COMPOUND_EXPR)
4126 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4127 return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4128 TREE_OPERAND (arg, 0), real_result);
4131 /* Handle (a ? b : c) used as an "lvalue". */
4132 if (TREE_CODE (arg) == COND_EXPR
4133 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4134 return rationalize_conditional_expr (code, arg);
4136 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4137 if (TREE_CODE (arg) == MODIFY_EXPR
4138 || TREE_CODE (arg) == PREINCREMENT_EXPR
4139 || TREE_CODE (arg) == PREDECREMENT_EXPR)
4141 tree lvalue = TREE_OPERAND (arg, 0);
4142 if (TREE_SIDE_EFFECTS (lvalue))
4144 lvalue = stabilize_reference (lvalue);
4145 arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4146 lvalue, TREE_OPERAND (arg, 1));
4148 return unary_complex_lvalue
4149 (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4152 if (code != ADDR_EXPR)
4155 /* Handle (a = b) used as an "lvalue" for `&'. */
4156 if (TREE_CODE (arg) == MODIFY_EXPR
4157 || TREE_CODE (arg) == INIT_EXPR)
4159 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4160 arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4162 TREE_NO_WARNING (arg) = 1;
4166 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4167 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4168 || TREE_CODE (arg) == OFFSET_REF)
4172 gcc_assert (TREE_CODE (arg) != SCOPE_REF);
4174 if (TREE_CODE (arg) != OFFSET_REF)
4177 t = TREE_OPERAND (arg, 1);
4179 /* Check all this code for right semantics. */
4180 if (TREE_CODE (t) == FUNCTION_DECL)
4182 if (DECL_DESTRUCTOR_P (t))
4183 error ("taking address of destructor");
4184 return build_unary_op (ADDR_EXPR, t, 0);
4186 if (TREE_CODE (t) == VAR_DECL)
4187 return build_unary_op (ADDR_EXPR, t, 0);
4192 if (TREE_OPERAND (arg, 0)
4193 && ! is_dummy_object (TREE_OPERAND (arg, 0))
4194 && TREE_CODE (t) != FIELD_DECL)
4196 error ("taking address of bound pointer-to-member expression");
4197 return error_mark_node;
4199 if (!PTRMEM_OK_P (arg))
4200 return build_unary_op (code, arg, 0);
4202 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4204 error ("cannot create pointer to reference member %qD", t);
4205 return error_mark_node;
4208 type = build_ptrmem_type (context_for_name_lookup (t),
4210 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4216 /* We permit compiler to make function calls returning
4217 objects of aggregate type look like lvalues. */
4221 if (TREE_CODE (targ) == SAVE_EXPR)
4222 targ = TREE_OPERAND (targ, 0);
4224 if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4226 if (TREE_CODE (arg) == SAVE_EXPR)
4229 targ = build_cplus_new (TREE_TYPE (arg), arg);
4230 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4233 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4234 return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4235 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4238 /* Don't let anything else be handled specially. */
4242 /* Mark EXP saying that we need to be able to take the
4243 address of it; it should not be allocated in a register.
4244 Value is true if successful.
4246 C++: we do not allow `current_class_ptr' to be addressable. */
4249 cxx_mark_addressable (tree exp)
4254 switch (TREE_CODE (x))
4261 x = TREE_OPERAND (x, 0);
4265 if (x == current_class_ptr)
4267 error ("cannot take the address of %<this%>, which is an rvalue expression");
4268 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
4274 /* Caller should not be trying to mark initialized
4275 constant fields addressable. */
4276 gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4277 || DECL_IN_AGGR_P (x) == 0
4279 || DECL_EXTERNAL (x));
4284 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4285 && !DECL_ARTIFICIAL (x))
4287 if (DECL_HARD_REGISTER (x) != 0)
4290 ("address of explicit register variable %qD requested", x);
4293 else if (extra_warnings)
4295 ("address requested for %qD, which is declared %<register%>", x);
4297 TREE_ADDRESSABLE (x) = 1;
4301 TREE_ADDRESSABLE (x) = 1;
4305 TREE_ADDRESSABLE (x) = 1;
4309 TREE_ADDRESSABLE (x) = 1;
4310 cxx_mark_addressable (TREE_OPERAND (x, 0));
4318 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4321 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4323 tree orig_ifexp = ifexp;
4324 tree orig_op1 = op1;
4325 tree orig_op2 = op2;
4328 if (processing_template_decl)
4330 /* The standard says that the expression is type-dependent if
4331 IFEXP is type-dependent, even though the eventual type of the
4332 expression doesn't dependent on IFEXP. */
4333 if (type_dependent_expression_p (ifexp)
4334 /* As a GNU extension, the middle operand may be omitted. */
4335 || (op1 && type_dependent_expression_p (op1))
4336 || type_dependent_expression_p (op2))
4337 return build_min_nt (COND_EXPR, ifexp, op1, op2);
4338 ifexp = build_non_dependent_expr (ifexp);
4340 op1 = build_non_dependent_expr (op1);
4341 op2 = build_non_dependent_expr (op2);
4344 expr = build_conditional_expr (ifexp, op1, op2);
4345 if (processing_template_decl && expr != error_mark_node)
4346 return build_min_non_dep (COND_EXPR, expr,
4347 orig_ifexp, orig_op1, orig_op2);
4351 /* Given a list of expressions, return a compound expression
4352 that performs them all and returns the value of the last of them. */
4354 tree build_x_compound_expr_from_list (tree list, const char *msg)
4356 tree expr = TREE_VALUE (list);
4358 if (TREE_CHAIN (list))
4361 pedwarn ("%s expression list treated as compound expression", msg);
4363 for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4364 expr = build_x_compound_expr (expr, TREE_VALUE (list));
4370 /* Handle overloading of the ',' operator when needed. */
4373 build_x_compound_expr (tree op1, tree op2)
4376 tree orig_op1 = op1;
4377 tree orig_op2 = op2;
4379 if (processing_template_decl)
4381 if (type_dependent_expression_p (op1)
4382 || type_dependent_expression_p (op2))
4383 return build_min_nt (COMPOUND_EXPR, op1, op2);
4384 op1 = build_non_dependent_expr (op1);
4385 op2 = build_non_dependent_expr (op2);
4388 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4389 /*overloaded_p=*/NULL);
4391 result = build_compound_expr (op1, op2);
4393 if (processing_template_decl && result != error_mark_node)
4394 return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4399 /* Build a compound expression. */
4402 build_compound_expr (tree lhs, tree rhs)
4404 lhs = convert_to_void (lhs, "left-hand operand of comma");
4406 if (lhs == error_mark_node || rhs == error_mark_node)
4407 return error_mark_node;
4409 if (TREE_CODE (rhs) == TARGET_EXPR)
4411 /* If the rhs is a TARGET_EXPR, then build the compound
4412 expression inside the target_expr's initializer. This
4413 helps the compiler to eliminate unnecessary temporaries. */
4414 tree init = TREE_OPERAND (rhs, 1);
4416 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4417 TREE_OPERAND (rhs, 1) = init;
4422 return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4425 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4426 casts away constness. DIAG_FN gives the function to call if we
4427 need to issue a diagnostic; if it is NULL, no diagnostic will be
4428 issued. DESCRIPTION explains what operation is taking place. */
4431 check_for_casting_away_constness (tree src_type, tree dest_type,
4432 void (*diag_fn)(const char *, ...),
4433 const char *description)
4435 if (diag_fn && casts_away_constness (src_type, dest_type))
4436 error ("%s from type %qT to type %qT casts away constness",
4437 description, src_type, dest_type);
4440 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4441 (another pointer-to-member type in the same hierarchy) and return
4442 the converted expression. If ALLOW_INVERSE_P is permitted, a
4443 pointer-to-derived may be converted to pointer-to-base; otherwise,
4444 only the other direction is permitted. If C_CAST_P is true, this
4445 conversion is taking place as part of a C-style cast. */
4448 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
4451 if (TYPE_PTRMEM_P (type))
4455 if (TREE_CODE (expr) == PTRMEM_CST)
4456 expr = cplus_expand_constant (expr);
4457 delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
4458 TYPE_PTRMEM_CLASS_TYPE (type),
4461 if (!integer_zerop (delta))
4462 expr = cp_build_binary_op (PLUS_EXPR,
4463 build_nop (ptrdiff_type_node, expr),
4465 return build_nop (type, expr);
4468 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4469 allow_inverse_p, c_cast_p);
4472 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
4473 this static_cast is being attempted as one of the possible casts
4474 allowed by a C-style cast. (In that case, accessibility of base
4475 classes is not considered, and it is OK to cast away
4476 constness.) Return the result of the cast. *VALID_P is set to
4477 indicate whether or not the cast was valid. */
4480 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
4486 void (*diag_fn)(const char*, ...);
4489 /* Assume the cast is valid. */
4492 intype = TREE_TYPE (expr);
4494 /* Determine what to do when casting away constness. */
4497 /* C-style casts are allowed to cast away constness. With
4498 WARN_CAST_QUAL, we still want to issue a warning. */
4499 diag_fn = warn_cast_qual ? warning : NULL;
4504 /* A static_cast may not cast away constness. */
4506 desc = "static_cast";
4509 /* [expr.static.cast]
4511 An lvalue of type "cv1 B", where B is a class type, can be cast
4512 to type "reference to cv2 D", where D is a class derived (clause
4513 _class.derived_) from B, if a valid standard conversion from
4514 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4515 same cv-qualification as, or greater cv-qualification than, cv1,
4516 and B is not a virtual base class of D. */
4517 /* We check this case before checking the validity of "TYPE t =
4518 EXPR;" below because for this case:
4521 struct D : public B { D(const B&); };
4523 void f() { static_cast<const D&>(b); }
4525 we want to avoid constructing a new D. The standard is not
4526 completely clear about this issue, but our interpretation is
4527 consistent with other compilers. */
4528 if (TREE_CODE (type) == REFERENCE_TYPE
4529 && CLASS_TYPE_P (TREE_TYPE (type))
4530 && CLASS_TYPE_P (intype)
4531 && real_lvalue_p (expr)
4532 && DERIVED_FROM_P (intype, TREE_TYPE (type))
4533 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4534 build_pointer_type (TYPE_MAIN_VARIANT
4535 (TREE_TYPE (type))))
4537 || at_least_as_qualified_p (TREE_TYPE (type), intype)))
4541 /* There is a standard conversion from "D*" to "B*" even if "B"
4542 is ambiguous or inaccessible. If this is really a
4543 static_cast, then we check both for inaccessibility and
4544 ambiguity. However, if this is a static_cast being performed
4545 because the user wrote a C-style cast, then accessibility is
4547 base = lookup_base (TREE_TYPE (type), intype,
4548 c_cast_p ? ba_unique : ba_check,
4551 /* Convert from "B*" to "D*". This function will check that "B"
4552 is not a virtual base of "D". */
4553 expr = build_base_path (MINUS_EXPR, build_address (expr),
4554 base, /*nonnull=*/false);
4555 /* Convert the pointer to a reference -- but then remember that
4556 there are no expressions with reference type in C++. */
4557 return convert_from_reference (build_nop (type, expr));
4562 /* [expr.static.cast]
4564 An expression e can be explicitly converted to a type T using a
4565 static_cast of the form static_cast<T>(e) if the declaration T
4566 t(e);" is well-formed, for some invented temporary variable
4568 result = perform_direct_initialization_if_possible (type, expr,
4572 result = convert_from_reference (result);
4574 /* Ignore any integer overflow caused by the cast. */
4575 if (TREE_CODE (result) == INTEGER_CST
4576 && CONSTANT_CLASS_P (orig))
4578 TREE_OVERFLOW (result) = TREE_OVERFLOW (orig);
4579 TREE_CONSTANT_OVERFLOW (result)
4580 = TREE_CONSTANT_OVERFLOW (orig);
4582 /* [expr.static.cast]
4584 If T is a reference type, the result is an lvalue; otherwise,
4585 the result is an rvalue. */
4586 if (TREE_CODE (type) != REFERENCE_TYPE
4587 && real_lvalue_p (result))
4588 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
4592 /* [expr.static.cast]
4594 Any expression can be explicitly converted to type cv void. */
4595 if (TREE_CODE (type) == VOID_TYPE)
4596 return convert_to_void (expr, /*implicit=*/NULL);
4598 /* [expr.static.cast]
4600 The inverse of any standard conversion sequence (clause _conv_),
4601 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4602 (_conv.array_), function-to-pointer (_conv.func_), and boolean
4603 (_conv.bool_) conversions, can be performed explicitly using
4604 static_cast subject to the restriction that the explicit
4605 conversion does not cast away constness (_expr.const.cast_), and
4606 the following additional rules for specific cases: */
4607 /* For reference, the conversions not excluded are: integral
4608 promotions, floating point promotion, integral conversions,
4609 floating point conversions, floating-integral conversions,
4610 pointer conversions, and pointer to member conversions. */
4611 if ((ARITHMETIC_TYPE_P (type) && ARITHMETIC_TYPE_P (intype))
4614 A value of integral _or enumeration_ type can be explicitly
4615 converted to an enumeration type. */
4616 || (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
4617 && INTEGRAL_OR_ENUMERATION_TYPE_P (intype)))
4619 expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
4621 /* Ignore any integer overflow caused by the cast. */
4622 if (TREE_CODE (expr) == INTEGER_CST
4623 && CONSTANT_CLASS_P (orig))
4625 TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
4626 TREE_CONSTANT_OVERFLOW (expr) = TREE_CONSTANT_OVERFLOW (orig);
4631 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4632 && CLASS_TYPE_P (TREE_TYPE (type))
4633 && CLASS_TYPE_P (TREE_TYPE (intype))
4634 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4635 (TREE_TYPE (intype))),
4636 build_pointer_type (TYPE_MAIN_VARIANT
4637 (TREE_TYPE (type)))))
4642 check_for_casting_away_constness (intype, type, diag_fn, desc);
4643 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4644 c_cast_p ? ba_unique : ba_check,
4646 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4649 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4650 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4657 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4658 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4660 if (TYPE_PTRMEM_P (type))
4662 t1 = (build_ptrmem_type
4664 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4665 t2 = (build_ptrmem_type
4667 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4674 if (can_convert (t1, t2))
4677 check_for_casting_away_constness (intype, type, diag_fn,
4679 return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
4684 /* [expr.static.cast]
4686 An rvalue of type "pointer to cv void" can be explicitly
4687 converted to a pointer to object type. A value of type pointer
4688 to object converted to "pointer to cv void" and back to the
4689 original pointer type will have its original value. */
4690 if (TREE_CODE (intype) == POINTER_TYPE
4691 && VOID_TYPE_P (TREE_TYPE (intype))
4692 && TYPE_PTROB_P (type))
4695 check_for_casting_away_constness (intype, type, diag_fn, desc);
4696 return build_nop (type, expr);
4700 return error_mark_node;
4703 /* Return an expression representing static_cast<TYPE>(EXPR). */
4706 build_static_cast (tree type, tree expr)
4711 if (type == error_mark_node || expr == error_mark_node)
4712 return error_mark_node;
4714 if (processing_template_decl)
4716 expr = build_min (STATIC_CAST_EXPR, type, expr);
4717 /* We don't know if it will or will not have side effects. */
4718 TREE_SIDE_EFFECTS (expr) = 1;
4719 return convert_from_reference (expr);
4722 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4723 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4724 if (TREE_CODE (type) != REFERENCE_TYPE
4725 && TREE_CODE (expr) == NOP_EXPR
4726 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4727 expr = TREE_OPERAND (expr, 0);
4729 result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p);
4733 error ("invalid static_cast from type %qT to type %qT",
4734 TREE_TYPE (expr), type);
4735 return error_mark_node;
4738 /* EXPR is an expression with member function or pointer-to-member
4739 function type. TYPE is a pointer type. Converting EXPR to TYPE is
4740 not permitted by ISO C++, but we accept it in some modes. If we
4741 are not in one of those modes, issue a diagnostic. Return the
4742 converted expression. */
4745 convert_member_func_to_ptr (tree type, tree expr)
4750 intype = TREE_TYPE (expr);
4751 gcc_assert (TYPE_PTRMEMFUNC_P (intype)
4752 || TREE_CODE (intype) == METHOD_TYPE);
4754 if (pedantic || warn_pmf2ptr)
4755 pedwarn ("converting from %qT to %qT", intype, type);
4757 if (TREE_CODE (intype) == METHOD_TYPE)
4758 expr = build_addr_func (expr);
4759 else if (TREE_CODE (expr) == PTRMEM_CST)
4760 expr = build_address (PTRMEM_CST_MEMBER (expr));
4763 decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
4764 decl = build_address (decl);
4765 expr = get_member_function_from_ptrfunc (&decl, expr);
4768 return build_nop (type, expr);
4771 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
4772 If C_CAST_P is true, this reinterpret cast is being done as part of
4773 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
4774 indicate whether or not reinterpret_cast was valid. */
4777 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
4782 /* Assume the cast is invalid. */
4786 if (type == error_mark_node || error_operand_p (expr))
4787 return error_mark_node;
4789 intype = TREE_TYPE (expr);
4791 /* [expr.reinterpret.cast]
4792 An lvalue expression of type T1 can be cast to the type
4793 "reference to T2" if an expression of type "pointer to T1" can be
4794 explicitly converted to the type "pointer to T2" using a
4795 reinterpret_cast. */
4796 if (TREE_CODE (type) == REFERENCE_TYPE)
4798 if (! real_lvalue_p (expr))
4800 error ("invalid cast of an rvalue expression of type "
4803 return error_mark_node;
4806 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
4807 "B" are related class types; the reinterpret_cast does not
4808 adjust the pointer. */
4809 if (TYPE_PTR_P (intype)
4810 && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
4811 COMPARE_BASE | COMPARE_DERIVED)))
4812 warning ("casting %qT to %qT does not dereference pointer",
4815 expr = build_unary_op (ADDR_EXPR, expr, 0);
4816 if (expr != error_mark_node)
4817 expr = build_reinterpret_cast_1
4818 (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
4820 if (expr != error_mark_node)
4821 expr = build_indirect_ref (expr, 0);
4825 /* As a G++ extension, we consider conversions from member
4826 functions, and pointers to member functions to
4827 pointer-to-function and pointer-to-void types. If
4828 -Wno-pmf-conversions has not been specified,
4829 convert_member_func_to_ptr will issue an error message. */
4830 if ((TYPE_PTRMEMFUNC_P (intype)
4831 || TREE_CODE (intype) == METHOD_TYPE)
4832 && TYPE_PTR_P (type)
4833 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
4834 || VOID_TYPE_P (TREE_TYPE (type))))
4835 return convert_member_func_to_ptr (type, expr);
4837 /* If the cast is not to a reference type, the lvalue-to-rvalue,
4838 array-to-pointer, and function-to-pointer conversions are
4840 expr = decay_conversion (expr);
4842 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4843 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4844 if (TREE_CODE (expr) == NOP_EXPR
4845 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4846 expr = TREE_OPERAND (expr, 0);
4848 if (error_operand_p (expr))
4849 return error_mark_node;
4851 intype = TREE_TYPE (expr);
4853 /* [expr.reinterpret.cast]
4854 A pointer can be converted to any integral type large enough to
4856 if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
4858 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
4859 pedwarn ("cast from %qT to %qT loses precision",
4862 /* [expr.reinterpret.cast]
4863 A value of integral or enumeration type can be explicitly
4864 converted to a pointer. */
4865 else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
4868 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
4869 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4870 return fold_if_not_in_template (build_nop (type, expr));
4871 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4872 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
4875 check_for_casting_away_constness (intype, type, error,
4876 "reinterpret_cast");
4877 /* Warn about possible alignment problems. */
4878 if (STRICT_ALIGNMENT && warn_cast_align
4879 && !VOID_TYPE_P (type)
4880 && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
4881 && COMPLETE_TYPE_P (TREE_TYPE (type))
4882 && COMPLETE_TYPE_P (TREE_TYPE (intype))
4883 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
4884 warning ("cast from %qT to %qT increases required alignment of "
4888 return fold_if_not_in_template (build_nop (type, expr));
4890 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
4891 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
4894 /* Only issue a warning, as we have always supported this
4895 where possible, and it is necessary in some cases. DR 195
4896 addresses this issue, but as of 2004/10/26 is still in
4898 warning ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
4899 return fold_if_not_in_template (build_nop (type, expr));
4901 else if (TREE_CODE (type) == VECTOR_TYPE)
4902 return fold_if_not_in_template (convert_to_vector (type, expr));
4903 else if (TREE_CODE (intype) == VECTOR_TYPE)
4904 return fold_if_not_in_template (convert_to_integer (type, expr));
4909 error ("invalid cast from type %qT to type %qT", intype, type);
4910 return error_mark_node;
4913 return cp_convert (type, expr);
4917 build_reinterpret_cast (tree type, tree expr)
4919 if (type == error_mark_node || expr == error_mark_node)
4920 return error_mark_node;
4922 if (processing_template_decl)
4924 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4926 if (!TREE_SIDE_EFFECTS (t)
4927 && type_dependent_expression_p (expr))
4928 /* There might turn out to be side effects inside expr. */
4929 TREE_SIDE_EFFECTS (t) = 1;
4930 return convert_from_reference (t);
4933 return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
4937 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
4938 return an appropriate expression. Otherwise, return
4939 error_mark_node. If the cast is not valid, and COMPLAIN is true,
4940 then a diagnostic will be issued. If VALID_P is non-NULL, its
4941 value upon return will indicate whether or not the conversion
4945 build_const_cast_1 (tree dst_type, tree expr, bool complain,
4949 tree reference_type;
4951 /* Callers are responsible for handling error_mark_node as a
4952 destination type. */
4953 gcc_assert (dst_type != error_mark_node);
4954 /* In a template, callers should be building syntactic
4955 representations of casts, not using this machinery. */
4956 gcc_assert (!processing_template_decl);
4958 /* Assume the conversion is invalid. */
4962 if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
4965 error ("invalid use of const_cast with type %qT, "
4966 "which is not a pointer, "
4967 "reference, nor a pointer-to-data-member type", dst_type);
4968 return error_mark_node;
4971 if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
4974 error ("invalid use of const_cast with type %qT, which is a pointer "
4975 "or reference to a function type", dst_type);
4976 return error_mark_node;
4979 src_type = TREE_TYPE (expr);
4980 /* Expressions do not really have reference types. */
4981 if (TREE_CODE (src_type) == REFERENCE_TYPE)
4982 src_type = TREE_TYPE (src_type);
4984 /* [expr.const.cast]
4986 An lvalue of type T1 can be explicitly converted to an lvalue of
4987 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
4988 types) if a pointer to T1 can be explicitly converted to the type
4989 pointer to T2 using a const_cast. */
4990 if (TREE_CODE (dst_type) == REFERENCE_TYPE)
4992 reference_type = dst_type;
4993 if (! real_lvalue_p (expr))
4996 error ("invalid const_cast of an rvalue of type %qT to type %qT",
4997 src_type, dst_type);
4998 return error_mark_node;
5000 dst_type = build_pointer_type (TREE_TYPE (dst_type));
5001 src_type = build_pointer_type (src_type);
5005 reference_type = NULL_TREE;
5006 /* If the destination type is not a reference type, the
5007 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5008 conversions are performed. */
5009 src_type = type_decays_to (src_type);
5010 if (src_type == error_mark_node)
5011 return error_mark_node;
5014 if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5015 && comp_ptr_ttypes_const (dst_type, src_type))
5021 expr = build_unary_op (ADDR_EXPR, expr, 0);
5022 expr = build_nop (reference_type, expr);
5023 return convert_from_reference (expr);
5027 expr = decay_conversion (expr);
5028 /* build_c_cast puts on a NOP_EXPR to make the result not an
5029 lvalue. Strip such NOP_EXPRs if VALUE is being used in
5030 non-lvalue context. */
5031 if (TREE_CODE (expr) == NOP_EXPR
5032 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5033 expr = TREE_OPERAND (expr, 0);
5034 return build_nop (dst_type, expr);
5039 error ("invalid const_cast from type %qT to type %qT",
5040 src_type, dst_type);
5041 return error_mark_node;
5045 build_const_cast (tree type, tree expr)
5047 if (type == error_mark_node || error_operand_p (expr))
5048 return error_mark_node;
5050 if (processing_template_decl)
5052 tree t = build_min (CONST_CAST_EXPR, type, expr);
5054 if (!TREE_SIDE_EFFECTS (t)
5055 && type_dependent_expression_p (expr))
5056 /* There might turn out to be side effects inside expr. */
5057 TREE_SIDE_EFFECTS (t) = 1;
5058 return convert_from_reference (t);
5061 return build_const_cast_1 (type, expr, /*complain=*/true,
5065 /* Build an expression representing an explicit C-style cast to type
5066 TYPE of expression EXPR. */
5069 build_c_cast (tree type, tree expr)
5075 if (type == error_mark_node || error_operand_p (expr))
5076 return error_mark_node;
5078 if (processing_template_decl)
5080 tree t = build_min (CAST_EXPR, type,
5081 tree_cons (NULL_TREE, value, NULL_TREE));
5082 /* We don't know if it will or will not have side effects. */
5083 TREE_SIDE_EFFECTS (t) = 1;
5084 return convert_from_reference (t);
5087 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5088 'Class') should always be retained, because this information aids
5089 in method lookup. */
5090 if (objc_is_object_ptr (type)
5091 && objc_is_object_ptr (TREE_TYPE (expr)))
5092 return build_nop (type, expr);
5094 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5095 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5096 if (TREE_CODE (type) != REFERENCE_TYPE
5097 && TREE_CODE (value) == NOP_EXPR
5098 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5099 value = TREE_OPERAND (value, 0);
5101 if (TREE_CODE (type) == ARRAY_TYPE)
5103 /* Allow casting from T1* to T2[] because Cfront allows it.
5104 NIHCL uses it. It is not valid ISO C++ however. */
5105 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5107 pedwarn ("ISO C++ forbids casting to an array type %qT", type);
5108 type = build_pointer_type (TREE_TYPE (type));
5112 error ("ISO C++ forbids casting to an array type %qT", type);
5113 return error_mark_node;
5117 if (TREE_CODE (type) == FUNCTION_TYPE
5118 || TREE_CODE (type) == METHOD_TYPE)
5120 error ("invalid cast to function type %qT", type);
5121 return error_mark_node;
5124 /* A C-style cast can be a const_cast. */
5125 result = build_const_cast_1 (type, value, /*complain=*/false,
5130 /* Or a static cast. */
5131 result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5133 /* Or a reinterpret_cast. */
5135 result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5137 /* The static_cast or reinterpret_cast may be followed by a
5140 /* A valid cast may result in errors if, for example, a
5141 conversion to am ambiguous base class is required. */
5142 && !error_operand_p (result))
5146 /* Non-class rvalues always have cv-unqualified type. */
5147 if (!CLASS_TYPE_P (type))
5148 type = TYPE_MAIN_VARIANT (type);
5149 result_type = TREE_TYPE (result);
5150 if (!CLASS_TYPE_P (result_type))
5151 result_type = TYPE_MAIN_VARIANT (result_type);
5152 /* If the type of RESULT does not match TYPE, perform a
5153 const_cast to make it match. If the static_cast or
5154 reinterpret_cast succeeded, we will differ by at most
5155 cv-qualification, so the follow-on const_cast is guaranteed
5157 if (!same_type_p (non_reference (type), non_reference (result_type)))
5159 result = build_const_cast_1 (type, result, false, &valid_p);
5160 gcc_assert (valid_p);
5165 return error_mark_node;
5168 /* Build an assignment expression of lvalue LHS from value RHS.
5169 MODIFYCODE is the code for a binary operator that we use
5170 to combine the old value of LHS with RHS to get the new value.
5171 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5173 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5176 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5180 tree lhstype = TREE_TYPE (lhs);
5181 tree olhstype = lhstype;
5182 tree olhs = NULL_TREE;
5183 bool plain_assign = (modifycode == NOP_EXPR);
5185 /* Avoid duplicate error messages from operands that had errors. */
5186 if (lhs == error_mark_node || rhs == error_mark_node)
5187 return error_mark_node;
5189 /* Handle control structure constructs used as "lvalues". */
5190 switch (TREE_CODE (lhs))
5192 /* Handle --foo = 5; as these are valid constructs in C++. */
5193 case PREDECREMENT_EXPR:
5194 case PREINCREMENT_EXPR:
5195 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5196 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5197 stabilize_reference (TREE_OPERAND (lhs, 0)),
5198 TREE_OPERAND (lhs, 1));
5199 return build2 (COMPOUND_EXPR, lhstype,
5201 build_modify_expr (TREE_OPERAND (lhs, 0),
5204 /* Handle (a, b) used as an "lvalue". */
5206 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5208 if (newrhs == error_mark_node)
5209 return error_mark_node;
5210 return build2 (COMPOUND_EXPR, lhstype,
5211 TREE_OPERAND (lhs, 0), newrhs);
5214 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5215 lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5216 stabilize_reference (TREE_OPERAND (lhs, 0)),
5217 TREE_OPERAND (lhs, 1));
5218 newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5219 if (newrhs == error_mark_node)
5220 return error_mark_node;
5221 return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5225 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5226 when neither operand has side-effects. */
5227 if (!lvalue_or_else (lhs, lv_assign))
5228 return error_mark_node;
5230 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5231 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5233 lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5234 build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5236 TREE_OPERAND (lhs, 0),
5237 TREE_OPERAND (lhs, 1)),
5238 TREE_OPERAND (lhs, 0),
5239 TREE_OPERAND (lhs, 1));
5242 /* Handle (a ? b : c) used as an "lvalue". */
5245 /* Produce (a ? (b = rhs) : (c = rhs))
5246 except that the RHS goes through a save-expr
5247 so the code to compute it is only emitted once. */
5249 tree preeval = NULL_TREE;
5251 rhs = stabilize_expr (rhs, &preeval);
5253 /* Check this here to avoid odd errors when trying to convert
5254 a throw to the type of the COND_EXPR. */
5255 if (!lvalue_or_else (lhs, lv_assign))
5256 return error_mark_node;
5258 cond = build_conditional_expr
5259 (TREE_OPERAND (lhs, 0),
5260 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5261 TREE_OPERAND (lhs, 1)),
5263 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5264 TREE_OPERAND (lhs, 2)),
5267 if (cond == error_mark_node)
5269 /* Make sure the code to compute the rhs comes out
5270 before the split. */
5272 cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5280 if (modifycode == INIT_EXPR)
5282 if (TREE_CODE (rhs) == CONSTRUCTOR)
5284 if (! same_type_p (TREE_TYPE (rhs), lhstype))
5285 /* Call convert to generate an error; see PR 11063. */
5286 rhs = convert (lhstype, rhs);
5287 result = build2 (INIT_EXPR, lhstype, lhs, rhs);
5288 TREE_SIDE_EFFECTS (result) = 1;
5291 else if (! IS_AGGR_TYPE (lhstype))
5292 /* Do the default thing. */;
5295 result = build_special_member_call (lhs, complete_ctor_identifier,
5296 build_tree_list (NULL_TREE, rhs),
5297 lhstype, LOOKUP_NORMAL);
5298 if (result == NULL_TREE)
5299 return error_mark_node;
5305 lhs = require_complete_type (lhs);
5306 if (lhs == error_mark_node)
5307 return error_mark_node;
5309 if (modifycode == NOP_EXPR)
5311 /* `operator=' is not an inheritable operator. */
5312 if (! IS_AGGR_TYPE (lhstype))
5313 /* Do the default thing. */;
5316 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5317 lhs, rhs, make_node (NOP_EXPR),
5318 /*overloaded_p=*/NULL);
5319 if (result == NULL_TREE)
5320 return error_mark_node;
5327 /* A binary op has been requested. Combine the old LHS
5328 value with the RHS producing the value we should actually
5329 store into the LHS. */
5331 gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
5332 lhs = stabilize_reference (lhs);
5333 newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5334 if (newrhs == error_mark_node)
5336 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode,
5337 TREE_TYPE (lhs), TREE_TYPE (rhs));
5338 return error_mark_node;
5341 /* Now it looks like a plain assignment. */
5342 modifycode = NOP_EXPR;
5344 gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
5345 gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
5348 /* The left-hand side must be an lvalue. */
5349 if (!lvalue_or_else (lhs, lv_assign))
5350 return error_mark_node;
5352 /* Warn about modifying something that is `const'. Don't warn if
5353 this is initialization. */
5354 if (modifycode != INIT_EXPR
5355 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5356 /* Functions are not modifiable, even though they are
5358 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5359 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5360 /* If it's an aggregate and any field is const, then it is
5361 effectively const. */
5362 || (CLASS_TYPE_P (lhstype)
5363 && C_TYPE_FIELDS_READONLY (lhstype))))
5364 readonly_error (lhs, "assignment", 0);
5366 /* If storing into a structure or union member, it has probably been
5367 given type `int'. Compute the type that would go with the actual
5368 amount of storage the member occupies. */
5370 if (TREE_CODE (lhs) == COMPONENT_REF
5371 && (TREE_CODE (lhstype) == INTEGER_TYPE
5372 || TREE_CODE (lhstype) == REAL_TYPE
5373 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5375 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5377 /* If storing in a field that is in actuality a short or narrower
5378 than one, we must store in the field in its actual type. */
5380 if (lhstype != TREE_TYPE (lhs))
5382 /* Avoid warnings converting integral types back into enums for
5384 if (TREE_CODE (lhstype) == INTEGER_TYPE
5385 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5387 if (TREE_SIDE_EFFECTS (lhs))
5388 lhs = stabilize_reference (lhs);
5391 lhs = copy_node (lhs);
5392 TREE_TYPE (lhs) = lhstype;
5396 /* Convert new value to destination type. */
5398 if (TREE_CODE (lhstype) == ARRAY_TYPE)
5402 if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5403 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5405 error ("incompatible types in assignment of %qT to %qT",
5406 TREE_TYPE (rhs), lhstype);
5407 return error_mark_node;
5410 /* Allow array assignment in compiler-generated code. */
5411 if (! DECL_ARTIFICIAL (current_function_decl))
5412 pedwarn ("ISO C++ forbids assignment of arrays");
5414 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5415 ? 1 + (modifycode != INIT_EXPR): 0;
5416 return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5419 if (modifycode == INIT_EXPR)
5420 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5421 "initialization", NULL_TREE, 0);
5424 /* Avoid warnings on enum bit fields. */
5425 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5426 && TREE_CODE (lhstype) == INTEGER_TYPE)
5428 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5430 newrhs = convert_force (lhstype, newrhs, 0);
5433 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5435 if (TREE_CODE (newrhs) == CALL_EXPR
5436 && TYPE_NEEDS_CONSTRUCTING (lhstype))
5437 newrhs = build_cplus_new (lhstype, newrhs);
5439 /* Can't initialize directly from a TARGET_EXPR, since that would
5440 cause the lhs to be constructed twice, and possibly result in
5441 accidental self-initialization. So we force the TARGET_EXPR to be
5442 expanded without a target. */
5443 if (TREE_CODE (newrhs) == TARGET_EXPR)
5444 newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5445 TREE_OPERAND (newrhs, 0));
5448 if (newrhs == error_mark_node)
5449 return error_mark_node;
5451 result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5452 lhstype, lhs, newrhs);
5454 TREE_SIDE_EFFECTS (result) = 1;
5456 TREE_NO_WARNING (result) = 1;
5458 /* If we got the LHS in a different type for storing in,
5459 convert the result back to the nominal type of LHS
5460 so that the value we return always has the same type
5461 as the LHS argument. */
5463 if (olhstype == TREE_TYPE (result))
5467 result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
5468 TREE_NO_WARNING (result) = 1;
5471 return convert_for_assignment (olhstype, result, "assignment",
5476 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5478 if (processing_template_decl)
5479 return build_min_nt (MODOP_EXPR, lhs,
5480 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5482 if (modifycode != NOP_EXPR)
5484 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5485 make_node (modifycode),
5486 /*overloaded_p=*/NULL);
5489 TREE_NO_WARNING (rval) = 1;
5493 return build_modify_expr (lhs, modifycode, rhs);
5497 /* Get difference in deltas for different pointer to member function
5498 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
5499 the conversion is invalid, the constant is zero. If
5500 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
5501 If C_CAST_P is true this conversion is taking place as part of a
5504 Note that the naming of FROM and TO is kind of backwards; the return
5505 value is what we add to a TO in order to get a FROM. They are named
5506 this way because we call this function to find out how to convert from
5507 a pointer to member of FROM to a pointer to member of TO. */
5510 get_delta_difference (tree from, tree to,
5511 bool allow_inverse_p,
5519 /* Assume no conversion is required. */
5520 result = integer_zero_node;
5521 binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
5522 if (kind == bk_inaccessible || kind == bk_ambig)
5523 error (" in pointer to member function conversion");
5526 if (!allow_inverse_p)
5528 error_not_base_type (from, to);
5529 error (" in pointer to member conversion");
5533 binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check,
5537 virt_binfo = binfo_from_vbase (binfo);
5539 /* This is a reinterpret cast, we choose to do nothing. */
5540 warning ("pointer to member cast via virtual base %qT",
5541 BINFO_TYPE (virt_binfo));
5543 result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
5549 virt_binfo = binfo_from_vbase (binfo);
5551 result = BINFO_OFFSET (binfo);
5554 /* This is a reinterpret cast, we choose to do nothing. */
5555 if (allow_inverse_p)
5556 warning ("pointer to member cast via virtual base %qT",
5557 BINFO_TYPE (virt_binfo));
5559 error ("pointer to member conversion via virtual base %qT",
5560 BINFO_TYPE (virt_binfo));
5564 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
5568 /* Return a constructor for the pointer-to-member-function TYPE using
5569 the other components as specified. */
5572 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5578 /* Pull the FIELD_DECLs out of the type. */
5579 pfn_field = TYPE_FIELDS (type);
5580 delta_field = TREE_CHAIN (pfn_field);
5582 /* Make sure DELTA has the type we want. */
5583 delta = convert_and_check (delta_type_node, delta);
5585 /* Finish creating the initializer. */
5586 u = tree_cons (pfn_field, pfn,
5587 build_tree_list (delta_field, delta));
5588 u = build_constructor (type, u);
5589 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
5590 TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta);
5591 TREE_STATIC (u) = (TREE_CONSTANT (u)
5592 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5594 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5599 /* Build a constructor for a pointer to member function. It can be
5600 used to initialize global variables, local variable, or used
5601 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
5604 If FORCE is nonzero, then force this conversion, even if
5605 we would rather not do it. Usually set when using an explicit
5606 cast. A C-style cast is being processed iff C_CAST_P is true.
5608 Return error_mark_node, if something goes wrong. */
5611 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
5617 if (error_operand_p (pfn))
5618 return error_mark_node;
5620 pfn_type = TREE_TYPE (pfn);
5621 to_type = build_ptrmemfunc_type (type);
5623 /* Handle multiple conversions of pointer to member functions. */
5624 if (TYPE_PTRMEMFUNC_P (pfn_type))
5626 tree delta = NULL_TREE;
5627 tree npfn = NULL_TREE;
5631 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5632 error ("invalid conversion to type %qT from type %qT",
5635 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5636 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5640 /* We don't have to do any conversion to convert a
5641 pointer-to-member to its own type. But, we don't want to
5642 just return a PTRMEM_CST if there's an explicit cast; that
5643 cast should make the expression an invalid template argument. */
5644 if (TREE_CODE (pfn) != PTRMEM_CST)
5646 if (same_type_p (to_type, pfn_type))
5648 else if (integer_zerop (n))
5649 return build_reinterpret_cast (to_type, pfn);
5652 if (TREE_SIDE_EFFECTS (pfn))
5653 pfn = save_expr (pfn);
5655 /* Obtain the function pointer and the current DELTA. */
5656 if (TREE_CODE (pfn) == PTRMEM_CST)
5657 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5660 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5661 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5664 /* Just adjust the DELTA field. */
5665 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5666 (TREE_TYPE (delta), ptrdiff_type_node));
5667 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5668 n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5669 delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5670 return build_ptrmemfunc1 (to_type, delta, npfn);
5673 /* Handle null pointer to member function conversions. */
5674 if (integer_zerop (pfn))
5676 pfn = build_c_cast (type, integer_zero_node);
5677 return build_ptrmemfunc1 (to_type,
5682 if (type_unknown_p (pfn))
5683 return instantiate_type (type, pfn, tf_error | tf_warning);
5685 fn = TREE_OPERAND (pfn, 0);
5686 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5687 return make_ptrmem_cst (to_type, fn);
5690 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5693 ??? There is no consistency as to the types returned for the above
5694 values. Some code acts as if it were a sizetype and some as if it were
5695 integer_type_node. */
5698 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5700 tree type = TREE_TYPE (cst);
5701 tree fn = PTRMEM_CST_MEMBER (cst);
5702 tree ptr_class, fn_class;
5704 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5706 /* The class that the function belongs to. */
5707 fn_class = DECL_CONTEXT (fn);
5709 /* The class that we're creating a pointer to member of. */
5710 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5712 /* First, calculate the adjustment to the function's class. */
5713 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
5716 if (!DECL_VIRTUAL_P (fn))
5717 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5720 /* If we're dealing with a virtual function, we have to adjust 'this'
5721 again, to point to the base which provides the vtable entry for
5722 fn; the call will do the opposite adjustment. */
5723 tree orig_class = DECL_CONTEXT (fn);
5724 tree binfo = binfo_or_else (orig_class, fn_class);
5725 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5726 *delta, BINFO_OFFSET (binfo));
5727 *delta = fold_if_not_in_template (*delta);
5729 /* We set PFN to the vtable offset at which the function can be
5730 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5731 case delta is shifted left, and then incremented). */
5732 *pfn = DECL_VINDEX (fn);
5733 *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
5734 TYPE_SIZE_UNIT (vtable_entry_type));
5735 *pfn = fold_if_not_in_template (*pfn);
5737 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5739 case ptrmemfunc_vbit_in_pfn:
5740 *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
5742 *pfn = fold_if_not_in_template (*pfn);
5745 case ptrmemfunc_vbit_in_delta:
5746 *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
5747 *delta, integer_one_node);
5748 *delta = fold_if_not_in_template (*delta);
5749 *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5750 *delta, integer_one_node);
5751 *delta = fold_if_not_in_template (*delta);
5758 *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
5759 *pfn = fold_if_not_in_template (*pfn);
5763 /* Return an expression for PFN from the pointer-to-member function
5767 pfn_from_ptrmemfunc (tree t)
5769 if (TREE_CODE (t) == PTRMEM_CST)
5774 expand_ptrmemfunc_cst (t, &delta, &pfn);
5779 return build_ptrmemfunc_access_expr (t, pfn_identifier);
5782 /* Convert value RHS to type TYPE as preparation for an assignment to
5783 an lvalue of type TYPE. ERRTYPE is a string to use in error
5784 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
5785 are doing the conversion in order to pass the PARMNUMth argument of
5789 convert_for_assignment (tree type, tree rhs,
5790 const char *errtype, tree fndecl, int parmnum)
5793 enum tree_code coder;
5795 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
5796 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5797 rhs = TREE_OPERAND (rhs, 0);
5799 rhstype = TREE_TYPE (rhs);
5800 coder = TREE_CODE (rhstype);
5802 if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
5803 && vector_types_convertible_p (type, rhstype))
5804 return convert (type, rhs);
5806 if (rhs == error_mark_node || rhstype == error_mark_node)
5807 return error_mark_node;
5808 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
5809 return error_mark_node;
5811 /* The RHS of an assignment cannot have void type. */
5812 if (coder == VOID_TYPE)
5814 error ("void value not ignored as it ought to be");
5815 return error_mark_node;
5818 /* Simplify the RHS if possible. */
5819 if (TREE_CODE (rhs) == CONST_DECL)
5820 rhs = DECL_INITIAL (rhs);
5824 The expression is implicitly converted (clause _conv_) to the
5825 cv-unqualified type of the left operand.
5827 We allow bad conversions here because by the time we get to this point
5828 we are committed to doing the conversion. If we end up doing a bad
5829 conversion, convert_like will complain. */
5830 if (!can_convert_arg_bad (type, rhstype, rhs))
5832 /* When -Wno-pmf-conversions is use, we just silently allow
5833 conversions from pointers-to-members to plain pointers. If
5834 the conversion doesn't work, cp_convert will complain. */
5836 && TYPE_PTR_P (type)
5837 && TYPE_PTRMEMFUNC_P (rhstype))
5838 rhs = cp_convert (strip_top_quals (type), rhs);
5841 /* If the right-hand side has unknown type, then it is an
5842 overloaded function. Call instantiate_type to get error
5844 if (rhstype == unknown_type_node)
5845 instantiate_type (type, rhs, tf_error | tf_warning);
5847 error ("cannot convert %qT to %qT for argument %qP to %qD",
5848 rhstype, type, parmnum, fndecl);
5850 error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
5851 return error_mark_node;
5854 return perform_implicit_conversion (strip_top_quals (type), rhs);
5857 /* Convert RHS to be of type TYPE.
5858 If EXP is nonzero, it is the target of the initialization.
5859 ERRTYPE is a string to use in error messages.
5861 Two major differences between the behavior of
5862 `convert_for_assignment' and `convert_for_initialization'
5863 are that references are bashed in the former, while
5864 copied in the latter, and aggregates are assigned in
5865 the former (operator=) while initialized in the
5868 If using constructor make sure no conversion operator exists, if one does
5869 exist, an ambiguity exists.
5871 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
5874 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
5875 const char *errtype, tree fndecl, int parmnum)
5877 enum tree_code codel = TREE_CODE (type);
5879 enum tree_code coder;
5881 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5882 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
5883 if (TREE_CODE (rhs) == NOP_EXPR
5884 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
5885 && codel != REFERENCE_TYPE)
5886 rhs = TREE_OPERAND (rhs, 0);
5888 if (rhs == error_mark_node
5889 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
5890 return error_mark_node;
5892 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
5893 && TREE_CODE (type) != ARRAY_TYPE
5894 && (TREE_CODE (type) != REFERENCE_TYPE
5895 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
5896 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
5897 && (TREE_CODE (type) != REFERENCE_TYPE
5898 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
5899 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
5900 rhs = decay_conversion (rhs);
5902 rhstype = TREE_TYPE (rhs);
5903 coder = TREE_CODE (rhstype);
5905 if (coder == ERROR_MARK)
5906 return error_mark_node;
5908 /* We accept references to incomplete types, so we can
5909 return here before checking if RHS is of complete type. */
5911 if (codel == REFERENCE_TYPE)
5913 /* This should eventually happen in convert_arguments. */
5914 int savew = 0, savee = 0;
5917 savew = warningcount, savee = errorcount;
5918 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
5922 if (warningcount > savew)
5923 cp_warning_at ("in passing argument %P of %q+D", parmnum, fndecl);
5924 else if (errorcount > savee)
5925 cp_error_at ("in passing argument %P of %q+D", parmnum, fndecl);
5931 exp = require_complete_type (exp);
5932 if (exp == error_mark_node)
5933 return error_mark_node;
5935 rhstype = non_reference (rhstype);
5937 type = complete_type (type);
5939 if (IS_AGGR_TYPE (type))
5940 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
5942 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
5945 /* If RETVAL is the address of, or a reference to, a local variable or
5946 temporary give an appropriate warning. */
5949 maybe_warn_about_returning_address_of_local (tree retval)
5951 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
5952 tree whats_returned = retval;
5956 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
5957 whats_returned = TREE_OPERAND (whats_returned, 1);
5958 else if (TREE_CODE (whats_returned) == CONVERT_EXPR
5959 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
5960 || TREE_CODE (whats_returned) == NOP_EXPR)
5961 whats_returned = TREE_OPERAND (whats_returned, 0);
5966 if (TREE_CODE (whats_returned) != ADDR_EXPR)
5968 whats_returned = TREE_OPERAND (whats_returned, 0);
5970 if (TREE_CODE (valtype) == REFERENCE_TYPE)
5972 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
5973 || TREE_CODE (whats_returned) == TARGET_EXPR)
5975 warning ("returning reference to temporary");
5978 if (TREE_CODE (whats_returned) == VAR_DECL
5979 && DECL_NAME (whats_returned)
5980 && TEMP_NAME_P (DECL_NAME (whats_returned)))
5982 warning ("reference to non-lvalue returned");
5987 if (DECL_P (whats_returned)
5988 && DECL_NAME (whats_returned)
5989 && DECL_FUNCTION_SCOPE_P (whats_returned)
5990 && !(TREE_STATIC (whats_returned)
5991 || TREE_PUBLIC (whats_returned)))
5993 if (TREE_CODE (valtype) == REFERENCE_TYPE)
5994 cp_warning_at ("reference to local variable %qD returned",
5997 cp_warning_at ("address of local variable %qD returned",
6003 /* Check that returning RETVAL from the current function is valid.
6004 Return an expression explicitly showing all conversions required to
6005 change RETVAL into the function return type, and to assign it to
6006 the DECL_RESULT for the function. */
6009 check_return_expr (tree retval)
6012 /* The type actually returned by the function, after any
6015 int fn_returns_value_p;
6017 /* A `volatile' function is one that isn't supposed to return, ever.
6018 (This is a G++ extension, used to get better code for functions
6019 that call the `volatile' function.) */
6020 if (TREE_THIS_VOLATILE (current_function_decl))
6021 warning ("function declared %<noreturn%> has a %<return%> statement");
6023 /* Check for various simple errors. */
6024 if (DECL_DESTRUCTOR_P (current_function_decl))
6027 error ("returning a value from a destructor");
6030 else if (DECL_CONSTRUCTOR_P (current_function_decl))
6032 if (in_function_try_handler)
6033 /* If a return statement appears in a handler of the
6034 function-try-block of a constructor, the program is ill-formed. */
6035 error ("cannot return from a handler of a function-try-block of a constructor");
6037 /* You can't return a value from a constructor. */
6038 error ("returning a value from a constructor");
6042 if (processing_template_decl)
6044 current_function_returns_value = 1;
6048 /* When no explicit return-value is given in a function with a named
6049 return value, the named return value is used. */
6050 result = DECL_RESULT (current_function_decl);
6051 valtype = TREE_TYPE (result);
6052 gcc_assert (valtype != NULL_TREE);
6053 fn_returns_value_p = !VOID_TYPE_P (valtype);
6054 if (!retval && DECL_NAME (result) && fn_returns_value_p)
6057 /* Check for a return statement with no return value in a function
6058 that's supposed to return a value. */
6059 if (!retval && fn_returns_value_p)
6061 pedwarn ("return-statement with no value, in function returning %qT",
6063 /* Clear this, so finish_function won't say that we reach the
6064 end of a non-void function (which we don't, we gave a
6066 current_function_returns_null = 0;
6068 /* Check for a return statement with a value in a function that
6069 isn't supposed to return a value. */
6070 else if (retval && !fn_returns_value_p)
6072 if (VOID_TYPE_P (TREE_TYPE (retval)))
6073 /* You can return a `void' value from a function of `void'
6074 type. In that case, we have to evaluate the expression for
6075 its side-effects. */
6076 finish_expr_stmt (retval);
6078 pedwarn ("return-statement with a value, in function "
6079 "returning 'void'");
6081 current_function_returns_null = 1;
6083 /* There's really no value to return, after all. */
6087 /* Remember that this function can sometimes return without a
6089 current_function_returns_null = 1;
6091 /* Remember that this function did return a value. */
6092 current_function_returns_value = 1;
6094 /* Check for erroneous operands -- but after giving ourselves a
6095 chance to provide an error about returning a value from a void
6097 if (error_operand_p (retval))
6099 current_function_return_value = error_mark_node;
6100 return error_mark_node;
6103 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6104 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6105 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6106 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6108 && null_ptr_cst_p (retval))
6109 warning ("%<operator new%> must not return NULL unless it is "
6110 "declared %<throw()%> (or -fcheck-new is in effect)");
6112 /* Effective C++ rule 15. See also start_function. */
6114 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6118 /* The function return type must be a reference to the current
6120 if (TREE_CODE (valtype) == REFERENCE_TYPE
6121 && same_type_ignoring_top_level_qualifiers_p
6122 (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6124 /* Returning '*this' is obviously OK. */
6125 if (retval == current_class_ref)
6127 /* If we are calling a function whose return type is the same of
6128 the current class reference, it is ok. */
6129 else if (TREE_CODE (retval) == INDIRECT_REF
6130 && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6135 warning ("%<operator=%> should return a reference to %<*this%>");
6138 /* The fabled Named Return Value optimization, as per [class.copy]/15:
6140 [...] For a function with a class return type, if the expression
6141 in the return statement is the name of a local object, and the cv-
6142 unqualified type of the local object is the same as the function
6143 return type, an implementation is permitted to omit creating the tem-
6144 porary object to hold the function return value [...]
6146 So, if this is a value-returning function that always returns the same
6147 local variable, remember it.
6149 It might be nice to be more flexible, and choose the first suitable
6150 variable even if the function sometimes returns something else, but
6151 then we run the risk of clobbering the variable we chose if the other
6152 returned expression uses the chosen variable somehow. And people expect
6153 this restriction, anyway. (jason 2000-11-19)
6155 See finish_function and finalize_nrv for the rest of this optimization. */
6157 if (fn_returns_value_p && flag_elide_constructors)
6159 if (retval != NULL_TREE
6160 && (current_function_return_value == NULL_TREE
6161 || current_function_return_value == retval)
6162 && TREE_CODE (retval) == VAR_DECL
6163 && DECL_CONTEXT (retval) == current_function_decl
6164 && ! TREE_STATIC (retval)
6165 && (DECL_ALIGN (retval)
6166 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6167 && same_type_p ((TYPE_MAIN_VARIANT
6168 (TREE_TYPE (retval))),
6170 (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6171 current_function_return_value = retval;
6173 current_function_return_value = error_mark_node;
6176 /* We don't need to do any conversions when there's nothing being
6181 /* Do any required conversions. */
6182 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6183 /* No conversions are required. */
6187 /* The type the function is declared to return. */
6188 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6190 /* First convert the value to the function's return type, then
6191 to the type of return value's location to handle the
6192 case that functype is smaller than the valtype. */
6193 retval = convert_for_initialization
6194 (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6195 "return", NULL_TREE, 0);
6196 retval = convert (valtype, retval);
6198 /* If the conversion failed, treat this just like `return;'. */
6199 if (retval == error_mark_node)
6201 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6202 else if (! current_function_returns_struct
6203 && TREE_CODE (retval) == TARGET_EXPR
6204 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6205 retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6206 TREE_OPERAND (retval, 0));
6208 maybe_warn_about_returning_address_of_local (retval);
6211 /* Actually copy the value returned into the appropriate location. */
6212 if (retval && retval != result)
6213 retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
6219 /* Returns nonzero if the pointer-type FROM can be converted to the
6220 pointer-type TO via a qualification conversion. If CONSTP is -1,
6221 then we return nonzero if the pointers are similar, and the
6222 cv-qualification signature of FROM is a proper subset of that of TO.
6224 If CONSTP is positive, then all outer pointers have been
6228 comp_ptr_ttypes_real (tree to, tree from, int constp)
6230 bool to_more_cv_qualified = false;
6232 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6234 if (TREE_CODE (to) != TREE_CODE (from))
6237 if (TREE_CODE (from) == OFFSET_TYPE
6238 && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6239 TYPE_OFFSET_BASETYPE (to)))
6242 /* Const and volatile mean something different for function types,
6243 so the usual checks are not appropriate. */
6244 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6246 if (!at_least_as_qualified_p (to, from))
6249 if (!at_least_as_qualified_p (from, to))
6253 to_more_cv_qualified = true;
6257 constp &= TYPE_READONLY (to);
6260 if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6261 return ((constp >= 0 || to_more_cv_qualified)
6262 && same_type_ignoring_top_level_qualifiers_p (to, from));
6266 /* When comparing, say, char ** to char const **, this function takes
6267 the 'char *' and 'char const *'. Do not pass non-pointer/reference
6268 types to this function. */
6271 comp_ptr_ttypes (tree to, tree from)
6273 return comp_ptr_ttypes_real (to, from, 1);
6276 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6277 type or inheritance-related types, regardless of cv-quals. */
6280 ptr_reasonably_similar (tree to, tree from)
6282 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6284 /* Any target type is similar enough to void. */
6285 if (TREE_CODE (to) == VOID_TYPE
6286 || TREE_CODE (from) == VOID_TYPE)
6289 if (TREE_CODE (to) != TREE_CODE (from))
6292 if (TREE_CODE (from) == OFFSET_TYPE
6293 && comptypes (TYPE_OFFSET_BASETYPE (to),
6294 TYPE_OFFSET_BASETYPE (from),
6295 COMPARE_BASE | COMPARE_DERIVED))
6298 if (TREE_CODE (to) == VECTOR_TYPE
6299 && vector_types_convertible_p (to, from))
6302 if (TREE_CODE (to) == INTEGER_TYPE
6303 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6306 if (TREE_CODE (to) == FUNCTION_TYPE)
6309 if (TREE_CODE (to) != POINTER_TYPE)
6311 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6312 COMPARE_BASE | COMPARE_DERIVED);
6316 /* Like comp_ptr_ttypes, for const_cast. */
6319 comp_ptr_ttypes_const (tree to, tree from)
6321 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6323 if (TREE_CODE (to) != TREE_CODE (from))
6326 if (TREE_CODE (from) == OFFSET_TYPE
6327 && same_type_p (TYPE_OFFSET_BASETYPE (from),
6328 TYPE_OFFSET_BASETYPE (to)))
6331 if (TREE_CODE (to) != POINTER_TYPE)
6332 return same_type_ignoring_top_level_qualifiers_p (to, from);
6336 /* Returns the type qualifiers for this type, including the qualifiers on the
6337 elements for an array type. */
6340 cp_type_quals (tree type)
6342 type = strip_array_types (type);
6343 if (type == error_mark_node)
6344 return TYPE_UNQUALIFIED;
6345 return TYPE_QUALS (type);
6348 /* Returns nonzero if the TYPE contains a mutable member. */
6351 cp_has_mutable_p (tree type)
6353 type = strip_array_types (type);
6355 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6358 /* Apply the TYPE_QUALS to the new DECL. */
6360 cp_apply_type_quals_to_decl (int type_quals, tree decl)
6362 tree type = TREE_TYPE (decl);
6364 if (type == error_mark_node)
6367 if (TREE_CODE (type) == FUNCTION_TYPE
6368 && type_quals != TYPE_UNQUALIFIED)
6370 /* This was an error in C++98 (cv-qualifiers cannot be added to
6371 a function type), but DR 295 makes the code well-formed by
6372 dropping the extra qualifiers. */
6375 tree bad_type = build_qualified_type (type, type_quals);
6376 pedwarn ("ignoring %qV qualifiers added to function type %qT",
6380 TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
6384 /* Avoid setting TREE_READONLY incorrectly. */
6385 if (/* If the object has a constructor, the constructor may modify
6387 TYPE_NEEDS_CONSTRUCTING (type)
6388 /* If the type isn't complete, we don't know yet if it will need
6390 || !COMPLETE_TYPE_P (type)
6391 /* If the type has a mutable component, that component might be
6393 || TYPE_HAS_MUTABLE_P (type))
6394 type_quals &= ~TYPE_QUAL_CONST;
6396 c_apply_type_quals_to_decl (type_quals, decl);
6399 /* Subroutine of casts_away_constness. Make T1 and T2 point at
6400 exemplar types such that casting T1 to T2 is casting away constness
6401 if and only if there is no implicit conversion from T1 to T2. */
6404 casts_away_constness_r (tree *t1, tree *t2)
6409 /* [expr.const.cast]
6411 For multi-level pointer to members and multi-level mixed pointers
6412 and pointers to members (conv.qual), the "member" aspect of a
6413 pointer to member level is ignored when determining if a const
6414 cv-qualifier has been cast away. */
6415 if (TYPE_PTRMEM_P (*t1))
6416 *t1 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t1));
6417 if (TYPE_PTRMEM_P (*t2))
6418 *t2 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t2));
6420 /* [expr.const.cast]
6422 For two pointer types:
6424 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
6425 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
6428 casting from X1 to X2 casts away constness if, for a non-pointer
6429 type T there does not exist an implicit conversion (clause
6432 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6436 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
6438 if (TREE_CODE (*t1) != POINTER_TYPE
6439 || TREE_CODE (*t2) != POINTER_TYPE)
6441 *t1 = cp_build_qualified_type (void_type_node,
6442 cp_type_quals (*t1));
6443 *t2 = cp_build_qualified_type (void_type_node,
6444 cp_type_quals (*t2));
6448 quals1 = cp_type_quals (*t1);
6449 quals2 = cp_type_quals (*t2);
6450 *t1 = TREE_TYPE (*t1);
6451 *t2 = TREE_TYPE (*t2);
6452 casts_away_constness_r (t1, t2);
6453 *t1 = build_pointer_type (*t1);
6454 *t2 = build_pointer_type (*t2);
6455 *t1 = cp_build_qualified_type (*t1, quals1);
6456 *t2 = cp_build_qualified_type (*t2, quals2);
6459 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6463 casts_away_constness (tree t1, tree t2)
6465 if (TREE_CODE (t2) == REFERENCE_TYPE)
6467 /* [expr.const.cast]
6469 Casting from an lvalue of type T1 to an lvalue of type T2
6470 using a reference cast casts away constness if a cast from an
6471 rvalue of type "pointer to T1" to the type "pointer to T2"
6472 casts away constness. */
6473 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6474 return casts_away_constness (build_pointer_type (t1),
6475 build_pointer_type (TREE_TYPE (t2)));
6478 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6479 /* [expr.const.cast]
6481 Casting from an rvalue of type "pointer to data member of X
6482 of type T1" to the type "pointer to data member of Y of type
6483 T2" casts away constness if a cast from an rvalue of type
6484 "pointer to T1" to the type "pointer to T2" casts away
6486 return casts_away_constness
6487 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6488 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6490 /* Casting away constness is only something that makes sense for
6491 pointer or reference types. */
6492 if (TREE_CODE (t1) != POINTER_TYPE
6493 || TREE_CODE (t2) != POINTER_TYPE)
6496 /* Top-level qualifiers don't matter. */
6497 t1 = TYPE_MAIN_VARIANT (t1);
6498 t2 = TYPE_MAIN_VARIANT (t2);
6499 casts_away_constness_r (&t1, &t2);
6500 if (!can_convert (t2, t1))
6506 /* If T is a REFERENCE_TYPE return the type to which T refers.
6507 Otherwise, return T itself. */
6510 non_reference (tree t)
6512 if (TREE_CODE (t) == REFERENCE_TYPE)
6518 /* Return nonzero if REF is an lvalue valid for this language;
6519 otherwise, print an error message and return zero. USE says
6520 how the lvalue is being used and so selects the error message. */
6523 lvalue_or_else (tree ref, enum lvalue_use use)
6525 int win = lvalue_p (ref);