1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* This file is part of the C++ front end.
25 It contains routines to build C++ expressions given their operands,
26 including computing the types of the result, C and C++ specific error
27 checks, and some optimization. */
31 #include "coretypes.h"
41 #include "diagnostic.h"
48 static tree
pfn_from_ptrmemfunc (tree
);
49 static tree
delta_from_ptrmemfunc (tree
);
50 static tree
convert_for_assignment (tree
, tree
, const char *, tree
, int,
52 static tree
cp_pointer_int_sum (enum tree_code
, tree
, tree
);
53 static tree
rationalize_conditional_expr (enum tree_code
, tree
,
55 static int comp_ptr_ttypes_real (tree
, tree
, int);
56 static bool comp_except_types (tree
, tree
, bool);
57 static bool comp_array_types (const_tree
, const_tree
, bool);
58 static tree
pointer_diff (tree
, tree
, tree
);
59 static tree
get_delta_difference (tree
, tree
, bool, bool);
60 static void casts_away_constness_r (tree
*, tree
*);
61 static bool casts_away_constness (tree
, tree
);
62 static void maybe_warn_about_returning_address_of_local (tree
);
63 static tree
lookup_destructor (tree
, tree
, tree
);
64 static int convert_arguments (int, tree
*, tree
, tree
, tree
, int,
67 /* Do `exp = require_complete_type (exp);' to make sure exp
68 does not have an incomplete type. (That includes void types.)
69 Returns the error_mark_node if the VALUE does not have
70 complete type when this function returns. */
73 require_complete_type (tree value
)
77 if (processing_template_decl
|| value
== error_mark_node
)
80 if (TREE_CODE (value
) == OVERLOAD
)
81 type
= unknown_type_node
;
83 type
= TREE_TYPE (value
);
85 if (type
== error_mark_node
)
86 return error_mark_node
;
88 /* First, detect a valid value with a complete type. */
89 if (COMPLETE_TYPE_P (type
))
92 if (complete_type_or_else (type
, value
))
95 return error_mark_node
;
98 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
99 a template instantiation, do the instantiation. Returns TYPE,
100 whether or not it could be completed, unless something goes
101 horribly wrong, in which case the error_mark_node is returned. */
104 complete_type (tree type
)
106 if (type
== NULL_TREE
)
107 /* Rather than crash, we return something sure to cause an error
109 return error_mark_node
;
111 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
113 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
115 tree t
= complete_type (TREE_TYPE (type
));
116 unsigned int needs_constructing
, has_nontrivial_dtor
;
117 if (COMPLETE_TYPE_P (t
) && !dependent_type_p (type
))
120 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
122 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
123 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
125 TYPE_NEEDS_CONSTRUCTING (t
) = needs_constructing
;
126 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = has_nontrivial_dtor
;
129 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
130 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
135 /* Like complete_type, but issue an error if the TYPE cannot be completed.
136 VALUE is used for informative diagnostics.
137 Returns NULL_TREE if the type cannot be made complete. */
140 complete_type_or_else (tree type
, tree value
)
142 type
= complete_type (type
);
143 if (type
== error_mark_node
)
144 /* We already issued an error. */
146 else if (!COMPLETE_TYPE_P (type
))
148 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
155 /* Return truthvalue of whether type of EXP is instantiated. */
158 type_unknown_p (const_tree exp
)
160 return (TREE_CODE (exp
) == TREE_LIST
161 || TREE_TYPE (exp
) == unknown_type_node
);
165 /* Return the common type of two parameter lists.
166 We assume that comptypes has already been done and returned 1;
167 if that isn't so, this may crash.
169 As an optimization, free the space we allocate if the parameter
170 lists are already common. */
173 commonparms (tree p1
, tree p2
)
175 tree oldargs
= p1
, newargs
, n
;
179 len
= list_length (p1
);
180 newargs
= tree_last (p1
);
182 if (newargs
== void_list_node
)
191 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
196 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
198 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
200 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
203 else if (! TREE_PURPOSE (p1
))
205 if (TREE_PURPOSE (p2
))
207 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
213 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
215 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
217 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
220 TREE_VALUE (n
) = merge_types (TREE_VALUE (p1
), TREE_VALUE (p2
));
223 TREE_VALUE (n
) = TREE_VALUE (p1
);
231 /* Given a type, perhaps copied for a typedef,
232 find the "original" version of it. */
234 original_type (tree t
)
236 int quals
= cp_type_quals (t
);
237 while (t
!= error_mark_node
238 && TYPE_NAME (t
) != NULL_TREE
)
240 tree x
= TYPE_NAME (t
);
241 if (TREE_CODE (x
) != TYPE_DECL
)
243 x
= DECL_ORIGINAL_TYPE (x
);
248 return cp_build_qualified_type (t
, quals
);
251 /* T1 and T2 are arithmetic or enumeration types. Return the type
252 that will result from the "usual arithmetic conversions" on T1 and
253 T2 as described in [expr]. */
256 type_after_usual_arithmetic_conversions (tree t1
, tree t2
)
258 enum tree_code code1
= TREE_CODE (t1
);
259 enum tree_code code2
= TREE_CODE (t2
);
262 /* FIXME: Attributes. */
263 gcc_assert (ARITHMETIC_TYPE_P (t1
)
264 || TREE_CODE (t1
) == VECTOR_TYPE
265 || UNSCOPED_ENUM_P (t1
));
266 gcc_assert (ARITHMETIC_TYPE_P (t2
)
267 || TREE_CODE (t2
) == VECTOR_TYPE
268 || UNSCOPED_ENUM_P (t2
));
270 /* In what follows, we slightly generalize the rules given in [expr] so
271 as to deal with `long long' and `complex'. First, merge the
273 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
275 /* If one type is complex, form the common type of the non-complex
276 components, then make that complex. Use T1 or T2 if it is the
278 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
280 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
281 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
283 = type_after_usual_arithmetic_conversions (subtype1
, subtype2
);
285 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
286 return build_type_attribute_variant (t1
, attributes
);
287 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
288 return build_type_attribute_variant (t2
, attributes
);
290 return build_type_attribute_variant (build_complex_type (subtype
),
294 if (code1
== VECTOR_TYPE
)
296 /* When we get here we should have two vectors of the same size.
297 Just prefer the unsigned one if present. */
298 if (TYPE_UNSIGNED (t1
))
299 return build_type_attribute_variant (t1
, attributes
);
301 return build_type_attribute_variant (t2
, attributes
);
304 /* If only one is real, use it as the result. */
305 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
306 return build_type_attribute_variant (t1
, attributes
);
307 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
308 return build_type_attribute_variant (t2
, attributes
);
310 /* Perform the integral promotions. */
311 if (code1
!= REAL_TYPE
)
313 t1
= type_promotes_to (t1
);
314 t2
= type_promotes_to (t2
);
317 /* Both real or both integers; use the one with greater precision. */
318 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
319 return build_type_attribute_variant (t1
, attributes
);
320 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
321 return build_type_attribute_variant (t2
, attributes
);
323 /* The types are the same; no need to do anything fancy. */
324 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
325 return build_type_attribute_variant (t1
, attributes
);
327 if (code1
!= REAL_TYPE
)
329 /* If one is unsigned long long, then convert the other to unsigned
331 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
332 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
333 return build_type_attribute_variant (long_long_unsigned_type_node
,
335 /* If one is a long long, and the other is an unsigned long, and
336 long long can represent all the values of an unsigned long, then
337 convert to a long long. Otherwise, convert to an unsigned long
338 long. Otherwise, if either operand is long long, convert the
341 Since we're here, we know the TYPE_PRECISION is the same;
342 therefore converting to long long cannot represent all the values
343 of an unsigned long, so we choose unsigned long long in that
345 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
346 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
348 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
349 ? long_long_unsigned_type_node
350 : long_long_integer_type_node
);
351 return build_type_attribute_variant (t
, attributes
);
354 /* Go through the same procedure, but for longs. */
355 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
356 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
357 return build_type_attribute_variant (long_unsigned_type_node
,
359 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
360 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
362 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
363 ? long_unsigned_type_node
: long_integer_type_node
);
364 return build_type_attribute_variant (t
, attributes
);
366 /* Otherwise prefer the unsigned one. */
367 if (TYPE_UNSIGNED (t1
))
368 return build_type_attribute_variant (t1
, attributes
);
370 return build_type_attribute_variant (t2
, attributes
);
374 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
375 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
376 return build_type_attribute_variant (long_double_type_node
,
378 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
379 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
380 return build_type_attribute_variant (double_type_node
,
382 if (same_type_p (TYPE_MAIN_VARIANT (t1
), float_type_node
)
383 || same_type_p (TYPE_MAIN_VARIANT (t2
), float_type_node
))
384 return build_type_attribute_variant (float_type_node
,
387 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
388 the standard C++ floating-point types. Logic earlier in this
389 function has already eliminated the possibility that
390 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
391 compelling reason to choose one or the other. */
392 return build_type_attribute_variant (t1
, attributes
);
396 /* Subroutine of composite_pointer_type to implement the recursive
397 case. See that function for documentation fo the parameters. */
400 composite_pointer_type_r (tree t1
, tree t2
, const char* location
,
401 tsubst_flags_t complain
)
408 /* Determine the types pointed to by T1 and T2. */
409 if (TREE_CODE (t1
) == POINTER_TYPE
)
411 pointee1
= TREE_TYPE (t1
);
412 pointee2
= TREE_TYPE (t2
);
416 pointee1
= TYPE_PTRMEM_POINTED_TO_TYPE (t1
);
417 pointee2
= TYPE_PTRMEM_POINTED_TO_TYPE (t2
);
422 Otherwise, the composite pointer type is a pointer type
423 similar (_conv.qual_) to the type of one of the operands,
424 with a cv-qualification signature (_conv.qual_) that is the
425 union of the cv-qualification signatures of the operand
427 if (same_type_ignoring_top_level_qualifiers_p (pointee1
, pointee2
))
428 result_type
= pointee1
;
429 else if ((TREE_CODE (pointee1
) == POINTER_TYPE
430 && TREE_CODE (pointee2
) == POINTER_TYPE
)
431 || (TYPE_PTR_TO_MEMBER_P (pointee1
)
432 && TYPE_PTR_TO_MEMBER_P (pointee2
)))
433 result_type
= composite_pointer_type_r (pointee1
, pointee2
, location
,
437 if (complain
& tf_error
)
438 permerror (input_location
, "%s between distinct pointer types %qT and %qT "
441 result_type
= void_type_node
;
443 result_type
= cp_build_qualified_type (result_type
,
444 (cp_type_quals (pointee1
)
445 | cp_type_quals (pointee2
)));
446 /* If the original types were pointers to members, so is the
448 if (TYPE_PTR_TO_MEMBER_P (t1
))
450 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
451 TYPE_PTRMEM_CLASS_TYPE (t2
))
452 && (complain
& tf_error
))
453 permerror (input_location
, "%s between distinct pointer types %qT and %qT "
456 result_type
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
460 result_type
= build_pointer_type (result_type
);
462 /* Merge the attributes. */
463 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
464 return build_type_attribute_variant (result_type
, attributes
);
467 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
468 ARG1 and ARG2 are the values with those types. The LOCATION is a
469 string describing the current location, in case an error occurs.
471 This routine also implements the computation of a common type for
472 pointers-to-members as per [expr.eq]. */
475 composite_pointer_type (tree t1
, tree t2
, tree arg1
, tree arg2
,
476 const char* location
, tsubst_flags_t complain
)
483 If one operand is a null pointer constant, the composite pointer
484 type is the type of the other operand. */
485 if (null_ptr_cst_p (arg1
))
487 if (null_ptr_cst_p (arg2
))
494 If one of the operands has type "pointer to cv1 void*", then
495 the other has type "pointer to cv2T", and the composite pointer
496 type is "pointer to cv12 void", where cv12 is the union of cv1
499 If either type is a pointer to void, make sure it is T1. */
500 if (TREE_CODE (t2
) == POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (t2
)))
508 /* Now, if T1 is a pointer to void, merge the qualifiers. */
509 if (TREE_CODE (t1
) == POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (t1
)))
514 if (TYPE_PTRFN_P (t2
) && (complain
& tf_error
))
515 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids %s "
516 "between pointer of type %<void *%> and pointer-to-function",
519 = cp_build_qualified_type (void_type_node
,
520 (cp_type_quals (TREE_TYPE (t1
))
521 | cp_type_quals (TREE_TYPE (t2
))));
522 result_type
= build_pointer_type (result_type
);
523 /* Merge the attributes. */
524 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
525 return build_type_attribute_variant (result_type
, attributes
);
528 if (c_dialect_objc () && TREE_CODE (t1
) == POINTER_TYPE
529 && TREE_CODE (t2
) == POINTER_TYPE
)
531 if (objc_compare_types (t1
, t2
, -3, NULL_TREE
))
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 if (complain
& tf_error
)
555 error ("%s between distinct pointer types %qT and %qT "
556 "lacks a cast", location
, t1
, t2
);
557 return error_mark_node
;
560 /* [expr.eq] permits the application of a pointer-to-member
561 conversion to change the class type of one of the types. */
562 else if (TYPE_PTR_TO_MEMBER_P (t1
)
563 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
564 TYPE_PTRMEM_CLASS_TYPE (t2
)))
566 class1
= TYPE_PTRMEM_CLASS_TYPE (t1
);
567 class2
= TYPE_PTRMEM_CLASS_TYPE (t2
);
569 if (DERIVED_FROM_P (class1
, class2
))
570 t1
= build_ptrmem_type (class2
, TYPE_PTRMEM_POINTED_TO_TYPE (t1
));
571 else if (DERIVED_FROM_P (class2
, class1
))
572 t2
= build_ptrmem_type (class1
, TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
575 if (complain
& tf_error
)
576 error ("%s between distinct pointer-to-member types %qT and %qT "
577 "lacks a cast", location
, t1
, t2
);
578 return error_mark_node
;
582 return composite_pointer_type_r (t1
, t2
, location
, complain
);
585 /* Return the merged type of two types.
586 We assume that comptypes has already been done and returned 1;
587 if that isn't so, this may crash.
589 This just combines attributes and default arguments; any other
590 differences would cause the two types to compare unalike. */
593 merge_types (tree t1
, tree t2
)
595 enum tree_code code1
;
596 enum tree_code code2
;
599 /* Save time if the two types are the same. */
602 if (original_type (t1
) == original_type (t2
))
605 /* If one type is nonsense, use the other. */
606 if (t1
== error_mark_node
)
608 if (t2
== error_mark_node
)
611 /* Merge the attributes. */
612 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
614 if (TYPE_PTRMEMFUNC_P (t1
))
615 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
616 if (TYPE_PTRMEMFUNC_P (t2
))
617 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
619 code1
= TREE_CODE (t1
);
620 code2
= TREE_CODE (t2
);
626 /* For two pointers, do this recursively on the target type. */
628 tree target
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
629 int quals
= cp_type_quals (t1
);
631 if (code1
== POINTER_TYPE
)
632 t1
= build_pointer_type (target
);
634 t1
= cp_build_reference_type (target
, TYPE_REF_IS_RVALUE (t1
));
635 t1
= build_type_attribute_variant (t1
, attributes
);
636 t1
= cp_build_qualified_type (t1
, quals
);
638 if (TREE_CODE (target
) == METHOD_TYPE
)
639 t1
= build_ptrmemfunc_type (t1
);
648 quals
= cp_type_quals (t1
);
649 pointee
= merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1
),
650 TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
651 t1
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
653 t1
= cp_build_qualified_type (t1
, quals
);
659 tree elt
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
660 /* Save space: see if the result is identical to one of the args. */
661 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
662 return build_type_attribute_variant (t1
, attributes
);
663 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
664 return build_type_attribute_variant (t2
, attributes
);
665 /* Merge the element types, and have a size if either arg has one. */
666 t1
= build_cplus_array_type
667 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
672 /* Function types: prefer the one that specified arg types.
673 If both do, merge the arg types. Also merge the return types. */
675 tree valtype
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
676 tree p1
= TYPE_ARG_TYPES (t1
);
677 tree p2
= TYPE_ARG_TYPES (t2
);
680 /* Save space: see if the result is identical to one of the args. */
681 if (valtype
== TREE_TYPE (t1
) && ! p2
)
682 return cp_build_type_attribute_variant (t1
, attributes
);
683 if (valtype
== TREE_TYPE (t2
) && ! p1
)
684 return cp_build_type_attribute_variant (t2
, attributes
);
686 /* Simple way if one arg fails to specify argument types. */
687 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
689 rval
= build_function_type (valtype
, p2
);
690 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
691 rval
= build_exception_variant (rval
, raises
);
692 return cp_build_type_attribute_variant (rval
, attributes
);
694 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
695 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
697 rval
= build_function_type (valtype
, p1
);
699 rval
= build_exception_variant (rval
, raises
);
700 return cp_build_type_attribute_variant (rval
, attributes
);
703 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
704 t1
= build_exception_variant (rval
, raises
);
710 /* Get this value the long way, since TYPE_METHOD_BASETYPE
711 is just the main variant of this. */
712 tree basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
713 tree raises
= TYPE_RAISES_EXCEPTIONS (t1
);
716 /* If this was a member function type, get back to the
717 original type of type member function (i.e., without
718 the class instance variable up front. */
719 t1
= build_function_type (TREE_TYPE (t1
),
720 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
721 t2
= build_function_type (TREE_TYPE (t2
),
722 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
723 t3
= merge_types (t1
, t2
);
724 t3
= build_method_type_directly (basetype
, TREE_TYPE (t3
),
725 TYPE_ARG_TYPES (t3
));
726 t1
= build_exception_variant (t3
, raises
);
731 /* There is no need to merge attributes into a TYPENAME_TYPE.
732 When the type is instantiated it will have whatever
733 attributes result from the instantiation. */
739 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
741 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
744 return cp_build_type_attribute_variant (t1
, attributes
);
747 /* Return the common type of two types.
748 We assume that comptypes has already been done and returned 1;
749 if that isn't so, this may crash.
751 This is the type for the result of most arithmetic operations
752 if the operands have the given two types. */
755 common_type (tree t1
, tree t2
)
757 enum tree_code code1
;
758 enum tree_code code2
;
760 /* If one type is nonsense, bail. */
761 if (t1
== error_mark_node
|| t2
== error_mark_node
)
762 return error_mark_node
;
764 code1
= TREE_CODE (t1
);
765 code2
= TREE_CODE (t2
);
767 if ((ARITHMETIC_TYPE_P (t1
) || UNSCOPED_ENUM_P (t1
)
768 || code1
== VECTOR_TYPE
)
769 && (ARITHMETIC_TYPE_P (t2
) || UNSCOPED_ENUM_P (t2
)
770 || code2
== VECTOR_TYPE
))
771 return type_after_usual_arithmetic_conversions (t1
, t2
);
773 else if ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
774 || (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
))
775 || (TYPE_PTRMEMFUNC_P (t1
) && TYPE_PTRMEMFUNC_P (t2
)))
776 return composite_pointer_type (t1
, t2
, error_mark_node
, error_mark_node
,
777 "conversion", tf_warning_or_error
);
782 /* Compare two exception specifier types for exactness or subsetness, if
783 allowed. Returns false for mismatch, true for match (same, or
786 [except.spec] "If a class X ... objects of class X or any class publicly
787 and unambiguously derived from X. Similarly, if a pointer type Y * ...
788 exceptions of type Y * or that are pointers to any type publicly and
789 unambiguously derived from Y. Otherwise a function only allows exceptions
790 that have the same type ..."
791 This does not mention cv qualifiers and is different to what throw
792 [except.throw] and catch [except.catch] will do. They will ignore the
793 top level cv qualifiers, and allow qualifiers in the pointer to class
796 We implement the letter of the standard. */
799 comp_except_types (tree a
, tree b
, bool exact
)
801 if (same_type_p (a
, b
))
805 if (cp_type_quals (a
) || cp_type_quals (b
))
808 if (TREE_CODE (a
) == POINTER_TYPE
809 && TREE_CODE (b
) == POINTER_TYPE
)
813 if (cp_type_quals (a
) || cp_type_quals (b
))
817 if (TREE_CODE (a
) != RECORD_TYPE
818 || TREE_CODE (b
) != RECORD_TYPE
)
821 if (PUBLICLY_UNIQUELY_DERIVED_P (a
, b
))
827 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
828 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
829 otherwise it must be exact. Exception lists are unordered, but
830 we've already filtered out duplicates. Most lists will be in order,
831 we should try to make use of that. */
834 comp_except_specs (const_tree t1
, const_tree t2
, bool exact
)
843 if (t1
== NULL_TREE
) /* T1 is ... */
844 return t2
== NULL_TREE
|| !exact
;
845 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
846 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
847 if (t2
== NULL_TREE
) /* T2 is ... */
849 if (TREE_VALUE (t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
852 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
853 Count how many we find, to determine exactness. For exact matching and
854 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
856 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
858 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
860 tree a
= TREE_VALUE (probe
);
861 tree b
= TREE_VALUE (t2
);
863 if (comp_except_types (a
, b
, exact
))
865 if (probe
== base
&& exact
)
866 base
= TREE_CHAIN (probe
);
871 if (probe
== NULL_TREE
)
874 return !exact
|| base
== NULL_TREE
|| length
== list_length (t1
);
877 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
878 [] can match [size]. */
881 comp_array_types (const_tree t1
, const_tree t2
, bool allow_redeclaration
)
890 /* The type of the array elements must be the same. */
891 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
894 d1
= TYPE_DOMAIN (t1
);
895 d2
= TYPE_DOMAIN (t2
);
900 /* If one of the arrays is dimensionless, and the other has a
901 dimension, they are of different types. However, it is valid to
909 declarations for an array object can specify
910 array types that differ by the presence or absence of a major
911 array bound (_dcl.array_). */
913 return allow_redeclaration
;
915 /* Check that the dimensions are the same. */
917 if (!cp_tree_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
)))
919 max1
= TYPE_MAX_VALUE (d1
);
920 max2
= TYPE_MAX_VALUE (d2
);
921 if (processing_template_decl
&& !abi_version_at_least (2)
922 && !value_dependent_expression_p (max1
)
923 && !value_dependent_expression_p (max2
))
925 /* With abi-1 we do not fold non-dependent array bounds, (and
926 consequently mangle them incorrectly). We must therefore
927 fold them here, to verify the domains have the same
933 if (!cp_tree_equal (max1
, max2
))
939 /* Subroutine in comptypes. */
942 structural_comptypes (tree t1
, tree t2
, int strict
)
947 /* Suppress errors caused by previously reported errors. */
948 if (t1
== error_mark_node
|| t2
== error_mark_node
)
951 gcc_assert (TYPE_P (t1
) && TYPE_P (t2
));
953 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
954 current instantiation. */
955 if (TREE_CODE (t1
) == TYPENAME_TYPE
)
956 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
958 if (TREE_CODE (t2
) == TYPENAME_TYPE
)
959 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
961 if (TYPE_PTRMEMFUNC_P (t1
))
962 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
963 if (TYPE_PTRMEMFUNC_P (t2
))
964 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
966 /* Different classes of types can't be compatible. */
967 if (TREE_CODE (t1
) != TREE_CODE (t2
))
970 /* Qualifiers must match. For array types, we will check when we
971 recur on the array element types. */
972 if (TREE_CODE (t1
) != ARRAY_TYPE
973 && TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
975 if (TYPE_FOR_JAVA (t1
) != TYPE_FOR_JAVA (t2
))
978 /* Allow for two different type nodes which have essentially the same
979 definition. Note that we already checked for equality of the type
980 qualifiers (just above). */
982 if (TREE_CODE (t1
) != ARRAY_TYPE
983 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
986 /* Compare the types. Break out if they could be the same. */
987 switch (TREE_CODE (t1
))
991 /* All void and bool types are the same. */
995 case FIXED_POINT_TYPE
:
997 /* With these nodes, we can't determine type equivalence by
998 looking at what is stored in the nodes themselves, because
999 two nodes might have different TYPE_MAIN_VARIANTs but still
1000 represent the same type. For example, wchar_t and int could
1001 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1002 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1003 and are distinct types. On the other hand, int and the
1006 typedef int INT __attribute((may_alias));
1008 have identical properties, different TYPE_MAIN_VARIANTs, but
1009 represent the same type. The canonical type system keeps
1010 track of equivalence in this case, so we fall back on it. */
1011 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1013 case TEMPLATE_TEMPLATE_PARM
:
1014 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1015 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
1016 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
)
1017 || (TEMPLATE_TYPE_PARAMETER_PACK (t1
)
1018 != TEMPLATE_TYPE_PARAMETER_PACK (t2
)))
1020 if (!comp_template_parms
1021 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1022 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1024 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1026 /* Don't check inheritance. */
1027 strict
= COMPARE_STRICT
;
1032 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1033 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1034 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
1035 && comp_template_args (TYPE_TI_ARGS (t1
), TYPE_TI_ARGS (t2
)))
1038 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1040 else if ((strict
& COMPARE_DERIVED
) && DERIVED_FROM_P (t2
, t1
))
1046 if (!comptypes (TYPE_OFFSET_BASETYPE (t1
), TYPE_OFFSET_BASETYPE (t2
),
1047 strict
& ~COMPARE_REDECLARATION
))
1049 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1053 case REFERENCE_TYPE
:
1054 if (TYPE_REF_IS_RVALUE (t1
) != TYPE_REF_IS_RVALUE (t2
))
1056 /* fall through to checks for pointer types */
1059 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1060 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
)
1061 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1067 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1069 if (!compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)))
1074 /* Target types must match incl. qualifiers. */
1075 if (!comp_array_types (t1
, t2
, !!(strict
& COMPARE_REDECLARATION
)))
1079 case TEMPLATE_TYPE_PARM
:
1080 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
1081 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
)
1082 || (TEMPLATE_TYPE_PARAMETER_PACK (t1
)
1083 != TEMPLATE_TYPE_PARAMETER_PACK (t2
)))
1088 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1089 TYPENAME_TYPE_FULLNAME (t2
)))
1091 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1095 case UNBOUND_CLASS_TEMPLATE
:
1096 if (!cp_tree_equal (TYPE_IDENTIFIER (t1
), TYPE_IDENTIFIER (t2
)))
1098 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1103 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1108 if (TYPE_VECTOR_SUBPARTS (t1
) != TYPE_VECTOR_SUBPARTS (t2
)
1109 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1113 case TYPE_PACK_EXPANSION
:
1114 return same_type_p (PACK_EXPANSION_PATTERN (t1
),
1115 PACK_EXPANSION_PATTERN (t2
));
1118 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1
)
1119 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2
)
1120 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1
),
1121 DECLTYPE_TYPE_EXPR (t2
)))
1129 /* If we get here, we know that from a target independent POV the
1130 types are the same. Make sure the target attributes are also
1132 return targetm
.comp_type_attributes (t1
, t2
);
1135 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1136 is a bitwise-or of the COMPARE_* flags. */
1139 comptypes (tree t1
, tree t2
, int strict
)
1141 if (strict
== COMPARE_STRICT
)
1146 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1149 if (TYPE_STRUCTURAL_EQUALITY_P (t1
) || TYPE_STRUCTURAL_EQUALITY_P (t2
))
1150 /* At least one of the types requires structural equality, so
1151 perform a deep check. */
1152 return structural_comptypes (t1
, t2
, strict
);
1154 #ifdef ENABLE_CHECKING
1155 if (USE_CANONICAL_TYPES
)
1157 bool result
= structural_comptypes (t1
, t2
, strict
);
1159 if (result
&& TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1160 /* The two types are structurally equivalent, but their
1161 canonical types were different. This is a failure of the
1162 canonical type propagation code.*/
1164 ("canonical types differ for identical types %T and %T",
1166 else if (!result
&& TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
1167 /* Two types are structurally different, but the canonical
1168 types are the same. This means we were over-eager in
1169 assigning canonical types. */
1171 ("same canonical type node for different types %T and %T",
1177 if (USE_CANONICAL_TYPES
)
1178 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1181 return structural_comptypes (t1
, t2
, strict
);
1183 else if (strict
== COMPARE_STRUCTURAL
)
1184 return structural_comptypes (t1
, t2
, COMPARE_STRICT
);
1186 return structural_comptypes (t1
, t2
, strict
);
1189 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1192 at_least_as_qualified_p (const_tree type1
, const_tree type2
)
1194 int q1
= cp_type_quals (type1
);
1195 int q2
= cp_type_quals (type2
);
1197 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1198 return (q1
& q2
) == q2
;
1201 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1202 more cv-qualified that TYPE1, and 0 otherwise. */
1205 comp_cv_qualification (const_tree type1
, const_tree type2
)
1207 int q1
= cp_type_quals (type1
);
1208 int q2
= cp_type_quals (type2
);
1213 if ((q1
& q2
) == q2
)
1215 else if ((q1
& q2
) == q1
)
1221 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1222 subset of the cv-qualification signature of TYPE2, and the types
1223 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1226 comp_cv_qual_signature (tree type1
, tree type2
)
1228 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1230 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1236 /* Subroutines of `comptypes'. */
1238 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1239 equivalent in the sense that functions with those parameter types
1240 can have equivalent types. The two lists must be equivalent,
1241 element by element. */
1244 compparms (const_tree parms1
, const_tree parms2
)
1248 /* An unspecified parmlist matches any specified parmlist
1249 whose argument types don't need default promotions. */
1251 for (t1
= parms1
, t2
= parms2
;
1253 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1255 /* If one parmlist is shorter than the other,
1256 they fail to match. */
1259 if (!same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1266 /* Process a sizeof or alignof expression where the operand is a
1270 cxx_sizeof_or_alignof_type (tree type
, enum tree_code op
, bool complain
)
1275 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
1276 if (type
== error_mark_node
)
1277 return error_mark_node
;
1279 type
= non_reference (type
);
1280 if (TREE_CODE (type
) == METHOD_TYPE
)
1283 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
1284 "invalid application of %qs to a member function",
1285 operator_name_info
[(int) op
].name
);
1286 value
= size_one_node
;
1289 dependent_p
= dependent_type_p (type
);
1291 complete_type (type
);
1293 /* VLA types will have a non-constant size. In the body of an
1294 uninstantiated template, we don't need to try to compute the
1295 value, because the sizeof expression is not an integral
1296 constant expression in that case. And, if we do try to
1297 compute the value, we'll likely end up with SAVE_EXPRs, which
1298 the template substitution machinery does not expect to see. */
1299 || (processing_template_decl
1300 && COMPLETE_TYPE_P (type
)
1301 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
1303 value
= build_min (op
, size_type_node
, type
);
1304 TREE_READONLY (value
) = 1;
1308 return c_sizeof_or_alignof_type (complete_type (type
),
1313 /* Return the size of the type, without producing any warnings for
1314 types whose size cannot be taken. This routine should be used only
1315 in some other routine that has already produced a diagnostic about
1316 using the size of such a type. */
1318 cxx_sizeof_nowarn (tree type
)
1320 if (TREE_CODE (type
) == FUNCTION_TYPE
1321 || TREE_CODE (type
) == VOID_TYPE
1322 || TREE_CODE (type
) == ERROR_MARK
)
1323 return size_one_node
;
1324 else if (!COMPLETE_TYPE_P (type
))
1325 return size_zero_node
;
1327 return cxx_sizeof_or_alignof_type (type
, SIZEOF_EXPR
, false);
1330 /* Process a sizeof expression where the operand is an expression. */
1333 cxx_sizeof_expr (tree e
, tsubst_flags_t complain
)
1335 if (e
== error_mark_node
)
1336 return error_mark_node
;
1338 if (processing_template_decl
)
1340 e
= build_min (SIZEOF_EXPR
, size_type_node
, e
);
1341 TREE_SIDE_EFFECTS (e
) = 0;
1342 TREE_READONLY (e
) = 1;
1347 if (TREE_CODE (e
) == COMPONENT_REF
1348 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
1349 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1351 if (complain
& tf_error
)
1352 error ("invalid application of %<sizeof%> to a bit-field");
1354 return error_mark_node
;
1357 else if (is_overloaded_fn (e
))
1359 if (complain
& tf_error
)
1360 permerror (input_location
, "ISO C++ forbids applying %<sizeof%> to an expression of "
1363 return error_mark_node
;
1366 else if (type_unknown_p (e
))
1368 if (complain
& tf_error
)
1369 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1371 return error_mark_node
;
1377 return cxx_sizeof_or_alignof_type (e
, SIZEOF_EXPR
, complain
& tf_error
);
1380 /* Implement the __alignof keyword: Return the minimum required
1381 alignment of E, measured in bytes. For VAR_DECL's and
1382 FIELD_DECL's return DECL_ALIGN (which can be set from an
1383 "aligned" __attribute__ specification). */
1386 cxx_alignof_expr (tree e
, tsubst_flags_t complain
)
1390 if (e
== error_mark_node
)
1391 return error_mark_node
;
1393 if (processing_template_decl
)
1395 e
= build_min (ALIGNOF_EXPR
, size_type_node
, e
);
1396 TREE_SIDE_EFFECTS (e
) = 0;
1397 TREE_READONLY (e
) = 1;
1402 if (TREE_CODE (e
) == VAR_DECL
)
1403 t
= size_int (DECL_ALIGN_UNIT (e
));
1404 else if (TREE_CODE (e
) == COMPONENT_REF
1405 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
1406 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1408 if (complain
& tf_error
)
1409 error ("invalid application of %<__alignof%> to a bit-field");
1411 return error_mark_node
;
1414 else if (TREE_CODE (e
) == COMPONENT_REF
1415 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
)
1416 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e
, 1)));
1417 else if (is_overloaded_fn (e
))
1419 if (complain
& tf_error
)
1420 permerror (input_location
, "ISO C++ forbids applying %<__alignof%> to an expression of "
1423 return error_mark_node
;
1424 if (TREE_CODE (e
) == FUNCTION_DECL
)
1425 t
= size_int (DECL_ALIGN_UNIT (e
));
1429 else if (type_unknown_p (e
))
1431 if (complain
& tf_error
)
1432 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1434 return error_mark_node
;
1438 return cxx_sizeof_or_alignof_type (TREE_TYPE (e
), ALIGNOF_EXPR
,
1439 complain
& tf_error
);
1441 return fold_convert (size_type_node
, t
);
1444 /* Process a sizeof or alignof expression E with code OP where the operand
1445 is an expression. */
1448 cxx_sizeof_or_alignof_expr (tree e
, enum tree_code op
, bool complain
)
1450 if (op
== SIZEOF_EXPR
)
1451 return cxx_sizeof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1453 return cxx_alignof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1456 /* EXPR is being used in a context that is not a function call.
1461 The expression can be used only as the left-hand operand of a
1462 member function call.
1464 [expr.mptr.operator]
1466 If the result of .* or ->* is a function, then that result can be
1467 used only as the operand for the function call operator ().
1469 by issuing an error message if appropriate. Returns true iff EXPR
1470 violates these rules. */
1473 invalid_nonstatic_memfn_p (const_tree expr
, tsubst_flags_t complain
)
1475 if (TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
)
1477 if (complain
& tf_error
)
1478 error ("invalid use of non-static member function");
1484 /* If EXP is a reference to a bitfield, and the type of EXP does not
1485 match the declared type of the bitfield, return the declared type
1486 of the bitfield. Otherwise, return NULL_TREE. */
1489 is_bitfield_expr_with_lowered_type (const_tree exp
)
1491 switch (TREE_CODE (exp
))
1494 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1)
1495 ? TREE_OPERAND (exp
, 1)
1496 : TREE_OPERAND (exp
, 0)))
1498 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 2));
1501 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1));
1505 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1511 field
= TREE_OPERAND (exp
, 1);
1512 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_BIT_FIELD_TYPE (field
))
1514 if (same_type_ignoring_top_level_qualifiers_p
1515 (TREE_TYPE (exp
), DECL_BIT_FIELD_TYPE (field
)))
1517 return DECL_BIT_FIELD_TYPE (field
);
1521 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp
, 0)))
1522 == TYPE_MAIN_VARIANT (TREE_TYPE (exp
)))
1523 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1531 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1532 bitfield with a lowered type, the type of EXP is returned, rather
1536 unlowered_expr_type (const_tree exp
)
1540 type
= is_bitfield_expr_with_lowered_type (exp
);
1542 type
= TREE_TYPE (exp
);
1547 /* Perform the conversions in [expr] that apply when an lvalue appears
1548 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1549 function-to-pointer conversions. In addition, manifest constants
1550 are replaced by their values, and bitfield references are converted
1551 to their declared types.
1553 Although the returned value is being used as an rvalue, this
1554 function does not wrap the returned expression in a
1555 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1556 that the return value is no longer an lvalue. */
1559 decay_conversion (tree exp
)
1562 enum tree_code code
;
1564 type
= TREE_TYPE (exp
);
1565 if (type
== error_mark_node
)
1566 return error_mark_node
;
1568 if (type_unknown_p (exp
))
1570 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
1571 return error_mark_node
;
1574 exp
= decl_constant_value (exp
);
1575 if (error_operand_p (exp
))
1576 return error_mark_node
;
1578 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1579 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1580 code
= TREE_CODE (type
);
1581 if (code
== VOID_TYPE
)
1583 error ("void value not ignored as it ought to be");
1584 return error_mark_node
;
1586 if (invalid_nonstatic_memfn_p (exp
, tf_warning_or_error
))
1587 return error_mark_node
;
1588 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1589 return cp_build_unary_op (ADDR_EXPR
, exp
, 0, tf_warning_or_error
);
1590 if (code
== ARRAY_TYPE
)
1595 if (TREE_CODE (exp
) == INDIRECT_REF
)
1596 return build_nop (build_pointer_type (TREE_TYPE (type
)),
1597 TREE_OPERAND (exp
, 0));
1599 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1601 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1602 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
1603 TREE_OPERAND (exp
, 0), op1
);
1607 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1609 error ("invalid use of non-lvalue array");
1610 return error_mark_node
;
1613 ptrtype
= build_pointer_type (TREE_TYPE (type
));
1615 if (TREE_CODE (exp
) == VAR_DECL
)
1617 if (!cxx_mark_addressable (exp
))
1618 return error_mark_node
;
1619 adr
= build_nop (ptrtype
, build_address (exp
));
1622 /* This way is better for a COMPONENT_REF since it can
1623 simplify the offset for a component. */
1624 adr
= cp_build_unary_op (ADDR_EXPR
, exp
, 1, tf_warning_or_error
);
1625 return cp_convert (ptrtype
, adr
);
1628 /* If a bitfield is used in a context where integral promotion
1629 applies, then the caller is expected to have used
1630 default_conversion. That function promotes bitfields correctly
1631 before calling this function. At this point, if we have a
1632 bitfield referenced, we may assume that is not subject to
1633 promotion, and that, therefore, the type of the resulting rvalue
1634 is the declared type of the bitfield. */
1635 exp
= convert_bitfield_to_declared_type (exp
);
1637 /* We do not call rvalue() here because we do not want to wrap EXP
1638 in a NON_LVALUE_EXPR. */
1642 Non-class rvalues always have cv-unqualified types. */
1643 type
= TREE_TYPE (exp
);
1644 if (!CLASS_TYPE_P (type
) && cp_type_quals (type
))
1645 exp
= build_nop (TYPE_MAIN_VARIANT (type
), exp
);
1650 /* Perform preparatory conversions, as part of the "usual arithmetic
1651 conversions". In particular, as per [expr]:
1653 Whenever an lvalue expression appears as an operand of an
1654 operator that expects the rvalue for that operand, the
1655 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1656 standard conversions are applied to convert the expression to an
1659 In addition, we perform integral promotions here, as those are
1660 applied to both operands to a binary operator before determining
1661 what additional conversions should apply. */
1664 default_conversion (tree exp
)
1666 /* Perform the integral promotions first so that bitfield
1667 expressions (which may promote to "int", even if the bitfield is
1668 declared "unsigned") are promoted correctly. */
1669 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp
)))
1670 exp
= perform_integral_promotions (exp
);
1671 /* Perform the other conversions. */
1672 exp
= decay_conversion (exp
);
1677 /* EXPR is an expression with an integral or enumeration type.
1678 Perform the integral promotions in [conv.prom], and return the
1682 perform_integral_promotions (tree expr
)
1689 If the bitfield has an enumerated type, it is treated as any
1690 other value of that type for promotion purposes. */
1691 type
= is_bitfield_expr_with_lowered_type (expr
);
1692 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
1693 type
= TREE_TYPE (expr
);
1694 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
1695 promoted_type
= type_promotes_to (type
);
1696 if (type
!= promoted_type
)
1697 expr
= cp_convert (promoted_type
, expr
);
1701 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1702 decay_conversion to one. */
1705 string_conv_p (const_tree totype
, const_tree exp
, int warn
)
1709 if (TREE_CODE (totype
) != POINTER_TYPE
)
1712 t
= TREE_TYPE (totype
);
1713 if (!same_type_p (t
, char_type_node
)
1714 && !same_type_p (t
, char16_type_node
)
1715 && !same_type_p (t
, char32_type_node
)
1716 && !same_type_p (t
, wchar_type_node
))
1719 if (TREE_CODE (exp
) == STRING_CST
)
1721 /* Make sure that we don't try to convert between char and wide chars. */
1722 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
1727 /* Is this a string constant which has decayed to 'const char *'? */
1728 t
= build_pointer_type (build_qualified_type (t
, TYPE_QUAL_CONST
));
1729 if (!same_type_p (TREE_TYPE (exp
), t
))
1732 if (TREE_CODE (exp
) != ADDR_EXPR
1733 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1737 /* This warning is not very useful, as it complains about printf. */
1739 warning (OPT_Wwrite_strings
,
1740 "deprecated conversion from string constant to %qT",
1746 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1747 can, for example, use as an lvalue. This code used to be in
1748 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1749 expressions, where we're dealing with aggregates. But now it's again only
1750 called from unary_complex_lvalue. The case (in particular) that led to
1751 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1755 rationalize_conditional_expr (enum tree_code code
, tree t
,
1756 tsubst_flags_t complain
)
1758 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1759 the first operand is always the one to be used if both operands
1760 are equal, so we know what conditional expression this used to be. */
1761 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1763 tree op0
= TREE_OPERAND (t
, 0);
1764 tree op1
= TREE_OPERAND (t
, 1);
1766 /* The following code is incorrect if either operand side-effects. */
1767 gcc_assert (!TREE_SIDE_EFFECTS (op0
)
1768 && !TREE_SIDE_EFFECTS (op1
));
1770 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1771 ? LE_EXPR
: GE_EXPR
),
1772 op0
, TREE_CODE (op0
),
1773 op1
, TREE_CODE (op1
),
1774 /*overloaded_p=*/NULL
,
1776 cp_build_unary_op (code
, op0
, 0, complain
),
1777 cp_build_unary_op (code
, op1
, 0, complain
),
1782 build_conditional_expr (TREE_OPERAND (t
, 0),
1783 cp_build_unary_op (code
, TREE_OPERAND (t
, 1), 0,
1785 cp_build_unary_op (code
, TREE_OPERAND (t
, 2), 0,
1790 /* Given the TYPE of an anonymous union field inside T, return the
1791 FIELD_DECL for the field. If not found return NULL_TREE. Because
1792 anonymous unions can nest, we must also search all anonymous unions
1793 that are directly reachable. */
1796 lookup_anon_field (tree t
, tree type
)
1800 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1802 if (TREE_STATIC (field
))
1804 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1807 /* If we find it directly, return the field. */
1808 if (DECL_NAME (field
) == NULL_TREE
1809 && type
== TYPE_MAIN_VARIANT (TREE_TYPE (field
)))
1814 /* Otherwise, it could be nested, search harder. */
1815 if (DECL_NAME (field
) == NULL_TREE
1816 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1818 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
1826 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1827 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1828 non-NULL, it indicates the path to the base used to name MEMBER.
1829 If PRESERVE_REFERENCE is true, the expression returned will have
1830 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1831 returned will have the type referred to by the reference.
1833 This function does not perform access control; that is either done
1834 earlier by the parser when the name of MEMBER is resolved to MEMBER
1835 itself, or later when overload resolution selects one of the
1836 functions indicated by MEMBER. */
1839 build_class_member_access_expr (tree object
, tree member
,
1840 tree access_path
, bool preserve_reference
,
1841 tsubst_flags_t complain
)
1845 tree result
= NULL_TREE
;
1847 if (error_operand_p (object
) || error_operand_p (member
))
1848 return error_mark_node
;
1850 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
1854 The type of the first expression shall be "class object" (of a
1856 object_type
= TREE_TYPE (object
);
1857 if (!currently_open_class (object_type
)
1858 && !complete_type_or_else (object_type
, object
))
1859 return error_mark_node
;
1860 if (!CLASS_TYPE_P (object_type
))
1862 if (complain
& tf_error
)
1863 error ("request for member %qD in %qE, which is of non-class type %qT",
1864 member
, object
, object_type
);
1865 return error_mark_node
;
1868 /* The standard does not seem to actually say that MEMBER must be a
1869 member of OBJECT_TYPE. However, that is clearly what is
1871 if (DECL_P (member
))
1873 member_scope
= DECL_CLASS_CONTEXT (member
);
1875 if (TREE_DEPRECATED (member
))
1876 warn_deprecated_use (member
);
1879 member_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (member
));
1880 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1881 presently be the anonymous union. Go outwards until we find a
1882 type related to OBJECT_TYPE. */
1883 while (ANON_AGGR_TYPE_P (member_scope
)
1884 && !same_type_ignoring_top_level_qualifiers_p (member_scope
,
1886 member_scope
= TYPE_CONTEXT (member_scope
);
1887 if (!member_scope
|| !DERIVED_FROM_P (member_scope
, object_type
))
1889 if (complain
& tf_error
)
1891 if (TREE_CODE (member
) == FIELD_DECL
)
1892 error ("invalid use of nonstatic data member %qE", member
);
1894 error ("%qD is not a member of %qT", member
, object_type
);
1896 return error_mark_node
;
1899 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1900 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1901 in the front end; only _DECLs and _REFs are lvalues in the back end. */
1903 tree temp
= unary_complex_lvalue (ADDR_EXPR
, object
);
1905 object
= cp_build_indirect_ref (temp
, NULL
, complain
);
1908 /* In [expr.ref], there is an explicit list of the valid choices for
1909 MEMBER. We check for each of those cases here. */
1910 if (TREE_CODE (member
) == VAR_DECL
)
1912 /* A static data member. */
1914 /* If OBJECT has side-effects, they are supposed to occur. */
1915 if (TREE_SIDE_EFFECTS (object
))
1916 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), object
, result
);
1918 else if (TREE_CODE (member
) == FIELD_DECL
)
1920 /* A non-static data member. */
1925 null_object_p
= (TREE_CODE (object
) == INDIRECT_REF
1926 && integer_zerop (TREE_OPERAND (object
, 0)));
1928 /* Convert OBJECT to the type of MEMBER. */
1929 if (!same_type_p (TYPE_MAIN_VARIANT (object_type
),
1930 TYPE_MAIN_VARIANT (member_scope
)))
1935 binfo
= lookup_base (access_path
? access_path
: object_type
,
1936 member_scope
, ba_unique
, &kind
);
1937 if (binfo
== error_mark_node
)
1938 return error_mark_node
;
1940 /* It is invalid to try to get to a virtual base of a
1941 NULL object. The most common cause is invalid use of
1943 if (null_object_p
&& kind
== bk_via_virtual
)
1945 if (complain
& tf_error
)
1947 error ("invalid access to non-static data member %qD of "
1950 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
1952 return error_mark_node
;
1955 /* Convert to the base. */
1956 object
= build_base_path (PLUS_EXPR
, object
, binfo
,
1958 /* If we found the base successfully then we should be able
1959 to convert to it successfully. */
1960 gcc_assert (object
!= error_mark_node
);
1963 /* Complain about other invalid uses of offsetof, even though they will
1964 give the right answer. Note that we complain whether or not they
1965 actually used the offsetof macro, since there's no way to know at this
1966 point. So we just give a warning, instead of a pedwarn. */
1967 /* Do not produce this warning for base class field references, because
1968 we know for a fact that didn't come from offsetof. This does occur
1969 in various testsuite cases where a null object is passed where a
1970 vtable access is required. */
1971 if (null_object_p
&& warn_invalid_offsetof
1972 && CLASSTYPE_NON_POD_P (object_type
)
1973 && !DECL_FIELD_IS_BASE (member
)
1975 && (complain
& tf_warning
))
1977 warning (OPT_Winvalid_offsetof
,
1978 "invalid access to non-static data member %qD "
1979 " of NULL object", member
);
1980 warning (OPT_Winvalid_offsetof
,
1981 "(perhaps the %<offsetof%> macro was used incorrectly)");
1984 /* If MEMBER is from an anonymous aggregate, we have converted
1985 OBJECT so that it refers to the class containing the
1986 anonymous union. Generate a reference to the anonymous union
1987 itself, and recur to find MEMBER. */
1988 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member
))
1989 /* When this code is called from build_field_call, the
1990 object already has the type of the anonymous union.
1991 That is because the COMPONENT_REF was already
1992 constructed, and was then disassembled before calling
1993 build_field_call. After the function-call code is
1994 cleaned up, this waste can be eliminated. */
1995 && (!same_type_ignoring_top_level_qualifiers_p
1996 (TREE_TYPE (object
), DECL_CONTEXT (member
))))
1998 tree anonymous_union
;
2000 anonymous_union
= lookup_anon_field (TREE_TYPE (object
),
2001 DECL_CONTEXT (member
));
2002 object
= build_class_member_access_expr (object
,
2004 /*access_path=*/NULL_TREE
,
2009 /* Compute the type of the field, as described in [expr.ref]. */
2010 type_quals
= TYPE_UNQUALIFIED
;
2011 member_type
= TREE_TYPE (member
);
2012 if (TREE_CODE (member_type
) != REFERENCE_TYPE
)
2014 type_quals
= (cp_type_quals (member_type
)
2015 | cp_type_quals (object_type
));
2017 /* A field is const (volatile) if the enclosing object, or the
2018 field itself, is const (volatile). But, a mutable field is
2019 not const, even within a const object. */
2020 if (DECL_MUTABLE_P (member
))
2021 type_quals
&= ~TYPE_QUAL_CONST
;
2022 member_type
= cp_build_qualified_type (member_type
, type_quals
);
2025 result
= build3 (COMPONENT_REF
, member_type
, object
, member
,
2027 result
= fold_if_not_in_template (result
);
2029 /* Mark the expression const or volatile, as appropriate. Even
2030 though we've dealt with the type above, we still have to mark the
2031 expression itself. */
2032 if (type_quals
& TYPE_QUAL_CONST
)
2033 TREE_READONLY (result
) = 1;
2034 if (type_quals
& TYPE_QUAL_VOLATILE
)
2035 TREE_THIS_VOLATILE (result
) = 1;
2037 else if (BASELINK_P (member
))
2039 /* The member is a (possibly overloaded) member function. */
2043 /* If the MEMBER is exactly one static member function, then we
2044 know the type of the expression. Otherwise, we must wait
2045 until overload resolution has been performed. */
2046 functions
= BASELINK_FUNCTIONS (member
);
2047 if (TREE_CODE (functions
) == FUNCTION_DECL
2048 && DECL_STATIC_FUNCTION_P (functions
))
2049 type
= TREE_TYPE (functions
);
2051 type
= unknown_type_node
;
2052 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2053 base. That will happen when the function is called. */
2054 result
= build3 (COMPONENT_REF
, type
, object
, member
, NULL_TREE
);
2056 else if (TREE_CODE (member
) == CONST_DECL
)
2058 /* The member is an enumerator. */
2060 /* If OBJECT has side-effects, they are supposed to occur. */
2061 if (TREE_SIDE_EFFECTS (object
))
2062 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
2067 if (complain
& tf_error
)
2068 error ("invalid use of %qD", member
);
2069 return error_mark_node
;
2072 if (!preserve_reference
)
2075 If E2 is declared to have type "reference to T", then ... the
2076 type of E1.E2 is T. */
2077 result
= convert_from_reference (result
);
2082 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
2083 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
2086 lookup_destructor (tree object
, tree scope
, tree dtor_name
)
2088 tree object_type
= TREE_TYPE (object
);
2089 tree dtor_type
= TREE_OPERAND (dtor_name
, 0);
2092 if (scope
&& !check_dtor_name (scope
, dtor_type
))
2094 error ("qualified type %qT does not match destructor name ~%qT",
2096 return error_mark_node
;
2098 if (!DERIVED_FROM_P (dtor_type
, TYPE_MAIN_VARIANT (object_type
)))
2100 error ("the type being destroyed is %qT, but the destructor refers to %qT",
2101 TYPE_MAIN_VARIANT (object_type
), dtor_type
);
2102 return error_mark_node
;
2104 expr
= lookup_member (dtor_type
, complete_dtor_identifier
,
2105 /*protect=*/1, /*want_type=*/false);
2106 expr
= (adjust_result_of_qualified_name_lookup
2107 (expr
, dtor_type
, object_type
));
2111 /* An expression of the form "A::template B" has been resolved to
2112 DECL. Issue a diagnostic if B is not a template or template
2116 check_template_keyword (tree decl
)
2118 /* The standard says:
2122 If a name prefixed by the keyword template is not a member
2123 template, the program is ill-formed.
2125 DR 228 removed the restriction that the template be a member
2128 DR 96, if accepted would add the further restriction that explicit
2129 template arguments must be provided if the template keyword is
2130 used, but, as of 2005-10-16, that DR is still in "drafting". If
2131 this DR is accepted, then the semantic checks here can be
2132 simplified, as the entity named must in fact be a template
2133 specialization, rather than, as at present, a set of overloaded
2134 functions containing at least one template function. */
2135 if (TREE_CODE (decl
) != TEMPLATE_DECL
2136 && TREE_CODE (decl
) != TEMPLATE_ID_EXPR
)
2138 if (!is_overloaded_fn (decl
))
2139 permerror (input_location
, "%qD is not a template", decl
);
2144 if (BASELINK_P (fns
))
2145 fns
= BASELINK_FUNCTIONS (fns
);
2148 tree fn
= OVL_CURRENT (fns
);
2149 if (TREE_CODE (fn
) == TEMPLATE_DECL
2150 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2152 if (TREE_CODE (fn
) == FUNCTION_DECL
2153 && DECL_USE_TEMPLATE (fn
)
2154 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
2156 fns
= OVL_NEXT (fns
);
2159 permerror (input_location
, "%qD is not a template", decl
);
2164 /* This function is called by the parser to process a class member
2165 access expression of the form OBJECT.NAME. NAME is a node used by
2166 the parser to represent a name; it is not yet a DECL. It may,
2167 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2168 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2169 there is no reason to do the lookup twice, so the parser keeps the
2170 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2171 be a template via the use of the "A::template B" syntax. */
2174 finish_class_member_access_expr (tree object
, tree name
, bool template_p
,
2175 tsubst_flags_t complain
)
2180 tree access_path
= NULL_TREE
;
2181 tree orig_object
= object
;
2182 tree orig_name
= name
;
2184 if (object
== error_mark_node
|| name
== error_mark_node
)
2185 return error_mark_node
;
2187 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2188 if (!objc_is_public (object
, name
))
2189 return error_mark_node
;
2191 object_type
= TREE_TYPE (object
);
2193 if (processing_template_decl
)
2195 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2196 dependent_type_p (object_type
)
2197 /* If NAME is just an IDENTIFIER_NODE, then the expression
2199 || TREE_CODE (object
) == IDENTIFIER_NODE
2200 /* If NAME is "f<args>", where either 'f' or 'args' is
2201 dependent, then the expression is dependent. */
2202 || (TREE_CODE (name
) == TEMPLATE_ID_EXPR
2203 && dependent_template_id_p (TREE_OPERAND (name
, 0),
2204 TREE_OPERAND (name
, 1)))
2205 /* If NAME is "T::X" where "T" is dependent, then the
2206 expression is dependent. */
2207 || (TREE_CODE (name
) == SCOPE_REF
2208 && TYPE_P (TREE_OPERAND (name
, 0))
2209 && dependent_type_p (TREE_OPERAND (name
, 0))))
2210 return build_min_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
2211 object
= build_non_dependent_expr (object
);
2216 The type of the first expression shall be "class object" (of a
2218 if (!currently_open_class (object_type
)
2219 && !complete_type_or_else (object_type
, object
))
2220 return error_mark_node
;
2221 if (!CLASS_TYPE_P (object_type
))
2223 if (complain
& tf_error
)
2224 error ("request for member %qD in %qE, which is of non-class type %qT",
2225 name
, object
, object_type
);
2226 return error_mark_node
;
2229 if (BASELINK_P (name
))
2230 /* A member function that has already been looked up. */
2234 bool is_template_id
= false;
2235 tree template_args
= NULL_TREE
;
2238 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2240 is_template_id
= true;
2241 template_args
= TREE_OPERAND (name
, 1);
2242 name
= TREE_OPERAND (name
, 0);
2244 if (TREE_CODE (name
) == OVERLOAD
)
2245 name
= DECL_NAME (get_first_fn (name
));
2246 else if (DECL_P (name
))
2247 name
= DECL_NAME (name
);
2250 if (TREE_CODE (name
) == SCOPE_REF
)
2252 /* A qualified name. The qualifying class or namespace `S'
2253 has already been looked up; it is either a TYPE or a
2255 scope
= TREE_OPERAND (name
, 0);
2256 name
= TREE_OPERAND (name
, 1);
2258 /* If SCOPE is a namespace, then the qualified name does not
2259 name a member of OBJECT_TYPE. */
2260 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
2262 if (complain
& tf_error
)
2263 error ("%<%D::%D%> is not a member of %qT",
2264 scope
, name
, object_type
);
2265 return error_mark_node
;
2268 gcc_assert (CLASS_TYPE_P (scope
));
2269 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
2270 || TREE_CODE (name
) == BIT_NOT_EXPR
);
2272 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2273 access_path
= lookup_base (object_type
, scope
, ba_check
, NULL
);
2274 if (access_path
== error_mark_node
)
2275 return error_mark_node
;
2278 if (complain
& tf_error
)
2279 error ("%qT is not a base of %qT", scope
, object_type
);
2280 return error_mark_node
;
2286 access_path
= object_type
;
2289 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2290 member
= lookup_destructor (object
, scope
, name
);
2293 /* Look up the member. */
2294 member
= lookup_member (access_path
, name
, /*protect=*/1,
2295 /*want_type=*/false);
2296 if (member
== NULL_TREE
)
2298 if (complain
& tf_error
)
2299 error ("%qD has no member named %qE", object_type
, name
);
2300 return error_mark_node
;
2302 if (member
== error_mark_node
)
2303 return error_mark_node
;
2308 tree templ
= member
;
2310 if (BASELINK_P (templ
))
2311 templ
= lookup_template_function (templ
, template_args
);
2314 if (complain
& tf_error
)
2315 error ("%qD is not a member template function", name
);
2316 return error_mark_node
;
2321 if (TREE_DEPRECATED (member
))
2322 warn_deprecated_use (member
);
2325 check_template_keyword (member
);
2327 expr
= build_class_member_access_expr (object
, member
, access_path
,
2328 /*preserve_reference=*/false,
2330 if (processing_template_decl
&& expr
!= error_mark_node
)
2332 if (BASELINK_P (member
))
2334 if (TREE_CODE (orig_name
) == SCOPE_REF
)
2335 BASELINK_QUALIFIED_P (member
) = 1;
2338 return build_min_non_dep (COMPONENT_REF
, expr
,
2339 orig_object
, orig_name
,
2346 /* Return an expression for the MEMBER_NAME field in the internal
2347 representation of PTRMEM, a pointer-to-member function. (Each
2348 pointer-to-member function type gets its own RECORD_TYPE so it is
2349 more convenient to access the fields by name than by FIELD_DECL.)
2350 This routine converts the NAME to a FIELD_DECL and then creates the
2351 node for the complete expression. */
2354 build_ptrmemfunc_access_expr (tree ptrmem
, tree member_name
)
2360 /* This code is a stripped down version of
2361 build_class_member_access_expr. It does not work to use that
2362 routine directly because it expects the object to be of class
2364 ptrmem_type
= TREE_TYPE (ptrmem
);
2365 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type
));
2366 member
= lookup_member (ptrmem_type
, member_name
, /*protect=*/0,
2367 /*want_type=*/false);
2368 member_type
= cp_build_qualified_type (TREE_TYPE (member
),
2369 cp_type_quals (ptrmem_type
));
2370 return fold_build3 (COMPONENT_REF
, member_type
,
2371 ptrmem
, member
, NULL_TREE
);
2374 /* Given an expression PTR for a pointer, return an expression
2375 for the value pointed to.
2376 ERRORSTRING is the name of the operator to appear in error messages.
2378 This function may need to overload OPERATOR_FNNAME.
2379 Must also handle REFERENCE_TYPEs for C++. */
2382 build_x_indirect_ref (tree expr
, const char *errorstring
,
2383 tsubst_flags_t complain
)
2385 tree orig_expr
= expr
;
2388 if (processing_template_decl
)
2390 if (type_dependent_expression_p (expr
))
2391 return build_min_nt (INDIRECT_REF
, expr
);
2392 expr
= build_non_dependent_expr (expr
);
2395 rval
= build_new_op (INDIRECT_REF
, LOOKUP_NORMAL
, expr
, NULL_TREE
,
2396 NULL_TREE
, /*overloaded_p=*/NULL
, complain
);
2398 rval
= cp_build_indirect_ref (expr
, errorstring
, complain
);
2400 if (processing_template_decl
&& rval
!= error_mark_node
)
2401 return build_min_non_dep (INDIRECT_REF
, rval
, orig_expr
);
2406 /* Helper function called from c-common. */
2408 build_indirect_ref (tree ptr
, const char *errorstring
)
2410 return cp_build_indirect_ref (ptr
, errorstring
, tf_warning_or_error
);
2414 cp_build_indirect_ref (tree ptr
, const char *errorstring
,
2415 tsubst_flags_t complain
)
2419 if (ptr
== error_mark_node
)
2420 return error_mark_node
;
2422 if (ptr
== current_class_ptr
)
2423 return current_class_ref
;
2425 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2426 ? ptr
: decay_conversion (ptr
));
2427 type
= TREE_TYPE (pointer
);
2429 if (POINTER_TYPE_P (type
))
2433 If the type of the expression is "pointer to T," the type
2434 of the result is "T."
2436 We must use the canonical variant because certain parts of
2437 the back end, like fold, do pointer comparisons between
2439 tree t
= canonical_type_variant (TREE_TYPE (type
));
2441 if (CONVERT_EXPR_P (ptr
)
2442 || TREE_CODE (ptr
) == VIEW_CONVERT_EXPR
)
2444 /* If a warning is issued, mark it to avoid duplicates from
2445 the backend. This only needs to be done at
2446 warn_strict_aliasing > 2. */
2447 if (warn_strict_aliasing
> 2)
2448 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr
, 0)),
2449 type
, TREE_OPERAND (ptr
, 0)))
2450 TREE_NO_WARNING (ptr
) = 1;
2453 if (VOID_TYPE_P (t
))
2455 /* A pointer to incomplete type (other than cv void) can be
2456 dereferenced [expr.unary.op]/1 */
2457 if (complain
& tf_error
)
2458 error ("%qT is not a pointer-to-object type", type
);
2459 return error_mark_node
;
2461 else if (TREE_CODE (pointer
) == ADDR_EXPR
2462 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
2463 /* The POINTER was something like `&x'. We simplify `*&x' to
2465 return TREE_OPERAND (pointer
, 0);
2468 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
2470 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2471 so that we get the proper error message if the result is used
2472 to assign to. Also, &* is supposed to be a no-op. */
2473 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
2474 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
2475 TREE_SIDE_EFFECTS (ref
)
2476 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
));
2480 else if (!(complain
& tf_error
))
2481 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
2483 /* `pointer' won't be an error_mark_node if we were given a
2484 pointer to member, so it's cool to check for this here. */
2485 else if (TYPE_PTR_TO_MEMBER_P (type
))
2486 error ("invalid use of %qs on pointer to member", errorstring
);
2487 else if (pointer
!= error_mark_node
)
2490 error ("invalid type argument of %qs", errorstring
);
2492 error ("invalid type argument");
2494 return error_mark_node
;
2497 /* This handles expressions of the form "a[i]", which denotes
2500 This is logically equivalent in C to *(a+i), but we may do it differently.
2501 If A is a variable or a member, we generate a primitive ARRAY_REF.
2502 This avoids forcing the array out of registers, and can work on
2503 arrays that are not lvalues (for example, members of structures returned
2506 If INDEX is of some user-defined type, it must be converted to
2507 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2508 will inherit the type of the array, which will be some pointer type. */
2511 build_array_ref (tree array
, tree idx
)
2515 error ("subscript missing in array reference");
2516 return error_mark_node
;
2519 if (TREE_TYPE (array
) == error_mark_node
2520 || TREE_TYPE (idx
) == error_mark_node
)
2521 return error_mark_node
;
2523 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2525 switch (TREE_CODE (array
))
2529 tree value
= build_array_ref (TREE_OPERAND (array
, 1), idx
);
2530 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
2531 TREE_OPERAND (array
, 0), value
);
2535 return build_conditional_expr
2536 (TREE_OPERAND (array
, 0),
2537 build_array_ref (TREE_OPERAND (array
, 1), idx
),
2538 build_array_ref (TREE_OPERAND (array
, 2), idx
),
2539 tf_warning_or_error
);
2545 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
2549 warn_array_subscript_with_type_char (idx
);
2551 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx
)))
2553 error ("array subscript is not an integer");
2554 return error_mark_node
;
2557 /* Apply integral promotions *after* noticing character types.
2558 (It is unclear why we do these promotions -- the standard
2559 does not say that we should. In fact, the natural thing would
2560 seem to be to convert IDX to ptrdiff_t; we're performing
2561 pointer arithmetic.) */
2562 idx
= perform_integral_promotions (idx
);
2564 /* An array that is indexed by a non-constant
2565 cannot be stored in a register; we must be able to do
2566 address arithmetic on its address.
2567 Likewise an array of elements of variable size. */
2568 if (TREE_CODE (idx
) != INTEGER_CST
2569 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
2570 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2573 if (!cxx_mark_addressable (array
))
2574 return error_mark_node
;
2577 /* An array that is indexed by a constant value which is not within
2578 the array bounds cannot be stored in a register either; because we
2579 would get a crash in store_bit_field/extract_bit_field when trying
2580 to access a non-existent part of the register. */
2581 if (TREE_CODE (idx
) == INTEGER_CST
2582 && TYPE_DOMAIN (TREE_TYPE (array
))
2583 && ! int_fits_type_p (idx
, TYPE_DOMAIN (TREE_TYPE (array
))))
2585 if (!cxx_mark_addressable (array
))
2586 return error_mark_node
;
2589 if (!lvalue_p (array
))
2590 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids subscripting non-lvalue array");
2592 /* Note in C++ it is valid to subscript a `register' array, since
2593 it is valid to take the address of something with that
2594 storage specification. */
2598 while (TREE_CODE (foo
) == COMPONENT_REF
)
2599 foo
= TREE_OPERAND (foo
, 0);
2600 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2601 warning (OPT_Wextra
, "subscripting array declared %<register%>");
2604 type
= TREE_TYPE (TREE_TYPE (array
));
2605 rval
= build4 (ARRAY_REF
, type
, array
, idx
, NULL_TREE
, NULL_TREE
);
2606 /* Array ref is const/volatile if the array elements are
2607 or if the array is.. */
2608 TREE_READONLY (rval
)
2609 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
2610 TREE_SIDE_EFFECTS (rval
)
2611 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
2612 TREE_THIS_VOLATILE (rval
)
2613 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
2614 return require_complete_type (fold_if_not_in_template (rval
));
2618 tree ar
= default_conversion (array
);
2619 tree ind
= default_conversion (idx
);
2621 /* Put the integer in IND to simplify error checking. */
2622 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2629 if (ar
== error_mark_node
)
2632 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2634 error ("subscripted value is neither array nor pointer");
2635 return error_mark_node
;
2637 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2639 error ("array subscript is not an integer");
2640 return error_mark_node
;
2643 warn_array_subscript_with_type_char (idx
);
2645 return cp_build_indirect_ref (cp_build_binary_op (PLUS_EXPR
, ar
, ind
,
2646 tf_warning_or_error
),
2648 tf_warning_or_error
);
2652 /* Resolve a pointer to member function. INSTANCE is the object
2653 instance to use, if the member points to a virtual member.
2655 This used to avoid checking for virtual functions if basetype
2656 has no virtual functions, according to an earlier ANSI draft.
2657 With the final ISO C++ rules, such an optimization is
2658 incorrect: A pointer to a derived member can be static_cast
2659 to pointer-to-base-member, as long as the dynamic object
2660 later has the right member. */
2663 get_member_function_from_ptrfunc (tree
*instance_ptrptr
, tree function
)
2665 if (TREE_CODE (function
) == OFFSET_REF
)
2666 function
= TREE_OPERAND (function
, 1);
2668 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2670 tree idx
, delta
, e1
, e2
, e3
, vtbl
, basetype
;
2671 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2673 tree instance_ptr
= *instance_ptrptr
;
2674 tree instance_save_expr
= 0;
2675 if (instance_ptr
== error_mark_node
)
2677 if (TREE_CODE (function
) == PTRMEM_CST
)
2679 /* Extracting the function address from a pmf is only
2680 allowed with -Wno-pmf-conversions. It only works for
2682 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
));
2683 e1
= convert (fntype
, e1
);
2688 error ("object missing in use of %qE", function
);
2689 return error_mark_node
;
2693 if (TREE_SIDE_EFFECTS (instance_ptr
))
2694 instance_ptr
= instance_save_expr
= save_expr (instance_ptr
);
2696 if (TREE_SIDE_EFFECTS (function
))
2697 function
= save_expr (function
);
2699 /* Start by extracting all the information from the PMF itself. */
2700 e3
= pfn_from_ptrmemfunc (function
);
2701 delta
= delta_from_ptrmemfunc (function
);
2702 idx
= build1 (NOP_EXPR
, vtable_index_type
, e3
);
2703 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
2705 case ptrmemfunc_vbit_in_pfn
:
2706 e1
= cp_build_binary_op (BIT_AND_EXPR
, idx
, integer_one_node
,
2707 tf_warning_or_error
);
2708 idx
= cp_build_binary_op (MINUS_EXPR
, idx
, integer_one_node
,
2709 tf_warning_or_error
);
2712 case ptrmemfunc_vbit_in_delta
:
2713 e1
= cp_build_binary_op (BIT_AND_EXPR
, delta
, integer_one_node
,
2714 tf_warning_or_error
);
2715 delta
= cp_build_binary_op (RSHIFT_EXPR
, delta
, integer_one_node
,
2716 tf_warning_or_error
);
2723 /* Convert down to the right base before using the instance. A
2724 special case is that in a pointer to member of class C, C may
2725 be incomplete. In that case, the function will of course be
2726 a member of C, and no conversion is required. In fact,
2727 lookup_base will fail in that case, because incomplete
2728 classes do not have BINFOs. */
2729 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2730 if (!same_type_ignoring_top_level_qualifiers_p
2731 (basetype
, TREE_TYPE (TREE_TYPE (instance_ptr
))))
2733 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr
)),
2734 basetype
, ba_check
, NULL
);
2735 instance_ptr
= build_base_path (PLUS_EXPR
, instance_ptr
, basetype
,
2737 if (instance_ptr
== error_mark_node
)
2738 return error_mark_node
;
2740 /* ...and then the delta in the PMF. */
2741 instance_ptr
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2742 instance_ptr
, fold_convert (sizetype
, delta
));
2744 /* Hand back the adjusted 'this' argument to our caller. */
2745 *instance_ptrptr
= instance_ptr
;
2747 /* Next extract the vtable pointer from the object. */
2748 vtbl
= build1 (NOP_EXPR
, build_pointer_type (vtbl_ptr_type_node
),
2750 vtbl
= cp_build_indirect_ref (vtbl
, NULL
, tf_warning_or_error
);
2752 /* Finally, extract the function pointer from the vtable. */
2753 e2
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (vtbl
), vtbl
,
2754 fold_convert (sizetype
, idx
));
2755 e2
= cp_build_indirect_ref (e2
, NULL
, tf_warning_or_error
);
2756 TREE_CONSTANT (e2
) = 1;
2758 /* When using function descriptors, the address of the
2759 vtable entry is treated as a function pointer. */
2760 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2761 e2
= build1 (NOP_EXPR
, TREE_TYPE (e2
),
2762 cp_build_unary_op (ADDR_EXPR
, e2
, /*noconvert=*/1,
2763 tf_warning_or_error
));
2765 e2
= fold_convert (TREE_TYPE (e3
), e2
);
2766 e1
= build_conditional_expr (e1
, e2
, e3
, tf_warning_or_error
);
2768 /* Make sure this doesn't get evaluated first inside one of the
2769 branches of the COND_EXPR. */
2770 if (instance_save_expr
)
2771 e1
= build2 (COMPOUND_EXPR
, TREE_TYPE (e1
),
2772 instance_save_expr
, e1
);
2779 /* Used by the C-common bits. */
2781 build_function_call (tree function
, tree params
)
2783 return cp_build_function_call (function
, params
, tf_warning_or_error
);
2787 cp_build_function_call (tree function
, tree params
, tsubst_flags_t complain
)
2789 tree fntype
, fndecl
;
2790 tree name
= NULL_TREE
;
2792 tree original
= function
;
2793 int nargs
, parm_types_len
;
2797 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2798 expressions, like those used for ObjC messenger dispatches. */
2799 function
= objc_rewrite_function_call (function
, params
);
2801 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2802 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2803 if (TREE_CODE (function
) == NOP_EXPR
2804 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2805 function
= TREE_OPERAND (function
, 0);
2807 if (TREE_CODE (function
) == FUNCTION_DECL
)
2809 name
= DECL_NAME (function
);
2811 mark_used (function
);
2814 /* Convert anything with function type to a pointer-to-function. */
2815 if (DECL_MAIN_P (function
) && (complain
& tf_error
))
2816 pedwarn (input_location
, OPT_pedantic
,
2817 "ISO C++ forbids calling %<::main%> from within program");
2819 function
= build_addr_func (function
);
2825 function
= build_addr_func (function
);
2828 if (function
== error_mark_node
)
2829 return error_mark_node
;
2831 fntype
= TREE_TYPE (function
);
2833 if (TYPE_PTRMEMFUNC_P (fntype
))
2835 if (complain
& tf_error
)
2836 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2837 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
2838 original
, original
);
2839 return error_mark_node
;
2842 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2843 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2845 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2846 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2848 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
2850 if (complain
& tf_error
)
2851 error ("%qE cannot be used as a function", original
);
2852 return error_mark_node
;
2855 /* fntype now gets the type of function pointed to. */
2856 fntype
= TREE_TYPE (fntype
);
2857 parm_types
= TYPE_ARG_TYPES (fntype
);
2859 /* Allocate storage for converted arguments. */
2860 parm_types_len
= list_length (parm_types
);
2861 nargs
= list_length (params
);
2862 if (parm_types_len
> nargs
)
2863 nargs
= parm_types_len
;
2864 argarray
= (tree
*) alloca (nargs
* sizeof (tree
));
2866 /* Convert the parameters to the types declared in the
2867 function prototype, or apply default promotions. */
2868 nargs
= convert_arguments (nargs
, argarray
, parm_types
,
2869 params
, fndecl
, LOOKUP_NORMAL
,
2872 return error_mark_node
;
2874 /* Check for errors in format strings and inappropriately
2876 check_function_arguments (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
,
2879 return build_cxx_call (function
, nargs
, argarray
);
2882 /* Convert the actual parameter expressions in the list VALUES
2883 to the types in the list TYPELIST.
2884 If parmdecls is exhausted, or when an element has NULL as its type,
2885 perform the default conversions.
2887 Store the converted arguments in ARGARRAY. NARGS is the size of this array.
2889 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2891 This is also where warnings about wrong number of args are generated.
2893 Returns the actual number of arguments processed (which might be less
2894 than NARGS), or -1 on error.
2896 VALUES is a chain of TREE_LIST nodes with the elements of the list
2897 in the TREE_VALUE slots of those nodes.
2899 In C++, unspecified trailing parameters can be filled in with their
2900 default arguments, if such were specified. Do so here. */
2903 convert_arguments (int nargs
, tree
*argarray
,
2904 tree typelist
, tree values
, tree fndecl
, int flags
,
2905 tsubst_flags_t complain
)
2907 tree typetail
, valtail
;
2908 const char *called_thing
= 0;
2911 /* Argument passing is always copy-initialization. */
2912 flags
|= LOOKUP_ONLYCONVERTING
;
2916 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2918 if (DECL_NAME (fndecl
) == NULL_TREE
2919 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2920 called_thing
= "constructor";
2922 called_thing
= "member function";
2925 called_thing
= "function";
2928 for (valtail
= values
, typetail
= typelist
;
2930 valtail
= TREE_CHAIN (valtail
), i
++)
2932 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2933 tree val
= TREE_VALUE (valtail
);
2935 if (val
== error_mark_node
|| type
== error_mark_node
)
2938 if (type
== void_type_node
)
2940 if (complain
& tf_error
)
2944 error ("too many arguments to %s %q+#D",
2945 called_thing
, fndecl
);
2946 error ("at this point in file");
2949 error ("too many arguments to function");
2956 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2957 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2958 if (TREE_CODE (val
) == NOP_EXPR
2959 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
2960 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
2961 val
= TREE_OPERAND (val
, 0);
2963 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
2965 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
2966 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
2967 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2968 val
= decay_conversion (val
);
2971 if (val
== error_mark_node
)
2976 /* Formal parm type is specified by a function prototype. */
2979 if (!COMPLETE_TYPE_P (complete_type (type
)))
2981 if (complain
& tf_error
)
2984 error ("parameter %P of %qD has incomplete type %qT",
2987 error ("parameter %P has incomplete type %qT", i
, type
);
2989 parmval
= error_mark_node
;
2993 parmval
= convert_for_initialization
2994 (NULL_TREE
, type
, val
, flags
,
2995 "argument passing", fndecl
, i
, complain
);
2996 parmval
= convert_for_arg_passing (type
, parmval
);
2999 if (parmval
== error_mark_node
)
3002 argarray
[i
] = parmval
;
3006 if (fndecl
&& DECL_BUILT_IN (fndecl
)
3007 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CONSTANT_P
)
3008 /* Don't do ellipsis conversion for __built_in_constant_p
3009 as this will result in spurious warnings for non-POD
3011 val
= require_complete_type (val
);
3013 val
= convert_arg_to_ellipsis (val
);
3019 typetail
= TREE_CHAIN (typetail
);
3022 if (typetail
!= 0 && typetail
!= void_list_node
)
3024 /* See if there are default arguments that can be used. Because
3025 we hold default arguments in the FUNCTION_TYPE (which is so
3026 wrong), we can see default parameters here from deduced
3027 contexts (and via typeof) for indirect function calls.
3028 Fortunately we know whether we have a function decl to
3029 provide default arguments in a language conformant
3031 if (fndecl
&& TREE_PURPOSE (typetail
)
3032 && TREE_CODE (TREE_PURPOSE (typetail
)) != DEFAULT_ARG
)
3034 for (; typetail
!= void_list_node
; ++i
)
3037 = convert_default_arg (TREE_VALUE (typetail
),
3038 TREE_PURPOSE (typetail
),
3041 if (parmval
== error_mark_node
)
3044 argarray
[i
] = parmval
;
3045 typetail
= TREE_CHAIN (typetail
);
3046 /* ends with `...'. */
3047 if (typetail
== NULL_TREE
)
3053 if (complain
& tf_error
)
3057 error ("too few arguments to %s %q+#D",
3058 called_thing
, fndecl
);
3059 error ("at this point in file");
3062 error ("too few arguments to function");
3068 gcc_assert (i
<= nargs
);
3072 /* Build a binary-operation expression, after performing default
3073 conversions on the operands. CODE is the kind of expression to
3074 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3075 are the tree codes which correspond to ARG1 and ARG2 when issuing
3076 warnings about possibly misplaced parentheses. They may differ
3077 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3078 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3079 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3080 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3081 ARG2_CODE as ERROR_MARK. */
3084 build_x_binary_op (enum tree_code code
, tree arg1
, enum tree_code arg1_code
,
3085 tree arg2
, enum tree_code arg2_code
, bool *overloaded_p
,
3086 tsubst_flags_t complain
)
3095 if (processing_template_decl
)
3097 if (type_dependent_expression_p (arg1
)
3098 || type_dependent_expression_p (arg2
))
3099 return build_min_nt (code
, arg1
, arg2
);
3100 arg1
= build_non_dependent_expr (arg1
);
3101 arg2
= build_non_dependent_expr (arg2
);
3104 if (code
== DOTSTAR_EXPR
)
3105 expr
= build_m_component_ref (arg1
, arg2
);
3107 expr
= build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
3108 overloaded_p
, complain
);
3110 /* Check for cases such as x+y<<z which users are likely to
3111 misinterpret. But don't warn about obj << x + y, since that is a
3112 common idiom for I/O. */
3113 if (warn_parentheses
3114 && !processing_template_decl
3115 && !error_operand_p (arg1
)
3116 && !error_operand_p (arg2
)
3117 && (code
!= LSHIFT_EXPR
3118 || !CLASS_TYPE_P (TREE_TYPE (arg1
))))
3119 warn_about_parentheses (code
, arg1_code
, arg2_code
);
3121 if (processing_template_decl
&& expr
!= error_mark_node
)
3122 return build_min_non_dep (code
, expr
, orig_arg1
, orig_arg2
);
3127 /* For the c-common bits. */
3129 build_binary_op (enum tree_code code
, tree op0
, tree op1
,
3130 int convert_p ATTRIBUTE_UNUSED
)
3132 return cp_build_binary_op(code
, op0
, op1
, tf_warning_or_error
);
3136 /* Build a binary-operation expression without default conversions.
3137 CODE is the kind of expression to build.
3138 This function differs from `build' in several ways:
3139 the data type of the result is computed and recorded in it,
3140 warnings are generated if arg data types are invalid,
3141 special handling for addition and subtraction of pointers is known,
3142 and some optimization is done (operations on narrow ints
3143 are done in the narrower type when that gives the same result).
3144 Constant folding is also done before the result is returned.
3146 Note that the operands will never have enumeral types
3147 because either they have just had the default conversions performed
3148 or they have both just been converted to some other type in which
3149 the arithmetic is to be done.
3151 C++: must do special pointer arithmetic when implementing
3152 multiple inheritance, and deal with pointer to member functions. */
3155 cp_build_binary_op (enum tree_code code
, tree orig_op0
, tree orig_op1
,
3156 tsubst_flags_t complain
)
3159 enum tree_code code0
, code1
;
3161 const char *invalid_op_diag
;
3163 /* Expression code to give to the expression when it is built.
3164 Normally this is CODE, which is what the caller asked for,
3165 but in some special cases we change it. */
3166 enum tree_code resultcode
= code
;
3168 /* Data type in which the computation is to be performed.
3169 In the simplest cases this is the common type of the arguments. */
3170 tree result_type
= NULL
;
3172 /* Nonzero means operands have already been type-converted
3173 in whatever way is necessary.
3174 Zero means they need to be converted to RESULT_TYPE. */
3177 /* Nonzero means create the expression with this type, rather than
3179 tree build_type
= 0;
3181 /* Nonzero means after finally constructing the expression
3182 convert it to this type. */
3183 tree final_type
= 0;
3187 /* Nonzero if this is an operation like MIN or MAX which can
3188 safely be computed in short if both args are promoted shorts.
3189 Also implies COMMON.
3190 -1 indicates a bitwise operation; this makes a difference
3191 in the exact conditions for when it is safe to do the operation
3192 in a narrower mode. */
3195 /* Nonzero if this is a comparison operation;
3196 if both args are promoted shorts, compare the original shorts.
3197 Also implies COMMON. */
3198 int short_compare
= 0;
3200 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3203 /* True if both operands have arithmetic type. */
3204 bool arithmetic_types_p
;
3206 /* Apply default conversions. */
3210 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3211 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3212 || code
== TRUTH_XOR_EXPR
)
3214 if (!really_overloaded_fn (op0
))
3215 op0
= decay_conversion (op0
);
3216 if (!really_overloaded_fn (op1
))
3217 op1
= decay_conversion (op1
);
3221 if (!really_overloaded_fn (op0
))
3222 op0
= default_conversion (op0
);
3223 if (!really_overloaded_fn (op1
))
3224 op1
= default_conversion (op1
);
3227 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3228 STRIP_TYPE_NOPS (op0
);
3229 STRIP_TYPE_NOPS (op1
);
3231 /* DTRT if one side is an overloaded function, but complain about it. */
3232 if (type_unknown_p (op0
))
3234 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, tf_none
);
3235 if (t
!= error_mark_node
)
3237 if (complain
& tf_error
)
3238 permerror (input_location
, "assuming cast to type %qT from overloaded function",
3243 if (type_unknown_p (op1
))
3245 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, tf_none
);
3246 if (t
!= error_mark_node
)
3248 if (complain
& tf_error
)
3249 permerror (input_location
, "assuming cast to type %qT from overloaded function",
3255 type0
= TREE_TYPE (op0
);
3256 type1
= TREE_TYPE (op1
);
3258 /* The expression codes of the data types of the arguments tell us
3259 whether the arguments are integers, floating, pointers, etc. */
3260 code0
= TREE_CODE (type0
);
3261 code1
= TREE_CODE (type1
);
3263 /* If an error was already reported for one of the arguments,
3264 avoid reporting another error. */
3266 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3267 return error_mark_node
;
3269 if ((invalid_op_diag
3270 = targetm
.invalid_binary_op (code
, type0
, type1
)))
3272 error (invalid_op_diag
);
3273 return error_mark_node
;
3279 /* Subtraction of two similar pointers.
3280 We must subtract them as integers, then divide by object size. */
3281 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3282 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
3284 return pointer_diff (op0
, op1
, common_type (type0
, type1
));
3285 /* In all other cases except pointer - int, the usual arithmetic
3287 else if (!(code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
))
3292 /* The pointer - int case is just like pointer + int; fall
3295 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
3296 && (code0
== INTEGER_TYPE
|| code1
== INTEGER_TYPE
))
3300 ptr_operand
= ((code0
== POINTER_TYPE
) ? op0
: op1
);
3301 int_operand
= ((code0
== INTEGER_TYPE
) ? op0
: op1
);
3302 if (processing_template_decl
)
3304 result_type
= TREE_TYPE (ptr_operand
);
3307 return cp_pointer_int_sum (code
,
3318 case TRUNC_DIV_EXPR
:
3320 case FLOOR_DIV_EXPR
:
3321 case ROUND_DIV_EXPR
:
3322 case EXACT_DIV_EXPR
:
3323 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3324 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
3325 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3326 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
3328 enum tree_code tcode0
= code0
, tcode1
= code1
;
3330 warn_for_div_by_zero (op1
);
3332 if (tcode0
== COMPLEX_TYPE
|| tcode0
== VECTOR_TYPE
)
3333 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
3334 if (tcode1
== COMPLEX_TYPE
|| tcode1
== VECTOR_TYPE
)
3335 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
3337 if (!(tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
))
3338 resultcode
= RDIV_EXPR
;
3340 /* When dividing two signed integers, we have to promote to int.
3341 unless we divide by a constant != -1. Note that default
3342 conversion will have been performed on the operands at this
3343 point, so we have to dig out the original type to find out if
3345 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3346 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3347 || (TREE_CODE (op1
) == INTEGER_CST
3348 && ! integer_all_onesp (op1
)));
3357 if ((code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3358 || (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
3359 && !VECTOR_FLOAT_TYPE_P (type0
)
3360 && !VECTOR_FLOAT_TYPE_P (type1
)))
3364 case TRUNC_MOD_EXPR
:
3365 case FLOOR_MOD_EXPR
:
3366 warn_for_div_by_zero (op1
);
3368 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3370 /* Although it would be tempting to shorten always here, that loses
3371 on some targets, since the modulo instruction is undefined if the
3372 quotient can't be represented in the computation mode. We shorten
3373 only if unsigned or if dividing by something we know != -1. */
3374 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3375 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3376 || (TREE_CODE (op1
) == INTEGER_CST
3377 && ! integer_all_onesp (op1
)));
3382 case TRUTH_ANDIF_EXPR
:
3383 case TRUTH_ORIF_EXPR
:
3384 case TRUTH_AND_EXPR
:
3386 result_type
= boolean_type_node
;
3389 /* Shift operations: result has same type as first operand;
3390 always convert second operand to int.
3391 Also set SHORT_SHIFT if shifting rightward. */
3394 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3396 result_type
= type0
;
3397 if (TREE_CODE (op1
) == INTEGER_CST
)
3399 if (tree_int_cst_lt (op1
, integer_zero_node
))
3401 if (complain
& tf_warning
)
3402 warning (0, "right shift count is negative");
3406 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0
3407 && (complain
& tf_warning
))
3408 warning (0, "right shift count >= width of type");
3411 /* Convert the shift-count to an integer, regardless of
3412 size of value being shifted. */
3413 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3414 op1
= cp_convert (integer_type_node
, op1
);
3415 /* Avoid converting op1 to result_type later. */
3421 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3423 result_type
= type0
;
3424 if (TREE_CODE (op1
) == INTEGER_CST
)
3426 if (tree_int_cst_lt (op1
, integer_zero_node
))
3428 if (complain
& tf_warning
)
3429 warning (0, "left shift count is negative");
3431 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3433 if (complain
& tf_warning
)
3434 warning (0, "left shift count >= width of type");
3437 /* Convert the shift-count to an integer, regardless of
3438 size of value being shifted. */
3439 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3440 op1
= cp_convert (integer_type_node
, op1
);
3441 /* Avoid converting op1 to result_type later. */
3448 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3450 result_type
= type0
;
3451 if (TREE_CODE (op1
) == INTEGER_CST
)
3453 if (tree_int_cst_lt (op1
, integer_zero_node
))
3455 if (complain
& tf_warning
)
3456 warning (0, (code
== LROTATE_EXPR
)
3457 ? G_("left rotate count is negative")
3458 : G_("right rotate count is negative"));
3460 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3462 if (complain
& tf_warning
)
3463 warning (0, (code
== LROTATE_EXPR
)
3464 ? G_("left rotate count >= width of type")
3465 : G_("right rotate count >= width of type"));
3468 /* Convert the shift-count to an integer, regardless of
3469 size of value being shifted. */
3470 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3471 op1
= cp_convert (integer_type_node
, op1
);
3477 if ((complain
& tf_warning
)
3478 && (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
)))
3479 warning (OPT_Wfloat_equal
,
3480 "comparing floating point with == or != is unsafe");
3481 if ((complain
& tf_warning
)
3482 && ((TREE_CODE (orig_op0
) == STRING_CST
&& !integer_zerop (op1
))
3483 || (TREE_CODE (orig_op1
) == STRING_CST
&& !integer_zerop (op0
))))
3484 warning (OPT_Waddress
, "comparison with string literal results in unspecified behaviour");
3486 build_type
= boolean_type_node
;
3487 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3488 || code0
== COMPLEX_TYPE
)
3489 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3490 || code1
== COMPLEX_TYPE
))
3492 else if ((code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3493 || (TYPE_PTRMEM_P (type0
) && TYPE_PTRMEM_P (type1
)))
3494 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3495 "comparison", complain
);
3496 else if ((code0
== POINTER_TYPE
|| TYPE_PTRMEM_P (type0
))
3497 && null_ptr_cst_p (op1
))
3499 if (TREE_CODE (op0
) == ADDR_EXPR
3500 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0)))
3502 if (complain
& tf_warning
)
3503 warning (OPT_Waddress
, "the address of %qD will never be NULL",
3504 TREE_OPERAND (op0
, 0));
3506 result_type
= type0
;
3508 else if ((code1
== POINTER_TYPE
|| TYPE_PTRMEM_P (type1
))
3509 && null_ptr_cst_p (op0
))
3511 if (TREE_CODE (op1
) == ADDR_EXPR
3512 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0)))
3514 if (complain
& tf_warning
)
3515 warning (OPT_Waddress
, "the address of %qD will never be NULL",
3516 TREE_OPERAND (op1
, 0));
3518 result_type
= type1
;
3520 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3522 result_type
= type0
;
3523 if (complain
& tf_error
)
3524 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3526 return error_mark_node
;
3528 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3530 result_type
= type1
;
3531 if (complain
& tf_error
)
3532 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3534 return error_mark_node
;
3536 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (op1
))
3538 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3539 == ptrmemfunc_vbit_in_delta
)
3541 tree pfn0
= pfn_from_ptrmemfunc (op0
);
3542 tree delta0
= delta_from_ptrmemfunc (op0
);
3543 tree e1
= cp_build_binary_op (EQ_EXPR
,
3545 fold_convert (TREE_TYPE (pfn0
),
3548 tree e2
= cp_build_binary_op (BIT_AND_EXPR
,
3552 e2
= cp_build_binary_op (EQ_EXPR
, e2
, integer_zero_node
,
3554 op0
= cp_build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
,
3556 op1
= cp_convert (TREE_TYPE (op0
), integer_one_node
);
3560 op0
= build_ptrmemfunc_access_expr (op0
, pfn_identifier
);
3561 op1
= cp_convert (TREE_TYPE (op0
), integer_zero_node
);
3563 result_type
= TREE_TYPE (op0
);
3565 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (op0
))
3566 return cp_build_binary_op (code
, op1
, op0
, complain
);
3567 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
))
3570 /* E will be the final comparison. */
3572 /* E1 and E2 are for scratch. */
3580 type
= composite_pointer_type (type0
, type1
, op0
, op1
, "comparison",
3583 if (!same_type_p (TREE_TYPE (op0
), type
))
3584 op0
= cp_convert_and_check (type
, op0
);
3585 if (!same_type_p (TREE_TYPE (op1
), type
))
3586 op1
= cp_convert_and_check (type
, op1
);
3588 if (op0
== error_mark_node
|| op1
== error_mark_node
)
3589 return error_mark_node
;
3591 if (TREE_SIDE_EFFECTS (op0
))
3592 op0
= save_expr (op0
);
3593 if (TREE_SIDE_EFFECTS (op1
))
3594 op1
= save_expr (op1
);
3596 pfn0
= pfn_from_ptrmemfunc (op0
);
3597 pfn1
= pfn_from_ptrmemfunc (op1
);
3598 delta0
= delta_from_ptrmemfunc (op0
);
3599 delta1
= delta_from_ptrmemfunc (op1
);
3600 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3601 == ptrmemfunc_vbit_in_delta
)
3606 && ((op0.delta == op1.delta)
3607 || (!op0.pfn && op0.delta & 1 == 0
3608 && op1.delta & 1 == 0))
3610 The reason for the `!op0.pfn' bit is that a NULL
3611 pointer-to-member is any member with a zero PFN and
3612 LSB of the DELTA field is 0. */
3614 e1
= cp_build_binary_op (BIT_AND_EXPR
,
3618 e1
= cp_build_binary_op (EQ_EXPR
, e1
, integer_zero_node
,
3620 e2
= cp_build_binary_op (BIT_AND_EXPR
,
3624 e2
= cp_build_binary_op (EQ_EXPR
, e2
, integer_zero_node
,
3626 e1
= cp_build_binary_op (TRUTH_ANDIF_EXPR
, e2
, e1
,
3628 e2
= cp_build_binary_op (EQ_EXPR
,
3630 fold_convert (TREE_TYPE (pfn0
),
3633 e2
= cp_build_binary_op (TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
3634 e1
= cp_build_binary_op (EQ_EXPR
, delta0
, delta1
, complain
);
3635 e1
= cp_build_binary_op (TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
3642 && (!op0.pfn || op0.delta == op1.delta))
3644 The reason for the `!op0.pfn' bit is that a NULL
3645 pointer-to-member is any member with a zero PFN; the
3646 DELTA field is unspecified. */
3648 e1
= cp_build_binary_op (EQ_EXPR
, delta0
, delta1
, complain
);
3649 e2
= cp_build_binary_op (EQ_EXPR
,
3651 fold_convert (TREE_TYPE (pfn0
),
3654 e1
= cp_build_binary_op (TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
3656 e2
= build2 (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
3657 e
= cp_build_binary_op (TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
3658 if (code
== EQ_EXPR
)
3660 return cp_build_binary_op (EQ_EXPR
, e
, integer_zero_node
, complain
);
3664 gcc_assert (!TYPE_PTRMEMFUNC_P (type0
)
3665 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
),
3667 gcc_assert (!TYPE_PTRMEMFUNC_P (type1
)
3668 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
),
3676 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3677 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3679 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3680 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3681 "comparison", complain
);
3688 if (TREE_CODE (orig_op0
) == STRING_CST
3689 || TREE_CODE (orig_op1
) == STRING_CST
)
3691 if (complain
& tf_warning
)
3692 warning (OPT_Waddress
, "comparison with string literal results in unspecified behaviour");
3695 build_type
= boolean_type_node
;
3696 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3697 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3699 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3700 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3701 "comparison", complain
);
3702 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3703 && integer_zerop (op1
))
3704 result_type
= type0
;
3705 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3706 && integer_zerop (op0
))
3707 result_type
= type1
;
3708 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3710 result_type
= type0
;
3711 if (complain
& tf_error
)
3712 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3714 return error_mark_node
;
3716 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3718 result_type
= type1
;
3719 if (complain
& tf_error
)
3720 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3722 return error_mark_node
;
3726 case UNORDERED_EXPR
:
3733 build_type
= integer_type_node
;
3734 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
3736 if (complain
& tf_error
)
3737 error ("unordered comparison on non-floating point argument");
3738 return error_mark_node
;
3747 if (((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
3748 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3749 || code1
== COMPLEX_TYPE
)))
3750 arithmetic_types_p
= 1;
3753 arithmetic_types_p
= 0;
3754 /* Vector arithmetic is only allowed when both sides are vectors. */
3755 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
3757 if (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
3758 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0
),
3761 binary_op_error (code
, type0
, type1
);
3762 return error_mark_node
;
3764 arithmetic_types_p
= 1;
3767 /* Determine the RESULT_TYPE, if it is not already known. */
3769 && arithmetic_types_p
3770 && (shorten
|| common
|| short_compare
))
3771 result_type
= common_type (type0
, type1
);
3775 if (complain
& tf_error
)
3776 error ("invalid operands of types %qT and %qT to binary %qO",
3777 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
3778 return error_mark_node
;
3781 /* If we're in a template, the only thing we need to know is the
3783 if (processing_template_decl
)
3785 /* Since the middle-end checks the type when doing a build2, we
3786 need to build the tree in pieces. This built tree will never
3787 get out of the front-end as we replace it when instantiating
3789 tree tmp
= build2 (resultcode
,
3790 build_type
? build_type
: result_type
,
3792 TREE_OPERAND (tmp
, 0) = op0
;
3796 if (arithmetic_types_p
)
3798 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
3800 /* For certain operations (which identify themselves by shorten != 0)
3801 if both args were extended from the same smaller type,
3802 do the arithmetic in that type and then extend.
3804 shorten !=0 and !=1 indicates a bitwise operation.
3805 For them, this optimization is safe only if
3806 both args are zero-extended or both are sign-extended.
3807 Otherwise, we might change the result.
3808 E.g., (short)-1 | (unsigned short)-1 is (int)-1
3809 but calculated in (unsigned short) it would be (unsigned short)-1. */
3811 if (shorten
&& none_complex
)
3813 final_type
= result_type
;
3814 result_type
= shorten_binary_op (result_type
, op0
, op1
,
3818 /* Comparison operations are shortened too but differently.
3819 They identify themselves by setting short_compare = 1. */
3823 /* Don't write &op0, etc., because that would prevent op0
3824 from being kept in a register.
3825 Instead, make copies of the our local variables and
3826 pass the copies by reference, then copy them back afterward. */
3827 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3828 enum tree_code xresultcode
= resultcode
;
3830 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3832 return cp_convert (boolean_type_node
, val
);
3833 op0
= xop0
, op1
= xop1
;
3835 resultcode
= xresultcode
;
3838 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
3839 && warn_sign_compare
3840 /* Do not warn until the template is instantiated; we cannot
3841 bound the ranges of the arguments until that point. */
3842 && !processing_template_decl
3843 && (complain
& tf_warning
))
3845 warn_for_sign_compare (orig_op0
, orig_op1
, op0
, op1
,
3846 result_type
, resultcode
);
3850 /* Issue warnings about peculiar, but valid, uses of NULL. */
3851 if ((orig_op0
== null_node
|| orig_op1
== null_node
)
3852 /* It's reasonable to use pointer values as operands of &&
3853 and ||, so NULL is no exception. */
3854 && code
!= TRUTH_ANDIF_EXPR
&& code
!= TRUTH_ORIF_EXPR
3855 && ( /* Both are NULL (or 0) and the operation was not a comparison. */
3856 (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)
3857 && code
!= EQ_EXPR
&& code
!= NE_EXPR
)
3858 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
3859 || (!null_ptr_cst_p (orig_op0
) && TREE_CODE (TREE_TYPE (op0
)) != POINTER_TYPE
)
3860 || (!null_ptr_cst_p (orig_op1
) && TREE_CODE (TREE_TYPE (op1
)) != POINTER_TYPE
))
3861 && (complain
& tf_warning
))
3862 /* Some sort of arithmetic operation involving NULL was
3863 performed. Note that pointer-difference and pointer-addition
3864 have already been handled above, and so we don't end up here in
3866 warning (OPT_Wpointer_arith
, "NULL used in arithmetic");
3869 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3870 Then the expression will be built.
3871 It will be given type FINAL_TYPE if that is nonzero;
3872 otherwise, it will be given type RESULT_TYPE. */
3875 if (TREE_TYPE (op0
) != result_type
)
3876 op0
= cp_convert_and_check (result_type
, op0
);
3877 if (TREE_TYPE (op1
) != result_type
)
3878 op1
= cp_convert_and_check (result_type
, op1
);
3880 if (op0
== error_mark_node
|| op1
== error_mark_node
)
3881 return error_mark_node
;
3884 if (build_type
== NULL_TREE
)
3885 build_type
= result_type
;
3887 result
= build2 (resultcode
, build_type
, op0
, op1
);
3888 result
= fold_if_not_in_template (result
);
3889 if (final_type
!= 0)
3890 result
= cp_convert (final_type
, result
);
3892 if (TREE_OVERFLOW_P (result
)
3893 && !TREE_OVERFLOW_P (op0
)
3894 && !TREE_OVERFLOW_P (op1
))
3895 overflow_warning (result
);
3900 /* Return a tree for the sum or difference (RESULTCODE says which)
3901 of pointer PTROP and integer INTOP. */
3904 cp_pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
3906 tree res_type
= TREE_TYPE (ptrop
);
3908 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3909 in certain circumstance (when it's valid to do so). So we need
3910 to make sure it's complete. We don't need to check here, if we
3911 can actually complete it at all, as those checks will be done in
3912 pointer_int_sum() anyway. */
3913 complete_type (TREE_TYPE (res_type
));
3915 return pointer_int_sum (resultcode
, ptrop
,
3916 fold_if_not_in_template (intop
));
3919 /* Return a tree for the difference of pointers OP0 and OP1.
3920 The resulting tree has type int. */
3923 pointer_diff (tree op0
, tree op1
, tree ptrtype
)
3926 tree restype
= ptrdiff_type_node
;
3927 tree target_type
= TREE_TYPE (ptrtype
);
3929 if (!complete_type_or_else (target_type
, NULL_TREE
))
3930 return error_mark_node
;
3932 if (TREE_CODE (target_type
) == VOID_TYPE
)
3933 permerror (input_location
, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
3934 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3935 permerror (input_location
, "ISO C++ forbids using pointer to a function in subtraction");
3936 if (TREE_CODE (target_type
) == METHOD_TYPE
)
3937 permerror (input_location
, "ISO C++ forbids using pointer to a method in subtraction");
3939 /* First do the subtraction as integers;
3940 then drop through to build the divide operator. */
3942 op0
= cp_build_binary_op (MINUS_EXPR
,
3943 cp_convert (restype
, op0
),
3944 cp_convert (restype
, op1
),
3945 tf_warning_or_error
);
3947 /* This generates an error if op1 is a pointer to an incomplete type. */
3948 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
3949 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3951 op1
= (TYPE_PTROB_P (ptrtype
)
3952 ? size_in_bytes (target_type
)
3953 : integer_one_node
);
3955 /* Do the division. */
3957 result
= build2 (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
3958 return fold_if_not_in_template (result
);
3961 /* Construct and perhaps optimize a tree representation
3962 for a unary operation. CODE, a tree_code, specifies the operation
3963 and XARG is the operand. */
3966 build_x_unary_op (enum tree_code code
, tree xarg
, tsubst_flags_t complain
)
3968 tree orig_expr
= xarg
;
3972 if (processing_template_decl
)
3974 if (type_dependent_expression_p (xarg
))
3975 return build_min_nt (code
, xarg
, NULL_TREE
);
3977 xarg
= build_non_dependent_expr (xarg
);
3982 /* [expr.unary.op] says:
3984 The address of an object of incomplete type can be taken.
3986 (And is just the ordinary address operator, not an overloaded
3987 "operator &".) However, if the type is a template
3988 specialization, we must complete the type at this point so that
3989 an overloaded "operator &" will be available if required. */
3990 if (code
== ADDR_EXPR
3991 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
3992 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
3993 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
3994 || (TREE_CODE (xarg
) == OFFSET_REF
)))
3995 /* Don't look for a function. */;
3997 exp
= build_new_op (code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
, NULL_TREE
,
3998 /*overloaded_p=*/NULL
, complain
);
3999 if (!exp
&& code
== ADDR_EXPR
)
4001 /* A pointer to member-function can be formed only by saying
4003 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
4004 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
4006 if (TREE_CODE (xarg
) != OFFSET_REF
4007 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
4009 error ("invalid use of %qE to form a pointer-to-member-function",
4011 if (TREE_CODE (xarg
) != OFFSET_REF
)
4012 inform (input_location
, " a qualified-id is required");
4013 return error_mark_node
;
4017 error ("parentheses around %qE cannot be used to form a"
4018 " pointer-to-member-function",
4020 PTRMEM_OK_P (xarg
) = 1;
4024 if (TREE_CODE (xarg
) == OFFSET_REF
)
4026 ptrmem
= PTRMEM_OK_P (xarg
);
4028 if (!ptrmem
&& !flag_ms_extensions
4029 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
4031 /* A single non-static member, make sure we don't allow a
4032 pointer-to-member. */
4033 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
4034 TREE_OPERAND (xarg
, 0),
4035 ovl_cons (TREE_OPERAND (xarg
, 1), NULL_TREE
));
4036 PTRMEM_OK_P (xarg
) = ptrmem
;
4039 else if (TREE_CODE (xarg
) == TARGET_EXPR
&& (complain
& tf_warning
))
4040 warning (0, "taking address of temporary");
4041 exp
= cp_build_unary_op (ADDR_EXPR
, xarg
, 0, complain
);
4044 if (processing_template_decl
&& exp
!= error_mark_node
)
4045 exp
= build_min_non_dep (code
, exp
, orig_expr
,
4046 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
4047 if (TREE_CODE (exp
) == ADDR_EXPR
)
4048 PTRMEM_OK_P (exp
) = ptrmem
;
4052 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4053 constants, where a null value is represented by an INTEGER_CST of
4057 cp_truthvalue_conversion (tree expr
)
4059 tree type
= TREE_TYPE (expr
);
4060 if (TYPE_PTRMEM_P (type
))
4061 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
4063 return c_common_truthvalue_conversion (expr
);
4066 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4069 condition_conversion (tree expr
)
4072 if (processing_template_decl
)
4074 t
= perform_implicit_conversion (boolean_type_node
, expr
,
4075 tf_warning_or_error
);
4076 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
4080 /* Return an ADDR_EXPR giving the address of T. This function
4081 attempts no optimizations or simplifications; it is a low-level
4085 build_address (tree t
)
4089 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
4090 return error_mark_node
;
4092 addr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (t
)), t
);
4097 /* Return a NOP_EXPR converting EXPR to TYPE. */
4100 build_nop (tree type
, tree expr
)
4102 if (type
== error_mark_node
|| error_operand_p (expr
))
4104 return build1 (NOP_EXPR
, type
, expr
);
4107 /* C++: Must handle pointers to members.
4109 Perhaps type instantiation should be extended to handle conversion
4110 from aggregates to types we don't yet know we want? (Or are those
4111 cases typically errors which should be reported?)
4113 NOCONVERT nonzero suppresses the default promotions
4114 (such as from short to int). */
4117 cp_build_unary_op (enum tree_code code
, tree xarg
, int noconvert
,
4118 tsubst_flags_t complain
)
4120 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4123 const char *errstring
= NULL
;
4125 const char *invalid_op_diag
;
4127 if (arg
== error_mark_node
)
4128 return error_mark_node
;
4130 if ((invalid_op_diag
4131 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
4136 error (invalid_op_diag
);
4137 return error_mark_node
;
4142 case UNARY_PLUS_EXPR
:
4145 int flags
= WANT_ARITH
| WANT_ENUM
;
4146 /* Unary plus (but not unary minus) is allowed on pointers. */
4147 if (code
== UNARY_PLUS_EXPR
)
4148 flags
|= WANT_POINTER
;
4149 arg
= build_expr_type_conversion (flags
, arg
, true);
4151 errstring
= (code
== NEGATE_EXPR
4152 ? "wrong type argument to unary minus"
4153 : "wrong type argument to unary plus");
4156 if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
4157 arg
= perform_integral_promotions (arg
);
4159 /* Make sure the result is not an lvalue: a unary plus or minus
4160 expression is always a rvalue. */
4167 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4171 arg
= default_conversion (arg
);
4173 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
4176 errstring
= "wrong type argument to bit-complement";
4177 else if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
4178 arg
= perform_integral_promotions (arg
);
4182 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
4183 errstring
= "wrong type argument to abs";
4184 else if (!noconvert
)
4185 arg
= default_conversion (arg
);
4189 /* Conjugating a real value is a no-op, but allow it anyway. */
4190 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
4191 errstring
= "wrong type argument to conjugation";
4192 else if (!noconvert
)
4193 arg
= default_conversion (arg
);
4196 case TRUTH_NOT_EXPR
:
4197 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
4199 val
= invert_truthvalue (arg
);
4200 if (arg
!= error_mark_node
)
4202 errstring
= "in argument to unary !";
4209 if (TREE_CODE (arg
) == COMPLEX_CST
)
4210 return TREE_REALPART (arg
);
4211 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4213 arg
= build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
4214 return fold_if_not_in_template (arg
);
4220 if (TREE_CODE (arg
) == COMPLEX_CST
)
4221 return TREE_IMAGPART (arg
);
4222 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4224 arg
= build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
4225 return fold_if_not_in_template (arg
);
4228 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4230 case PREINCREMENT_EXPR
:
4231 case POSTINCREMENT_EXPR
:
4232 case PREDECREMENT_EXPR
:
4233 case POSTDECREMENT_EXPR
:
4234 /* Handle complex lvalues (when permitted)
4235 by reduction to simpler cases. */
4237 val
= unary_complex_lvalue (code
, arg
);
4241 /* Increment or decrement the real part of the value,
4242 and don't change the imaginary part. */
4243 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4247 arg
= stabilize_reference (arg
);
4248 real
= cp_build_unary_op (REALPART_EXPR
, arg
, 1, complain
);
4249 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, 1, complain
);
4250 real
= cp_build_unary_op (code
, real
, 1, complain
);
4251 if (real
== error_mark_node
|| imag
== error_mark_node
)
4252 return error_mark_node
;
4253 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
4257 /* Report invalid types. */
4259 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4262 if (code
== PREINCREMENT_EXPR
)
4263 errstring
="no pre-increment operator for type";
4264 else if (code
== POSTINCREMENT_EXPR
)
4265 errstring
="no post-increment operator for type";
4266 else if (code
== PREDECREMENT_EXPR
)
4267 errstring
="no pre-decrement operator for type";
4269 errstring
="no post-decrement operator for type";
4272 else if (arg
== error_mark_node
)
4273 return error_mark_node
;
4275 /* Report something read-only. */
4277 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
4278 || TREE_READONLY (arg
))
4280 if (complain
& tf_error
)
4281 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4282 || code
== POSTINCREMENT_EXPR
)
4283 ? "increment" : "decrement"));
4285 return error_mark_node
;
4291 tree result_type
= TREE_TYPE (arg
);
4293 declared_type
= unlowered_expr_type (arg
);
4295 arg
= get_unwidened (arg
, 0);
4296 argtype
= TREE_TYPE (arg
);
4298 /* ARM $5.2.5 last annotation says this should be forbidden. */
4299 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4301 if (complain
& tf_error
)
4302 permerror (input_location
, (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4303 ? G_("ISO C++ forbids incrementing an enum")
4304 : G_("ISO C++ forbids decrementing an enum"));
4306 return error_mark_node
;
4309 /* Compute the increment. */
4311 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4313 tree type
= complete_type (TREE_TYPE (argtype
));
4315 if (!COMPLETE_OR_VOID_TYPE_P (type
))
4317 if (complain
& tf_error
)
4318 error (((code
== PREINCREMENT_EXPR
4319 || code
== POSTINCREMENT_EXPR
))
4320 ? G_("cannot increment a pointer to incomplete type %qT")
4321 : G_("cannot decrement a pointer to incomplete type %qT"),
4322 TREE_TYPE (argtype
));
4324 return error_mark_node
;
4326 else if ((pedantic
|| warn_pointer_arith
)
4327 && !TYPE_PTROB_P (argtype
))
4329 if (complain
& tf_error
)
4330 permerror (input_location
, (code
== PREINCREMENT_EXPR
4331 || code
== POSTINCREMENT_EXPR
)
4332 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4333 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4336 return error_mark_node
;
4339 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
4342 inc
= integer_one_node
;
4344 inc
= cp_convert (argtype
, inc
);
4346 /* Complain about anything else that is not a true lvalue. */
4347 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4348 || code
== POSTINCREMENT_EXPR
)
4349 ? lv_increment
: lv_decrement
),
4351 return error_mark_node
;
4353 /* Forbid using -- on `bool'. */
4354 if (same_type_p (declared_type
, boolean_type_node
))
4356 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4358 if (complain
& tf_error
)
4359 error ("invalid use of Boolean expression as operand "
4360 "to %<operator--%>");
4361 return error_mark_node
;
4363 val
= boolean_increment (code
, arg
);
4366 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
4368 TREE_SIDE_EFFECTS (val
) = 1;
4369 return cp_convert (result_type
, val
);
4373 /* Note that this operation never does default_conversion
4374 regardless of NOCONVERT. */
4376 argtype
= lvalue_type (arg
);
4378 if (TREE_CODE (arg
) == OFFSET_REF
)
4381 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4383 tree type
= build_pointer_type (TREE_TYPE (argtype
));
4384 arg
= build1 (CONVERT_EXPR
, type
, arg
);
4387 else if (DECL_MAIN_P (arg
))
4390 if (complain
& tf_error
)
4391 permerror (input_location
, "ISO C++ forbids taking address of function %<::main%>");
4393 return error_mark_node
;
4396 /* Let &* cancel out to simplify resulting code. */
4397 if (TREE_CODE (arg
) == INDIRECT_REF
)
4399 /* We don't need to have `current_class_ptr' wrapped in a
4400 NON_LVALUE_EXPR node. */
4401 if (arg
== current_class_ref
)
4402 return current_class_ptr
;
4404 arg
= TREE_OPERAND (arg
, 0);
4405 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4407 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
4408 arg
= build1 (CONVERT_EXPR
, type
, arg
);
4411 /* Don't let this be an lvalue. */
4416 /* Uninstantiated types are all functions. Taking the
4417 address of a function is a no-op, so just return the
4420 gcc_assert (TREE_CODE (arg
) != IDENTIFIER_NODE
4421 || !IDENTIFIER_OPNAME_P (arg
));
4423 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
4424 && !really_overloaded_fn (TREE_OPERAND (arg
, 1)))
4426 /* They're trying to take the address of a unique non-static
4427 member function. This is ill-formed (except in MS-land),
4428 but let's try to DTRT.
4429 Note: We only handle unique functions here because we don't
4430 want to complain if there's a static overload; non-unique
4431 cases will be handled by instantiate_type. But we need to
4432 handle this case here to allow casts on the resulting PMF.
4433 We could defer this in non-MS mode, but it's easier to give
4434 a useful error here. */
4436 /* Inside constant member functions, the `this' pointer
4437 contains an extra const qualifier. TYPE_MAIN_VARIANT
4438 is used here to remove this const from the diagnostics
4439 and the created OFFSET_REF. */
4440 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
4441 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
4444 if (! flag_ms_extensions
)
4446 tree name
= DECL_NAME (fn
);
4447 if (!(complain
& tf_error
))
4448 return error_mark_node
;
4449 else if (current_class_type
4450 && TREE_OPERAND (arg
, 0) == current_class_ref
)
4451 /* An expression like &memfn. */
4452 permerror (input_location
, "ISO C++ forbids taking the address of an unqualified"
4453 " or parenthesized non-static member function to form"
4454 " a pointer to member function. Say %<&%T::%D%>",
4457 permerror (input_location
, "ISO C++ forbids taking the address of a bound member"
4458 " function to form a pointer to member function."
4462 arg
= build_offset_ref (base
, fn
, /*address_p=*/true);
4466 if (type_unknown_p (arg
))
4467 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4469 /* Handle complex lvalues (when permitted)
4470 by reduction to simpler cases. */
4471 val
= unary_complex_lvalue (code
, arg
);
4475 switch (TREE_CODE (arg
))
4479 case FIX_TRUNC_EXPR
:
4480 /* Even if we're not being pedantic, we cannot allow this
4481 extension when we're instantiating in a SFINAE
4483 if (! lvalue_p (arg
) && complain
== tf_none
)
4485 if (complain
& tf_error
)
4486 permerror (input_location
, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4488 return error_mark_node
;
4493 arg
= BASELINK_FUNCTIONS (arg
);
4497 arg
= OVL_CURRENT (arg
);
4501 /* Turn a reference to a non-static data member into a
4502 pointer-to-member. */
4507 if (!PTRMEM_OK_P (arg
))
4508 return cp_build_unary_op (code
, arg
, 0, complain
);
4510 t
= TREE_OPERAND (arg
, 1);
4511 if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4513 if (complain
& tf_error
)
4514 error ("cannot create pointer to reference member %qD", t
);
4515 return error_mark_node
;
4518 type
= build_ptrmem_type (context_for_name_lookup (t
),
4520 t
= make_ptrmem_cst (type
, TREE_OPERAND (arg
, 1));
4528 /* Anything not already handled and not a true memory reference
4530 if (TREE_CODE (argtype
) != FUNCTION_TYPE
4531 && TREE_CODE (argtype
) != METHOD_TYPE
4532 && TREE_CODE (arg
) != OFFSET_REF
4533 && !lvalue_or_else (arg
, lv_addressof
, complain
))
4534 return error_mark_node
;
4536 if (argtype
!= error_mark_node
)
4537 argtype
= build_pointer_type (argtype
);
4539 /* In a template, we are processing a non-dependent expression
4540 so we can just form an ADDR_EXPR with the correct type. */
4541 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
4543 val
= build_address (arg
);
4544 if (TREE_CODE (arg
) == OFFSET_REF
)
4545 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
4547 else if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BASELINK
)
4549 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
4551 /* We can only get here with a single static member
4553 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
4554 && DECL_STATIC_FUNCTION_P (fn
));
4556 val
= build_address (fn
);
4557 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
4558 /* Do not lose object's side effects. */
4559 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
4560 TREE_OPERAND (arg
, 0), val
);
4562 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)))
4564 if (complain
& tf_error
)
4565 error ("attempt to take address of bit-field structure member %qD",
4566 TREE_OPERAND (arg
, 1));
4567 return error_mark_node
;
4571 tree object
= TREE_OPERAND (arg
, 0);
4572 tree field
= TREE_OPERAND (arg
, 1);
4573 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4574 (TREE_TYPE (object
), decl_type_context (field
)));
4575 val
= build_address (arg
);
4578 if (TREE_CODE (argtype
) == POINTER_TYPE
4579 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4581 build_ptrmemfunc_type (argtype
);
4582 val
= build_ptrmemfunc (argtype
, val
, 0,
4583 /*c_cast_p=*/false);
4595 argtype
= TREE_TYPE (arg
);
4596 return fold_if_not_in_template (build1 (code
, argtype
, arg
));
4599 if (complain
& tf_error
)
4600 error ("%s", errstring
);
4601 return error_mark_node
;
4604 /* Hook for the c-common bits that build a unary op. */
4606 build_unary_op (enum tree_code code
, tree xarg
, int noconvert
)
4608 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
4611 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4612 for certain kinds of expressions which are not really lvalues
4613 but which we can accept as lvalues.
4615 If ARG is not a kind of expression we can handle, return
4619 unary_complex_lvalue (enum tree_code code
, tree arg
)
4621 /* Inside a template, making these kinds of adjustments is
4622 pointless; we are only concerned with the type of the
4624 if (processing_template_decl
)
4627 /* Handle (a, b) used as an "lvalue". */
4628 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4630 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), 0,
4631 tf_warning_or_error
);
4632 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4633 TREE_OPERAND (arg
, 0), real_result
);
4636 /* Handle (a ? b : c) used as an "lvalue". */
4637 if (TREE_CODE (arg
) == COND_EXPR
4638 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4639 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
4641 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4642 if (TREE_CODE (arg
) == MODIFY_EXPR
4643 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4644 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4646 tree lvalue
= TREE_OPERAND (arg
, 0);
4647 if (TREE_SIDE_EFFECTS (lvalue
))
4649 lvalue
= stabilize_reference (lvalue
);
4650 arg
= build2 (TREE_CODE (arg
), TREE_TYPE (arg
),
4651 lvalue
, TREE_OPERAND (arg
, 1));
4653 return unary_complex_lvalue
4654 (code
, build2 (COMPOUND_EXPR
, TREE_TYPE (lvalue
), arg
, lvalue
));
4657 if (code
!= ADDR_EXPR
)
4660 /* Handle (a = b) used as an "lvalue" for `&'. */
4661 if (TREE_CODE (arg
) == MODIFY_EXPR
4662 || TREE_CODE (arg
) == INIT_EXPR
)
4664 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), 0,
4665 tf_warning_or_error
);
4666 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4668 TREE_NO_WARNING (arg
) = 1;
4672 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4673 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4674 || TREE_CODE (arg
) == OFFSET_REF
)
4677 /* We permit compiler to make function calls returning
4678 objects of aggregate type look like lvalues. */
4682 if (TREE_CODE (targ
) == SAVE_EXPR
)
4683 targ
= TREE_OPERAND (targ
, 0);
4685 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
4687 if (TREE_CODE (arg
) == SAVE_EXPR
)
4690 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4691 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4694 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4695 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4696 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4699 /* Don't let anything else be handled specially. */
4703 /* Mark EXP saying that we need to be able to take the
4704 address of it; it should not be allocated in a register.
4705 Value is true if successful.
4707 C++: we do not allow `current_class_ptr' to be addressable. */
4710 cxx_mark_addressable (tree exp
)
4715 switch (TREE_CODE (x
))
4722 x
= TREE_OPERAND (x
, 0);
4726 if (x
== current_class_ptr
)
4728 error ("cannot take the address of %<this%>, which is an rvalue expression");
4729 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
4735 /* Caller should not be trying to mark initialized
4736 constant fields addressable. */
4737 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
4738 || DECL_IN_AGGR_P (x
) == 0
4740 || DECL_EXTERNAL (x
));
4745 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4746 && !DECL_ARTIFICIAL (x
))
4748 if (TREE_CODE (x
) == VAR_DECL
&& DECL_HARD_REGISTER (x
))
4751 ("address of explicit register variable %qD requested", x
);
4754 else if (extra_warnings
)
4756 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
4758 TREE_ADDRESSABLE (x
) = 1;
4762 TREE_ADDRESSABLE (x
) = 1;
4766 TREE_ADDRESSABLE (x
) = 1;
4770 TREE_ADDRESSABLE (x
) = 1;
4771 cxx_mark_addressable (TREE_OPERAND (x
, 0));
4779 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4782 build_x_conditional_expr (tree ifexp
, tree op1
, tree op2
,
4783 tsubst_flags_t complain
)
4785 tree orig_ifexp
= ifexp
;
4786 tree orig_op1
= op1
;
4787 tree orig_op2
= op2
;
4790 if (processing_template_decl
)
4792 /* The standard says that the expression is type-dependent if
4793 IFEXP is type-dependent, even though the eventual type of the
4794 expression doesn't dependent on IFEXP. */
4795 if (type_dependent_expression_p (ifexp
)
4796 /* As a GNU extension, the middle operand may be omitted. */
4797 || (op1
&& type_dependent_expression_p (op1
))
4798 || type_dependent_expression_p (op2
))
4799 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
4800 ifexp
= build_non_dependent_expr (ifexp
);
4802 op1
= build_non_dependent_expr (op1
);
4803 op2
= build_non_dependent_expr (op2
);
4806 expr
= build_conditional_expr (ifexp
, op1
, op2
, complain
);
4807 if (processing_template_decl
&& expr
!= error_mark_node
)
4808 return build_min_non_dep (COND_EXPR
, expr
,
4809 orig_ifexp
, orig_op1
, orig_op2
);
4813 /* Given a list of expressions, return a compound expression
4814 that performs them all and returns the value of the last of them. */
4816 tree
build_x_compound_expr_from_list (tree list
, const char *msg
)
4818 tree expr
= TREE_VALUE (list
);
4820 if (TREE_CHAIN (list
))
4823 permerror (input_location
, "%s expression list treated as compound expression", msg
);
4825 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
4826 expr
= build_x_compound_expr (expr
, TREE_VALUE (list
),
4827 tf_warning_or_error
);
4833 /* Handle overloading of the ',' operator when needed. */
4836 build_x_compound_expr (tree op1
, tree op2
, tsubst_flags_t complain
)
4839 tree orig_op1
= op1
;
4840 tree orig_op2
= op2
;
4842 if (processing_template_decl
)
4844 if (type_dependent_expression_p (op1
)
4845 || type_dependent_expression_p (op2
))
4846 return build_min_nt (COMPOUND_EXPR
, op1
, op2
);
4847 op1
= build_non_dependent_expr (op1
);
4848 op2
= build_non_dependent_expr (op2
);
4851 result
= build_new_op (COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
, NULL_TREE
,
4852 /*overloaded_p=*/NULL
, complain
);
4854 result
= cp_build_compound_expr (op1
, op2
, complain
);
4856 if (processing_template_decl
&& result
!= error_mark_node
)
4857 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
4862 /* Like cp_build_compound_expr, but for the c-common bits. */
4865 build_compound_expr (tree lhs
, tree rhs
)
4867 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
4870 /* Build a compound expression. */
4873 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
4875 lhs
= convert_to_void (lhs
, "left-hand operand of comma", complain
);
4877 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
4878 return error_mark_node
;
4880 if (TREE_CODE (rhs
) == TARGET_EXPR
)
4882 /* If the rhs is a TARGET_EXPR, then build the compound
4883 expression inside the target_expr's initializer. This
4884 helps the compiler to eliminate unnecessary temporaries. */
4885 tree init
= TREE_OPERAND (rhs
, 1);
4887 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
4888 TREE_OPERAND (rhs
, 1) = init
;
4893 return build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
4896 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4897 casts away constness. CAST gives the type of cast. */
4900 check_for_casting_away_constness (tree src_type
, tree dest_type
,
4901 enum tree_code cast
)
4903 /* C-style casts are allowed to cast away constness. With
4904 WARN_CAST_QUAL, we still want to issue a warning. */
4905 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
4908 if (casts_away_constness (src_type
, dest_type
))
4912 warning (OPT_Wcast_qual
,
4913 "cast from type %qT to type %qT casts away constness",
4914 src_type
, dest_type
);
4917 case STATIC_CAST_EXPR
:
4918 error ("static_cast from type %qT to type %qT casts away constness",
4919 src_type
, dest_type
);
4922 case REINTERPRET_CAST_EXPR
:
4923 error ("reinterpret_cast from type %qT to type %qT casts away constness",
4924 src_type
, dest_type
);
4931 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4932 (another pointer-to-member type in the same hierarchy) and return
4933 the converted expression. If ALLOW_INVERSE_P is permitted, a
4934 pointer-to-derived may be converted to pointer-to-base; otherwise,
4935 only the other direction is permitted. If C_CAST_P is true, this
4936 conversion is taking place as part of a C-style cast. */
4939 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
4942 if (TYPE_PTRMEM_P (type
))
4946 if (TREE_CODE (expr
) == PTRMEM_CST
)
4947 expr
= cplus_expand_constant (expr
);
4948 delta
= get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
)),
4949 TYPE_PTRMEM_CLASS_TYPE (type
),
4952 if (!integer_zerop (delta
))
4954 tree cond
, op1
, op2
;
4956 cond
= cp_build_binary_op (EQ_EXPR
,
4958 build_int_cst (TREE_TYPE (expr
), -1),
4959 tf_warning_or_error
);
4960 op1
= build_nop (ptrdiff_type_node
, expr
);
4961 op2
= cp_build_binary_op (PLUS_EXPR
, op1
, delta
,
4962 tf_warning_or_error
);
4964 expr
= fold_build3 (COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
4968 return build_nop (type
, expr
);
4971 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
4972 allow_inverse_p
, c_cast_p
);
4975 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
4976 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
4977 Otherwise, return EXPR unchanged. */
4980 ignore_overflows (tree expr
, tree orig
)
4982 if (TREE_CODE (expr
) == INTEGER_CST
4983 && CONSTANT_CLASS_P (orig
)
4984 && TREE_CODE (orig
) != STRING_CST
4985 && TREE_OVERFLOW (expr
) != TREE_OVERFLOW (orig
))
4987 if (!TREE_OVERFLOW (orig
))
4988 /* Ensure constant sharing. */
4989 expr
= build_int_cst_wide (TREE_TYPE (expr
),
4990 TREE_INT_CST_LOW (expr
),
4991 TREE_INT_CST_HIGH (expr
));
4994 /* Avoid clobbering a shared constant. */
4995 expr
= copy_node (expr
);
4996 TREE_OVERFLOW (expr
) = TREE_OVERFLOW (orig
);
5002 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
5003 this static_cast is being attempted as one of the possible casts
5004 allowed by a C-style cast. (In that case, accessibility of base
5005 classes is not considered, and it is OK to cast away
5006 constness.) Return the result of the cast. *VALID_P is set to
5007 indicate whether or not the cast was valid. */
5010 build_static_cast_1 (tree type
, tree expr
, bool c_cast_p
,
5011 bool *valid_p
, tsubst_flags_t complain
)
5017 /* Assume the cast is valid. */
5020 intype
= TREE_TYPE (expr
);
5022 /* Save casted types in the function's used types hash table. */
5023 used_types_insert (type
);
5025 /* [expr.static.cast]
5027 An lvalue of type "cv1 B", where B is a class type, can be cast
5028 to type "reference to cv2 D", where D is a class derived (clause
5029 _class.derived_) from B, if a valid standard conversion from
5030 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5031 same cv-qualification as, or greater cv-qualification than, cv1,
5032 and B is not a virtual base class of D. */
5033 /* We check this case before checking the validity of "TYPE t =
5034 EXPR;" below because for this case:
5037 struct D : public B { D(const B&); };
5039 void f() { static_cast<const D&>(b); }
5041 we want to avoid constructing a new D. The standard is not
5042 completely clear about this issue, but our interpretation is
5043 consistent with other compilers. */
5044 if (TREE_CODE (type
) == REFERENCE_TYPE
5045 && CLASS_TYPE_P (TREE_TYPE (type
))
5046 && CLASS_TYPE_P (intype
)
5047 && real_lvalue_p (expr
)
5048 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
5049 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
5050 build_pointer_type (TYPE_MAIN_VARIANT
5051 (TREE_TYPE (type
))))
5053 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
5057 /* There is a standard conversion from "D*" to "B*" even if "B"
5058 is ambiguous or inaccessible. If this is really a
5059 static_cast, then we check both for inaccessibility and
5060 ambiguity. However, if this is a static_cast being performed
5061 because the user wrote a C-style cast, then accessibility is
5063 base
= lookup_base (TREE_TYPE (type
), intype
,
5064 c_cast_p
? ba_unique
: ba_check
,
5067 /* Convert from "B*" to "D*". This function will check that "B"
5068 is not a virtual base of "D". */
5069 expr
= build_base_path (MINUS_EXPR
, build_address (expr
),
5070 base
, /*nonnull=*/false);
5071 /* Convert the pointer to a reference -- but then remember that
5072 there are no expressions with reference type in C++. */
5073 return convert_from_reference (build_nop (type
, expr
));
5078 /* [expr.static.cast]
5080 An expression e can be explicitly converted to a type T using a
5081 static_cast of the form static_cast<T>(e) if the declaration T
5082 t(e);" is well-formed, for some invented temporary variable
5084 result
= perform_direct_initialization_if_possible (type
, expr
,
5085 c_cast_p
, complain
);
5088 result
= convert_from_reference (result
);
5090 /* Ignore any integer overflow caused by the cast. */
5091 result
= ignore_overflows (result
, orig
);
5093 /* [expr.static.cast]
5095 If T is a reference type, the result is an lvalue; otherwise,
5096 the result is an rvalue. */
5097 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5098 result
= rvalue (result
);
5102 /* [expr.static.cast]
5104 Any expression can be explicitly converted to type cv void. */
5105 if (TREE_CODE (type
) == VOID_TYPE
)
5106 return convert_to_void (expr
, /*implicit=*/NULL
, complain
);
5108 /* [expr.static.cast]
5110 The inverse of any standard conversion sequence (clause _conv_),
5111 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5112 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5113 (_conv.bool_) conversions, can be performed explicitly using
5114 static_cast subject to the restriction that the explicit
5115 conversion does not cast away constness (_expr.const.cast_), and
5116 the following additional rules for specific cases: */
5117 /* For reference, the conversions not excluded are: integral
5118 promotions, floating point promotion, integral conversions,
5119 floating point conversions, floating-integral conversions,
5120 pointer conversions, and pointer to member conversions. */
5123 A value of integral _or enumeration_ type can be explicitly
5124 converted to an enumeration type. */
5125 /* The effect of all that is that any conversion between any two
5126 types which are integral, floating, or enumeration types can be
5128 if ((INTEGRAL_TYPE_P (type
) || SCALAR_FLOAT_TYPE_P (type
))
5129 && (INTEGRAL_TYPE_P (intype
) || SCALAR_FLOAT_TYPE_P (intype
)))
5131 expr
= ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
);
5133 /* Ignore any integer overflow caused by the cast. */
5134 expr
= ignore_overflows (expr
, orig
);
5138 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
5139 && CLASS_TYPE_P (TREE_TYPE (type
))
5140 && CLASS_TYPE_P (TREE_TYPE (intype
))
5141 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5142 (TREE_TYPE (intype
))),
5143 build_pointer_type (TYPE_MAIN_VARIANT
5144 (TREE_TYPE (type
)))))
5149 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5150 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
5151 c_cast_p
? ba_unique
: ba_check
,
5153 return build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false);
5156 if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5157 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5164 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
5165 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
5167 if (TYPE_PTRMEM_P (type
))
5169 t1
= (build_ptrmem_type
5171 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
5172 t2
= (build_ptrmem_type
5174 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
5181 if (can_convert (t1
, t2
) || can_convert (t2
, t1
))
5184 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5185 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
5190 /* [expr.static.cast]
5192 An rvalue of type "pointer to cv void" can be explicitly
5193 converted to a pointer to object type. A value of type pointer
5194 to object converted to "pointer to cv void" and back to the
5195 original pointer type will have its original value. */
5196 if (TREE_CODE (intype
) == POINTER_TYPE
5197 && VOID_TYPE_P (TREE_TYPE (intype
))
5198 && TYPE_PTROB_P (type
))
5201 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5202 return build_nop (type
, expr
);
5206 return error_mark_node
;
5209 /* Return an expression representing static_cast<TYPE>(EXPR). */
5212 build_static_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5217 if (type
== error_mark_node
|| expr
== error_mark_node
)
5218 return error_mark_node
;
5220 if (processing_template_decl
)
5222 expr
= build_min (STATIC_CAST_EXPR
, type
, expr
);
5223 /* We don't know if it will or will not have side effects. */
5224 TREE_SIDE_EFFECTS (expr
) = 1;
5225 return convert_from_reference (expr
);
5228 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5229 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5230 if (TREE_CODE (type
) != REFERENCE_TYPE
5231 && TREE_CODE (expr
) == NOP_EXPR
5232 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5233 expr
= TREE_OPERAND (expr
, 0);
5235 result
= build_static_cast_1 (type
, expr
, /*c_cast_p=*/false, &valid_p
,
5240 if (complain
& tf_error
)
5241 error ("invalid static_cast from type %qT to type %qT",
5242 TREE_TYPE (expr
), type
);
5243 return error_mark_node
;
5246 /* EXPR is an expression with member function or pointer-to-member
5247 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5248 not permitted by ISO C++, but we accept it in some modes. If we
5249 are not in one of those modes, issue a diagnostic. Return the
5250 converted expression. */
5253 convert_member_func_to_ptr (tree type
, tree expr
)
5258 intype
= TREE_TYPE (expr
);
5259 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
5260 || TREE_CODE (intype
) == METHOD_TYPE
);
5262 if (pedantic
|| warn_pmf2ptr
)
5263 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpmf_conversions
,
5264 "converting from %qT to %qT", intype
, type
);
5266 if (TREE_CODE (intype
) == METHOD_TYPE
)
5267 expr
= build_addr_func (expr
);
5268 else if (TREE_CODE (expr
) == PTRMEM_CST
)
5269 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
5272 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
5273 decl
= build_address (decl
);
5274 expr
= get_member_function_from_ptrfunc (&decl
, expr
);
5277 return build_nop (type
, expr
);
5280 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5281 If C_CAST_P is true, this reinterpret cast is being done as part of
5282 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5283 indicate whether or not reinterpret_cast was valid. */
5286 build_reinterpret_cast_1 (tree type
, tree expr
, bool c_cast_p
,
5287 bool *valid_p
, tsubst_flags_t complain
)
5291 /* Assume the cast is invalid. */
5295 if (type
== error_mark_node
|| error_operand_p (expr
))
5296 return error_mark_node
;
5298 intype
= TREE_TYPE (expr
);
5300 /* Save casted types in the function's used types hash table. */
5301 used_types_insert (type
);
5303 /* [expr.reinterpret.cast]
5304 An lvalue expression of type T1 can be cast to the type
5305 "reference to T2" if an expression of type "pointer to T1" can be
5306 explicitly converted to the type "pointer to T2" using a
5307 reinterpret_cast. */
5308 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5310 if (! real_lvalue_p (expr
))
5312 if (complain
& tf_error
)
5313 error ("invalid cast of an rvalue expression of type "
5316 return error_mark_node
;
5319 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5320 "B" are related class types; the reinterpret_cast does not
5321 adjust the pointer. */
5322 if (TYPE_PTR_P (intype
)
5323 && (complain
& tf_warning
)
5324 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
5325 COMPARE_BASE
| COMPARE_DERIVED
)))
5326 warning (0, "casting %qT to %qT does not dereference pointer",
5329 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, 0, complain
);
5330 if (expr
!= error_mark_node
)
5331 expr
= build_reinterpret_cast_1
5332 (build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
5334 if (expr
!= error_mark_node
)
5335 expr
= cp_build_indirect_ref (expr
, 0, complain
);
5339 /* As a G++ extension, we consider conversions from member
5340 functions, and pointers to member functions to
5341 pointer-to-function and pointer-to-void types. If
5342 -Wno-pmf-conversions has not been specified,
5343 convert_member_func_to_ptr will issue an error message. */
5344 if ((TYPE_PTRMEMFUNC_P (intype
)
5345 || TREE_CODE (intype
) == METHOD_TYPE
)
5346 && TYPE_PTR_P (type
)
5347 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
5348 || VOID_TYPE_P (TREE_TYPE (type
))))
5349 return convert_member_func_to_ptr (type
, expr
);
5351 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5352 array-to-pointer, and function-to-pointer conversions are
5354 expr
= decay_conversion (expr
);
5356 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5357 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5358 if (TREE_CODE (expr
) == NOP_EXPR
5359 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5360 expr
= TREE_OPERAND (expr
, 0);
5362 if (error_operand_p (expr
))
5363 return error_mark_node
;
5365 intype
= TREE_TYPE (expr
);
5367 /* [expr.reinterpret.cast]
5368 A pointer can be converted to any integral type large enough to
5370 if (CP_INTEGRAL_TYPE_P (type
) && TYPE_PTR_P (intype
))
5372 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5374 if (complain
& tf_error
)
5375 permerror (input_location
, "cast from %qT to %qT loses precision",
5378 return error_mark_node
;
5381 /* [expr.reinterpret.cast]
5382 A value of integral or enumeration type can be explicitly
5383 converted to a pointer. */
5384 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
5387 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5388 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5389 return fold_if_not_in_template (build_nop (type
, expr
));
5390 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5391 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5396 check_for_casting_away_constness (intype
, type
, REINTERPRET_CAST_EXPR
);
5397 /* Warn about possible alignment problems. */
5398 if (STRICT_ALIGNMENT
&& warn_cast_align
5399 && (complain
& tf_warning
)
5400 && !VOID_TYPE_P (type
)
5401 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
5402 && COMPLETE_TYPE_P (TREE_TYPE (type
))
5403 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
5404 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (intype
)))
5405 warning (OPT_Wcast_align
, "cast from %qT to %qT "
5406 "increases required alignment of target type", intype
, type
);
5408 /* We need to strip nops here, because the front end likes to
5409 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5411 if (warn_strict_aliasing
<= 2)
5412 strict_aliasing_warning (intype
, type
, sexpr
);
5414 return fold_if_not_in_template (build_nop (type
, expr
));
5416 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5417 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
5419 if (pedantic
&& (complain
& tf_warning
))
5420 /* Only issue a warning, as we have always supported this
5421 where possible, and it is necessary in some cases. DR 195
5422 addresses this issue, but as of 2004/10/26 is still in
5424 warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5425 return fold_if_not_in_template (build_nop (type
, expr
));
5427 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5428 return fold_if_not_in_template (convert_to_vector (type
, expr
));
5429 else if (TREE_CODE (intype
) == VECTOR_TYPE
&& INTEGRAL_TYPE_P (type
))
5430 return fold_if_not_in_template (convert_to_integer (type
, expr
));
5435 if (complain
& tf_error
)
5436 error ("invalid cast from type %qT to type %qT", intype
, type
);
5437 return error_mark_node
;
5440 return cp_convert (type
, expr
);
5444 build_reinterpret_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5446 if (type
== error_mark_node
|| expr
== error_mark_node
)
5447 return error_mark_node
;
5449 if (processing_template_decl
)
5451 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
5453 if (!TREE_SIDE_EFFECTS (t
)
5454 && type_dependent_expression_p (expr
))
5455 /* There might turn out to be side effects inside expr. */
5456 TREE_SIDE_EFFECTS (t
) = 1;
5457 return convert_from_reference (t
);
5460 return build_reinterpret_cast_1 (type
, expr
, /*c_cast_p=*/false,
5461 /*valid_p=*/NULL
, complain
);
5464 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5465 return an appropriate expression. Otherwise, return
5466 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5467 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5468 performing a C-style cast, its value upon return will indicate
5469 whether or not the conversion succeeded. */
5472 build_const_cast_1 (tree dst_type
, tree expr
, bool complain
,
5476 tree reference_type
;
5478 /* Callers are responsible for handling error_mark_node as a
5479 destination type. */
5480 gcc_assert (dst_type
!= error_mark_node
);
5481 /* In a template, callers should be building syntactic
5482 representations of casts, not using this machinery. */
5483 gcc_assert (!processing_template_decl
);
5485 /* Assume the conversion is invalid. */
5489 if (!POINTER_TYPE_P (dst_type
) && !TYPE_PTRMEM_P (dst_type
))
5492 error ("invalid use of const_cast with type %qT, "
5493 "which is not a pointer, "
5494 "reference, nor a pointer-to-data-member type", dst_type
);
5495 return error_mark_node
;
5498 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
5501 error ("invalid use of const_cast with type %qT, which is a pointer "
5502 "or reference to a function type", dst_type
);
5503 return error_mark_node
;
5506 /* Save casted types in the function's used types hash table. */
5507 used_types_insert (dst_type
);
5509 src_type
= TREE_TYPE (expr
);
5510 /* Expressions do not really have reference types. */
5511 if (TREE_CODE (src_type
) == REFERENCE_TYPE
)
5512 src_type
= TREE_TYPE (src_type
);
5514 /* [expr.const.cast]
5516 An lvalue of type T1 can be explicitly converted to an lvalue of
5517 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5518 types) if a pointer to T1 can be explicitly converted to the type
5519 pointer to T2 using a const_cast. */
5520 if (TREE_CODE (dst_type
) == REFERENCE_TYPE
)
5522 reference_type
= dst_type
;
5523 if (! real_lvalue_p (expr
))
5526 error ("invalid const_cast of an rvalue of type %qT to type %qT",
5527 src_type
, dst_type
);
5528 return error_mark_node
;
5530 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
5531 src_type
= build_pointer_type (src_type
);
5535 reference_type
= NULL_TREE
;
5536 /* If the destination type is not a reference type, the
5537 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5538 conversions are performed. */
5539 src_type
= type_decays_to (src_type
);
5540 if (src_type
== error_mark_node
)
5541 return error_mark_node
;
5544 if ((TYPE_PTR_P (src_type
) || TYPE_PTRMEM_P (src_type
))
5545 && comp_ptr_ttypes_const (dst_type
, src_type
))
5550 /* This cast is actually a C-style cast. Issue a warning if
5551 the user is making a potentially unsafe cast. */
5552 check_for_casting_away_constness (src_type
, dst_type
, CAST_EXPR
);
5556 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, 0,
5557 complain
? tf_warning_or_error
: tf_none
);
5558 expr
= build_nop (reference_type
, expr
);
5559 return convert_from_reference (expr
);
5563 expr
= decay_conversion (expr
);
5564 /* build_c_cast puts on a NOP_EXPR to make the result not an
5565 lvalue. Strip such NOP_EXPRs if VALUE is being used in
5566 non-lvalue context. */
5567 if (TREE_CODE (expr
) == NOP_EXPR
5568 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5569 expr
= TREE_OPERAND (expr
, 0);
5570 return build_nop (dst_type
, expr
);
5575 error ("invalid const_cast from type %qT to type %qT",
5576 src_type
, dst_type
);
5577 return error_mark_node
;
5581 build_const_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5583 if (type
== error_mark_node
|| error_operand_p (expr
))
5584 return error_mark_node
;
5586 if (processing_template_decl
)
5588 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
5590 if (!TREE_SIDE_EFFECTS (t
)
5591 && type_dependent_expression_p (expr
))
5592 /* There might turn out to be side effects inside expr. */
5593 TREE_SIDE_EFFECTS (t
) = 1;
5594 return convert_from_reference (t
);
5597 return build_const_cast_1 (type
, expr
, complain
& tf_error
,
5601 /* Like cp_build_c_cast, but for the c-common bits. */
5604 build_c_cast (tree type
, tree expr
)
5606 return cp_build_c_cast (type
, expr
, tf_warning_or_error
);
5609 /* Build an expression representing an explicit C-style cast to type
5610 TYPE of expression EXPR. */
5613 cp_build_c_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5619 if (type
== error_mark_node
|| error_operand_p (expr
))
5620 return error_mark_node
;
5622 if (processing_template_decl
)
5624 tree t
= build_min (CAST_EXPR
, type
,
5625 tree_cons (NULL_TREE
, value
, NULL_TREE
));
5626 /* We don't know if it will or will not have side effects. */
5627 TREE_SIDE_EFFECTS (t
) = 1;
5628 return convert_from_reference (t
);
5631 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5632 'Class') should always be retained, because this information aids
5633 in method lookup. */
5634 if (objc_is_object_ptr (type
)
5635 && objc_is_object_ptr (TREE_TYPE (expr
)))
5636 return build_nop (type
, expr
);
5638 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5639 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5640 if (TREE_CODE (type
) != REFERENCE_TYPE
5641 && TREE_CODE (value
) == NOP_EXPR
5642 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5643 value
= TREE_OPERAND (value
, 0);
5645 if (TREE_CODE (type
) == ARRAY_TYPE
)
5647 /* Allow casting from T1* to T2[] because Cfront allows it.
5648 NIHCL uses it. It is not valid ISO C++ however. */
5649 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5651 if (complain
& tf_error
)
5652 permerror (input_location
, "ISO C++ forbids casting to an array type %qT", type
);
5654 return error_mark_node
;
5655 type
= build_pointer_type (TREE_TYPE (type
));
5659 if (complain
& tf_error
)
5660 error ("ISO C++ forbids casting to an array type %qT", type
);
5661 return error_mark_node
;
5665 if (TREE_CODE (type
) == FUNCTION_TYPE
5666 || TREE_CODE (type
) == METHOD_TYPE
)
5668 if (complain
& tf_error
)
5669 error ("invalid cast to function type %qT", type
);
5670 return error_mark_node
;
5673 /* A C-style cast can be a const_cast. */
5674 result
= build_const_cast_1 (type
, value
, /*complain=*/false,
5679 /* Or a static cast. */
5680 result
= build_static_cast_1 (type
, value
, /*c_cast_p=*/true,
5681 &valid_p
, complain
);
5682 /* Or a reinterpret_cast. */
5684 result
= build_reinterpret_cast_1 (type
, value
, /*c_cast_p=*/true,
5685 &valid_p
, complain
);
5686 /* The static_cast or reinterpret_cast may be followed by a
5689 /* A valid cast may result in errors if, for example, a
5690 conversion to am ambiguous base class is required. */
5691 && !error_operand_p (result
))
5695 /* Non-class rvalues always have cv-unqualified type. */
5696 if (!CLASS_TYPE_P (type
))
5697 type
= TYPE_MAIN_VARIANT (type
);
5698 result_type
= TREE_TYPE (result
);
5699 if (!CLASS_TYPE_P (result_type
))
5700 result_type
= TYPE_MAIN_VARIANT (result_type
);
5701 /* If the type of RESULT does not match TYPE, perform a
5702 const_cast to make it match. If the static_cast or
5703 reinterpret_cast succeeded, we will differ by at most
5704 cv-qualification, so the follow-on const_cast is guaranteed
5706 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
5708 result
= build_const_cast_1 (type
, result
, false, &valid_p
);
5709 gcc_assert (valid_p
);
5714 return error_mark_node
;
5717 /* For use from the C common bits. */
5719 build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
)
5721 return cp_build_modify_expr (lhs
, modifycode
, rhs
, tf_warning_or_error
);
5724 /* Build an assignment expression of lvalue LHS from value RHS.
5725 MODIFYCODE is the code for a binary operator that we use
5726 to combine the old value of LHS with RHS to get the new value.
5727 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5729 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5732 cp_build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
,
5733 tsubst_flags_t complain
)
5737 tree lhstype
= TREE_TYPE (lhs
);
5738 tree olhstype
= lhstype
;
5739 tree olhs
= NULL_TREE
;
5740 bool plain_assign
= (modifycode
== NOP_EXPR
);
5742 /* Avoid duplicate error messages from operands that had errors. */
5743 if (error_operand_p (lhs
) || error_operand_p (rhs
))
5744 return error_mark_node
;
5746 /* Handle control structure constructs used as "lvalues". */
5747 switch (TREE_CODE (lhs
))
5749 /* Handle --foo = 5; as these are valid constructs in C++. */
5750 case PREDECREMENT_EXPR
:
5751 case PREINCREMENT_EXPR
:
5752 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5753 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5754 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5755 TREE_OPERAND (lhs
, 1));
5756 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 0),
5757 modifycode
, rhs
, complain
);
5758 if (newrhs
== error_mark_node
)
5759 return error_mark_node
;
5760 return build2 (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5762 /* Handle (a, b) used as an "lvalue". */
5764 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 1),
5765 modifycode
, rhs
, complain
);
5766 if (newrhs
== error_mark_node
)
5767 return error_mark_node
;
5768 return build2 (COMPOUND_EXPR
, lhstype
,
5769 TREE_OPERAND (lhs
, 0), newrhs
);
5772 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5773 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5774 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5775 TREE_OPERAND (lhs
, 1));
5776 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
,
5778 if (newrhs
== error_mark_node
)
5779 return error_mark_node
;
5780 return build2 (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5784 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5785 when neither operand has side-effects. */
5786 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
5787 return error_mark_node
;
5789 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
5790 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
5792 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
5793 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
5795 TREE_OPERAND (lhs
, 0),
5796 TREE_OPERAND (lhs
, 1)),
5797 TREE_OPERAND (lhs
, 0),
5798 TREE_OPERAND (lhs
, 1));
5801 /* Handle (a ? b : c) used as an "lvalue". */
5804 /* Produce (a ? (b = rhs) : (c = rhs))
5805 except that the RHS goes through a save-expr
5806 so the code to compute it is only emitted once. */
5808 tree preeval
= NULL_TREE
;
5810 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
5812 if (complain
& tf_error
)
5813 error ("void value not ignored as it ought to be");
5814 return error_mark_node
;
5817 rhs
= stabilize_expr (rhs
, &preeval
);
5819 /* Check this here to avoid odd errors when trying to convert
5820 a throw to the type of the COND_EXPR. */
5821 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
5822 return error_mark_node
;
5824 cond
= build_conditional_expr
5825 (TREE_OPERAND (lhs
, 0),
5826 cp_build_modify_expr (TREE_OPERAND (lhs
, 1),
5827 modifycode
, rhs
, complain
),
5828 cp_build_modify_expr (TREE_OPERAND (lhs
, 2),
5829 modifycode
, rhs
, complain
),
5832 if (cond
== error_mark_node
)
5834 /* Make sure the code to compute the rhs comes out
5835 before the split. */
5837 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (lhs
), preeval
, cond
);
5845 if (modifycode
== INIT_EXPR
)
5847 if (TREE_CODE (rhs
) == CONSTRUCTOR
)
5849 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
5850 /* Call convert to generate an error; see PR 11063. */
5851 rhs
= convert (lhstype
, rhs
);
5852 result
= build2 (INIT_EXPR
, lhstype
, lhs
, rhs
);
5853 TREE_SIDE_EFFECTS (result
) = 1;
5856 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
5857 /* Do the default thing. */;
5860 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
5861 build_tree_list (NULL_TREE
, rhs
),
5862 lhstype
, LOOKUP_NORMAL
,
5864 if (result
== NULL_TREE
)
5865 return error_mark_node
;
5871 lhs
= require_complete_type (lhs
);
5872 if (lhs
== error_mark_node
)
5873 return error_mark_node
;
5875 if (modifycode
== NOP_EXPR
)
5877 /* `operator=' is not an inheritable operator. */
5878 if (! MAYBE_CLASS_TYPE_P (lhstype
))
5879 /* Do the default thing. */;
5882 result
= build_new_op (MODIFY_EXPR
, LOOKUP_NORMAL
,
5883 lhs
, rhs
, make_node (NOP_EXPR
),
5884 /*overloaded_p=*/NULL
,
5886 if (result
== NULL_TREE
)
5887 return error_mark_node
;
5894 /* A binary op has been requested. Combine the old LHS
5895 value with the RHS producing the value we should actually
5896 store into the LHS. */
5897 gcc_assert (!((TREE_CODE (lhstype
) == REFERENCE_TYPE
5898 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
5899 || MAYBE_CLASS_TYPE_P (lhstype
)));
5901 lhs
= stabilize_reference (lhs
);
5902 newrhs
= cp_build_binary_op (modifycode
, lhs
, rhs
,
5904 if (newrhs
== error_mark_node
)
5906 if (complain
& tf_error
)
5907 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode
,
5908 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
5909 return error_mark_node
;
5912 /* Now it looks like a plain assignment. */
5913 modifycode
= NOP_EXPR
;
5915 gcc_assert (TREE_CODE (lhstype
) != REFERENCE_TYPE
);
5916 gcc_assert (TREE_CODE (TREE_TYPE (newrhs
)) != REFERENCE_TYPE
);
5919 /* The left-hand side must be an lvalue. */
5920 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
5921 return error_mark_node
;
5923 /* Warn about modifying something that is `const'. Don't warn if
5924 this is initialization. */
5925 if (modifycode
!= INIT_EXPR
5926 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
5927 /* Functions are not modifiable, even though they are
5929 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
5930 || TREE_CODE (TREE_TYPE (lhs
)) == METHOD_TYPE
5931 /* If it's an aggregate and any field is const, then it is
5932 effectively const. */
5933 || (CLASS_TYPE_P (lhstype
)
5934 && C_TYPE_FIELDS_READONLY (lhstype
))))
5936 if (complain
& tf_error
)
5937 readonly_error (lhs
, "assignment");
5939 return error_mark_node
;
5942 /* If storing into a structure or union member, it has probably been
5943 given type `int'. Compute the type that would go with the actual
5944 amount of storage the member occupies. */
5946 if (TREE_CODE (lhs
) == COMPONENT_REF
5947 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5948 || TREE_CODE (lhstype
) == REAL_TYPE
5949 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5951 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5953 /* If storing in a field that is in actuality a short or narrower
5954 than one, we must store in the field in its actual type. */
5956 if (lhstype
!= TREE_TYPE (lhs
))
5958 /* Avoid warnings converting integral types back into enums for
5960 if (TREE_CODE (lhstype
) == INTEGER_TYPE
5961 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
5963 if (TREE_SIDE_EFFECTS (lhs
))
5964 lhs
= stabilize_reference (lhs
);
5967 lhs
= copy_node (lhs
);
5968 TREE_TYPE (lhs
) = lhstype
;
5972 /* Convert new value to destination type. */
5974 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5978 if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
5979 TYPE_MAIN_VARIANT (TREE_TYPE (rhs
))))
5981 if (complain
& tf_error
)
5982 error ("incompatible types in assignment of %qT to %qT",
5983 TREE_TYPE (rhs
), lhstype
);
5984 return error_mark_node
;
5987 /* Allow array assignment in compiler-generated code. */
5988 if (! DECL_ARTIFICIAL (current_function_decl
))
5990 /* This routine is used for both initialization and assignment.
5991 Make sure the diagnostic message differentiates the context. */
5992 if (complain
& tf_error
)
5994 if (modifycode
== INIT_EXPR
)
5995 error ("array used as initializer");
5997 error ("invalid array assignment");
5999 return error_mark_node
;
6002 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6003 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6004 return build_vec_init (lhs
, NULL_TREE
, newrhs
,
6005 /*explicit_value_init_p=*/false,
6006 from_array
, complain
);
6009 if (modifycode
== INIT_EXPR
)
6010 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
6011 "initialization", NULL_TREE
, 0,
6015 /* Avoid warnings on enum bit fields. */
6016 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
6017 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
6019 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6020 NULL_TREE
, 0, complain
);
6021 newrhs
= convert_force (lhstype
, newrhs
, 0);
6024 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
6025 NULL_TREE
, 0, complain
);
6026 if (TREE_CODE (newrhs
) == CALL_EXPR
6027 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6028 newrhs
= build_cplus_new (lhstype
, newrhs
);
6030 /* Can't initialize directly from a TARGET_EXPR, since that would
6031 cause the lhs to be constructed twice, and possibly result in
6032 accidental self-initialization. So we force the TARGET_EXPR to be
6033 expanded without a target. */
6034 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6035 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
6036 TREE_OPERAND (newrhs
, 0));
6039 if (newrhs
== error_mark_node
)
6040 return error_mark_node
;
6042 if (c_dialect_objc () && flag_objc_gc
)
6044 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
6050 result
= build2 (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6051 lhstype
, lhs
, newrhs
);
6053 TREE_SIDE_EFFECTS (result
) = 1;
6055 TREE_NO_WARNING (result
) = 1;
6057 /* If we got the LHS in a different type for storing in,
6058 convert the result back to the nominal type of LHS
6059 so that the value we return always has the same type
6060 as the LHS argument. */
6062 if (olhstype
== TREE_TYPE (result
))
6066 result
= build2 (COMPOUND_EXPR
, olhstype
, result
, olhs
);
6067 TREE_NO_WARNING (result
) = 1;
6070 return convert_for_assignment (olhstype
, result
, "assignment",
6071 NULL_TREE
, 0, complain
);
6075 build_x_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
,
6076 tsubst_flags_t complain
)
6078 if (processing_template_decl
)
6079 return build_min_nt (MODOP_EXPR
, lhs
,
6080 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
6082 if (modifycode
!= NOP_EXPR
)
6084 tree rval
= build_new_op (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
6085 make_node (modifycode
),
6086 /*overloaded_p=*/NULL
,
6090 TREE_NO_WARNING (rval
) = 1;
6094 return cp_build_modify_expr (lhs
, modifycode
, rhs
, complain
);
6097 /* Helper function for get_delta_difference which assumes FROM is a base
6098 class of TO. Returns a delta for the conversion of pointer-to-member
6099 of FROM to pointer-to-member of TO. If the conversion is invalid,
6100 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
6101 If C_CAST_P is true, this conversion is taking place as part of a C-style
6105 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
)
6110 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
, &kind
);
6111 if (kind
== bk_inaccessible
|| kind
== bk_ambig
)
6113 error (" in pointer to member function conversion");
6114 return size_zero_node
;
6118 if (kind
!= bk_via_virtual
)
6119 return BINFO_OFFSET (binfo
);
6121 /* FROM is a virtual base class of TO. Issue an error or warning
6122 depending on whether or not this is a reinterpret cast. */
6124 error ("pointer to member conversion via virtual base %qT",
6125 BINFO_TYPE (binfo_from_vbase (binfo
)));
6127 return size_zero_node
;
6134 /* Get difference in deltas for different pointer to member function
6135 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6136 the conversion is invalid, the constant is zero. If
6137 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6138 If C_CAST_P is true this conversion is taking place as part of a
6141 Note that the naming of FROM and TO is kind of backwards; the return
6142 value is what we add to a TO in order to get a FROM. They are named
6143 this way because we call this function to find out how to convert from
6144 a pointer to member of FROM to a pointer to member of TO. */
6147 get_delta_difference (tree from
, tree to
,
6148 bool allow_inverse_p
,
6153 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
6154 /* Pointer to member of incomplete class is permitted*/
6155 result
= size_zero_node
;
6157 result
= get_delta_difference_1 (from
, to
, c_cast_p
);
6161 if (!allow_inverse_p
)
6163 error_not_base_type (from
, to
);
6164 error (" in pointer to member conversion");
6165 result
= size_zero_node
;
6169 result
= get_delta_difference_1 (to
, from
, c_cast_p
);
6172 result
= size_diffop (size_zero_node
, result
);
6175 error_not_base_type (from
, to
);
6176 error (" in pointer to member conversion");
6177 result
= size_zero_node
;
6182 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node
,
6186 /* Return a constructor for the pointer-to-member-function TYPE using
6187 the other components as specified. */
6190 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
6195 VEC(constructor_elt
, gc
) *v
;
6197 /* Pull the FIELD_DECLs out of the type. */
6198 pfn_field
= TYPE_FIELDS (type
);
6199 delta_field
= TREE_CHAIN (pfn_field
);
6201 /* Make sure DELTA has the type we want. */
6202 delta
= convert_and_check (delta_type_node
, delta
);
6204 /* Convert to the correct target type if necessary. */
6205 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
6207 /* Finish creating the initializer. */
6208 v
= VEC_alloc(constructor_elt
, gc
, 2);
6209 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
6210 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
6211 u
= build_constructor (type
, v
);
6212 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
6213 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
6214 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
6216 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
6221 /* Build a constructor for a pointer to member function. It can be
6222 used to initialize global variables, local variable, or used
6223 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6226 If FORCE is nonzero, then force this conversion, even if
6227 we would rather not do it. Usually set when using an explicit
6228 cast. A C-style cast is being processed iff C_CAST_P is true.
6230 Return error_mark_node, if something goes wrong. */
6233 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
)
6239 if (error_operand_p (pfn
))
6240 return error_mark_node
;
6242 pfn_type
= TREE_TYPE (pfn
);
6243 to_type
= build_ptrmemfunc_type (type
);
6245 /* Handle multiple conversions of pointer to member functions. */
6246 if (TYPE_PTRMEMFUNC_P (pfn_type
))
6248 tree delta
= NULL_TREE
;
6249 tree npfn
= NULL_TREE
;
6253 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
, LOOKUP_NORMAL
))
6254 error ("invalid conversion to type %qT from type %qT",
6257 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
6258 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
6262 /* We don't have to do any conversion to convert a
6263 pointer-to-member to its own type. But, we don't want to
6264 just return a PTRMEM_CST if there's an explicit cast; that
6265 cast should make the expression an invalid template argument. */
6266 if (TREE_CODE (pfn
) != PTRMEM_CST
)
6268 if (same_type_p (to_type
, pfn_type
))
6270 else if (integer_zerop (n
))
6271 return build_reinterpret_cast (to_type
, pfn
,
6272 tf_warning_or_error
);
6275 if (TREE_SIDE_EFFECTS (pfn
))
6276 pfn
= save_expr (pfn
);
6278 /* Obtain the function pointer and the current DELTA. */
6279 if (TREE_CODE (pfn
) == PTRMEM_CST
)
6280 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
6283 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
6284 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
6287 /* Just adjust the DELTA field. */
6288 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6289 (TREE_TYPE (delta
), ptrdiff_type_node
));
6290 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
6291 n
= cp_build_binary_op (LSHIFT_EXPR
, n
, integer_one_node
,
6292 tf_warning_or_error
);
6293 delta
= cp_build_binary_op (PLUS_EXPR
, delta
, n
, tf_warning_or_error
);
6294 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
6297 /* Handle null pointer to member function conversions. */
6298 if (integer_zerop (pfn
))
6300 pfn
= build_c_cast (type
, integer_zero_node
);
6301 return build_ptrmemfunc1 (to_type
,
6306 if (type_unknown_p (pfn
))
6307 return instantiate_type (type
, pfn
, tf_warning_or_error
);
6309 fn
= TREE_OPERAND (pfn
, 0);
6310 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6311 /* In a template, we will have preserved the
6313 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
6314 return make_ptrmem_cst (to_type
, fn
);
6317 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6320 ??? There is no consistency as to the types returned for the above
6321 values. Some code acts as if it were a sizetype and some as if it were
6322 integer_type_node. */
6325 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
6327 tree type
= TREE_TYPE (cst
);
6328 tree fn
= PTRMEM_CST_MEMBER (cst
);
6329 tree ptr_class
, fn_class
;
6331 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6333 /* The class that the function belongs to. */
6334 fn_class
= DECL_CONTEXT (fn
);
6336 /* The class that we're creating a pointer to member of. */
6337 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
6339 /* First, calculate the adjustment to the function's class. */
6340 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
6343 if (!DECL_VIRTUAL_P (fn
))
6344 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), build_addr_func (fn
));
6347 /* If we're dealing with a virtual function, we have to adjust 'this'
6348 again, to point to the base which provides the vtable entry for
6349 fn; the call will do the opposite adjustment. */
6350 tree orig_class
= DECL_CONTEXT (fn
);
6351 tree binfo
= binfo_or_else (orig_class
, fn_class
);
6352 *delta
= build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
6353 *delta
, BINFO_OFFSET (binfo
));
6354 *delta
= fold_if_not_in_template (*delta
);
6356 /* We set PFN to the vtable offset at which the function can be
6357 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6358 case delta is shifted left, and then incremented). */
6359 *pfn
= DECL_VINDEX (fn
);
6360 *pfn
= build2 (MULT_EXPR
, integer_type_node
, *pfn
,
6361 TYPE_SIZE_UNIT (vtable_entry_type
));
6362 *pfn
= fold_if_not_in_template (*pfn
);
6364 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
6366 case ptrmemfunc_vbit_in_pfn
:
6367 *pfn
= build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
6369 *pfn
= fold_if_not_in_template (*pfn
);
6372 case ptrmemfunc_vbit_in_delta
:
6373 *delta
= build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
6374 *delta
, integer_one_node
);
6375 *delta
= fold_if_not_in_template (*delta
);
6376 *delta
= build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
6377 *delta
, integer_one_node
);
6378 *delta
= fold_if_not_in_template (*delta
);
6385 *pfn
= build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
6386 *pfn
= fold_if_not_in_template (*pfn
);
6390 /* Return an expression for PFN from the pointer-to-member function
6394 pfn_from_ptrmemfunc (tree t
)
6396 if (TREE_CODE (t
) == PTRMEM_CST
)
6401 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
6406 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
6409 /* Return an expression for DELTA from the pointer-to-member function
6413 delta_from_ptrmemfunc (tree t
)
6415 if (TREE_CODE (t
) == PTRMEM_CST
)
6420 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
6425 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
6428 /* Convert value RHS to type TYPE as preparation for an assignment to
6429 an lvalue of type TYPE. ERRTYPE is a string to use in error
6430 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6431 are doing the conversion in order to pass the PARMNUMth argument of
6435 convert_for_assignment (tree type
, tree rhs
,
6436 const char *errtype
, tree fndecl
, int parmnum
,
6437 tsubst_flags_t complain
)
6440 enum tree_code coder
;
6442 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6443 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6444 rhs
= TREE_OPERAND (rhs
, 0);
6446 rhstype
= TREE_TYPE (rhs
);
6447 coder
= TREE_CODE (rhstype
);
6449 if (TREE_CODE (type
) == VECTOR_TYPE
&& coder
== VECTOR_TYPE
6450 && vector_types_convertible_p (type
, rhstype
, true))
6451 return convert (type
, rhs
);
6453 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
6454 return error_mark_node
;
6455 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6456 return error_mark_node
;
6458 /* The RHS of an assignment cannot have void type. */
6459 if (coder
== VOID_TYPE
)
6461 if (complain
& tf_error
)
6462 error ("void value not ignored as it ought to be");
6463 return error_mark_node
;
6466 /* Simplify the RHS if possible. */
6467 if (TREE_CODE (rhs
) == CONST_DECL
)
6468 rhs
= DECL_INITIAL (rhs
);
6470 if (c_dialect_objc ())
6473 tree rname
= fndecl
;
6475 if (!strcmp (errtype
, "assignment"))
6477 else if (!strcmp (errtype
, "initialization"))
6481 tree selector
= objc_message_selector ();
6485 if (selector
&& parmno
> 1)
6492 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
6493 return convert (type
, rhs
);
6498 The expression is implicitly converted (clause _conv_) to the
6499 cv-unqualified type of the left operand.
6501 We allow bad conversions here because by the time we get to this point
6502 we are committed to doing the conversion. If we end up doing a bad
6503 conversion, convert_like will complain. */
6504 if (!can_convert_arg_bad (type
, rhstype
, rhs
))
6506 /* When -Wno-pmf-conversions is use, we just silently allow
6507 conversions from pointers-to-members to plain pointers. If
6508 the conversion doesn't work, cp_convert will complain. */
6510 && TYPE_PTR_P (type
)
6511 && TYPE_PTRMEMFUNC_P (rhstype
))
6512 rhs
= cp_convert (strip_top_quals (type
), rhs
);
6515 if (complain
& tf_error
)
6517 /* If the right-hand side has unknown type, then it is an
6518 overloaded function. Call instantiate_type to get error
6520 if (rhstype
== unknown_type_node
)
6521 instantiate_type (type
, rhs
, tf_warning_or_error
);
6523 error ("cannot convert %qT to %qT for argument %qP to %qD",
6524 rhstype
, type
, parmnum
, fndecl
);
6526 error ("cannot convert %qT to %qT in %s", rhstype
, type
,
6529 return error_mark_node
;
6532 if (warn_missing_format_attribute
)
6534 const enum tree_code codel
= TREE_CODE (type
);
6535 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6537 && check_missing_format_attribute (type
, rhstype
)
6538 && (complain
& tf_warning
))
6539 warning (OPT_Wmissing_format_attribute
,
6540 "%s might be a candidate for a format attribute",
6544 /* If -Wparentheses, warn about a = b = c when a has type bool and b
6546 if (warn_parentheses
6547 && type
== boolean_type_node
6548 && TREE_CODE (rhs
) == MODIFY_EXPR
6549 && !TREE_NO_WARNING (rhs
)
6550 && TREE_TYPE (rhs
) != boolean_type_node
6551 && (complain
& tf_warning
))
6553 warning (OPT_Wparentheses
,
6554 "suggest parentheses around assignment used as truth value");
6555 TREE_NO_WARNING (rhs
) = 1;
6558 return perform_implicit_conversion (strip_top_quals (type
), rhs
, complain
);
6561 /* Convert RHS to be of type TYPE.
6562 If EXP is nonzero, it is the target of the initialization.
6563 ERRTYPE is a string to use in error messages.
6565 Two major differences between the behavior of
6566 `convert_for_assignment' and `convert_for_initialization'
6567 are that references are bashed in the former, while
6568 copied in the latter, and aggregates are assigned in
6569 the former (operator=) while initialized in the
6572 If using constructor make sure no conversion operator exists, if one does
6573 exist, an ambiguity exists.
6575 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6578 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
6579 const char *errtype
, tree fndecl
, int parmnum
,
6580 tsubst_flags_t complain
)
6582 enum tree_code codel
= TREE_CODE (type
);
6584 enum tree_code coder
;
6586 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6587 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6588 if (TREE_CODE (rhs
) == NOP_EXPR
6589 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6590 && codel
!= REFERENCE_TYPE
)
6591 rhs
= TREE_OPERAND (rhs
, 0);
6593 if (type
== error_mark_node
6594 || rhs
== error_mark_node
6595 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6596 return error_mark_node
;
6598 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6599 && TREE_CODE (type
) != ARRAY_TYPE
6600 && (TREE_CODE (type
) != REFERENCE_TYPE
6601 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6602 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6603 && (TREE_CODE (type
) != REFERENCE_TYPE
6604 || TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
))
6605 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6606 rhs
= decay_conversion (rhs
);
6608 rhstype
= TREE_TYPE (rhs
);
6609 coder
= TREE_CODE (rhstype
);
6611 if (coder
== ERROR_MARK
)
6612 return error_mark_node
;
6614 /* We accept references to incomplete types, so we can
6615 return here before checking if RHS is of complete type. */
6617 if (codel
== REFERENCE_TYPE
)
6619 /* This should eventually happen in convert_arguments. */
6620 int savew
= 0, savee
= 0;
6623 savew
= warningcount
, savee
= errorcount
;
6624 rhs
= initialize_reference (type
, rhs
, /*decl=*/NULL_TREE
,
6628 if (warningcount
> savew
)
6629 warning (0, "in passing argument %P of %q+D", parmnum
, fndecl
);
6630 else if (errorcount
> savee
)
6631 error ("in passing argument %P of %q+D", parmnum
, fndecl
);
6637 exp
= require_complete_type (exp
);
6638 if (exp
== error_mark_node
)
6639 return error_mark_node
;
6641 rhstype
= non_reference (rhstype
);
6643 type
= complete_type (type
);
6645 if (MAYBE_CLASS_TYPE_P (type
))
6646 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
6648 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
6652 /* If RETVAL is the address of, or a reference to, a local variable or
6653 temporary give an appropriate warning. */
6656 maybe_warn_about_returning_address_of_local (tree retval
)
6658 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
6659 tree whats_returned
= retval
;
6663 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
6664 whats_returned
= TREE_OPERAND (whats_returned
, 1);
6665 else if (CONVERT_EXPR_P (whats_returned
)
6666 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
6667 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6672 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
6674 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6676 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6678 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
6679 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
6681 warning (0, "returning reference to temporary");
6684 if (TREE_CODE (whats_returned
) == VAR_DECL
6685 && DECL_NAME (whats_returned
)
6686 && TEMP_NAME_P (DECL_NAME (whats_returned
)))
6688 warning (0, "reference to non-lvalue returned");
6693 while (TREE_CODE (whats_returned
) == COMPONENT_REF
6694 || TREE_CODE (whats_returned
) == ARRAY_REF
)
6695 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6697 if (DECL_P (whats_returned
)
6698 && DECL_NAME (whats_returned
)
6699 && DECL_FUNCTION_SCOPE_P (whats_returned
)
6700 && !(TREE_STATIC (whats_returned
)
6701 || TREE_PUBLIC (whats_returned
)))
6703 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6704 warning (0, "reference to local variable %q+D returned",
6707 warning (0, "address of local variable %q+D returned",
6713 /* Check that returning RETVAL from the current function is valid.
6714 Return an expression explicitly showing all conversions required to
6715 change RETVAL into the function return type, and to assign it to
6716 the DECL_RESULT for the function. Set *NO_WARNING to true if
6717 code reaches end of non-void function warning shouldn't be issued
6718 on this RETURN_EXPR. */
6721 check_return_expr (tree retval
, bool *no_warning
)
6724 /* The type actually returned by the function, after any
6727 int fn_returns_value_p
;
6728 bool named_return_value_okay_p
;
6730 *no_warning
= false;
6732 /* A `volatile' function is one that isn't supposed to return, ever.
6733 (This is a G++ extension, used to get better code for functions
6734 that call the `volatile' function.) */
6735 if (TREE_THIS_VOLATILE (current_function_decl
))
6736 warning (0, "function declared %<noreturn%> has a %<return%> statement");
6738 /* Check for various simple errors. */
6739 if (DECL_DESTRUCTOR_P (current_function_decl
))
6742 error ("returning a value from a destructor");
6745 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
6747 if (in_function_try_handler
)
6748 /* If a return statement appears in a handler of the
6749 function-try-block of a constructor, the program is ill-formed. */
6750 error ("cannot return from a handler of a function-try-block of a constructor");
6752 /* You can't return a value from a constructor. */
6753 error ("returning a value from a constructor");
6757 if (processing_template_decl
)
6759 current_function_returns_value
= 1;
6760 if (check_for_bare_parameter_packs (retval
))
6761 retval
= error_mark_node
;
6765 /* When no explicit return-value is given in a function with a named
6766 return value, the named return value is used. */
6767 result
= DECL_RESULT (current_function_decl
);
6768 valtype
= TREE_TYPE (result
);
6769 gcc_assert (valtype
!= NULL_TREE
);
6770 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
6771 if (!retval
&& DECL_NAME (result
) && fn_returns_value_p
)
6774 /* Check for a return statement with no return value in a function
6775 that's supposed to return a value. */
6776 if (!retval
&& fn_returns_value_p
)
6778 permerror (input_location
, "return-statement with no value, in function returning %qT",
6780 /* Clear this, so finish_function won't say that we reach the
6781 end of a non-void function (which we don't, we gave a
6783 current_function_returns_null
= 0;
6784 /* And signal caller that TREE_NO_WARNING should be set on the
6785 RETURN_EXPR to avoid control reaches end of non-void function
6786 warnings in tree-cfg.c. */
6789 /* Check for a return statement with a value in a function that
6790 isn't supposed to return a value. */
6791 else if (retval
&& !fn_returns_value_p
)
6793 if (VOID_TYPE_P (TREE_TYPE (retval
)))
6794 /* You can return a `void' value from a function of `void'
6795 type. In that case, we have to evaluate the expression for
6796 its side-effects. */
6797 finish_expr_stmt (retval
);
6799 permerror (input_location
, "return-statement with a value, in function "
6800 "returning 'void'");
6801 current_function_returns_null
= 1;
6803 /* There's really no value to return, after all. */
6807 /* Remember that this function can sometimes return without a
6809 current_function_returns_null
= 1;
6811 /* Remember that this function did return a value. */
6812 current_function_returns_value
= 1;
6814 /* Check for erroneous operands -- but after giving ourselves a
6815 chance to provide an error about returning a value from a void
6817 if (error_operand_p (retval
))
6819 current_function_return_value
= error_mark_node
;
6820 return error_mark_node
;
6823 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6824 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == NEW_EXPR
6825 || DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == VEC_NEW_EXPR
)
6826 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
6828 && retval
&& null_ptr_cst_p (retval
))
6829 warning (0, "%<operator new%> must not return NULL unless it is "
6830 "declared %<throw()%> (or -fcheck-new is in effect)");
6832 /* Effective C++ rule 15. See also start_function. */
6834 && DECL_NAME (current_function_decl
) == ansi_assopname(NOP_EXPR
))
6838 /* The function return type must be a reference to the current
6840 if (TREE_CODE (valtype
) == REFERENCE_TYPE
6841 && same_type_ignoring_top_level_qualifiers_p
6842 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
6844 /* Returning '*this' is obviously OK. */
6845 if (retval
== current_class_ref
)
6847 /* If we are calling a function whose return type is the same of
6848 the current class reference, it is ok. */
6849 else if (TREE_CODE (retval
) == INDIRECT_REF
6850 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
6855 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
6858 /* The fabled Named Return Value optimization, as per [class.copy]/15:
6860 [...] For a function with a class return type, if the expression
6861 in the return statement is the name of a local object, and the cv-
6862 unqualified type of the local object is the same as the function
6863 return type, an implementation is permitted to omit creating the tem-
6864 porary object to hold the function return value [...]
6866 So, if this is a value-returning function that always returns the same
6867 local variable, remember it.
6869 It might be nice to be more flexible, and choose the first suitable
6870 variable even if the function sometimes returns something else, but
6871 then we run the risk of clobbering the variable we chose if the other
6872 returned expression uses the chosen variable somehow. And people expect
6873 this restriction, anyway. (jason 2000-11-19)
6875 See finish_function and finalize_nrv for the rest of this optimization. */
6877 named_return_value_okay_p
=
6878 (retval
!= NULL_TREE
6879 /* Must be a local, automatic variable. */
6880 && TREE_CODE (retval
) == VAR_DECL
6881 && DECL_CONTEXT (retval
) == current_function_decl
6882 && ! TREE_STATIC (retval
)
6883 && ! DECL_ANON_UNION_VAR_P (retval
)
6884 && (DECL_ALIGN (retval
)
6885 >= DECL_ALIGN (DECL_RESULT (current_function_decl
)))
6886 /* The cv-unqualified type of the returned value must be the
6887 same as the cv-unqualified return type of the
6889 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval
))),
6891 (TREE_TYPE (TREE_TYPE (current_function_decl
)))))
6892 /* And the returned value must be non-volatile. */
6893 && ! TYPE_VOLATILE (TREE_TYPE (retval
)));
6895 if (fn_returns_value_p
&& flag_elide_constructors
)
6897 if (named_return_value_okay_p
6898 && (current_function_return_value
== NULL_TREE
6899 || current_function_return_value
== retval
))
6900 current_function_return_value
= retval
;
6902 current_function_return_value
= error_mark_node
;
6905 /* We don't need to do any conversions when there's nothing being
6910 /* Do any required conversions. */
6911 if (retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
6912 /* No conversions are required. */
6916 /* The type the function is declared to return. */
6917 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6918 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
6920 /* The functype's return type will have been set to void, if it
6921 was an incomplete type. Just treat this as 'return;' */
6922 if (VOID_TYPE_P (functype
))
6923 return error_mark_node
;
6925 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
6926 treated as an rvalue for the purposes of overload resolution to
6927 favor move constructors over copy constructors. */
6928 if ((cxx_dialect
!= cxx98
)
6929 && named_return_value_okay_p
6930 /* The variable must not have the `volatile' qualifier. */
6931 && !(cp_type_quals (TREE_TYPE (retval
)) & TYPE_QUAL_VOLATILE
)
6932 /* The return type must be a class type. */
6933 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
6934 flags
= flags
| LOOKUP_PREFER_RVALUE
;
6936 /* First convert the value to the function's return type, then
6937 to the type of return value's location to handle the
6938 case that functype is smaller than the valtype. */
6939 retval
= convert_for_initialization
6940 (NULL_TREE
, functype
, retval
, flags
, "return", NULL_TREE
, 0,
6941 tf_warning_or_error
);
6942 retval
= convert (valtype
, retval
);
6944 /* If the conversion failed, treat this just like `return;'. */
6945 if (retval
== error_mark_node
)
6947 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6948 else if (! cfun
->returns_struct
6949 && TREE_CODE (retval
) == TARGET_EXPR
6950 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
6951 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
6952 TREE_OPERAND (retval
, 0));
6954 maybe_warn_about_returning_address_of_local (retval
);
6957 /* Actually copy the value returned into the appropriate location. */
6958 if (retval
&& retval
!= result
)
6959 retval
= build2 (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
6965 /* Returns nonzero if the pointer-type FROM can be converted to the
6966 pointer-type TO via a qualification conversion. If CONSTP is -1,
6967 then we return nonzero if the pointers are similar, and the
6968 cv-qualification signature of FROM is a proper subset of that of TO.
6970 If CONSTP is positive, then all outer pointers have been
6974 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
6976 bool to_more_cv_qualified
= false;
6977 bool is_opaque_pointer
= false;
6979 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
6981 if (TREE_CODE (to
) != TREE_CODE (from
))
6984 if (TREE_CODE (from
) == OFFSET_TYPE
6985 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
6986 TYPE_OFFSET_BASETYPE (to
)))
6989 /* Const and volatile mean something different for function types,
6990 so the usual checks are not appropriate. */
6991 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
6993 /* In Objective-C++, some types may have been 'volatilized' by
6994 the compiler for EH; when comparing them here, the volatile
6995 qualification must be ignored. */
6996 bool objc_quals_match
= objc_type_quals_match (to
, from
);
6998 if (!at_least_as_qualified_p (to
, from
) && !objc_quals_match
)
7001 if (!at_least_as_qualified_p (from
, to
) && !objc_quals_match
)
7005 to_more_cv_qualified
= true;
7009 constp
&= TYPE_READONLY (to
);
7012 if (TREE_CODE (to
) == VECTOR_TYPE
)
7013 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
7015 if (TREE_CODE (to
) != POINTER_TYPE
&& !TYPE_PTRMEM_P (to
))
7016 return ((constp
>= 0 || to_more_cv_qualified
)
7017 && (is_opaque_pointer
7018 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
7022 /* When comparing, say, char ** to char const **, this function takes
7023 the 'char *' and 'char const *'. Do not pass non-pointer/reference
7024 types to this function. */
7027 comp_ptr_ttypes (tree to
, tree from
)
7029 return comp_ptr_ttypes_real (to
, from
, 1);
7032 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7033 type or inheritance-related types, regardless of cv-quals. */
7036 ptr_reasonably_similar (const_tree to
, const_tree from
)
7038 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7040 /* Any target type is similar enough to void. */
7041 if (TREE_CODE (to
) == VOID_TYPE
7042 || TREE_CODE (from
) == VOID_TYPE
)
7045 if (TREE_CODE (to
) != TREE_CODE (from
))
7048 if (TREE_CODE (from
) == OFFSET_TYPE
7049 && comptypes (TYPE_OFFSET_BASETYPE (to
),
7050 TYPE_OFFSET_BASETYPE (from
),
7051 COMPARE_BASE
| COMPARE_DERIVED
))
7054 if (TREE_CODE (to
) == VECTOR_TYPE
7055 && vector_types_convertible_p (to
, from
, false))
7058 if (TREE_CODE (to
) == INTEGER_TYPE
7059 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
7062 if (TREE_CODE (to
) == FUNCTION_TYPE
)
7065 if (TREE_CODE (to
) != POINTER_TYPE
)
7067 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
7068 COMPARE_BASE
| COMPARE_DERIVED
);
7072 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7073 pointer-to-member types) are the same, ignoring cv-qualification at
7077 comp_ptr_ttypes_const (tree to
, tree from
)
7079 bool is_opaque_pointer
= false;
7081 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7083 if (TREE_CODE (to
) != TREE_CODE (from
))
7086 if (TREE_CODE (from
) == OFFSET_TYPE
7087 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7088 TYPE_OFFSET_BASETYPE (to
)))
7091 if (TREE_CODE (to
) == VECTOR_TYPE
)
7092 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
7094 if (TREE_CODE (to
) != POINTER_TYPE
)
7095 return (is_opaque_pointer
7096 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
7100 /* Returns the type qualifiers for this type, including the qualifiers on the
7101 elements for an array type. */
7104 cp_type_quals (const_tree type
)
7106 /* This CONST_CAST is okay because strip_array_types returns its
7107 argument unmodified and we assign it to a const_tree. */
7108 type
= strip_array_types (CONST_CAST_TREE(type
));
7109 if (type
== error_mark_node
)
7110 return TYPE_UNQUALIFIED
;
7111 return TYPE_QUALS (type
);
7114 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7118 cp_type_readonly (const_tree type
)
7120 /* This CONST_CAST is okay because strip_array_types returns its
7121 argument unmodified and we assign it to a const_tree. */
7122 type
= strip_array_types (CONST_CAST_TREE(type
));
7123 return TYPE_READONLY (type
);
7126 /* Returns nonzero if the TYPE contains a mutable member. */
7129 cp_has_mutable_p (const_tree type
)
7131 /* This CONST_CAST is okay because strip_array_types returns its
7132 argument unmodified and we assign it to a const_tree. */
7133 type
= strip_array_types (CONST_CAST_TREE(type
));
7135 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
7138 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7139 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7140 approximation. In particular, consider:
7143 struct S { int i; };
7144 const S s = { f(); }
7146 Here, we will make "s" as TREE_READONLY (because it is declared
7147 "const") -- only to reverse ourselves upon seeing that the
7148 initializer is non-constant. */
7151 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
7153 tree type
= TREE_TYPE (decl
);
7155 if (type
== error_mark_node
)
7158 if (TREE_CODE (type
) == FUNCTION_TYPE
7159 && type_quals
!= TYPE_UNQUALIFIED
)
7161 /* This was an error in C++98 (cv-qualifiers cannot be added to
7162 a function type), but DR 295 makes the code well-formed by
7163 dropping the extra qualifiers. */
7166 tree bad_type
= build_qualified_type (type
, type_quals
);
7167 pedwarn (input_location
, OPT_pedantic
,
7168 "ignoring %qV qualifiers added to function type %qT",
7172 TREE_TYPE (decl
) = TYPE_MAIN_VARIANT (type
);
7176 /* Avoid setting TREE_READONLY incorrectly. */
7177 if (/* If the object has a constructor, the constructor may modify
7179 TYPE_NEEDS_CONSTRUCTING (type
)
7180 /* If the type isn't complete, we don't know yet if it will need
7182 || !COMPLETE_TYPE_P (type
)
7183 /* If the type has a mutable component, that component might be
7185 || TYPE_HAS_MUTABLE_P (type
))
7186 type_quals
&= ~TYPE_QUAL_CONST
;
7188 c_apply_type_quals_to_decl (type_quals
, decl
);
7191 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7192 exemplar types such that casting T1 to T2 is casting away constness
7193 if and only if there is no implicit conversion from T1 to T2. */
7196 casts_away_constness_r (tree
*t1
, tree
*t2
)
7201 /* [expr.const.cast]
7203 For multi-level pointer to members and multi-level mixed pointers
7204 and pointers to members (conv.qual), the "member" aspect of a
7205 pointer to member level is ignored when determining if a const
7206 cv-qualifier has been cast away. */
7207 /* [expr.const.cast]
7209 For two pointer types:
7211 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7212 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7215 casting from X1 to X2 casts away constness if, for a non-pointer
7216 type T there does not exist an implicit conversion (clause
7219 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7223 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7224 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRMEM_P (*t1
))
7225 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRMEM_P (*t2
)))
7227 *t1
= cp_build_qualified_type (void_type_node
,
7228 cp_type_quals (*t1
));
7229 *t2
= cp_build_qualified_type (void_type_node
,
7230 cp_type_quals (*t2
));
7234 quals1
= cp_type_quals (*t1
);
7235 quals2
= cp_type_quals (*t2
);
7237 if (TYPE_PTRMEM_P (*t1
))
7238 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
7240 *t1
= TREE_TYPE (*t1
);
7241 if (TYPE_PTRMEM_P (*t2
))
7242 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
7244 *t2
= TREE_TYPE (*t2
);
7246 casts_away_constness_r (t1
, t2
);
7247 *t1
= build_pointer_type (*t1
);
7248 *t2
= build_pointer_type (*t2
);
7249 *t1
= cp_build_qualified_type (*t1
, quals1
);
7250 *t2
= cp_build_qualified_type (*t2
, quals2
);
7253 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7257 casts_away_constness (tree t1
, tree t2
)
7259 if (TREE_CODE (t2
) == REFERENCE_TYPE
)
7261 /* [expr.const.cast]
7263 Casting from an lvalue of type T1 to an lvalue of type T2
7264 using a reference cast casts away constness if a cast from an
7265 rvalue of type "pointer to T1" to the type "pointer to T2"
7266 casts away constness. */
7267 t1
= (TREE_CODE (t1
) == REFERENCE_TYPE
? TREE_TYPE (t1
) : t1
);
7268 return casts_away_constness (build_pointer_type (t1
),
7269 build_pointer_type (TREE_TYPE (t2
)));
7272 if (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
))
7273 /* [expr.const.cast]
7275 Casting from an rvalue of type "pointer to data member of X
7276 of type T1" to the type "pointer to data member of Y of type
7277 T2" casts away constness if a cast from an rvalue of type
7278 "pointer to T1" to the type "pointer to T2" casts away
7280 return casts_away_constness
7281 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
7282 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)));
7284 /* Casting away constness is only something that makes sense for
7285 pointer or reference types. */
7286 if (TREE_CODE (t1
) != POINTER_TYPE
7287 || TREE_CODE (t2
) != POINTER_TYPE
)
7290 /* Top-level qualifiers don't matter. */
7291 t1
= TYPE_MAIN_VARIANT (t1
);
7292 t2
= TYPE_MAIN_VARIANT (t2
);
7293 casts_away_constness_r (&t1
, &t2
);
7294 if (!can_convert (t2
, t1
))
7300 /* If T is a REFERENCE_TYPE return the type to which T refers.
7301 Otherwise, return T itself. */
7304 non_reference (tree t
)
7306 if (TREE_CODE (t
) == REFERENCE_TYPE
)
7312 /* Return nonzero if REF is an lvalue valid for this language;
7313 otherwise, print an error message and return zero. USE says
7314 how the lvalue is being used and so selects the error message. */
7317 lvalue_or_else (const_tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
7319 int win
= lvalue_p (ref
);
7321 if (!win
&& (complain
& tf_error
))