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.
29 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
30 and to process initializations in declarations (since they work
31 like a strange sort of assignment). */
35 #include "coretypes.h"
45 #include "diagnostic.h"
49 static tree convert_for_assignment (tree, tree, const char *, tree, int);
50 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
51 static tree rationalize_conditional_expr (enum tree_code, tree);
52 static int comp_ptr_ttypes_real (tree, tree, int);
53 static int comp_ptr_ttypes_const (tree, tree);
54 static bool comp_except_types (tree, tree, bool);
55 static bool comp_array_types (tree, tree, bool);
56 static tree common_base_type (tree, tree);
57 static tree pointer_diff (tree, tree, tree);
58 static tree get_delta_difference (tree, tree, int);
59 static void casts_away_constness_r (tree *, tree *);
60 static bool casts_away_constness (tree, tree);
61 static void maybe_warn_about_returning_address_of_local (tree);
62 static tree lookup_destructor (tree, tree, tree);
64 /* Return the target type of TYPE, which means return T for:
65 T*, T&, T[], T (...), and otherwise, just T. */
68 target_type (tree type)
70 type = non_reference (type);
71 while (TREE_CODE (type) == POINTER_TYPE
72 || TREE_CODE (type) == ARRAY_TYPE
73 || TREE_CODE (type) == FUNCTION_TYPE
74 || TREE_CODE (type) == METHOD_TYPE
75 || TYPE_PTRMEM_P (type))
76 type = TREE_TYPE (type);
80 /* Do `exp = require_complete_type (exp);' to make sure exp
81 does not have an incomplete type. (That includes void types.)
82 Returns the error_mark_node if the VALUE does not have
83 complete type when this function returns. */
86 require_complete_type (tree value)
90 if (processing_template_decl || value == error_mark_node)
93 if (TREE_CODE (value) == OVERLOAD)
94 type = unknown_type_node;
96 type = TREE_TYPE (value);
98 /* First, detect a valid value with a complete type. */
99 if (COMPLETE_TYPE_P (type))
102 if (complete_type_or_else (type, value))
105 return error_mark_node;
108 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
109 a template instantiation, do the instantiation. Returns TYPE,
110 whether or not it could be completed, unless something goes
111 horribly wrong, in which case the error_mark_node is returned. */
114 complete_type (tree type)
116 if (type == NULL_TREE)
117 /* Rather than crash, we return something sure to cause an error
119 return error_mark_node;
121 if (type == error_mark_node || COMPLETE_TYPE_P (type))
123 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
125 tree t = complete_type (TREE_TYPE (type));
126 if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
128 TYPE_NEEDS_CONSTRUCTING (type)
129 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
130 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
131 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
133 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
134 instantiate_class_template (TYPE_MAIN_VARIANT (type));
139 /* Like complete_type, but issue an error if the TYPE cannot be completed.
140 VALUE is used for informative diagnostics. DIAG_TYPE indicates the type
141 of diagnostic: 0 for an error, 1 for a warning, 2 for a pedwarn.
142 Returns NULL_TREE if the type cannot be made complete. */
145 complete_type_or_diagnostic (tree type, tree value, int diag_type)
147 type = complete_type (type);
148 if (type == error_mark_node)
149 /* We already issued an error. */
151 else if (!COMPLETE_TYPE_P (type))
153 cxx_incomplete_type_diagnostic (value, type, diag_type);
160 /* Return truthvalue of whether type of EXP is instantiated. */
163 type_unknown_p (tree exp)
165 return (TREE_CODE (exp) == TREE_LIST
166 || TREE_TYPE (exp) == unknown_type_node);
170 /* Return the common type of two parameter lists.
171 We assume that comptypes has already been done and returned 1;
172 if that isn't so, this may crash.
174 As an optimization, free the space we allocate if the parameter
175 lists are already common. */
178 commonparms (tree p1, tree p2)
180 tree oldargs = p1, newargs, n;
184 len = list_length (p1);
185 newargs = tree_last (p1);
187 if (newargs == void_list_node)
196 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
201 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
203 if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
205 TREE_PURPOSE (n) = TREE_PURPOSE (p1);
208 else if (! TREE_PURPOSE (p1))
210 if (TREE_PURPOSE (p2))
212 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
218 if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
220 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
222 if (TREE_VALUE (p1) != TREE_VALUE (p2))
225 TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
228 TREE_VALUE (n) = TREE_VALUE (p1);
236 /* Given a type, perhaps copied for a typedef,
237 find the "original" version of it. */
239 original_type (tree t)
241 while (TYPE_NAME (t) != NULL_TREE)
243 tree x = TYPE_NAME (t);
244 if (TREE_CODE (x) != TYPE_DECL)
246 x = DECL_ORIGINAL_TYPE (x);
254 /* T1 and T2 are arithmetic or enumeration types. Return the type
255 that will result from the "usual arithmetic conversions" on T1 and
256 T2 as described in [expr]. */
259 type_after_usual_arithmetic_conversions (tree t1, tree t2)
261 enum tree_code code1 = TREE_CODE (t1);
262 enum tree_code code2 = TREE_CODE (t2);
265 /* FIXME: Attributes. */
266 my_friendly_assert (ARITHMETIC_TYPE_P (t1)
267 || TREE_CODE (t1) == COMPLEX_TYPE
268 || TREE_CODE (t1) == VECTOR_TYPE
269 || TREE_CODE (t1) == ENUMERAL_TYPE,
271 my_friendly_assert (ARITHMETIC_TYPE_P (t2)
272 || TREE_CODE (t2) == COMPLEX_TYPE
273 || TREE_CODE (t2) == VECTOR_TYPE
274 || TREE_CODE (t2) == ENUMERAL_TYPE,
277 /* In what follows, we slightly generalize the rules given in [expr] so
278 as to deal with `long long' and `complex'. First, merge the
280 attributes = (*targetm.merge_type_attributes) (t1, t2);
282 /* If one type is complex, form the common type of the non-complex
283 components, then make that complex. Use T1 or T2 if it is the
285 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
287 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
288 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
290 = type_after_usual_arithmetic_conversions (subtype1, subtype2);
292 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
293 return build_type_attribute_variant (t1, attributes);
294 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
295 return build_type_attribute_variant (t2, attributes);
297 return build_type_attribute_variant (build_complex_type (subtype),
301 if (code1 == VECTOR_TYPE)
303 /* When we get here we should have two vectors of the same size.
304 Just prefer the unsigned one if present. */
305 if (TREE_UNSIGNED (t1))
306 return build_type_attribute_variant (t1, attributes);
308 return build_type_attribute_variant (t2, attributes);
311 /* If only one is real, use it as the result. */
312 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
313 return build_type_attribute_variant (t1, attributes);
314 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
315 return build_type_attribute_variant (t2, attributes);
317 /* Perform the integral promotions. */
318 if (code1 != REAL_TYPE)
320 t1 = type_promotes_to (t1);
321 t2 = type_promotes_to (t2);
324 /* Both real or both integers; use the one with greater precision. */
325 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
326 return build_type_attribute_variant (t1, attributes);
327 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
328 return build_type_attribute_variant (t2, attributes);
330 /* The types are the same; no need to do anything fancy. */
331 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
332 return build_type_attribute_variant (t1, attributes);
334 if (code1 != REAL_TYPE)
336 /* If one is a sizetype, use it so size_binop doesn't blow up. */
337 if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
338 return build_type_attribute_variant (t1, attributes);
339 if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
340 return build_type_attribute_variant (t2, attributes);
342 /* If one is unsigned long long, then convert the other to unsigned
344 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
345 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
346 return build_type_attribute_variant (long_long_unsigned_type_node,
348 /* If one is a long long, and the other is an unsigned long, and
349 long long can represent all the values of an unsigned long, then
350 convert to a long long. Otherwise, convert to an unsigned long
351 long. Otherwise, if either operand is long long, convert the
354 Since we're here, we know the TYPE_PRECISION is the same;
355 therefore converting to long long cannot represent all the values
356 of an unsigned long, so we choose unsigned long long in that
358 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
359 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
361 tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
362 ? long_long_unsigned_type_node
363 : long_long_integer_type_node);
364 return build_type_attribute_variant (t, attributes);
367 /* Go through the same procedure, but for longs. */
368 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
369 || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
370 return build_type_attribute_variant (long_unsigned_type_node,
372 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
373 || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
375 tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
376 ? long_unsigned_type_node : long_integer_type_node);
377 return build_type_attribute_variant (t, attributes);
379 /* Otherwise prefer the unsigned one. */
380 if (TREE_UNSIGNED (t1))
381 return build_type_attribute_variant (t1, attributes);
383 return build_type_attribute_variant (t2, attributes);
387 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
388 || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
389 return build_type_attribute_variant (long_double_type_node,
391 if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
392 || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
393 return build_type_attribute_variant (double_type_node,
395 if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
396 || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
397 return build_type_attribute_variant (float_type_node,
400 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
401 the standard C++ floating-point types. Logic earlier in this
402 function has already eliminated the possibility that
403 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
404 compelling reason to choose one or the other. */
405 return build_type_attribute_variant (t1, attributes);
409 /* Subroutine of composite_pointer_type to implement the recursive
410 case. See that function for documentation fo the parameters. */
413 composite_pointer_type_r (tree t1, tree t2, const char* location)
420 /* Determine the types pointed to by T1 and T2. */
421 if (TREE_CODE (t1) == POINTER_TYPE)
423 pointee1 = TREE_TYPE (t1);
424 pointee2 = TREE_TYPE (t2);
428 pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
429 pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
434 Otherwise, the composite pointer type is a pointer type
435 similar (_conv.qual_) to the type of one of the operands,
436 with a cv-qualification signature (_conv.qual_) that is the
437 union of the cv-qualification signatures of the operand
439 if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
440 result_type = pointee1;
441 else if ((TREE_CODE (pointee1) == POINTER_TYPE
442 && TREE_CODE (pointee2) == POINTER_TYPE)
443 || (TYPE_PTR_TO_MEMBER_P (pointee1)
444 && TYPE_PTR_TO_MEMBER_P (pointee2)))
445 result_type = composite_pointer_type_r (pointee1, pointee2, location);
448 pedwarn ("%s between distinct pointer types `%T' and `%T' "
451 result_type = void_type_node;
453 result_type = cp_build_qualified_type (result_type,
454 (cp_type_quals (pointee1)
455 | cp_type_quals (pointee2)));
456 /* If the original types were pointers to members, so is the
458 if (TYPE_PTR_TO_MEMBER_P (t1))
460 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
461 TYPE_PTRMEM_CLASS_TYPE (t2)))
462 pedwarn ("%s between distinct pointer types `%T' and `%T' "
465 result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
469 result_type = build_pointer_type (result_type);
471 /* Merge the attributes. */
472 attributes = (*targetm.merge_type_attributes) (t1, t2);
473 return build_type_attribute_variant (result_type, attributes);
476 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
477 ARG1 and ARG2 are the values with those types. The LOCATION is a
478 string describing the current location, in case an error occurs.
480 This routine also implements the computation of a common type for
481 pointers-to-members as per [expr.eq]. */
484 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
485 const char* location)
492 If one operand is a null pointer constant, the composite pointer
493 type is the type of the other operand. */
494 if (null_ptr_cst_p (arg1))
496 if (null_ptr_cst_p (arg2))
503 If one of the operands has type "pointer to cv1 void*", then
504 the other has type "pointer to cv2T", and the composite pointer
505 type is "pointer to cv12 void", where cv12 is the union of cv1
508 If either type is a pointer to void, make sure it is T1. */
509 if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
517 /* Now, if T1 is a pointer to void, merge the qualifiers. */
518 if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
523 if (pedantic && TYPE_PTRFN_P (t2))
524 pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location);
526 = cp_build_qualified_type (void_type_node,
527 (cp_type_quals (TREE_TYPE (t1))
528 | cp_type_quals (TREE_TYPE (t2))));
529 result_type = build_pointer_type (result_type);
530 /* Merge the attributes. */
531 attributes = (*targetm.merge_type_attributes) (t1, t2);
532 return build_type_attribute_variant (result_type, attributes);
535 /* [expr.eq] permits the application of a pointer conversion to
536 bring the pointers to a common type. */
537 if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
538 && CLASS_TYPE_P (TREE_TYPE (t1))
539 && CLASS_TYPE_P (TREE_TYPE (t2))
540 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
543 class1 = TREE_TYPE (t1);
544 class2 = TREE_TYPE (t2);
546 if (DERIVED_FROM_P (class1, class2))
547 t2 = (build_pointer_type
548 (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
549 else if (DERIVED_FROM_P (class2, class1))
550 t1 = (build_pointer_type
551 (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
554 error ("%s between distinct pointer types `%T' and `%T' "
555 "lacks a cast", location, t1, t2);
556 return error_mark_node;
559 /* [expr.eq] permits the application of a pointer-to-member
560 conversion to change the class type of one of the types. */
561 else if (TYPE_PTR_TO_MEMBER_P (t1)
562 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
563 TYPE_PTRMEM_CLASS_TYPE (t2)))
565 class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
566 class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
568 if (DERIVED_FROM_P (class1, class2))
569 t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
570 else if (DERIVED_FROM_P (class2, class1))
571 t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
574 error ("%s between distinct pointer-to-member types `%T' and `%T' "
575 "lacks a cast", location, t1, t2);
576 return error_mark_node;
580 return composite_pointer_type_r (t1, t2, location);
583 /* Return the merged type of two types.
584 We assume that comptypes has already been done and returned 1;
585 if that isn't so, this may crash.
587 This just combines attributes and default arguments; any other
588 differences would cause the two types to compare unalike. */
591 merge_types (tree t1, tree t2)
593 enum tree_code code1;
594 enum tree_code code2;
597 /* Save time if the two types are the same. */
600 if (original_type (t1) == original_type (t2))
603 /* If one type is nonsense, use the other. */
604 if (t1 == error_mark_node)
606 if (t2 == error_mark_node)
609 /* Merge the attributes. */
610 attributes = (*targetm.merge_type_attributes) (t1, t2);
612 if (TYPE_PTRMEMFUNC_P (t1))
613 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
614 if (TYPE_PTRMEMFUNC_P (t2))
615 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
617 code1 = TREE_CODE (t1);
618 code2 = TREE_CODE (t2);
624 /* For two pointers, do this recursively on the target type. */
626 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
627 int quals = cp_type_quals (t1);
629 if (code1 == POINTER_TYPE)
630 t1 = build_pointer_type (target);
632 t1 = build_reference_type (target);
633 t1 = build_type_attribute_variant (t1, attributes);
634 t1 = cp_build_qualified_type (t1, quals);
636 if (TREE_CODE (target) == METHOD_TYPE)
637 t1 = build_ptrmemfunc_type (t1);
646 quals = cp_type_quals (t1);
647 pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
648 TYPE_PTRMEM_POINTED_TO_TYPE (t2));
649 t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
651 t1 = cp_build_qualified_type (t1, quals);
657 tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
658 /* Save space: see if the result is identical to one of the args. */
659 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
660 return build_type_attribute_variant (t1, attributes);
661 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
662 return build_type_attribute_variant (t2, attributes);
663 /* Merge the element types, and have a size if either arg has one. */
664 t1 = build_cplus_array_type
665 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
670 /* Function types: prefer the one that specified arg types.
671 If both do, merge the arg types. Also merge the return types. */
673 tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
674 tree p1 = TYPE_ARG_TYPES (t1);
675 tree p2 = TYPE_ARG_TYPES (t2);
678 /* Save space: see if the result is identical to one of the args. */
679 if (valtype == TREE_TYPE (t1) && ! p2)
680 return cp_build_type_attribute_variant (t1, attributes);
681 if (valtype == TREE_TYPE (t2) && ! p1)
682 return cp_build_type_attribute_variant (t2, attributes);
684 /* Simple way if one arg fails to specify argument types. */
685 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
687 rval = build_function_type (valtype, p2);
688 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
689 rval = build_exception_variant (rval, raises);
690 return cp_build_type_attribute_variant (rval, attributes);
692 raises = TYPE_RAISES_EXCEPTIONS (t1);
693 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
695 rval = build_function_type (valtype, p1);
697 rval = build_exception_variant (rval, raises);
698 return cp_build_type_attribute_variant (rval, attributes);
701 rval = build_function_type (valtype, commonparms (p1, p2));
702 t1 = build_exception_variant (rval, raises);
708 /* Get this value the long way, since TYPE_METHOD_BASETYPE
709 is just the main variant of this. */
710 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
711 tree raises = TYPE_RAISES_EXCEPTIONS (t1);
714 /* If this was a member function type, get back to the
715 original type of type member function (i.e., without
716 the class instance variable up front. */
717 t1 = build_function_type (TREE_TYPE (t1),
718 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
719 t2 = build_function_type (TREE_TYPE (t2),
720 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
721 t3 = merge_types (t1, t2);
722 t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
723 TYPE_ARG_TYPES (t3));
724 t1 = build_exception_variant (t3, raises);
729 /* There is no need to merge attributes into a TYPENAME_TYPE.
730 When the type is instantiated it will have whatever
731 attributes result from the instantiation. */
736 return cp_build_type_attribute_variant (t1, attributes);
739 /* Return the common type of two types.
740 We assume that comptypes has already been done and returned 1;
741 if that isn't so, this may crash.
743 This is the type for the result of most arithmetic operations
744 if the operands have the given two types. */
747 common_type (tree t1, tree t2)
749 enum tree_code code1;
750 enum tree_code code2;
752 /* If one type is nonsense, bail. */
753 if (t1 == error_mark_node || t2 == error_mark_node)
754 return error_mark_node;
756 code1 = TREE_CODE (t1);
757 code2 = TREE_CODE (t2);
759 if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
760 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
761 && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
762 || code2 == COMPLEX_TYPE || code2 == VECTOR_TYPE))
763 return type_after_usual_arithmetic_conversions (t1, t2);
765 else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
766 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
767 || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
768 return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
774 /* Compare two exception specifier types for exactness or subsetness, if
775 allowed. Returns false for mismatch, true for match (same, or
778 [except.spec] "If a class X ... objects of class X or any class publicly
779 and unambiguously derived from X. Similarly, if a pointer type Y * ...
780 exceptions of type Y * or that are pointers to any type publicly and
781 unambiguously derived from Y. Otherwise a function only allows exceptions
782 that have the same type ..."
783 This does not mention cv qualifiers and is different to what throw
784 [except.throw] and catch [except.catch] will do. They will ignore the
785 top level cv qualifiers, and allow qualifiers in the pointer to class
788 We implement the letter of the standard. */
791 comp_except_types (tree a, tree b, bool exact)
793 if (same_type_p (a, b))
797 if (cp_type_quals (a) || cp_type_quals (b))
800 if (TREE_CODE (a) == POINTER_TYPE
801 && TREE_CODE (b) == POINTER_TYPE)
805 if (cp_type_quals (a) || cp_type_quals (b))
809 if (TREE_CODE (a) != RECORD_TYPE
810 || TREE_CODE (b) != RECORD_TYPE)
813 if (ACCESSIBLY_UNIQUELY_DERIVED_P (a, b))
819 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
820 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
821 otherwise it must be exact. Exception lists are unordered, but
822 we've already filtered out duplicates. Most lists will be in order,
823 we should try to make use of that. */
826 comp_except_specs (tree t1, tree t2, bool exact)
835 if (t1 == NULL_TREE) /* T1 is ... */
836 return t2 == NULL_TREE || !exact;
837 if (!TREE_VALUE (t1)) /* t1 is EMPTY */
838 return t2 != NULL_TREE && !TREE_VALUE (t2);
839 if (t2 == NULL_TREE) /* T2 is ... */
841 if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
844 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
845 Count how many we find, to determine exactness. For exact matching and
846 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
848 for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
850 for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
852 tree a = TREE_VALUE (probe);
853 tree b = TREE_VALUE (t2);
855 if (comp_except_types (a, b, exact))
857 if (probe == base && exact)
858 base = TREE_CHAIN (probe);
863 if (probe == NULL_TREE)
866 return !exact || base == NULL_TREE || length == list_length (t1);
869 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
870 [] can match [size]. */
873 comp_array_types (tree t1, tree t2, bool allow_redeclaration)
882 /* The type of the array elements must be the same. */
883 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
886 d1 = TYPE_DOMAIN (t1);
887 d2 = TYPE_DOMAIN (t2);
892 /* If one of the arrays is dimensionless, and the other has a
893 dimension, they are of different types. However, it is valid to
901 declarations for an array object can specify
902 array types that differ by the presence or absence of a major
903 array bound (_dcl.array_). */
905 return allow_redeclaration;
907 /* Check that the dimensions are the same. */
909 if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
911 max1 = TYPE_MAX_VALUE (d1);
912 max2 = TYPE_MAX_VALUE (d2);
913 if (processing_template_decl && !abi_version_at_least (2)
914 && !value_dependent_expression_p (max1)
915 && !value_dependent_expression_p (max2))
917 /* With abi-1 we do not fold non-dependent array bounds, (and
918 consequently mangle them incorrectly). We must therefore
919 fold them here, to verify the domains have the same
925 if (!cp_tree_equal (max1, max2))
931 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
932 is a bitwise-or of the COMPARE_* flags. */
935 comptypes (tree t1, tree t2, int strict)
940 /* Suppress errors caused by previously reported errors. */
941 if (t1 == error_mark_node || t2 == error_mark_node)
944 my_friendly_assert (TYPE_P (t1) && TYPE_P (t2), 20030623);
946 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
947 current instantiation. */
948 if (TREE_CODE (t1) == TYPENAME_TYPE)
950 tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
952 if (resolved != error_mark_node)
956 if (TREE_CODE (t2) == TYPENAME_TYPE)
958 tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
960 if (resolved != error_mark_node)
964 /* If either type is the internal version of sizetype, use the
966 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
968 t1 = TYPE_DOMAIN (t1);
970 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
972 t2 = TYPE_DOMAIN (t2);
974 if (TYPE_PTRMEMFUNC_P (t1))
975 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
976 if (TYPE_PTRMEMFUNC_P (t2))
977 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
979 /* Different classes of types can't be compatible. */
980 if (TREE_CODE (t1) != TREE_CODE (t2))
983 /* Qualifiers must match. For array types, we will check when we
984 recur on the array element types. */
985 if (TREE_CODE (t1) != ARRAY_TYPE
986 && TYPE_QUALS (t1) != TYPE_QUALS (t2))
988 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
991 /* Allow for two different type nodes which have essentially the same
992 definition. Note that we already checked for equality of the type
993 qualifiers (just above). */
995 if (TREE_CODE (t1) != ARRAY_TYPE
996 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
999 if (!(*targetm.comp_type_attributes) (t1, t2))
1002 switch (TREE_CODE (t1))
1004 case TEMPLATE_TEMPLATE_PARM:
1005 case BOUND_TEMPLATE_TEMPLATE_PARM:
1006 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1007 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
1009 if (!comp_template_parms
1010 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1011 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1013 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1015 /* Don't check inheritance. */
1016 strict = COMPARE_STRICT;
1021 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1022 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1023 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1024 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1027 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1029 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1035 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1036 strict & ~COMPARE_REDECLARATION))
1041 case REFERENCE_TYPE:
1042 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1046 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1048 return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
1051 /* Target types must match incl. qualifiers. */
1052 return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION));
1054 case TEMPLATE_TYPE_PARM:
1055 return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
1056 && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2));
1059 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1060 TYPENAME_TYPE_FULLNAME (t2)))
1062 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1064 case UNBOUND_CLASS_TEMPLATE:
1065 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1067 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1070 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1078 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1081 at_least_as_qualified_p (tree type1, tree type2)
1083 int q1 = cp_type_quals (type1);
1084 int q2 = cp_type_quals (type2);
1086 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1087 return (q1 & q2) == q2;
1090 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1093 more_qualified_p (tree type1, tree type2)
1095 int q1 = cp_type_quals (type1);
1096 int q2 = cp_type_quals (type2);
1098 return q1 != q2 && (q1 & q2) == q2;
1101 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1102 more cv-qualified that TYPE1, and 0 otherwise. */
1105 comp_cv_qualification (tree type1, tree type2)
1107 int q1 = cp_type_quals (type1);
1108 int q2 = cp_type_quals (type2);
1113 if ((q1 & q2) == q2)
1115 else if ((q1 & q2) == q1)
1121 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1122 subset of the cv-qualification signature of TYPE2, and the types
1123 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1126 comp_cv_qual_signature (tree type1, tree type2)
1128 if (comp_ptr_ttypes_real (type2, type1, -1))
1130 else if (comp_ptr_ttypes_real (type1, type2, -1))
1136 /* If two types share a common base type, return that basetype.
1137 If there is not a unique most-derived base type, this function
1138 returns ERROR_MARK_NODE. */
1141 common_base_type (tree tt1, tree tt2)
1143 tree best = NULL_TREE;
1146 /* If one is a baseclass of another, that's good enough. */
1147 if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1149 if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1152 /* Otherwise, try to find a unique baseclass of TT1
1153 that is shared by TT2, and follow that down. */
1154 for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
1156 tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
1157 tree trial = common_base_type (basetype, tt2);
1160 if (trial == error_mark_node)
1162 if (best == NULL_TREE)
1164 else if (best != trial)
1165 return error_mark_node;
1170 for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
1172 tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
1173 tree trial = common_base_type (tt1, basetype);
1176 if (trial == error_mark_node)
1178 if (best == NULL_TREE)
1180 else if (best != trial)
1181 return error_mark_node;
1187 /* Subroutines of `comptypes'. */
1189 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1190 equivalent in the sense that functions with those parameter types
1191 can have equivalent types. The two lists must be equivalent,
1192 element by element. */
1195 compparms (tree parms1, tree parms2)
1199 /* An unspecified parmlist matches any specified parmlist
1200 whose argument types don't need default promotions. */
1202 for (t1 = parms1, t2 = parms2;
1204 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1206 /* If one parmlist is shorter than the other,
1207 they fail to match. */
1210 if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1217 /* Process a sizeof or alignof expression where the operand is a
1221 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1223 enum tree_code type_code;
1225 const char *op_name;
1227 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
1228 if (type == error_mark_node)
1229 return error_mark_node;
1231 if (dependent_type_p (type))
1233 value = build_min (op, size_type_node, type);
1234 TREE_READONLY (value) = 1;
1238 op_name = operator_name_info[(int) op].name;
1240 type = non_reference (type);
1241 type_code = TREE_CODE (type);
1243 if (type_code == METHOD_TYPE)
1245 if (complain && (pedantic || warn_pointer_arith))
1246 pedwarn ("invalid application of `%s' to a member function", op_name);
1247 value = size_one_node;
1250 value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
1255 /* Process a sizeof or alignof expression where the operand is an
1259 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
1261 const char *op_name = operator_name_info[(int) op].name;
1263 if (e == error_mark_node)
1264 return error_mark_node;
1266 if (processing_template_decl)
1268 e = build_min (op, size_type_node, e);
1269 TREE_SIDE_EFFECTS (e) = 0;
1270 TREE_READONLY (e) = 1;
1275 if (TREE_CODE (e) == COMPONENT_REF
1276 && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1277 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1279 error ("invalid application of `%s' to a bit-field", op_name);
1282 else if (is_overloaded_fn (e))
1284 pedwarn ("ISO C++ forbids applying `%s' to an expression of function type", op_name);
1287 else if (type_unknown_p (e))
1289 cxx_incomplete_type_error (e, TREE_TYPE (e));
1295 return cxx_sizeof_or_alignof_type (e, op, true);
1299 /* EXPR is being used in a context that is not a function call.
1304 The expression can be used only as the left-hand operand of a
1305 member function call.
1307 [expr.mptr.operator]
1309 If the result of .* or ->* is a function, then that result can be
1310 used only as the operand for the function call operator ().
1312 by issuing an error message if appropriate. Returns true iff EXPR
1313 violates these rules. */
1316 invalid_nonstatic_memfn_p (tree expr)
1318 if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
1320 error ("invalid use of non-static member function");
1326 /* Perform the conversions in [expr] that apply when an lvalue appears
1327 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1328 function-to-pointer conversions.
1330 In addition manifest constants are replaced by their values. */
1333 decay_conversion (tree exp)
1336 enum tree_code code;
1338 type = TREE_TYPE (exp);
1339 code = TREE_CODE (type);
1341 if (code == REFERENCE_TYPE)
1343 exp = convert_from_reference (exp);
1344 type = TREE_TYPE (exp);
1345 code = TREE_CODE (type);
1348 if (type == error_mark_node)
1349 return error_mark_node;
1351 if (type_unknown_p (exp))
1353 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1354 return error_mark_node;
1357 /* Constants can be used directly unless they're not loadable. */
1358 if (TREE_CODE (exp) == CONST_DECL)
1359 exp = DECL_INITIAL (exp);
1360 /* Replace a nonvolatile const static variable with its value. We
1361 don't do this for arrays, though; we want the address of the
1362 first element of the array, not the address of the first element
1363 of its initializing constant. */
1364 else if (code != ARRAY_TYPE)
1366 exp = decl_constant_value (exp);
1367 type = TREE_TYPE (exp);
1370 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1371 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1373 if (code == VOID_TYPE)
1375 error ("void value not ignored as it ought to be");
1376 return error_mark_node;
1378 if (invalid_nonstatic_memfn_p (exp))
1379 return error_mark_node;
1380 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1381 return build_unary_op (ADDR_EXPR, exp, 0);
1382 if (code == ARRAY_TYPE)
1387 if (TREE_CODE (exp) == INDIRECT_REF)
1388 return build_nop (build_pointer_type (TREE_TYPE (type)),
1389 TREE_OPERAND (exp, 0));
1391 if (TREE_CODE (exp) == COMPOUND_EXPR)
1393 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1394 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1395 TREE_OPERAND (exp, 0), op1);
1399 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1401 error ("invalid use of non-lvalue array");
1402 return error_mark_node;
1405 ptrtype = build_pointer_type (TREE_TYPE (type));
1407 if (TREE_CODE (exp) == VAR_DECL)
1409 if (!cxx_mark_addressable (exp))
1410 return error_mark_node;
1411 adr = build_nop (ptrtype, build_address (exp));
1412 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1415 /* This way is better for a COMPONENT_REF since it can
1416 simplify the offset for a component. */
1417 adr = build_unary_op (ADDR_EXPR, exp, 1);
1418 return cp_convert (ptrtype, adr);
1421 /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1422 rvalues always have cv-unqualified types. */
1423 if (! CLASS_TYPE_P (type))
1424 exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1430 default_conversion (tree exp)
1432 exp = decay_conversion (exp);
1434 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1435 exp = perform_integral_promotions (exp);
1440 /* EXPR is an expression with an integral or enumeration type.
1441 Perform the integral promotions in [conv.prom], and return the
1445 perform_integral_promotions (tree expr)
1450 type = TREE_TYPE (expr);
1451 my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type), 20030703);
1452 promoted_type = type_promotes_to (type);
1453 if (type != promoted_type)
1454 expr = cp_convert (promoted_type, expr);
1458 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1462 inline_conversion (tree exp)
1464 if (TREE_CODE (exp) == FUNCTION_DECL)
1465 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1470 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1471 decay_conversion to one. */
1474 string_conv_p (tree totype, tree exp, int warn)
1478 if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1481 t = TREE_TYPE (totype);
1482 if (!same_type_p (t, char_type_node)
1483 && !same_type_p (t, wchar_type_node))
1486 if (TREE_CODE (exp) == STRING_CST)
1488 /* Make sure that we don't try to convert between char and wchar_t. */
1489 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1494 /* Is this a string constant which has decayed to 'const char *'? */
1495 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1496 if (!same_type_p (TREE_TYPE (exp), t))
1499 if (TREE_CODE (exp) != ADDR_EXPR
1500 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1504 /* This warning is not very useful, as it complains about printf. */
1505 if (warn && warn_write_strings)
1506 warning ("deprecated conversion from string constant to `%T'", totype);
1511 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1512 can, for example, use as an lvalue. This code used to be in
1513 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1514 expressions, where we're dealing with aggregates. But now it's again only
1515 called from unary_complex_lvalue. The case (in particular) that led to
1516 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1520 rationalize_conditional_expr (enum tree_code code, tree t)
1522 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1523 the first operand is always the one to be used if both operands
1524 are equal, so we know what conditional expression this used to be. */
1525 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1528 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1529 ? LE_EXPR : GE_EXPR),
1530 TREE_OPERAND (t, 0),
1531 TREE_OPERAND (t, 1),
1532 /*overloaded_p=*/NULL),
1533 build_unary_op (code, TREE_OPERAND (t, 0), 0),
1534 build_unary_op (code, TREE_OPERAND (t, 1), 0));
1538 build_conditional_expr (TREE_OPERAND (t, 0),
1539 build_unary_op (code, TREE_OPERAND (t, 1), 0),
1540 build_unary_op (code, TREE_OPERAND (t, 2), 0));
1543 /* Given the TYPE of an anonymous union field inside T, return the
1544 FIELD_DECL for the field. If not found return NULL_TREE. Because
1545 anonymous unions can nest, we must also search all anonymous unions
1546 that are directly reachable. */
1549 lookup_anon_field (tree t, tree type)
1553 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1555 if (TREE_STATIC (field))
1557 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1560 /* If we find it directly, return the field. */
1561 if (DECL_NAME (field) == NULL_TREE
1562 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1567 /* Otherwise, it could be nested, search harder. */
1568 if (DECL_NAME (field) == NULL_TREE
1569 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1571 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1579 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1580 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1581 non-NULL, it indicates the path to the base used to name MEMBER.
1582 If PRESERVE_REFERENCE is true, the expression returned will have
1583 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1584 returned will have the type referred to by the reference.
1586 This function does not perform access control; that is either done
1587 earlier by the parser when the name of MEMBER is resolved to MEMBER
1588 itself, or later when overload resolution selects one of the
1589 functions indicated by MEMBER. */
1592 build_class_member_access_expr (tree object, tree member,
1593 tree access_path, bool preserve_reference)
1597 tree result = NULL_TREE;
1599 if (object == error_mark_node || member == error_mark_node)
1600 return error_mark_node;
1602 if (TREE_CODE (member) == PSEUDO_DTOR_EXPR)
1605 my_friendly_assert (DECL_P (member) || BASELINK_P (member),
1610 The type of the first expression shall be "class object" (of a
1612 object_type = TREE_TYPE (object);
1613 if (!currently_open_class (object_type)
1614 && !complete_type_or_else (object_type, object))
1615 return error_mark_node;
1616 if (!CLASS_TYPE_P (object_type))
1618 error ("request for member `%D' in `%E', which is of non-class type `%T'",
1619 member, object, object_type);
1620 return error_mark_node;
1623 /* The standard does not seem to actually say that MEMBER must be a
1624 member of OBJECT_TYPE. However, that is clearly what is
1626 if (DECL_P (member))
1628 member_scope = DECL_CLASS_CONTEXT (member);
1630 if (TREE_DEPRECATED (member))
1631 warn_deprecated_use (member);
1634 member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1635 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1636 presently be the anonymous union. Go outwards until we find a
1637 type related to OBJECT_TYPE. */
1638 while (ANON_AGGR_TYPE_P (member_scope)
1639 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1641 member_scope = TYPE_CONTEXT (member_scope);
1642 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1644 if (TREE_CODE (member) == FIELD_DECL)
1645 error ("invalid use of nonstatic data member '%E'", member);
1647 error ("`%D' is not a member of `%T'", member, object_type);
1648 return error_mark_node;
1651 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1652 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1653 in the frontend; only _DECLs and _REFs are lvalues in the backend. */
1655 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1657 object = build_indirect_ref (temp, NULL);
1660 /* In [expr.ref], there is an explicit list of the valid choices for
1661 MEMBER. We check for each of those cases here. */
1662 if (TREE_CODE (member) == VAR_DECL)
1664 /* A static data member. */
1666 /* If OBJECT has side-effects, they are supposed to occur. */
1667 if (TREE_SIDE_EFFECTS (object))
1668 result = build (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1670 else if (TREE_CODE (member) == FIELD_DECL)
1672 /* A non-static data member. */
1677 null_object_p = (TREE_CODE (object) == INDIRECT_REF
1678 && integer_zerop (TREE_OPERAND (object, 0)));
1680 /* Convert OBJECT to the type of MEMBER. */
1681 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1682 TYPE_MAIN_VARIANT (member_scope)))
1687 binfo = lookup_base (access_path ? access_path : object_type,
1688 member_scope, ba_ignore, &kind);
1689 if (binfo == error_mark_node)
1690 return error_mark_node;
1692 /* It is invalid to try to get to a virtual base of a
1693 NULL object. The most common cause is invalid use of
1695 if (null_object_p && kind == bk_via_virtual)
1697 error ("invalid access to non-static data member `%D' of NULL object",
1699 error ("(perhaps the `offsetof' macro was used incorrectly)");
1700 return error_mark_node;
1703 /* Convert to the base. */
1704 object = build_base_path (PLUS_EXPR, object, binfo,
1706 /* If we found the base successfully then we should be able
1707 to convert to it successfully. */
1708 my_friendly_assert (object != error_mark_node,
1712 /* Complain about other invalid uses of offsetof, even though they will
1713 give the right answer. Note that we complain whether or not they
1714 actually used the offsetof macro, since there's no way to know at this
1715 point. So we just give a warning, instead of a pedwarn. */
1716 if (null_object_p && warn_invalid_offsetof
1717 && CLASSTYPE_NON_POD_P (object_type))
1719 warning ("invalid access to non-static data member `%D' of NULL object",
1721 warning ("(perhaps the `offsetof' macro was used incorrectly)");
1724 /* If MEMBER is from an anonymous aggregate, we have converted
1725 OBJECT so that it refers to the class containing the
1726 anonymous union. Generate a reference to the anonymous union
1727 itself, and recur to find MEMBER. */
1728 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1729 /* When this code is called from build_field_call, the
1730 object already has the type of the anonymous union.
1731 That is because the COMPONENT_REF was already
1732 constructed, and was then disassembled before calling
1733 build_field_call. After the function-call code is
1734 cleaned up, this waste can be eliminated. */
1735 && (!same_type_ignoring_top_level_qualifiers_p
1736 (TREE_TYPE (object), DECL_CONTEXT (member))))
1738 tree anonymous_union;
1740 anonymous_union = lookup_anon_field (TREE_TYPE (object),
1741 DECL_CONTEXT (member));
1742 object = build_class_member_access_expr (object,
1744 /*access_path=*/NULL_TREE,
1745 preserve_reference);
1748 /* Compute the type of the field, as described in [expr.ref]. */
1749 type_quals = TYPE_UNQUALIFIED;
1750 member_type = TREE_TYPE (member);
1751 if (TREE_CODE (member_type) != REFERENCE_TYPE)
1753 type_quals = (cp_type_quals (member_type)
1754 | cp_type_quals (object_type));
1756 /* A field is const (volatile) if the enclosing object, or the
1757 field itself, is const (volatile). But, a mutable field is
1758 not const, even within a const object. */
1759 if (DECL_MUTABLE_P (member))
1760 type_quals &= ~TYPE_QUAL_CONST;
1761 member_type = cp_build_qualified_type (member_type, type_quals);
1764 result = fold (build (COMPONENT_REF, member_type, object, member));
1766 /* Mark the expression const or volatile, as appropriate. Even
1767 though we've dealt with the type above, we still have to mark the
1768 expression itself. */
1769 if (type_quals & TYPE_QUAL_CONST)
1770 TREE_READONLY (result) = 1;
1771 else if (type_quals & TYPE_QUAL_VOLATILE)
1772 TREE_THIS_VOLATILE (result) = 1;
1774 else if (BASELINK_P (member))
1776 /* The member is a (possibly overloaded) member function. */
1780 /* If the MEMBER is exactly one static member function, then we
1781 know the type of the expression. Otherwise, we must wait
1782 until overload resolution has been performed. */
1783 functions = BASELINK_FUNCTIONS (member);
1784 if (TREE_CODE (functions) == FUNCTION_DECL
1785 && DECL_STATIC_FUNCTION_P (functions))
1786 type = TREE_TYPE (functions);
1788 type = unknown_type_node;
1789 /* Note that we do not convert OBJECT to the BASELINK_BINFO
1790 base. That will happen when the function is called. */
1791 result = build (COMPONENT_REF, type, object, member);
1793 else if (TREE_CODE (member) == CONST_DECL)
1795 /* The member is an enumerator. */
1797 /* If OBJECT has side-effects, they are supposed to occur. */
1798 if (TREE_SIDE_EFFECTS (object))
1799 result = build (COMPOUND_EXPR, TREE_TYPE (result),
1804 error ("invalid use of `%D'", member);
1805 return error_mark_node;
1808 if (!preserve_reference)
1811 If E2 is declared to have type "reference to T", then ... the
1812 type of E1.E2 is T. */
1813 result = convert_from_reference (result);
1818 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
1819 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
1822 lookup_destructor (tree object, tree scope, tree dtor_name)
1824 tree object_type = TREE_TYPE (object);
1825 tree dtor_type = TREE_OPERAND (dtor_name, 0);
1828 if (scope && !check_dtor_name (scope, dtor_name))
1830 error ("qualified type `%T' does not match destructor name `~%T'",
1832 return error_mark_node;
1834 if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
1836 error ("the type being destroyed is `%T', but the destructor refers to `%T'",
1837 TYPE_MAIN_VARIANT (object_type), dtor_type);
1838 return error_mark_node;
1840 if (!TYPE_HAS_DESTRUCTOR (dtor_type))
1841 return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope,
1843 expr = lookup_member (dtor_type, complete_dtor_identifier,
1844 /*protect=*/1, /*want_type=*/false);
1845 expr = (adjust_result_of_qualified_name_lookup
1846 (expr, dtor_type, object_type));
1850 /* This function is called by the parser to process a class member
1851 access expression of the form OBJECT.NAME. NAME is a node used by
1852 the parser to represent a name; it is not yet a DECL. It may,
1853 however, be a BASELINK where the BASELINK_FUNCTIONS is a
1854 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
1855 there is no reason to do the lookup twice, so the parser keeps the
1859 finish_class_member_access_expr (tree object, tree name)
1864 tree access_path = NULL_TREE;
1865 tree orig_object = object;
1866 tree orig_name = name;
1868 if (object == error_mark_node || name == error_mark_node)
1869 return error_mark_node;
1871 object_type = TREE_TYPE (object);
1873 if (processing_template_decl)
1875 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
1876 dependent_type_p (object_type)
1877 /* If NAME is just an IDENTIFIER_NODE, then the expression
1879 || TREE_CODE (object) == IDENTIFIER_NODE
1880 /* If NAME is "f<args>", where either 'f' or 'args' is
1881 dependent, then the expression is dependent. */
1882 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
1883 && dependent_template_id_p (TREE_OPERAND (name, 0),
1884 TREE_OPERAND (name, 1)))
1885 /* If NAME is "T::X" where "T" is dependent, then the
1886 expression is dependent. */
1887 || (TREE_CODE (name) == SCOPE_REF
1888 && TYPE_P (TREE_OPERAND (name, 0))
1889 && dependent_type_p (TREE_OPERAND (name, 0))))
1890 return build_min_nt (COMPONENT_REF, object, name);
1891 object = build_non_dependent_expr (object);
1894 if (TREE_CODE (object_type) == REFERENCE_TYPE)
1896 object = convert_from_reference (object);
1897 object_type = TREE_TYPE (object);
1902 The type of the first expression shall be "class object" (of a
1904 if (!currently_open_class (object_type)
1905 && !complete_type_or_else (object_type, object))
1906 return error_mark_node;
1907 if (!CLASS_TYPE_P (object_type))
1909 error ("request for member `%D' in `%E', which is of non-class type `%T'",
1910 name, object, object_type);
1911 return error_mark_node;
1914 if (BASELINK_P (name))
1916 /* A member function that has already been looked up. */
1917 my_friendly_assert ((TREE_CODE (BASELINK_FUNCTIONS (name))
1918 == TEMPLATE_ID_EXPR),
1924 bool is_template_id = false;
1925 tree template_args = NULL_TREE;
1928 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1930 is_template_id = true;
1931 template_args = TREE_OPERAND (name, 1);
1932 name = TREE_OPERAND (name, 0);
1934 if (TREE_CODE (name) == OVERLOAD)
1935 name = DECL_NAME (get_first_fn (name));
1936 else if (DECL_P (name))
1937 name = DECL_NAME (name);
1940 if (TREE_CODE (name) == SCOPE_REF)
1942 /* A qualified name. The qualifying class or namespace `S' has
1943 already been looked up; it is either a TYPE or a
1944 NAMESPACE_DECL. The member name is either an IDENTIFIER_NODE
1945 or a BIT_NOT_EXPR. */
1946 scope = TREE_OPERAND (name, 0);
1947 name = TREE_OPERAND (name, 1);
1948 my_friendly_assert ((CLASS_TYPE_P (scope)
1949 || TREE_CODE (scope) == NAMESPACE_DECL),
1951 my_friendly_assert ((TREE_CODE (name) == IDENTIFIER_NODE
1952 || TREE_CODE (name) == BIT_NOT_EXPR),
1955 /* If SCOPE is a namespace, then the qualified name does not
1956 name a member of OBJECT_TYPE. */
1957 if (TREE_CODE (scope) == NAMESPACE_DECL)
1959 error ("`%D::%D' is not a member of `%T'",
1960 scope, name, object_type);
1961 return error_mark_node;
1964 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
1965 access_path = lookup_base (object_type, scope, ba_check, NULL);
1966 if (access_path == error_mark_node)
1967 return error_mark_node;
1970 error ("`%T' is not a base of `%T'", scope, object_type);
1971 return error_mark_node;
1977 access_path = object_type;
1980 if (TREE_CODE (name) == BIT_NOT_EXPR)
1981 member = lookup_destructor (object, scope, name);
1984 /* Look up the member. */
1985 member = lookup_member (access_path, name, /*protect=*/1,
1986 /*want_type=*/false);
1987 if (member == NULL_TREE)
1989 error ("'%D' has no member named '%E'", object_type, name);
1990 return error_mark_node;
1992 if (member == error_mark_node)
1993 return error_mark_node;
1998 tree template = member;
2000 if (BASELINK_P (template))
2001 template = lookup_template_function (template, template_args);
2004 error ("`%D' is not a member template function", name);
2005 return error_mark_node;
2010 if (TREE_DEPRECATED (member))
2011 warn_deprecated_use (member);
2013 expr = build_class_member_access_expr (object, member, access_path,
2014 /*preserve_reference=*/false);
2015 if (processing_template_decl && expr != error_mark_node)
2016 return build_min_non_dep (COMPONENT_REF, expr,
2017 orig_object, orig_name);
2021 /* Return an expression for the MEMBER_NAME field in the internal
2022 representation of PTRMEM, a pointer-to-member function. (Each
2023 pointer-to-member function type gets its own RECORD_TYPE so it is
2024 more convenient to access the fields by name than by FIELD_DECL.)
2025 This routine converts the NAME to a FIELD_DECL and then creates the
2026 node for the complete expression. */
2029 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2035 /* This code is a stripped down version of
2036 build_class_member_access_expr. It does not work to use that
2037 routine directly because it expects the object to be of class
2039 ptrmem_type = TREE_TYPE (ptrmem);
2040 my_friendly_assert (TYPE_PTRMEMFUNC_P (ptrmem_type), 20020804);
2041 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2042 /*want_type=*/false);
2043 member_type = cp_build_qualified_type (TREE_TYPE (member),
2044 cp_type_quals (ptrmem_type));
2045 return fold (build (COMPONENT_REF, member_type, ptrmem, member));
2048 /* Given an expression PTR for a pointer, return an expression
2049 for the value pointed to.
2050 ERRORSTRING is the name of the operator to appear in error messages.
2052 This function may need to overload OPERATOR_FNNAME.
2053 Must also handle REFERENCE_TYPEs for C++. */
2056 build_x_indirect_ref (tree expr, const char *errorstring)
2058 tree orig_expr = expr;
2061 if (processing_template_decl)
2063 if (type_dependent_expression_p (expr))
2064 return build_min_nt (INDIRECT_REF, expr);
2065 expr = build_non_dependent_expr (expr);
2068 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2069 NULL_TREE, /*overloaded_p=*/NULL);
2071 rval = build_indirect_ref (expr, errorstring);
2073 if (processing_template_decl && rval != error_mark_node)
2074 return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2080 build_indirect_ref (tree ptr, const char *errorstring)
2084 if (ptr == error_mark_node)
2085 return error_mark_node;
2087 if (ptr == current_class_ptr)
2088 return current_class_ref;
2090 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2091 ? ptr : decay_conversion (ptr));
2092 type = TREE_TYPE (pointer);
2094 if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
2098 If the type of the expression is "pointer to T," the type
2099 of the result is "T."
2101 We must use the canonical variant because certain parts of
2102 the back end, like fold, do pointer comparisons between
2104 tree t = canonical_type_variant (TREE_TYPE (type));
2106 if (VOID_TYPE_P (t))
2108 /* A pointer to incomplete type (other than cv void) can be
2109 dereferenced [expr.unary.op]/1 */
2110 error ("`%T' is not a pointer-to-object type", type);
2111 return error_mark_node;
2113 else if (TREE_CODE (pointer) == ADDR_EXPR
2114 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2115 /* The POINTER was something like `&x'. We simplify `*&x' to
2117 return TREE_OPERAND (pointer, 0);
2120 tree ref = build1 (INDIRECT_REF, t, pointer);
2122 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2123 so that we get the proper error message if the result is used
2124 to assign to. Also, &* is supposed to be a no-op. */
2125 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2126 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2127 TREE_SIDE_EFFECTS (ref)
2128 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2132 /* `pointer' won't be an error_mark_node if we were given a
2133 pointer to member, so it's cool to check for this here. */
2134 else if (TYPE_PTR_TO_MEMBER_P (type))
2135 error ("invalid use of `%s' on pointer to member", errorstring);
2136 else if (pointer != error_mark_node)
2139 error ("invalid type argument of `%s'", errorstring);
2141 error ("invalid type argument");
2143 return error_mark_node;
2146 /* This handles expressions of the form "a[i]", which denotes
2149 This is logically equivalent in C to *(a+i), but we may do it differently.
2150 If A is a variable or a member, we generate a primitive ARRAY_REF.
2151 This avoids forcing the array out of registers, and can work on
2152 arrays that are not lvalues (for example, members of structures returned
2155 If INDEX is of some user-defined type, it must be converted to
2156 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2157 will inherit the type of the array, which will be some pointer type. */
2160 build_array_ref (tree array, tree idx)
2164 error ("subscript missing in array reference");
2165 return error_mark_node;
2168 if (TREE_TYPE (array) == error_mark_node
2169 || TREE_TYPE (idx) == error_mark_node)
2170 return error_mark_node;
2172 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2174 switch (TREE_CODE (array))
2178 tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2179 return build (COMPOUND_EXPR, TREE_TYPE (value),
2180 TREE_OPERAND (array, 0), value);
2184 return build_conditional_expr
2185 (TREE_OPERAND (array, 0),
2186 build_array_ref (TREE_OPERAND (array, 1), idx),
2187 build_array_ref (TREE_OPERAND (array, 2), idx));
2193 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
2194 && TREE_CODE (array) != INDIRECT_REF)
2198 /* Subscripting with type char is likely to lose
2199 on a machine where chars are signed.
2200 So warn on any machine, but optionally.
2201 Don't warn for unsigned char since that type is safe.
2202 Don't warn for signed char because anyone who uses that
2203 must have done so deliberately. */
2204 if (warn_char_subscripts
2205 && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2206 warning ("array subscript has type `char'");
2208 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2210 error ("array subscript is not an integer");
2211 return error_mark_node;
2214 /* Apply integral promotions *after* noticing character types.
2215 (It is unclear why we do these promotions -- the standard
2216 does not say that we should. In fact, the natual thing would
2217 seem to be to convert IDX to ptrdiff_t; we're performing
2218 pointer arithmetic.) */
2219 idx = perform_integral_promotions (idx);
2221 /* An array that is indexed by a non-constant
2222 cannot be stored in a register; we must be able to do
2223 address arithmetic on its address.
2224 Likewise an array of elements of variable size. */
2225 if (TREE_CODE (idx) != INTEGER_CST
2226 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2227 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2230 if (!cxx_mark_addressable (array))
2231 return error_mark_node;
2234 /* An array that is indexed by a constant value which is not within
2235 the array bounds cannot be stored in a register either; because we
2236 would get a crash in store_bit_field/extract_bit_field when trying
2237 to access a non-existent part of the register. */
2238 if (TREE_CODE (idx) == INTEGER_CST
2239 && TYPE_VALUES (TREE_TYPE (array))
2240 && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
2242 if (!cxx_mark_addressable (array))
2243 return error_mark_node;
2246 if (pedantic && !lvalue_p (array))
2247 pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2249 /* Note in C++ it is valid to subscript a `register' array, since
2250 it is valid to take the address of something with that
2251 storage specification. */
2255 while (TREE_CODE (foo) == COMPONENT_REF)
2256 foo = TREE_OPERAND (foo, 0);
2257 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2258 warning ("subscripting array declared `register'");
2261 type = TREE_TYPE (TREE_TYPE (array));
2262 rval = build (ARRAY_REF, type, array, idx);
2263 /* Array ref is const/volatile if the array elements are
2264 or if the array is.. */
2265 TREE_READONLY (rval)
2266 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2267 TREE_SIDE_EFFECTS (rval)
2268 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2269 TREE_THIS_VOLATILE (rval)
2270 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2271 return require_complete_type (fold (rval));
2275 tree ar = default_conversion (array);
2276 tree ind = default_conversion (idx);
2278 /* Put the integer in IND to simplify error checking. */
2279 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2286 if (ar == error_mark_node)
2289 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2291 error ("subscripted value is neither array nor pointer");
2292 return error_mark_node;
2294 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2296 error ("array subscript is not an integer");
2297 return error_mark_node;
2300 return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2305 /* Resolve a pointer to member function. INSTANCE is the object
2306 instance to use, if the member points to a virtual member.
2308 This used to avoid checking for virtual functions if basetype
2309 has no virtual functions, according to an earlier ANSI draft.
2310 With the final ISO C++ rules, such an optimization is
2311 incorrect: A pointer to a derived member can be static_cast
2312 to pointer-to-base-member, as long as the dynamic object
2313 later has the right member. */
2316 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2318 if (TREE_CODE (function) == OFFSET_REF)
2319 function = TREE_OPERAND (function, 1);
2321 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2323 tree idx, delta, e1, e2, e3, vtbl, basetype;
2324 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2326 tree instance_ptr = *instance_ptrptr;
2327 tree instance_save_expr = 0;
2328 if (instance_ptr == error_mark_node)
2330 if (TREE_CODE (function) == PTRMEM_CST)
2332 /* Extracting the function address from a pmf is only
2333 allowed with -Wno-pmf-conversions. It only works for
2335 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2336 e1 = convert (fntype, e1);
2341 error ("object missing in use of `%E'", function);
2342 return error_mark_node;
2346 if (TREE_SIDE_EFFECTS (instance_ptr))
2347 instance_ptr = instance_save_expr = save_expr (instance_ptr);
2349 if (TREE_SIDE_EFFECTS (function))
2350 function = save_expr (function);
2352 /* Start by extracting all the information from the PMF itself. */
2353 e3 = PFN_FROM_PTRMEMFUNC (function);
2354 delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2355 idx = build1 (NOP_EXPR, vtable_index_type, e3);
2356 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2358 case ptrmemfunc_vbit_in_pfn:
2359 e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2360 idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2363 case ptrmemfunc_vbit_in_delta:
2364 e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2365 delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2372 /* Convert down to the right base before using the instance. First
2374 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2375 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2376 basetype, ba_check, NULL);
2377 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2378 if (instance_ptr == error_mark_node)
2379 return error_mark_node;
2380 /* ...and then the delta in the PMF. */
2381 instance_ptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
2382 instance_ptr, delta);
2384 /* Hand back the adjusted 'this' argument to our caller. */
2385 *instance_ptrptr = instance_ptr;
2387 /* Next extract the vtable pointer from the object. */
2388 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2390 vtbl = build_indirect_ref (vtbl, NULL);
2392 /* Finally, extract the function pointer from the vtable. */
2393 e2 = fold (build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
2394 e2 = build_indirect_ref (e2, NULL);
2395 TREE_CONSTANT (e2) = 1;
2397 /* When using function descriptors, the address of the
2398 vtable entry is treated as a function pointer. */
2399 if (TARGET_VTABLE_USES_DESCRIPTORS)
2400 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2401 build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2403 TREE_TYPE (e2) = TREE_TYPE (e3);
2404 e1 = build_conditional_expr (e1, e2, e3);
2406 /* Make sure this doesn't get evaluated first inside one of the
2407 branches of the COND_EXPR. */
2408 if (instance_save_expr)
2409 e1 = build (COMPOUND_EXPR, TREE_TYPE (e1),
2410 instance_save_expr, e1);
2418 build_function_call (tree function, tree params)
2420 tree fntype, fndecl;
2421 tree coerced_params;
2423 tree name = NULL_TREE, assembler_name = NULL_TREE;
2425 tree original = function;
2427 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2428 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2429 if (TREE_CODE (function) == NOP_EXPR
2430 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2431 function = TREE_OPERAND (function, 0);
2433 if (TREE_CODE (function) == FUNCTION_DECL)
2435 name = DECL_NAME (function);
2436 assembler_name = DECL_ASSEMBLER_NAME (function);
2438 mark_used (function);
2441 /* Convert anything with function type to a pointer-to-function. */
2442 if (pedantic && DECL_MAIN_P (function))
2443 pedwarn ("ISO C++ forbids calling `::main' from within program");
2445 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2446 (because calling an inline function does not mean the function
2447 needs to be separately compiled). */
2449 if (DECL_INLINE (function))
2450 function = inline_conversion (function);
2452 function = build_addr_func (function);
2458 function = build_addr_func (function);
2461 if (function == error_mark_node)
2462 return error_mark_node;
2464 fntype = TREE_TYPE (function);
2466 if (TYPE_PTRMEMFUNC_P (fntype))
2468 error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2470 return error_mark_node;
2473 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2474 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2476 if (!((TREE_CODE (fntype) == POINTER_TYPE
2477 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2479 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2481 error ("`%E' cannot be used as a function", original);
2482 return error_mark_node;
2485 /* fntype now gets the type of function pointed to. */
2486 fntype = TREE_TYPE (fntype);
2488 /* Convert the parameters to the types declared in the
2489 function prototype, or apply default promotions. */
2491 coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2492 params, fndecl, LOOKUP_NORMAL);
2493 if (coerced_params == error_mark_node)
2494 return error_mark_node;
2496 /* Check for errors in format strings. */
2499 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
2501 /* Recognize certain built-in functions so we can make tree-codes
2502 other than CALL_EXPR. We do this when it enables fold-const.c
2503 to do something useful. */
2505 if (TREE_CODE (function) == ADDR_EXPR
2506 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2507 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2509 result = expand_tree_builtin (TREE_OPERAND (function, 0),
2510 params, coerced_params);
2515 return build_cxx_call (function, params, coerced_params);
2518 /* Convert the actual parameter expressions in the list VALUES
2519 to the types in the list TYPELIST.
2520 If parmdecls is exhausted, or when an element has NULL as its type,
2521 perform the default conversions.
2523 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2525 This is also where warnings about wrong number of args are generated.
2527 Return a list of expressions for the parameters as converted.
2529 Both VALUES and the returned value are chains of TREE_LIST nodes
2530 with the elements of the list in the TREE_VALUE slots of those nodes.
2532 In C++, unspecified trailing parameters can be filled in with their
2533 default arguments, if such were specified. Do so here. */
2536 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2538 tree typetail, valtail;
2539 tree result = NULL_TREE;
2540 const char *called_thing = 0;
2543 /* Argument passing is always copy-initialization. */
2544 flags |= LOOKUP_ONLYCONVERTING;
2548 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2550 if (DECL_NAME (fndecl) == NULL_TREE
2551 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2552 called_thing = "constructor";
2554 called_thing = "member function";
2557 called_thing = "function";
2560 for (valtail = values, typetail = typelist;
2562 valtail = TREE_CHAIN (valtail), i++)
2564 tree type = typetail ? TREE_VALUE (typetail) : 0;
2565 tree val = TREE_VALUE (valtail);
2567 if (val == error_mark_node)
2568 return error_mark_node;
2570 if (type == void_type_node)
2574 cp_error_at ("too many arguments to %s `%+#D'", called_thing,
2576 error ("at this point in file");
2579 error ("too many arguments to function");
2580 /* In case anybody wants to know if this argument
2583 TREE_TYPE (tree_last (result)) = error_mark_node;
2587 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2588 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2589 if (TREE_CODE (val) == NOP_EXPR
2590 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2591 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2592 val = TREE_OPERAND (val, 0);
2594 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2596 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2597 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2598 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2599 val = decay_conversion (val);
2602 if (val == error_mark_node)
2603 return error_mark_node;
2607 /* Formal parm type is specified by a function prototype. */
2610 if (!COMPLETE_TYPE_P (complete_type (type)))
2613 error ("parameter %P of `%D' has incomplete type `%T'",
2616 error ("parameter %P has incomplete type `%T'", i, type);
2617 parmval = error_mark_node;
2621 parmval = convert_for_initialization
2622 (NULL_TREE, type, val, flags,
2623 "argument passing", fndecl, i);
2624 parmval = convert_for_arg_passing (type, parmval);
2627 if (parmval == error_mark_node)
2628 return error_mark_node;
2630 result = tree_cons (NULL_TREE, parmval, result);
2634 if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
2635 val = convert_from_reference (val);
2637 if (fndecl && DECL_BUILT_IN (fndecl)
2638 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2639 /* Don't do ellipsis conversion for __built_in_constant_p
2640 as this will result in spurious warnings for non-POD
2642 val = require_complete_type (val);
2644 val = convert_arg_to_ellipsis (val);
2646 result = tree_cons (NULL_TREE, val, result);
2650 typetail = TREE_CHAIN (typetail);
2653 if (typetail != 0 && typetail != void_list_node)
2655 /* See if there are default arguments that can be used. */
2656 if (TREE_PURPOSE (typetail)
2657 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2659 for (; typetail != void_list_node; ++i)
2662 = convert_default_arg (TREE_VALUE (typetail),
2663 TREE_PURPOSE (typetail),
2666 if (parmval == error_mark_node)
2667 return error_mark_node;
2669 result = tree_cons (0, parmval, result);
2670 typetail = TREE_CHAIN (typetail);
2671 /* ends with `...'. */
2672 if (typetail == NULL_TREE)
2680 cp_error_at ("too few arguments to %s `%+#D'",
2681 called_thing, fndecl);
2682 error ("at this point in file");
2685 error ("too few arguments to function");
2686 return error_mark_list;
2690 return nreverse (result);
2693 /* Build a binary-operation expression, after performing default
2694 conversions on the operands. CODE is the kind of expression to build. */
2697 build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
2707 if (processing_template_decl)
2709 if (type_dependent_expression_p (arg1)
2710 || type_dependent_expression_p (arg2))
2711 return build_min_nt (code, arg1, arg2);
2712 arg1 = build_non_dependent_expr (arg1);
2713 arg2 = build_non_dependent_expr (arg2);
2716 if (code == DOTSTAR_EXPR)
2717 expr = build_m_component_ref (arg1, arg2);
2719 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
2722 if (processing_template_decl && expr != error_mark_node)
2723 return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
2728 /* Build a binary-operation expression without default conversions.
2729 CODE is the kind of expression to build.
2730 This function differs from `build' in several ways:
2731 the data type of the result is computed and recorded in it,
2732 warnings are generated if arg data types are invalid,
2733 special handling for addition and subtraction of pointers is known,
2734 and some optimization is done (operations on narrow ints
2735 are done in the narrower type when that gives the same result).
2736 Constant folding is also done before the result is returned.
2738 Note that the operands will never have enumeral types
2739 because either they have just had the default conversions performed
2740 or they have both just been converted to some other type in which
2741 the arithmetic is to be done.
2743 C++: must do special pointer arithmetic when implementing
2744 multiple inheritance, and deal with pointer to member functions. */
2747 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2748 int convert_p ATTRIBUTE_UNUSED)
2751 enum tree_code code0, code1;
2754 /* Expression code to give to the expression when it is built.
2755 Normally this is CODE, which is what the caller asked for,
2756 but in some special cases we change it. */
2757 enum tree_code resultcode = code;
2759 /* Data type in which the computation is to be performed.
2760 In the simplest cases this is the common type of the arguments. */
2761 tree result_type = NULL;
2763 /* Nonzero means operands have already been type-converted
2764 in whatever way is necessary.
2765 Zero means they need to be converted to RESULT_TYPE. */
2768 /* Nonzero means create the expression with this type, rather than
2770 tree build_type = 0;
2772 /* Nonzero means after finally constructing the expression
2773 convert it to this type. */
2774 tree final_type = 0;
2776 /* Nonzero if this is an operation like MIN or MAX which can
2777 safely be computed in short if both args are promoted shorts.
2778 Also implies COMMON.
2779 -1 indicates a bitwise operation; this makes a difference
2780 in the exact conditions for when it is safe to do the operation
2781 in a narrower mode. */
2784 /* Nonzero if this is a comparison operation;
2785 if both args are promoted shorts, compare the original shorts.
2786 Also implies COMMON. */
2787 int short_compare = 0;
2789 /* Nonzero if this is a right-shift operation, which can be computed on the
2790 original short and then promoted if the operand is a promoted short. */
2791 int short_shift = 0;
2793 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2796 /* Apply default conversions. */
2800 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2801 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2802 || code == TRUTH_XOR_EXPR)
2804 if (!really_overloaded_fn (op0))
2805 op0 = decay_conversion (op0);
2806 if (!really_overloaded_fn (op1))
2807 op1 = decay_conversion (op1);
2811 if (!really_overloaded_fn (op0))
2812 op0 = default_conversion (op0);
2813 if (!really_overloaded_fn (op1))
2814 op1 = default_conversion (op1);
2817 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2818 STRIP_TYPE_NOPS (op0);
2819 STRIP_TYPE_NOPS (op1);
2821 /* DTRT if one side is an overloaded function, but complain about it. */
2822 if (type_unknown_p (op0))
2824 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2825 if (t != error_mark_node)
2827 pedwarn ("assuming cast to type `%T' from overloaded function",
2832 if (type_unknown_p (op1))
2834 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2835 if (t != error_mark_node)
2837 pedwarn ("assuming cast to type `%T' from overloaded function",
2843 type0 = TREE_TYPE (op0);
2844 type1 = TREE_TYPE (op1);
2846 /* The expression codes of the data types of the arguments tell us
2847 whether the arguments are integers, floating, pointers, etc. */
2848 code0 = TREE_CODE (type0);
2849 code1 = TREE_CODE (type1);
2851 /* If an error was already reported for one of the arguments,
2852 avoid reporting another error. */
2854 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2855 return error_mark_node;
2860 /* Handle the pointer + int case. */
2861 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2862 return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
2863 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2864 return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
2870 /* Subtraction of two similar pointers.
2871 We must subtract them as integers, then divide by object size. */
2872 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2873 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
2875 return pointer_diff (op0, op1, common_type (type0, type1));
2876 /* Handle pointer minus int. Just like pointer plus int. */
2877 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2878 return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
2887 case TRUNC_DIV_EXPR:
2889 case FLOOR_DIV_EXPR:
2890 case ROUND_DIV_EXPR:
2891 case EXACT_DIV_EXPR:
2892 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2893 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2894 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2895 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
2897 if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
2898 warning ("division by zero in `%E / 0'", op0);
2899 else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
2900 warning ("division by zero in `%E / 0.'", op0);
2902 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2903 resultcode = RDIV_EXPR;
2905 /* When dividing two signed integers, we have to promote to int.
2906 unless we divide by a constant != -1. Note that default
2907 conversion will have been performed on the operands at this
2908 point, so we have to dig out the original type to find out if
2910 shorten = ((TREE_CODE (op0) == NOP_EXPR
2911 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2912 || (TREE_CODE (op1) == INTEGER_CST
2913 && ! integer_all_onesp (op1)));
2922 if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2923 || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
2927 case TRUNC_MOD_EXPR:
2928 case FLOOR_MOD_EXPR:
2929 if (code1 == INTEGER_TYPE && integer_zerop (op1))
2930 warning ("division by zero in `%E %% 0'", op0);
2931 else if (code1 == REAL_TYPE && real_zerop (op1))
2932 warning ("division by zero in `%E %% 0.'", op0);
2934 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2936 /* Although it would be tempting to shorten always here, that loses
2937 on some targets, since the modulo instruction is undefined if the
2938 quotient can't be represented in the computation mode. We shorten
2939 only if unsigned or if dividing by something we know != -1. */
2940 shorten = ((TREE_CODE (op0) == NOP_EXPR
2941 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2942 || (TREE_CODE (op1) == INTEGER_CST
2943 && ! integer_all_onesp (op1)));
2948 case TRUTH_ANDIF_EXPR:
2949 case TRUTH_ORIF_EXPR:
2950 case TRUTH_AND_EXPR:
2952 result_type = boolean_type_node;
2955 /* Shift operations: result has same type as first operand;
2956 always convert second operand to int.
2957 Also set SHORT_SHIFT if shifting rightward. */
2960 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2962 result_type = type0;
2963 if (TREE_CODE (op1) == INTEGER_CST)
2965 if (tree_int_cst_lt (op1, integer_zero_node))
2966 warning ("right shift count is negative");
2969 if (! integer_zerop (op1))
2971 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2972 warning ("right shift count >= width of type");
2975 /* Convert the shift-count to an integer, regardless of
2976 size of value being shifted. */
2977 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2978 op1 = cp_convert (integer_type_node, op1);
2979 /* Avoid converting op1 to result_type later. */
2985 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2987 result_type = type0;
2988 if (TREE_CODE (op1) == INTEGER_CST)
2990 if (tree_int_cst_lt (op1, integer_zero_node))
2991 warning ("left shift count is negative");
2992 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2993 warning ("left shift count >= width of type");
2995 /* Convert the shift-count to an integer, regardless of
2996 size of value being shifted. */
2997 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2998 op1 = cp_convert (integer_type_node, op1);
2999 /* Avoid converting op1 to result_type later. */
3006 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3008 result_type = type0;
3009 if (TREE_CODE (op1) == INTEGER_CST)
3011 if (tree_int_cst_lt (op1, integer_zero_node))
3012 warning ("%s rotate count is negative",
3013 (code == LROTATE_EXPR) ? "left" : "right");
3014 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3015 warning ("%s rotate count >= width of type",
3016 (code == LROTATE_EXPR) ? "left" : "right");
3018 /* Convert the shift-count to an integer, regardless of
3019 size of value being shifted. */
3020 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3021 op1 = cp_convert (integer_type_node, op1);
3027 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3028 warning ("comparing floating point with == or != is unsafe");
3030 build_type = boolean_type_node;
3031 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3032 || code0 == COMPLEX_TYPE)
3033 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3034 || code1 == COMPLEX_TYPE))
3036 else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3037 || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3038 result_type = composite_pointer_type (type0, type1, op0, op1,
3040 else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3041 && null_ptr_cst_p (op1))
3042 result_type = type0;
3043 else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3044 && null_ptr_cst_p (op0))
3045 result_type = type1;
3046 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3048 result_type = type0;
3049 error ("ISO C++ forbids comparison between pointer and integer");
3051 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3053 result_type = type1;
3054 error ("ISO C++ forbids comparison between pointer and integer");
3056 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3058 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3059 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3060 result_type = TREE_TYPE (op0);
3062 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3063 return cp_build_binary_op (code, op1, op0);
3064 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3065 && same_type_p (type0, type1))
3067 /* E will be the final comparison. */
3069 /* E1 and E2 are for scratch. */
3077 if (TREE_SIDE_EFFECTS (op0))
3078 op0 = save_expr (op0);
3079 if (TREE_SIDE_EFFECTS (op1))
3080 op1 = save_expr (op1);
3085 && (!op0.pfn || op0.delta == op1.delta))
3087 The reason for the `!op0.pfn' bit is that a NULL
3088 pointer-to-member is any member with a zero PFN; the
3089 DELTA field is unspecified. */
3090 pfn0 = pfn_from_ptrmemfunc (op0);
3091 pfn1 = pfn_from_ptrmemfunc (op1);
3092 delta0 = build_ptrmemfunc_access_expr (op0,
3094 delta1 = build_ptrmemfunc_access_expr (op1,
3096 e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3097 e2 = cp_build_binary_op (EQ_EXPR,
3099 cp_convert (TREE_TYPE (pfn0),
3100 integer_zero_node));
3101 e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3102 e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3103 e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3104 if (code == EQ_EXPR)
3106 return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3108 else if ((TYPE_PTRMEMFUNC_P (type0)
3109 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
3110 || (TYPE_PTRMEMFUNC_P (type1)
3111 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
3117 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3118 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3120 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3121 result_type = composite_pointer_type (type0, type1, op0, op1,
3129 build_type = boolean_type_node;
3130 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3131 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3133 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3134 result_type = composite_pointer_type (type0, type1, op0, op1,
3136 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3137 && integer_zerop (op1))
3138 result_type = type0;
3139 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3140 && integer_zerop (op0))
3141 result_type = type1;
3142 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3144 result_type = type0;
3145 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3147 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3149 result_type = type1;
3150 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3154 case UNORDERED_EXPR:
3161 build_type = integer_type_node;
3162 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3164 error ("unordered comparison on non-floating point argument");
3165 return error_mark_node;
3174 if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3176 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
3177 || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
3179 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3181 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3182 && !tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)))
3183 error ("can't convert between vector values of different size");
3185 if (shorten || common || short_compare)
3186 result_type = common_type (type0, type1);
3188 /* For certain operations (which identify themselves by shorten != 0)
3189 if both args were extended from the same smaller type,
3190 do the arithmetic in that type and then extend.
3192 shorten !=0 and !=1 indicates a bitwise operation.
3193 For them, this optimization is safe only if
3194 both args are zero-extended or both are sign-extended.
3195 Otherwise, we might change the result.
3196 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3197 but calculated in (unsigned short) it would be (unsigned short)-1. */
3199 if (shorten && none_complex)
3201 int unsigned0, unsigned1;
3202 tree arg0 = get_narrower (op0, &unsigned0);
3203 tree arg1 = get_narrower (op1, &unsigned1);
3204 /* UNS is 1 if the operation to be done is an unsigned one. */
3205 int uns = TREE_UNSIGNED (result_type);
3208 final_type = result_type;
3210 /* Handle the case that OP0 does not *contain* a conversion
3211 but it *requires* conversion to FINAL_TYPE. */
3213 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3214 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3215 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3216 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3218 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3220 /* For bitwise operations, signedness of nominal type
3221 does not matter. Consider only how operands were extended. */
3225 /* Note that in all three cases below we refrain from optimizing
3226 an unsigned operation on sign-extended args.
3227 That would not be valid. */
3229 /* Both args variable: if both extended in same way
3230 from same width, do it in that width.
3231 Do it unsigned if args were zero-extended. */
3232 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3233 < TYPE_PRECISION (result_type))
3234 && (TYPE_PRECISION (TREE_TYPE (arg1))
3235 == TYPE_PRECISION (TREE_TYPE (arg0)))
3236 && unsigned0 == unsigned1
3237 && (unsigned0 || !uns))
3238 result_type = c_common_signed_or_unsigned_type
3239 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3240 else if (TREE_CODE (arg0) == INTEGER_CST
3241 && (unsigned1 || !uns)
3242 && (TYPE_PRECISION (TREE_TYPE (arg1))
3243 < TYPE_PRECISION (result_type))
3244 && (type = c_common_signed_or_unsigned_type
3245 (unsigned1, TREE_TYPE (arg1)),
3246 int_fits_type_p (arg0, type)))
3248 else if (TREE_CODE (arg1) == INTEGER_CST
3249 && (unsigned0 || !uns)
3250 && (TYPE_PRECISION (TREE_TYPE (arg0))
3251 < TYPE_PRECISION (result_type))
3252 && (type = c_common_signed_or_unsigned_type
3253 (unsigned0, TREE_TYPE (arg0)),
3254 int_fits_type_p (arg1, type)))
3258 /* Shifts can be shortened if shifting right. */
3263 tree arg0 = get_narrower (op0, &unsigned_arg);
3265 final_type = result_type;
3267 if (arg0 == op0 && final_type == TREE_TYPE (op0))
3268 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3270 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3271 /* We can shorten only if the shift count is less than the
3272 number of bits in the smaller type size. */
3273 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3274 /* If arg is sign-extended and then unsigned-shifted,
3275 we can simulate this with a signed shift in arg's type
3276 only if the extended result is at least twice as wide
3277 as the arg. Otherwise, the shift could use up all the
3278 ones made by sign-extension and bring in zeros.
3279 We can't optimize that case at all, but in most machines
3280 it never happens because available widths are 2**N. */
3281 && (!TREE_UNSIGNED (final_type)
3283 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3284 <= TYPE_PRECISION (result_type))))
3286 /* Do an unsigned shift if the operand was zero-extended. */
3288 = c_common_signed_or_unsigned_type (unsigned_arg,
3290 /* Convert value-to-be-shifted to that type. */
3291 if (TREE_TYPE (op0) != result_type)
3292 op0 = cp_convert (result_type, op0);
3297 /* Comparison operations are shortened too but differently.
3298 They identify themselves by setting short_compare = 1. */
3302 /* Don't write &op0, etc., because that would prevent op0
3303 from being kept in a register.
3304 Instead, make copies of the our local variables and
3305 pass the copies by reference, then copy them back afterward. */
3306 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3307 enum tree_code xresultcode = resultcode;
3309 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3311 return cp_convert (boolean_type_node, val);
3312 op0 = xop0, op1 = xop1;
3314 resultcode = xresultcode;
3317 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3318 && warn_sign_compare
3319 /* Do not warn until the template is instantiated; we cannot
3320 bound the ranges of the arguments until that point. */
3321 && !processing_template_decl)
3323 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
3324 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
3326 int unsignedp0, unsignedp1;
3327 tree primop0 = get_narrower (op0, &unsignedp0);
3328 tree primop1 = get_narrower (op1, &unsignedp1);
3330 /* Check for comparison of different enum types. */
3331 if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3332 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3333 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3334 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3336 warning ("comparison between types `%#T' and `%#T'",
3337 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3340 /* Give warnings for comparisons between signed and unsigned
3341 quantities that may fail. */
3342 /* Do the checking based on the original operand trees, so that
3343 casts will be considered, but default promotions won't be. */
3345 /* Do not warn if the comparison is being done in a signed type,
3346 since the signed type will only be chosen if it can represent
3347 all the values of the unsigned type. */
3348 if (! TREE_UNSIGNED (result_type))
3350 /* Do not warn if both operands are unsigned. */
3351 else if (op0_signed == op1_signed)
3353 /* Do not warn if the signed quantity is an unsuffixed
3354 integer literal (or some static constant expression
3355 involving such literals or a conditional expression
3356 involving such literals) and it is non-negative. */
3357 else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3358 || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3360 /* Do not warn if the comparison is an equality operation,
3361 the unsigned quantity is an integral constant and it does
3362 not use the most significant bit of result_type. */
3363 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3364 && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3365 && int_fits_type_p (orig_op1, c_common_signed_type
3367 || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3368 && int_fits_type_p (orig_op0, c_common_signed_type
3372 warning ("comparison between signed and unsigned integer expressions");
3374 /* Warn if two unsigned values are being compared in a size
3375 larger than their original size, and one (and only one) is the
3376 result of a `~' operator. This comparison will always fail.
3378 Also warn if one operand is a constant, and the constant does not
3379 have all bits set that are set in the ~ operand when it is
3382 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3383 ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3385 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3386 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3387 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3388 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3390 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3393 HOST_WIDE_INT constant, mask;
3397 if (host_integerp (primop0, 0))
3400 unsignedp = unsignedp1;
3401 constant = tree_low_cst (primop0, 0);
3406 unsignedp = unsignedp0;
3407 constant = tree_low_cst (primop1, 0);
3410 bits = TYPE_PRECISION (TREE_TYPE (primop));
3411 if (bits < TYPE_PRECISION (result_type)
3412 && bits < HOST_BITS_PER_LONG && unsignedp)
3414 mask = (~ (HOST_WIDE_INT) 0) << bits;
3415 if ((mask & constant) != mask)
3416 warning ("comparison of promoted ~unsigned with constant");
3419 else if (unsignedp0 && unsignedp1
3420 && (TYPE_PRECISION (TREE_TYPE (primop0))
3421 < TYPE_PRECISION (result_type))
3422 && (TYPE_PRECISION (TREE_TYPE (primop1))
3423 < TYPE_PRECISION (result_type)))
3424 warning ("comparison of promoted ~unsigned with unsigned");
3429 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3430 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3431 Then the expression will be built.
3432 It will be given type FINAL_TYPE if that is nonzero;
3433 otherwise, it will be given type RESULT_TYPE. */
3437 error ("invalid operands of types `%T' and `%T' to binary `%O'",
3438 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3439 return error_mark_node;
3442 /* Issue warnings about peculiar, but valid, uses of NULL. */
3443 if (/* It's reasonable to use pointer values as operands of &&
3444 and ||, so NULL is no exception. */
3445 !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3446 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3447 (orig_op0 == null_node
3448 && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3449 /* Or vice versa. */
3450 || (orig_op1 == null_node
3451 && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3452 /* Or, both are NULL and the operation was not a comparison. */
3453 || (orig_op0 == null_node && orig_op1 == null_node
3454 && code != EQ_EXPR && code != NE_EXPR)))
3455 /* Some sort of arithmetic operation involving NULL was
3456 performed. Note that pointer-difference and pointer-addition
3457 have already been handled above, and so we don't end up here in
3459 warning ("NULL used in arithmetic");
3463 if (TREE_TYPE (op0) != result_type)
3464 op0 = cp_convert (result_type, op0);
3465 if (TREE_TYPE (op1) != result_type)
3466 op1 = cp_convert (result_type, op1);
3468 if (op0 == error_mark_node || op1 == error_mark_node)
3469 return error_mark_node;
3472 if (build_type == NULL_TREE)
3473 build_type = result_type;
3476 tree result = build (resultcode, build_type, op0, op1);
3479 folded = fold_if_not_in_template (result);
3480 if (folded == result)
3481 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3482 if (final_type != 0)
3483 return cp_convert (final_type, folded);
3488 /* Return a tree for the sum or difference (RESULTCODE says which)
3489 of pointer PTROP and integer INTOP. */
3492 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3494 tree res_type = TREE_TYPE (ptrop);
3496 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3497 in certain circumstance (when it's valid to do so). So we need
3498 to make sure it's complete. We don't need to check here, if we
3499 can actually complete it at all, as those checks will be done in
3500 pointer_int_sum() anyway. */
3501 complete_type (TREE_TYPE (res_type));
3503 return pointer_int_sum (resultcode, ptrop, fold (intop));
3506 /* Return a tree for the difference of pointers OP0 and OP1.
3507 The resulting tree has type int. */
3510 pointer_diff (tree op0, tree op1, tree ptrtype)
3512 tree result, folded;
3513 tree restype = ptrdiff_type_node;
3514 tree target_type = TREE_TYPE (ptrtype);
3516 if (!complete_type_or_else (target_type, NULL_TREE))
3517 return error_mark_node;
3519 if (pedantic || warn_pointer_arith)
3521 if (TREE_CODE (target_type) == VOID_TYPE)
3522 pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
3523 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3524 pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3525 if (TREE_CODE (target_type) == METHOD_TYPE)
3526 pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3529 /* First do the subtraction as integers;
3530 then drop through to build the divide operator. */
3532 op0 = cp_build_binary_op (MINUS_EXPR,
3533 cp_convert (restype, op0),
3534 cp_convert (restype, op1));
3536 /* This generates an error if op1 is a pointer to an incomplete type. */
3537 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3538 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3540 op1 = (TYPE_PTROB_P (ptrtype)
3541 ? size_in_bytes (target_type)
3542 : integer_one_node);
3544 /* Do the division. */
3546 result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3548 folded = fold (result);
3549 if (folded == result)
3550 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3554 /* Construct and perhaps optimize a tree representation
3555 for a unary operation. CODE, a tree_code, specifies the operation
3556 and XARG is the operand. */
3559 build_x_unary_op (enum tree_code code, tree xarg)
3561 tree orig_expr = xarg;
3565 if (processing_template_decl)
3567 if (type_dependent_expression_p (xarg))
3568 return build_min_nt (code, xarg, NULL_TREE);
3570 xarg = build_non_dependent_expr (xarg);
3575 /* [expr.unary.op] says:
3577 The address of an object of incomplete type can be taken.
3579 (And is just the ordinary address operator, not an overloaded
3580 "operator &".) However, if the type is a template
3581 specialization, we must complete the type at this point so that
3582 an overloaded "operator &" will be available if required. */
3583 if (code == ADDR_EXPR
3584 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3585 && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3586 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3587 || (TREE_CODE (xarg) == OFFSET_REF)))
3588 /* Don't look for a function. */;
3590 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3591 /*overloaded_p=*/NULL);
3592 if (!exp && code == ADDR_EXPR)
3594 /* A pointer to member-function can be formed only by saying
3596 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3597 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3599 if (TREE_CODE (xarg) != OFFSET_REF)
3601 error ("invalid use of '%E' to form a pointer-to-member-function. Use a qualified-id.",
3603 return error_mark_node;
3607 error ("parenthesis around '%E' cannot be used to form a pointer-to-member-function",
3609 PTRMEM_OK_P (xarg) = 1;
3613 if (TREE_CODE (xarg) == OFFSET_REF)
3615 ptrmem = PTRMEM_OK_P (xarg);
3617 if (!ptrmem && !flag_ms_extensions
3618 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3620 /* A single non-static member, make sure we don't allow a
3621 pointer-to-member. */
3622 xarg = build (OFFSET_REF, TREE_TYPE (xarg),
3623 TREE_OPERAND (xarg, 0),
3624 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3625 PTRMEM_OK_P (xarg) = ptrmem;
3628 else if (TREE_CODE (xarg) == TARGET_EXPR)
3629 warning ("taking address of temporary");
3630 exp = build_unary_op (ADDR_EXPR, xarg, 0);
3633 if (processing_template_decl && exp != error_mark_node)
3634 exp = build_min_non_dep (code, exp, orig_expr,
3635 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3636 if (TREE_CODE (exp) == ADDR_EXPR)
3637 PTRMEM_OK_P (exp) = ptrmem;
3641 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3642 constants, where a null value is represented by an INTEGER_CST of
3646 cp_truthvalue_conversion (tree expr)
3648 tree type = TREE_TYPE (expr);
3649 if (TYPE_PTRMEM_P (type))
3650 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3652 return c_common_truthvalue_conversion (expr);
3655 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
3658 condition_conversion (tree expr)
3661 if (processing_template_decl)
3663 t = perform_implicit_conversion (boolean_type_node, expr);
3664 t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
3668 /* Return an ADDR_EXPR giving the address of T. This function
3669 attempts no optimizations or simplifications; it is a low-level
3673 build_address (tree t)
3677 if (error_operand_p (t) || !cxx_mark_addressable (t))
3678 return error_mark_node;
3680 addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3682 TREE_CONSTANT (addr) = 1;
3687 /* Return a NOP_EXPR converting EXPR to TYPE. */
3690 build_nop (tree type, tree expr)
3694 if (type == error_mark_node || error_operand_p (expr))
3697 nop = build1 (NOP_EXPR, type, expr);
3698 if (TREE_CONSTANT (expr))
3699 TREE_CONSTANT (nop) = 1;
3704 /* C++: Must handle pointers to members.
3706 Perhaps type instantiation should be extended to handle conversion
3707 from aggregates to types we don't yet know we want? (Or are those
3708 cases typically errors which should be reported?)
3710 NOCONVERT nonzero suppresses the default promotions
3711 (such as from short to int). */
3714 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3716 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3719 const char *errstring = NULL;
3722 if (arg == error_mark_node)
3723 return error_mark_node;
3728 /* This is used for unary plus, because a CONVERT_EXPR
3729 is enough to prevent anybody from looking inside for
3730 associativity, but won't generate any code. */
3731 if (!(arg = build_expr_type_conversion
3732 (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, true)))
3733 errstring = "wrong type argument to unary plus";
3737 arg = default_conversion (arg);
3738 arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3739 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3744 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3745 errstring = "wrong type argument to unary minus";
3746 else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3747 arg = perform_integral_promotions (arg);
3751 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3755 arg = default_conversion (arg);
3757 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3759 errstring = "wrong type argument to bit-complement";
3760 else if (!noconvert)
3761 arg = perform_integral_promotions (arg);
3765 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3766 errstring = "wrong type argument to abs";
3767 else if (!noconvert)
3768 arg = default_conversion (arg);
3772 /* Conjugating a real value is a no-op, but allow it anyway. */
3773 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3774 errstring = "wrong type argument to conjugation";
3775 else if (!noconvert)
3776 arg = default_conversion (arg);
3779 case TRUTH_NOT_EXPR:
3780 arg = perform_implicit_conversion (boolean_type_node, arg);
3781 val = invert_truthvalue (arg);
3782 if (arg != error_mark_node)
3784 errstring = "in argument to unary !";
3791 if (TREE_CODE (arg) == COMPLEX_CST)
3792 return TREE_REALPART (arg);
3793 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3794 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3799 if (TREE_CODE (arg) == COMPLEX_CST)
3800 return TREE_IMAGPART (arg);
3801 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3802 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3804 return cp_convert (TREE_TYPE (arg), integer_zero_node);
3806 case PREINCREMENT_EXPR:
3807 case POSTINCREMENT_EXPR:
3808 case PREDECREMENT_EXPR:
3809 case POSTDECREMENT_EXPR:
3810 /* Handle complex lvalues (when permitted)
3811 by reduction to simpler cases. */
3813 val = unary_complex_lvalue (code, arg);
3817 /* Increment or decrement the real part of the value,
3818 and don't change the imaginary part. */
3819 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3823 arg = stabilize_reference (arg);
3824 real = build_unary_op (REALPART_EXPR, arg, 1);
3825 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3826 return build (COMPLEX_EXPR, TREE_TYPE (arg),
3827 build_unary_op (code, real, 1), imag);
3830 /* Report invalid types. */
3832 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3835 if (code == PREINCREMENT_EXPR)
3836 errstring ="no pre-increment operator for type";
3837 else if (code == POSTINCREMENT_EXPR)
3838 errstring ="no post-increment operator for type";
3839 else if (code == PREDECREMENT_EXPR)
3840 errstring ="no pre-decrement operator for type";
3842 errstring ="no post-decrement operator for type";
3846 /* Report something read-only. */
3848 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3849 || TREE_READONLY (arg))
3850 readonly_error (arg, ((code == PREINCREMENT_EXPR
3851 || code == POSTINCREMENT_EXPR)
3852 ? "increment" : "decrement"),
3857 tree result_type = TREE_TYPE (arg);
3859 arg = get_unwidened (arg, 0);
3860 argtype = TREE_TYPE (arg);
3862 /* ARM $5.2.5 last annotation says this should be forbidden. */
3863 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3864 pedwarn ("ISO C++ forbids %sing an enum",
3865 (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3866 ? "increment" : "decrement");
3868 /* Compute the increment. */
3870 if (TREE_CODE (argtype) == POINTER_TYPE)
3872 tree type = complete_type (TREE_TYPE (argtype));
3874 if (!COMPLETE_OR_VOID_TYPE_P (type))
3875 error ("cannot %s a pointer to incomplete type `%T'",
3876 ((code == PREINCREMENT_EXPR
3877 || code == POSTINCREMENT_EXPR)
3878 ? "increment" : "decrement"), TREE_TYPE (argtype));
3879 else if ((pedantic || warn_pointer_arith)
3880 && !TYPE_PTROB_P (argtype))
3881 pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
3882 ((code == PREINCREMENT_EXPR
3883 || code == POSTINCREMENT_EXPR)
3884 ? "increment" : "decrement"), argtype);
3885 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3888 inc = integer_one_node;
3890 inc = cp_convert (argtype, inc);
3892 /* Handle incrementing a cast-expression. */
3894 switch (TREE_CODE (arg))
3899 case FIX_TRUNC_EXPR:
3900 case FIX_FLOOR_EXPR:
3901 case FIX_ROUND_EXPR:
3904 tree incremented, modify, value, compound;
3905 if (! lvalue_p (arg) && pedantic)
3906 pedwarn ("cast to non-reference type used as lvalue");
3907 arg = stabilize_reference (arg);
3908 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3911 value = save_expr (arg);
3912 incremented = build (((code == PREINCREMENT_EXPR
3913 || code == POSTINCREMENT_EXPR)
3914 ? PLUS_EXPR : MINUS_EXPR),
3915 argtype, value, inc);
3917 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3918 compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3920 /* Eliminate warning about unused result of + or -. */
3921 TREE_NO_UNUSED_WARNING (compound) = 1;
3929 /* Complain about anything else that is not a true lvalue. */
3930 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3931 || code == POSTINCREMENT_EXPR)
3932 ? "increment" : "decrement")))
3933 return error_mark_node;
3935 /* Forbid using -- on `bool'. */
3936 if (TREE_TYPE (arg) == boolean_type_node)
3938 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
3940 error ("invalid use of `--' on bool variable `%D'", arg);
3941 return error_mark_node;
3943 val = boolean_increment (code, arg);
3946 val = build (code, TREE_TYPE (arg), arg, inc);
3948 TREE_SIDE_EFFECTS (val) = 1;
3949 return cp_convert (result_type, val);
3953 /* Note that this operation never does default_conversion
3954 regardless of NOCONVERT. */
3956 argtype = lvalue_type (arg);
3958 if (TREE_CODE (arg) == OFFSET_REF)
3961 if (TREE_CODE (argtype) == REFERENCE_TYPE)
3965 build_pointer_type (TREE_TYPE (argtype)), arg);
3966 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3969 else if (pedantic && DECL_MAIN_P (arg))
3971 pedwarn ("ISO C++ forbids taking address of function `::main'");
3973 /* Let &* cancel out to simplify resulting code. */
3974 if (TREE_CODE (arg) == INDIRECT_REF)
3976 /* We don't need to have `current_class_ptr' wrapped in a
3977 NON_LVALUE_EXPR node. */
3978 if (arg == current_class_ref)
3979 return current_class_ptr;
3981 arg = TREE_OPERAND (arg, 0);
3982 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3986 build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
3987 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3989 else if (lvalue_p (arg))
3990 /* Don't let this be an lvalue. */
3991 return non_lvalue (arg);
3995 /* For &x[y], return x+y. But, in a template, ARG may be an
3996 ARRAY_REF representing a non-dependent expression. In that
3997 case, there may be an overloaded "operator []" that will be
3998 chosen at instantiation time; we must not try to optimize
4000 if (TREE_CODE (arg) == ARRAY_REF && !processing_template_decl)
4002 if (!cxx_mark_addressable (TREE_OPERAND (arg, 0)))
4003 return error_mark_node;
4004 return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4005 TREE_OPERAND (arg, 1));
4008 /* Uninstantiated types are all functions. Taking the
4009 address of a function is a no-op, so just return the
4012 if (TREE_CODE (arg) == IDENTIFIER_NODE
4013 && IDENTIFIER_OPNAME_P (arg))
4016 /* We don't know the type yet, so just work around the problem.
4017 We know that this will resolve to an lvalue. */
4018 return build1 (ADDR_EXPR, unknown_type_node, arg);
4021 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4022 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4024 /* They're trying to take the address of a unique non-static
4025 member function. This is ill-formed (except in MS-land),
4026 but let's try to DTRT.
4027 Note: We only handle unique functions here because we don't
4028 want to complain if there's a static overload; non-unique
4029 cases will be handled by instantiate_type. But we need to
4030 handle this case here to allow casts on the resulting PMF.
4031 We could defer this in non-MS mode, but it's easier to give
4032 a useful error here. */
4034 /* Inside constant member functions, the `this' pointer
4035 contains an extra const qualifier. TYPE_MAIN_VARIANT
4036 is used here to remove this const from the diagnostics
4037 and the created OFFSET_REF. */
4038 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4039 tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4041 if (! flag_ms_extensions)
4043 if (current_class_type
4044 && TREE_OPERAND (arg, 0) == current_class_ref)
4045 /* An expression like &memfn. */
4046 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4047 " or parenthesized non-static member function to form"
4048 " a pointer to member function. Say `&%T::%D'",
4051 pedwarn ("ISO C++ forbids taking the address of a bound member"
4052 " function to form a pointer to member function."
4056 arg = build_offset_ref (base, name, /*address_p=*/true);
4060 if (type_unknown_p (arg))
4061 return build1 (ADDR_EXPR, unknown_type_node, arg);
4063 /* Handle complex lvalues (when permitted)
4064 by reduction to simpler cases. */
4065 val = unary_complex_lvalue (code, arg);
4069 switch (TREE_CODE (arg))
4074 case FIX_TRUNC_EXPR:
4075 case FIX_FLOOR_EXPR:
4076 case FIX_ROUND_EXPR:
4078 if (! lvalue_p (arg) && pedantic)
4079 pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4083 arg = OVL_CURRENT (arg);
4090 /* Allow the address of a constructor if all the elements
4092 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4093 && TREE_CONSTANT (arg))
4095 /* Anything not already handled and not a true memory reference
4097 else if (TREE_CODE (argtype) != FUNCTION_TYPE
4098 && TREE_CODE (argtype) != METHOD_TYPE
4099 && TREE_CODE (arg) != OFFSET_REF
4100 && !lvalue_or_else (arg, "unary `&'"))
4101 return error_mark_node;
4103 if (argtype != error_mark_node)
4104 argtype = build_pointer_type (argtype);
4109 if (TREE_CODE (arg) != COMPONENT_REF
4110 /* Inside a template, we are processing a non-dependent
4111 expression so we can just form an ADDR_EXPR with the
4113 || processing_template_decl)
4115 addr = build_address (arg);
4116 if (TREE_CODE (arg) == OFFSET_REF)
4117 PTRMEM_OK_P (addr) = PTRMEM_OK_P (arg);
4119 else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4121 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4123 /* We can only get here with a single static member
4125 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
4126 && DECL_STATIC_FUNCTION_P (fn),
4129 addr = build_address (fn);
4130 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4131 /* Do not lose object's side effects. */
4132 addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
4133 TREE_OPERAND (arg, 0), addr);
4135 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4137 error ("attempt to take address of bit-field structure member `%D'",
4138 TREE_OPERAND (arg, 1));
4139 return error_mark_node;
4143 /* Unfortunately we cannot just build an address
4144 expression here, because we would not handle
4145 address-constant-expressions or offsetof correctly. */
4146 tree field = TREE_OPERAND (arg, 1);
4147 tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4148 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
4149 decl_type_context (field),
4152 rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
4153 rval = build_nop (argtype, rval);
4154 addr = fold (build (PLUS_EXPR, argtype, rval,
4155 cp_convert (argtype, byte_position (field))));
4158 if (TREE_CODE (argtype) == POINTER_TYPE
4159 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4161 build_ptrmemfunc_type (argtype);
4162 addr = build_ptrmemfunc (argtype, addr, 0);
4175 argtype = TREE_TYPE (arg);
4176 return fold (build1 (code, argtype, arg));
4179 error ("%s", errstring);
4180 return error_mark_node;
4183 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4184 for certain kinds of expressions which are not really lvalues
4185 but which we can accept as lvalues.
4187 If ARG is not a kind of expression we can handle, return
4191 unary_complex_lvalue (enum tree_code code, tree arg)
4193 /* Handle (a, b) used as an "lvalue". */
4194 if (TREE_CODE (arg) == COMPOUND_EXPR)
4196 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4197 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4198 TREE_OPERAND (arg, 0), real_result);
4201 /* Handle (a ? b : c) used as an "lvalue". */
4202 if (TREE_CODE (arg) == COND_EXPR
4203 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4204 return rationalize_conditional_expr (code, arg);
4206 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4207 if (TREE_CODE (arg) == MODIFY_EXPR
4208 || TREE_CODE (arg) == PREINCREMENT_EXPR
4209 || TREE_CODE (arg) == PREDECREMENT_EXPR)
4211 tree lvalue = TREE_OPERAND (arg, 0);
4212 if (TREE_SIDE_EFFECTS (lvalue))
4214 lvalue = stabilize_reference (lvalue);
4215 arg = build (TREE_CODE (arg), TREE_TYPE (arg),
4216 lvalue, TREE_OPERAND (arg, 1));
4218 return unary_complex_lvalue
4219 (code, build (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4222 if (code != ADDR_EXPR)
4225 /* Handle (a = b) used as an "lvalue" for `&'. */
4226 if (TREE_CODE (arg) == MODIFY_EXPR
4227 || TREE_CODE (arg) == INIT_EXPR)
4229 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4230 arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4231 TREE_NO_UNUSED_WARNING (arg) = 1;
4235 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4236 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4237 || TREE_CODE (arg) == OFFSET_REF)
4241 my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4243 if (TREE_CODE (arg) != OFFSET_REF)
4246 t = TREE_OPERAND (arg, 1);
4248 /* Check all this code for right semantics. */
4249 if (TREE_CODE (t) == FUNCTION_DECL)
4251 if (DECL_DESTRUCTOR_P (t))
4252 error ("taking address of destructor");
4253 return build_unary_op (ADDR_EXPR, t, 0);
4255 if (TREE_CODE (t) == VAR_DECL)
4256 return build_unary_op (ADDR_EXPR, t, 0);
4261 if (TREE_OPERAND (arg, 0)
4262 && ! is_dummy_object (TREE_OPERAND (arg, 0))
4263 && TREE_CODE (t) != FIELD_DECL)
4265 error ("taking address of bound pointer-to-member expression");
4266 return error_mark_node;
4268 if (!PTRMEM_OK_P (arg))
4269 return build_unary_op (code, arg, 0);
4271 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4273 error ("cannot create pointer to reference member `%D'", t);
4274 return error_mark_node;
4277 type = build_ptrmem_type (context_for_name_lookup (t),
4279 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4285 /* We permit compiler to make function calls returning
4286 objects of aggregate type look like lvalues. */
4290 if (TREE_CODE (targ) == SAVE_EXPR)
4291 targ = TREE_OPERAND (targ, 0);
4293 if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4295 if (TREE_CODE (arg) == SAVE_EXPR)
4298 targ = build_cplus_new (TREE_TYPE (arg), arg);
4299 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4302 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4303 return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4304 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4307 /* Don't let anything else be handled specially. */
4311 /* Mark EXP saying that we need to be able to take the
4312 address of it; it should not be allocated in a register.
4313 Value is true if successful.
4315 C++: we do not allow `current_class_ptr' to be addressable. */
4318 cxx_mark_addressable (tree exp)
4323 switch (TREE_CODE (x))
4330 x = TREE_OPERAND (x, 0);
4334 if (x == current_class_ptr)
4336 error ("cannot take the address of `this', which is an rvalue expression");
4337 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */
4343 /* Caller should not be trying to mark initialized
4344 constant fields addressable. */
4345 my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4346 || DECL_IN_AGGR_P (x) == 0
4348 || DECL_EXTERNAL (x), 314);
4353 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4354 && !DECL_ARTIFICIAL (x) && extra_warnings)
4355 warning ("address requested for `%D', which is declared `register'",
4357 TREE_ADDRESSABLE (x) = 1;
4358 put_var_into_stack (x, /*rescan=*/true);
4362 TREE_ADDRESSABLE (x) = 1;
4363 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4367 TREE_ADDRESSABLE (x) = 1;
4371 TREE_ADDRESSABLE (x) = 1;
4372 cxx_mark_addressable (TREE_OPERAND (x, 0));
4380 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4383 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4385 tree orig_ifexp = ifexp;
4386 tree orig_op1 = op1;
4387 tree orig_op2 = op2;
4390 if (processing_template_decl)
4392 /* The standard says that the expression is type-dependent if
4393 IFEXP is type-dependent, even though the eventual type of the
4394 expression doesn't dependent on IFEXP. */
4395 if (type_dependent_expression_p (ifexp)
4396 /* As a GNU extension, the middle operand may be omitted. */
4397 || (op1 && type_dependent_expression_p (op1))
4398 || type_dependent_expression_p (op2))
4399 return build_min_nt (COND_EXPR, ifexp, op1, op2);
4400 ifexp = build_non_dependent_expr (ifexp);
4402 op1 = build_non_dependent_expr (op1);
4403 op2 = build_non_dependent_expr (op2);
4406 expr = build_conditional_expr (ifexp, op1, op2);
4407 if (processing_template_decl && expr != error_mark_node)
4408 return build_min_non_dep (COND_EXPR, expr,
4409 orig_ifexp, orig_op1, orig_op2);
4413 /* Given a list of expressions, return a compound expression
4414 that performs them all and returns the value of the last of them. */
4416 tree build_x_compound_expr_from_list (tree list, const char *msg)
4418 tree expr = TREE_VALUE (list);
4420 if (TREE_CHAIN (list))
4423 pedwarn ("%s expression list treated as compound expression", msg);
4425 for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4426 expr = build_x_compound_expr (expr, TREE_VALUE (list));
4432 /* Handle overloading of the ',' operator when needed. */
4435 build_x_compound_expr (tree op1, tree op2)
4438 tree orig_op1 = op1;
4439 tree orig_op2 = op2;
4441 if (processing_template_decl)
4443 if (type_dependent_expression_p (op1)
4444 || type_dependent_expression_p (op2))
4445 return build_min_nt (COMPOUND_EXPR, op1, op2);
4446 op1 = build_non_dependent_expr (op1);
4447 op2 = build_non_dependent_expr (op2);
4450 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4451 /*overloaded_p=*/NULL);
4453 result = build_compound_expr (op1, op2);
4455 if (processing_template_decl && result != error_mark_node)
4456 return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4461 /* Build a compound expression. */
4464 build_compound_expr (tree lhs, tree rhs)
4466 lhs = decl_constant_value (lhs);
4467 lhs = convert_to_void (lhs, "left-hand operand of comma");
4469 if (lhs == error_mark_node || rhs == error_mark_node)
4470 return error_mark_node;
4472 if (TREE_CODE (rhs) == TARGET_EXPR)
4474 /* If the rhs is a TARGET_EXPR, then build the compound
4475 expression inside the target_expr's initializer. This
4476 helps the compiler to eliminate unnecessary temporaries. */
4477 tree init = TREE_OPERAND (rhs, 1);
4479 init = build (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4480 TREE_OPERAND (rhs, 1) = init;
4485 return build (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4488 /* Issue an error message if casting from SRC_TYPE to DEST_TYPE casts
4489 away constness. DESCRIPTION explains what operation is taking
4493 check_for_casting_away_constness (tree src_type, tree dest_type,
4494 const char *description)
4496 if (casts_away_constness (src_type, dest_type))
4497 error ("%s from type `%T' to type `%T' casts away constness",
4498 description, src_type, dest_type);
4501 /* Return an expression representing static_cast<TYPE>(EXPR). */
4504 build_static_cast (tree type, tree expr)
4509 if (type == error_mark_node || expr == error_mark_node)
4510 return error_mark_node;
4512 if (processing_template_decl)
4514 expr = build_min (STATIC_CAST_EXPR, type, expr);
4515 /* We don't know if it will or will not have side effects. */
4516 TREE_SIDE_EFFECTS (expr) = 1;
4520 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4521 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4522 if (TREE_CODE (type) != REFERENCE_TYPE
4523 && TREE_CODE (expr) == NOP_EXPR
4524 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4525 expr = TREE_OPERAND (expr, 0);
4527 intype = TREE_TYPE (expr);
4529 /* [expr.static.cast]
4531 An lvalue of type "cv1 B", where B is a class type, can be cast
4532 to type "reference to cv2 D", where D is a class derived (clause
4533 _class.derived_) from B, if a valid standard conversion from
4534 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4535 same cv-qualification as, or greater cv-qualification than, cv1,
4536 and B is not a virtual base class of D. */
4537 /* We check this case before checking the validity of "TYPE t =
4538 EXPR;" below because for this case:
4541 struct D : public B { D(const B&); };
4543 void f() { static_cast<const D&>(b); }
4545 we want to avoid constructing a new D. The standard is not
4546 completely clear about this issue, but our interpretation is
4547 consistent with other compilers. */
4548 if (TREE_CODE (type) == REFERENCE_TYPE
4549 && CLASS_TYPE_P (TREE_TYPE (type))
4550 && CLASS_TYPE_P (intype)
4551 && real_lvalue_p (expr)
4552 && DERIVED_FROM_P (intype, TREE_TYPE (type))
4553 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4554 build_pointer_type (TYPE_MAIN_VARIANT
4555 (TREE_TYPE (type))))
4556 && at_least_as_qualified_p (TREE_TYPE (type), intype))
4558 /* There is a standard conversion from "D*" to "B*" even if "B"
4559 is ambiguous or inaccessible. Therefore, we ask lookup_base
4560 to check these conditions. */
4561 tree base = lookup_base (TREE_TYPE (type), intype, ba_check, NULL);
4563 /* Convert from "B*" to "D*". This function will check that "B"
4564 is not a virtual base of "D". */
4565 expr = build_base_path (MINUS_EXPR, build_address (expr),
4566 base, /*nonnull=*/false);
4567 /* Convert the pointer to a reference -- but then remember that
4568 there are no expressions with reference type in C++. */
4569 return convert_from_reference (build_nop (type, expr));
4572 /* [expr.static.cast]
4574 An expression e can be explicitly converted to a type T using a
4575 static_cast of the form static_cast<T>(e) if the declaration T
4576 t(e);" is well-formed, for some invented temporary variable
4578 result = perform_direct_initialization_if_possible (type, expr);
4581 result = convert_from_reference (result);
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)))
4618 /* Really, build_c_cast should defer to this function rather
4619 than the other way around. */
4620 return build_c_cast (type, expr);
4622 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4623 && CLASS_TYPE_P (TREE_TYPE (type))
4624 && CLASS_TYPE_P (TREE_TYPE (intype))
4625 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4626 (TREE_TYPE (intype))),
4627 build_pointer_type (TYPE_MAIN_VARIANT
4628 (TREE_TYPE (type)))))
4632 check_for_casting_away_constness (intype, type, "static_cast");
4633 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), ba_check,
4635 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4638 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4639 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4646 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4647 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4649 if (TYPE_PTRMEM_P (type))
4651 t1 = (build_ptrmem_type
4653 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4654 t2 = (build_ptrmem_type
4656 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4663 if (can_convert (t1, t2))
4665 check_for_casting_away_constness (intype, type, "static_cast");
4666 if (TYPE_PTRMEM_P (type))
4670 if (TREE_CODE (expr) == PTRMEM_CST)
4671 expr = cplus_expand_constant (expr);
4672 delta = get_delta_difference (c1, c2, /*force=*/1);
4673 if (!integer_zerop (delta))
4674 expr = cp_build_binary_op (PLUS_EXPR,
4675 build_nop (ptrdiff_type_node, expr),
4677 return build_nop (type, expr);
4680 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4685 /* [expr.static.cast]
4687 An rvalue of type "pointer to cv void" can be explicitly
4688 converted to a pointer to object type. A value of type pointer
4689 to object converted to "pointer to cv void" and back to the
4690 original pointer type will have its original value. */
4691 if (TREE_CODE (intype) == POINTER_TYPE
4692 && VOID_TYPE_P (TREE_TYPE (intype))
4693 && TYPE_PTROB_P (type))
4695 check_for_casting_away_constness (intype, type, "static_cast");
4696 return build_nop (type, expr);
4699 error ("invalid static_cast from type `%T' to type `%T'", intype, type);
4700 return error_mark_node;
4704 build_reinterpret_cast (tree type, tree expr)
4708 if (type == error_mark_node || expr == error_mark_node)
4709 return error_mark_node;
4711 if (processing_template_decl)
4713 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4715 if (!TREE_SIDE_EFFECTS (t)
4716 && type_dependent_expression_p (expr))
4717 /* There might turn out to be side effects inside expr. */
4718 TREE_SIDE_EFFECTS (t) = 1;
4722 if (TREE_CODE (type) != REFERENCE_TYPE)
4724 expr = decay_conversion (expr);
4726 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4727 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4728 if (TREE_CODE (expr) == NOP_EXPR
4729 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4730 expr = TREE_OPERAND (expr, 0);
4733 intype = TREE_TYPE (expr);
4735 if (TREE_CODE (type) == REFERENCE_TYPE)
4737 if (! real_lvalue_p (expr))
4739 error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
4740 return error_mark_node;
4742 expr = build_unary_op (ADDR_EXPR, expr, 0);
4743 if (expr != error_mark_node)
4744 expr = build_reinterpret_cast
4745 (build_pointer_type (TREE_TYPE (type)), expr);
4746 if (expr != error_mark_node)
4747 expr = build_indirect_ref (expr, 0);
4750 else if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4751 return build_static_cast (type, expr);
4753 if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE
4754 || TREE_CODE (intype) == ENUMERAL_TYPE))
4756 else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
4758 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
4759 pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
4762 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
4763 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4765 expr = decl_constant_value (expr);
4766 return fold (build1 (NOP_EXPR, type, expr));
4768 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4769 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
4771 check_for_casting_away_constness (intype, type, "reinterpret_cast");
4772 expr = decl_constant_value (expr);
4773 return fold (build1 (NOP_EXPR, type, expr));
4775 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
4776 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
4778 pedwarn ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
4779 expr = decl_constant_value (expr);
4780 return fold (build1 (NOP_EXPR, type, expr));
4784 error ("invalid reinterpret_cast from type `%T' to type `%T'",
4786 return error_mark_node;
4789 return cp_convert (type, expr);
4793 build_const_cast (tree type, tree expr)
4797 if (type == error_mark_node || expr == error_mark_node)
4798 return error_mark_node;
4800 if (processing_template_decl)
4802 tree t = build_min (CONST_CAST_EXPR, type, expr);
4804 if (!TREE_SIDE_EFFECTS (t)
4805 && type_dependent_expression_p (expr))
4806 /* There might turn out to be side effects inside expr. */
4807 TREE_SIDE_EFFECTS (t) = 1;
4811 if (!POINTER_TYPE_P (type) && !TYPE_PTRMEM_P (type))
4812 error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
4813 else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4815 error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
4816 return error_mark_node;
4819 if (TREE_CODE (type) != REFERENCE_TYPE)
4821 expr = decay_conversion (expr);
4823 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4824 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4825 if (TREE_CODE (expr) == NOP_EXPR
4826 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4827 expr = TREE_OPERAND (expr, 0);
4830 intype = TREE_TYPE (expr);
4832 if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4833 return build_static_cast (type, expr);
4834 else if (TREE_CODE (type) == REFERENCE_TYPE)
4836 if (! real_lvalue_p (expr))
4838 error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
4839 return error_mark_node;
4842 if (comp_ptr_ttypes_const (TREE_TYPE (type), intype))
4844 expr = build_unary_op (ADDR_EXPR, expr, 0);
4845 expr = build1 (NOP_EXPR, type, expr);
4846 return convert_from_reference (expr);
4849 else if (((TREE_CODE (type) == POINTER_TYPE
4850 && TREE_CODE (intype) == POINTER_TYPE)
4851 || (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)))
4852 && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
4853 return cp_convert (type, expr);
4855 error ("invalid const_cast from type `%T' to type `%T'", intype, type);
4856 return error_mark_node;
4859 /* Build an expression representing a cast to type TYPE of expression EXPR.
4861 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
4862 when doing the cast. */
4865 build_c_cast (tree type, tree expr)
4870 if (type == error_mark_node || expr == error_mark_node)
4871 return error_mark_node;
4873 if (processing_template_decl)
4875 tree t = build_min (CAST_EXPR, type,
4876 tree_cons (NULL_TREE, value, NULL_TREE));
4877 /* We don't know if it will or will not have side effects. */
4878 TREE_SIDE_EFFECTS (t) = 1;
4882 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4883 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4884 if (TREE_CODE (type) != REFERENCE_TYPE
4885 && TREE_CODE (value) == NOP_EXPR
4886 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
4887 value = TREE_OPERAND (value, 0);
4889 if (TREE_CODE (type) == ARRAY_TYPE)
4891 /* Allow casting from T1* to T2[] because Cfront allows it.
4892 NIHCL uses it. It is not valid ISO C++ however. */
4893 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
4895 pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
4896 type = build_pointer_type (TREE_TYPE (type));
4900 error ("ISO C++ forbids casting to an array type `%T'", type);
4901 return error_mark_node;
4905 if (TREE_CODE (type) == FUNCTION_TYPE
4906 || TREE_CODE (type) == METHOD_TYPE)
4908 error ("invalid cast to function type `%T'", type);
4909 return error_mark_node;
4912 if (TREE_CODE (type) == VOID_TYPE)
4914 /* Conversion to void does not cause any of the normal function to
4915 * pointer, array to pointer and lvalue to rvalue decays. */
4917 value = convert_to_void (value, /*implicit=*/NULL);
4921 if (!complete_type_or_else (type, NULL_TREE))
4922 return error_mark_node;
4924 /* Convert functions and arrays to pointers and
4925 convert references to their expanded types,
4926 but don't convert any other types. If, however, we are
4927 casting to a class type, there's no reason to do this: the
4928 cast will only succeed if there is a converting constructor,
4929 and the default conversions will be done at that point. In
4930 fact, doing the default conversion here is actually harmful
4934 struct S { S(const A&); };
4936 since we don't want the array-to-pointer conversion done. */
4937 if (!IS_AGGR_TYPE (type))
4939 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
4940 || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
4941 /* Don't do the default conversion on a ->* expression. */
4942 && ! (TREE_CODE (type) == POINTER_TYPE
4943 && bound_pmf_p (value)))
4944 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
4945 || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
4946 value = decay_conversion (value);
4948 else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
4949 /* However, even for class types, we still need to strip away
4950 the reference type, since the call to convert_force below
4951 does not expect the input expression to be of reference
4953 value = convert_from_reference (value);
4955 otype = TREE_TYPE (value);
4957 /* Optionally warn about potentially worrisome casts. */
4960 && TREE_CODE (type) == POINTER_TYPE
4961 && TREE_CODE (otype) == POINTER_TYPE
4962 && !at_least_as_qualified_p (TREE_TYPE (type),
4964 warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
4967 if (TREE_CODE (type) == INTEGER_TYPE
4968 && TYPE_PTR_P (otype)
4969 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4970 warning ("cast from pointer to integer of different size");
4972 if (TYPE_PTR_P (type)
4973 && TREE_CODE (otype) == INTEGER_TYPE
4974 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4975 /* Don't warn about converting any constant. */
4976 && !TREE_CONSTANT (value))
4977 warning ("cast to pointer from integer of different size");
4979 if (TREE_CODE (type) == REFERENCE_TYPE)
4980 value = (convert_from_reference
4981 (convert_to_reference (type, value, CONV_C_CAST,
4982 LOOKUP_COMPLAIN, NULL_TREE)));
4987 value = decl_constant_value (value);
4990 value = convert_force (type, value, CONV_C_CAST);
4992 /* Ignore any integer overflow caused by the cast. */
4993 if (TREE_CODE (value) == INTEGER_CST)
4995 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4996 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
5000 /* Warn about possible alignment problems. Do this here when we will have
5001 instantiated any necessary template types. */
5002 if (STRICT_ALIGNMENT && warn_cast_align
5003 && TREE_CODE (type) == POINTER_TYPE
5004 && TREE_CODE (otype) == POINTER_TYPE
5005 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5006 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5007 && COMPLETE_TYPE_P (TREE_TYPE (otype))
5008 && COMPLETE_TYPE_P (TREE_TYPE (type))
5009 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
5010 warning ("cast from `%T' to `%T' increases required alignment of target type",
5013 /* Always produce some operator for an explicit cast,
5014 so we can tell (for -pedantic) that the cast is no lvalue. */
5015 if (TREE_CODE (type) != REFERENCE_TYPE && value == expr
5016 && real_lvalue_p (value))
5017 value = non_lvalue (value);
5022 /* Build an assignment expression of lvalue LHS from value RHS.
5023 MODIFYCODE is the code for a binary operator that we use
5024 to combine the old value of LHS with RHS to get the new value.
5025 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5027 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5030 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5034 tree lhstype = TREE_TYPE (lhs);
5035 tree olhstype = lhstype;
5036 tree olhs = NULL_TREE;
5038 /* Avoid duplicate error messages from operands that had errors. */
5039 if (lhs == error_mark_node || rhs == error_mark_node)
5040 return error_mark_node;
5042 /* Handle control structure constructs used as "lvalues". */
5043 switch (TREE_CODE (lhs))
5045 /* Handle --foo = 5; as these are valid constructs in C++. */
5046 case PREDECREMENT_EXPR:
5047 case PREINCREMENT_EXPR:
5048 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5049 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5050 stabilize_reference (TREE_OPERAND (lhs, 0)),
5051 TREE_OPERAND (lhs, 1));
5052 return build (COMPOUND_EXPR, lhstype,
5054 build_modify_expr (TREE_OPERAND (lhs, 0),
5057 /* Handle (a, b) used as an "lvalue". */
5059 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5061 if (newrhs == error_mark_node)
5062 return error_mark_node;
5063 return build (COMPOUND_EXPR, lhstype,
5064 TREE_OPERAND (lhs, 0), newrhs);
5067 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5068 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5069 stabilize_reference (TREE_OPERAND (lhs, 0)),
5070 TREE_OPERAND (lhs, 1));
5071 newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5072 if (newrhs == error_mark_node)
5073 return error_mark_node;
5074 return build (COMPOUND_EXPR, lhstype, lhs, newrhs);
5076 /* Handle (a ? b : c) used as an "lvalue". */
5079 /* Produce (a ? (b = rhs) : (c = rhs))
5080 except that the RHS goes through a save-expr
5081 so the code to compute it is only emitted once. */
5083 tree preeval = NULL_TREE;
5085 rhs = stabilize_expr (rhs, &preeval);
5087 /* Check this here to avoid odd errors when trying to convert
5088 a throw to the type of the COND_EXPR. */
5089 if (!lvalue_or_else (lhs, "assignment"))
5090 return error_mark_node;
5092 cond = build_conditional_expr
5093 (TREE_OPERAND (lhs, 0),
5094 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5095 TREE_OPERAND (lhs, 1)),
5097 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5098 TREE_OPERAND (lhs, 2)),
5101 if (cond == error_mark_node)
5103 /* Make sure the code to compute the rhs comes out
5104 before the split. */
5106 cond = build (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5114 if (modifycode == INIT_EXPR)
5116 if (TREE_CODE (rhs) == CONSTRUCTOR)
5118 if (! same_type_p (TREE_TYPE (rhs), lhstype))
5119 /* Call convert to generate an error; see PR 11063. */
5120 rhs = convert (lhstype, rhs);
5121 result = build (INIT_EXPR, lhstype, lhs, rhs);
5122 TREE_SIDE_EFFECTS (result) = 1;
5125 else if (! IS_AGGR_TYPE (lhstype))
5126 /* Do the default thing. */;
5129 result = build_special_member_call (lhs, complete_ctor_identifier,
5130 build_tree_list (NULL_TREE, rhs),
5131 TYPE_BINFO (lhstype),
5133 if (result == NULL_TREE)
5134 return error_mark_node;
5140 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5142 lhs = convert_from_reference (lhs);
5143 olhstype = lhstype = TREE_TYPE (lhs);
5145 lhs = require_complete_type (lhs);
5146 if (lhs == error_mark_node)
5147 return error_mark_node;
5149 if (modifycode == NOP_EXPR)
5151 /* `operator=' is not an inheritable operator. */
5152 if (! IS_AGGR_TYPE (lhstype))
5153 /* Do the default thing. */;
5156 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5157 lhs, rhs, make_node (NOP_EXPR),
5158 /*overloaded_p=*/NULL);
5159 if (result == NULL_TREE)
5160 return error_mark_node;
5167 /* A binary op has been requested. Combine the old LHS
5168 value with the RHS producing the value we should actually
5169 store into the LHS. */
5171 my_friendly_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE),
5173 lhs = stabilize_reference (lhs);
5174 newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5175 if (newrhs == error_mark_node)
5177 error (" in evaluation of `%Q(%#T, %#T)'", modifycode,
5178 TREE_TYPE (lhs), TREE_TYPE (rhs));
5179 return error_mark_node;
5182 /* Now it looks like a plain assignment. */
5183 modifycode = NOP_EXPR;
5185 my_friendly_assert (TREE_CODE (lhstype) != REFERENCE_TYPE, 20011220);
5186 my_friendly_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE,
5190 /* Handle a cast used as an "lvalue".
5191 We have already performed any binary operator using the value as cast.
5192 Now convert the result to the cast type of the lhs,
5193 and then true type of the lhs and store it there;
5194 then convert result back to the cast type to be the value
5195 of the assignment. */
5197 switch (TREE_CODE (lhs))
5202 case FIX_TRUNC_EXPR:
5203 case FIX_FLOOR_EXPR:
5204 case FIX_ROUND_EXPR:
5207 tree inner_lhs = TREE_OPERAND (lhs, 0);
5210 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5211 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5212 || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5213 || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5214 newrhs = decay_conversion (newrhs);
5216 /* ISO C++ 5.4/1: The result is an lvalue if T is a reference
5217 type, otherwise the result is an rvalue. */
5218 if (! lvalue_p (lhs))
5219 pedwarn ("ISO C++ forbids cast to non-reference type used as lvalue");
5221 result = build_modify_expr (inner_lhs, NOP_EXPR,
5222 cp_convert (TREE_TYPE (inner_lhs),
5223 cp_convert (lhstype, newrhs)));
5224 if (result == error_mark_node)
5226 return cp_convert (TREE_TYPE (lhs), result);
5233 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5234 Reject anything strange now. */
5236 if (!lvalue_or_else (lhs, "assignment"))
5237 return error_mark_node;
5239 /* Warn about modifying something that is `const'. Don't warn if
5240 this is initialization. */
5241 if (modifycode != INIT_EXPR
5242 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5243 /* Functions are not modifiable, even though they are
5245 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5246 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5247 /* If it's an aggregate and any field is const, then it is
5248 effectively const. */
5249 || (CLASS_TYPE_P (lhstype)
5250 && C_TYPE_FIELDS_READONLY (lhstype))))
5251 readonly_error (lhs, "assignment", 0);
5253 /* If storing into a structure or union member, it has probably been
5254 given type `int'. Compute the type that would go with the actual
5255 amount of storage the member occupies. */
5257 if (TREE_CODE (lhs) == COMPONENT_REF
5258 && (TREE_CODE (lhstype) == INTEGER_TYPE
5259 || TREE_CODE (lhstype) == REAL_TYPE
5260 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5262 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5264 /* If storing in a field that is in actuality a short or narrower
5265 than one, we must store in the field in its actual type. */
5267 if (lhstype != TREE_TYPE (lhs))
5269 /* Avoid warnings converting integral types back into enums for
5271 if (TREE_CODE (lhstype) == INTEGER_TYPE
5272 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5274 if (TREE_SIDE_EFFECTS (lhs))
5275 lhs = stabilize_reference (lhs);
5278 lhs = copy_node (lhs);
5279 TREE_TYPE (lhs) = lhstype;
5283 /* Convert new value to destination type. */
5285 if (TREE_CODE (lhstype) == ARRAY_TYPE)
5289 if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5290 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5292 error ("incompatible types in assignment of `%T' to `%T'",
5293 TREE_TYPE (rhs), lhstype);
5294 return error_mark_node;
5297 /* Allow array assignment in compiler-generated code. */
5298 if (! DECL_ARTIFICIAL (current_function_decl))
5299 pedwarn ("ISO C++ forbids assignment of arrays");
5301 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5302 ? 1 + (modifycode != INIT_EXPR): 0;
5303 return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5306 if (modifycode == INIT_EXPR)
5307 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5308 "initialization", NULL_TREE, 0);
5311 /* Avoid warnings on enum bit fields. */
5312 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5313 && TREE_CODE (lhstype) == INTEGER_TYPE)
5315 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5317 newrhs = convert_force (lhstype, newrhs, 0);
5320 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5322 if (TREE_CODE (newrhs) == CALL_EXPR
5323 && TYPE_NEEDS_CONSTRUCTING (lhstype))
5324 newrhs = build_cplus_new (lhstype, newrhs);
5326 /* Can't initialize directly from a TARGET_EXPR, since that would
5327 cause the lhs to be constructed twice, and possibly result in
5328 accidental self-initialization. So we force the TARGET_EXPR to be
5329 expanded without a target. */
5330 if (TREE_CODE (newrhs) == TARGET_EXPR)
5331 newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5332 TREE_OPERAND (newrhs, 0));
5335 if (newrhs == error_mark_node)
5336 return error_mark_node;
5338 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5339 lhstype, lhs, newrhs);
5341 TREE_SIDE_EFFECTS (result) = 1;
5343 /* If we got the LHS in a different type for storing in,
5344 convert the result back to the nominal type of LHS
5345 so that the value we return always has the same type
5346 as the LHS argument. */
5348 if (olhstype == TREE_TYPE (result))
5352 result = build (COMPOUND_EXPR, olhstype, result, olhs);
5353 TREE_NO_UNUSED_WARNING (result) = 1;
5356 return convert_for_assignment (olhstype, result, "assignment",
5361 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5363 if (processing_template_decl)
5364 return build_min_nt (MODOP_EXPR, lhs,
5365 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5367 if (modifycode != NOP_EXPR)
5369 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5370 make_node (modifycode),
5371 /*overloaded_p=*/NULL);
5375 return build_modify_expr (lhs, modifycode, rhs);
5379 /* Get difference in deltas for different pointer to member function
5380 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
5381 the conversion is invalid, the constant is zero. If FORCE is true,
5382 then allow reverse conversions as well.
5384 Note that the naming of FROM and TO is kind of backwards; the return
5385 value is what we add to a TO in order to get a FROM. They are named
5386 this way because we call this function to find out how to convert from
5387 a pointer to member of FROM to a pointer to member of TO. */
5390 get_delta_difference (tree from, tree to, int force)
5396 binfo = lookup_base (to, from, ba_check, &kind);
5397 if (kind == bk_inaccessible || kind == bk_ambig)
5399 error (" in pointer to member function conversion");
5406 error_not_base_type (from, to);
5407 error (" in pointer to member conversion");
5410 binfo = lookup_base (from, to, ba_check, &kind);
5413 virt_binfo = binfo_from_vbase (binfo);
5416 /* This is a reinterpret cast, we choose to do nothing. */
5417 warning ("pointer to member cast via virtual base `%T'",
5418 BINFO_TYPE (virt_binfo));
5421 return fold (convert_to_integer (ptrdiff_type_node,
5422 size_diffop (size_zero_node,
5423 BINFO_OFFSET (binfo))));
5426 virt_binfo = binfo_from_vbase (binfo);
5428 return fold (convert_to_integer (ptrdiff_type_node, BINFO_OFFSET (binfo)));
5430 /* This is a reinterpret cast, we choose to do nothing. */
5432 warning ("pointer to member cast via virtual base `%T'",
5433 BINFO_TYPE (virt_binfo));
5435 error ("pointer to member conversion via virtual base `%T'",
5436 BINFO_TYPE (virt_binfo));
5439 return fold (convert_to_integer(ptrdiff_type_node, integer_zero_node));
5442 /* Return a constructor for the pointer-to-member-function TYPE using
5443 the other components as specified. */
5446 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5452 /* Pull the FIELD_DECLs out of the type. */
5453 pfn_field = TYPE_FIELDS (type);
5454 delta_field = TREE_CHAIN (pfn_field);
5456 /* Make sure DELTA has the type we want. */
5457 delta = convert_and_check (delta_type_node, delta);
5459 /* Finish creating the initializer. */
5460 u = tree_cons (pfn_field, pfn,
5461 build_tree_list (delta_field, delta));
5462 u = build_constructor (type, u);
5463 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) && TREE_CONSTANT (delta);
5464 TREE_STATIC (u) = (TREE_CONSTANT (u)
5465 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5467 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5472 /* Build a constructor for a pointer to member function. It can be
5473 used to initialize global variables, local variable, or used
5474 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
5477 If FORCE is nonzero, then force this conversion, even if
5478 we would rather not do it. Usually set when using an explicit
5481 Return error_mark_node, if something goes wrong. */
5484 build_ptrmemfunc (tree type, tree pfn, int force)
5490 if (error_operand_p (pfn))
5491 return error_mark_node;
5493 pfn_type = TREE_TYPE (pfn);
5494 to_type = build_ptrmemfunc_type (type);
5496 /* Handle multiple conversions of pointer to member functions. */
5497 if (TYPE_PTRMEMFUNC_P (pfn_type))
5499 tree delta = NULL_TREE;
5500 tree npfn = NULL_TREE;
5504 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5505 error ("invalid conversion to type `%T' from type `%T'",
5508 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5509 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5512 /* We don't have to do any conversion to convert a
5513 pointer-to-member to its own type. But, we don't want to
5514 just return a PTRMEM_CST if there's an explicit cast; that
5515 cast should make the expression an invalid template argument. */
5516 if (TREE_CODE (pfn) != PTRMEM_CST)
5518 if (same_type_p (to_type, pfn_type))
5520 else if (integer_zerop (n))
5521 return build_reinterpret_cast (to_type, pfn);
5524 if (TREE_SIDE_EFFECTS (pfn))
5525 pfn = save_expr (pfn);
5527 /* Obtain the function pointer and the current DELTA. */
5528 if (TREE_CODE (pfn) == PTRMEM_CST)
5529 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5532 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5533 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5536 /* Just adjust the DELTA field. */
5538 (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (delta),
5541 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5542 n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5543 delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5544 return build_ptrmemfunc1 (to_type, delta, npfn);
5547 /* Handle null pointer to member function conversions. */
5548 if (integer_zerop (pfn))
5550 pfn = build_c_cast (type, integer_zero_node);
5551 return build_ptrmemfunc1 (to_type,
5556 if (type_unknown_p (pfn))
5557 return instantiate_type (type, pfn, tf_error | tf_warning);
5559 fn = TREE_OPERAND (pfn, 0);
5560 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5561 return make_ptrmem_cst (to_type, fn);
5564 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5567 ??? There is no consistency as to the types returned for the above
5568 values. Some code acts as if its a sizetype and some as if its
5569 integer_type_node. */
5572 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5574 tree type = TREE_TYPE (cst);
5575 tree fn = PTRMEM_CST_MEMBER (cst);
5576 tree ptr_class, fn_class;
5578 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5580 /* The class that the function belongs to. */
5581 fn_class = DECL_CONTEXT (fn);
5583 /* The class that we're creating a pointer to member of. */
5584 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5586 /* First, calculate the adjustment to the function's class. */
5587 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0);
5589 if (!DECL_VIRTUAL_P (fn))
5590 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5593 /* If we're dealing with a virtual function, we have to adjust 'this'
5594 again, to point to the base which provides the vtable entry for
5595 fn; the call will do the opposite adjustment. */
5596 tree orig_class = DECL_CONTEXT (fn);
5597 tree binfo = binfo_or_else (orig_class, fn_class);
5598 *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5599 *delta, BINFO_OFFSET (binfo)));
5601 /* We set PFN to the vtable offset at which the function can be
5602 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5603 case delta is shifted left, and then incremented). */
5604 *pfn = DECL_VINDEX (fn);
5605 *pfn = fold (build (MULT_EXPR, integer_type_node, *pfn,
5606 TYPE_SIZE_UNIT (vtable_entry_type)));
5608 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5610 case ptrmemfunc_vbit_in_pfn:
5611 *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn,
5615 case ptrmemfunc_vbit_in_delta:
5616 *delta = fold (build (LSHIFT_EXPR, TREE_TYPE (*delta),
5617 *delta, integer_one_node));
5618 *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5619 *delta, integer_one_node));
5626 *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
5631 /* Return an expression for PFN from the pointer-to-member function
5635 pfn_from_ptrmemfunc (tree t)
5637 if (TREE_CODE (t) == PTRMEM_CST)
5642 expand_ptrmemfunc_cst (t, &delta, &pfn);
5647 return build_ptrmemfunc_access_expr (t, pfn_identifier);
5650 /* Expression EXPR is about to be implicitly converted to TYPE. Warn
5651 if this is a potentially dangerous thing to do. Returns a possibly
5655 dubious_conversion_warnings (tree type, tree expr,
5656 const char *errtype, tree fndecl, int parmnum)
5658 type = non_reference (type);
5660 /* Issue warnings about peculiar, but valid, uses of NULL. */
5661 if (ARITHMETIC_TYPE_P (type) && expr == null_node)
5664 warning ("passing NULL used for non-pointer %s %P of `%D'",
5665 errtype, parmnum, fndecl);
5667 warning ("%s to non-pointer type `%T' from NULL", errtype, type);
5670 /* Warn about assigning a floating-point type to an integer type. */
5671 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
5672 && TREE_CODE (type) == INTEGER_TYPE)
5675 warning ("passing `%T' for %s %P of `%D'",
5676 TREE_TYPE (expr), errtype, parmnum, fndecl);
5678 warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
5680 /* And warn about assigning a negative value to an unsigned
5682 else if (TREE_UNSIGNED (type) && TREE_CODE (type) != BOOLEAN_TYPE)
5684 if (TREE_CODE (expr) == INTEGER_CST
5685 && TREE_NEGATED_INT (expr))
5688 warning ("passing negative value `%E' for %s %P of `%D'",
5689 expr, errtype, parmnum, fndecl);
5691 warning ("%s of negative value `%E' to `%T'",
5692 errtype, expr, type);
5695 overflow_warning (expr);
5697 if (TREE_CONSTANT (expr))
5703 /* Convert value RHS to type TYPE as preparation for an assignment to
5704 an lvalue of type TYPE. ERRTYPE is a string to use in error
5705 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
5706 are doing the conversion in order to pass the PARMNUMth argument of
5710 convert_for_assignment (tree type, tree rhs,
5711 const char *errtype, tree fndecl, int parmnum)
5714 enum tree_code coder;
5716 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
5717 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5718 rhs = TREE_OPERAND (rhs, 0);
5720 rhstype = TREE_TYPE (rhs);
5721 coder = TREE_CODE (rhstype);
5723 if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
5724 && ((*targetm.vector_opaque_p) (type)
5725 || (*targetm.vector_opaque_p) (rhstype)))
5726 return convert (type, rhs);
5728 if (rhs == error_mark_node || rhstype == error_mark_node)
5729 return error_mark_node;
5730 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
5731 return error_mark_node;
5733 /* The RHS of an assignment cannot have void type. */
5734 if (coder == VOID_TYPE)
5736 error ("void value not ignored as it ought to be");
5737 return error_mark_node;
5740 /* Simplify the RHS if possible. */
5741 if (TREE_CODE (rhs) == CONST_DECL)
5742 rhs = DECL_INITIAL (rhs);
5744 /* We do not use decl_constant_value here because of this case:
5746 const char* const s = "s";
5748 The conversion rules for a string literal are more lax than for a
5749 variable; in particular, a string literal can be converted to a
5750 "char *" but the variable "s" cannot be converted in the same
5751 way. If the conversion is allowed, the optimization should be
5752 performed while creating the converted expression. */
5756 The expression is implicitly converted (clause _conv_) to the
5757 cv-unqualified type of the left operand.
5759 We allow bad conversions here because by the time we get to this point
5760 we are committed to doing the conversion. If we end up doing a bad
5761 conversion, convert_like will complain. */
5762 if (!can_convert_arg_bad (type, rhstype, rhs))
5764 /* When -Wno-pmf-conversions is use, we just silently allow
5765 conversions from pointers-to-members to plain pointers. If
5766 the conversion doesn't work, cp_convert will complain. */
5768 && TYPE_PTR_P (type)
5769 && TYPE_PTRMEMFUNC_P (rhstype))
5770 rhs = cp_convert (strip_top_quals (type), rhs);
5773 /* If the right-hand side has unknown type, then it is an
5774 overloaded function. Call instantiate_type to get error
5776 if (rhstype == unknown_type_node)
5777 instantiate_type (type, rhs, tf_error | tf_warning);
5779 error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
5780 rhstype, type, parmnum, fndecl);
5782 error ("cannot convert `%T' to `%T' in %s", rhstype, type,
5784 return error_mark_node;
5787 return perform_implicit_conversion (strip_top_quals (type), rhs);
5790 /* Convert RHS to be of type TYPE.
5791 If EXP is nonzero, it is the target of the initialization.
5792 ERRTYPE is a string to use in error messages.
5794 Two major differences between the behavior of
5795 `convert_for_assignment' and `convert_for_initialization'
5796 are that references are bashed in the former, while
5797 copied in the latter, and aggregates are assigned in
5798 the former (operator=) while initialized in the
5801 If using constructor make sure no conversion operator exists, if one does
5802 exist, an ambiguity exists.
5804 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
5807 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
5808 const char *errtype, tree fndecl, int parmnum)
5810 enum tree_code codel = TREE_CODE (type);
5812 enum tree_code coder;
5814 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5815 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
5816 if (TREE_CODE (rhs) == NOP_EXPR
5817 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
5818 && codel != REFERENCE_TYPE)
5819 rhs = TREE_OPERAND (rhs, 0);
5821 if (rhs == error_mark_node
5822 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
5823 return error_mark_node;
5825 if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
5826 rhs = convert_from_reference (rhs);
5828 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
5829 && TREE_CODE (type) != ARRAY_TYPE
5830 && (TREE_CODE (type) != REFERENCE_TYPE
5831 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
5832 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
5833 && (TREE_CODE (type) != REFERENCE_TYPE
5834 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
5835 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
5836 rhs = decay_conversion (rhs);
5838 rhstype = TREE_TYPE (rhs);
5839 coder = TREE_CODE (rhstype);
5841 if (coder == ERROR_MARK)
5842 return error_mark_node;
5844 /* We accept references to incomplete types, so we can
5845 return here before checking if RHS is of complete type. */
5847 if (codel == REFERENCE_TYPE)
5849 /* This should eventually happen in convert_arguments. */
5850 int savew = 0, savee = 0;
5853 savew = warningcount, savee = errorcount;
5854 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
5858 if (warningcount > savew)
5859 cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5860 else if (errorcount > savee)
5861 cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5867 exp = require_complete_type (exp);
5868 if (exp == error_mark_node)
5869 return error_mark_node;
5871 rhstype = non_reference (rhstype);
5873 type = complete_type (type);
5875 if (IS_AGGR_TYPE (type))
5876 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
5878 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
5881 /* Expand an ASM statement with operands, handling output operands
5882 that are not variables or INDIRECT_REFS by transforming such
5883 cases into cases that expand_asm_operands can handle.
5885 Arguments are same as for expand_asm_operands.
5887 We don't do default conversions on all inputs, because it can screw
5888 up operands that are expected to be in memory. */
5891 c_expand_asm_operands (tree string, tree outputs, tree inputs, tree clobbers,
5892 int vol, location_t locus)
5894 int noutputs = list_length (outputs);
5896 /* o[I] is the place that output number I should be written. */
5897 tree *o = alloca (noutputs * sizeof (tree));
5900 /* Record the contents of OUTPUTS before it is modified. */
5901 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5902 o[i] = TREE_VALUE (tail);
5904 /* Generate the ASM_OPERANDS insn;
5905 store into the TREE_VALUEs of OUTPUTS some trees for
5906 where the values were actually stored. */
5907 expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
5909 /* Copy all the intermediate outputs into the specified outputs. */
5910 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5912 if (o[i] != TREE_VALUE (tail))
5914 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
5915 const0_rtx, VOIDmode, EXPAND_NORMAL);
5918 /* Restore the original value so that it's correct the next
5919 time we expand this function. */
5920 TREE_VALUE (tail) = o[i];
5922 /* Detect modification of read-only values.
5923 (Otherwise done by build_modify_expr.) */
5926 tree type = TREE_TYPE (o[i]);
5927 if (type != error_mark_node
5928 && (CP_TYPE_CONST_P (type)
5929 || (CLASS_TYPE_P (type) && C_TYPE_FIELDS_READONLY (type))))
5930 readonly_error (o[i], "modification by `asm'", 1);
5934 /* Those MODIFY_EXPRs could do autoincrements. */
5938 /* If RETVAL is the address of, or a reference to, a local variable or
5939 temporary give an appropriate warning. */
5942 maybe_warn_about_returning_address_of_local (tree retval)
5944 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
5945 tree whats_returned = retval;
5949 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
5950 whats_returned = TREE_OPERAND (whats_returned, 1);
5951 else if (TREE_CODE (whats_returned) == CONVERT_EXPR
5952 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
5953 || TREE_CODE (whats_returned) == NOP_EXPR)
5954 whats_returned = TREE_OPERAND (whats_returned, 0);
5959 if (TREE_CODE (whats_returned) != ADDR_EXPR)
5961 whats_returned = TREE_OPERAND (whats_returned, 0);
5963 if (TREE_CODE (valtype) == REFERENCE_TYPE)
5965 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
5966 || TREE_CODE (whats_returned) == TARGET_EXPR)
5968 warning ("returning reference to temporary");
5971 if (TREE_CODE (whats_returned) == VAR_DECL
5972 && DECL_NAME (whats_returned)
5973 && TEMP_NAME_P (DECL_NAME (whats_returned)))
5975 warning ("reference to non-lvalue returned");
5980 if (TREE_CODE (whats_returned) == VAR_DECL
5981 && DECL_NAME (whats_returned)
5982 && DECL_FUNCTION_SCOPE_P (whats_returned)
5983 && !(TREE_STATIC (whats_returned)
5984 || TREE_PUBLIC (whats_returned)))
5986 if (TREE_CODE (valtype) == REFERENCE_TYPE)
5987 cp_warning_at ("reference to local variable `%D' returned",
5990 cp_warning_at ("address of local variable `%D' returned",
5996 /* Check that returning RETVAL from the current function is valid.
5997 Return an expression explicitly showing all conversions required to
5998 change RETVAL into the function return type, and to assign it to
5999 the DECL_RESULT for the function. */
6002 check_return_expr (tree retval)
6005 /* The type actually returned by the function, after any
6008 int fn_returns_value_p;
6010 /* A `volatile' function is one that isn't supposed to return, ever.
6011 (This is a G++ extension, used to get better code for functions
6012 that call the `volatile' function.) */
6013 if (TREE_THIS_VOLATILE (current_function_decl))
6014 warning ("function declared `noreturn' has a `return' statement");
6016 /* Check for various simple errors. */
6017 if (DECL_DESTRUCTOR_P (current_function_decl))
6020 error ("returning a value from a destructor");
6023 else if (DECL_CONSTRUCTOR_P (current_function_decl))
6025 if (in_function_try_handler)
6026 /* If a return statement appears in a handler of the
6027 function-try-block of a constructor, the program is ill-formed. */
6028 error ("cannot return from a handler of a function-try-block of a constructor");
6030 /* You can't return a value from a constructor. */
6031 error ("returning a value from a constructor");
6035 if (processing_template_decl)
6037 current_function_returns_value = 1;
6041 /* When no explicit return-value is given in a function with a named
6042 return value, the named return value is used. */
6043 result = DECL_RESULT (current_function_decl);
6044 valtype = TREE_TYPE (result);
6045 my_friendly_assert (valtype != NULL_TREE, 19990924);
6046 fn_returns_value_p = !VOID_TYPE_P (valtype);
6047 if (!retval && DECL_NAME (result) && fn_returns_value_p)
6050 /* Check for a return statement with no return value in a function
6051 that's supposed to return a value. */
6052 if (!retval && fn_returns_value_p)
6054 pedwarn ("return-statement with no value, in function returning '%T'",
6056 /* Clear this, so finish_function won't say that we reach the
6057 end of a non-void function (which we don't, we gave a
6059 current_function_returns_null = 0;
6061 /* Check for a return statement with a value in a function that
6062 isn't supposed to return a value. */
6063 else if (retval && !fn_returns_value_p)
6065 if (VOID_TYPE_P (TREE_TYPE (retval)))
6066 /* You can return a `void' value from a function of `void'
6067 type. In that case, we have to evaluate the expression for
6068 its side-effects. */
6069 finish_expr_stmt (retval);
6071 pedwarn ("return-statement with a value, in function "
6072 "returning 'void'");
6074 current_function_returns_null = 1;
6076 /* There's really no value to return, after all. */
6080 /* Remember that this function can sometimes return without a
6082 current_function_returns_null = 1;
6084 /* Remember that this function did return a value. */
6085 current_function_returns_value = 1;
6087 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6088 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6089 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6090 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6092 && null_ptr_cst_p (retval))
6093 warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
6095 /* Effective C++ rule 15. See also start_function. */
6097 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)
6098 && retval != current_class_ref)
6099 warning ("`operator=' should return a reference to `*this'");
6101 /* The fabled Named Return Value optimization, as per [class.copy]/15:
6103 [...] For a function with a class return type, if the expression
6104 in the return statement is the name of a local object, and the cv-
6105 unqualified type of the local object is the same as the function
6106 return type, an implementation is permitted to omit creating the tem-
6107 porary object to hold the function return value [...]
6109 So, if this is a value-returning function that always returns the same
6110 local variable, remember it.
6112 It might be nice to be more flexible, and choose the first suitable
6113 variable even if the function sometimes returns something else, but
6114 then we run the risk of clobbering the variable we chose if the other
6115 returned expression uses the chosen variable somehow. And people expect
6116 this restriction, anyway. (jason 2000-11-19)
6118 See finish_function, cxx_expand_function_start, and
6119 cp_copy_res_decl_for_inlining for other pieces of this
6122 if (fn_returns_value_p && flag_elide_constructors)
6124 if (retval != NULL_TREE
6125 && (current_function_return_value == NULL_TREE
6126 || current_function_return_value == retval)
6127 && TREE_CODE (retval) == VAR_DECL
6128 && DECL_CONTEXT (retval) == current_function_decl
6129 && ! TREE_STATIC (retval)
6130 && (DECL_ALIGN (retval)
6131 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6132 && same_type_p ((TYPE_MAIN_VARIANT
6133 (TREE_TYPE (retval))),
6135 (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6136 current_function_return_value = retval;
6138 current_function_return_value = error_mark_node;
6141 /* We don't need to do any conversions when there's nothing being
6143 if (!retval || retval == error_mark_node)
6146 /* Do any required conversions. */
6147 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6148 /* No conversions are required. */
6152 /* The type the function is declared to return. */
6153 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6155 /* First convert the value to the function's return type, then
6156 to the type of return value's location to handle the
6157 case that functype is smaller than the valtype. */
6158 retval = convert_for_initialization
6159 (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6160 "return", NULL_TREE, 0);
6161 retval = convert (valtype, retval);
6163 /* If the conversion failed, treat this just like `return;'. */
6164 if (retval == error_mark_node)
6166 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6167 else if (! current_function_returns_struct
6168 && TREE_CODE (retval) == TARGET_EXPR
6169 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6170 retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6171 TREE_OPERAND (retval, 0));
6173 maybe_warn_about_returning_address_of_local (retval);
6176 /* Actually copy the value returned into the appropriate location. */
6177 if (retval && retval != result)
6178 retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6184 /* Returns nonzero if the pointer-type FROM can be converted to the
6185 pointer-type TO via a qualification conversion. If CONSTP is -1,
6186 then we return nonzero if the pointers are similar, and the
6187 cv-qualification signature of FROM is a proper subset of that of TO.
6189 If CONSTP is positive, then all outer pointers have been
6193 comp_ptr_ttypes_real (tree to, tree from, int constp)
6195 bool to_more_cv_qualified = false;
6197 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6199 if (TREE_CODE (to) != TREE_CODE (from))
6202 if (TREE_CODE (from) == OFFSET_TYPE
6203 && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6204 TYPE_OFFSET_BASETYPE (to)))
6207 /* Const and volatile mean something different for function types,
6208 so the usual checks are not appropriate. */
6209 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6211 if (!at_least_as_qualified_p (to, from))
6214 if (!at_least_as_qualified_p (from, to))
6218 to_more_cv_qualified = true;
6222 constp &= TYPE_READONLY (to);
6225 if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6226 return ((constp >= 0 || to_more_cv_qualified)
6227 && same_type_ignoring_top_level_qualifiers_p (to, from));
6231 /* When comparing, say, char ** to char const **, this function takes
6232 the 'char *' and 'char const *'. Do not pass non-pointer/reference
6233 types to this function. */
6236 comp_ptr_ttypes (tree to, tree from)
6238 return comp_ptr_ttypes_real (to, from, 1);
6241 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6242 type or inheritance-related types, regardless of cv-quals. */
6245 ptr_reasonably_similar (tree to, tree from)
6247 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6249 /* Any target type is similar enough to void. */
6250 if (TREE_CODE (to) == VOID_TYPE
6251 || TREE_CODE (from) == VOID_TYPE)
6254 if (TREE_CODE (to) != TREE_CODE (from))
6257 if (TREE_CODE (from) == OFFSET_TYPE
6258 && comptypes (TYPE_OFFSET_BASETYPE (to),
6259 TYPE_OFFSET_BASETYPE (from),
6260 COMPARE_BASE | COMPARE_DERIVED))
6263 if (TREE_CODE (to) == INTEGER_TYPE
6264 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6267 if (TREE_CODE (to) == FUNCTION_TYPE)
6270 if (TREE_CODE (to) != POINTER_TYPE)
6272 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6273 COMPARE_BASE | COMPARE_DERIVED);
6277 /* Like comp_ptr_ttypes, for const_cast. */
6280 comp_ptr_ttypes_const (tree to, tree from)
6282 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6284 if (TREE_CODE (to) != TREE_CODE (from))
6287 if (TREE_CODE (from) == OFFSET_TYPE
6288 && same_type_p (TYPE_OFFSET_BASETYPE (from),
6289 TYPE_OFFSET_BASETYPE (to)))
6292 if (TREE_CODE (to) != POINTER_TYPE)
6293 return same_type_ignoring_top_level_qualifiers_p (to, from);
6297 /* Returns the type qualifiers for this type, including the qualifiers on the
6298 elements for an array type. */
6301 cp_type_quals (tree type)
6303 type = strip_array_types (type);
6304 if (type == error_mark_node)
6305 return TYPE_UNQUALIFIED;
6306 return TYPE_QUALS (type);
6309 /* Returns nonzero if the TYPE contains a mutable member. */
6312 cp_has_mutable_p (tree type)
6314 type = strip_array_types (type);
6316 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6319 /* Subroutine of casts_away_constness. Make T1 and T2 point at
6320 exemplar types such that casting T1 to T2 is casting away castness
6321 if and only if there is no implicit conversion from T1 to T2. */
6324 casts_away_constness_r (tree *t1, tree *t2)
6329 /* [expr.const.cast]
6331 For multi-level pointer to members and multi-level mixed pointers
6332 and pointers to members (conv.qual), the "member" aspect of a
6333 pointer to member level is ignored when determining if a const
6334 cv-qualifier has been cast away. */
6335 /* [expr.const.cast]
6337 For two pointer types:
6339 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
6340 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
6343 casting from X1 to X2 casts away constness if, for a non-pointer
6344 type T there does not exist an implicit conversion (clause
6347 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6351 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
6352 if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
6353 || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
6355 *t1 = cp_build_qualified_type (void_type_node,
6356 cp_type_quals (*t1));
6357 *t2 = cp_build_qualified_type (void_type_node,
6358 cp_type_quals (*t2));
6362 quals1 = cp_type_quals (*t1);
6363 quals2 = cp_type_quals (*t2);
6365 if (TYPE_PTRMEM_P (*t1))
6366 *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
6368 *t1 = TREE_TYPE (*t1);
6369 if (TYPE_PTRMEM_P (*t2))
6370 *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
6372 *t2 = TREE_TYPE (*t2);
6374 casts_away_constness_r (t1, t2);
6375 *t1 = build_pointer_type (*t1);
6376 *t2 = build_pointer_type (*t2);
6377 *t1 = cp_build_qualified_type (*t1, quals1);
6378 *t2 = cp_build_qualified_type (*t2, quals2);
6381 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6385 casts_away_constness (tree t1, tree t2)
6387 if (TREE_CODE (t2) == REFERENCE_TYPE)
6389 /* [expr.const.cast]
6391 Casting from an lvalue of type T1 to an lvalue of type T2
6392 using a reference cast casts away constness if a cast from an
6393 rvalue of type "pointer to T1" to the type "pointer to T2"
6394 casts away constness. */
6395 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6396 return casts_away_constness (build_pointer_type (t1),
6397 build_pointer_type (TREE_TYPE (t2)));
6400 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6401 /* [expr.const.cast]
6403 Casting from an rvalue of type "pointer to data member of X
6404 of type T1" to the type "pointer to data member of Y of type
6405 T2" casts away constness if a cast from an rvalue of type
6406 "pointer to T1" to the type "pointer to T2" casts away
6408 return casts_away_constness
6409 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6410 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6412 /* Casting away constness is only something that makes sense for
6413 pointer or reference types. */
6414 if (TREE_CODE (t1) != POINTER_TYPE
6415 || TREE_CODE (t2) != POINTER_TYPE)
6418 /* Top-level qualifiers don't matter. */
6419 t1 = TYPE_MAIN_VARIANT (t1);
6420 t2 = TYPE_MAIN_VARIANT (t2);
6421 casts_away_constness_r (&t1, &t2);
6422 if (!can_convert (t2, t1))
6428 /* If T is a REFERENCE_TYPE return the type to which T refers.
6429 Otherwise, return T itself. */
6432 non_reference (tree t)
6434 if (TREE_CODE (t) == REFERENCE_TYPE)