1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* This file is part of the C++ front end.
25 It contains routines to build C++ expressions given their operands,
26 including computing the types of the result, C and C++ specific error
27 checks, and some optimization. */
31 #include "coretypes.h"
41 #include "diagnostic.h"
48 static tree
pfn_from_ptrmemfunc (tree
);
49 static tree
delta_from_ptrmemfunc (tree
);
50 static tree
convert_for_assignment (tree
, tree
, const char *, tree
, int,
52 static tree
cp_pointer_int_sum (enum tree_code
, tree
, tree
);
53 static tree
rationalize_conditional_expr (enum tree_code
, tree
,
55 static int comp_ptr_ttypes_real (tree
, tree
, int);
56 static bool comp_except_types (tree
, tree
, bool);
57 static bool comp_array_types (const_tree
, const_tree
, bool);
58 static tree
pointer_diff (tree
, tree
, tree
);
59 static tree
get_delta_difference (tree
, tree
, bool, bool);
60 static void casts_away_constness_r (tree
*, tree
*);
61 static bool casts_away_constness (tree
, tree
);
62 static void maybe_warn_about_returning_address_of_local (tree
);
63 static tree
lookup_destructor (tree
, tree
, tree
);
64 static int convert_arguments (tree
, VEC(tree
,gc
) **, tree
, int,
67 /* Do `exp = require_complete_type (exp);' to make sure exp
68 does not have an incomplete type. (That includes void types.)
69 Returns the error_mark_node if the VALUE does not have
70 complete type when this function returns. */
73 require_complete_type (tree value
)
77 if (processing_template_decl
|| value
== error_mark_node
)
80 if (TREE_CODE (value
) == OVERLOAD
)
81 type
= unknown_type_node
;
83 type
= TREE_TYPE (value
);
85 if (type
== error_mark_node
)
86 return error_mark_node
;
88 /* First, detect a valid value with a complete type. */
89 if (COMPLETE_TYPE_P (type
))
92 if (complete_type_or_else (type
, value
))
95 return error_mark_node
;
98 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
99 a template instantiation, do the instantiation. Returns TYPE,
100 whether or not it could be completed, unless something goes
101 horribly wrong, in which case the error_mark_node is returned. */
104 complete_type (tree type
)
106 if (type
== NULL_TREE
)
107 /* Rather than crash, we return something sure to cause an error
109 return error_mark_node
;
111 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
113 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
115 tree t
= complete_type (TREE_TYPE (type
));
116 unsigned int needs_constructing
, has_nontrivial_dtor
;
117 if (COMPLETE_TYPE_P (t
) && !dependent_type_p (type
))
120 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
122 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
123 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
125 TYPE_NEEDS_CONSTRUCTING (t
) = needs_constructing
;
126 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = has_nontrivial_dtor
;
129 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
130 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
135 /* Like complete_type, but issue an error if the TYPE cannot be completed.
136 VALUE is used for informative diagnostics.
137 Returns NULL_TREE if the type cannot be made complete. */
140 complete_type_or_else (tree type
, tree value
)
142 type
= complete_type (type
);
143 if (type
== error_mark_node
)
144 /* We already issued an error. */
146 else if (!COMPLETE_TYPE_P (type
))
148 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
155 /* Return truthvalue of whether type of EXP is instantiated. */
158 type_unknown_p (const_tree exp
)
160 return (TREE_CODE (exp
) == TREE_LIST
161 || TREE_TYPE (exp
) == unknown_type_node
);
165 /* Return the common type of two parameter lists.
166 We assume that comptypes has already been done and returned 1;
167 if that isn't so, this may crash.
169 As an optimization, free the space we allocate if the parameter
170 lists are already common. */
173 commonparms (tree p1
, tree p2
)
175 tree oldargs
= p1
, newargs
, n
;
179 len
= list_length (p1
);
180 newargs
= tree_last (p1
);
182 if (newargs
== void_list_node
)
191 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
196 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
198 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
200 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
203 else if (! TREE_PURPOSE (p1
))
205 if (TREE_PURPOSE (p2
))
207 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
213 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
215 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
217 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
220 TREE_VALUE (n
) = merge_types (TREE_VALUE (p1
), TREE_VALUE (p2
));
223 TREE_VALUE (n
) = TREE_VALUE (p1
);
231 /* Given a type, perhaps copied for a typedef,
232 find the "original" version of it. */
234 original_type (tree t
)
236 int quals
= cp_type_quals (t
);
237 while (t
!= error_mark_node
238 && TYPE_NAME (t
) != NULL_TREE
)
240 tree x
= TYPE_NAME (t
);
241 if (TREE_CODE (x
) != TYPE_DECL
)
243 x
= DECL_ORIGINAL_TYPE (x
);
248 return cp_build_qualified_type (t
, quals
);
251 /* Return the common type for two arithmetic types T1 and T2 under the
252 usual arithmetic conversions. The default conversions have already
253 been applied, and enumerated types converted to their compatible
257 cp_common_type (tree t1
, tree t2
)
259 enum tree_code code1
= TREE_CODE (t1
);
260 enum tree_code code2
= TREE_CODE (t2
);
263 /* In what follows, we slightly generalize the rules given in [expr] so
264 as to deal with `long long' and `complex'. First, merge the
266 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
268 if (SCOPED_ENUM_P (t1
) || SCOPED_ENUM_P (t2
))
270 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
271 return build_type_attribute_variant (t1
, attributes
);
276 /* FIXME: Attributes. */
277 gcc_assert (ARITHMETIC_TYPE_P (t1
)
278 || TREE_CODE (t1
) == VECTOR_TYPE
279 || UNSCOPED_ENUM_P (t1
));
280 gcc_assert (ARITHMETIC_TYPE_P (t2
)
281 || TREE_CODE (t2
) == VECTOR_TYPE
282 || UNSCOPED_ENUM_P (t2
));
284 /* If one type is complex, form the common type of the non-complex
285 components, then make that complex. Use T1 or T2 if it is the
287 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
289 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
290 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
292 = type_after_usual_arithmetic_conversions (subtype1
, subtype2
);
294 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
295 return build_type_attribute_variant (t1
, attributes
);
296 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
297 return build_type_attribute_variant (t2
, attributes
);
299 return build_type_attribute_variant (build_complex_type (subtype
),
303 if (code1
== VECTOR_TYPE
)
305 /* When we get here we should have two vectors of the same size.
306 Just prefer the unsigned one if present. */
307 if (TYPE_UNSIGNED (t1
))
308 return build_type_attribute_variant (t1
, attributes
);
310 return build_type_attribute_variant (t2
, attributes
);
313 /* If only one is real, use it as the result. */
314 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
315 return build_type_attribute_variant (t1
, attributes
);
316 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
317 return build_type_attribute_variant (t2
, attributes
);
319 /* Both real or both integers; use the one with greater precision. */
320 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
321 return build_type_attribute_variant (t1
, attributes
);
322 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
323 return build_type_attribute_variant (t2
, attributes
);
325 /* The types are the same; no need to do anything fancy. */
326 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
327 return build_type_attribute_variant (t1
, attributes
);
329 if (code1
!= REAL_TYPE
)
331 /* If one is unsigned long long, then convert the other to unsigned
333 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
334 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
335 return build_type_attribute_variant (long_long_unsigned_type_node
,
337 /* If one is a long long, and the other is an unsigned long, and
338 long long can represent all the values of an unsigned long, then
339 convert to a long long. Otherwise, convert to an unsigned long
340 long. Otherwise, if either operand is long long, convert the
343 Since we're here, we know the TYPE_PRECISION is the same;
344 therefore converting to long long cannot represent all the values
345 of an unsigned long, so we choose unsigned long long in that
347 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
348 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
350 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
351 ? long_long_unsigned_type_node
352 : long_long_integer_type_node
);
353 return build_type_attribute_variant (t
, attributes
);
356 /* Go through the same procedure, but for longs. */
357 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
358 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
359 return build_type_attribute_variant (long_unsigned_type_node
,
361 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
362 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
364 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
365 ? long_unsigned_type_node
: long_integer_type_node
);
366 return build_type_attribute_variant (t
, attributes
);
368 /* Otherwise prefer the unsigned one. */
369 if (TYPE_UNSIGNED (t1
))
370 return build_type_attribute_variant (t1
, attributes
);
372 return build_type_attribute_variant (t2
, attributes
);
376 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
377 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
378 return build_type_attribute_variant (long_double_type_node
,
380 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
381 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
382 return build_type_attribute_variant (double_type_node
,
384 if (same_type_p (TYPE_MAIN_VARIANT (t1
), float_type_node
)
385 || same_type_p (TYPE_MAIN_VARIANT (t2
), float_type_node
))
386 return build_type_attribute_variant (float_type_node
,
389 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
390 the standard C++ floating-point types. Logic earlier in this
391 function has already eliminated the possibility that
392 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
393 compelling reason to choose one or the other. */
394 return build_type_attribute_variant (t1
, attributes
);
398 /* T1 and T2 are arithmetic or enumeration types. Return the type
399 that will result from the "usual arithmetic conversions" on T1 and
400 T2 as described in [expr]. */
403 type_after_usual_arithmetic_conversions (tree t1
, tree t2
)
405 gcc_assert (ARITHMETIC_TYPE_P (t1
)
406 || TREE_CODE (t1
) == VECTOR_TYPE
407 || UNSCOPED_ENUM_P (t1
));
408 gcc_assert (ARITHMETIC_TYPE_P (t2
)
409 || TREE_CODE (t2
) == VECTOR_TYPE
410 || UNSCOPED_ENUM_P (t2
));
412 /* Perform the integral promotions. We do not promote real types here. */
413 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t1
)
414 && INTEGRAL_OR_ENUMERATION_TYPE_P (t2
))
416 t1
= type_promotes_to (t1
);
417 t2
= type_promotes_to (t2
);
420 return cp_common_type (t1
, t2
);
423 /* Subroutine of composite_pointer_type to implement the recursive
424 case. See that function for documentation fo the parameters. */
427 composite_pointer_type_r (tree t1
, tree t2
, const char* location
,
428 tsubst_flags_t complain
)
435 /* Determine the types pointed to by T1 and T2. */
436 if (TREE_CODE (t1
) == POINTER_TYPE
)
438 pointee1
= TREE_TYPE (t1
);
439 pointee2
= TREE_TYPE (t2
);
443 pointee1
= TYPE_PTRMEM_POINTED_TO_TYPE (t1
);
444 pointee2
= TYPE_PTRMEM_POINTED_TO_TYPE (t2
);
449 Otherwise, the composite pointer type is a pointer type
450 similar (_conv.qual_) to the type of one of the operands,
451 with a cv-qualification signature (_conv.qual_) that is the
452 union of the cv-qualification signatures of the operand
454 if (same_type_ignoring_top_level_qualifiers_p (pointee1
, pointee2
))
455 result_type
= pointee1
;
456 else if ((TREE_CODE (pointee1
) == POINTER_TYPE
457 && TREE_CODE (pointee2
) == POINTER_TYPE
)
458 || (TYPE_PTR_TO_MEMBER_P (pointee1
)
459 && TYPE_PTR_TO_MEMBER_P (pointee2
)))
460 result_type
= composite_pointer_type_r (pointee1
, pointee2
, location
,
464 if (complain
& tf_error
)
465 permerror (input_location
, "%s between distinct pointer types %qT and %qT "
468 result_type
= void_type_node
;
470 result_type
= cp_build_qualified_type (result_type
,
471 (cp_type_quals (pointee1
)
472 | cp_type_quals (pointee2
)));
473 /* If the original types were pointers to members, so is the
475 if (TYPE_PTR_TO_MEMBER_P (t1
))
477 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
478 TYPE_PTRMEM_CLASS_TYPE (t2
))
479 && (complain
& tf_error
))
480 permerror (input_location
, "%s between distinct pointer types %qT and %qT "
483 result_type
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
487 result_type
= build_pointer_type (result_type
);
489 /* Merge the attributes. */
490 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
491 return build_type_attribute_variant (result_type
, attributes
);
494 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
495 ARG1 and ARG2 are the values with those types. The LOCATION is a
496 string describing the current location, in case an error occurs.
498 This routine also implements the computation of a common type for
499 pointers-to-members as per [expr.eq]. */
502 composite_pointer_type (tree t1
, tree t2
, tree arg1
, tree arg2
,
503 const char* location
, tsubst_flags_t complain
)
510 If one operand is a null pointer constant, the composite pointer
511 type is the type of the other operand. */
512 if (null_ptr_cst_p (arg1
))
514 if (null_ptr_cst_p (arg2
))
521 If one of the operands has type "pointer to cv1 void*", then
522 the other has type "pointer to cv2T", and the composite pointer
523 type is "pointer to cv12 void", where cv12 is the union of cv1
526 If either type is a pointer to void, make sure it is T1. */
527 if (TREE_CODE (t2
) == POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (t2
)))
535 /* Now, if T1 is a pointer to void, merge the qualifiers. */
536 if (TREE_CODE (t1
) == POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (t1
)))
541 if (TYPE_PTRFN_P (t2
) && (complain
& tf_error
))
542 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids %s "
543 "between pointer of type %<void *%> and pointer-to-function",
546 = cp_build_qualified_type (void_type_node
,
547 (cp_type_quals (TREE_TYPE (t1
))
548 | cp_type_quals (TREE_TYPE (t2
))));
549 result_type
= build_pointer_type (result_type
);
550 /* Merge the attributes. */
551 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
552 return build_type_attribute_variant (result_type
, attributes
);
555 if (c_dialect_objc () && TREE_CODE (t1
) == POINTER_TYPE
556 && TREE_CODE (t2
) == POINTER_TYPE
)
558 if (objc_compare_types (t1
, t2
, -3, NULL_TREE
))
562 /* [expr.eq] permits the application of a pointer conversion to
563 bring the pointers to a common type. */
564 if (TREE_CODE (t1
) == POINTER_TYPE
&& TREE_CODE (t2
) == POINTER_TYPE
565 && CLASS_TYPE_P (TREE_TYPE (t1
))
566 && CLASS_TYPE_P (TREE_TYPE (t2
))
567 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1
),
570 class1
= TREE_TYPE (t1
);
571 class2
= TREE_TYPE (t2
);
573 if (DERIVED_FROM_P (class1
, class2
))
574 t2
= (build_pointer_type
575 (cp_build_qualified_type (class1
, TYPE_QUALS (class2
))));
576 else if (DERIVED_FROM_P (class2
, class1
))
577 t1
= (build_pointer_type
578 (cp_build_qualified_type (class2
, TYPE_QUALS (class1
))));
581 if (complain
& tf_error
)
582 error ("%s between distinct pointer types %qT and %qT "
583 "lacks a cast", location
, t1
, t2
);
584 return error_mark_node
;
587 /* [expr.eq] permits the application of a pointer-to-member
588 conversion to change the class type of one of the types. */
589 else if (TYPE_PTR_TO_MEMBER_P (t1
)
590 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
591 TYPE_PTRMEM_CLASS_TYPE (t2
)))
593 class1
= TYPE_PTRMEM_CLASS_TYPE (t1
);
594 class2
= TYPE_PTRMEM_CLASS_TYPE (t2
);
596 if (DERIVED_FROM_P (class1
, class2
))
597 t1
= build_ptrmem_type (class2
, TYPE_PTRMEM_POINTED_TO_TYPE (t1
));
598 else if (DERIVED_FROM_P (class2
, class1
))
599 t2
= build_ptrmem_type (class1
, TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
602 if (complain
& tf_error
)
603 error ("%s between distinct pointer-to-member types %qT and %qT "
604 "lacks a cast", location
, t1
, t2
);
605 return error_mark_node
;
609 return composite_pointer_type_r (t1
, t2
, location
, complain
);
612 /* Return the merged type of two types.
613 We assume that comptypes has already been done and returned 1;
614 if that isn't so, this may crash.
616 This just combines attributes and default arguments; any other
617 differences would cause the two types to compare unalike. */
620 merge_types (tree t1
, tree t2
)
622 enum tree_code code1
;
623 enum tree_code code2
;
626 /* Save time if the two types are the same. */
629 if (original_type (t1
) == original_type (t2
))
632 /* If one type is nonsense, use the other. */
633 if (t1
== error_mark_node
)
635 if (t2
== error_mark_node
)
638 /* Merge the attributes. */
639 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
641 if (TYPE_PTRMEMFUNC_P (t1
))
642 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
643 if (TYPE_PTRMEMFUNC_P (t2
))
644 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
646 code1
= TREE_CODE (t1
);
647 code2
= TREE_CODE (t2
);
650 gcc_assert (code1
== TYPENAME_TYPE
|| code2
== TYPENAME_TYPE
);
651 if (code1
== TYPENAME_TYPE
)
653 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
654 code1
= TREE_CODE (t1
);
658 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
659 code2
= TREE_CODE (t2
);
667 /* For two pointers, do this recursively on the target type. */
669 tree target
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
670 int quals
= cp_type_quals (t1
);
672 if (code1
== POINTER_TYPE
)
673 t1
= build_pointer_type (target
);
675 t1
= cp_build_reference_type (target
, TYPE_REF_IS_RVALUE (t1
));
676 t1
= build_type_attribute_variant (t1
, attributes
);
677 t1
= cp_build_qualified_type (t1
, quals
);
679 if (TREE_CODE (target
) == METHOD_TYPE
)
680 t1
= build_ptrmemfunc_type (t1
);
689 quals
= cp_type_quals (t1
);
690 pointee
= merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1
),
691 TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
692 t1
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
694 t1
= cp_build_qualified_type (t1
, quals
);
700 tree elt
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
701 /* Save space: see if the result is identical to one of the args. */
702 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
703 return build_type_attribute_variant (t1
, attributes
);
704 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
705 return build_type_attribute_variant (t2
, attributes
);
706 /* Merge the element types, and have a size if either arg has one. */
707 t1
= build_cplus_array_type
708 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
713 /* Function types: prefer the one that specified arg types.
714 If both do, merge the arg types. Also merge the return types. */
716 tree valtype
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
717 tree p1
= TYPE_ARG_TYPES (t1
);
718 tree p2
= TYPE_ARG_TYPES (t2
);
721 /* Save space: see if the result is identical to one of the args. */
722 if (valtype
== TREE_TYPE (t1
) && ! p2
)
723 return cp_build_type_attribute_variant (t1
, attributes
);
724 if (valtype
== TREE_TYPE (t2
) && ! p1
)
725 return cp_build_type_attribute_variant (t2
, attributes
);
727 /* Simple way if one arg fails to specify argument types. */
728 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
730 rval
= build_function_type (valtype
, p2
);
731 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
732 rval
= build_exception_variant (rval
, raises
);
733 return cp_build_type_attribute_variant (rval
, attributes
);
735 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
736 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
738 rval
= build_function_type (valtype
, p1
);
740 rval
= build_exception_variant (rval
, raises
);
741 return cp_build_type_attribute_variant (rval
, attributes
);
744 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
745 t1
= build_exception_variant (rval
, raises
);
751 /* Get this value the long way, since TYPE_METHOD_BASETYPE
752 is just the main variant of this. */
753 tree basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
754 tree raises
= TYPE_RAISES_EXCEPTIONS (t1
);
757 /* If this was a member function type, get back to the
758 original type of type member function (i.e., without
759 the class instance variable up front. */
760 t1
= build_function_type (TREE_TYPE (t1
),
761 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
762 t2
= build_function_type (TREE_TYPE (t2
),
763 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
764 t3
= merge_types (t1
, t2
);
765 t3
= build_method_type_directly (basetype
, TREE_TYPE (t3
),
766 TYPE_ARG_TYPES (t3
));
767 t1
= build_exception_variant (t3
, raises
);
772 /* There is no need to merge attributes into a TYPENAME_TYPE.
773 When the type is instantiated it will have whatever
774 attributes result from the instantiation. */
780 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
782 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
785 return cp_build_type_attribute_variant (t1
, attributes
);
788 /* Wrapper around cp_common_type that is used by c-common.c and other
789 front end optimizations that remove promotions.
791 Return the common type for two arithmetic types T1 and T2 under the
792 usual arithmetic conversions. The default conversions have already
793 been applied, and enumerated types converted to their compatible
797 common_type (tree t1
, tree t2
)
799 /* If one type is nonsense, use the other */
800 if (t1
== error_mark_node
)
802 if (t2
== error_mark_node
)
805 return cp_common_type (t1
, t2
);
808 /* Return the common type of two pointer types T1 and T2. This is the
809 type for the result of most arithmetic operations if the operands
810 have the given two types.
812 We assume that comp_target_types has already been done and returned
813 nonzero; if that isn't so, this may crash. */
816 common_pointer_type (tree t1
, tree t2
)
818 gcc_assert ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
819 || (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
))
820 || (TYPE_PTRMEMFUNC_P (t1
) && TYPE_PTRMEMFUNC_P (t2
)));
822 return composite_pointer_type (t1
, t2
, error_mark_node
, error_mark_node
,
823 "conversion", tf_warning_or_error
);
826 /* Compare two exception specifier types for exactness or subsetness, if
827 allowed. Returns false for mismatch, true for match (same, or
830 [except.spec] "If a class X ... objects of class X or any class publicly
831 and unambiguously derived from X. Similarly, if a pointer type Y * ...
832 exceptions of type Y * or that are pointers to any type publicly and
833 unambiguously derived from Y. Otherwise a function only allows exceptions
834 that have the same type ..."
835 This does not mention cv qualifiers and is different to what throw
836 [except.throw] and catch [except.catch] will do. They will ignore the
837 top level cv qualifiers, and allow qualifiers in the pointer to class
840 We implement the letter of the standard. */
843 comp_except_types (tree a
, tree b
, bool exact
)
845 if (same_type_p (a
, b
))
849 if (cp_type_quals (a
) || cp_type_quals (b
))
852 if (TREE_CODE (a
) == POINTER_TYPE
853 && TREE_CODE (b
) == POINTER_TYPE
)
857 if (cp_type_quals (a
) || cp_type_quals (b
))
861 if (TREE_CODE (a
) != RECORD_TYPE
862 || TREE_CODE (b
) != RECORD_TYPE
)
865 if (PUBLICLY_UNIQUELY_DERIVED_P (a
, b
))
871 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
872 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
873 otherwise it must be exact. Exception lists are unordered, but
874 we've already filtered out duplicates. Most lists will be in order,
875 we should try to make use of that. */
878 comp_except_specs (const_tree t1
, const_tree t2
, bool exact
)
887 if (t1
== NULL_TREE
) /* T1 is ... */
888 return t2
== NULL_TREE
|| !exact
;
889 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
890 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
891 if (t2
== NULL_TREE
) /* T2 is ... */
893 if (TREE_VALUE (t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
896 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
897 Count how many we find, to determine exactness. For exact matching and
898 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
900 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
902 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
904 tree a
= TREE_VALUE (probe
);
905 tree b
= TREE_VALUE (t2
);
907 if (comp_except_types (a
, b
, exact
))
909 if (probe
== base
&& exact
)
910 base
= TREE_CHAIN (probe
);
915 if (probe
== NULL_TREE
)
918 return !exact
|| base
== NULL_TREE
|| length
== list_length (t1
);
921 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
922 [] can match [size]. */
925 comp_array_types (const_tree t1
, const_tree t2
, bool allow_redeclaration
)
934 /* The type of the array elements must be the same. */
935 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
938 d1
= TYPE_DOMAIN (t1
);
939 d2
= TYPE_DOMAIN (t2
);
944 /* If one of the arrays is dimensionless, and the other has a
945 dimension, they are of different types. However, it is valid to
953 declarations for an array object can specify
954 array types that differ by the presence or absence of a major
955 array bound (_dcl.array_). */
957 return allow_redeclaration
;
959 /* Check that the dimensions are the same. */
961 if (!cp_tree_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
)))
963 max1
= TYPE_MAX_VALUE (d1
);
964 max2
= TYPE_MAX_VALUE (d2
);
965 if (processing_template_decl
&& !abi_version_at_least (2)
966 && !value_dependent_expression_p (max1
)
967 && !value_dependent_expression_p (max2
))
969 /* With abi-1 we do not fold non-dependent array bounds, (and
970 consequently mangle them incorrectly). We must therefore
971 fold them here, to verify the domains have the same
977 if (!cp_tree_equal (max1
, max2
))
983 /* Subroutine in comptypes. */
986 structural_comptypes (tree t1
, tree t2
, int strict
)
991 /* Suppress errors caused by previously reported errors. */
992 if (t1
== error_mark_node
|| t2
== error_mark_node
)
995 gcc_assert (TYPE_P (t1
) && TYPE_P (t2
));
997 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
998 current instantiation. */
999 if (TREE_CODE (t1
) == TYPENAME_TYPE
)
1000 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
1002 if (TREE_CODE (t2
) == TYPENAME_TYPE
)
1003 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
1005 if (TYPE_PTRMEMFUNC_P (t1
))
1006 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
1007 if (TYPE_PTRMEMFUNC_P (t2
))
1008 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
1010 /* Different classes of types can't be compatible. */
1011 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1014 /* Qualifiers must match. For array types, we will check when we
1015 recur on the array element types. */
1016 if (TREE_CODE (t1
) != ARRAY_TYPE
1017 && TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
1019 if (TYPE_FOR_JAVA (t1
) != TYPE_FOR_JAVA (t2
))
1022 /* Allow for two different type nodes which have essentially the same
1023 definition. Note that we already checked for equality of the type
1024 qualifiers (just above). */
1026 if (TREE_CODE (t1
) != ARRAY_TYPE
1027 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1030 /* Compare the types. Break out if they could be the same. */
1031 switch (TREE_CODE (t1
))
1035 /* All void and bool types are the same. */
1039 case FIXED_POINT_TYPE
:
1041 /* With these nodes, we can't determine type equivalence by
1042 looking at what is stored in the nodes themselves, because
1043 two nodes might have different TYPE_MAIN_VARIANTs but still
1044 represent the same type. For example, wchar_t and int could
1045 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1046 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1047 and are distinct types. On the other hand, int and the
1050 typedef int INT __attribute((may_alias));
1052 have identical properties, different TYPE_MAIN_VARIANTs, but
1053 represent the same type. The canonical type system keeps
1054 track of equivalence in this case, so we fall back on it. */
1055 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1057 case TEMPLATE_TEMPLATE_PARM
:
1058 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1059 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
1060 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
)
1061 || (TEMPLATE_TYPE_PARAMETER_PACK (t1
)
1062 != TEMPLATE_TYPE_PARAMETER_PACK (t2
)))
1064 if (!comp_template_parms
1065 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1066 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1068 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1070 /* Don't check inheritance. */
1071 strict
= COMPARE_STRICT
;
1076 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1077 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1078 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
1079 && comp_template_args (TYPE_TI_ARGS (t1
), TYPE_TI_ARGS (t2
)))
1082 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1084 else if ((strict
& COMPARE_DERIVED
) && DERIVED_FROM_P (t2
, t1
))
1090 if (!comptypes (TYPE_OFFSET_BASETYPE (t1
), TYPE_OFFSET_BASETYPE (t2
),
1091 strict
& ~COMPARE_REDECLARATION
))
1093 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1097 case REFERENCE_TYPE
:
1098 if (TYPE_REF_IS_RVALUE (t1
) != TYPE_REF_IS_RVALUE (t2
))
1100 /* fall through to checks for pointer types */
1103 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1104 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
)
1105 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1111 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1113 if (!compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)))
1118 /* Target types must match incl. qualifiers. */
1119 if (!comp_array_types (t1
, t2
, !!(strict
& COMPARE_REDECLARATION
)))
1123 case TEMPLATE_TYPE_PARM
:
1124 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
1125 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
)
1126 || (TEMPLATE_TYPE_PARAMETER_PACK (t1
)
1127 != TEMPLATE_TYPE_PARAMETER_PACK (t2
)))
1132 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1133 TYPENAME_TYPE_FULLNAME (t2
)))
1135 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1139 case UNBOUND_CLASS_TEMPLATE
:
1140 if (!cp_tree_equal (TYPE_IDENTIFIER (t1
), TYPE_IDENTIFIER (t2
)))
1142 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1147 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1152 if (TYPE_VECTOR_SUBPARTS (t1
) != TYPE_VECTOR_SUBPARTS (t2
)
1153 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1157 case TYPE_PACK_EXPANSION
:
1158 return same_type_p (PACK_EXPANSION_PATTERN (t1
),
1159 PACK_EXPANSION_PATTERN (t2
));
1162 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1
)
1163 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2
)
1164 || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1
)
1165 != DECLTYPE_FOR_LAMBDA_CAPTURE (t2
))
1166 || (DECLTYPE_FOR_LAMBDA_RETURN (t1
)
1167 != DECLTYPE_FOR_LAMBDA_RETURN (t2
))
1168 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1
),
1169 DECLTYPE_TYPE_EXPR (t2
)))
1177 /* If we get here, we know that from a target independent POV the
1178 types are the same. Make sure the target attributes are also
1180 return targetm
.comp_type_attributes (t1
, t2
);
1183 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1184 is a bitwise-or of the COMPARE_* flags. */
1187 comptypes (tree t1
, tree t2
, int strict
)
1189 if (strict
== COMPARE_STRICT
)
1194 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1197 if (TYPE_STRUCTURAL_EQUALITY_P (t1
) || TYPE_STRUCTURAL_EQUALITY_P (t2
))
1198 /* At least one of the types requires structural equality, so
1199 perform a deep check. */
1200 return structural_comptypes (t1
, t2
, strict
);
1202 #ifdef ENABLE_CHECKING
1203 if (USE_CANONICAL_TYPES
)
1205 bool result
= structural_comptypes (t1
, t2
, strict
);
1207 if (result
&& TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1208 /* The two types are structurally equivalent, but their
1209 canonical types were different. This is a failure of the
1210 canonical type propagation code.*/
1212 ("canonical types differ for identical types %T and %T",
1214 else if (!result
&& TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
1215 /* Two types are structurally different, but the canonical
1216 types are the same. This means we were over-eager in
1217 assigning canonical types. */
1219 ("same canonical type node for different types %T and %T",
1225 if (USE_CANONICAL_TYPES
)
1226 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1229 return structural_comptypes (t1
, t2
, strict
);
1231 else if (strict
== COMPARE_STRUCTURAL
)
1232 return structural_comptypes (t1
, t2
, COMPARE_STRICT
);
1234 return structural_comptypes (t1
, t2
, strict
);
1237 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1240 at_least_as_qualified_p (const_tree type1
, const_tree type2
)
1242 int q1
= cp_type_quals (type1
);
1243 int q2
= cp_type_quals (type2
);
1245 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1246 return (q1
& q2
) == q2
;
1249 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1250 more cv-qualified that TYPE1, and 0 otherwise. */
1253 comp_cv_qualification (const_tree type1
, const_tree type2
)
1255 int q1
= cp_type_quals (type1
);
1256 int q2
= cp_type_quals (type2
);
1261 if ((q1
& q2
) == q2
)
1263 else if ((q1
& q2
) == q1
)
1269 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1270 subset of the cv-qualification signature of TYPE2, and the types
1271 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1274 comp_cv_qual_signature (tree type1
, tree type2
)
1276 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1278 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1284 /* Subroutines of `comptypes'. */
1286 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1287 equivalent in the sense that functions with those parameter types
1288 can have equivalent types. The two lists must be equivalent,
1289 element by element. */
1292 compparms (const_tree parms1
, const_tree parms2
)
1296 /* An unspecified parmlist matches any specified parmlist
1297 whose argument types don't need default promotions. */
1299 for (t1
= parms1
, t2
= parms2
;
1301 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1303 /* If one parmlist is shorter than the other,
1304 they fail to match. */
1307 if (!same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1314 /* Process a sizeof or alignof expression where the operand is a
1318 cxx_sizeof_or_alignof_type (tree type
, enum tree_code op
, bool complain
)
1323 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
1324 if (type
== error_mark_node
)
1325 return error_mark_node
;
1327 type
= non_reference (type
);
1328 if (TREE_CODE (type
) == METHOD_TYPE
)
1331 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
1332 "invalid application of %qs to a member function",
1333 operator_name_info
[(int) op
].name
);
1334 value
= size_one_node
;
1337 dependent_p
= dependent_type_p (type
);
1339 complete_type (type
);
1341 /* VLA types will have a non-constant size. In the body of an
1342 uninstantiated template, we don't need to try to compute the
1343 value, because the sizeof expression is not an integral
1344 constant expression in that case. And, if we do try to
1345 compute the value, we'll likely end up with SAVE_EXPRs, which
1346 the template substitution machinery does not expect to see. */
1347 || (processing_template_decl
1348 && COMPLETE_TYPE_P (type
)
1349 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
1351 value
= build_min (op
, size_type_node
, type
);
1352 TREE_READONLY (value
) = 1;
1356 return c_sizeof_or_alignof_type (input_location
, complete_type (type
),
1361 /* Return the size of the type, without producing any warnings for
1362 types whose size cannot be taken. This routine should be used only
1363 in some other routine that has already produced a diagnostic about
1364 using the size of such a type. */
1366 cxx_sizeof_nowarn (tree type
)
1368 if (TREE_CODE (type
) == FUNCTION_TYPE
1369 || TREE_CODE (type
) == VOID_TYPE
1370 || TREE_CODE (type
) == ERROR_MARK
)
1371 return size_one_node
;
1372 else if (!COMPLETE_TYPE_P (type
))
1373 return size_zero_node
;
1375 return cxx_sizeof_or_alignof_type (type
, SIZEOF_EXPR
, false);
1378 /* Process a sizeof expression where the operand is an expression. */
1381 cxx_sizeof_expr (tree e
, tsubst_flags_t complain
)
1383 if (e
== error_mark_node
)
1384 return error_mark_node
;
1386 if (processing_template_decl
)
1388 e
= build_min (SIZEOF_EXPR
, size_type_node
, e
);
1389 TREE_SIDE_EFFECTS (e
) = 0;
1390 TREE_READONLY (e
) = 1;
1395 if (TREE_CODE (e
) == COMPONENT_REF
1396 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
1397 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1399 if (complain
& tf_error
)
1400 error ("invalid application of %<sizeof%> to a bit-field");
1402 return error_mark_node
;
1405 else if (is_overloaded_fn (e
))
1407 if (complain
& tf_error
)
1408 permerror (input_location
, "ISO C++ forbids applying %<sizeof%> to an expression of "
1411 return error_mark_node
;
1414 else if (type_unknown_p (e
))
1416 if (complain
& tf_error
)
1417 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1419 return error_mark_node
;
1425 return cxx_sizeof_or_alignof_type (e
, SIZEOF_EXPR
, complain
& tf_error
);
1428 /* Implement the __alignof keyword: Return the minimum required
1429 alignment of E, measured in bytes. For VAR_DECL's and
1430 FIELD_DECL's return DECL_ALIGN (which can be set from an
1431 "aligned" __attribute__ specification). */
1434 cxx_alignof_expr (tree e
, tsubst_flags_t complain
)
1438 if (e
== error_mark_node
)
1439 return error_mark_node
;
1441 if (processing_template_decl
)
1443 e
= build_min (ALIGNOF_EXPR
, size_type_node
, e
);
1444 TREE_SIDE_EFFECTS (e
) = 0;
1445 TREE_READONLY (e
) = 1;
1450 if (TREE_CODE (e
) == VAR_DECL
)
1451 t
= size_int (DECL_ALIGN_UNIT (e
));
1452 else if (TREE_CODE (e
) == COMPONENT_REF
1453 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
1454 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1456 if (complain
& tf_error
)
1457 error ("invalid application of %<__alignof%> to a bit-field");
1459 return error_mark_node
;
1462 else if (TREE_CODE (e
) == COMPONENT_REF
1463 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
)
1464 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e
, 1)));
1465 else if (is_overloaded_fn (e
))
1467 if (complain
& tf_error
)
1468 permerror (input_location
, "ISO C++ forbids applying %<__alignof%> to an expression of "
1471 return error_mark_node
;
1472 if (TREE_CODE (e
) == FUNCTION_DECL
)
1473 t
= size_int (DECL_ALIGN_UNIT (e
));
1477 else if (type_unknown_p (e
))
1479 if (complain
& tf_error
)
1480 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1482 return error_mark_node
;
1486 return cxx_sizeof_or_alignof_type (TREE_TYPE (e
), ALIGNOF_EXPR
,
1487 complain
& tf_error
);
1489 return fold_convert (size_type_node
, t
);
1492 /* Process a sizeof or alignof expression E with code OP where the operand
1493 is an expression. */
1496 cxx_sizeof_or_alignof_expr (tree e
, enum tree_code op
, bool complain
)
1498 if (op
== SIZEOF_EXPR
)
1499 return cxx_sizeof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1501 return cxx_alignof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1504 /* EXPR is being used in a context that is not a function call.
1509 The expression can be used only as the left-hand operand of a
1510 member function call.
1512 [expr.mptr.operator]
1514 If the result of .* or ->* is a function, then that result can be
1515 used only as the operand for the function call operator ().
1517 by issuing an error message if appropriate. Returns true iff EXPR
1518 violates these rules. */
1521 invalid_nonstatic_memfn_p (const_tree expr
, tsubst_flags_t complain
)
1523 if (expr
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (expr
))
1525 if (complain
& tf_error
)
1526 error ("invalid use of non-static member function");
1532 /* If EXP is a reference to a bitfield, and the type of EXP does not
1533 match the declared type of the bitfield, return the declared type
1534 of the bitfield. Otherwise, return NULL_TREE. */
1537 is_bitfield_expr_with_lowered_type (const_tree exp
)
1539 switch (TREE_CODE (exp
))
1542 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1)
1543 ? TREE_OPERAND (exp
, 1)
1544 : TREE_OPERAND (exp
, 0)))
1546 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 2));
1549 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1));
1553 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1559 field
= TREE_OPERAND (exp
, 1);
1560 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_BIT_FIELD_TYPE (field
))
1562 if (same_type_ignoring_top_level_qualifiers_p
1563 (TREE_TYPE (exp
), DECL_BIT_FIELD_TYPE (field
)))
1565 return DECL_BIT_FIELD_TYPE (field
);
1569 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp
, 0)))
1570 == TYPE_MAIN_VARIANT (TREE_TYPE (exp
)))
1571 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1579 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1580 bitfield with a lowered type, the type of EXP is returned, rather
1584 unlowered_expr_type (const_tree exp
)
1588 type
= is_bitfield_expr_with_lowered_type (exp
);
1590 type
= TREE_TYPE (exp
);
1595 /* Perform the conversions in [expr] that apply when an lvalue appears
1596 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1597 function-to-pointer conversions. In addition, manifest constants
1598 are replaced by their values, and bitfield references are converted
1599 to their declared types.
1601 Although the returned value is being used as an rvalue, this
1602 function does not wrap the returned expression in a
1603 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1604 that the return value is no longer an lvalue. */
1607 decay_conversion (tree exp
)
1610 enum tree_code code
;
1612 type
= TREE_TYPE (exp
);
1613 if (type
== error_mark_node
)
1614 return error_mark_node
;
1616 if (type_unknown_p (exp
))
1618 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
1619 return error_mark_node
;
1622 exp
= decl_constant_value (exp
);
1623 if (error_operand_p (exp
))
1624 return error_mark_node
;
1626 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1627 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1628 code
= TREE_CODE (type
);
1629 if (code
== VOID_TYPE
)
1631 error ("void value not ignored as it ought to be");
1632 return error_mark_node
;
1634 if (invalid_nonstatic_memfn_p (exp
, tf_warning_or_error
))
1635 return error_mark_node
;
1636 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1637 return cp_build_unary_op (ADDR_EXPR
, exp
, 0, tf_warning_or_error
);
1638 if (code
== ARRAY_TYPE
)
1643 if (TREE_CODE (exp
) == INDIRECT_REF
)
1644 return build_nop (build_pointer_type (TREE_TYPE (type
)),
1645 TREE_OPERAND (exp
, 0));
1647 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1649 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1650 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
1651 TREE_OPERAND (exp
, 0), op1
);
1655 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1657 error ("invalid use of non-lvalue array");
1658 return error_mark_node
;
1661 ptrtype
= build_pointer_type (TREE_TYPE (type
));
1663 if (TREE_CODE (exp
) == VAR_DECL
)
1665 if (!cxx_mark_addressable (exp
))
1666 return error_mark_node
;
1667 adr
= build_nop (ptrtype
, build_address (exp
));
1670 /* This way is better for a COMPONENT_REF since it can
1671 simplify the offset for a component. */
1672 adr
= cp_build_unary_op (ADDR_EXPR
, exp
, 1, tf_warning_or_error
);
1673 return cp_convert (ptrtype
, adr
);
1676 /* If a bitfield is used in a context where integral promotion
1677 applies, then the caller is expected to have used
1678 default_conversion. That function promotes bitfields correctly
1679 before calling this function. At this point, if we have a
1680 bitfield referenced, we may assume that is not subject to
1681 promotion, and that, therefore, the type of the resulting rvalue
1682 is the declared type of the bitfield. */
1683 exp
= convert_bitfield_to_declared_type (exp
);
1685 /* We do not call rvalue() here because we do not want to wrap EXP
1686 in a NON_LVALUE_EXPR. */
1690 Non-class rvalues always have cv-unqualified types. */
1691 type
= TREE_TYPE (exp
);
1692 if (!CLASS_TYPE_P (type
) && cp_type_quals (type
))
1693 exp
= build_nop (TYPE_MAIN_VARIANT (type
), exp
);
1698 /* Perform preparatory conversions, as part of the "usual arithmetic
1699 conversions". In particular, as per [expr]:
1701 Whenever an lvalue expression appears as an operand of an
1702 operator that expects the rvalue for that operand, the
1703 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1704 standard conversions are applied to convert the expression to an
1707 In addition, we perform integral promotions here, as those are
1708 applied to both operands to a binary operator before determining
1709 what additional conversions should apply. */
1712 default_conversion (tree exp
)
1714 /* Check for target-specific promotions. */
1715 tree promoted_type
= targetm
.promoted_type (TREE_TYPE (exp
));
1717 exp
= cp_convert (promoted_type
, exp
);
1718 /* Perform the integral promotions first so that bitfield
1719 expressions (which may promote to "int", even if the bitfield is
1720 declared "unsigned") are promoted correctly. */
1721 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp
)))
1722 exp
= perform_integral_promotions (exp
);
1723 /* Perform the other conversions. */
1724 exp
= decay_conversion (exp
);
1729 /* EXPR is an expression with an integral or enumeration type.
1730 Perform the integral promotions in [conv.prom], and return the
1734 perform_integral_promotions (tree expr
)
1741 If the bitfield has an enumerated type, it is treated as any
1742 other value of that type for promotion purposes. */
1743 type
= is_bitfield_expr_with_lowered_type (expr
);
1744 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
1745 type
= TREE_TYPE (expr
);
1746 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
1747 promoted_type
= type_promotes_to (type
);
1748 if (type
!= promoted_type
)
1749 expr
= cp_convert (promoted_type
, expr
);
1753 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1754 decay_conversion to one. */
1757 string_conv_p (const_tree totype
, const_tree exp
, int warn
)
1761 if (TREE_CODE (totype
) != POINTER_TYPE
)
1764 t
= TREE_TYPE (totype
);
1765 if (!same_type_p (t
, char_type_node
)
1766 && !same_type_p (t
, char16_type_node
)
1767 && !same_type_p (t
, char32_type_node
)
1768 && !same_type_p (t
, wchar_type_node
))
1771 if (TREE_CODE (exp
) == STRING_CST
)
1773 /* Make sure that we don't try to convert between char and wide chars. */
1774 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
1779 /* Is this a string constant which has decayed to 'const char *'? */
1780 t
= build_pointer_type (build_qualified_type (t
, TYPE_QUAL_CONST
));
1781 if (!same_type_p (TREE_TYPE (exp
), t
))
1784 if (TREE_CODE (exp
) != ADDR_EXPR
1785 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1789 /* This warning is not very useful, as it complains about printf. */
1791 warning (OPT_Wwrite_strings
,
1792 "deprecated conversion from string constant to %qT",
1798 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1799 can, for example, use as an lvalue. This code used to be in
1800 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1801 expressions, where we're dealing with aggregates. But now it's again only
1802 called from unary_complex_lvalue. The case (in particular) that led to
1803 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1807 rationalize_conditional_expr (enum tree_code code
, tree t
,
1808 tsubst_flags_t complain
)
1810 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1811 the first operand is always the one to be used if both operands
1812 are equal, so we know what conditional expression this used to be. */
1813 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1815 tree op0
= TREE_OPERAND (t
, 0);
1816 tree op1
= TREE_OPERAND (t
, 1);
1818 /* The following code is incorrect if either operand side-effects. */
1819 gcc_assert (!TREE_SIDE_EFFECTS (op0
)
1820 && !TREE_SIDE_EFFECTS (op1
));
1822 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1823 ? LE_EXPR
: GE_EXPR
),
1824 op0
, TREE_CODE (op0
),
1825 op1
, TREE_CODE (op1
),
1826 /*overloaded_p=*/NULL
,
1828 cp_build_unary_op (code
, op0
, 0, complain
),
1829 cp_build_unary_op (code
, op1
, 0, complain
),
1834 build_conditional_expr (TREE_OPERAND (t
, 0),
1835 cp_build_unary_op (code
, TREE_OPERAND (t
, 1), 0,
1837 cp_build_unary_op (code
, TREE_OPERAND (t
, 2), 0,
1842 /* Given the TYPE of an anonymous union field inside T, return the
1843 FIELD_DECL for the field. If not found return NULL_TREE. Because
1844 anonymous unions can nest, we must also search all anonymous unions
1845 that are directly reachable. */
1848 lookup_anon_field (tree t
, tree type
)
1852 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1854 if (TREE_STATIC (field
))
1856 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1859 /* If we find it directly, return the field. */
1860 if (DECL_NAME (field
) == NULL_TREE
1861 && type
== TYPE_MAIN_VARIANT (TREE_TYPE (field
)))
1866 /* Otherwise, it could be nested, search harder. */
1867 if (DECL_NAME (field
) == NULL_TREE
1868 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1870 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
1878 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1879 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1880 non-NULL, it indicates the path to the base used to name MEMBER.
1881 If PRESERVE_REFERENCE is true, the expression returned will have
1882 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1883 returned will have the type referred to by the reference.
1885 This function does not perform access control; that is either done
1886 earlier by the parser when the name of MEMBER is resolved to MEMBER
1887 itself, or later when overload resolution selects one of the
1888 functions indicated by MEMBER. */
1891 build_class_member_access_expr (tree object
, tree member
,
1892 tree access_path
, bool preserve_reference
,
1893 tsubst_flags_t complain
)
1897 tree result
= NULL_TREE
;
1899 if (error_operand_p (object
) || error_operand_p (member
))
1900 return error_mark_node
;
1902 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
1906 The type of the first expression shall be "class object" (of a
1908 object_type
= TREE_TYPE (object
);
1909 if (!currently_open_class (object_type
)
1910 && !complete_type_or_else (object_type
, object
))
1911 return error_mark_node
;
1912 if (!CLASS_TYPE_P (object_type
))
1914 if (complain
& tf_error
)
1915 error ("request for member %qD in %qE, which is of non-class type %qT",
1916 member
, object
, object_type
);
1917 return error_mark_node
;
1920 /* The standard does not seem to actually say that MEMBER must be a
1921 member of OBJECT_TYPE. However, that is clearly what is
1923 if (DECL_P (member
))
1925 member_scope
= DECL_CLASS_CONTEXT (member
);
1927 if (TREE_DEPRECATED (member
))
1928 warn_deprecated_use (member
, NULL_TREE
);
1931 member_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (member
));
1932 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1933 presently be the anonymous union. Go outwards until we find a
1934 type related to OBJECT_TYPE. */
1935 while (ANON_AGGR_TYPE_P (member_scope
)
1936 && !same_type_ignoring_top_level_qualifiers_p (member_scope
,
1938 member_scope
= TYPE_CONTEXT (member_scope
);
1939 if (!member_scope
|| !DERIVED_FROM_P (member_scope
, object_type
))
1941 if (complain
& tf_error
)
1943 if (TREE_CODE (member
) == FIELD_DECL
)
1944 error ("invalid use of nonstatic data member %qE", member
);
1946 error ("%qD is not a member of %qT", member
, object_type
);
1948 return error_mark_node
;
1951 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1952 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1953 in the front end; only _DECLs and _REFs are lvalues in the back end. */
1955 tree temp
= unary_complex_lvalue (ADDR_EXPR
, object
);
1957 object
= cp_build_indirect_ref (temp
, NULL
, complain
);
1960 /* In [expr.ref], there is an explicit list of the valid choices for
1961 MEMBER. We check for each of those cases here. */
1962 if (TREE_CODE (member
) == VAR_DECL
)
1964 /* A static data member. */
1966 /* If OBJECT has side-effects, they are supposed to occur. */
1967 if (TREE_SIDE_EFFECTS (object
))
1968 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), object
, result
);
1970 else if (TREE_CODE (member
) == FIELD_DECL
)
1972 /* A non-static data member. */
1977 null_object_p
= (TREE_CODE (object
) == INDIRECT_REF
1978 && integer_zerop (TREE_OPERAND (object
, 0)));
1980 /* Convert OBJECT to the type of MEMBER. */
1981 if (!same_type_p (TYPE_MAIN_VARIANT (object_type
),
1982 TYPE_MAIN_VARIANT (member_scope
)))
1987 binfo
= lookup_base (access_path
? access_path
: object_type
,
1988 member_scope
, ba_unique
, &kind
);
1989 if (binfo
== error_mark_node
)
1990 return error_mark_node
;
1992 /* It is invalid to try to get to a virtual base of a
1993 NULL object. The most common cause is invalid use of
1995 if (null_object_p
&& kind
== bk_via_virtual
)
1997 if (complain
& tf_error
)
1999 error ("invalid access to non-static data member %qD of "
2002 error ("(perhaps the %<offsetof%> macro was used incorrectly)");
2004 return error_mark_node
;
2007 /* Convert to the base. */
2008 object
= build_base_path (PLUS_EXPR
, object
, binfo
,
2010 /* If we found the base successfully then we should be able
2011 to convert to it successfully. */
2012 gcc_assert (object
!= error_mark_node
);
2015 /* Complain about other invalid uses of offsetof, even though they will
2016 give the right answer. Note that we complain whether or not they
2017 actually used the offsetof macro, since there's no way to know at this
2018 point. So we just give a warning, instead of a pedwarn. */
2019 /* Do not produce this warning for base class field references, because
2020 we know for a fact that didn't come from offsetof. This does occur
2021 in various testsuite cases where a null object is passed where a
2022 vtable access is required. */
2023 if (null_object_p
&& warn_invalid_offsetof
2024 && CLASSTYPE_NON_STD_LAYOUT (object_type
)
2025 && !DECL_FIELD_IS_BASE (member
)
2026 && cp_unevaluated_operand
== 0
2027 && (complain
& tf_warning
))
2029 warning (OPT_Winvalid_offsetof
,
2030 "invalid access to non-static data member %qD "
2031 " of NULL object", member
);
2032 warning (OPT_Winvalid_offsetof
,
2033 "(perhaps the %<offsetof%> macro was used incorrectly)");
2036 /* If MEMBER is from an anonymous aggregate, we have converted
2037 OBJECT so that it refers to the class containing the
2038 anonymous union. Generate a reference to the anonymous union
2039 itself, and recur to find MEMBER. */
2040 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member
))
2041 /* When this code is called from build_field_call, the
2042 object already has the type of the anonymous union.
2043 That is because the COMPONENT_REF was already
2044 constructed, and was then disassembled before calling
2045 build_field_call. After the function-call code is
2046 cleaned up, this waste can be eliminated. */
2047 && (!same_type_ignoring_top_level_qualifiers_p
2048 (TREE_TYPE (object
), DECL_CONTEXT (member
))))
2050 tree anonymous_union
;
2052 anonymous_union
= lookup_anon_field (TREE_TYPE (object
),
2053 DECL_CONTEXT (member
));
2054 object
= build_class_member_access_expr (object
,
2056 /*access_path=*/NULL_TREE
,
2061 /* Compute the type of the field, as described in [expr.ref]. */
2062 type_quals
= TYPE_UNQUALIFIED
;
2063 member_type
= TREE_TYPE (member
);
2064 if (TREE_CODE (member_type
) != REFERENCE_TYPE
)
2066 type_quals
= (cp_type_quals (member_type
)
2067 | cp_type_quals (object_type
));
2069 /* A field is const (volatile) if the enclosing object, or the
2070 field itself, is const (volatile). But, a mutable field is
2071 not const, even within a const object. */
2072 if (DECL_MUTABLE_P (member
))
2073 type_quals
&= ~TYPE_QUAL_CONST
;
2074 member_type
= cp_build_qualified_type (member_type
, type_quals
);
2077 result
= build3 (COMPONENT_REF
, member_type
, object
, member
,
2079 result
= fold_if_not_in_template (result
);
2081 /* Mark the expression const or volatile, as appropriate. Even
2082 though we've dealt with the type above, we still have to mark the
2083 expression itself. */
2084 if (type_quals
& TYPE_QUAL_CONST
)
2085 TREE_READONLY (result
) = 1;
2086 if (type_quals
& TYPE_QUAL_VOLATILE
)
2087 TREE_THIS_VOLATILE (result
) = 1;
2089 else if (BASELINK_P (member
))
2091 /* The member is a (possibly overloaded) member function. */
2095 /* If the MEMBER is exactly one static member function, then we
2096 know the type of the expression. Otherwise, we must wait
2097 until overload resolution has been performed. */
2098 functions
= BASELINK_FUNCTIONS (member
);
2099 if (TREE_CODE (functions
) == FUNCTION_DECL
2100 && DECL_STATIC_FUNCTION_P (functions
))
2101 type
= TREE_TYPE (functions
);
2103 type
= unknown_type_node
;
2104 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2105 base. That will happen when the function is called. */
2106 result
= build3 (COMPONENT_REF
, type
, object
, member
, NULL_TREE
);
2108 else if (TREE_CODE (member
) == CONST_DECL
)
2110 /* The member is an enumerator. */
2112 /* If OBJECT has side-effects, they are supposed to occur. */
2113 if (TREE_SIDE_EFFECTS (object
))
2114 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
2119 if (complain
& tf_error
)
2120 error ("invalid use of %qD", member
);
2121 return error_mark_node
;
2124 if (!preserve_reference
)
2127 If E2 is declared to have type "reference to T", then ... the
2128 type of E1.E2 is T. */
2129 result
= convert_from_reference (result
);
2134 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2135 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
2138 lookup_destructor (tree object
, tree scope
, tree dtor_name
)
2140 tree object_type
= TREE_TYPE (object
);
2141 tree dtor_type
= TREE_OPERAND (dtor_name
, 0);
2144 if (scope
&& !check_dtor_name (scope
, dtor_type
))
2146 error ("qualified type %qT does not match destructor name ~%qT",
2148 return error_mark_node
;
2150 if (TREE_CODE (dtor_type
) == IDENTIFIER_NODE
)
2152 /* In a template, names we can't find a match for are still accepted
2153 destructor names, and we check them here. */
2154 if (check_dtor_name (object_type
, dtor_type
))
2155 dtor_type
= object_type
;
2158 error ("object type %qT does not match destructor name ~%qT",
2159 object_type
, dtor_type
);
2160 return error_mark_node
;
2164 else if (!DERIVED_FROM_P (dtor_type
, TYPE_MAIN_VARIANT (object_type
)))
2166 error ("the type being destroyed is %qT, but the destructor refers to %qT",
2167 TYPE_MAIN_VARIANT (object_type
), dtor_type
);
2168 return error_mark_node
;
2170 expr
= lookup_member (dtor_type
, complete_dtor_identifier
,
2171 /*protect=*/1, /*want_type=*/false);
2172 expr
= (adjust_result_of_qualified_name_lookup
2173 (expr
, dtor_type
, object_type
));
2177 /* An expression of the form "A::template B" has been resolved to
2178 DECL. Issue a diagnostic if B is not a template or template
2182 check_template_keyword (tree decl
)
2184 /* The standard says:
2188 If a name prefixed by the keyword template is not a member
2189 template, the program is ill-formed.
2191 DR 228 removed the restriction that the template be a member
2194 DR 96, if accepted would add the further restriction that explicit
2195 template arguments must be provided if the template keyword is
2196 used, but, as of 2005-10-16, that DR is still in "drafting". If
2197 this DR is accepted, then the semantic checks here can be
2198 simplified, as the entity named must in fact be a template
2199 specialization, rather than, as at present, a set of overloaded
2200 functions containing at least one template function. */
2201 if (TREE_CODE (decl
) != TEMPLATE_DECL
2202 && TREE_CODE (decl
) != TEMPLATE_ID_EXPR
)
2204 if (!is_overloaded_fn (decl
))
2205 permerror (input_location
, "%qD is not a template", decl
);
2210 if (BASELINK_P (fns
))
2211 fns
= BASELINK_FUNCTIONS (fns
);
2214 tree fn
= OVL_CURRENT (fns
);
2215 if (TREE_CODE (fn
) == TEMPLATE_DECL
2216 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2218 if (TREE_CODE (fn
) == FUNCTION_DECL
2219 && DECL_USE_TEMPLATE (fn
)
2220 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
2222 fns
= OVL_NEXT (fns
);
2225 permerror (input_location
, "%qD is not a template", decl
);
2230 /* This function is called by the parser to process a class member
2231 access expression of the form OBJECT.NAME. NAME is a node used by
2232 the parser to represent a name; it is not yet a DECL. It may,
2233 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2234 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2235 there is no reason to do the lookup twice, so the parser keeps the
2236 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2237 be a template via the use of the "A::template B" syntax. */
2240 finish_class_member_access_expr (tree object
, tree name
, bool template_p
,
2241 tsubst_flags_t complain
)
2246 tree access_path
= NULL_TREE
;
2247 tree orig_object
= object
;
2248 tree orig_name
= name
;
2250 if (object
== error_mark_node
|| name
== error_mark_node
)
2251 return error_mark_node
;
2253 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2254 if (!objc_is_public (object
, name
))
2255 return error_mark_node
;
2257 object_type
= TREE_TYPE (object
);
2259 if (processing_template_decl
)
2261 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2262 dependent_type_p (object_type
)
2263 /* If NAME is just an IDENTIFIER_NODE, then the expression
2265 || TREE_CODE (object
) == IDENTIFIER_NODE
2266 /* If NAME is "f<args>", where either 'f' or 'args' is
2267 dependent, then the expression is dependent. */
2268 || (TREE_CODE (name
) == TEMPLATE_ID_EXPR
2269 && dependent_template_id_p (TREE_OPERAND (name
, 0),
2270 TREE_OPERAND (name
, 1)))
2271 /* If NAME is "T::X" where "T" is dependent, then the
2272 expression is dependent. */
2273 || (TREE_CODE (name
) == SCOPE_REF
2274 && TYPE_P (TREE_OPERAND (name
, 0))
2275 && dependent_type_p (TREE_OPERAND (name
, 0))))
2276 return build_min_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
2277 object
= build_non_dependent_expr (object
);
2282 The type of the first expression shall be "class object" (of a
2284 if (!currently_open_class (object_type
)
2285 && !complete_type_or_else (object_type
, object
))
2286 return error_mark_node
;
2287 if (!CLASS_TYPE_P (object_type
))
2289 if (complain
& tf_error
)
2290 error ("request for member %qD in %qE, which is of non-class type %qT",
2291 name
, object
, object_type
);
2292 return error_mark_node
;
2295 if (BASELINK_P (name
))
2296 /* A member function that has already been looked up. */
2300 bool is_template_id
= false;
2301 tree template_args
= NULL_TREE
;
2304 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2306 is_template_id
= true;
2307 template_args
= TREE_OPERAND (name
, 1);
2308 name
= TREE_OPERAND (name
, 0);
2310 if (TREE_CODE (name
) == OVERLOAD
)
2311 name
= DECL_NAME (get_first_fn (name
));
2312 else if (DECL_P (name
))
2313 name
= DECL_NAME (name
);
2316 if (TREE_CODE (name
) == SCOPE_REF
)
2318 /* A qualified name. The qualifying class or namespace `S'
2319 has already been looked up; it is either a TYPE or a
2321 scope
= TREE_OPERAND (name
, 0);
2322 name
= TREE_OPERAND (name
, 1);
2324 /* If SCOPE is a namespace, then the qualified name does not
2325 name a member of OBJECT_TYPE. */
2326 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
2328 if (complain
& tf_error
)
2329 error ("%<%D::%D%> is not a member of %qT",
2330 scope
, name
, object_type
);
2331 return error_mark_node
;
2334 gcc_assert (CLASS_TYPE_P (scope
));
2335 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
2336 || TREE_CODE (name
) == BIT_NOT_EXPR
);
2338 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2339 access_path
= lookup_base (object_type
, scope
, ba_check
, NULL
);
2340 if (access_path
== error_mark_node
)
2341 return error_mark_node
;
2344 if (complain
& tf_error
)
2345 error ("%qT is not a base of %qT", scope
, object_type
);
2346 return error_mark_node
;
2352 access_path
= object_type
;
2355 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2356 member
= lookup_destructor (object
, scope
, name
);
2359 /* Look up the member. */
2360 member
= lookup_member (access_path
, name
, /*protect=*/1,
2361 /*want_type=*/false);
2362 if (member
== NULL_TREE
)
2364 if (complain
& tf_error
)
2365 error ("%qD has no member named %qE", object_type
, name
);
2366 return error_mark_node
;
2368 if (member
== error_mark_node
)
2369 return error_mark_node
;
2374 tree templ
= member
;
2376 if (BASELINK_P (templ
))
2377 templ
= lookup_template_function (templ
, template_args
);
2380 if (complain
& tf_error
)
2381 error ("%qD is not a member template function", name
);
2382 return error_mark_node
;
2387 if (TREE_DEPRECATED (member
))
2388 warn_deprecated_use (member
, NULL_TREE
);
2391 check_template_keyword (member
);
2393 expr
= build_class_member_access_expr (object
, member
, access_path
,
2394 /*preserve_reference=*/false,
2396 if (processing_template_decl
&& expr
!= error_mark_node
)
2398 if (BASELINK_P (member
))
2400 if (TREE_CODE (orig_name
) == SCOPE_REF
)
2401 BASELINK_QUALIFIED_P (member
) = 1;
2404 return build_min_non_dep (COMPONENT_REF
, expr
,
2405 orig_object
, orig_name
,
2412 /* Return an expression for the MEMBER_NAME field in the internal
2413 representation of PTRMEM, a pointer-to-member function. (Each
2414 pointer-to-member function type gets its own RECORD_TYPE so it is
2415 more convenient to access the fields by name than by FIELD_DECL.)
2416 This routine converts the NAME to a FIELD_DECL and then creates the
2417 node for the complete expression. */
2420 build_ptrmemfunc_access_expr (tree ptrmem
, tree member_name
)
2426 /* This code is a stripped down version of
2427 build_class_member_access_expr. It does not work to use that
2428 routine directly because it expects the object to be of class
2430 ptrmem_type
= TREE_TYPE (ptrmem
);
2431 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type
));
2432 member
= lookup_member (ptrmem_type
, member_name
, /*protect=*/0,
2433 /*want_type=*/false);
2434 member_type
= cp_build_qualified_type (TREE_TYPE (member
),
2435 cp_type_quals (ptrmem_type
));
2436 return fold_build3_loc (input_location
,
2437 COMPONENT_REF
, member_type
,
2438 ptrmem
, member
, NULL_TREE
);
2441 /* Given an expression PTR for a pointer, return an expression
2442 for the value pointed to.
2443 ERRORSTRING is the name of the operator to appear in error messages.
2445 This function may need to overload OPERATOR_FNNAME.
2446 Must also handle REFERENCE_TYPEs for C++. */
2449 build_x_indirect_ref (tree expr
, const char *errorstring
,
2450 tsubst_flags_t complain
)
2452 tree orig_expr
= expr
;
2455 if (processing_template_decl
)
2457 /* Retain the type if we know the operand is a pointer so that
2458 describable_type doesn't make auto deduction break. */
2459 if (TREE_TYPE (expr
) && POINTER_TYPE_P (TREE_TYPE (expr
)))
2460 return build_min (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (expr
)), expr
);
2461 if (type_dependent_expression_p (expr
))
2462 return build_min_nt (INDIRECT_REF
, expr
);
2463 expr
= build_non_dependent_expr (expr
);
2466 rval
= build_new_op (INDIRECT_REF
, LOOKUP_NORMAL
, expr
, NULL_TREE
,
2467 NULL_TREE
, /*overloaded_p=*/NULL
, complain
);
2469 rval
= cp_build_indirect_ref (expr
, errorstring
, complain
);
2471 if (processing_template_decl
&& rval
!= error_mark_node
)
2472 return build_min_non_dep (INDIRECT_REF
, rval
, orig_expr
);
2477 /* Helper function called from c-common. */
2479 build_indirect_ref (location_t loc
__attribute__ ((__unused__
)),
2480 tree ptr
, const char *errorstring
)
2482 return cp_build_indirect_ref (ptr
, errorstring
, tf_warning_or_error
);
2486 cp_build_indirect_ref (tree ptr
, const char *errorstring
,
2487 tsubst_flags_t complain
)
2491 if (ptr
== error_mark_node
)
2492 return error_mark_node
;
2494 if (ptr
== current_class_ptr
)
2495 return current_class_ref
;
2497 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2498 ? ptr
: decay_conversion (ptr
));
2499 type
= TREE_TYPE (pointer
);
2501 if (POINTER_TYPE_P (type
))
2505 If the type of the expression is "pointer to T," the type
2506 of the result is "T." */
2507 tree t
= TREE_TYPE (type
);
2509 if (CONVERT_EXPR_P (ptr
)
2510 || TREE_CODE (ptr
) == VIEW_CONVERT_EXPR
)
2512 /* If a warning is issued, mark it to avoid duplicates from
2513 the backend. This only needs to be done at
2514 warn_strict_aliasing > 2. */
2515 if (warn_strict_aliasing
> 2)
2516 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr
, 0)),
2517 type
, TREE_OPERAND (ptr
, 0)))
2518 TREE_NO_WARNING (ptr
) = 1;
2521 if (VOID_TYPE_P (t
))
2523 /* A pointer to incomplete type (other than cv void) can be
2524 dereferenced [expr.unary.op]/1 */
2525 if (complain
& tf_error
)
2526 error ("%qT is not a pointer-to-object type", type
);
2527 return error_mark_node
;
2529 else if (TREE_CODE (pointer
) == ADDR_EXPR
2530 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
2531 /* The POINTER was something like `&x'. We simplify `*&x' to
2533 return TREE_OPERAND (pointer
, 0);
2536 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
2538 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2539 so that we get the proper error message if the result is used
2540 to assign to. Also, &* is supposed to be a no-op. */
2541 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
2542 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
2543 TREE_SIDE_EFFECTS (ref
)
2544 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
));
2548 else if (!(complain
& tf_error
))
2549 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
2551 /* `pointer' won't be an error_mark_node if we were given a
2552 pointer to member, so it's cool to check for this here. */
2553 else if (TYPE_PTR_TO_MEMBER_P (type
))
2554 error ("invalid use of %qs on pointer to member", errorstring
);
2555 else if (pointer
!= error_mark_node
)
2558 error ("invalid type argument of %qs", errorstring
);
2560 error ("invalid type argument");
2562 return error_mark_node
;
2565 /* This handles expressions of the form "a[i]", which denotes
2568 This is logically equivalent in C to *(a+i), but we may do it differently.
2569 If A is a variable or a member, we generate a primitive ARRAY_REF.
2570 This avoids forcing the array out of registers, and can work on
2571 arrays that are not lvalues (for example, members of structures returned
2574 If INDEX is of some user-defined type, it must be converted to
2575 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2576 will inherit the type of the array, which will be some pointer type.
2578 LOC is the location to use in building the array reference. */
2581 build_array_ref (location_t loc
, tree array
, tree idx
)
2587 error_at (loc
, "subscript missing in array reference");
2588 return error_mark_node
;
2591 if (TREE_TYPE (array
) == error_mark_node
2592 || TREE_TYPE (idx
) == error_mark_node
)
2593 return error_mark_node
;
2595 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2597 switch (TREE_CODE (array
))
2601 tree value
= build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
);
2602 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
2603 TREE_OPERAND (array
, 0), value
);
2604 SET_EXPR_LOCATION (ret
, loc
);
2609 ret
= build_conditional_expr
2610 (TREE_OPERAND (array
, 0),
2611 build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
),
2612 build_array_ref (loc
, TREE_OPERAND (array
, 2), idx
),
2613 tf_warning_or_error
);
2614 protected_set_expr_location (ret
, loc
);
2621 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
2625 warn_array_subscript_with_type_char (idx
);
2627 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx
)))
2629 error_at (loc
, "array subscript is not an integer");
2630 return error_mark_node
;
2633 /* Apply integral promotions *after* noticing character types.
2634 (It is unclear why we do these promotions -- the standard
2635 does not say that we should. In fact, the natural thing would
2636 seem to be to convert IDX to ptrdiff_t; we're performing
2637 pointer arithmetic.) */
2638 idx
= perform_integral_promotions (idx
);
2640 /* An array that is indexed by a non-constant
2641 cannot be stored in a register; we must be able to do
2642 address arithmetic on its address.
2643 Likewise an array of elements of variable size. */
2644 if (TREE_CODE (idx
) != INTEGER_CST
2645 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
2646 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2649 if (!cxx_mark_addressable (array
))
2650 return error_mark_node
;
2653 /* An array that is indexed by a constant value which is not within
2654 the array bounds cannot be stored in a register either; because we
2655 would get a crash in store_bit_field/extract_bit_field when trying
2656 to access a non-existent part of the register. */
2657 if (TREE_CODE (idx
) == INTEGER_CST
2658 && TYPE_DOMAIN (TREE_TYPE (array
))
2659 && ! int_fits_type_p (idx
, TYPE_DOMAIN (TREE_TYPE (array
))))
2661 if (!cxx_mark_addressable (array
))
2662 return error_mark_node
;
2665 if (!lvalue_p (array
))
2666 pedwarn (loc
, OPT_pedantic
,
2667 "ISO C++ forbids subscripting non-lvalue array");
2669 /* Note in C++ it is valid to subscript a `register' array, since
2670 it is valid to take the address of something with that
2671 storage specification. */
2675 while (TREE_CODE (foo
) == COMPONENT_REF
)
2676 foo
= TREE_OPERAND (foo
, 0);
2677 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2678 warning_at (loc
, OPT_Wextra
,
2679 "subscripting array declared %<register%>");
2682 type
= TREE_TYPE (TREE_TYPE (array
));
2683 rval
= build4 (ARRAY_REF
, type
, array
, idx
, NULL_TREE
, NULL_TREE
);
2684 /* Array ref is const/volatile if the array elements are
2685 or if the array is.. */
2686 TREE_READONLY (rval
)
2687 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
2688 TREE_SIDE_EFFECTS (rval
)
2689 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
2690 TREE_THIS_VOLATILE (rval
)
2691 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
2692 ret
= require_complete_type (fold_if_not_in_template (rval
));
2693 protected_set_expr_location (ret
, loc
);
2698 tree ar
= default_conversion (array
);
2699 tree ind
= default_conversion (idx
);
2701 /* Put the integer in IND to simplify error checking. */
2702 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2709 if (ar
== error_mark_node
)
2712 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2714 error_at (loc
, "subscripted value is neither array nor pointer");
2715 return error_mark_node
;
2717 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2719 error_at (loc
, "array subscript is not an integer");
2720 return error_mark_node
;
2723 warn_array_subscript_with_type_char (idx
);
2725 ret
= cp_build_indirect_ref (cp_build_binary_op (input_location
,
2727 tf_warning_or_error
),
2729 tf_warning_or_error
);
2730 protected_set_expr_location (ret
, loc
);
2735 /* Resolve a pointer to member function. INSTANCE is the object
2736 instance to use, if the member points to a virtual member.
2738 This used to avoid checking for virtual functions if basetype
2739 has no virtual functions, according to an earlier ANSI draft.
2740 With the final ISO C++ rules, such an optimization is
2741 incorrect: A pointer to a derived member can be static_cast
2742 to pointer-to-base-member, as long as the dynamic object
2743 later has the right member. */
2746 get_member_function_from_ptrfunc (tree
*instance_ptrptr
, tree function
)
2748 if (TREE_CODE (function
) == OFFSET_REF
)
2749 function
= TREE_OPERAND (function
, 1);
2751 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2753 tree idx
, delta
, e1
, e2
, e3
, vtbl
, basetype
;
2754 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2756 tree instance_ptr
= *instance_ptrptr
;
2757 tree instance_save_expr
= 0;
2758 if (instance_ptr
== error_mark_node
)
2760 if (TREE_CODE (function
) == PTRMEM_CST
)
2762 /* Extracting the function address from a pmf is only
2763 allowed with -Wno-pmf-conversions. It only works for
2765 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
));
2766 e1
= convert (fntype
, e1
);
2771 error ("object missing in use of %qE", function
);
2772 return error_mark_node
;
2776 if (TREE_SIDE_EFFECTS (instance_ptr
))
2777 instance_ptr
= instance_save_expr
= save_expr (instance_ptr
);
2779 if (TREE_SIDE_EFFECTS (function
))
2780 function
= save_expr (function
);
2782 /* Start by extracting all the information from the PMF itself. */
2783 e3
= pfn_from_ptrmemfunc (function
);
2784 delta
= delta_from_ptrmemfunc (function
);
2785 idx
= build1 (NOP_EXPR
, vtable_index_type
, e3
);
2786 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
2788 case ptrmemfunc_vbit_in_pfn
:
2789 e1
= cp_build_binary_op (input_location
,
2790 BIT_AND_EXPR
, idx
, integer_one_node
,
2791 tf_warning_or_error
);
2792 idx
= cp_build_binary_op (input_location
,
2793 MINUS_EXPR
, idx
, integer_one_node
,
2794 tf_warning_or_error
);
2797 case ptrmemfunc_vbit_in_delta
:
2798 e1
= cp_build_binary_op (input_location
,
2799 BIT_AND_EXPR
, delta
, integer_one_node
,
2800 tf_warning_or_error
);
2801 delta
= cp_build_binary_op (input_location
,
2802 RSHIFT_EXPR
, delta
, integer_one_node
,
2803 tf_warning_or_error
);
2810 /* Convert down to the right base before using the instance. A
2811 special case is that in a pointer to member of class C, C may
2812 be incomplete. In that case, the function will of course be
2813 a member of C, and no conversion is required. In fact,
2814 lookup_base will fail in that case, because incomplete
2815 classes do not have BINFOs. */
2816 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2817 if (!same_type_ignoring_top_level_qualifiers_p
2818 (basetype
, TREE_TYPE (TREE_TYPE (instance_ptr
))))
2820 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr
)),
2821 basetype
, ba_check
, NULL
);
2822 instance_ptr
= build_base_path (PLUS_EXPR
, instance_ptr
, basetype
,
2824 if (instance_ptr
== error_mark_node
)
2825 return error_mark_node
;
2827 /* ...and then the delta in the PMF. */
2828 instance_ptr
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2829 instance_ptr
, fold_convert (sizetype
, delta
));
2831 /* Hand back the adjusted 'this' argument to our caller. */
2832 *instance_ptrptr
= instance_ptr
;
2834 /* Next extract the vtable pointer from the object. */
2835 vtbl
= build1 (NOP_EXPR
, build_pointer_type (vtbl_ptr_type_node
),
2837 vtbl
= cp_build_indirect_ref (vtbl
, NULL
, tf_warning_or_error
);
2838 /* If the object is not dynamic the access invokes undefined
2839 behavior. As it is not executed in this case silence the
2840 spurious warnings it may provoke. */
2841 TREE_NO_WARNING (vtbl
) = 1;
2843 /* Finally, extract the function pointer from the vtable. */
2844 e2
= fold_build2_loc (input_location
,
2845 POINTER_PLUS_EXPR
, TREE_TYPE (vtbl
), vtbl
,
2846 fold_convert (sizetype
, idx
));
2847 e2
= cp_build_indirect_ref (e2
, NULL
, tf_warning_or_error
);
2848 TREE_CONSTANT (e2
) = 1;
2850 /* When using function descriptors, the address of the
2851 vtable entry is treated as a function pointer. */
2852 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2853 e2
= build1 (NOP_EXPR
, TREE_TYPE (e2
),
2854 cp_build_unary_op (ADDR_EXPR
, e2
, /*noconvert=*/1,
2855 tf_warning_or_error
));
2857 e2
= fold_convert (TREE_TYPE (e3
), e2
);
2858 e1
= build_conditional_expr (e1
, e2
, e3
, tf_warning_or_error
);
2860 /* Make sure this doesn't get evaluated first inside one of the
2861 branches of the COND_EXPR. */
2862 if (instance_save_expr
)
2863 e1
= build2 (COMPOUND_EXPR
, TREE_TYPE (e1
),
2864 instance_save_expr
, e1
);
2871 /* Used by the C-common bits. */
2873 build_function_call (location_t loc ATTRIBUTE_UNUSED
,
2874 tree function
, tree params
)
2876 return cp_build_function_call (function
, params
, tf_warning_or_error
);
2879 /* Used by the C-common bits. */
2881 build_function_call_vec (location_t loc ATTRIBUTE_UNUSED
,
2882 tree function
, VEC(tree
,gc
) *params
,
2883 VEC(tree
,gc
) *origtypes ATTRIBUTE_UNUSED
)
2885 VEC(tree
,gc
) *orig_params
= params
;
2886 tree ret
= cp_build_function_call_vec (function
, ¶ms
,
2887 tf_warning_or_error
);
2889 /* cp_build_function_call_vec can reallocate PARAMS by adding
2890 default arguments. That should never happen here. Verify
2892 gcc_assert (params
== orig_params
);
2897 /* Build a function call using a tree list of arguments. */
2900 cp_build_function_call (tree function
, tree params
, tsubst_flags_t complain
)
2905 vec
= make_tree_vector ();
2906 for (; params
!= NULL_TREE
; params
= TREE_CHAIN (params
))
2907 VEC_safe_push (tree
, gc
, vec
, TREE_VALUE (params
));
2908 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
2909 release_tree_vector (vec
);
2913 /* Build a function call using a vector of arguments. PARAMS may be
2914 NULL if there are no parameters. This changes the contents of
2918 cp_build_function_call_vec (tree function
, VEC(tree
,gc
) **params
,
2919 tsubst_flags_t complain
)
2921 tree fntype
, fndecl
;
2922 tree name
= NULL_TREE
;
2924 tree original
= function
;
2928 VEC(tree
,gc
) *allocated
= NULL
;
2931 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2932 expressions, like those used for ObjC messenger dispatches. */
2933 if (params
!= NULL
&& !VEC_empty (tree
, *params
))
2934 function
= objc_rewrite_function_call (function
,
2935 VEC_index (tree
, *params
, 0));
2937 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2938 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2939 if (TREE_CODE (function
) == NOP_EXPR
2940 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2941 function
= TREE_OPERAND (function
, 0);
2943 if (TREE_CODE (function
) == FUNCTION_DECL
)
2945 name
= DECL_NAME (function
);
2947 mark_used (function
);
2950 /* Convert anything with function type to a pointer-to-function. */
2951 if (DECL_MAIN_P (function
) && (complain
& tf_error
))
2952 pedwarn (input_location
, OPT_pedantic
,
2953 "ISO C++ forbids calling %<::main%> from within program");
2955 function
= build_addr_func (function
);
2961 function
= build_addr_func (function
);
2964 if (function
== error_mark_node
)
2965 return error_mark_node
;
2967 fntype
= TREE_TYPE (function
);
2969 if (TYPE_PTRMEMFUNC_P (fntype
))
2971 if (complain
& tf_error
)
2972 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2973 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
2974 original
, original
);
2975 return error_mark_node
;
2978 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2979 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2981 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2982 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2984 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
2986 if (complain
& tf_error
)
2987 error ("%qE cannot be used as a function", original
);
2988 return error_mark_node
;
2991 /* fntype now gets the type of function pointed to. */
2992 fntype
= TREE_TYPE (fntype
);
2993 parm_types
= TYPE_ARG_TYPES (fntype
);
2997 allocated
= make_tree_vector ();
2998 params
= &allocated
;
3001 nargs
= convert_arguments (parm_types
, params
, fndecl
, LOOKUP_NORMAL
,
3004 return error_mark_node
;
3006 argarray
= VEC_address (tree
, *params
);
3008 /* Check for errors in format strings and inappropriately
3010 check_function_arguments (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
,
3013 ret
= build_cxx_call (function
, nargs
, argarray
);
3015 if (allocated
!= NULL
)
3016 release_tree_vector (allocated
);
3021 /* Convert the actual parameter expressions in the list VALUES to the
3022 types in the list TYPELIST. The converted expressions are stored
3023 back in the VALUES vector.
3024 If parmdecls is exhausted, or when an element has NULL as its type,
3025 perform the default conversions.
3027 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
3029 This is also where warnings about wrong number of args are generated.
3031 Returns the actual number of arguments processed (which might be less
3032 than the length of the vector), or -1 on error.
3034 In C++, unspecified trailing parameters can be filled in with their
3035 default arguments, if such were specified. Do so here. */
3038 convert_arguments (tree typelist
, VEC(tree
,gc
) **values
, tree fndecl
,
3039 int flags
, tsubst_flags_t complain
)
3042 const char *called_thing
= 0;
3045 /* Argument passing is always copy-initialization. */
3046 flags
|= LOOKUP_ONLYCONVERTING
;
3050 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
3052 if (DECL_NAME (fndecl
) == NULL_TREE
3053 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
3054 called_thing
= "constructor";
3056 called_thing
= "member function";
3059 called_thing
= "function";
3062 for (i
= 0, typetail
= typelist
;
3063 i
< VEC_length (tree
, *values
);
3066 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
3067 tree val
= VEC_index (tree
, *values
, i
);
3069 if (val
== error_mark_node
|| type
== error_mark_node
)
3072 if (type
== void_type_node
)
3074 if (complain
& tf_error
)
3078 error ("too many arguments to %s %q+#D",
3079 called_thing
, fndecl
);
3080 error ("at this point in file");
3083 error ("too many arguments to function");
3090 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3091 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3092 if (TREE_CODE (val
) == NOP_EXPR
3093 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3094 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3095 val
= TREE_OPERAND (val
, 0);
3097 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3099 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3100 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3101 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3102 val
= decay_conversion (val
);
3105 if (val
== error_mark_node
)
3110 /* Formal parm type is specified by a function prototype. */
3113 if (!COMPLETE_TYPE_P (complete_type (type
)))
3115 if (complain
& tf_error
)
3118 error ("parameter %P of %qD has incomplete type %qT",
3121 error ("parameter %P has incomplete type %qT", i
, type
);
3123 parmval
= error_mark_node
;
3127 parmval
= convert_for_initialization
3128 (NULL_TREE
, type
, val
, flags
,
3129 "argument passing", fndecl
, i
, complain
);
3130 parmval
= convert_for_arg_passing (type
, parmval
);
3133 if (parmval
== error_mark_node
)
3136 VEC_replace (tree
, *values
, i
, parmval
);
3140 if (fndecl
&& DECL_BUILT_IN (fndecl
)
3141 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CONSTANT_P
)
3142 /* Don't do ellipsis conversion for __built_in_constant_p
3143 as this will result in spurious errors for non-trivial
3145 val
= require_complete_type (val
);
3147 val
= convert_arg_to_ellipsis (val
);
3149 VEC_replace (tree
, *values
, i
, val
);
3153 typetail
= TREE_CHAIN (typetail
);
3156 if (typetail
!= 0 && typetail
!= void_list_node
)
3158 /* See if there are default arguments that can be used. Because
3159 we hold default arguments in the FUNCTION_TYPE (which is so
3160 wrong), we can see default parameters here from deduced
3161 contexts (and via typeof) for indirect function calls.
3162 Fortunately we know whether we have a function decl to
3163 provide default arguments in a language conformant
3165 if (fndecl
&& TREE_PURPOSE (typetail
)
3166 && TREE_CODE (TREE_PURPOSE (typetail
)) != DEFAULT_ARG
)
3168 for (; typetail
!= void_list_node
; ++i
)
3171 = convert_default_arg (TREE_VALUE (typetail
),
3172 TREE_PURPOSE (typetail
),
3175 if (parmval
== error_mark_node
)
3178 VEC_safe_push (tree
, gc
, *values
, parmval
);
3179 typetail
= TREE_CHAIN (typetail
);
3180 /* ends with `...'. */
3181 if (typetail
== NULL_TREE
)
3187 if (complain
& tf_error
)
3191 error ("too few arguments to %s %q+#D",
3192 called_thing
, fndecl
);
3193 error ("at this point in file");
3196 error ("too few arguments to function");
3205 /* Build a binary-operation expression, after performing default
3206 conversions on the operands. CODE is the kind of expression to
3207 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3208 are the tree codes which correspond to ARG1 and ARG2 when issuing
3209 warnings about possibly misplaced parentheses. They may differ
3210 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3211 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3212 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3213 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3214 ARG2_CODE as ERROR_MARK. */
3217 build_x_binary_op (enum tree_code code
, tree arg1
, enum tree_code arg1_code
,
3218 tree arg2
, enum tree_code arg2_code
, bool *overloaded_p
,
3219 tsubst_flags_t complain
)
3228 if (processing_template_decl
)
3230 if (type_dependent_expression_p (arg1
)
3231 || type_dependent_expression_p (arg2
))
3232 return build_min_nt (code
, arg1
, arg2
);
3233 arg1
= build_non_dependent_expr (arg1
);
3234 arg2
= build_non_dependent_expr (arg2
);
3237 if (code
== DOTSTAR_EXPR
)
3238 expr
= build_m_component_ref (arg1
, arg2
);
3240 expr
= build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
3241 overloaded_p
, complain
);
3243 /* Check for cases such as x+y<<z which users are likely to
3244 misinterpret. But don't warn about obj << x + y, since that is a
3245 common idiom for I/O. */
3246 if (warn_parentheses
3247 && !processing_template_decl
3248 && !error_operand_p (arg1
)
3249 && !error_operand_p (arg2
)
3250 && (code
!= LSHIFT_EXPR
3251 || !CLASS_TYPE_P (TREE_TYPE (arg1
))))
3252 warn_about_parentheses (code
, arg1_code
, orig_arg1
, arg2_code
, orig_arg2
);
3254 if (processing_template_decl
&& expr
!= error_mark_node
)
3255 return build_min_non_dep (code
, expr
, orig_arg1
, orig_arg2
);
3260 /* Build and return an ARRAY_REF expression. */
3263 build_x_array_ref (tree arg1
, tree arg2
, tsubst_flags_t complain
)
3265 tree orig_arg1
= arg1
;
3266 tree orig_arg2
= arg2
;
3269 if (processing_template_decl
)
3271 if (type_dependent_expression_p (arg1
)
3272 || type_dependent_expression_p (arg2
))
3273 return build_min_nt (ARRAY_REF
, arg1
, arg2
,
3274 NULL_TREE
, NULL_TREE
);
3275 arg1
= build_non_dependent_expr (arg1
);
3276 arg2
= build_non_dependent_expr (arg2
);
3279 expr
= build_new_op (ARRAY_REF
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
3280 /*overloaded_p=*/NULL
, complain
);
3282 if (processing_template_decl
&& expr
!= error_mark_node
)
3283 return build_min_non_dep (ARRAY_REF
, expr
, orig_arg1
, orig_arg2
,
3284 NULL_TREE
, NULL_TREE
);
3288 /* For the c-common bits. */
3290 build_binary_op (location_t location
, enum tree_code code
, tree op0
, tree op1
,
3291 int convert_p ATTRIBUTE_UNUSED
)
3293 return cp_build_binary_op (location
, code
, op0
, op1
, tf_warning_or_error
);
3297 /* Build a binary-operation expression without default conversions.
3298 CODE is the kind of expression to build.
3299 LOCATION is the location_t of the operator in the source code.
3300 This function differs from `build' in several ways:
3301 the data type of the result is computed and recorded in it,
3302 warnings are generated if arg data types are invalid,
3303 special handling for addition and subtraction of pointers is known,
3304 and some optimization is done (operations on narrow ints
3305 are done in the narrower type when that gives the same result).
3306 Constant folding is also done before the result is returned.
3308 Note that the operands will never have enumeral types
3309 because either they have just had the default conversions performed
3310 or they have both just been converted to some other type in which
3311 the arithmetic is to be done.
3313 C++: must do special pointer arithmetic when implementing
3314 multiple inheritance, and deal with pointer to member functions. */
3317 cp_build_binary_op (location_t location
,
3318 enum tree_code code
, tree orig_op0
, tree orig_op1
,
3319 tsubst_flags_t complain
)
3322 enum tree_code code0
, code1
;
3324 const char *invalid_op_diag
;
3326 /* Expression code to give to the expression when it is built.
3327 Normally this is CODE, which is what the caller asked for,
3328 but in some special cases we change it. */
3329 enum tree_code resultcode
= code
;
3331 /* Data type in which the computation is to be performed.
3332 In the simplest cases this is the common type of the arguments. */
3333 tree result_type
= NULL
;
3335 /* Nonzero means operands have already been type-converted
3336 in whatever way is necessary.
3337 Zero means they need to be converted to RESULT_TYPE. */
3340 /* Nonzero means create the expression with this type, rather than
3342 tree build_type
= 0;
3344 /* Nonzero means after finally constructing the expression
3345 convert it to this type. */
3346 tree final_type
= 0;
3350 /* Nonzero if this is an operation like MIN or MAX which can
3351 safely be computed in short if both args are promoted shorts.
3352 Also implies COMMON.
3353 -1 indicates a bitwise operation; this makes a difference
3354 in the exact conditions for when it is safe to do the operation
3355 in a narrower mode. */
3358 /* Nonzero if this is a comparison operation;
3359 if both args are promoted shorts, compare the original shorts.
3360 Also implies COMMON. */
3361 int short_compare
= 0;
3363 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3366 /* True if both operands have arithmetic type. */
3367 bool arithmetic_types_p
;
3369 /* Apply default conversions. */
3373 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3374 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3375 || code
== TRUTH_XOR_EXPR
)
3377 if (!really_overloaded_fn (op0
))
3378 op0
= decay_conversion (op0
);
3379 if (!really_overloaded_fn (op1
))
3380 op1
= decay_conversion (op1
);
3384 if (!really_overloaded_fn (op0
))
3385 op0
= default_conversion (op0
);
3386 if (!really_overloaded_fn (op1
))
3387 op1
= default_conversion (op1
);
3390 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3391 STRIP_TYPE_NOPS (op0
);
3392 STRIP_TYPE_NOPS (op1
);
3394 /* DTRT if one side is an overloaded function, but complain about it. */
3395 if (type_unknown_p (op0
))
3397 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, tf_none
);
3398 if (t
!= error_mark_node
)
3400 if (complain
& tf_error
)
3401 permerror (input_location
, "assuming cast to type %qT from overloaded function",
3406 if (type_unknown_p (op1
))
3408 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, tf_none
);
3409 if (t
!= error_mark_node
)
3411 if (complain
& tf_error
)
3412 permerror (input_location
, "assuming cast to type %qT from overloaded function",
3418 type0
= TREE_TYPE (op0
);
3419 type1
= TREE_TYPE (op1
);
3421 /* The expression codes of the data types of the arguments tell us
3422 whether the arguments are integers, floating, pointers, etc. */
3423 code0
= TREE_CODE (type0
);
3424 code1
= TREE_CODE (type1
);
3426 /* If an error was already reported for one of the arguments,
3427 avoid reporting another error. */
3428 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3429 return error_mark_node
;
3431 if ((invalid_op_diag
3432 = targetm
.invalid_binary_op (code
, type0
, type1
)))
3434 error (invalid_op_diag
);
3435 return error_mark_node
;
3438 /* Issue warnings about peculiar, but valid, uses of NULL. */
3439 if ((orig_op0
== null_node
|| orig_op1
== null_node
)
3440 /* It's reasonable to use pointer values as operands of &&
3441 and ||, so NULL is no exception. */
3442 && code
!= TRUTH_ANDIF_EXPR
&& code
!= TRUTH_ORIF_EXPR
3443 && ( /* Both are NULL (or 0) and the operation was not a
3444 comparison or a pointer subtraction. */
3445 (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)
3446 && code
!= EQ_EXPR
&& code
!= NE_EXPR
&& code
!= MINUS_EXPR
)
3447 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
3448 || (!null_ptr_cst_p (orig_op0
)
3449 && !TYPE_PTR_P (type0
) && !TYPE_PTR_TO_MEMBER_P (type0
))
3450 || (!null_ptr_cst_p (orig_op1
)
3451 && !TYPE_PTR_P (type1
) && !TYPE_PTR_TO_MEMBER_P (type1
)))
3452 && (complain
& tf_warning
))
3453 /* Some sort of arithmetic operation involving NULL was
3455 warning (OPT_Wpointer_arith
, "NULL used in arithmetic");
3460 /* Subtraction of two similar pointers.
3461 We must subtract them as integers, then divide by object size. */
3462 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3463 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
3465 return pointer_diff (op0
, op1
, common_pointer_type (type0
, type1
));
3466 /* In all other cases except pointer - int, the usual arithmetic
3468 else if (!(code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
))
3473 /* The pointer - int case is just like pointer + int; fall
3476 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
3477 && (code0
== INTEGER_TYPE
|| code1
== INTEGER_TYPE
))
3481 ptr_operand
= ((code0
== POINTER_TYPE
) ? op0
: op1
);
3482 int_operand
= ((code0
== INTEGER_TYPE
) ? op0
: op1
);
3483 if (processing_template_decl
)
3485 result_type
= TREE_TYPE (ptr_operand
);
3488 return cp_pointer_int_sum (code
,
3499 case TRUNC_DIV_EXPR
:
3501 case FLOOR_DIV_EXPR
:
3502 case ROUND_DIV_EXPR
:
3503 case EXACT_DIV_EXPR
:
3504 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3505 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
3506 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3507 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
3509 enum tree_code tcode0
= code0
, tcode1
= code1
;
3511 warn_for_div_by_zero (location
, op1
);
3513 if (tcode0
== COMPLEX_TYPE
|| tcode0
== VECTOR_TYPE
)
3514 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
3515 if (tcode1
== COMPLEX_TYPE
|| tcode1
== VECTOR_TYPE
)
3516 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
3518 if (!(tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
))
3519 resultcode
= RDIV_EXPR
;
3521 /* When dividing two signed integers, we have to promote to int.
3522 unless we divide by a constant != -1. Note that default
3523 conversion will have been performed on the operands at this
3524 point, so we have to dig out the original type to find out if
3526 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3527 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3528 || (TREE_CODE (op1
) == INTEGER_CST
3529 && ! integer_all_onesp (op1
)));
3538 if ((code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3539 || (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
3540 && !VECTOR_FLOAT_TYPE_P (type0
)
3541 && !VECTOR_FLOAT_TYPE_P (type1
)))
3545 case TRUNC_MOD_EXPR
:
3546 case FLOOR_MOD_EXPR
:
3547 warn_for_div_by_zero (location
, op1
);
3549 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
3550 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
3551 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
3553 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3555 /* Although it would be tempting to shorten always here, that loses
3556 on some targets, since the modulo instruction is undefined if the
3557 quotient can't be represented in the computation mode. We shorten
3558 only if unsigned or if dividing by something we know != -1. */
3559 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3560 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3561 || (TREE_CODE (op1
) == INTEGER_CST
3562 && ! integer_all_onesp (op1
)));
3567 case TRUTH_ANDIF_EXPR
:
3568 case TRUTH_ORIF_EXPR
:
3569 case TRUTH_AND_EXPR
:
3571 result_type
= boolean_type_node
;
3574 /* Shift operations: result has same type as first operand;
3575 always convert second operand to int.
3576 Also set SHORT_SHIFT if shifting rightward. */
3579 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3581 result_type
= type0
;
3582 if (TREE_CODE (op1
) == INTEGER_CST
)
3584 if (tree_int_cst_lt (op1
, integer_zero_node
))
3586 if ((complain
& tf_warning
)
3587 && c_inhibit_evaluation_warnings
== 0)
3588 warning (0, "right shift count is negative");
3592 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0
3593 && (complain
& tf_warning
)
3594 && c_inhibit_evaluation_warnings
== 0)
3595 warning (0, "right shift count >= width of type");
3598 /* Convert the shift-count to an integer, regardless of
3599 size of value being shifted. */
3600 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3601 op1
= cp_convert (integer_type_node
, op1
);
3602 /* Avoid converting op1 to result_type later. */
3608 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3610 result_type
= type0
;
3611 if (TREE_CODE (op1
) == INTEGER_CST
)
3613 if (tree_int_cst_lt (op1
, integer_zero_node
))
3615 if ((complain
& tf_warning
)
3616 && c_inhibit_evaluation_warnings
== 0)
3617 warning (0, "left shift count is negative");
3619 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3621 if ((complain
& tf_warning
)
3622 && c_inhibit_evaluation_warnings
== 0)
3623 warning (0, "left shift count >= width of type");
3626 /* Convert the shift-count to an integer, regardless of
3627 size of value being shifted. */
3628 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3629 op1
= cp_convert (integer_type_node
, op1
);
3630 /* Avoid converting op1 to result_type later. */
3637 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3639 result_type
= type0
;
3640 if (TREE_CODE (op1
) == INTEGER_CST
)
3642 if (tree_int_cst_lt (op1
, integer_zero_node
))
3644 if (complain
& tf_warning
)
3645 warning (0, (code
== LROTATE_EXPR
)
3646 ? G_("left rotate count is negative")
3647 : G_("right rotate count is negative"));
3649 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3651 if (complain
& tf_warning
)
3652 warning (0, (code
== LROTATE_EXPR
)
3653 ? G_("left rotate count >= width of type")
3654 : G_("right rotate count >= width of type"));
3657 /* Convert the shift-count to an integer, regardless of
3658 size of value being shifted. */
3659 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3660 op1
= cp_convert (integer_type_node
, op1
);
3666 if ((complain
& tf_warning
)
3667 && (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
)))
3668 warning (OPT_Wfloat_equal
,
3669 "comparing floating point with == or != is unsafe");
3670 if ((complain
& tf_warning
)
3671 && ((TREE_CODE (orig_op0
) == STRING_CST
&& !integer_zerop (op1
))
3672 || (TREE_CODE (orig_op1
) == STRING_CST
&& !integer_zerop (op0
))))
3673 warning (OPT_Waddress
, "comparison with string literal results in unspecified behaviour");
3675 build_type
= boolean_type_node
;
3676 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3677 || code0
== COMPLEX_TYPE
|| code0
== ENUMERAL_TYPE
)
3678 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3679 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
))
3681 else if ((code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3682 || (TYPE_PTRMEM_P (type0
) && TYPE_PTRMEM_P (type1
)))
3683 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3684 "comparison", complain
);
3685 else if ((code0
== POINTER_TYPE
|| TYPE_PTRMEM_P (type0
))
3686 && null_ptr_cst_p (op1
))
3688 if (TREE_CODE (op0
) == ADDR_EXPR
3689 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0)))
3691 if (complain
& tf_warning
)
3692 warning (OPT_Waddress
, "the address of %qD will never be NULL",
3693 TREE_OPERAND (op0
, 0));
3695 result_type
= type0
;
3697 else if ((code1
== POINTER_TYPE
|| TYPE_PTRMEM_P (type1
))
3698 && null_ptr_cst_p (op0
))
3700 if (TREE_CODE (op1
) == ADDR_EXPR
3701 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0)))
3703 if (complain
& tf_warning
)
3704 warning (OPT_Waddress
, "the address of %qD will never be NULL",
3705 TREE_OPERAND (op1
, 0));
3707 result_type
= type1
;
3709 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3711 result_type
= type0
;
3712 if (complain
& tf_error
)
3713 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3715 return error_mark_node
;
3717 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3719 result_type
= type1
;
3720 if (complain
& tf_error
)
3721 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3723 return error_mark_node
;
3725 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (op1
))
3727 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3728 == ptrmemfunc_vbit_in_delta
)
3730 tree pfn0
= pfn_from_ptrmemfunc (op0
);
3731 tree delta0
= delta_from_ptrmemfunc (op0
);
3732 tree e1
= cp_build_binary_op (location
,
3735 fold_convert (TREE_TYPE (pfn0
),
3738 tree e2
= cp_build_binary_op (location
,
3743 e2
= cp_build_binary_op (location
,
3744 EQ_EXPR
, e2
, integer_zero_node
,
3746 op0
= cp_build_binary_op (location
,
3747 TRUTH_ANDIF_EXPR
, e1
, e2
,
3749 op1
= cp_convert (TREE_TYPE (op0
), integer_one_node
);
3753 op0
= build_ptrmemfunc_access_expr (op0
, pfn_identifier
);
3754 op1
= cp_convert (TREE_TYPE (op0
), integer_zero_node
);
3756 result_type
= TREE_TYPE (op0
);
3758 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (op0
))
3759 return cp_build_binary_op (location
, code
, op1
, op0
, complain
);
3760 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
))
3763 /* E will be the final comparison. */
3765 /* E1 and E2 are for scratch. */
3773 type
= composite_pointer_type (type0
, type1
, op0
, op1
, "comparison",
3776 if (!same_type_p (TREE_TYPE (op0
), type
))
3777 op0
= cp_convert_and_check (type
, op0
);
3778 if (!same_type_p (TREE_TYPE (op1
), type
))
3779 op1
= cp_convert_and_check (type
, op1
);
3781 if (op0
== error_mark_node
|| op1
== error_mark_node
)
3782 return error_mark_node
;
3784 if (TREE_SIDE_EFFECTS (op0
))
3785 op0
= save_expr (op0
);
3786 if (TREE_SIDE_EFFECTS (op1
))
3787 op1
= save_expr (op1
);
3789 pfn0
= pfn_from_ptrmemfunc (op0
);
3790 pfn1
= pfn_from_ptrmemfunc (op1
);
3791 delta0
= delta_from_ptrmemfunc (op0
);
3792 delta1
= delta_from_ptrmemfunc (op1
);
3793 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3794 == ptrmemfunc_vbit_in_delta
)
3799 && ((op0.delta == op1.delta)
3800 || (!op0.pfn && op0.delta & 1 == 0
3801 && op1.delta & 1 == 0))
3803 The reason for the `!op0.pfn' bit is that a NULL
3804 pointer-to-member is any member with a zero PFN and
3805 LSB of the DELTA field is 0. */
3807 e1
= cp_build_binary_op (location
, BIT_AND_EXPR
,
3811 e1
= cp_build_binary_op (location
,
3812 EQ_EXPR
, e1
, integer_zero_node
,
3814 e2
= cp_build_binary_op (location
, BIT_AND_EXPR
,
3818 e2
= cp_build_binary_op (location
,
3819 EQ_EXPR
, e2
, integer_zero_node
,
3821 e1
= cp_build_binary_op (location
,
3822 TRUTH_ANDIF_EXPR
, e2
, e1
,
3824 e2
= cp_build_binary_op (location
, EQ_EXPR
,
3826 fold_convert (TREE_TYPE (pfn0
),
3829 e2
= cp_build_binary_op (location
,
3830 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
3831 e1
= cp_build_binary_op (location
,
3832 EQ_EXPR
, delta0
, delta1
, complain
);
3833 e1
= cp_build_binary_op (location
,
3834 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
3841 && (!op0.pfn || op0.delta == op1.delta))
3843 The reason for the `!op0.pfn' bit is that a NULL
3844 pointer-to-member is any member with a zero PFN; the
3845 DELTA field is unspecified. */
3847 e1
= cp_build_binary_op (location
,
3848 EQ_EXPR
, delta0
, delta1
, complain
);
3849 e2
= cp_build_binary_op (location
,
3852 fold_convert (TREE_TYPE (pfn0
),
3855 e1
= cp_build_binary_op (location
,
3856 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
3858 e2
= build2 (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
3859 e
= cp_build_binary_op (location
,
3860 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
3861 if (code
== EQ_EXPR
)
3863 return cp_build_binary_op (location
,
3864 EQ_EXPR
, e
, integer_zero_node
, complain
);
3868 gcc_assert (!TYPE_PTRMEMFUNC_P (type0
)
3869 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
),
3871 gcc_assert (!TYPE_PTRMEMFUNC_P (type1
)
3872 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
),
3880 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3881 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3883 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3884 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3885 "comparison", complain
);
3892 if (TREE_CODE (orig_op0
) == STRING_CST
3893 || TREE_CODE (orig_op1
) == STRING_CST
)
3895 if (complain
& tf_warning
)
3896 warning (OPT_Waddress
, "comparison with string literal results in unspecified behaviour");
3899 build_type
= boolean_type_node
;
3900 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3901 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3903 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3904 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3905 "comparison", complain
);
3906 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3907 && integer_zerop (op1
))
3908 result_type
= type0
;
3909 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3910 && integer_zerop (op0
))
3911 result_type
= type1
;
3912 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3914 result_type
= type0
;
3915 if (complain
& tf_error
)
3916 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3918 return error_mark_node
;
3920 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3922 result_type
= type1
;
3923 if (complain
& tf_error
)
3924 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
3926 return error_mark_node
;
3930 case UNORDERED_EXPR
:
3937 build_type
= integer_type_node
;
3938 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
3940 if (complain
& tf_error
)
3941 error ("unordered comparison on non-floating point argument");
3942 return error_mark_node
;
3951 if (((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
3952 || code0
== ENUMERAL_TYPE
)
3953 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3954 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
)))
3955 arithmetic_types_p
= 1;
3958 arithmetic_types_p
= 0;
3959 /* Vector arithmetic is only allowed when both sides are vectors. */
3960 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
3962 if (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
3963 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0
),
3966 binary_op_error (location
, code
, type0
, type1
);
3967 return error_mark_node
;
3969 arithmetic_types_p
= 1;
3972 /* Determine the RESULT_TYPE, if it is not already known. */
3974 && arithmetic_types_p
3975 && (shorten
|| common
|| short_compare
))
3976 result_type
= cp_common_type (type0
, type1
);
3980 if (complain
& tf_error
)
3981 error ("invalid operands of types %qT and %qT to binary %qO",
3982 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
3983 return error_mark_node
;
3986 /* If we're in a template, the only thing we need to know is the
3988 if (processing_template_decl
)
3990 /* Since the middle-end checks the type when doing a build2, we
3991 need to build the tree in pieces. This built tree will never
3992 get out of the front-end as we replace it when instantiating
3994 tree tmp
= build2 (resultcode
,
3995 build_type
? build_type
: result_type
,
3997 TREE_OPERAND (tmp
, 0) = op0
;
4001 if (arithmetic_types_p
)
4003 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
4005 /* For certain operations (which identify themselves by shorten != 0)
4006 if both args were extended from the same smaller type,
4007 do the arithmetic in that type and then extend.
4009 shorten !=0 and !=1 indicates a bitwise operation.
4010 For them, this optimization is safe only if
4011 both args are zero-extended or both are sign-extended.
4012 Otherwise, we might change the result.
4013 E.g., (short)-1 | (unsigned short)-1 is (int)-1
4014 but calculated in (unsigned short) it would be (unsigned short)-1. */
4016 if (shorten
&& none_complex
)
4018 final_type
= result_type
;
4019 result_type
= shorten_binary_op (result_type
, op0
, op1
,
4023 /* Comparison operations are shortened too but differently.
4024 They identify themselves by setting short_compare = 1. */
4028 /* Don't write &op0, etc., because that would prevent op0
4029 from being kept in a register.
4030 Instead, make copies of the our local variables and
4031 pass the copies by reference, then copy them back afterward. */
4032 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
4033 enum tree_code xresultcode
= resultcode
;
4035 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
4037 return cp_convert (boolean_type_node
, val
);
4038 op0
= xop0
, op1
= xop1
;
4040 resultcode
= xresultcode
;
4043 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
4044 && warn_sign_compare
4045 && !TREE_NO_WARNING (orig_op0
)
4046 && !TREE_NO_WARNING (orig_op1
)
4047 /* Do not warn until the template is instantiated; we cannot
4048 bound the ranges of the arguments until that point. */
4049 && !processing_template_decl
4050 && (complain
& tf_warning
)
4051 && c_inhibit_evaluation_warnings
== 0)
4053 warn_for_sign_compare (location
, orig_op0
, orig_op1
, op0
, op1
,
4054 result_type
, resultcode
);
4058 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4059 Then the expression will be built.
4060 It will be given type FINAL_TYPE if that is nonzero;
4061 otherwise, it will be given type RESULT_TYPE. */
4064 if (TREE_TYPE (op0
) != result_type
)
4065 op0
= cp_convert_and_check (result_type
, op0
);
4066 if (TREE_TYPE (op1
) != result_type
)
4067 op1
= cp_convert_and_check (result_type
, op1
);
4069 if (op0
== error_mark_node
|| op1
== error_mark_node
)
4070 return error_mark_node
;
4073 if (build_type
== NULL_TREE
)
4074 build_type
= result_type
;
4076 result
= build2 (resultcode
, build_type
, op0
, op1
);
4077 result
= fold_if_not_in_template (result
);
4078 if (final_type
!= 0)
4079 result
= cp_convert (final_type
, result
);
4081 if (TREE_OVERFLOW_P (result
)
4082 && !TREE_OVERFLOW_P (op0
)
4083 && !TREE_OVERFLOW_P (op1
))
4084 overflow_warning (location
, result
);
4089 /* Return a tree for the sum or difference (RESULTCODE says which)
4090 of pointer PTROP and integer INTOP. */
4093 cp_pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
4095 tree res_type
= TREE_TYPE (ptrop
);
4097 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
4098 in certain circumstance (when it's valid to do so). So we need
4099 to make sure it's complete. We don't need to check here, if we
4100 can actually complete it at all, as those checks will be done in
4101 pointer_int_sum() anyway. */
4102 complete_type (TREE_TYPE (res_type
));
4104 return pointer_int_sum (input_location
, resultcode
, ptrop
,
4105 fold_if_not_in_template (intop
));
4108 /* Return a tree for the difference of pointers OP0 and OP1.
4109 The resulting tree has type int. */
4112 pointer_diff (tree op0
, tree op1
, tree ptrtype
)
4115 tree restype
= ptrdiff_type_node
;
4116 tree target_type
= TREE_TYPE (ptrtype
);
4118 if (!complete_type_or_else (target_type
, NULL_TREE
))
4119 return error_mark_node
;
4121 if (TREE_CODE (target_type
) == VOID_TYPE
)
4122 permerror (input_location
, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
4123 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
4124 permerror (input_location
, "ISO C++ forbids using pointer to a function in subtraction");
4125 if (TREE_CODE (target_type
) == METHOD_TYPE
)
4126 permerror (input_location
, "ISO C++ forbids using pointer to a method in subtraction");
4128 /* First do the subtraction as integers;
4129 then drop through to build the divide operator. */
4131 op0
= cp_build_binary_op (input_location
,
4133 cp_convert (restype
, op0
),
4134 cp_convert (restype
, op1
),
4135 tf_warning_or_error
);
4137 /* This generates an error if op1 is a pointer to an incomplete type. */
4138 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
4139 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4141 op1
= (TYPE_PTROB_P (ptrtype
)
4142 ? size_in_bytes (target_type
)
4143 : integer_one_node
);
4145 /* Do the division. */
4147 result
= build2 (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
4148 return fold_if_not_in_template (result
);
4151 /* Construct and perhaps optimize a tree representation
4152 for a unary operation. CODE, a tree_code, specifies the operation
4153 and XARG is the operand. */
4156 build_x_unary_op (enum tree_code code
, tree xarg
, tsubst_flags_t complain
)
4158 tree orig_expr
= xarg
;
4162 if (processing_template_decl
)
4164 if (type_dependent_expression_p (xarg
))
4165 return build_min_nt (code
, xarg
, NULL_TREE
);
4167 xarg
= build_non_dependent_expr (xarg
);
4172 /* [expr.unary.op] says:
4174 The address of an object of incomplete type can be taken.
4176 (And is just the ordinary address operator, not an overloaded
4177 "operator &".) However, if the type is a template
4178 specialization, we must complete the type at this point so that
4179 an overloaded "operator &" will be available if required. */
4180 if (code
== ADDR_EXPR
4181 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
4182 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
4183 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
4184 || (TREE_CODE (xarg
) == OFFSET_REF
)))
4185 /* Don't look for a function. */;
4187 exp
= build_new_op (code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
, NULL_TREE
,
4188 /*overloaded_p=*/NULL
, complain
);
4189 if (!exp
&& code
== ADDR_EXPR
)
4191 if (is_overloaded_fn (xarg
))
4193 tree fn
= get_first_fn (xarg
);
4194 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
4197 (DECL_CONSTRUCTOR_P (fn
) ? "constructor" : "destructor");
4198 error ("taking address of %s %qE", type
, xarg
);
4199 return error_mark_node
;
4203 /* A pointer to member-function can be formed only by saying
4205 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
4206 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
4208 if (TREE_CODE (xarg
) != OFFSET_REF
4209 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
4211 error ("invalid use of %qE to form a pointer-to-member-function",
4213 if (TREE_CODE (xarg
) != OFFSET_REF
)
4214 inform (input_location
, " a qualified-id is required");
4215 return error_mark_node
;
4219 error ("parentheses around %qE cannot be used to form a"
4220 " pointer-to-member-function",
4222 PTRMEM_OK_P (xarg
) = 1;
4226 if (TREE_CODE (xarg
) == OFFSET_REF
)
4228 ptrmem
= PTRMEM_OK_P (xarg
);
4230 if (!ptrmem
&& !flag_ms_extensions
4231 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
4233 /* A single non-static member, make sure we don't allow a
4234 pointer-to-member. */
4235 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
4236 TREE_OPERAND (xarg
, 0),
4237 ovl_cons (TREE_OPERAND (xarg
, 1), NULL_TREE
));
4238 PTRMEM_OK_P (xarg
) = ptrmem
;
4241 else if (TREE_CODE (xarg
) == TARGET_EXPR
&& (complain
& tf_warning
))
4242 warning (0, "taking address of temporary");
4243 exp
= cp_build_unary_op (ADDR_EXPR
, xarg
, 0, complain
);
4246 if (processing_template_decl
&& exp
!= error_mark_node
)
4247 exp
= build_min_non_dep (code
, exp
, orig_expr
,
4248 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
4249 if (TREE_CODE (exp
) == ADDR_EXPR
)
4250 PTRMEM_OK_P (exp
) = ptrmem
;
4254 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4255 constants, where a null value is represented by an INTEGER_CST of
4259 cp_truthvalue_conversion (tree expr
)
4261 tree type
= TREE_TYPE (expr
);
4262 if (TYPE_PTRMEM_P (type
))
4263 return build_binary_op (EXPR_LOCATION (expr
),
4264 NE_EXPR
, expr
, integer_zero_node
, 1);
4266 return c_common_truthvalue_conversion (input_location
, expr
);
4269 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4272 condition_conversion (tree expr
)
4275 if (processing_template_decl
)
4277 t
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
4278 tf_warning_or_error
, LOOKUP_NORMAL
);
4279 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
4283 /* Returns the address of T. This function will fold away
4284 ADDR_EXPR of INDIRECT_REF. */
4287 build_address (tree t
)
4289 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
4290 return error_mark_node
;
4291 t
= build_fold_addr_expr (t
);
4292 if (TREE_CODE (t
) != ADDR_EXPR
)
4297 /* Returns the address of T with type TYPE. */
4300 build_typed_address (tree t
, tree type
)
4302 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
4303 return error_mark_node
;
4304 t
= build_fold_addr_expr_with_type (t
, type
);
4305 if (TREE_CODE (t
) != ADDR_EXPR
)
4310 /* Return a NOP_EXPR converting EXPR to TYPE. */
4313 build_nop (tree type
, tree expr
)
4315 if (type
== error_mark_node
|| error_operand_p (expr
))
4317 return build1 (NOP_EXPR
, type
, expr
);
4320 /* C++: Must handle pointers to members.
4322 Perhaps type instantiation should be extended to handle conversion
4323 from aggregates to types we don't yet know we want? (Or are those
4324 cases typically errors which should be reported?)
4326 NOCONVERT nonzero suppresses the default promotions
4327 (such as from short to int). */
4330 cp_build_unary_op (enum tree_code code
, tree xarg
, int noconvert
,
4331 tsubst_flags_t complain
)
4333 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4336 const char *errstring
= NULL
;
4338 const char *invalid_op_diag
;
4340 if (error_operand_p (arg
))
4341 return error_mark_node
;
4343 if ((invalid_op_diag
4344 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
4349 error (invalid_op_diag
);
4350 return error_mark_node
;
4355 case UNARY_PLUS_EXPR
:
4358 int flags
= WANT_ARITH
| WANT_ENUM
;
4359 /* Unary plus (but not unary minus) is allowed on pointers. */
4360 if (code
== UNARY_PLUS_EXPR
)
4361 flags
|= WANT_POINTER
;
4362 arg
= build_expr_type_conversion (flags
, arg
, true);
4364 errstring
= (code
== NEGATE_EXPR
4365 ? "wrong type argument to unary minus"
4366 : "wrong type argument to unary plus");
4369 if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
4370 arg
= perform_integral_promotions (arg
);
4372 /* Make sure the result is not an lvalue: a unary plus or minus
4373 expression is always a rvalue. */
4380 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4384 arg
= default_conversion (arg
);
4386 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
4389 errstring
= "wrong type argument to bit-complement";
4390 else if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
4391 arg
= perform_integral_promotions (arg
);
4395 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
4396 errstring
= "wrong type argument to abs";
4397 else if (!noconvert
)
4398 arg
= default_conversion (arg
);
4402 /* Conjugating a real value is a no-op, but allow it anyway. */
4403 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
4404 errstring
= "wrong type argument to conjugation";
4405 else if (!noconvert
)
4406 arg
= default_conversion (arg
);
4409 case TRUTH_NOT_EXPR
:
4410 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
4412 val
= invert_truthvalue_loc (input_location
, arg
);
4413 if (arg
!= error_mark_node
)
4415 errstring
= "in argument to unary !";
4422 if (TREE_CODE (arg
) == COMPLEX_CST
)
4423 return TREE_REALPART (arg
);
4424 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4426 arg
= build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
4427 return fold_if_not_in_template (arg
);
4433 if (TREE_CODE (arg
) == COMPLEX_CST
)
4434 return TREE_IMAGPART (arg
);
4435 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4437 arg
= build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
4438 return fold_if_not_in_template (arg
);
4441 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4443 case PREINCREMENT_EXPR
:
4444 case POSTINCREMENT_EXPR
:
4445 case PREDECREMENT_EXPR
:
4446 case POSTDECREMENT_EXPR
:
4447 /* Handle complex lvalues (when permitted)
4448 by reduction to simpler cases. */
4450 val
= unary_complex_lvalue (code
, arg
);
4454 /* Increment or decrement the real part of the value,
4455 and don't change the imaginary part. */
4456 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4460 arg
= stabilize_reference (arg
);
4461 real
= cp_build_unary_op (REALPART_EXPR
, arg
, 1, complain
);
4462 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, 1, complain
);
4463 real
= cp_build_unary_op (code
, real
, 1, complain
);
4464 if (real
== error_mark_node
|| imag
== error_mark_node
)
4465 return error_mark_node
;
4466 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
4470 /* Report invalid types. */
4472 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4475 if (code
== PREINCREMENT_EXPR
)
4476 errstring
="no pre-increment operator for type";
4477 else if (code
== POSTINCREMENT_EXPR
)
4478 errstring
="no post-increment operator for type";
4479 else if (code
== PREDECREMENT_EXPR
)
4480 errstring
="no pre-decrement operator for type";
4482 errstring
="no post-decrement operator for type";
4485 else if (arg
== error_mark_node
)
4486 return error_mark_node
;
4488 /* Report something read-only. */
4490 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
4491 || TREE_READONLY (arg
))
4493 if (complain
& tf_error
)
4494 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4495 || code
== POSTINCREMENT_EXPR
)
4496 ? "increment" : "decrement"));
4498 return error_mark_node
;
4503 tree declared_type
= unlowered_expr_type (arg
);
4505 argtype
= TREE_TYPE (arg
);
4507 /* ARM $5.2.5 last annotation says this should be forbidden. */
4508 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4510 if (complain
& tf_error
)
4511 permerror (input_location
, (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4512 ? G_("ISO C++ forbids incrementing an enum")
4513 : G_("ISO C++ forbids decrementing an enum"));
4515 return error_mark_node
;
4518 /* Compute the increment. */
4520 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4522 tree type
= complete_type (TREE_TYPE (argtype
));
4524 if (!COMPLETE_OR_VOID_TYPE_P (type
))
4526 if (complain
& tf_error
)
4527 error (((code
== PREINCREMENT_EXPR
4528 || code
== POSTINCREMENT_EXPR
))
4529 ? G_("cannot increment a pointer to incomplete type %qT")
4530 : G_("cannot decrement a pointer to incomplete type %qT"),
4531 TREE_TYPE (argtype
));
4533 return error_mark_node
;
4535 else if ((pedantic
|| warn_pointer_arith
)
4536 && !TYPE_PTROB_P (argtype
))
4538 if (complain
& tf_error
)
4539 permerror (input_location
, (code
== PREINCREMENT_EXPR
4540 || code
== POSTINCREMENT_EXPR
)
4541 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4542 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4545 return error_mark_node
;
4548 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
4551 inc
= integer_one_node
;
4553 inc
= cp_convert (argtype
, inc
);
4555 /* Complain about anything else that is not a true lvalue. */
4556 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4557 || code
== POSTINCREMENT_EXPR
)
4558 ? lv_increment
: lv_decrement
),
4560 return error_mark_node
;
4562 /* Forbid using -- on `bool'. */
4563 if (TREE_CODE (declared_type
) == BOOLEAN_TYPE
)
4565 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4567 if (complain
& tf_error
)
4568 error ("invalid use of Boolean expression as operand "
4569 "to %<operator--%>");
4570 return error_mark_node
;
4572 val
= boolean_increment (code
, arg
);
4575 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
4577 TREE_SIDE_EFFECTS (val
) = 1;
4582 /* Note that this operation never does default_conversion
4583 regardless of NOCONVERT. */
4585 argtype
= lvalue_type (arg
);
4587 if (TREE_CODE (arg
) == OFFSET_REF
)
4590 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4592 tree type
= build_pointer_type (TREE_TYPE (argtype
));
4593 arg
= build1 (CONVERT_EXPR
, type
, arg
);
4596 else if (pedantic
&& DECL_MAIN_P (arg
))
4599 /* Apparently a lot of autoconf scripts for C++ packages do this,
4600 so only complain if -pedantic. */
4601 if (complain
& (flag_pedantic_errors
? tf_error
: tf_warning
))
4602 pedwarn (input_location
, OPT_pedantic
,
4603 "ISO C++ forbids taking address of function %<::main%>");
4604 else if (flag_pedantic_errors
)
4605 return error_mark_node
;
4608 /* Let &* cancel out to simplify resulting code. */
4609 if (TREE_CODE (arg
) == INDIRECT_REF
)
4611 /* We don't need to have `current_class_ptr' wrapped in a
4612 NON_LVALUE_EXPR node. */
4613 if (arg
== current_class_ref
)
4614 return current_class_ptr
;
4616 arg
= TREE_OPERAND (arg
, 0);
4617 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4619 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
4620 arg
= build1 (CONVERT_EXPR
, type
, arg
);
4623 /* Don't let this be an lvalue. */
4628 /* Uninstantiated types are all functions. Taking the
4629 address of a function is a no-op, so just return the
4632 gcc_assert (TREE_CODE (arg
) != IDENTIFIER_NODE
4633 || !IDENTIFIER_OPNAME_P (arg
));
4635 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
4636 && !really_overloaded_fn (TREE_OPERAND (arg
, 1)))
4638 /* They're trying to take the address of a unique non-static
4639 member function. This is ill-formed (except in MS-land),
4640 but let's try to DTRT.
4641 Note: We only handle unique functions here because we don't
4642 want to complain if there's a static overload; non-unique
4643 cases will be handled by instantiate_type. But we need to
4644 handle this case here to allow casts on the resulting PMF.
4645 We could defer this in non-MS mode, but it's easier to give
4646 a useful error here. */
4648 /* Inside constant member functions, the `this' pointer
4649 contains an extra const qualifier. TYPE_MAIN_VARIANT
4650 is used here to remove this const from the diagnostics
4651 and the created OFFSET_REF. */
4652 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
4653 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
4656 if (! flag_ms_extensions
)
4658 tree name
= DECL_NAME (fn
);
4659 if (!(complain
& tf_error
))
4660 return error_mark_node
;
4661 else if (current_class_type
4662 && TREE_OPERAND (arg
, 0) == current_class_ref
)
4663 /* An expression like &memfn. */
4664 permerror (input_location
, "ISO C++ forbids taking the address of an unqualified"
4665 " or parenthesized non-static member function to form"
4666 " a pointer to member function. Say %<&%T::%D%>",
4669 permerror (input_location
, "ISO C++ forbids taking the address of a bound member"
4670 " function to form a pointer to member function."
4674 arg
= build_offset_ref (base
, fn
, /*address_p=*/true);
4678 if (type_unknown_p (arg
))
4679 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4681 /* Handle complex lvalues (when permitted)
4682 by reduction to simpler cases. */
4683 val
= unary_complex_lvalue (code
, arg
);
4687 switch (TREE_CODE (arg
))
4691 case FIX_TRUNC_EXPR
:
4692 /* Even if we're not being pedantic, we cannot allow this
4693 extension when we're instantiating in a SFINAE
4695 if (! lvalue_p (arg
) && complain
== tf_none
)
4697 if (complain
& tf_error
)
4698 permerror (input_location
, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4700 return error_mark_node
;
4705 arg
= BASELINK_FUNCTIONS (arg
);
4709 arg
= OVL_CURRENT (arg
);
4713 /* Turn a reference to a non-static data member into a
4714 pointer-to-member. */
4719 if (!PTRMEM_OK_P (arg
))
4720 return cp_build_unary_op (code
, arg
, 0, complain
);
4722 t
= TREE_OPERAND (arg
, 1);
4723 if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
4725 if (complain
& tf_error
)
4726 error ("cannot create pointer to reference member %qD", t
);
4727 return error_mark_node
;
4730 type
= build_ptrmem_type (context_for_name_lookup (t
),
4732 t
= make_ptrmem_cst (type
, TREE_OPERAND (arg
, 1));
4740 /* Anything not already handled and not a true memory reference
4742 if (TREE_CODE (argtype
) != FUNCTION_TYPE
4743 && TREE_CODE (argtype
) != METHOD_TYPE
4744 && TREE_CODE (arg
) != OFFSET_REF
4745 && !lvalue_or_else (arg
, lv_addressof
, complain
))
4746 return error_mark_node
;
4748 if (argtype
!= error_mark_node
)
4749 argtype
= build_pointer_type (argtype
);
4751 /* In a template, we are processing a non-dependent expression
4752 so we can just form an ADDR_EXPR with the correct type. */
4753 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
4755 val
= build_address (arg
);
4756 if (TREE_CODE (arg
) == OFFSET_REF
)
4757 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
4759 else if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BASELINK
)
4761 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
4763 /* We can only get here with a single static member
4765 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
4766 && DECL_STATIC_FUNCTION_P (fn
));
4768 val
= build_address (fn
);
4769 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
4770 /* Do not lose object's side effects. */
4771 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
4772 TREE_OPERAND (arg
, 0), val
);
4774 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)))
4776 if (complain
& tf_error
)
4777 error ("attempt to take address of bit-field structure member %qD",
4778 TREE_OPERAND (arg
, 1));
4779 return error_mark_node
;
4783 tree object
= TREE_OPERAND (arg
, 0);
4784 tree field
= TREE_OPERAND (arg
, 1);
4785 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4786 (TREE_TYPE (object
), decl_type_context (field
)));
4787 val
= build_address (arg
);
4790 if (TREE_CODE (argtype
) == POINTER_TYPE
4791 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4793 build_ptrmemfunc_type (argtype
);
4794 val
= build_ptrmemfunc (argtype
, val
, 0,
4795 /*c_cast_p=*/false);
4807 argtype
= TREE_TYPE (arg
);
4808 return fold_if_not_in_template (build1 (code
, argtype
, arg
));
4811 if (complain
& tf_error
)
4812 error ("%s", errstring
);
4813 return error_mark_node
;
4816 /* Hook for the c-common bits that build a unary op. */
4818 build_unary_op (location_t location ATTRIBUTE_UNUSED
,
4819 enum tree_code code
, tree xarg
, int noconvert
)
4821 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
4824 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4825 for certain kinds of expressions which are not really lvalues
4826 but which we can accept as lvalues.
4828 If ARG is not a kind of expression we can handle, return
4832 unary_complex_lvalue (enum tree_code code
, tree arg
)
4834 /* Inside a template, making these kinds of adjustments is
4835 pointless; we are only concerned with the type of the
4837 if (processing_template_decl
)
4840 /* Handle (a, b) used as an "lvalue". */
4841 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4843 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), 0,
4844 tf_warning_or_error
);
4845 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4846 TREE_OPERAND (arg
, 0), real_result
);
4849 /* Handle (a ? b : c) used as an "lvalue". */
4850 if (TREE_CODE (arg
) == COND_EXPR
4851 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4852 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
4854 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4855 if (TREE_CODE (arg
) == MODIFY_EXPR
4856 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4857 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4859 tree lvalue
= TREE_OPERAND (arg
, 0);
4860 if (TREE_SIDE_EFFECTS (lvalue
))
4862 lvalue
= stabilize_reference (lvalue
);
4863 arg
= build2 (TREE_CODE (arg
), TREE_TYPE (arg
),
4864 lvalue
, TREE_OPERAND (arg
, 1));
4866 return unary_complex_lvalue
4867 (code
, build2 (COMPOUND_EXPR
, TREE_TYPE (lvalue
), arg
, lvalue
));
4870 if (code
!= ADDR_EXPR
)
4873 /* Handle (a = b) used as an "lvalue" for `&'. */
4874 if (TREE_CODE (arg
) == MODIFY_EXPR
4875 || TREE_CODE (arg
) == INIT_EXPR
)
4877 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), 0,
4878 tf_warning_or_error
);
4879 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4881 TREE_NO_WARNING (arg
) = 1;
4885 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4886 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4887 || TREE_CODE (arg
) == OFFSET_REF
)
4890 /* We permit compiler to make function calls returning
4891 objects of aggregate type look like lvalues. */
4895 if (TREE_CODE (targ
) == SAVE_EXPR
)
4896 targ
= TREE_OPERAND (targ
, 0);
4898 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
4900 if (TREE_CODE (arg
) == SAVE_EXPR
)
4903 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4904 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4907 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4908 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4909 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4912 /* Don't let anything else be handled specially. */
4916 /* Mark EXP saying that we need to be able to take the
4917 address of it; it should not be allocated in a register.
4918 Value is true if successful.
4920 C++: we do not allow `current_class_ptr' to be addressable. */
4923 cxx_mark_addressable (tree exp
)
4928 switch (TREE_CODE (x
))
4935 x
= TREE_OPERAND (x
, 0);
4939 if (x
== current_class_ptr
)
4941 error ("cannot take the address of %<this%>, which is an rvalue expression");
4942 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
4948 /* Caller should not be trying to mark initialized
4949 constant fields addressable. */
4950 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
4951 || DECL_IN_AGGR_P (x
) == 0
4953 || DECL_EXTERNAL (x
));
4958 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4959 && !DECL_ARTIFICIAL (x
))
4961 if (TREE_CODE (x
) == VAR_DECL
&& DECL_HARD_REGISTER (x
))
4964 ("address of explicit register variable %qD requested", x
);
4967 else if (extra_warnings
)
4969 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
4971 TREE_ADDRESSABLE (x
) = 1;
4975 TREE_ADDRESSABLE (x
) = 1;
4979 TREE_ADDRESSABLE (x
) = 1;
4983 TREE_ADDRESSABLE (x
) = 1;
4984 cxx_mark_addressable (TREE_OPERAND (x
, 0));
4992 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4995 build_x_conditional_expr (tree ifexp
, tree op1
, tree op2
,
4996 tsubst_flags_t complain
)
4998 tree orig_ifexp
= ifexp
;
4999 tree orig_op1
= op1
;
5000 tree orig_op2
= op2
;
5003 if (processing_template_decl
)
5005 /* The standard says that the expression is type-dependent if
5006 IFEXP is type-dependent, even though the eventual type of the
5007 expression doesn't dependent on IFEXP. */
5008 if (type_dependent_expression_p (ifexp
)
5009 /* As a GNU extension, the middle operand may be omitted. */
5010 || (op1
&& type_dependent_expression_p (op1
))
5011 || type_dependent_expression_p (op2
))
5012 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
5013 ifexp
= build_non_dependent_expr (ifexp
);
5015 op1
= build_non_dependent_expr (op1
);
5016 op2
= build_non_dependent_expr (op2
);
5019 expr
= build_conditional_expr (ifexp
, op1
, op2
, complain
);
5020 if (processing_template_decl
&& expr
!= error_mark_node
)
5021 return build_min_non_dep (COND_EXPR
, expr
,
5022 orig_ifexp
, orig_op1
, orig_op2
);
5026 /* Given a list of expressions, return a compound expression
5027 that performs them all and returns the value of the last of them. */
5029 tree
build_x_compound_expr_from_list (tree list
, const char *msg
)
5031 tree expr
= TREE_VALUE (list
);
5033 if (TREE_CHAIN (list
))
5036 permerror (input_location
, "%s expression list treated as compound expression", msg
);
5038 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
5039 expr
= build_x_compound_expr (expr
, TREE_VALUE (list
),
5040 tf_warning_or_error
);
5046 /* Like build_x_compound_expr_from_list, but using a VEC. */
5049 build_x_compound_expr_from_vec (VEC(tree
,gc
) *vec
, const char *msg
)
5051 if (VEC_empty (tree
, vec
))
5053 else if (VEC_length (tree
, vec
) == 1)
5054 return VEC_index (tree
, vec
, 0);
5062 permerror (input_location
,
5063 "%s expression list treated as compound expression",
5066 expr
= VEC_index (tree
, vec
, 0);
5067 for (ix
= 1; VEC_iterate (tree
, vec
, ix
, t
); ++ix
)
5068 expr
= build_x_compound_expr (expr
, t
, tf_warning_or_error
);
5074 /* Handle overloading of the ',' operator when needed. */
5077 build_x_compound_expr (tree op1
, tree op2
, tsubst_flags_t complain
)
5080 tree orig_op1
= op1
;
5081 tree orig_op2
= op2
;
5083 if (processing_template_decl
)
5085 if (type_dependent_expression_p (op1
)
5086 || type_dependent_expression_p (op2
))
5087 return build_min_nt (COMPOUND_EXPR
, op1
, op2
);
5088 op1
= build_non_dependent_expr (op1
);
5089 op2
= build_non_dependent_expr (op2
);
5092 result
= build_new_op (COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
, NULL_TREE
,
5093 /*overloaded_p=*/NULL
, complain
);
5095 result
= cp_build_compound_expr (op1
, op2
, complain
);
5097 if (processing_template_decl
&& result
!= error_mark_node
)
5098 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
5103 /* Like cp_build_compound_expr, but for the c-common bits. */
5106 build_compound_expr (location_t loc ATTRIBUTE_UNUSED
, tree lhs
, tree rhs
)
5108 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
5111 /* Build a compound expression. */
5114 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
5116 lhs
= convert_to_void (lhs
, "left-hand operand of comma", complain
);
5118 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
5119 return error_mark_node
;
5121 if (TREE_CODE (rhs
) == TARGET_EXPR
)
5123 /* If the rhs is a TARGET_EXPR, then build the compound
5124 expression inside the target_expr's initializer. This
5125 helps the compiler to eliminate unnecessary temporaries. */
5126 tree init
= TREE_OPERAND (rhs
, 1);
5128 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
5129 TREE_OPERAND (rhs
, 1) = init
;
5134 if (type_unknown_p (rhs
))
5136 error ("no context to resolve type of %qE", rhs
);
5137 return error_mark_node
;
5140 return build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
5143 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
5144 casts away constness. CAST gives the type of cast.
5146 ??? This function warns for casting away any qualifier not just
5147 const. We would like to specify exactly what qualifiers are casted
5152 check_for_casting_away_constness (tree src_type
, tree dest_type
,
5153 enum tree_code cast
)
5155 /* C-style casts are allowed to cast away constness. With
5156 WARN_CAST_QUAL, we still want to issue a warning. */
5157 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
5160 if (!casts_away_constness (src_type
, dest_type
))
5166 warning (OPT_Wcast_qual
,
5167 "cast from type %qT to type %qT casts away qualifiers",
5168 src_type
, dest_type
);
5171 case STATIC_CAST_EXPR
:
5172 error ("static_cast from type %qT to type %qT casts away qualifiers",
5173 src_type
, dest_type
);
5176 case REINTERPRET_CAST_EXPR
:
5177 error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
5178 src_type
, dest_type
);
5185 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
5186 (another pointer-to-member type in the same hierarchy) and return
5187 the converted expression. If ALLOW_INVERSE_P is permitted, a
5188 pointer-to-derived may be converted to pointer-to-base; otherwise,
5189 only the other direction is permitted. If C_CAST_P is true, this
5190 conversion is taking place as part of a C-style cast. */
5193 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
5196 if (TYPE_PTRMEM_P (type
))
5200 if (TREE_CODE (expr
) == PTRMEM_CST
)
5201 expr
= cplus_expand_constant (expr
);
5202 delta
= get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
)),
5203 TYPE_PTRMEM_CLASS_TYPE (type
),
5206 if (!integer_zerop (delta
))
5208 tree cond
, op1
, op2
;
5210 cond
= cp_build_binary_op (input_location
,
5213 build_int_cst (TREE_TYPE (expr
), -1),
5214 tf_warning_or_error
);
5215 op1
= build_nop (ptrdiff_type_node
, expr
);
5216 op2
= cp_build_binary_op (input_location
,
5217 PLUS_EXPR
, op1
, delta
,
5218 tf_warning_or_error
);
5220 expr
= fold_build3_loc (input_location
,
5221 COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
5225 return build_nop (type
, expr
);
5228 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
5229 allow_inverse_p
, c_cast_p
);
5232 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5233 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5234 Otherwise, return EXPR unchanged. */
5237 ignore_overflows (tree expr
, tree orig
)
5239 if (TREE_CODE (expr
) == INTEGER_CST
5240 && CONSTANT_CLASS_P (orig
)
5241 && TREE_CODE (orig
) != STRING_CST
5242 && TREE_OVERFLOW (expr
) != TREE_OVERFLOW (orig
))
5244 if (!TREE_OVERFLOW (orig
))
5245 /* Ensure constant sharing. */
5246 expr
= build_int_cst_wide (TREE_TYPE (expr
),
5247 TREE_INT_CST_LOW (expr
),
5248 TREE_INT_CST_HIGH (expr
));
5251 /* Avoid clobbering a shared constant. */
5252 expr
= copy_node (expr
);
5253 TREE_OVERFLOW (expr
) = TREE_OVERFLOW (orig
);
5259 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
5260 this static_cast is being attempted as one of the possible casts
5261 allowed by a C-style cast. (In that case, accessibility of base
5262 classes is not considered, and it is OK to cast away
5263 constness.) Return the result of the cast. *VALID_P is set to
5264 indicate whether or not the cast was valid. */
5267 build_static_cast_1 (tree type
, tree expr
, bool c_cast_p
,
5268 bool *valid_p
, tsubst_flags_t complain
)
5274 /* Assume the cast is valid. */
5277 intype
= TREE_TYPE (expr
);
5279 /* Save casted types in the function's used types hash table. */
5280 used_types_insert (type
);
5282 /* [expr.static.cast]
5284 An lvalue of type "cv1 B", where B is a class type, can be cast
5285 to type "reference to cv2 D", where D is a class derived (clause
5286 _class.derived_) from B, if a valid standard conversion from
5287 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5288 same cv-qualification as, or greater cv-qualification than, cv1,
5289 and B is not a virtual base class of D. */
5290 /* We check this case before checking the validity of "TYPE t =
5291 EXPR;" below because for this case:
5294 struct D : public B { D(const B&); };
5296 void f() { static_cast<const D&>(b); }
5298 we want to avoid constructing a new D. The standard is not
5299 completely clear about this issue, but our interpretation is
5300 consistent with other compilers. */
5301 if (TREE_CODE (type
) == REFERENCE_TYPE
5302 && CLASS_TYPE_P (TREE_TYPE (type
))
5303 && CLASS_TYPE_P (intype
)
5304 && (TYPE_REF_IS_RVALUE (type
) || real_lvalue_p (expr
))
5305 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
5306 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
5307 build_pointer_type (TYPE_MAIN_VARIANT
5308 (TREE_TYPE (type
))))
5310 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
5314 /* There is a standard conversion from "D*" to "B*" even if "B"
5315 is ambiguous or inaccessible. If this is really a
5316 static_cast, then we check both for inaccessibility and
5317 ambiguity. However, if this is a static_cast being performed
5318 because the user wrote a C-style cast, then accessibility is
5320 base
= lookup_base (TREE_TYPE (type
), intype
,
5321 c_cast_p
? ba_unique
: ba_check
,
5324 /* Convert from "B*" to "D*". This function will check that "B"
5325 is not a virtual base of "D". */
5326 expr
= build_base_path (MINUS_EXPR
, build_address (expr
),
5327 base
, /*nonnull=*/false);
5328 /* Convert the pointer to a reference -- but then remember that
5329 there are no expressions with reference type in C++. */
5330 return convert_from_reference (cp_fold_convert (type
, expr
));
5333 /* "An lvalue of type cv1 T1 can be cast to type rvalue reference to
5334 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
5335 if (TREE_CODE (type
) == REFERENCE_TYPE
5336 && TYPE_REF_IS_RVALUE (type
)
5337 && real_lvalue_p (expr
)
5338 && reference_related_p (TREE_TYPE (type
), intype
)
5339 && (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
5341 expr
= build_typed_address (expr
, type
);
5342 return convert_from_reference (expr
);
5347 /* [expr.static.cast]
5349 An expression e can be explicitly converted to a type T using a
5350 static_cast of the form static_cast<T>(e) if the declaration T
5351 t(e);" is well-formed, for some invented temporary variable
5353 result
= perform_direct_initialization_if_possible (type
, expr
,
5354 c_cast_p
, complain
);
5357 result
= convert_from_reference (result
);
5359 /* Ignore any integer overflow caused by the cast. */
5360 result
= ignore_overflows (result
, orig
);
5362 /* [expr.static.cast]
5364 If T is a reference type, the result is an lvalue; otherwise,
5365 the result is an rvalue. */
5366 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5367 result
= rvalue (result
);
5371 /* [expr.static.cast]
5373 Any expression can be explicitly converted to type cv void. */
5374 if (TREE_CODE (type
) == VOID_TYPE
)
5375 return convert_to_void (expr
, /*implicit=*/NULL
, complain
);
5377 /* [expr.static.cast]
5379 The inverse of any standard conversion sequence (clause _conv_),
5380 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5381 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5382 (_conv.bool_) conversions, can be performed explicitly using
5383 static_cast subject to the restriction that the explicit
5384 conversion does not cast away constness (_expr.const.cast_), and
5385 the following additional rules for specific cases: */
5386 /* For reference, the conversions not excluded are: integral
5387 promotions, floating point promotion, integral conversions,
5388 floating point conversions, floating-integral conversions,
5389 pointer conversions, and pointer to member conversions. */
5392 A value of integral _or enumeration_ type can be explicitly
5393 converted to an enumeration type. */
5394 /* The effect of all that is that any conversion between any two
5395 types which are integral, floating, or enumeration types can be
5397 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5398 || SCALAR_FLOAT_TYPE_P (type
))
5399 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
5400 || SCALAR_FLOAT_TYPE_P (intype
)))
5402 expr
= ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
);
5404 /* Ignore any integer overflow caused by the cast. */
5405 expr
= ignore_overflows (expr
, orig
);
5409 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
5410 && CLASS_TYPE_P (TREE_TYPE (type
))
5411 && CLASS_TYPE_P (TREE_TYPE (intype
))
5412 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5413 (TREE_TYPE (intype
))),
5414 build_pointer_type (TYPE_MAIN_VARIANT
5415 (TREE_TYPE (type
)))))
5420 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5421 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
5422 c_cast_p
? ba_unique
: ba_check
,
5424 return build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false);
5427 if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5428 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5435 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
5436 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
5438 if (TYPE_PTRMEM_P (type
))
5440 t1
= (build_ptrmem_type
5442 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
5443 t2
= (build_ptrmem_type
5445 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
5452 if (can_convert (t1
, t2
) || can_convert (t2
, t1
))
5455 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5456 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
5461 /* [expr.static.cast]
5463 An rvalue of type "pointer to cv void" can be explicitly
5464 converted to a pointer to object type. A value of type pointer
5465 to object converted to "pointer to cv void" and back to the
5466 original pointer type will have its original value. */
5467 if (TREE_CODE (intype
) == POINTER_TYPE
5468 && VOID_TYPE_P (TREE_TYPE (intype
))
5469 && TYPE_PTROB_P (type
))
5472 check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
);
5473 return build_nop (type
, expr
);
5477 return error_mark_node
;
5480 /* Return an expression representing static_cast<TYPE>(EXPR). */
5483 build_static_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5488 if (type
== error_mark_node
|| expr
== error_mark_node
)
5489 return error_mark_node
;
5491 if (processing_template_decl
)
5493 expr
= build_min (STATIC_CAST_EXPR
, type
, expr
);
5494 /* We don't know if it will or will not have side effects. */
5495 TREE_SIDE_EFFECTS (expr
) = 1;
5496 return convert_from_reference (expr
);
5499 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5500 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5501 if (TREE_CODE (type
) != REFERENCE_TYPE
5502 && TREE_CODE (expr
) == NOP_EXPR
5503 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5504 expr
= TREE_OPERAND (expr
, 0);
5506 result
= build_static_cast_1 (type
, expr
, /*c_cast_p=*/false, &valid_p
,
5511 if (complain
& tf_error
)
5512 error ("invalid static_cast from type %qT to type %qT",
5513 TREE_TYPE (expr
), type
);
5514 return error_mark_node
;
5517 /* EXPR is an expression with member function or pointer-to-member
5518 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5519 not permitted by ISO C++, but we accept it in some modes. If we
5520 are not in one of those modes, issue a diagnostic. Return the
5521 converted expression. */
5524 convert_member_func_to_ptr (tree type
, tree expr
)
5529 intype
= TREE_TYPE (expr
);
5530 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
5531 || TREE_CODE (intype
) == METHOD_TYPE
);
5533 if (pedantic
|| warn_pmf2ptr
)
5534 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpmf_conversions
,
5535 "converting from %qT to %qT", intype
, type
);
5537 if (TREE_CODE (intype
) == METHOD_TYPE
)
5538 expr
= build_addr_func (expr
);
5539 else if (TREE_CODE (expr
) == PTRMEM_CST
)
5540 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
5543 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
5544 decl
= build_address (decl
);
5545 expr
= get_member_function_from_ptrfunc (&decl
, expr
);
5548 return build_nop (type
, expr
);
5551 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5552 If C_CAST_P is true, this reinterpret cast is being done as part of
5553 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5554 indicate whether or not reinterpret_cast was valid. */
5557 build_reinterpret_cast_1 (tree type
, tree expr
, bool c_cast_p
,
5558 bool *valid_p
, tsubst_flags_t complain
)
5562 /* Assume the cast is invalid. */
5566 if (type
== error_mark_node
|| error_operand_p (expr
))
5567 return error_mark_node
;
5569 intype
= TREE_TYPE (expr
);
5571 /* Save casted types in the function's used types hash table. */
5572 used_types_insert (type
);
5574 /* [expr.reinterpret.cast]
5575 An lvalue expression of type T1 can be cast to the type
5576 "reference to T2" if an expression of type "pointer to T1" can be
5577 explicitly converted to the type "pointer to T2" using a
5578 reinterpret_cast. */
5579 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5581 if (! real_lvalue_p (expr
))
5583 if (complain
& tf_error
)
5584 error ("invalid cast of an rvalue expression of type "
5587 return error_mark_node
;
5590 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5591 "B" are related class types; the reinterpret_cast does not
5592 adjust the pointer. */
5593 if (TYPE_PTR_P (intype
)
5594 && (complain
& tf_warning
)
5595 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
5596 COMPARE_BASE
| COMPARE_DERIVED
)))
5597 warning (0, "casting %qT to %qT does not dereference pointer",
5600 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, 0, complain
);
5601 if (expr
!= error_mark_node
)
5602 expr
= build_reinterpret_cast_1
5603 (build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
5605 if (expr
!= error_mark_node
)
5606 expr
= cp_build_indirect_ref (expr
, 0, complain
);
5610 /* As a G++ extension, we consider conversions from member
5611 functions, and pointers to member functions to
5612 pointer-to-function and pointer-to-void types. If
5613 -Wno-pmf-conversions has not been specified,
5614 convert_member_func_to_ptr will issue an error message. */
5615 if ((TYPE_PTRMEMFUNC_P (intype
)
5616 || TREE_CODE (intype
) == METHOD_TYPE
)
5617 && TYPE_PTR_P (type
)
5618 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
5619 || VOID_TYPE_P (TREE_TYPE (type
))))
5620 return convert_member_func_to_ptr (type
, expr
);
5622 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5623 array-to-pointer, and function-to-pointer conversions are
5625 expr
= decay_conversion (expr
);
5627 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5628 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5629 if (TREE_CODE (expr
) == NOP_EXPR
5630 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5631 expr
= TREE_OPERAND (expr
, 0);
5633 if (error_operand_p (expr
))
5634 return error_mark_node
;
5636 intype
= TREE_TYPE (expr
);
5638 /* [expr.reinterpret.cast]
5639 A pointer can be converted to any integral type large enough to
5641 if (CP_INTEGRAL_TYPE_P (type
) && TYPE_PTR_P (intype
))
5643 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5645 if (complain
& tf_error
)
5646 permerror (input_location
, "cast from %qT to %qT loses precision",
5649 return error_mark_node
;
5652 /* [expr.reinterpret.cast]
5653 A value of integral or enumeration type can be explicitly
5654 converted to a pointer. */
5655 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
5658 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5659 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5660 return fold_if_not_in_template (build_nop (type
, expr
));
5661 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5662 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5667 check_for_casting_away_constness (intype
, type
, REINTERPRET_CAST_EXPR
);
5668 /* Warn about possible alignment problems. */
5669 if (STRICT_ALIGNMENT
&& warn_cast_align
5670 && (complain
& tf_warning
)
5671 && !VOID_TYPE_P (type
)
5672 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
5673 && COMPLETE_TYPE_P (TREE_TYPE (type
))
5674 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
5675 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (intype
)))
5676 warning (OPT_Wcast_align
, "cast from %qT to %qT "
5677 "increases required alignment of target type", intype
, type
);
5679 /* We need to strip nops here, because the front end likes to
5680 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5682 if (warn_strict_aliasing
<= 2)
5683 strict_aliasing_warning (intype
, type
, sexpr
);
5685 return fold_if_not_in_template (build_nop (type
, expr
));
5687 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5688 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
5690 if (pedantic
&& (complain
& tf_warning
))
5691 /* Only issue a warning, as we have always supported this
5692 where possible, and it is necessary in some cases. DR 195
5693 addresses this issue, but as of 2004/10/26 is still in
5695 warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5696 return fold_if_not_in_template (build_nop (type
, expr
));
5698 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5699 return fold_if_not_in_template (convert_to_vector (type
, expr
));
5700 else if (TREE_CODE (intype
) == VECTOR_TYPE
5701 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5702 return fold_if_not_in_template (convert_to_integer (type
, expr
));
5707 if (complain
& tf_error
)
5708 error ("invalid cast from type %qT to type %qT", intype
, type
);
5709 return error_mark_node
;
5712 return cp_convert (type
, expr
);
5716 build_reinterpret_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5718 if (type
== error_mark_node
|| expr
== error_mark_node
)
5719 return error_mark_node
;
5721 if (processing_template_decl
)
5723 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
5725 if (!TREE_SIDE_EFFECTS (t
)
5726 && type_dependent_expression_p (expr
))
5727 /* There might turn out to be side effects inside expr. */
5728 TREE_SIDE_EFFECTS (t
) = 1;
5729 return convert_from_reference (t
);
5732 return build_reinterpret_cast_1 (type
, expr
, /*c_cast_p=*/false,
5733 /*valid_p=*/NULL
, complain
);
5736 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5737 return an appropriate expression. Otherwise, return
5738 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5739 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5740 performing a C-style cast, its value upon return will indicate
5741 whether or not the conversion succeeded. */
5744 build_const_cast_1 (tree dst_type
, tree expr
, bool complain
,
5748 tree reference_type
;
5750 /* Callers are responsible for handling error_mark_node as a
5751 destination type. */
5752 gcc_assert (dst_type
!= error_mark_node
);
5753 /* In a template, callers should be building syntactic
5754 representations of casts, not using this machinery. */
5755 gcc_assert (!processing_template_decl
);
5757 /* Assume the conversion is invalid. */
5761 if (!POINTER_TYPE_P (dst_type
) && !TYPE_PTRMEM_P (dst_type
))
5764 error ("invalid use of const_cast with type %qT, "
5765 "which is not a pointer, "
5766 "reference, nor a pointer-to-data-member type", dst_type
);
5767 return error_mark_node
;
5770 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
5773 error ("invalid use of const_cast with type %qT, which is a pointer "
5774 "or reference to a function type", dst_type
);
5775 return error_mark_node
;
5778 /* Save casted types in the function's used types hash table. */
5779 used_types_insert (dst_type
);
5781 src_type
= TREE_TYPE (expr
);
5782 /* Expressions do not really have reference types. */
5783 if (TREE_CODE (src_type
) == REFERENCE_TYPE
)
5784 src_type
= TREE_TYPE (src_type
);
5786 /* [expr.const.cast]
5788 An lvalue of type T1 can be explicitly converted to an lvalue of
5789 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5790 types) if a pointer to T1 can be explicitly converted to the type
5791 pointer to T2 using a const_cast. */
5792 if (TREE_CODE (dst_type
) == REFERENCE_TYPE
)
5794 reference_type
= dst_type
;
5795 if (! real_lvalue_p (expr
))
5798 error ("invalid const_cast of an rvalue of type %qT to type %qT",
5799 src_type
, dst_type
);
5800 return error_mark_node
;
5802 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
5803 src_type
= build_pointer_type (src_type
);
5807 reference_type
= NULL_TREE
;
5808 /* If the destination type is not a reference type, the
5809 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5810 conversions are performed. */
5811 src_type
= type_decays_to (src_type
);
5812 if (src_type
== error_mark_node
)
5813 return error_mark_node
;
5816 if ((TYPE_PTR_P (src_type
) || TYPE_PTRMEM_P (src_type
))
5817 && comp_ptr_ttypes_const (dst_type
, src_type
))
5822 /* This cast is actually a C-style cast. Issue a warning if
5823 the user is making a potentially unsafe cast. */
5824 check_for_casting_away_constness (src_type
, dst_type
, CAST_EXPR
);
5828 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, 0,
5829 complain
? tf_warning_or_error
: tf_none
);
5830 expr
= build_nop (reference_type
, expr
);
5831 return convert_from_reference (expr
);
5835 expr
= decay_conversion (expr
);
5836 /* build_c_cast puts on a NOP_EXPR to make the result not an
5837 lvalue. Strip such NOP_EXPRs if VALUE is being used in
5838 non-lvalue context. */
5839 if (TREE_CODE (expr
) == NOP_EXPR
5840 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5841 expr
= TREE_OPERAND (expr
, 0);
5842 return build_nop (dst_type
, expr
);
5847 error ("invalid const_cast from type %qT to type %qT",
5848 src_type
, dst_type
);
5849 return error_mark_node
;
5853 build_const_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5855 if (type
== error_mark_node
|| error_operand_p (expr
))
5856 return error_mark_node
;
5858 if (processing_template_decl
)
5860 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
5862 if (!TREE_SIDE_EFFECTS (t
)
5863 && type_dependent_expression_p (expr
))
5864 /* There might turn out to be side effects inside expr. */
5865 TREE_SIDE_EFFECTS (t
) = 1;
5866 return convert_from_reference (t
);
5869 return build_const_cast_1 (type
, expr
, complain
& tf_error
,
5873 /* Like cp_build_c_cast, but for the c-common bits. */
5876 build_c_cast (location_t loc ATTRIBUTE_UNUSED
, tree type
, tree expr
)
5878 return cp_build_c_cast (type
, expr
, tf_warning_or_error
);
5881 /* Build an expression representing an explicit C-style cast to type
5882 TYPE of expression EXPR. */
5885 cp_build_c_cast (tree type
, tree expr
, tsubst_flags_t complain
)
5891 if (type
== error_mark_node
|| error_operand_p (expr
))
5892 return error_mark_node
;
5894 if (processing_template_decl
)
5896 tree t
= build_min (CAST_EXPR
, type
,
5897 tree_cons (NULL_TREE
, value
, NULL_TREE
));
5898 /* We don't know if it will or will not have side effects. */
5899 TREE_SIDE_EFFECTS (t
) = 1;
5900 return convert_from_reference (t
);
5903 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5904 'Class') should always be retained, because this information aids
5905 in method lookup. */
5906 if (objc_is_object_ptr (type
)
5907 && objc_is_object_ptr (TREE_TYPE (expr
)))
5908 return build_nop (type
, expr
);
5910 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5911 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5912 if (TREE_CODE (type
) != REFERENCE_TYPE
5913 && TREE_CODE (value
) == NOP_EXPR
5914 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5915 value
= TREE_OPERAND (value
, 0);
5917 if (TREE_CODE (type
) == ARRAY_TYPE
)
5919 /* Allow casting from T1* to T2[] because Cfront allows it.
5920 NIHCL uses it. It is not valid ISO C++ however. */
5921 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5923 if (complain
& tf_error
)
5924 permerror (input_location
, "ISO C++ forbids casting to an array type %qT", type
);
5926 return error_mark_node
;
5927 type
= build_pointer_type (TREE_TYPE (type
));
5931 if (complain
& tf_error
)
5932 error ("ISO C++ forbids casting to an array type %qT", type
);
5933 return error_mark_node
;
5937 if (TREE_CODE (type
) == FUNCTION_TYPE
5938 || TREE_CODE (type
) == METHOD_TYPE
)
5940 if (complain
& tf_error
)
5941 error ("invalid cast to function type %qT", type
);
5942 return error_mark_node
;
5945 /* A C-style cast can be a const_cast. */
5946 result
= build_const_cast_1 (type
, value
, /*complain=*/false,
5951 /* Or a static cast. */
5952 result
= build_static_cast_1 (type
, value
, /*c_cast_p=*/true,
5953 &valid_p
, complain
);
5954 /* Or a reinterpret_cast. */
5956 result
= build_reinterpret_cast_1 (type
, value
, /*c_cast_p=*/true,
5957 &valid_p
, complain
);
5958 /* The static_cast or reinterpret_cast may be followed by a
5961 /* A valid cast may result in errors if, for example, a
5962 conversion to am ambiguous base class is required. */
5963 && !error_operand_p (result
))
5967 /* Non-class rvalues always have cv-unqualified type. */
5968 if (!CLASS_TYPE_P (type
))
5969 type
= TYPE_MAIN_VARIANT (type
);
5970 result_type
= TREE_TYPE (result
);
5971 if (!CLASS_TYPE_P (result_type
))
5972 result_type
= TYPE_MAIN_VARIANT (result_type
);
5973 /* If the type of RESULT does not match TYPE, perform a
5974 const_cast to make it match. If the static_cast or
5975 reinterpret_cast succeeded, we will differ by at most
5976 cv-qualification, so the follow-on const_cast is guaranteed
5978 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
5980 result
= build_const_cast_1 (type
, result
, false, &valid_p
);
5981 gcc_assert (valid_p
);
5986 return error_mark_node
;
5989 /* For use from the C common bits. */
5991 build_modify_expr (location_t location ATTRIBUTE_UNUSED
,
5992 tree lhs
, tree lhs_origtype ATTRIBUTE_UNUSED
,
5993 enum tree_code modifycode
,
5994 location_t rhs_location ATTRIBUTE_UNUSED
, tree rhs
,
5995 tree rhs_origtype ATTRIBUTE_UNUSED
)
5997 return cp_build_modify_expr (lhs
, modifycode
, rhs
, tf_warning_or_error
);
6000 /* Build an assignment expression of lvalue LHS from value RHS.
6001 MODIFYCODE is the code for a binary operator that we use
6002 to combine the old value of LHS with RHS to get the new value.
6003 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
6005 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
6008 cp_build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
,
6009 tsubst_flags_t complain
)
6013 tree lhstype
= TREE_TYPE (lhs
);
6014 tree olhstype
= lhstype
;
6015 bool plain_assign
= (modifycode
== NOP_EXPR
);
6017 /* Avoid duplicate error messages from operands that had errors. */
6018 if (error_operand_p (lhs
) || error_operand_p (rhs
))
6019 return error_mark_node
;
6021 /* Handle control structure constructs used as "lvalues". */
6022 switch (TREE_CODE (lhs
))
6024 /* Handle --foo = 5; as these are valid constructs in C++. */
6025 case PREDECREMENT_EXPR
:
6026 case PREINCREMENT_EXPR
:
6027 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
6028 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
6029 stabilize_reference (TREE_OPERAND (lhs
, 0)),
6030 TREE_OPERAND (lhs
, 1));
6031 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 0),
6032 modifycode
, rhs
, complain
);
6033 if (newrhs
== error_mark_node
)
6034 return error_mark_node
;
6035 return build2 (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
6037 /* Handle (a, b) used as an "lvalue". */
6039 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 1),
6040 modifycode
, rhs
, complain
);
6041 if (newrhs
== error_mark_node
)
6042 return error_mark_node
;
6043 return build2 (COMPOUND_EXPR
, lhstype
,
6044 TREE_OPERAND (lhs
, 0), newrhs
);
6047 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
6048 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
6049 stabilize_reference (TREE_OPERAND (lhs
, 0)),
6050 TREE_OPERAND (lhs
, 1));
6051 newrhs
= cp_build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
,
6053 if (newrhs
== error_mark_node
)
6054 return error_mark_node
;
6055 return build2 (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
6059 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
6060 when neither operand has side-effects. */
6061 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
6062 return error_mark_node
;
6064 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
6065 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
6067 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
6068 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
6070 TREE_OPERAND (lhs
, 0),
6071 TREE_OPERAND (lhs
, 1)),
6072 TREE_OPERAND (lhs
, 0),
6073 TREE_OPERAND (lhs
, 1));
6076 /* Handle (a ? b : c) used as an "lvalue". */
6079 /* Produce (a ? (b = rhs) : (c = rhs))
6080 except that the RHS goes through a save-expr
6081 so the code to compute it is only emitted once. */
6083 tree preeval
= NULL_TREE
;
6085 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
6087 if (complain
& tf_error
)
6088 error ("void value not ignored as it ought to be");
6089 return error_mark_node
;
6092 rhs
= stabilize_expr (rhs
, &preeval
);
6094 /* Check this here to avoid odd errors when trying to convert
6095 a throw to the type of the COND_EXPR. */
6096 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
6097 return error_mark_node
;
6099 cond
= build_conditional_expr
6100 (TREE_OPERAND (lhs
, 0),
6101 cp_build_modify_expr (TREE_OPERAND (lhs
, 1),
6102 modifycode
, rhs
, complain
),
6103 cp_build_modify_expr (TREE_OPERAND (lhs
, 2),
6104 modifycode
, rhs
, complain
),
6107 if (cond
== error_mark_node
)
6109 /* Make sure the code to compute the rhs comes out
6110 before the split. */
6112 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (lhs
), preeval
, cond
);
6120 if (modifycode
== INIT_EXPR
)
6122 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
6123 /* Do the default thing. */;
6124 else if (TREE_CODE (rhs
) == CONSTRUCTOR
)
6126 /* Compound literal. */
6127 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
6128 /* Call convert to generate an error; see PR 11063. */
6129 rhs
= convert (lhstype
, rhs
);
6130 result
= build2 (INIT_EXPR
, lhstype
, lhs
, rhs
);
6131 TREE_SIDE_EFFECTS (result
) = 1;
6134 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
6135 /* Do the default thing. */;
6138 VEC(tree
,gc
) *rhs_vec
= make_tree_vector_single (rhs
);
6139 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
6140 &rhs_vec
, lhstype
, LOOKUP_NORMAL
,
6142 release_tree_vector (rhs_vec
);
6143 if (result
== NULL_TREE
)
6144 return error_mark_node
;
6150 lhs
= require_complete_type (lhs
);
6151 if (lhs
== error_mark_node
)
6152 return error_mark_node
;
6154 if (modifycode
== NOP_EXPR
)
6156 /* `operator=' is not an inheritable operator. */
6157 if (! MAYBE_CLASS_TYPE_P (lhstype
))
6158 /* Do the default thing. */;
6161 result
= build_new_op (MODIFY_EXPR
, LOOKUP_NORMAL
,
6162 lhs
, rhs
, make_node (NOP_EXPR
),
6163 /*overloaded_p=*/NULL
,
6165 if (result
== NULL_TREE
)
6166 return error_mark_node
;
6173 /* A binary op has been requested. Combine the old LHS
6174 value with the RHS producing the value we should actually
6175 store into the LHS. */
6176 gcc_assert (!((TREE_CODE (lhstype
) == REFERENCE_TYPE
6177 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
6178 || MAYBE_CLASS_TYPE_P (lhstype
)));
6180 lhs
= stabilize_reference (lhs
);
6181 newrhs
= cp_build_binary_op (input_location
,
6182 modifycode
, lhs
, rhs
,
6184 if (newrhs
== error_mark_node
)
6186 if (complain
& tf_error
)
6187 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode
,
6188 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
6189 return error_mark_node
;
6192 /* Now it looks like a plain assignment. */
6193 modifycode
= NOP_EXPR
;
6195 gcc_assert (TREE_CODE (lhstype
) != REFERENCE_TYPE
);
6196 gcc_assert (TREE_CODE (TREE_TYPE (newrhs
)) != REFERENCE_TYPE
);
6199 /* The left-hand side must be an lvalue. */
6200 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
6201 return error_mark_node
;
6203 /* Warn about modifying something that is `const'. Don't warn if
6204 this is initialization. */
6205 if (modifycode
!= INIT_EXPR
6206 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
6207 /* Functions are not modifiable, even though they are
6209 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
6210 || TREE_CODE (TREE_TYPE (lhs
)) == METHOD_TYPE
6211 /* If it's an aggregate and any field is const, then it is
6212 effectively const. */
6213 || (CLASS_TYPE_P (lhstype
)
6214 && C_TYPE_FIELDS_READONLY (lhstype
))))
6216 if (complain
& tf_error
)
6217 readonly_error (lhs
, "assignment");
6219 return error_mark_node
;
6222 /* If storing into a structure or union member, it may have been given a
6223 lowered bitfield type. We need to convert to the declared type first,
6224 so retrieve it now. */
6226 olhstype
= unlowered_expr_type (lhs
);
6228 /* Convert new value to destination type. */
6230 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
6234 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
6235 rhs
= digest_init (lhstype
, rhs
);
6237 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
6238 TYPE_MAIN_VARIANT (TREE_TYPE (rhs
))))
6240 if (complain
& tf_error
)
6241 error ("incompatible types in assignment of %qT to %qT",
6242 TREE_TYPE (rhs
), lhstype
);
6243 return error_mark_node
;
6246 /* Allow array assignment in compiler-generated code. */
6247 else if (!current_function_decl
6248 || !DECL_ARTIFICIAL (current_function_decl
))
6250 /* This routine is used for both initialization and assignment.
6251 Make sure the diagnostic message differentiates the context. */
6252 if (complain
& tf_error
)
6254 if (modifycode
== INIT_EXPR
)
6255 error ("array used as initializer");
6257 error ("invalid array assignment");
6259 return error_mark_node
;
6262 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6263 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6264 return build_vec_init (lhs
, NULL_TREE
, newrhs
,
6265 /*explicit_value_init_p=*/false,
6266 from_array
, complain
);
6269 if (modifycode
== INIT_EXPR
)
6270 /* Calls with INIT_EXPR are all direct-initialization, so don't set
6271 LOOKUP_ONLYCONVERTING. */
6272 newrhs
= convert_for_initialization (lhs
, olhstype
, newrhs
, LOOKUP_NORMAL
,
6273 "initialization", NULL_TREE
, 0,
6276 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6277 NULL_TREE
, 0, complain
, LOOKUP_IMPLICIT
);
6279 if (!same_type_p (lhstype
, olhstype
))
6280 newrhs
= cp_convert_and_check (lhstype
, newrhs
);
6282 if (modifycode
!= INIT_EXPR
)
6284 if (TREE_CODE (newrhs
) == CALL_EXPR
6285 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6286 newrhs
= build_cplus_new (lhstype
, newrhs
);
6288 /* Can't initialize directly from a TARGET_EXPR, since that would
6289 cause the lhs to be constructed twice, and possibly result in
6290 accidental self-initialization. So we force the TARGET_EXPR to be
6291 expanded without a target. */
6292 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6293 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
6294 TREE_OPERAND (newrhs
, 0));
6297 if (newrhs
== error_mark_node
)
6298 return error_mark_node
;
6300 if (c_dialect_objc () && flag_objc_gc
)
6302 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
6308 result
= build2 (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6309 lhstype
, lhs
, newrhs
);
6311 TREE_SIDE_EFFECTS (result
) = 1;
6313 TREE_NO_WARNING (result
) = 1;
6319 build_x_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
,
6320 tsubst_flags_t complain
)
6322 if (processing_template_decl
)
6323 return build_min_nt (MODOP_EXPR
, lhs
,
6324 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
6326 if (modifycode
!= NOP_EXPR
)
6328 tree rval
= build_new_op (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
6329 make_node (modifycode
),
6330 /*overloaded_p=*/NULL
,
6334 TREE_NO_WARNING (rval
) = 1;
6338 return cp_build_modify_expr (lhs
, modifycode
, rhs
, complain
);
6341 /* Helper function for get_delta_difference which assumes FROM is a base
6342 class of TO. Returns a delta for the conversion of pointer-to-member
6343 of FROM to pointer-to-member of TO. If the conversion is invalid,
6344 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
6345 If C_CAST_P is true, this conversion is taking place as part of a C-style
6349 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
)
6354 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
, &kind
);
6355 if (kind
== bk_inaccessible
|| kind
== bk_ambig
)
6357 error (" in pointer to member function conversion");
6358 return size_zero_node
;
6362 if (kind
!= bk_via_virtual
)
6363 return BINFO_OFFSET (binfo
);
6365 /* FROM is a virtual base class of TO. Issue an error or warning
6366 depending on whether or not this is a reinterpret cast. */
6368 error ("pointer to member conversion via virtual base %qT",
6369 BINFO_TYPE (binfo_from_vbase (binfo
)));
6371 return size_zero_node
;
6378 /* Get difference in deltas for different pointer to member function
6379 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6380 the conversion is invalid, the constant is zero. If
6381 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6382 If C_CAST_P is true this conversion is taking place as part of a
6385 Note that the naming of FROM and TO is kind of backwards; the return
6386 value is what we add to a TO in order to get a FROM. They are named
6387 this way because we call this function to find out how to convert from
6388 a pointer to member of FROM to a pointer to member of TO. */
6391 get_delta_difference (tree from
, tree to
,
6392 bool allow_inverse_p
,
6397 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
6398 /* Pointer to member of incomplete class is permitted*/
6399 result
= size_zero_node
;
6401 result
= get_delta_difference_1 (from
, to
, c_cast_p
);
6405 if (!allow_inverse_p
)
6407 error_not_base_type (from
, to
);
6408 error (" in pointer to member conversion");
6409 result
= size_zero_node
;
6413 result
= get_delta_difference_1 (to
, from
, c_cast_p
);
6416 result
= size_diffop_loc (input_location
,
6417 size_zero_node
, result
);
6420 error_not_base_type (from
, to
);
6421 error (" in pointer to member conversion");
6422 result
= size_zero_node
;
6427 return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node
,
6431 /* Return a constructor for the pointer-to-member-function TYPE using
6432 the other components as specified. */
6435 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
6440 VEC(constructor_elt
, gc
) *v
;
6442 /* Pull the FIELD_DECLs out of the type. */
6443 pfn_field
= TYPE_FIELDS (type
);
6444 delta_field
= TREE_CHAIN (pfn_field
);
6446 /* Make sure DELTA has the type we want. */
6447 delta
= convert_and_check (delta_type_node
, delta
);
6449 /* Convert to the correct target type if necessary. */
6450 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
6452 /* Finish creating the initializer. */
6453 v
= VEC_alloc(constructor_elt
, gc
, 2);
6454 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
6455 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
6456 u
= build_constructor (type
, v
);
6457 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
6458 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
6459 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
6461 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
6466 /* Build a constructor for a pointer to member function. It can be
6467 used to initialize global variables, local variable, or used
6468 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6471 If FORCE is nonzero, then force this conversion, even if
6472 we would rather not do it. Usually set when using an explicit
6473 cast. A C-style cast is being processed iff C_CAST_P is true.
6475 Return error_mark_node, if something goes wrong. */
6478 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
)
6484 if (error_operand_p (pfn
))
6485 return error_mark_node
;
6487 pfn_type
= TREE_TYPE (pfn
);
6488 to_type
= build_ptrmemfunc_type (type
);
6490 /* Handle multiple conversions of pointer to member functions. */
6491 if (TYPE_PTRMEMFUNC_P (pfn_type
))
6493 tree delta
= NULL_TREE
;
6494 tree npfn
= NULL_TREE
;
6498 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
, LOOKUP_NORMAL
))
6499 error ("invalid conversion to type %qT from type %qT",
6502 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
6503 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
6507 /* We don't have to do any conversion to convert a
6508 pointer-to-member to its own type. But, we don't want to
6509 just return a PTRMEM_CST if there's an explicit cast; that
6510 cast should make the expression an invalid template argument. */
6511 if (TREE_CODE (pfn
) != PTRMEM_CST
)
6513 if (same_type_p (to_type
, pfn_type
))
6515 else if (integer_zerop (n
))
6516 return build_reinterpret_cast (to_type
, pfn
,
6517 tf_warning_or_error
);
6520 if (TREE_SIDE_EFFECTS (pfn
))
6521 pfn
= save_expr (pfn
);
6523 /* Obtain the function pointer and the current DELTA. */
6524 if (TREE_CODE (pfn
) == PTRMEM_CST
)
6525 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
6528 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
6529 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
6532 /* Just adjust the DELTA field. */
6533 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6534 (TREE_TYPE (delta
), ptrdiff_type_node
));
6535 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
6536 n
= cp_build_binary_op (input_location
,
6537 LSHIFT_EXPR
, n
, integer_one_node
,
6538 tf_warning_or_error
);
6539 delta
= cp_build_binary_op (input_location
,
6540 PLUS_EXPR
, delta
, n
, tf_warning_or_error
);
6541 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
6544 /* Handle null pointer to member function conversions. */
6545 if (integer_zerop (pfn
))
6547 pfn
= build_c_cast (input_location
, type
, integer_zero_node
);
6548 return build_ptrmemfunc1 (to_type
,
6553 if (type_unknown_p (pfn
))
6554 return instantiate_type (type
, pfn
, tf_warning_or_error
);
6556 fn
= TREE_OPERAND (pfn
, 0);
6557 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6558 /* In a template, we will have preserved the
6560 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
6561 return make_ptrmem_cst (to_type
, fn
);
6564 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6567 ??? There is no consistency as to the types returned for the above
6568 values. Some code acts as if it were a sizetype and some as if it were
6569 integer_type_node. */
6572 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
6574 tree type
= TREE_TYPE (cst
);
6575 tree fn
= PTRMEM_CST_MEMBER (cst
);
6576 tree ptr_class
, fn_class
;
6578 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6580 /* The class that the function belongs to. */
6581 fn_class
= DECL_CONTEXT (fn
);
6583 /* The class that we're creating a pointer to member of. */
6584 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
6586 /* First, calculate the adjustment to the function's class. */
6587 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
6590 if (!DECL_VIRTUAL_P (fn
))
6591 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), build_addr_func (fn
));
6594 /* If we're dealing with a virtual function, we have to adjust 'this'
6595 again, to point to the base which provides the vtable entry for
6596 fn; the call will do the opposite adjustment. */
6597 tree orig_class
= DECL_CONTEXT (fn
);
6598 tree binfo
= binfo_or_else (orig_class
, fn_class
);
6599 *delta
= build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
6600 *delta
, BINFO_OFFSET (binfo
));
6601 *delta
= fold_if_not_in_template (*delta
);
6603 /* We set PFN to the vtable offset at which the function can be
6604 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6605 case delta is shifted left, and then incremented). */
6606 *pfn
= DECL_VINDEX (fn
);
6607 *pfn
= build2 (MULT_EXPR
, integer_type_node
, *pfn
,
6608 TYPE_SIZE_UNIT (vtable_entry_type
));
6609 *pfn
= fold_if_not_in_template (*pfn
);
6611 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
6613 case ptrmemfunc_vbit_in_pfn
:
6614 *pfn
= build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
6616 *pfn
= fold_if_not_in_template (*pfn
);
6619 case ptrmemfunc_vbit_in_delta
:
6620 *delta
= build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
6621 *delta
, integer_one_node
);
6622 *delta
= fold_if_not_in_template (*delta
);
6623 *delta
= build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
6624 *delta
, integer_one_node
);
6625 *delta
= fold_if_not_in_template (*delta
);
6632 *pfn
= build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
6633 *pfn
= fold_if_not_in_template (*pfn
);
6637 /* Return an expression for PFN from the pointer-to-member function
6641 pfn_from_ptrmemfunc (tree t
)
6643 if (TREE_CODE (t
) == PTRMEM_CST
)
6648 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
6653 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
6656 /* Return an expression for DELTA from the pointer-to-member function
6660 delta_from_ptrmemfunc (tree t
)
6662 if (TREE_CODE (t
) == PTRMEM_CST
)
6667 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
6672 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
6675 /* Convert value RHS to type TYPE as preparation for an assignment to
6676 an lvalue of type TYPE. ERRTYPE is a string to use in error
6677 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6678 are doing the conversion in order to pass the PARMNUMth argument of
6682 convert_for_assignment (tree type
, tree rhs
,
6683 const char *errtype
, tree fndecl
, int parmnum
,
6684 tsubst_flags_t complain
, int flags
)
6687 enum tree_code coder
;
6689 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6690 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6691 rhs
= TREE_OPERAND (rhs
, 0);
6693 rhstype
= TREE_TYPE (rhs
);
6694 coder
= TREE_CODE (rhstype
);
6696 if (TREE_CODE (type
) == VECTOR_TYPE
&& coder
== VECTOR_TYPE
6697 && vector_types_convertible_p (type
, rhstype
, true))
6698 return convert (type
, rhs
);
6700 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
6701 return error_mark_node
;
6702 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6703 return error_mark_node
;
6705 /* The RHS of an assignment cannot have void type. */
6706 if (coder
== VOID_TYPE
)
6708 if (complain
& tf_error
)
6709 error ("void value not ignored as it ought to be");
6710 return error_mark_node
;
6713 /* Simplify the RHS if possible. */
6714 if (TREE_CODE (rhs
) == CONST_DECL
)
6715 rhs
= DECL_INITIAL (rhs
);
6717 if (c_dialect_objc ())
6720 tree rname
= fndecl
;
6722 if (!strcmp (errtype
, "assignment"))
6724 else if (!strcmp (errtype
, "initialization"))
6728 tree selector
= objc_message_selector ();
6732 if (selector
&& parmno
> 1)
6739 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
6740 return convert (type
, rhs
);
6745 The expression is implicitly converted (clause _conv_) to the
6746 cv-unqualified type of the left operand.
6748 We allow bad conversions here because by the time we get to this point
6749 we are committed to doing the conversion. If we end up doing a bad
6750 conversion, convert_like will complain. */
6751 if (!can_convert_arg_bad (type
, rhstype
, rhs
, flags
))
6753 /* When -Wno-pmf-conversions is use, we just silently allow
6754 conversions from pointers-to-members to plain pointers. If
6755 the conversion doesn't work, cp_convert will complain. */
6757 && TYPE_PTR_P (type
)
6758 && TYPE_PTRMEMFUNC_P (rhstype
))
6759 rhs
= cp_convert (strip_top_quals (type
), rhs
);
6762 if (complain
& tf_error
)
6764 /* If the right-hand side has unknown type, then it is an
6765 overloaded function. Call instantiate_type to get error
6767 if (rhstype
== unknown_type_node
)
6768 instantiate_type (type
, rhs
, tf_warning_or_error
);
6770 error ("cannot convert %qT to %qT for argument %qP to %qD",
6771 rhstype
, type
, parmnum
, fndecl
);
6773 error ("cannot convert %qT to %qT in %s", rhstype
, type
,
6776 return error_mark_node
;
6779 if (warn_missing_format_attribute
)
6781 const enum tree_code codel
= TREE_CODE (type
);
6782 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6784 && check_missing_format_attribute (type
, rhstype
)
6785 && (complain
& tf_warning
))
6786 warning (OPT_Wmissing_format_attribute
,
6787 "%s might be a candidate for a format attribute",
6791 /* If -Wparentheses, warn about a = b = c when a has type bool and b
6793 if (warn_parentheses
6794 && TREE_CODE (type
) == BOOLEAN_TYPE
6795 && TREE_CODE (rhs
) == MODIFY_EXPR
6796 && !TREE_NO_WARNING (rhs
)
6797 && TREE_CODE (TREE_TYPE (rhs
)) != BOOLEAN_TYPE
6798 && (complain
& tf_warning
))
6800 location_t loc
= EXPR_HAS_LOCATION (rhs
)
6801 ? EXPR_LOCATION (rhs
) : input_location
;
6803 warning_at (loc
, OPT_Wparentheses
,
6804 "suggest parentheses around assignment used as truth value");
6805 TREE_NO_WARNING (rhs
) = 1;
6808 return perform_implicit_conversion_flags (strip_top_quals (type
), rhs
,
6812 /* Convert RHS to be of type TYPE.
6813 If EXP is nonzero, it is the target of the initialization.
6814 ERRTYPE is a string to use in error messages.
6816 Two major differences between the behavior of
6817 `convert_for_assignment' and `convert_for_initialization'
6818 are that references are bashed in the former, while
6819 copied in the latter, and aggregates are assigned in
6820 the former (operator=) while initialized in the
6823 If using constructor make sure no conversion operator exists, if one does
6824 exist, an ambiguity exists.
6826 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6829 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
6830 const char *errtype
, tree fndecl
, int parmnum
,
6831 tsubst_flags_t complain
)
6833 enum tree_code codel
= TREE_CODE (type
);
6835 enum tree_code coder
;
6837 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6838 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6839 if (TREE_CODE (rhs
) == NOP_EXPR
6840 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6841 && codel
!= REFERENCE_TYPE
)
6842 rhs
= TREE_OPERAND (rhs
, 0);
6844 if (type
== error_mark_node
6845 || rhs
== error_mark_node
6846 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6847 return error_mark_node
;
6849 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6850 && TREE_CODE (type
) != ARRAY_TYPE
6851 && (TREE_CODE (type
) != REFERENCE_TYPE
6852 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6853 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6854 && (TREE_CODE (type
) != REFERENCE_TYPE
6855 || TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
))
6856 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6857 rhs
= decay_conversion (rhs
);
6859 rhstype
= TREE_TYPE (rhs
);
6860 coder
= TREE_CODE (rhstype
);
6862 if (coder
== ERROR_MARK
)
6863 return error_mark_node
;
6865 /* We accept references to incomplete types, so we can
6866 return here before checking if RHS is of complete type. */
6868 if (codel
== REFERENCE_TYPE
)
6870 /* This should eventually happen in convert_arguments. */
6871 int savew
= 0, savee
= 0;
6874 savew
= warningcount
, savee
= errorcount
;
6875 rhs
= initialize_reference (type
, rhs
, /*decl=*/NULL_TREE
,
6879 if (warningcount
> savew
)
6880 warning (0, "in passing argument %P of %q+D", parmnum
, fndecl
);
6881 else if (errorcount
> savee
)
6882 error ("in passing argument %P of %q+D", parmnum
, fndecl
);
6888 exp
= require_complete_type (exp
);
6889 if (exp
== error_mark_node
)
6890 return error_mark_node
;
6892 rhstype
= non_reference (rhstype
);
6894 type
= complete_type (type
);
6896 if (MAYBE_CLASS_TYPE_P (type
))
6897 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
6899 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
6903 /* If RETVAL is the address of, or a reference to, a local variable or
6904 temporary give an appropriate warning. */
6907 maybe_warn_about_returning_address_of_local (tree retval
)
6909 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
6910 tree whats_returned
= retval
;
6914 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
6915 whats_returned
= TREE_OPERAND (whats_returned
, 1);
6916 else if (CONVERT_EXPR_P (whats_returned
)
6917 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
6918 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6923 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
6925 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6927 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6929 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
6930 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
6932 warning (0, "returning reference to temporary");
6935 if (TREE_CODE (whats_returned
) == VAR_DECL
6936 && DECL_NAME (whats_returned
)
6937 && TEMP_NAME_P (DECL_NAME (whats_returned
)))
6939 warning (0, "reference to non-lvalue returned");
6944 while (TREE_CODE (whats_returned
) == COMPONENT_REF
6945 || TREE_CODE (whats_returned
) == ARRAY_REF
)
6946 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6948 if (DECL_P (whats_returned
)
6949 && DECL_NAME (whats_returned
)
6950 && DECL_FUNCTION_SCOPE_P (whats_returned
)
6951 && !(TREE_STATIC (whats_returned
)
6952 || TREE_PUBLIC (whats_returned
)))
6954 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6955 warning (0, "reference to local variable %q+D returned",
6958 warning (0, "address of local variable %q+D returned",
6964 /* Check that returning RETVAL from the current function is valid.
6965 Return an expression explicitly showing all conversions required to
6966 change RETVAL into the function return type, and to assign it to
6967 the DECL_RESULT for the function. Set *NO_WARNING to true if
6968 code reaches end of non-void function warning shouldn't be issued
6969 on this RETURN_EXPR. */
6972 check_return_expr (tree retval
, bool *no_warning
)
6975 /* The type actually returned by the function, after any
6978 int fn_returns_value_p
;
6979 bool named_return_value_okay_p
;
6981 *no_warning
= false;
6983 /* A `volatile' function is one that isn't supposed to return, ever.
6984 (This is a G++ extension, used to get better code for functions
6985 that call the `volatile' function.) */
6986 if (TREE_THIS_VOLATILE (current_function_decl
))
6987 warning (0, "function declared %<noreturn%> has a %<return%> statement");
6989 /* Check for various simple errors. */
6990 if (DECL_DESTRUCTOR_P (current_function_decl
))
6993 error ("returning a value from a destructor");
6996 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
6998 if (in_function_try_handler
)
6999 /* If a return statement appears in a handler of the
7000 function-try-block of a constructor, the program is ill-formed. */
7001 error ("cannot return from a handler of a function-try-block of a constructor");
7003 /* You can't return a value from a constructor. */
7004 error ("returning a value from a constructor");
7008 /* As an extension, deduce lambda return type from a return statement
7009 anywhere in the body. */
7010 if (retval
&& LAMBDA_FUNCTION_P (current_function_decl
))
7012 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
7013 if (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda
))
7015 tree type
= lambda_return_type (retval
);
7016 tree oldtype
= LAMBDA_EXPR_RETURN_TYPE (lambda
);
7018 if (VOID_TYPE_P (type
))
7020 else if (oldtype
== NULL_TREE
)
7022 pedwarn (input_location
, OPT_pedantic
, "lambda return type "
7023 "can only be deduced when the return statement is "
7024 "the only statement in the function body");
7025 apply_lambda_return_type (lambda
, type
);
7027 else if (!same_type_p (type
, oldtype
))
7028 error ("inconsistent types %qT and %qT deduced for "
7029 "lambda return type", type
, oldtype
);
7033 if (processing_template_decl
)
7035 current_function_returns_value
= 1;
7036 if (check_for_bare_parameter_packs (retval
))
7037 retval
= error_mark_node
;
7041 /* When no explicit return-value is given in a function with a named
7042 return value, the named return value is used. */
7043 result
= DECL_RESULT (current_function_decl
);
7044 valtype
= TREE_TYPE (result
);
7045 gcc_assert (valtype
!= NULL_TREE
);
7046 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
7047 if (!retval
&& DECL_NAME (result
) && fn_returns_value_p
)
7050 /* Check for a return statement with no return value in a function
7051 that's supposed to return a value. */
7052 if (!retval
&& fn_returns_value_p
)
7054 permerror (input_location
, "return-statement with no value, in function returning %qT",
7056 /* Clear this, so finish_function won't say that we reach the
7057 end of a non-void function (which we don't, we gave a
7059 current_function_returns_null
= 0;
7060 /* And signal caller that TREE_NO_WARNING should be set on the
7061 RETURN_EXPR to avoid control reaches end of non-void function
7062 warnings in tree-cfg.c. */
7065 /* Check for a return statement with a value in a function that
7066 isn't supposed to return a value. */
7067 else if (retval
&& !fn_returns_value_p
)
7069 if (VOID_TYPE_P (TREE_TYPE (retval
)))
7070 /* You can return a `void' value from a function of `void'
7071 type. In that case, we have to evaluate the expression for
7072 its side-effects. */
7073 finish_expr_stmt (retval
);
7075 permerror (input_location
, "return-statement with a value, in function "
7076 "returning 'void'");
7077 current_function_returns_null
= 1;
7079 /* There's really no value to return, after all. */
7083 /* Remember that this function can sometimes return without a
7085 current_function_returns_null
= 1;
7087 /* Remember that this function did return a value. */
7088 current_function_returns_value
= 1;
7090 /* Check for erroneous operands -- but after giving ourselves a
7091 chance to provide an error about returning a value from a void
7093 if (error_operand_p (retval
))
7095 current_function_return_value
= error_mark_node
;
7096 return error_mark_node
;
7099 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
7100 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == NEW_EXPR
7101 || DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == VEC_NEW_EXPR
)
7102 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
7104 && retval
&& null_ptr_cst_p (retval
))
7105 warning (0, "%<operator new%> must not return NULL unless it is "
7106 "declared %<throw()%> (or -fcheck-new is in effect)");
7108 /* Effective C++ rule 15. See also start_function. */
7110 && DECL_NAME (current_function_decl
) == ansi_assopname(NOP_EXPR
))
7114 /* The function return type must be a reference to the current
7116 if (TREE_CODE (valtype
) == REFERENCE_TYPE
7117 && same_type_ignoring_top_level_qualifiers_p
7118 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
7120 /* Returning '*this' is obviously OK. */
7121 if (retval
== current_class_ref
)
7123 /* If we are calling a function whose return type is the same of
7124 the current class reference, it is ok. */
7125 else if (TREE_CODE (retval
) == INDIRECT_REF
7126 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
7131 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
7134 /* The fabled Named Return Value optimization, as per [class.copy]/15:
7136 [...] For a function with a class return type, if the expression
7137 in the return statement is the name of a local object, and the cv-
7138 unqualified type of the local object is the same as the function
7139 return type, an implementation is permitted to omit creating the tem-
7140 porary object to hold the function return value [...]
7142 So, if this is a value-returning function that always returns the same
7143 local variable, remember it.
7145 It might be nice to be more flexible, and choose the first suitable
7146 variable even if the function sometimes returns something else, but
7147 then we run the risk of clobbering the variable we chose if the other
7148 returned expression uses the chosen variable somehow. And people expect
7149 this restriction, anyway. (jason 2000-11-19)
7151 See finish_function and finalize_nrv for the rest of this optimization. */
7153 named_return_value_okay_p
=
7154 (retval
!= NULL_TREE
7155 /* Must be a local, automatic variable. */
7156 && TREE_CODE (retval
) == VAR_DECL
7157 && DECL_CONTEXT (retval
) == current_function_decl
7158 && ! TREE_STATIC (retval
)
7159 && ! DECL_ANON_UNION_VAR_P (retval
)
7160 && (DECL_ALIGN (retval
)
7161 >= DECL_ALIGN (DECL_RESULT (current_function_decl
)))
7162 /* The cv-unqualified type of the returned value must be the
7163 same as the cv-unqualified return type of the
7165 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval
))),
7167 (TREE_TYPE (TREE_TYPE (current_function_decl
)))))
7168 /* And the returned value must be non-volatile. */
7169 && ! TYPE_VOLATILE (TREE_TYPE (retval
)));
7171 if (fn_returns_value_p
&& flag_elide_constructors
)
7173 if (named_return_value_okay_p
7174 && (current_function_return_value
== NULL_TREE
7175 || current_function_return_value
== retval
))
7176 current_function_return_value
= retval
;
7178 current_function_return_value
= error_mark_node
;
7181 /* We don't need to do any conversions when there's nothing being
7186 /* Do any required conversions. */
7187 if (retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
7188 /* No conversions are required. */
7192 /* The type the function is declared to return. */
7193 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7194 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
7196 /* The functype's return type will have been set to void, if it
7197 was an incomplete type. Just treat this as 'return;' */
7198 if (VOID_TYPE_P (functype
))
7199 return error_mark_node
;
7201 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
7202 treated as an rvalue for the purposes of overload resolution to
7203 favor move constructors over copy constructors. */
7204 if ((cxx_dialect
!= cxx98
)
7205 && named_return_value_okay_p
7206 /* The variable must not have the `volatile' qualifier. */
7207 && !(cp_type_quals (TREE_TYPE (retval
)) & TYPE_QUAL_VOLATILE
)
7208 /* The return type must be a class type. */
7209 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
7210 flags
= flags
| LOOKUP_PREFER_RVALUE
;
7212 /* First convert the value to the function's return type, then
7213 to the type of return value's location to handle the
7214 case that functype is smaller than the valtype. */
7215 retval
= convert_for_initialization
7216 (NULL_TREE
, functype
, retval
, flags
, "return", NULL_TREE
, 0,
7217 tf_warning_or_error
);
7218 retval
= convert (valtype
, retval
);
7220 /* If the conversion failed, treat this just like `return;'. */
7221 if (retval
== error_mark_node
)
7223 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7224 else if (! cfun
->returns_struct
7225 && TREE_CODE (retval
) == TARGET_EXPR
7226 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
7227 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
7228 TREE_OPERAND (retval
, 0));
7230 maybe_warn_about_returning_address_of_local (retval
);
7233 /* Actually copy the value returned into the appropriate location. */
7234 if (retval
&& retval
!= result
)
7235 retval
= build2 (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7241 /* Returns nonzero if the pointer-type FROM can be converted to the
7242 pointer-type TO via a qualification conversion. If CONSTP is -1,
7243 then we return nonzero if the pointers are similar, and the
7244 cv-qualification signature of FROM is a proper subset of that of TO.
7246 If CONSTP is positive, then all outer pointers have been
7250 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
7252 bool to_more_cv_qualified
= false;
7253 bool is_opaque_pointer
= false;
7255 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7257 if (TREE_CODE (to
) != TREE_CODE (from
))
7260 if (TREE_CODE (from
) == OFFSET_TYPE
7261 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
7262 TYPE_OFFSET_BASETYPE (to
)))
7265 /* Const and volatile mean something different for function types,
7266 so the usual checks are not appropriate. */
7267 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7269 /* In Objective-C++, some types may have been 'volatilized' by
7270 the compiler for EH; when comparing them here, the volatile
7271 qualification must be ignored. */
7272 bool objc_quals_match
= objc_type_quals_match (to
, from
);
7274 if (!at_least_as_qualified_p (to
, from
) && !objc_quals_match
)
7277 if (!at_least_as_qualified_p (from
, to
) && !objc_quals_match
)
7281 to_more_cv_qualified
= true;
7285 constp
&= TYPE_READONLY (to
);
7288 if (TREE_CODE (to
) == VECTOR_TYPE
)
7289 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
7291 if (TREE_CODE (to
) != POINTER_TYPE
&& !TYPE_PTRMEM_P (to
))
7292 return ((constp
>= 0 || to_more_cv_qualified
)
7293 && (is_opaque_pointer
7294 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
7298 /* When comparing, say, char ** to char const **, this function takes
7299 the 'char *' and 'char const *'. Do not pass non-pointer/reference
7300 types to this function. */
7303 comp_ptr_ttypes (tree to
, tree from
)
7305 return comp_ptr_ttypes_real (to
, from
, 1);
7308 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7309 type or inheritance-related types, regardless of cv-quals. */
7312 ptr_reasonably_similar (const_tree to
, const_tree from
)
7314 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7316 /* Any target type is similar enough to void. */
7317 if (TREE_CODE (to
) == VOID_TYPE
7318 || TREE_CODE (from
) == VOID_TYPE
)
7321 if (TREE_CODE (to
) != TREE_CODE (from
))
7324 if (TREE_CODE (from
) == OFFSET_TYPE
7325 && comptypes (TYPE_OFFSET_BASETYPE (to
),
7326 TYPE_OFFSET_BASETYPE (from
),
7327 COMPARE_BASE
| COMPARE_DERIVED
))
7330 if (TREE_CODE (to
) == VECTOR_TYPE
7331 && vector_types_convertible_p (to
, from
, false))
7334 if (TREE_CODE (to
) == INTEGER_TYPE
7335 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
7338 if (TREE_CODE (to
) == FUNCTION_TYPE
)
7341 if (TREE_CODE (to
) != POINTER_TYPE
)
7343 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
7344 COMPARE_BASE
| COMPARE_DERIVED
);
7348 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7349 pointer-to-member types) are the same, ignoring cv-qualification at
7353 comp_ptr_ttypes_const (tree to
, tree from
)
7355 bool is_opaque_pointer
= false;
7357 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7359 if (TREE_CODE (to
) != TREE_CODE (from
))
7362 if (TREE_CODE (from
) == OFFSET_TYPE
7363 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7364 TYPE_OFFSET_BASETYPE (to
)))
7367 if (TREE_CODE (to
) == VECTOR_TYPE
)
7368 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
7370 if (TREE_CODE (to
) != POINTER_TYPE
)
7371 return (is_opaque_pointer
7372 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
7376 /* Returns the type qualifiers for this type, including the qualifiers on the
7377 elements for an array type. */
7380 cp_type_quals (const_tree type
)
7382 /* This CONST_CAST is okay because strip_array_types returns its
7383 argument unmodified and we assign it to a const_tree. */
7384 type
= strip_array_types (CONST_CAST_TREE(type
));
7385 if (type
== error_mark_node
)
7386 return TYPE_UNQUALIFIED
;
7387 return TYPE_QUALS (type
);
7390 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7394 cp_type_readonly (const_tree type
)
7396 /* This CONST_CAST is okay because strip_array_types returns its
7397 argument unmodified and we assign it to a const_tree. */
7398 type
= strip_array_types (CONST_CAST_TREE(type
));
7399 return TYPE_READONLY (type
);
7402 /* Returns nonzero if the TYPE contains a mutable member. */
7405 cp_has_mutable_p (const_tree type
)
7407 /* This CONST_CAST is okay because strip_array_types returns its
7408 argument unmodified and we assign it to a const_tree. */
7409 type
= strip_array_types (CONST_CAST_TREE(type
));
7411 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
7414 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7415 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7416 approximation. In particular, consider:
7419 struct S { int i; };
7420 const S s = { f(); }
7422 Here, we will make "s" as TREE_READONLY (because it is declared
7423 "const") -- only to reverse ourselves upon seeing that the
7424 initializer is non-constant. */
7427 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
7429 tree type
= TREE_TYPE (decl
);
7431 if (type
== error_mark_node
)
7434 if (TREE_CODE (decl
) == TYPE_DECL
)
7437 if (TREE_CODE (type
) == FUNCTION_TYPE
7438 && type_quals
!= TYPE_UNQUALIFIED
)
7440 /* This was an error in C++98 (cv-qualifiers cannot be added to
7441 a function type), but DR 295 makes the code well-formed by
7442 dropping the extra qualifiers. */
7445 tree bad_type
= build_qualified_type (type
, type_quals
);
7446 pedwarn (input_location
, OPT_pedantic
,
7447 "ignoring %qV qualifiers added to function type %qT",
7451 TREE_TYPE (decl
) = TYPE_MAIN_VARIANT (type
);
7455 /* Avoid setting TREE_READONLY incorrectly. */
7456 if (/* If the object has a constructor, the constructor may modify
7458 TYPE_NEEDS_CONSTRUCTING (type
)
7459 /* If the type isn't complete, we don't know yet if it will need
7461 || !COMPLETE_TYPE_P (type
)
7462 /* If the type has a mutable component, that component might be
7464 || TYPE_HAS_MUTABLE_P (type
))
7465 type_quals
&= ~TYPE_QUAL_CONST
;
7467 c_apply_type_quals_to_decl (type_quals
, decl
);
7470 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7471 exemplar types such that casting T1 to T2 is casting away constness
7472 if and only if there is no implicit conversion from T1 to T2. */
7475 casts_away_constness_r (tree
*t1
, tree
*t2
)
7480 /* [expr.const.cast]
7482 For multi-level pointer to members and multi-level mixed pointers
7483 and pointers to members (conv.qual), the "member" aspect of a
7484 pointer to member level is ignored when determining if a const
7485 cv-qualifier has been cast away. */
7486 /* [expr.const.cast]
7488 For two pointer types:
7490 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7491 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7494 casting from X1 to X2 casts away constness if, for a non-pointer
7495 type T there does not exist an implicit conversion (clause
7498 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7502 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7503 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRMEM_P (*t1
))
7504 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRMEM_P (*t2
)))
7506 *t1
= cp_build_qualified_type (void_type_node
,
7507 cp_type_quals (*t1
));
7508 *t2
= cp_build_qualified_type (void_type_node
,
7509 cp_type_quals (*t2
));
7513 quals1
= cp_type_quals (*t1
);
7514 quals2
= cp_type_quals (*t2
);
7516 if (TYPE_PTRMEM_P (*t1
))
7517 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
7519 *t1
= TREE_TYPE (*t1
);
7520 if (TYPE_PTRMEM_P (*t2
))
7521 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
7523 *t2
= TREE_TYPE (*t2
);
7525 casts_away_constness_r (t1
, t2
);
7526 *t1
= build_pointer_type (*t1
);
7527 *t2
= build_pointer_type (*t2
);
7528 *t1
= cp_build_qualified_type (*t1
, quals1
);
7529 *t2
= cp_build_qualified_type (*t2
, quals2
);
7532 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7535 ??? This function returns non-zero if casting away qualifiers not
7536 just const. We would like to return to the caller exactly which
7537 qualifiers are casted away to give more accurate diagnostics.
7541 casts_away_constness (tree t1
, tree t2
)
7543 if (TREE_CODE (t2
) == REFERENCE_TYPE
)
7545 /* [expr.const.cast]
7547 Casting from an lvalue of type T1 to an lvalue of type T2
7548 using a reference cast casts away constness if a cast from an
7549 rvalue of type "pointer to T1" to the type "pointer to T2"
7550 casts away constness. */
7551 t1
= (TREE_CODE (t1
) == REFERENCE_TYPE
? TREE_TYPE (t1
) : t1
);
7552 return casts_away_constness (build_pointer_type (t1
),
7553 build_pointer_type (TREE_TYPE (t2
)));
7556 if (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
))
7557 /* [expr.const.cast]
7559 Casting from an rvalue of type "pointer to data member of X
7560 of type T1" to the type "pointer to data member of Y of type
7561 T2" casts away constness if a cast from an rvalue of type
7562 "pointer to T1" to the type "pointer to T2" casts away
7564 return casts_away_constness
7565 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
7566 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)));
7568 /* Casting away constness is only something that makes sense for
7569 pointer or reference types. */
7570 if (TREE_CODE (t1
) != POINTER_TYPE
7571 || TREE_CODE (t2
) != POINTER_TYPE
)
7574 /* Top-level qualifiers don't matter. */
7575 t1
= TYPE_MAIN_VARIANT (t1
);
7576 t2
= TYPE_MAIN_VARIANT (t2
);
7577 casts_away_constness_r (&t1
, &t2
);
7578 if (!can_convert (t2
, t1
))
7584 /* If T is a REFERENCE_TYPE return the type to which T refers.
7585 Otherwise, return T itself. */
7588 non_reference (tree t
)
7590 if (TREE_CODE (t
) == REFERENCE_TYPE
)
7596 /* Return nonzero if REF is an lvalue valid for this language;
7597 otherwise, print an error message and return zero. USE says
7598 how the lvalue is being used and so selects the error message. */
7601 lvalue_or_else (tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
7603 int win
= lvalue_p (ref
);
7605 if (!win
&& (complain
& tf_error
))