1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file is part of the C++ front end.
23 It contains routines to build C++ expressions given their operands,
24 including computing the types of the result, C and C++ specific error
25 checks, and some optimization. */
29 #include "coretypes.h"
32 #include "stor-layout.h"
36 #include "c-family/c-objc.h"
37 #include "c-family/c-ubsan.h"
39 #include "gcc-rich-location.h"
41 static tree
cp_build_addr_expr_strict (tree
, tsubst_flags_t
);
42 static tree
cp_build_function_call (tree
, tree
, tsubst_flags_t
);
43 static tree
pfn_from_ptrmemfunc (tree
);
44 static tree
delta_from_ptrmemfunc (tree
);
45 static tree
convert_for_assignment (tree
, tree
, impl_conv_rhs
, tree
, int,
47 static tree
cp_pointer_int_sum (location_t
, enum tree_code
, tree
, tree
,
49 static tree
rationalize_conditional_expr (enum tree_code
, tree
,
51 static int comp_ptr_ttypes_real (tree
, tree
, int);
52 static bool comp_except_types (tree
, tree
, bool);
53 static bool comp_array_types (const_tree
, const_tree
, bool);
54 static tree
pointer_diff (location_t
, tree
, tree
, tree
, tsubst_flags_t
);
55 static tree
get_delta_difference (tree
, tree
, bool, bool, tsubst_flags_t
);
56 static void casts_away_constness_r (tree
*, tree
*, tsubst_flags_t
);
57 static bool casts_away_constness (tree
, tree
, tsubst_flags_t
);
58 static bool maybe_warn_about_returning_address_of_local (tree
);
59 static tree
lookup_destructor (tree
, tree
, tree
, tsubst_flags_t
);
60 static void error_args_num (location_t
, tree
, bool);
61 static int convert_arguments (tree
, vec
<tree
, va_gc
> **, tree
, int,
64 /* Do `exp = require_complete_type (exp);' to make sure exp
65 does not have an incomplete type. (That includes void types.)
66 Returns error_mark_node if the VALUE does not have
67 complete type when this function returns. */
70 require_complete_type_sfinae (tree value
, tsubst_flags_t complain
)
74 if (processing_template_decl
|| value
== error_mark_node
)
77 if (TREE_CODE (value
) == OVERLOAD
)
78 type
= unknown_type_node
;
80 type
= TREE_TYPE (value
);
82 if (type
== error_mark_node
)
83 return error_mark_node
;
85 /* First, detect a valid value with a complete type. */
86 if (COMPLETE_TYPE_P (type
))
89 if (complete_type_or_maybe_complain (type
, value
, complain
))
92 return error_mark_node
;
96 require_complete_type (tree value
)
98 return require_complete_type_sfinae (value
, tf_warning_or_error
);
101 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
102 a template instantiation, do the instantiation. Returns TYPE,
103 whether or not it could be completed, unless something goes
104 horribly wrong, in which case the error_mark_node is returned. */
107 complete_type (tree type
)
109 if (type
== NULL_TREE
)
110 /* Rather than crash, we return something sure to cause an error
112 return error_mark_node
;
114 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
116 else if (TREE_CODE (type
) == ARRAY_TYPE
)
118 tree t
= complete_type (TREE_TYPE (type
));
119 unsigned int needs_constructing
, has_nontrivial_dtor
;
120 if (COMPLETE_TYPE_P (t
) && !dependent_type_p (type
))
123 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
125 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
126 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
128 TYPE_NEEDS_CONSTRUCTING (t
) = needs_constructing
;
129 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = has_nontrivial_dtor
;
132 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
133 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
138 /* Like complete_type, but issue an error if the TYPE cannot be completed.
139 VALUE is used for informative diagnostics.
140 Returns NULL_TREE if the type cannot be made complete. */
143 complete_type_or_maybe_complain (tree type
, tree value
, tsubst_flags_t complain
)
145 type
= complete_type (type
);
146 if (type
== error_mark_node
)
147 /* We already issued an error. */
149 else if (!COMPLETE_TYPE_P (type
))
151 if (complain
& tf_error
)
152 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
160 complete_type_or_else (tree type
, tree value
)
162 return complete_type_or_maybe_complain (type
, value
, tf_warning_or_error
);
165 /* Return truthvalue of whether type of EXP is instantiated. */
168 type_unknown_p (const_tree exp
)
170 return (TREE_CODE (exp
) == TREE_LIST
171 || TREE_TYPE (exp
) == unknown_type_node
);
175 /* Return the common type of two parameter lists.
176 We assume that comptypes has already been done and returned 1;
177 if that isn't so, this may crash.
179 As an optimization, free the space we allocate if the parameter
180 lists are already common. */
183 commonparms (tree p1
, tree p2
)
185 tree oldargs
= p1
, newargs
, n
;
189 len
= list_length (p1
);
190 newargs
= tree_last (p1
);
192 if (newargs
== void_list_node
)
201 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
206 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
208 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
210 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
213 else if (! TREE_PURPOSE (p1
))
215 if (TREE_PURPOSE (p2
))
217 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
223 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
225 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
227 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
230 TREE_VALUE (n
) = merge_types (TREE_VALUE (p1
), TREE_VALUE (p2
));
233 TREE_VALUE (n
) = TREE_VALUE (p1
);
241 /* Given a type, perhaps copied for a typedef,
242 find the "original" version of it. */
244 original_type (tree t
)
246 int quals
= cp_type_quals (t
);
247 while (t
!= error_mark_node
248 && TYPE_NAME (t
) != NULL_TREE
)
250 tree x
= TYPE_NAME (t
);
251 if (TREE_CODE (x
) != TYPE_DECL
)
253 x
= DECL_ORIGINAL_TYPE (x
);
258 return cp_build_qualified_type (t
, quals
);
261 /* Return the common type for two arithmetic types T1 and T2 under the
262 usual arithmetic conversions. The default conversions have already
263 been applied, and enumerated types converted to their compatible
267 cp_common_type (tree t1
, tree t2
)
269 enum tree_code code1
= TREE_CODE (t1
);
270 enum tree_code code2
= TREE_CODE (t2
);
275 /* In what follows, we slightly generalize the rules given in [expr] so
276 as to deal with `long long' and `complex'. First, merge the
278 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
280 if (SCOPED_ENUM_P (t1
) || SCOPED_ENUM_P (t2
))
282 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
283 return build_type_attribute_variant (t1
, attributes
);
288 /* FIXME: Attributes. */
289 gcc_assert (ARITHMETIC_TYPE_P (t1
)
290 || VECTOR_TYPE_P (t1
)
291 || UNSCOPED_ENUM_P (t1
));
292 gcc_assert (ARITHMETIC_TYPE_P (t2
)
293 || VECTOR_TYPE_P (t2
)
294 || UNSCOPED_ENUM_P (t2
));
296 /* If one type is complex, form the common type of the non-complex
297 components, then make that complex. Use T1 or T2 if it is the
299 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
301 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
302 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
304 = type_after_usual_arithmetic_conversions (subtype1
, subtype2
);
306 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
307 return build_type_attribute_variant (t1
, attributes
);
308 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
309 return build_type_attribute_variant (t2
, attributes
);
311 return build_type_attribute_variant (build_complex_type (subtype
),
315 if (code1
== VECTOR_TYPE
)
317 /* When we get here we should have two vectors of the same size.
318 Just prefer the unsigned one if present. */
319 if (TYPE_UNSIGNED (t1
))
320 return build_type_attribute_variant (t1
, attributes
);
322 return build_type_attribute_variant (t2
, attributes
);
325 /* If only one is real, use it as the result. */
326 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
327 return build_type_attribute_variant (t1
, attributes
);
328 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
329 return build_type_attribute_variant (t2
, attributes
);
331 /* Both real or both integers; use the one with greater precision. */
332 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
333 return build_type_attribute_variant (t1
, attributes
);
334 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
335 return build_type_attribute_variant (t2
, attributes
);
337 /* The types are the same; no need to do anything fancy. */
338 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
339 return build_type_attribute_variant (t1
, attributes
);
341 if (code1
!= REAL_TYPE
)
343 /* If one is unsigned long long, then convert the other to unsigned
345 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
346 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
347 return build_type_attribute_variant (long_long_unsigned_type_node
,
349 /* If one is a long long, and the other is an unsigned long, and
350 long long can represent all the values of an unsigned long, then
351 convert to a long long. Otherwise, convert to an unsigned long
352 long. Otherwise, if either operand is long long, convert the
355 Since we're here, we know the TYPE_PRECISION is the same;
356 therefore converting to long long cannot represent all the values
357 of an unsigned long, so we choose unsigned long long in that
359 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
360 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
362 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
363 ? long_long_unsigned_type_node
364 : long_long_integer_type_node
);
365 return build_type_attribute_variant (t
, attributes
);
368 /* Go through the same procedure, but for longs. */
369 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
370 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
371 return build_type_attribute_variant (long_unsigned_type_node
,
373 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
374 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
376 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
377 ? long_unsigned_type_node
: long_integer_type_node
);
378 return build_type_attribute_variant (t
, attributes
);
381 /* For __intN types, either the type is __int128 (and is lower
382 priority than the types checked above, but higher than other
383 128-bit types) or it's known to not be the same size as other
384 types (enforced in toplev.c). Prefer the unsigned type. */
385 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
387 if (int_n_enabled_p
[i
]
388 && (same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].signed_type
)
389 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].signed_type
)
390 || same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].unsigned_type
)
391 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].unsigned_type
)))
393 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
394 ? int_n_trees
[i
].unsigned_type
395 : int_n_trees
[i
].signed_type
);
396 return build_type_attribute_variant (t
, attributes
);
400 /* Otherwise prefer the unsigned one. */
401 if (TYPE_UNSIGNED (t1
))
402 return build_type_attribute_variant (t1
, attributes
);
404 return build_type_attribute_variant (t2
, attributes
);
408 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
409 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
410 return build_type_attribute_variant (long_double_type_node
,
412 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
413 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
414 return build_type_attribute_variant (double_type_node
,
416 if (same_type_p (TYPE_MAIN_VARIANT (t1
), float_type_node
)
417 || same_type_p (TYPE_MAIN_VARIANT (t2
), float_type_node
))
418 return build_type_attribute_variant (float_type_node
,
421 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
422 the standard C++ floating-point types. Logic earlier in this
423 function has already eliminated the possibility that
424 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
425 compelling reason to choose one or the other. */
426 return build_type_attribute_variant (t1
, attributes
);
430 /* T1 and T2 are arithmetic or enumeration types. Return the type
431 that will result from the "usual arithmetic conversions" on T1 and
432 T2 as described in [expr]. */
435 type_after_usual_arithmetic_conversions (tree t1
, tree t2
)
437 gcc_assert (ARITHMETIC_TYPE_P (t1
)
438 || VECTOR_TYPE_P (t1
)
439 || UNSCOPED_ENUM_P (t1
));
440 gcc_assert (ARITHMETIC_TYPE_P (t2
)
441 || VECTOR_TYPE_P (t2
)
442 || UNSCOPED_ENUM_P (t2
));
444 /* Perform the integral promotions. We do not promote real types here. */
445 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t1
)
446 && INTEGRAL_OR_ENUMERATION_TYPE_P (t2
))
448 t1
= type_promotes_to (t1
);
449 t2
= type_promotes_to (t2
);
452 return cp_common_type (t1
, t2
);
456 composite_pointer_error (diagnostic_t kind
, tree t1
, tree t2
,
457 composite_pointer_operation operation
)
462 emit_diagnostic (kind
, input_location
, 0,
463 "comparison between "
464 "distinct pointer types %qT and %qT lacks a cast",
468 emit_diagnostic (kind
, input_location
, 0,
469 "conversion between "
470 "distinct pointer types %qT and %qT lacks a cast",
473 case CPO_CONDITIONAL_EXPR
:
474 emit_diagnostic (kind
, input_location
, 0,
475 "conditional expression between "
476 "distinct pointer types %qT and %qT lacks a cast",
484 /* Subroutine of composite_pointer_type to implement the recursive
485 case. See that function for documentation of the parameters. */
488 composite_pointer_type_r (tree t1
, tree t2
,
489 composite_pointer_operation operation
,
490 tsubst_flags_t complain
)
497 /* Determine the types pointed to by T1 and T2. */
500 pointee1
= TREE_TYPE (t1
);
501 pointee2
= TREE_TYPE (t2
);
505 pointee1
= TYPE_PTRMEM_POINTED_TO_TYPE (t1
);
506 pointee2
= TYPE_PTRMEM_POINTED_TO_TYPE (t2
);
511 Otherwise, the composite pointer type is a pointer type
512 similar (_conv.qual_) to the type of one of the operands,
513 with a cv-qualification signature (_conv.qual_) that is the
514 union of the cv-qualification signatures of the operand
516 if (same_type_ignoring_top_level_qualifiers_p (pointee1
, pointee2
))
517 result_type
= pointee1
;
518 else if ((TYPE_PTR_P (pointee1
) && TYPE_PTR_P (pointee2
))
519 || (TYPE_PTRMEM_P (pointee1
) && TYPE_PTRMEM_P (pointee2
)))
521 result_type
= composite_pointer_type_r (pointee1
, pointee2
, operation
,
523 if (result_type
== error_mark_node
)
524 return error_mark_node
;
528 if (complain
& tf_error
)
529 composite_pointer_error (DK_PERMERROR
, t1
, t2
, operation
);
531 return error_mark_node
;
532 result_type
= void_type_node
;
534 result_type
= cp_build_qualified_type (result_type
,
535 (cp_type_quals (pointee1
)
536 | cp_type_quals (pointee2
)));
537 /* If the original types were pointers to members, so is the
539 if (TYPE_PTRMEM_P (t1
))
541 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
542 TYPE_PTRMEM_CLASS_TYPE (t2
)))
544 if (complain
& tf_error
)
545 composite_pointer_error (DK_PERMERROR
, t1
, t2
, operation
);
547 return error_mark_node
;
549 result_type
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
553 result_type
= build_pointer_type (result_type
);
555 /* Merge the attributes. */
556 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
557 return build_type_attribute_variant (result_type
, attributes
);
560 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
561 ARG1 and ARG2 are the values with those types. The OPERATION is to
562 describe the operation between the pointer types,
563 in case an error occurs.
565 This routine also implements the computation of a common type for
566 pointers-to-members as per [expr.eq]. */
569 composite_pointer_type (tree t1
, tree t2
, tree arg1
, tree arg2
,
570 composite_pointer_operation operation
,
571 tsubst_flags_t complain
)
578 If one operand is a null pointer constant, the composite pointer
579 type is the type of the other operand. */
580 if (null_ptr_cst_p (arg1
))
582 if (null_ptr_cst_p (arg2
))
589 If one of the operands has type "pointer to cv1 void*", then
590 the other has type "pointer to cv2T", and the composite pointer
591 type is "pointer to cv12 void", where cv12 is the union of cv1
594 If either type is a pointer to void, make sure it is T1. */
595 if (TYPE_PTR_P (t2
) && VOID_TYPE_P (TREE_TYPE (t2
)))
598 /* Now, if T1 is a pointer to void, merge the qualifiers. */
599 if (TYPE_PTR_P (t1
) && VOID_TYPE_P (TREE_TYPE (t1
)))
604 if (TYPE_PTRFN_P (t2
))
606 if (complain
& tf_error
)
611 pedwarn (input_location
, OPT_Wpedantic
,
612 "ISO C++ forbids comparison between pointer "
613 "of type %<void *%> and pointer-to-function");
616 pedwarn (input_location
, OPT_Wpedantic
,
617 "ISO C++ forbids conversion between pointer "
618 "of type %<void *%> and pointer-to-function");
620 case CPO_CONDITIONAL_EXPR
:
621 pedwarn (input_location
, OPT_Wpedantic
,
622 "ISO C++ forbids conditional expression between "
623 "pointer of type %<void *%> and "
624 "pointer-to-function");
631 return error_mark_node
;
634 = cp_build_qualified_type (void_type_node
,
635 (cp_type_quals (TREE_TYPE (t1
))
636 | cp_type_quals (TREE_TYPE (t2
))));
637 result_type
= build_pointer_type (result_type
);
638 /* Merge the attributes. */
639 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
640 return build_type_attribute_variant (result_type
, attributes
);
643 if (c_dialect_objc () && TYPE_PTR_P (t1
)
646 if (objc_have_common_type (t1
, t2
, -3, NULL_TREE
))
647 return objc_common_type (t1
, t2
);
650 /* if T1 or T2 is "pointer to noexcept function" and the other type is
651 "pointer to function", where the function types are otherwise the same,
652 "pointer to function" */
653 if (fnptr_conv_p (t1
, t2
))
655 if (fnptr_conv_p (t2
, t1
))
658 /* [expr.eq] permits the application of a pointer conversion to
659 bring the pointers to a common type. */
660 if (TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
)
661 && CLASS_TYPE_P (TREE_TYPE (t1
))
662 && CLASS_TYPE_P (TREE_TYPE (t2
))
663 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1
),
666 class1
= TREE_TYPE (t1
);
667 class2
= TREE_TYPE (t2
);
669 if (DERIVED_FROM_P (class1
, class2
))
670 t2
= (build_pointer_type
671 (cp_build_qualified_type (class1
, cp_type_quals (class2
))));
672 else if (DERIVED_FROM_P (class2
, class1
))
673 t1
= (build_pointer_type
674 (cp_build_qualified_type (class2
, cp_type_quals (class1
))));
677 if (complain
& tf_error
)
678 composite_pointer_error (DK_ERROR
, t1
, t2
, operation
);
679 return error_mark_node
;
682 /* [expr.eq] permits the application of a pointer-to-member
683 conversion to change the class type of one of the types. */
684 else if (TYPE_PTRMEM_P (t1
)
685 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
686 TYPE_PTRMEM_CLASS_TYPE (t2
)))
688 class1
= TYPE_PTRMEM_CLASS_TYPE (t1
);
689 class2
= TYPE_PTRMEM_CLASS_TYPE (t2
);
691 if (DERIVED_FROM_P (class1
, class2
))
692 t1
= build_ptrmem_type (class2
, TYPE_PTRMEM_POINTED_TO_TYPE (t1
));
693 else if (DERIVED_FROM_P (class2
, class1
))
694 t2
= build_ptrmem_type (class1
, TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
697 if (complain
& tf_error
)
701 error ("comparison between distinct "
702 "pointer-to-member types %qT and %qT lacks a cast",
706 error ("conversion between distinct "
707 "pointer-to-member types %qT and %qT lacks a cast",
710 case CPO_CONDITIONAL_EXPR
:
711 error ("conditional expression between distinct "
712 "pointer-to-member types %qT and %qT lacks a cast",
718 return error_mark_node
;
722 return composite_pointer_type_r (t1
, t2
, operation
, complain
);
725 /* Return the merged type of two types.
726 We assume that comptypes has already been done and returned 1;
727 if that isn't so, this may crash.
729 This just combines attributes and default arguments; any other
730 differences would cause the two types to compare unalike. */
733 merge_types (tree t1
, tree t2
)
735 enum tree_code code1
;
736 enum tree_code code2
;
739 /* Save time if the two types are the same. */
742 if (original_type (t1
) == original_type (t2
))
745 /* If one type is nonsense, use the other. */
746 if (t1
== error_mark_node
)
748 if (t2
== error_mark_node
)
751 /* Handle merging an auto redeclaration with a previous deduced
756 /* Merge the attributes. */
757 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
759 if (TYPE_PTRMEMFUNC_P (t1
))
760 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
761 if (TYPE_PTRMEMFUNC_P (t2
))
762 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
764 code1
= TREE_CODE (t1
);
765 code2
= TREE_CODE (t2
);
768 gcc_assert (code1
== TYPENAME_TYPE
|| code2
== TYPENAME_TYPE
);
769 if (code1
== TYPENAME_TYPE
)
771 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
772 code1
= TREE_CODE (t1
);
776 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
777 code2
= TREE_CODE (t2
);
785 /* For two pointers, do this recursively on the target type. */
787 tree target
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
788 int quals
= cp_type_quals (t1
);
790 if (code1
== POINTER_TYPE
)
792 t1
= build_pointer_type (target
);
793 if (TREE_CODE (target
) == METHOD_TYPE
)
794 t1
= build_ptrmemfunc_type (t1
);
797 t1
= cp_build_reference_type (target
, TYPE_REF_IS_RVALUE (t1
));
798 t1
= build_type_attribute_variant (t1
, attributes
);
799 t1
= cp_build_qualified_type (t1
, quals
);
808 quals
= cp_type_quals (t1
);
809 pointee
= merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1
),
810 TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
811 t1
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
813 t1
= cp_build_qualified_type (t1
, quals
);
819 tree elt
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
820 /* Save space: see if the result is identical to one of the args. */
821 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
822 return build_type_attribute_variant (t1
, attributes
);
823 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
824 return build_type_attribute_variant (t2
, attributes
);
825 /* Merge the element types, and have a size if either arg has one. */
826 t1
= build_cplus_array_type
827 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
832 /* Function types: prefer the one that specified arg types.
833 If both do, merge the arg types. Also merge the return types. */
835 tree valtype
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
836 tree p1
= TYPE_ARG_TYPES (t1
);
837 tree p2
= TYPE_ARG_TYPES (t2
);
840 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
842 /* Save space: see if the result is identical to one of the args. */
843 if (valtype
== TREE_TYPE (t1
) && ! p2
)
844 return cp_build_type_attribute_variant (t1
, attributes
);
845 if (valtype
== TREE_TYPE (t2
) && ! p1
)
846 return cp_build_type_attribute_variant (t2
, attributes
);
848 /* Simple way if one arg fails to specify argument types. */
849 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
851 else if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
854 parms
= commonparms (p1
, p2
);
856 rval
= build_function_type (valtype
, parms
);
857 gcc_assert (type_memfn_quals (t1
) == type_memfn_quals (t2
));
858 gcc_assert (type_memfn_rqual (t1
) == type_memfn_rqual (t2
));
859 rval
= apply_memfn_quals (rval
,
860 type_memfn_quals (t1
),
861 type_memfn_rqual (t1
));
862 raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
863 TYPE_RAISES_EXCEPTIONS (t2
));
864 t1
= build_exception_variant (rval
, raises
);
865 if (late_return_type_p
)
866 TYPE_HAS_LATE_RETURN_TYPE (t1
) = 1;
872 /* Get this value the long way, since TYPE_METHOD_BASETYPE
873 is just the main variant of this. */
874 tree basetype
= class_of_this_parm (t2
);
875 tree raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
876 TYPE_RAISES_EXCEPTIONS (t2
));
877 cp_ref_qualifier rqual
= type_memfn_rqual (t1
);
879 bool late_return_type_1_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
880 bool late_return_type_2_p
= TYPE_HAS_LATE_RETURN_TYPE (t2
);
882 /* If this was a member function type, get back to the
883 original type of type member function (i.e., without
884 the class instance variable up front. */
885 t1
= build_function_type (TREE_TYPE (t1
),
886 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
887 t2
= build_function_type (TREE_TYPE (t2
),
888 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
889 t3
= merge_types (t1
, t2
);
890 t3
= build_method_type_directly (basetype
, TREE_TYPE (t3
),
891 TYPE_ARG_TYPES (t3
));
892 t1
= build_exception_variant (t3
, raises
);
893 t1
= build_ref_qualified_type (t1
, rqual
);
894 if (late_return_type_1_p
)
895 TYPE_HAS_LATE_RETURN_TYPE (t1
) = 1;
896 if (late_return_type_2_p
)
897 TYPE_HAS_LATE_RETURN_TYPE (t2
) = 1;
902 /* There is no need to merge attributes into a TYPENAME_TYPE.
903 When the type is instantiated it will have whatever
904 attributes result from the instantiation. */
910 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
912 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
915 return cp_build_type_attribute_variant (t1
, attributes
);
918 /* Return the ARRAY_TYPE type without its domain. */
921 strip_array_domain (tree type
)
924 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
925 if (TYPE_DOMAIN (type
) == NULL_TREE
)
927 t2
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
928 return cp_build_type_attribute_variant (t2
, TYPE_ATTRIBUTES (type
));
931 /* Wrapper around cp_common_type that is used by c-common.c and other
932 front end optimizations that remove promotions.
934 Return the common type for two arithmetic types T1 and T2 under the
935 usual arithmetic conversions. The default conversions have already
936 been applied, and enumerated types converted to their compatible
940 common_type (tree t1
, tree t2
)
942 /* If one type is nonsense, use the other */
943 if (t1
== error_mark_node
)
945 if (t2
== error_mark_node
)
948 return cp_common_type (t1
, t2
);
951 /* Return the common type of two pointer types T1 and T2. This is the
952 type for the result of most arithmetic operations if the operands
953 have the given two types.
955 We assume that comp_target_types has already been done and returned
956 nonzero; if that isn't so, this may crash. */
959 common_pointer_type (tree t1
, tree t2
)
961 gcc_assert ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
962 || (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
963 || (TYPE_PTRMEMFUNC_P (t1
) && TYPE_PTRMEMFUNC_P (t2
)));
965 return composite_pointer_type (t1
, t2
, error_mark_node
, error_mark_node
,
966 CPO_CONVERSION
, tf_warning_or_error
);
969 /* Compare two exception specifier types for exactness or subsetness, if
970 allowed. Returns false for mismatch, true for match (same, or
973 [except.spec] "If a class X ... objects of class X or any class publicly
974 and unambiguously derived from X. Similarly, if a pointer type Y * ...
975 exceptions of type Y * or that are pointers to any type publicly and
976 unambiguously derived from Y. Otherwise a function only allows exceptions
977 that have the same type ..."
978 This does not mention cv qualifiers and is different to what throw
979 [except.throw] and catch [except.catch] will do. They will ignore the
980 top level cv qualifiers, and allow qualifiers in the pointer to class
983 We implement the letter of the standard. */
986 comp_except_types (tree a
, tree b
, bool exact
)
988 if (same_type_p (a
, b
))
992 if (cp_type_quals (a
) || cp_type_quals (b
))
995 if (TYPE_PTR_P (a
) && TYPE_PTR_P (b
))
999 if (cp_type_quals (a
) || cp_type_quals (b
))
1003 if (TREE_CODE (a
) != RECORD_TYPE
1004 || TREE_CODE (b
) != RECORD_TYPE
)
1007 if (publicly_uniquely_derived_p (a
, b
))
1013 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
1014 If EXACT is ce_derived, T2 can be stricter than T1 (according to 15.4/5).
1015 If EXACT is ce_type, the C++17 type compatibility rules apply.
1016 If EXACT is ce_normal, the compatibility rules in 15.4/3 apply.
1017 If EXACT is ce_exact, the specs must be exactly the same. Exception lists
1018 are unordered, but we've already filtered out duplicates. Most lists will
1019 be in order, we should try to make use of that. */
1022 comp_except_specs (const_tree t1
, const_tree t2
, int exact
)
1031 /* First handle noexcept. */
1032 if (exact
< ce_exact
)
1034 if (exact
== ce_type
1035 && (canonical_eh_spec (CONST_CAST_TREE (t1
))
1036 == canonical_eh_spec (CONST_CAST_TREE (t2
))))
1039 /* noexcept(false) is compatible with no exception-specification,
1040 and less strict than any spec. */
1041 if (t1
== noexcept_false_spec
)
1042 return t2
== NULL_TREE
|| exact
== ce_derived
;
1043 /* Even a derived noexcept(false) is compatible with no
1044 exception-specification. */
1045 if (t2
== noexcept_false_spec
)
1046 return t1
== NULL_TREE
;
1048 /* Otherwise, if we aren't looking for an exact match, noexcept is
1049 equivalent to throw(). */
1050 if (t1
== noexcept_true_spec
)
1051 t1
= empty_except_spec
;
1052 if (t2
== noexcept_true_spec
)
1053 t2
= empty_except_spec
;
1056 /* If any noexcept is left, it is only comparable to itself;
1057 either we're looking for an exact match or we're redeclaring a
1058 template with dependent noexcept. */
1059 if ((t1
&& TREE_PURPOSE (t1
))
1060 || (t2
&& TREE_PURPOSE (t2
)))
1062 && cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)));
1064 if (t1
== NULL_TREE
) /* T1 is ... */
1065 return t2
== NULL_TREE
|| exact
== ce_derived
;
1066 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
1067 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
1068 if (t2
== NULL_TREE
) /* T2 is ... */
1070 if (TREE_VALUE (t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
1071 return exact
== ce_derived
;
1073 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
1074 Count how many we find, to determine exactness. For exact matching and
1075 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
1077 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
1079 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
1081 tree a
= TREE_VALUE (probe
);
1082 tree b
= TREE_VALUE (t2
);
1084 if (comp_except_types (a
, b
, exact
))
1086 if (probe
== base
&& exact
> ce_derived
)
1087 base
= TREE_CHAIN (probe
);
1092 if (probe
== NULL_TREE
)
1095 return exact
== ce_derived
|| base
== NULL_TREE
|| length
== list_length (t1
);
1098 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
1099 [] can match [size]. */
1102 comp_array_types (const_tree t1
, const_tree t2
, bool allow_redeclaration
)
1111 /* The type of the array elements must be the same. */
1112 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1115 d1
= TYPE_DOMAIN (t1
);
1116 d2
= TYPE_DOMAIN (t2
);
1121 /* If one of the arrays is dimensionless, and the other has a
1122 dimension, they are of different types. However, it is valid to
1130 declarations for an array object can specify
1131 array types that differ by the presence or absence of a major
1132 array bound (_dcl.array_). */
1134 return allow_redeclaration
;
1136 /* Check that the dimensions are the same. */
1138 if (!cp_tree_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
)))
1140 max1
= TYPE_MAX_VALUE (d1
);
1141 max2
= TYPE_MAX_VALUE (d2
);
1143 if (!cp_tree_equal (max1
, max2
))
1149 /* Compare the relative position of T1 and T2 into their respective
1150 template parameter list.
1151 T1 and T2 must be template parameter types.
1152 Return TRUE if T1 and T2 have the same position, FALSE otherwise. */
1155 comp_template_parms_position (tree t1
, tree t2
)
1157 tree index1
, index2
;
1158 gcc_assert (t1
&& t2
1159 && TREE_CODE (t1
) == TREE_CODE (t2
)
1160 && (TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
1161 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
1162 || TREE_CODE (t1
) == TEMPLATE_TYPE_PARM
));
1164 index1
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t1
));
1165 index2
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t2
));
1167 /* Then compare their relative position. */
1168 if (TEMPLATE_PARM_IDX (index1
) != TEMPLATE_PARM_IDX (index2
)
1169 || TEMPLATE_PARM_LEVEL (index1
) != TEMPLATE_PARM_LEVEL (index2
)
1170 || (TEMPLATE_PARM_PARAMETER_PACK (index1
)
1171 != TEMPLATE_PARM_PARAMETER_PACK (index2
)))
1174 /* In C++14 we can end up comparing 'auto' to a normal template
1175 parameter. Don't confuse them. */
1176 if (cxx_dialect
>= cxx14
&& (is_auto (t1
) || is_auto (t2
)))
1177 return TYPE_IDENTIFIER (t1
) == TYPE_IDENTIFIER (t2
);
1182 /* Subroutine in comptypes. */
1185 structural_comptypes (tree t1
, tree t2
, int strict
)
1190 /* Suppress errors caused by previously reported errors. */
1191 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1194 gcc_assert (TYPE_P (t1
) && TYPE_P (t2
));
1196 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1197 current instantiation. */
1198 if (TREE_CODE (t1
) == TYPENAME_TYPE
)
1199 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
1201 if (TREE_CODE (t2
) == TYPENAME_TYPE
)
1202 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
1204 if (TYPE_PTRMEMFUNC_P (t1
))
1205 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
1206 if (TYPE_PTRMEMFUNC_P (t2
))
1207 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
1209 /* Different classes of types can't be compatible. */
1210 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1213 /* Qualifiers must match. For array types, we will check when we
1214 recur on the array element types. */
1215 if (TREE_CODE (t1
) != ARRAY_TYPE
1216 && cp_type_quals (t1
) != cp_type_quals (t2
))
1218 if (TREE_CODE (t1
) == FUNCTION_TYPE
1219 && type_memfn_quals (t1
) != type_memfn_quals (t2
))
1221 /* Need to check this before TYPE_MAIN_VARIANT.
1222 FIXME function qualifiers should really change the main variant. */
1223 if (TREE_CODE (t1
) == FUNCTION_TYPE
1224 || TREE_CODE (t1
) == METHOD_TYPE
)
1226 if (type_memfn_rqual (t1
) != type_memfn_rqual (t2
))
1228 if (flag_noexcept_type
1229 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (t1
),
1230 TYPE_RAISES_EXCEPTIONS (t2
),
1235 /* Allow for two different type nodes which have essentially the same
1236 definition. Note that we already checked for equality of the type
1237 qualifiers (just above). */
1239 if (TREE_CODE (t1
) != ARRAY_TYPE
1240 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1244 /* Compare the types. Break out if they could be the same. */
1245 switch (TREE_CODE (t1
))
1249 /* All void and bool types are the same. */
1253 case FIXED_POINT_TYPE
:
1255 /* With these nodes, we can't determine type equivalence by
1256 looking at what is stored in the nodes themselves, because
1257 two nodes might have different TYPE_MAIN_VARIANTs but still
1258 represent the same type. For example, wchar_t and int could
1259 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1260 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1261 and are distinct types. On the other hand, int and the
1264 typedef int INT __attribute((may_alias));
1266 have identical properties, different TYPE_MAIN_VARIANTs, but
1267 represent the same type. The canonical type system keeps
1268 track of equivalence in this case, so we fall back on it. */
1269 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1271 case TEMPLATE_TEMPLATE_PARM
:
1272 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1273 if (!comp_template_parms_position (t1
, t2
))
1275 if (!comp_template_parms
1276 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1277 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1279 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1281 /* Don't check inheritance. */
1282 strict
= COMPARE_STRICT
;
1287 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1288 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1289 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
1290 && comp_template_args (TYPE_TI_ARGS (t1
), TYPE_TI_ARGS (t2
)))
1293 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1295 else if ((strict
& COMPARE_DERIVED
) && DERIVED_FROM_P (t2
, t1
))
1301 if (!comptypes (TYPE_OFFSET_BASETYPE (t1
), TYPE_OFFSET_BASETYPE (t2
),
1302 strict
& ~COMPARE_REDECLARATION
))
1304 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1308 case REFERENCE_TYPE
:
1309 if (TYPE_REF_IS_RVALUE (t1
) != TYPE_REF_IS_RVALUE (t2
))
1311 /* fall through to checks for pointer types */
1315 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1316 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1322 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1324 if (!compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)))
1329 /* Target types must match incl. qualifiers. */
1330 if (!comp_array_types (t1
, t2
, !!(strict
& COMPARE_REDECLARATION
)))
1334 case TEMPLATE_TYPE_PARM
:
1335 /* If T1 and T2 don't have the same relative position in their
1336 template parameters set, they can't be equal. */
1337 if (!comp_template_parms_position (t1
, t2
))
1339 /* Constrained 'auto's are distinct from parms that don't have the same
1341 if (!equivalent_placeholder_constraints (t1
, t2
))
1346 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1347 TYPENAME_TYPE_FULLNAME (t2
)))
1349 /* Qualifiers don't matter on scopes. */
1350 if (!same_type_ignoring_top_level_qualifiers_p (TYPE_CONTEXT (t1
),
1355 case UNBOUND_CLASS_TEMPLATE
:
1356 if (!cp_tree_equal (TYPE_IDENTIFIER (t1
), TYPE_IDENTIFIER (t2
)))
1358 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1363 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1368 if (TYPE_VECTOR_SUBPARTS (t1
) != TYPE_VECTOR_SUBPARTS (t2
)
1369 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1373 case TYPE_PACK_EXPANSION
:
1374 return (same_type_p (PACK_EXPANSION_PATTERN (t1
),
1375 PACK_EXPANSION_PATTERN (t2
))
1376 && comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
1377 PACK_EXPANSION_EXTRA_ARGS (t2
)));
1380 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1
)
1381 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2
)
1382 || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1
)
1383 != DECLTYPE_FOR_LAMBDA_CAPTURE (t2
))
1384 || (DECLTYPE_FOR_LAMBDA_PROXY (t1
)
1385 != DECLTYPE_FOR_LAMBDA_PROXY (t2
))
1386 || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1
),
1387 DECLTYPE_TYPE_EXPR (t2
)))
1391 case UNDERLYING_TYPE
:
1392 return same_type_p (UNDERLYING_TYPE_TYPE (t1
),
1393 UNDERLYING_TYPE_TYPE (t2
));
1399 /* If we get here, we know that from a target independent POV the
1400 types are the same. Make sure the target attributes are also
1402 return comp_type_attributes (t1
, t2
);
1405 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1406 is a bitwise-or of the COMPARE_* flags. */
1409 comptypes (tree t1
, tree t2
, int strict
)
1411 if (strict
== COMPARE_STRICT
)
1416 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1419 if (TYPE_STRUCTURAL_EQUALITY_P (t1
) || TYPE_STRUCTURAL_EQUALITY_P (t2
))
1420 /* At least one of the types requires structural equality, so
1421 perform a deep check. */
1422 return structural_comptypes (t1
, t2
, strict
);
1424 if (flag_checking
&& USE_CANONICAL_TYPES
)
1426 bool result
= structural_comptypes (t1
, t2
, strict
);
1428 if (result
&& TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1429 /* The two types are structurally equivalent, but their
1430 canonical types were different. This is a failure of the
1431 canonical type propagation code.*/
1433 ("canonical types differ for identical types %T and %T",
1435 else if (!result
&& TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
1436 /* Two types are structurally different, but the canonical
1437 types are the same. This means we were over-eager in
1438 assigning canonical types. */
1440 ("same canonical type node for different types %T and %T",
1445 if (!flag_checking
&& USE_CANONICAL_TYPES
)
1446 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1448 return structural_comptypes (t1
, t2
, strict
);
1450 else if (strict
== COMPARE_STRUCTURAL
)
1451 return structural_comptypes (t1
, t2
, COMPARE_STRICT
);
1453 return structural_comptypes (t1
, t2
, strict
);
1456 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
1457 top-level qualifiers. */
1460 same_type_ignoring_top_level_qualifiers_p (tree type1
, tree type2
)
1462 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1465 type1
= cp_build_qualified_type (type1
, TYPE_UNQUALIFIED
);
1466 type2
= cp_build_qualified_type (type2
, TYPE_UNQUALIFIED
);
1467 return same_type_p (type1
, type2
);
1470 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1473 at_least_as_qualified_p (const_tree type1
, const_tree type2
)
1475 int q1
= cp_type_quals (type1
);
1476 int q2
= cp_type_quals (type2
);
1478 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1479 return (q1
& q2
) == q2
;
1482 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1483 more cv-qualified that TYPE1, and 0 otherwise. */
1486 comp_cv_qualification (int q1
, int q2
)
1491 if ((q1
& q2
) == q2
)
1493 else if ((q1
& q2
) == q1
)
1500 comp_cv_qualification (const_tree type1
, const_tree type2
)
1502 int q1
= cp_type_quals (type1
);
1503 int q2
= cp_type_quals (type2
);
1504 return comp_cv_qualification (q1
, q2
);
1507 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1508 subset of the cv-qualification signature of TYPE2, and the types
1509 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1512 comp_cv_qual_signature (tree type1
, tree type2
)
1514 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1516 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1522 /* Subroutines of `comptypes'. */
1524 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1525 equivalent in the sense that functions with those parameter types
1526 can have equivalent types. The two lists must be equivalent,
1527 element by element. */
1530 compparms (const_tree parms1
, const_tree parms2
)
1534 /* An unspecified parmlist matches any specified parmlist
1535 whose argument types don't need default promotions. */
1537 for (t1
= parms1
, t2
= parms2
;
1539 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1541 /* If one parmlist is shorter than the other,
1542 they fail to match. */
1545 if (!same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1552 /* Process a sizeof or alignof expression where the operand is a
1556 cxx_sizeof_or_alignof_type (tree type
, enum tree_code op
, bool complain
)
1561 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
1562 if (type
== error_mark_node
)
1563 return error_mark_node
;
1565 type
= non_reference (type
);
1566 if (TREE_CODE (type
) == METHOD_TYPE
)
1569 pedwarn (input_location
, OPT_Wpointer_arith
,
1570 "invalid application of %qs to a member function",
1571 operator_name_info
[(int) op
].name
);
1573 return error_mark_node
;
1574 value
= size_one_node
;
1577 dependent_p
= dependent_type_p (type
);
1579 complete_type (type
);
1581 /* VLA types will have a non-constant size. In the body of an
1582 uninstantiated template, we don't need to try to compute the
1583 value, because the sizeof expression is not an integral
1584 constant expression in that case. And, if we do try to
1585 compute the value, we'll likely end up with SAVE_EXPRs, which
1586 the template substitution machinery does not expect to see. */
1587 || (processing_template_decl
1588 && COMPLETE_TYPE_P (type
)
1589 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
1591 value
= build_min (op
, size_type_node
, type
);
1592 TREE_READONLY (value
) = 1;
1596 return c_sizeof_or_alignof_type (input_location
, complete_type (type
),
1597 op
== SIZEOF_EXPR
, false,
1601 /* Return the size of the type, without producing any warnings for
1602 types whose size cannot be taken. This routine should be used only
1603 in some other routine that has already produced a diagnostic about
1604 using the size of such a type. */
1606 cxx_sizeof_nowarn (tree type
)
1608 if (TREE_CODE (type
) == FUNCTION_TYPE
1609 || VOID_TYPE_P (type
)
1610 || TREE_CODE (type
) == ERROR_MARK
)
1611 return size_one_node
;
1612 else if (!COMPLETE_TYPE_P (type
))
1613 return size_zero_node
;
1615 return cxx_sizeof_or_alignof_type (type
, SIZEOF_EXPR
, false);
1618 /* Process a sizeof expression where the operand is an expression. */
1621 cxx_sizeof_expr (tree e
, tsubst_flags_t complain
)
1623 if (e
== error_mark_node
)
1624 return error_mark_node
;
1626 if (processing_template_decl
)
1628 e
= build_min (SIZEOF_EXPR
, size_type_node
, e
);
1629 TREE_SIDE_EFFECTS (e
) = 0;
1630 TREE_READONLY (e
) = 1;
1635 /* To get the size of a static data member declared as an array of
1636 unknown bound, we need to instantiate it. */
1638 && VAR_HAD_UNKNOWN_BOUND (e
)
1639 && DECL_TEMPLATE_INSTANTIATION (e
))
1640 instantiate_decl (e
, /*defer_ok*/true, /*expl_inst_mem*/false);
1642 if (TREE_CODE (e
) == PARM_DECL
1643 && DECL_ARRAY_PARAMETER_P (e
)
1644 && (complain
& tf_warning
))
1646 if (warning (OPT_Wsizeof_array_argument
, "%<sizeof%> on array function "
1647 "parameter %qE will return size of %qT", e
, TREE_TYPE (e
)))
1648 inform (DECL_SOURCE_LOCATION (e
), "declared here");
1651 e
= mark_type_use (e
);
1655 if (complain
& tf_error
)
1656 error ("invalid application of %<sizeof%> to a bit-field");
1658 return error_mark_node
;
1661 else if (is_overloaded_fn (e
))
1663 if (complain
& tf_error
)
1664 permerror (input_location
, "ISO C++ forbids applying %<sizeof%> to an expression of "
1667 return error_mark_node
;
1670 else if (type_unknown_p (e
))
1672 if (complain
& tf_error
)
1673 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1675 return error_mark_node
;
1681 return cxx_sizeof_or_alignof_type (e
, SIZEOF_EXPR
, complain
& tf_error
);
1684 /* Implement the __alignof keyword: Return the minimum required
1685 alignment of E, measured in bytes. For VAR_DECL's and
1686 FIELD_DECL's return DECL_ALIGN (which can be set from an
1687 "aligned" __attribute__ specification). */
1690 cxx_alignof_expr (tree e
, tsubst_flags_t complain
)
1694 if (e
== error_mark_node
)
1695 return error_mark_node
;
1697 if (processing_template_decl
)
1699 e
= build_min (ALIGNOF_EXPR
, size_type_node
, e
);
1700 TREE_SIDE_EFFECTS (e
) = 0;
1701 TREE_READONLY (e
) = 1;
1706 e
= mark_type_use (e
);
1709 t
= size_int (DECL_ALIGN_UNIT (e
));
1710 else if (bitfield_p (e
))
1712 if (complain
& tf_error
)
1713 error ("invalid application of %<__alignof%> to a bit-field");
1715 return error_mark_node
;
1718 else if (TREE_CODE (e
) == COMPONENT_REF
1719 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
)
1720 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e
, 1)));
1721 else if (is_overloaded_fn (e
))
1723 if (complain
& tf_error
)
1724 permerror (input_location
, "ISO C++ forbids applying %<__alignof%> to an expression of "
1727 return error_mark_node
;
1728 if (TREE_CODE (e
) == FUNCTION_DECL
)
1729 t
= size_int (DECL_ALIGN_UNIT (e
));
1733 else if (type_unknown_p (e
))
1735 if (complain
& tf_error
)
1736 cxx_incomplete_type_error (e
, TREE_TYPE (e
));
1738 return error_mark_node
;
1742 return cxx_sizeof_or_alignof_type (TREE_TYPE (e
), ALIGNOF_EXPR
,
1743 complain
& tf_error
);
1745 return fold_convert (size_type_node
, t
);
1748 /* Process a sizeof or alignof expression E with code OP where the operand
1749 is an expression. */
1752 cxx_sizeof_or_alignof_expr (tree e
, enum tree_code op
, bool complain
)
1754 if (op
== SIZEOF_EXPR
)
1755 return cxx_sizeof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1757 return cxx_alignof_expr (e
, complain
? tf_warning_or_error
: tf_none
);
1760 /* Build a representation of an expression 'alignas(E).' Return the
1761 folded integer value of E if it is an integral constant expression
1762 that resolves to a valid alignment. If E depends on a template
1763 parameter, return a syntactic representation tree of kind
1764 ALIGNOF_EXPR. Otherwise, return an error_mark_node if the
1765 expression is ill formed, or NULL_TREE if E is NULL_TREE. */
1768 cxx_alignas_expr (tree e
)
1770 if (e
== NULL_TREE
|| e
== error_mark_node
1771 || (!TYPE_P (e
) && !require_potential_rvalue_constant_expression (e
)))
1777 When the alignment-specifier is of the form
1778 alignas(type-id ), it shall have the same effect as
1779 alignas(alignof(type-id )). */
1781 return cxx_sizeof_or_alignof_type (e
, ALIGNOF_EXPR
, false);
1783 /* If we reach this point, it means the alignas expression if of
1784 the form "alignas(assignment-expression)", so we should follow
1785 what is stated by [dcl.align]/2. */
1787 if (value_dependent_expression_p (e
))
1788 /* Leave value-dependent expression alone for now. */
1791 e
= instantiate_non_dependent_expr (e
);
1792 e
= mark_rvalue_use (e
);
1794 /* [dcl.align]/2 says:
1796 the assignment-expression shall be an integral constant
1799 return cxx_constant_value (e
);
1803 /* EXPR is being used in a context that is not a function call.
1808 The expression can be used only as the left-hand operand of a
1809 member function call.
1811 [expr.mptr.operator]
1813 If the result of .* or ->* is a function, then that result can be
1814 used only as the operand for the function call operator ().
1816 by issuing an error message if appropriate. Returns true iff EXPR
1817 violates these rules. */
1820 invalid_nonstatic_memfn_p (location_t loc
, tree expr
, tsubst_flags_t complain
)
1822 if (expr
== NULL_TREE
)
1824 /* Don't enforce this in MS mode. */
1825 if (flag_ms_extensions
)
1827 if (is_overloaded_fn (expr
) && !really_overloaded_fn (expr
))
1828 expr
= get_first_fn (expr
);
1829 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (expr
))
1831 if (complain
& tf_error
)
1835 error_at (loc
, "invalid use of non-static member function %qD",
1837 inform (DECL_SOURCE_LOCATION (expr
), "declared here");
1840 error_at (loc
, "invalid use of non-static member function of "
1841 "type %qT", TREE_TYPE (expr
));
1848 /* If EXP is a reference to a bitfield, and the type of EXP does not
1849 match the declared type of the bitfield, return the declared type
1850 of the bitfield. Otherwise, return NULL_TREE. */
1853 is_bitfield_expr_with_lowered_type (const_tree exp
)
1855 switch (TREE_CODE (exp
))
1858 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1)
1859 ? TREE_OPERAND (exp
, 1)
1860 : TREE_OPERAND (exp
, 0)))
1862 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 2));
1865 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1));
1869 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1875 field
= TREE_OPERAND (exp
, 1);
1876 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_BIT_FIELD_TYPE (field
))
1878 if (same_type_ignoring_top_level_qualifiers_p
1879 (TREE_TYPE (exp
), DECL_BIT_FIELD_TYPE (field
)))
1881 return DECL_BIT_FIELD_TYPE (field
);
1885 if (DECL_HAS_VALUE_EXPR_P (exp
))
1886 return is_bitfield_expr_with_lowered_type (DECL_VALUE_EXPR
1887 (CONST_CAST_TREE (exp
)));
1891 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp
, 0)))
1892 == TYPE_MAIN_VARIANT (TREE_TYPE (exp
)))
1893 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
1901 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1902 bitfield with a lowered type, the type of EXP is returned, rather
1906 unlowered_expr_type (const_tree exp
)
1909 tree etype
= TREE_TYPE (exp
);
1911 type
= is_bitfield_expr_with_lowered_type (exp
);
1913 type
= cp_build_qualified_type (type
, cp_type_quals (etype
));
1920 /* Perform the conversions in [expr] that apply when an lvalue appears
1921 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1922 function-to-pointer conversions. In addition, bitfield references are
1923 converted to their declared types. Note that this function does not perform
1924 the lvalue-to-rvalue conversion for class types. If you need that conversion
1925 for class types, then you probably need to use force_rvalue.
1927 Although the returned value is being used as an rvalue, this
1928 function does not wrap the returned expression in a
1929 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1930 that the return value is no longer an lvalue. */
1933 decay_conversion (tree exp
,
1934 tsubst_flags_t complain
,
1935 bool reject_builtin
/* = true */)
1938 enum tree_code code
;
1939 location_t loc
= EXPR_LOC_OR_LOC (exp
, input_location
);
1941 type
= TREE_TYPE (exp
);
1942 if (type
== error_mark_node
)
1943 return error_mark_node
;
1945 exp
= resolve_nondeduced_context (exp
, complain
);
1946 if (type_unknown_p (exp
))
1948 if (complain
& tf_error
)
1949 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
1950 return error_mark_node
;
1953 code
= TREE_CODE (type
);
1955 if (error_operand_p (exp
))
1956 return error_mark_node
;
1958 if (NULLPTR_TYPE_P (type
) && !TREE_SIDE_EFFECTS (exp
))
1959 return nullptr_node
;
1961 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1962 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1963 if (code
== VOID_TYPE
)
1965 if (complain
& tf_error
)
1966 error_at (loc
, "void value not ignored as it ought to be");
1967 return error_mark_node
;
1969 if (invalid_nonstatic_memfn_p (loc
, exp
, complain
))
1970 return error_mark_node
;
1971 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1973 exp
= mark_lvalue_use (exp
);
1974 if (reject_builtin
&& reject_gcc_builtin (exp
, loc
))
1975 return error_mark_node
;
1976 return cp_build_addr_expr (exp
, complain
);
1978 if (code
== ARRAY_TYPE
)
1983 exp
= mark_lvalue_use (exp
);
1985 if (INDIRECT_REF_P (exp
))
1986 return build_nop (build_pointer_type (TREE_TYPE (type
)),
1987 TREE_OPERAND (exp
, 0));
1989 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1991 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1), complain
);
1992 if (op1
== error_mark_node
)
1993 return error_mark_node
;
1994 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
1995 TREE_OPERAND (exp
, 0), op1
);
1998 if (!obvalue_p (exp
)
1999 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
2001 if (complain
& tf_error
)
2002 error_at (loc
, "invalid use of non-lvalue array");
2003 return error_mark_node
;
2006 /* Don't let an array compound literal decay to a pointer. It can
2007 still be used to initialize an array or bind to a reference. */
2008 if (TREE_CODE (exp
) == TARGET_EXPR
)
2010 if (complain
& tf_error
)
2011 error_at (loc
, "taking address of temporary array");
2012 return error_mark_node
;
2015 ptrtype
= build_pointer_type (TREE_TYPE (type
));
2019 if (!cxx_mark_addressable (exp
))
2020 return error_mark_node
;
2021 adr
= build_nop (ptrtype
, build_address (exp
));
2024 /* This way is better for a COMPONENT_REF since it can
2025 simplify the offset for a component. */
2026 adr
= cp_build_addr_expr (exp
, complain
);
2027 return cp_convert (ptrtype
, adr
, complain
);
2030 /* Otherwise, it's the lvalue-to-rvalue conversion. */
2031 exp
= mark_rvalue_use (exp
, loc
, reject_builtin
);
2033 /* If a bitfield is used in a context where integral promotion
2034 applies, then the caller is expected to have used
2035 default_conversion. That function promotes bitfields correctly
2036 before calling this function. At this point, if we have a
2037 bitfield referenced, we may assume that is not subject to
2038 promotion, and that, therefore, the type of the resulting rvalue
2039 is the declared type of the bitfield. */
2040 exp
= convert_bitfield_to_declared_type (exp
);
2042 /* We do not call rvalue() here because we do not want to wrap EXP
2043 in a NON_LVALUE_EXPR. */
2047 Non-class rvalues always have cv-unqualified types. */
2048 type
= TREE_TYPE (exp
);
2049 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
2050 exp
= build_nop (cv_unqualified (type
), exp
);
2052 if (!complete_type_or_maybe_complain (type
, exp
, complain
))
2053 return error_mark_node
;
2058 /* Perform preparatory conversions, as part of the "usual arithmetic
2059 conversions". In particular, as per [expr]:
2061 Whenever an lvalue expression appears as an operand of an
2062 operator that expects the rvalue for that operand, the
2063 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
2064 standard conversions are applied to convert the expression to an
2067 In addition, we perform integral promotions here, as those are
2068 applied to both operands to a binary operator before determining
2069 what additional conversions should apply. */
2072 cp_default_conversion (tree exp
, tsubst_flags_t complain
)
2074 /* Check for target-specific promotions. */
2075 tree promoted_type
= targetm
.promoted_type (TREE_TYPE (exp
));
2077 exp
= cp_convert (promoted_type
, exp
, complain
);
2078 /* Perform the integral promotions first so that bitfield
2079 expressions (which may promote to "int", even if the bitfield is
2080 declared "unsigned") are promoted correctly. */
2081 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp
)))
2082 exp
= cp_perform_integral_promotions (exp
, complain
);
2083 /* Perform the other conversions. */
2084 exp
= decay_conversion (exp
, complain
);
2092 default_conversion (tree exp
)
2094 return cp_default_conversion (exp
, tf_warning_or_error
);
2097 /* EXPR is an expression with an integral or enumeration type.
2098 Perform the integral promotions in [conv.prom], and return the
2102 cp_perform_integral_promotions (tree expr
, tsubst_flags_t complain
)
2107 expr
= mark_rvalue_use (expr
);
2111 If the bitfield has an enumerated type, it is treated as any
2112 other value of that type for promotion purposes. */
2113 type
= is_bitfield_expr_with_lowered_type (expr
);
2114 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
2115 type
= TREE_TYPE (expr
);
2116 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
2117 /* Scoped enums don't promote. */
2118 if (SCOPED_ENUM_P (type
))
2120 promoted_type
= type_promotes_to (type
);
2121 if (type
!= promoted_type
)
2122 expr
= cp_convert (promoted_type
, expr
, complain
);
2129 perform_integral_promotions (tree expr
)
2131 return cp_perform_integral_promotions (expr
, tf_warning_or_error
);
2134 /* Returns nonzero iff exp is a STRING_CST or the result of applying
2135 decay_conversion to one. */
2138 string_conv_p (const_tree totype
, const_tree exp
, int warn
)
2142 if (!TYPE_PTR_P (totype
))
2145 t
= TREE_TYPE (totype
);
2146 if (!same_type_p (t
, char_type_node
)
2147 && !same_type_p (t
, char16_type_node
)
2148 && !same_type_p (t
, char32_type_node
)
2149 && !same_type_p (t
, wchar_type_node
))
2152 if (TREE_CODE (exp
) == STRING_CST
)
2154 /* Make sure that we don't try to convert between char and wide chars. */
2155 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
2160 /* Is this a string constant which has decayed to 'const char *'? */
2161 t
= build_pointer_type (cp_build_qualified_type (t
, TYPE_QUAL_CONST
));
2162 if (!same_type_p (TREE_TYPE (exp
), t
))
2165 if (TREE_CODE (exp
) != ADDR_EXPR
2166 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
2171 if (cxx_dialect
>= cxx11
)
2172 pedwarn (input_location
,
2173 pedantic
? OPT_Wpedantic
: OPT_Wwrite_strings
,
2174 "ISO C++ forbids converting a string constant to %qT",
2177 warning (OPT_Wwrite_strings
,
2178 "deprecated conversion from string constant to %qT",
2185 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
2186 can, for example, use as an lvalue. This code used to be in
2187 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
2188 expressions, where we're dealing with aggregates. But now it's again only
2189 called from unary_complex_lvalue. The case (in particular) that led to
2190 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
2194 rationalize_conditional_expr (enum tree_code code
, tree t
,
2195 tsubst_flags_t complain
)
2197 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
2199 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
2200 the first operand is always the one to be used if both operands
2201 are equal, so we know what conditional expression this used to be. */
2202 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
2204 tree op0
= TREE_OPERAND (t
, 0);
2205 tree op1
= TREE_OPERAND (t
, 1);
2207 /* The following code is incorrect if either operand side-effects. */
2208 gcc_assert (!TREE_SIDE_EFFECTS (op0
)
2209 && !TREE_SIDE_EFFECTS (op1
));
2211 build_conditional_expr (loc
,
2212 build_x_binary_op (loc
,
2213 (TREE_CODE (t
) == MIN_EXPR
2214 ? LE_EXPR
: GE_EXPR
),
2215 op0
, TREE_CODE (op0
),
2216 op1
, TREE_CODE (op1
),
2219 cp_build_unary_op (code
, op0
, false, complain
),
2220 cp_build_unary_op (code
, op1
, false, complain
),
2225 build_conditional_expr (loc
, TREE_OPERAND (t
, 0),
2226 cp_build_unary_op (code
, TREE_OPERAND (t
, 1), false,
2228 cp_build_unary_op (code
, TREE_OPERAND (t
, 2), false,
2233 /* Given the TYPE of an anonymous union field inside T, return the
2234 FIELD_DECL for the field. If not found return NULL_TREE. Because
2235 anonymous unions can nest, we must also search all anonymous unions
2236 that are directly reachable. */
2239 lookup_anon_field (tree t
, tree type
)
2243 t
= TYPE_MAIN_VARIANT (t
);
2245 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
2247 if (TREE_STATIC (field
))
2249 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
2252 /* If we find it directly, return the field. */
2253 if (DECL_NAME (field
) == NULL_TREE
2254 && type
== TYPE_MAIN_VARIANT (TREE_TYPE (field
)))
2259 /* Otherwise, it could be nested, search harder. */
2260 if (DECL_NAME (field
) == NULL_TREE
2261 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2263 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
2271 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
2272 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
2273 non-NULL, it indicates the path to the base used to name MEMBER.
2274 If PRESERVE_REFERENCE is true, the expression returned will have
2275 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
2276 returned will have the type referred to by the reference.
2278 This function does not perform access control; that is either done
2279 earlier by the parser when the name of MEMBER is resolved to MEMBER
2280 itself, or later when overload resolution selects one of the
2281 functions indicated by MEMBER. */
2284 build_class_member_access_expr (cp_expr object
, tree member
,
2285 tree access_path
, bool preserve_reference
,
2286 tsubst_flags_t complain
)
2290 tree result
= NULL_TREE
;
2291 tree using_decl
= NULL_TREE
;
2293 if (error_operand_p (object
) || error_operand_p (member
))
2294 return error_mark_node
;
2296 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2300 The type of the first expression shall be "class object" (of a
2302 object_type
= TREE_TYPE (object
);
2303 if (!currently_open_class (object_type
)
2304 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
2305 return error_mark_node
;
2306 if (!CLASS_TYPE_P (object_type
))
2308 if (complain
& tf_error
)
2310 if (POINTER_TYPE_P (object_type
)
2311 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
2312 error ("request for member %qD in %qE, which is of pointer "
2313 "type %qT (maybe you meant to use %<->%> ?)",
2314 member
, object
.get_value (), object_type
);
2316 error ("request for member %qD in %qE, which is of non-class "
2317 "type %qT", member
, object
.get_value (), object_type
);
2319 return error_mark_node
;
2322 /* The standard does not seem to actually say that MEMBER must be a
2323 member of OBJECT_TYPE. However, that is clearly what is
2325 if (DECL_P (member
))
2327 member_scope
= DECL_CLASS_CONTEXT (member
);
2328 if (!mark_used (member
, complain
) && !(complain
& tf_error
))
2329 return error_mark_node
;
2330 if (TREE_DEPRECATED (member
))
2331 warn_deprecated_use (member
, NULL_TREE
);
2334 member_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (member
));
2335 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2336 presently be the anonymous union. Go outwards until we find a
2337 type related to OBJECT_TYPE. */
2338 while ((ANON_AGGR_TYPE_P (member_scope
) || UNSCOPED_ENUM_P (member_scope
))
2339 && !same_type_ignoring_top_level_qualifiers_p (member_scope
,
2341 member_scope
= TYPE_CONTEXT (member_scope
);
2342 if (!member_scope
|| !DERIVED_FROM_P (member_scope
, object_type
))
2344 if (complain
& tf_error
)
2346 if (TREE_CODE (member
) == FIELD_DECL
)
2347 error ("invalid use of nonstatic data member %qE", member
);
2349 error ("%qD is not a member of %qT", member
, object_type
);
2351 return error_mark_node
;
2354 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2355 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
2356 in the front end; only _DECLs and _REFs are lvalues in the back end. */
2358 tree temp
= unary_complex_lvalue (ADDR_EXPR
, object
);
2360 object
= cp_build_indirect_ref (temp
, RO_NULL
, complain
);
2363 /* In [expr.ref], there is an explicit list of the valid choices for
2364 MEMBER. We check for each of those cases here. */
2367 /* A static data member. */
2369 mark_exp_read (object
);
2370 /* If OBJECT has side-effects, they are supposed to occur. */
2371 if (TREE_SIDE_EFFECTS (object
))
2372 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), object
, result
);
2374 else if (TREE_CODE (member
) == FIELD_DECL
)
2376 /* A non-static data member. */
2381 if (INDIRECT_REF_P (object
))
2383 integer_zerop (tree_strip_nop_conversions (TREE_OPERAND (object
, 0)));
2385 null_object_p
= false;
2387 /* Convert OBJECT to the type of MEMBER. */
2388 if (!same_type_p (TYPE_MAIN_VARIANT (object_type
),
2389 TYPE_MAIN_VARIANT (member_scope
)))
2394 binfo
= lookup_base (access_path
? access_path
: object_type
,
2395 member_scope
, ba_unique
, &kind
, complain
);
2396 if (binfo
== error_mark_node
)
2397 return error_mark_node
;
2399 /* It is invalid to try to get to a virtual base of a
2400 NULL object. The most common cause is invalid use of
2402 if (null_object_p
&& kind
== bk_via_virtual
)
2404 if (complain
& tf_error
)
2406 error ("invalid access to non-static data member %qD in "
2407 "virtual base of NULL object", member
);
2409 return error_mark_node
;
2412 /* Convert to the base. */
2413 object
= build_base_path (PLUS_EXPR
, object
, binfo
,
2414 /*nonnull=*/1, complain
);
2415 /* If we found the base successfully then we should be able
2416 to convert to it successfully. */
2417 gcc_assert (object
!= error_mark_node
);
2420 /* If MEMBER is from an anonymous aggregate, we have converted
2421 OBJECT so that it refers to the class containing the
2422 anonymous union. Generate a reference to the anonymous union
2423 itself, and recur to find MEMBER. */
2424 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member
))
2425 /* When this code is called from build_field_call, the
2426 object already has the type of the anonymous union.
2427 That is because the COMPONENT_REF was already
2428 constructed, and was then disassembled before calling
2429 build_field_call. After the function-call code is
2430 cleaned up, this waste can be eliminated. */
2431 && (!same_type_ignoring_top_level_qualifiers_p
2432 (TREE_TYPE (object
), DECL_CONTEXT (member
))))
2434 tree anonymous_union
;
2436 anonymous_union
= lookup_anon_field (TREE_TYPE (object
),
2437 DECL_CONTEXT (member
));
2438 object
= build_class_member_access_expr (object
,
2440 /*access_path=*/NULL_TREE
,
2445 /* Compute the type of the field, as described in [expr.ref]. */
2446 type_quals
= TYPE_UNQUALIFIED
;
2447 member_type
= TREE_TYPE (member
);
2448 if (TREE_CODE (member_type
) != REFERENCE_TYPE
)
2450 type_quals
= (cp_type_quals (member_type
)
2451 | cp_type_quals (object_type
));
2453 /* A field is const (volatile) if the enclosing object, or the
2454 field itself, is const (volatile). But, a mutable field is
2455 not const, even within a const object. */
2456 if (DECL_MUTABLE_P (member
))
2457 type_quals
&= ~TYPE_QUAL_CONST
;
2458 member_type
= cp_build_qualified_type (member_type
, type_quals
);
2461 result
= build3_loc (input_location
, COMPONENT_REF
, member_type
,
2462 object
, member
, NULL_TREE
);
2464 /* Mark the expression const or volatile, as appropriate. Even
2465 though we've dealt with the type above, we still have to mark the
2466 expression itself. */
2467 if (type_quals
& TYPE_QUAL_CONST
)
2468 TREE_READONLY (result
) = 1;
2469 if (type_quals
& TYPE_QUAL_VOLATILE
)
2470 TREE_THIS_VOLATILE (result
) = 1;
2472 else if (BASELINK_P (member
))
2474 /* The member is a (possibly overloaded) member function. */
2478 /* If the MEMBER is exactly one static member function, then we
2479 know the type of the expression. Otherwise, we must wait
2480 until overload resolution has been performed. */
2481 functions
= BASELINK_FUNCTIONS (member
);
2482 if (TREE_CODE (functions
) == FUNCTION_DECL
2483 && DECL_STATIC_FUNCTION_P (functions
))
2484 type
= TREE_TYPE (functions
);
2486 type
= unknown_type_node
;
2487 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2488 base. That will happen when the function is called. */
2489 result
= build3 (COMPONENT_REF
, type
, object
, member
, NULL_TREE
);
2491 else if (TREE_CODE (member
) == CONST_DECL
)
2493 /* The member is an enumerator. */
2495 /* If OBJECT has side-effects, they are supposed to occur. */
2496 if (TREE_SIDE_EFFECTS (object
))
2497 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
2500 else if ((using_decl
= strip_using_decl (member
)) != member
)
2501 result
= build_class_member_access_expr (object
,
2503 access_path
, preserve_reference
,
2507 if (complain
& tf_error
)
2508 error ("invalid use of %qD", member
);
2509 return error_mark_node
;
2512 if (!preserve_reference
)
2515 If E2 is declared to have type "reference to T", then ... the
2516 type of E1.E2 is T. */
2517 result
= convert_from_reference (result
);
2522 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2523 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
2526 lookup_destructor (tree object
, tree scope
, tree dtor_name
,
2527 tsubst_flags_t complain
)
2529 tree object_type
= TREE_TYPE (object
);
2530 tree dtor_type
= TREE_OPERAND (dtor_name
, 0);
2533 /* We've already complained about this destructor. */
2534 if (dtor_type
== error_mark_node
)
2535 return error_mark_node
;
2537 if (scope
&& !check_dtor_name (scope
, dtor_type
))
2539 if (complain
& tf_error
)
2540 error ("qualified type %qT does not match destructor name ~%qT",
2542 return error_mark_node
;
2544 if (is_auto (dtor_type
))
2545 dtor_type
= object_type
;
2546 else if (identifier_p (dtor_type
))
2548 /* In a template, names we can't find a match for are still accepted
2549 destructor names, and we check them here. */
2550 if (check_dtor_name (object_type
, dtor_type
))
2551 dtor_type
= object_type
;
2554 if (complain
& tf_error
)
2555 error ("object type %qT does not match destructor name ~%qT",
2556 object_type
, dtor_type
);
2557 return error_mark_node
;
2561 else if (!DERIVED_FROM_P (dtor_type
, TYPE_MAIN_VARIANT (object_type
)))
2563 if (complain
& tf_error
)
2564 error ("the type being destroyed is %qT, but the destructor "
2565 "refers to %qT", TYPE_MAIN_VARIANT (object_type
), dtor_type
);
2566 return error_mark_node
;
2568 expr
= lookup_member (dtor_type
, complete_dtor_identifier
,
2569 /*protect=*/1, /*want_type=*/false,
2570 tf_warning_or_error
);
2573 if (complain
& tf_error
)
2574 cxx_incomplete_type_error (dtor_name
, dtor_type
);
2575 return error_mark_node
;
2577 expr
= (adjust_result_of_qualified_name_lookup
2578 (expr
, dtor_type
, object_type
));
2579 if (scope
== NULL_TREE
)
2580 /* We need to call adjust_result_of_qualified_name_lookup in case the
2581 destructor names a base class, but we unset BASELINK_QUALIFIED_P so
2582 that we still get virtual function binding. */
2583 BASELINK_QUALIFIED_P (expr
) = false;
2587 /* An expression of the form "A::template B" has been resolved to
2588 DECL. Issue a diagnostic if B is not a template or template
2592 check_template_keyword (tree decl
)
2594 /* The standard says:
2598 If a name prefixed by the keyword template is not a member
2599 template, the program is ill-formed.
2601 DR 228 removed the restriction that the template be a member
2604 DR 96, if accepted would add the further restriction that explicit
2605 template arguments must be provided if the template keyword is
2606 used, but, as of 2005-10-16, that DR is still in "drafting". If
2607 this DR is accepted, then the semantic checks here can be
2608 simplified, as the entity named must in fact be a template
2609 specialization, rather than, as at present, a set of overloaded
2610 functions containing at least one template function. */
2611 if (TREE_CODE (decl
) != TEMPLATE_DECL
2612 && TREE_CODE (decl
) != TEMPLATE_ID_EXPR
)
2616 if (DECL_USE_TEMPLATE (decl
)
2617 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2620 permerror (input_location
, "%qD is not a template", decl
);
2622 else if (!is_overloaded_fn (decl
))
2623 permerror (input_location
, "%qD is not a template", decl
);
2628 if (BASELINK_P (fns
))
2629 fns
= BASELINK_FUNCTIONS (fns
);
2632 tree fn
= OVL_CURRENT (fns
);
2633 if (TREE_CODE (fn
) == TEMPLATE_DECL
2634 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2636 if (TREE_CODE (fn
) == FUNCTION_DECL
2637 && DECL_USE_TEMPLATE (fn
)
2638 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
2640 fns
= OVL_NEXT (fns
);
2643 permerror (input_location
, "%qD is not a template", decl
);
2648 /* This function is called by the parser to process a class member
2649 access expression of the form OBJECT.NAME. NAME is a node used by
2650 the parser to represent a name; it is not yet a DECL. It may,
2651 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2652 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2653 there is no reason to do the lookup twice, so the parser keeps the
2654 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2655 be a template via the use of the "A::template B" syntax. */
2658 finish_class_member_access_expr (cp_expr object
, tree name
, bool template_p
,
2659 tsubst_flags_t complain
)
2664 tree access_path
= NULL_TREE
;
2665 tree orig_object
= object
;
2666 tree orig_name
= name
;
2668 if (object
== error_mark_node
|| name
== error_mark_node
)
2669 return error_mark_node
;
2671 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2672 if (!objc_is_public (object
, name
))
2673 return error_mark_node
;
2675 object_type
= TREE_TYPE (object
);
2677 if (processing_template_decl
)
2679 if (/* If OBJECT is dependent, so is OBJECT.NAME. */
2680 type_dependent_object_expression_p (object
)
2681 /* If NAME is "f<args>", where either 'f' or 'args' is
2682 dependent, then the expression is dependent. */
2683 || (TREE_CODE (name
) == TEMPLATE_ID_EXPR
2684 && dependent_template_id_p (TREE_OPERAND (name
, 0),
2685 TREE_OPERAND (name
, 1)))
2686 /* If NAME is "T::X" where "T" is dependent, then the
2687 expression is dependent. */
2688 || (TREE_CODE (name
) == SCOPE_REF
2689 && TYPE_P (TREE_OPERAND (name
, 0))
2690 && dependent_scope_p (TREE_OPERAND (name
, 0))))
2693 return build_min_nt_loc (UNKNOWN_LOCATION
, COMPONENT_REF
,
2694 orig_object
, orig_name
, NULL_TREE
);
2696 object
= build_non_dependent_expr (object
);
2698 else if (c_dialect_objc ()
2699 && identifier_p (name
)
2700 && (expr
= objc_maybe_build_component_ref (object
, name
)))
2705 The type of the first expression shall be "class object" (of a
2707 if (!currently_open_class (object_type
)
2708 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
2709 return error_mark_node
;
2710 if (!CLASS_TYPE_P (object_type
))
2712 if (complain
& tf_error
)
2714 if (POINTER_TYPE_P (object_type
)
2715 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
2716 error ("request for member %qD in %qE, which is of pointer "
2717 "type %qT (maybe you meant to use %<->%> ?)",
2718 name
, object
.get_value (), object_type
);
2720 error ("request for member %qD in %qE, which is of non-class "
2721 "type %qT", name
, object
.get_value (), object_type
);
2723 return error_mark_node
;
2726 if (BASELINK_P (name
))
2727 /* A member function that has already been looked up. */
2731 bool is_template_id
= false;
2732 tree template_args
= NULL_TREE
;
2735 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2737 is_template_id
= true;
2738 template_args
= TREE_OPERAND (name
, 1);
2739 name
= TREE_OPERAND (name
, 0);
2741 if (TREE_CODE (name
) == OVERLOAD
)
2742 name
= DECL_NAME (get_first_fn (name
));
2743 else if (DECL_P (name
))
2744 name
= DECL_NAME (name
);
2747 if (TREE_CODE (name
) == SCOPE_REF
)
2749 /* A qualified name. The qualifying class or namespace `S'
2750 has already been looked up; it is either a TYPE or a
2752 scope
= TREE_OPERAND (name
, 0);
2753 name
= TREE_OPERAND (name
, 1);
2755 /* If SCOPE is a namespace, then the qualified name does not
2756 name a member of OBJECT_TYPE. */
2757 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
2759 if (complain
& tf_error
)
2760 error ("%<%D::%D%> is not a member of %qT",
2761 scope
, name
, object_type
);
2762 return error_mark_node
;
2765 if (TREE_CODE (scope
) == ENUMERAL_TYPE
)
2767 /* Looking up a member enumerator (c++/56793). */
2768 if (!TYPE_CLASS_SCOPE_P (scope
)
2769 || !DERIVED_FROM_P (TYPE_CONTEXT (scope
), object_type
))
2771 if (complain
& tf_error
)
2772 error ("%<%D::%D%> is not a member of %qT",
2773 scope
, name
, object_type
);
2774 return error_mark_node
;
2776 tree val
= lookup_enumerator (scope
, name
);
2779 if (complain
& tf_error
)
2780 error ("%qD is not a member of %qD",
2782 return error_mark_node
;
2785 if (TREE_SIDE_EFFECTS (object
))
2786 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
), object
, val
);
2790 gcc_assert (CLASS_TYPE_P (scope
));
2791 gcc_assert (identifier_p (name
) || TREE_CODE (name
) == BIT_NOT_EXPR
);
2793 if (constructor_name_p (name
, scope
))
2795 if (complain
& tf_error
)
2796 error ("cannot call constructor %<%T::%D%> directly",
2798 return error_mark_node
;
2801 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2802 access_path
= lookup_base (object_type
, scope
, ba_check
,
2804 if (access_path
== error_mark_node
)
2805 return error_mark_node
;
2808 if (any_dependent_bases_p (object_type
))
2810 if (complain
& tf_error
)
2811 error ("%qT is not a base of %qT", scope
, object_type
);
2812 return error_mark_node
;
2818 access_path
= object_type
;
2821 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2823 if (dependent_type_p (object_type
))
2824 /* The destructor isn't declared yet. */
2826 member
= lookup_destructor (object
, scope
, name
, complain
);
2830 /* Look up the member. */
2831 member
= lookup_member (access_path
, name
, /*protect=*/1,
2832 /*want_type=*/false, complain
);
2833 if (member
== NULL_TREE
)
2835 if (dependent_type_p (object_type
))
2836 /* Try again at instantiation time. */
2838 if (complain
& tf_error
)
2840 tree guessed_id
= lookup_member_fuzzy (access_path
, name
,
2841 /*want_type=*/false);
2844 location_t bogus_component_loc
= input_location
;
2845 gcc_rich_location
rich_loc (bogus_component_loc
);
2846 rich_loc
.add_fixit_misspelled_id (bogus_component_loc
,
2850 "%q#T has no member named %qE; did you mean %qE?",
2851 TREE_CODE (access_path
) == TREE_BINFO
2852 ? TREE_TYPE (access_path
) : object_type
, name
,
2856 error ("%q#T has no member named %qE",
2857 TREE_CODE (access_path
) == TREE_BINFO
2858 ? TREE_TYPE (access_path
) : object_type
, name
);
2860 return error_mark_node
;
2862 if (member
== error_mark_node
)
2863 return error_mark_node
;
2865 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (member
)))
2866 /* Dependent type attributes on the decl mean that the TREE_TYPE is
2867 wrong, so don't use it. */
2869 if (TREE_CODE (member
) == USING_DECL
&& DECL_DEPENDENT_P (member
))
2875 tree templ
= member
;
2877 if (BASELINK_P (templ
))
2878 templ
= lookup_template_function (templ
, template_args
);
2881 if (complain
& tf_error
)
2882 error ("%qD is not a member template function", name
);
2883 return error_mark_node
;
2888 if (TREE_DEPRECATED (member
))
2889 warn_deprecated_use (member
, NULL_TREE
);
2892 check_template_keyword (member
);
2894 expr
= build_class_member_access_expr (object
, member
, access_path
,
2895 /*preserve_reference=*/false,
2897 if (processing_template_decl
&& expr
!= error_mark_node
)
2899 if (BASELINK_P (member
))
2901 if (TREE_CODE (orig_name
) == SCOPE_REF
)
2902 BASELINK_QUALIFIED_P (member
) = 1;
2905 return build_min_non_dep (COMPONENT_REF
, expr
,
2906 orig_object
, orig_name
,
2913 /* Build a COMPONENT_REF of OBJECT and MEMBER with the appropriate
2917 build_simple_component_ref (tree object
, tree member
)
2919 tree type
= cp_build_qualified_type (TREE_TYPE (member
),
2920 cp_type_quals (TREE_TYPE (object
)));
2921 return build3_loc (input_location
,
2922 COMPONENT_REF
, type
,
2923 object
, member
, NULL_TREE
);
2926 /* Return an expression for the MEMBER_NAME field in the internal
2927 representation of PTRMEM, a pointer-to-member function. (Each
2928 pointer-to-member function type gets its own RECORD_TYPE so it is
2929 more convenient to access the fields by name than by FIELD_DECL.)
2930 This routine converts the NAME to a FIELD_DECL and then creates the
2931 node for the complete expression. */
2934 build_ptrmemfunc_access_expr (tree ptrmem
, tree member_name
)
2939 /* This code is a stripped down version of
2940 build_class_member_access_expr. It does not work to use that
2941 routine directly because it expects the object to be of class
2943 ptrmem_type
= TREE_TYPE (ptrmem
);
2944 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type
));
2945 for (member
= TYPE_FIELDS (ptrmem_type
); member
;
2946 member
= DECL_CHAIN (member
))
2947 if (DECL_NAME (member
) == member_name
)
2949 return build_simple_component_ref (ptrmem
, member
);
2952 /* Given an expression PTR for a pointer, return an expression
2953 for the value pointed to.
2954 ERRORSTRING is the name of the operator to appear in error messages.
2956 This function may need to overload OPERATOR_FNNAME.
2957 Must also handle REFERENCE_TYPEs for C++. */
2960 build_x_indirect_ref (location_t loc
, tree expr
, ref_operator errorstring
,
2961 tsubst_flags_t complain
)
2963 tree orig_expr
= expr
;
2965 tree overload
= NULL_TREE
;
2967 if (processing_template_decl
)
2969 /* Retain the type if we know the operand is a pointer. */
2970 if (TREE_TYPE (expr
) && POINTER_TYPE_P (TREE_TYPE (expr
)))
2971 return build_min (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (expr
)), expr
);
2972 if (type_dependent_expression_p (expr
))
2973 return build_min_nt_loc (loc
, INDIRECT_REF
, expr
);
2974 expr
= build_non_dependent_expr (expr
);
2977 rval
= build_new_op (loc
, INDIRECT_REF
, LOOKUP_NORMAL
, expr
,
2978 NULL_TREE
, NULL_TREE
, &overload
, complain
);
2980 rval
= cp_build_indirect_ref (expr
, errorstring
, complain
);
2982 if (processing_template_decl
&& rval
!= error_mark_node
)
2984 if (overload
!= NULL_TREE
)
2985 return (build_min_non_dep_op_overload
2986 (INDIRECT_REF
, rval
, overload
, orig_expr
));
2988 return build_min_non_dep (INDIRECT_REF
, rval
, orig_expr
);
2994 /* Helper function called from c-common. */
2996 build_indirect_ref (location_t
/*loc*/,
2997 tree ptr
, ref_operator errorstring
)
2999 return cp_build_indirect_ref (ptr
, errorstring
, tf_warning_or_error
);
3003 cp_build_indirect_ref (tree ptr
, ref_operator errorstring
,
3004 tsubst_flags_t complain
)
3008 if (ptr
== current_class_ptr
3009 || (TREE_CODE (ptr
) == NOP_EXPR
3010 && TREE_OPERAND (ptr
, 0) == current_class_ptr
3011 && (same_type_ignoring_top_level_qualifiers_p
3012 (TREE_TYPE (ptr
), TREE_TYPE (current_class_ptr
)))))
3013 return current_class_ref
;
3015 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
3016 ? ptr
: decay_conversion (ptr
, complain
));
3017 if (pointer
== error_mark_node
)
3018 return error_mark_node
;
3020 type
= TREE_TYPE (pointer
);
3022 if (POINTER_TYPE_P (type
))
3026 If the type of the expression is "pointer to T," the type
3027 of the result is "T." */
3028 tree t
= TREE_TYPE (type
);
3030 if ((CONVERT_EXPR_P (ptr
)
3031 || TREE_CODE (ptr
) == VIEW_CONVERT_EXPR
)
3032 && (!CLASS_TYPE_P (t
) || !CLASSTYPE_EMPTY_P (t
)))
3034 /* If a warning is issued, mark it to avoid duplicates from
3035 the backend. This only needs to be done at
3036 warn_strict_aliasing > 2. */
3037 if (warn_strict_aliasing
> 2)
3038 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr
, 0)),
3039 type
, TREE_OPERAND (ptr
, 0)))
3040 TREE_NO_WARNING (ptr
) = 1;
3043 if (VOID_TYPE_P (t
))
3045 /* A pointer to incomplete type (other than cv void) can be
3046 dereferenced [expr.unary.op]/1 */
3047 if (complain
& tf_error
)
3048 error ("%qT is not a pointer-to-object type", type
);
3049 return error_mark_node
;
3051 else if (TREE_CODE (pointer
) == ADDR_EXPR
3052 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
3053 /* The POINTER was something like `&x'. We simplify `*&x' to
3055 return TREE_OPERAND (pointer
, 0);
3058 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
3060 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
3061 so that we get the proper error message if the result is used
3062 to assign to. Also, &* is supposed to be a no-op. */
3063 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
3064 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
3065 TREE_SIDE_EFFECTS (ref
)
3066 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
));
3070 else if (!(complain
& tf_error
))
3071 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
3073 /* `pointer' won't be an error_mark_node if we were given a
3074 pointer to member, so it's cool to check for this here. */
3075 else if (TYPE_PTRMEM_P (type
))
3076 switch (errorstring
)
3078 case RO_ARRAY_INDEXING
:
3079 error ("invalid use of array indexing on pointer to member");
3082 error ("invalid use of unary %<*%> on pointer to member");
3084 case RO_IMPLICIT_CONVERSION
:
3085 error ("invalid use of implicit conversion on pointer to member");
3088 error ("left hand operand of %<->*%> must be a pointer to class, "
3089 "but is a pointer to member of type %qT", type
);
3094 else if (pointer
!= error_mark_node
)
3095 invalid_indirection_error (input_location
, type
, errorstring
);
3097 return error_mark_node
;
3100 /* This handles expressions of the form "a[i]", which denotes
3103 This is logically equivalent in C to *(a+i), but we may do it differently.
3104 If A is a variable or a member, we generate a primitive ARRAY_REF.
3105 This avoids forcing the array out of registers, and can work on
3106 arrays that are not lvalues (for example, members of structures returned
3109 If INDEX is of some user-defined type, it must be converted to
3110 integer type. Otherwise, to make a compatible PLUS_EXPR, it
3111 will inherit the type of the array, which will be some pointer type.
3113 LOC is the location to use in building the array reference. */
3116 cp_build_array_ref (location_t loc
, tree array
, tree idx
,
3117 tsubst_flags_t complain
)
3123 if (complain
& tf_error
)
3124 error_at (loc
, "subscript missing in array reference");
3125 return error_mark_node
;
3128 /* If an array's index is an array notation, then its rank cannot be
3129 greater than one. */
3130 if (flag_cilkplus
&& contains_array_notation_expr (idx
))
3134 /* If find_rank returns false, then it should have reported an error,
3135 thus it is unnecessary for repetition. */
3136 if (!find_rank (loc
, idx
, idx
, true, &rank
))
3137 return error_mark_node
;
3140 error_at (loc
, "rank of the array%'s index is greater than 1");
3141 return error_mark_node
;
3144 if (TREE_TYPE (array
) == error_mark_node
3145 || TREE_TYPE (idx
) == error_mark_node
)
3146 return error_mark_node
;
3148 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
3150 switch (TREE_CODE (array
))
3154 tree value
= cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3156 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3157 TREE_OPERAND (array
, 0), value
);
3158 SET_EXPR_LOCATION (ret
, loc
);
3163 ret
= build_conditional_expr
3164 (loc
, TREE_OPERAND (array
, 0),
3165 cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3167 cp_build_array_ref (loc
, TREE_OPERAND (array
, 2), idx
,
3170 protected_set_expr_location (ret
, loc
);
3177 bool non_lvalue
= convert_vector_to_array_for_subscript (loc
, &array
, idx
);
3179 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
3183 warn_array_subscript_with_type_char (loc
, idx
);
3185 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx
)))
3187 if (complain
& tf_error
)
3188 error_at (loc
, "array subscript is not an integer");
3189 return error_mark_node
;
3192 /* Apply integral promotions *after* noticing character types.
3193 (It is unclear why we do these promotions -- the standard
3194 does not say that we should. In fact, the natural thing would
3195 seem to be to convert IDX to ptrdiff_t; we're performing
3196 pointer arithmetic.) */
3197 idx
= cp_perform_integral_promotions (idx
, complain
);
3199 /* An array that is indexed by a non-constant
3200 cannot be stored in a register; we must be able to do
3201 address arithmetic on its address.
3202 Likewise an array of elements of variable size. */
3203 if (TREE_CODE (idx
) != INTEGER_CST
3204 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
3205 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
3208 if (!cxx_mark_addressable (array
))
3209 return error_mark_node
;
3212 /* An array that is indexed by a constant value which is not within
3213 the array bounds cannot be stored in a register either; because we
3214 would get a crash in store_bit_field/extract_bit_field when trying
3215 to access a non-existent part of the register. */
3216 if (TREE_CODE (idx
) == INTEGER_CST
3217 && TYPE_DOMAIN (TREE_TYPE (array
))
3218 && ! int_fits_type_p (idx
, TYPE_DOMAIN (TREE_TYPE (array
))))
3220 if (!cxx_mark_addressable (array
))
3221 return error_mark_node
;
3224 /* Note in C++ it is valid to subscript a `register' array, since
3225 it is valid to take the address of something with that
3226 storage specification. */
3230 while (TREE_CODE (foo
) == COMPONENT_REF
)
3231 foo
= TREE_OPERAND (foo
, 0);
3232 if (VAR_P (foo
) && DECL_REGISTER (foo
)
3233 && (complain
& tf_warning
))
3234 warning_at (loc
, OPT_Wextra
,
3235 "subscripting array declared %<register%>");
3238 type
= TREE_TYPE (TREE_TYPE (array
));
3239 rval
= build4 (ARRAY_REF
, type
, array
, idx
, NULL_TREE
, NULL_TREE
);
3240 /* Array ref is const/volatile if the array elements are
3241 or if the array is.. */
3242 TREE_READONLY (rval
)
3243 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
3244 TREE_SIDE_EFFECTS (rval
)
3245 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
3246 TREE_THIS_VOLATILE (rval
)
3247 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
3248 ret
= require_complete_type_sfinae (rval
, complain
);
3249 protected_set_expr_location (ret
, loc
);
3251 ret
= non_lvalue_loc (loc
, ret
);
3256 tree ar
= cp_default_conversion (array
, complain
);
3257 tree ind
= cp_default_conversion (idx
, complain
);
3259 /* Put the integer in IND to simplify error checking. */
3260 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
3261 std::swap (ar
, ind
);
3263 if (ar
== error_mark_node
|| ind
== error_mark_node
)
3264 return error_mark_node
;
3266 if (!TYPE_PTR_P (TREE_TYPE (ar
)))
3268 if (complain
& tf_error
)
3269 error_at (loc
, "subscripted value is neither array nor pointer");
3270 return error_mark_node
;
3272 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
3274 if (complain
& tf_error
)
3275 error_at (loc
, "array subscript is not an integer");
3276 return error_mark_node
;
3279 warn_array_subscript_with_type_char (loc
, idx
);
3281 ret
= cp_build_indirect_ref (cp_build_binary_op (input_location
,
3286 protected_set_expr_location (ret
, loc
);
3288 ret
= non_lvalue_loc (loc
, ret
);
3293 /* Entry point for Obj-C++. */
3296 build_array_ref (location_t loc
, tree array
, tree idx
)
3298 return cp_build_array_ref (loc
, array
, idx
, tf_warning_or_error
);
3301 /* Resolve a pointer to member function. INSTANCE is the object
3302 instance to use, if the member points to a virtual member.
3304 This used to avoid checking for virtual functions if basetype
3305 has no virtual functions, according to an earlier ANSI draft.
3306 With the final ISO C++ rules, such an optimization is
3307 incorrect: A pointer to a derived member can be static_cast
3308 to pointer-to-base-member, as long as the dynamic object
3309 later has the right member. So now we only do this optimization
3310 when we know the dynamic type of the object. */
3313 get_member_function_from_ptrfunc (tree
*instance_ptrptr
, tree function
,
3314 tsubst_flags_t complain
)
3316 if (TREE_CODE (function
) == OFFSET_REF
)
3317 function
= TREE_OPERAND (function
, 1);
3319 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
3321 tree idx
, delta
, e1
, e2
, e3
, vtbl
;
3323 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
3324 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
3326 tree instance_ptr
= *instance_ptrptr
;
3327 tree instance_save_expr
= 0;
3328 if (instance_ptr
== error_mark_node
)
3330 if (TREE_CODE (function
) == PTRMEM_CST
)
3332 /* Extracting the function address from a pmf is only
3333 allowed with -Wno-pmf-conversions. It only works for
3335 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
), complain
);
3336 e1
= convert (fntype
, e1
);
3341 if (complain
& tf_error
)
3342 error ("object missing in use of %qE", function
);
3343 return error_mark_node
;
3347 /* True if we know that the dynamic type of the object doesn't have
3348 virtual functions, so we can assume the PFN field is a pointer. */
3349 nonvirtual
= (COMPLETE_TYPE_P (basetype
)
3350 && !TYPE_POLYMORPHIC_P (basetype
)
3351 && resolves_to_fixed_type_p (instance_ptr
, 0));
3353 /* If we don't really have an object (i.e. in an ill-formed
3354 conversion from PMF to pointer), we can't resolve virtual
3355 functions anyway. */
3356 if (!nonvirtual
&& is_dummy_object (instance_ptr
))
3359 if (TREE_SIDE_EFFECTS (instance_ptr
))
3360 instance_ptr
= instance_save_expr
= save_expr (instance_ptr
);
3362 if (TREE_SIDE_EFFECTS (function
))
3363 function
= save_expr (function
);
3365 /* Start by extracting all the information from the PMF itself. */
3366 e3
= pfn_from_ptrmemfunc (function
);
3367 delta
= delta_from_ptrmemfunc (function
);
3368 idx
= build1 (NOP_EXPR
, vtable_index_type
, e3
);
3369 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
3371 int flag_sanitize_save
;
3372 case ptrmemfunc_vbit_in_pfn
:
3373 e1
= cp_build_binary_op (input_location
,
3374 BIT_AND_EXPR
, idx
, integer_one_node
,
3376 idx
= cp_build_binary_op (input_location
,
3377 MINUS_EXPR
, idx
, integer_one_node
,
3379 if (idx
== error_mark_node
)
3380 return error_mark_node
;
3383 case ptrmemfunc_vbit_in_delta
:
3384 e1
= cp_build_binary_op (input_location
,
3385 BIT_AND_EXPR
, delta
, integer_one_node
,
3387 /* Don't instrument the RSHIFT_EXPR we're about to create because
3388 we're going to use DELTA number of times, and that wouldn't play
3389 well with SAVE_EXPRs therein. */
3390 flag_sanitize_save
= flag_sanitize
;
3392 delta
= cp_build_binary_op (input_location
,
3393 RSHIFT_EXPR
, delta
, integer_one_node
,
3395 flag_sanitize
= flag_sanitize_save
;
3396 if (delta
== error_mark_node
)
3397 return error_mark_node
;
3404 if (e1
== error_mark_node
)
3405 return error_mark_node
;
3407 /* Convert down to the right base before using the instance. A
3408 special case is that in a pointer to member of class C, C may
3409 be incomplete. In that case, the function will of course be
3410 a member of C, and no conversion is required. In fact,
3411 lookup_base will fail in that case, because incomplete
3412 classes do not have BINFOs. */
3413 if (!same_type_ignoring_top_level_qualifiers_p
3414 (basetype
, TREE_TYPE (TREE_TYPE (instance_ptr
))))
3416 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr
)),
3417 basetype
, ba_check
, NULL
, complain
);
3418 instance_ptr
= build_base_path (PLUS_EXPR
, instance_ptr
, basetype
,
3420 if (instance_ptr
== error_mark_node
)
3421 return error_mark_node
;
3423 /* ...and then the delta in the PMF. */
3424 instance_ptr
= fold_build_pointer_plus (instance_ptr
, delta
);
3426 /* Hand back the adjusted 'this' argument to our caller. */
3427 *instance_ptrptr
= instance_ptr
;
3430 /* Now just return the pointer. */
3433 /* Next extract the vtable pointer from the object. */
3434 vtbl
= build1 (NOP_EXPR
, build_pointer_type (vtbl_ptr_type_node
),
3436 vtbl
= cp_build_indirect_ref (vtbl
, RO_NULL
, complain
);
3437 if (vtbl
== error_mark_node
)
3438 return error_mark_node
;
3440 /* Finally, extract the function pointer from the vtable. */
3441 e2
= fold_build_pointer_plus_loc (input_location
, vtbl
, idx
);
3442 e2
= cp_build_indirect_ref (e2
, RO_NULL
, complain
);
3443 if (e2
== error_mark_node
)
3444 return error_mark_node
;
3445 TREE_CONSTANT (e2
) = 1;
3447 /* When using function descriptors, the address of the
3448 vtable entry is treated as a function pointer. */
3449 if (TARGET_VTABLE_USES_DESCRIPTORS
)
3450 e2
= build1 (NOP_EXPR
, TREE_TYPE (e2
),
3451 cp_build_addr_expr (e2
, complain
));
3453 e2
= fold_convert (TREE_TYPE (e3
), e2
);
3454 e1
= build_conditional_expr (input_location
, e1
, e2
, e3
, complain
);
3455 if (e1
== error_mark_node
)
3456 return error_mark_node
;
3458 /* Make sure this doesn't get evaluated first inside one of the
3459 branches of the COND_EXPR. */
3460 if (instance_save_expr
)
3461 e1
= build2 (COMPOUND_EXPR
, TREE_TYPE (e1
),
3462 instance_save_expr
, e1
);
3469 /* Used by the C-common bits. */
3471 build_function_call (location_t
/*loc*/,
3472 tree function
, tree params
)
3474 return cp_build_function_call (function
, params
, tf_warning_or_error
);
3477 /* Used by the C-common bits. */
3479 build_function_call_vec (location_t
/*loc*/, vec
<location_t
> /*arg_loc*/,
3480 tree function
, vec
<tree
, va_gc
> *params
,
3481 vec
<tree
, va_gc
> * /*origtypes*/)
3483 vec
<tree
, va_gc
> *orig_params
= params
;
3484 tree ret
= cp_build_function_call_vec (function
, ¶ms
,
3485 tf_warning_or_error
);
3487 /* cp_build_function_call_vec can reallocate PARAMS by adding
3488 default arguments. That should never happen here. Verify
3490 gcc_assert (params
== orig_params
);
3495 /* Build a function call using a tree list of arguments. */
3498 cp_build_function_call (tree function
, tree params
, tsubst_flags_t complain
)
3500 vec
<tree
, va_gc
> *vec
;
3503 vec
= make_tree_vector ();
3504 for (; params
!= NULL_TREE
; params
= TREE_CHAIN (params
))
3505 vec_safe_push (vec
, TREE_VALUE (params
));
3506 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
3507 release_tree_vector (vec
);
3511 /* Build a function call using varargs. */
3514 cp_build_function_call_nary (tree function
, tsubst_flags_t complain
, ...)
3516 vec
<tree
, va_gc
> *vec
;
3520 vec
= make_tree_vector ();
3521 va_start (args
, complain
);
3522 for (t
= va_arg (args
, tree
); t
!= NULL_TREE
; t
= va_arg (args
, tree
))
3523 vec_safe_push (vec
, t
);
3525 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
3526 release_tree_vector (vec
);
3530 /* Build a function call using a vector of arguments. PARAMS may be
3531 NULL if there are no parameters. This changes the contents of
3535 cp_build_function_call_vec (tree function
, vec
<tree
, va_gc
> **params
,
3536 tsubst_flags_t complain
)
3538 tree fntype
, fndecl
;
3540 tree original
= function
;
3544 vec
<tree
, va_gc
> *allocated
= NULL
;
3547 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3548 expressions, like those used for ObjC messenger dispatches. */
3549 if (params
!= NULL
&& !vec_safe_is_empty (*params
))
3550 function
= objc_rewrite_function_call (function
, (**params
)[0]);
3552 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3553 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
3554 if (TREE_CODE (function
) == NOP_EXPR
3555 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
3556 function
= TREE_OPERAND (function
, 0);
3558 if (TREE_CODE (function
) == FUNCTION_DECL
)
3560 /* If the function is a non-template member function
3561 or a non-template friend, then we need to check the
3564 Note that if overload resolution failed with a single
3565 candidate this function will be used to explicitly diagnose
3566 the failure for the single call expression. The check is
3567 technically redundant since we also would have failed in
3568 add_function_candidate. */
3570 && (complain
& tf_error
)
3571 && !constraints_satisfied_p (function
))
3573 error ("cannot call function %qD", function
);
3574 location_t loc
= DECL_SOURCE_LOCATION (function
);
3575 diagnose_constraints (loc
, function
, NULL_TREE
);
3576 return error_mark_node
;
3579 if (!mark_used (function
, complain
) && !(complain
& tf_error
))
3580 return error_mark_node
;
3583 /* Convert anything with function type to a pointer-to-function. */
3584 if (DECL_MAIN_P (function
))
3586 if (complain
& tf_error
)
3587 pedwarn (input_location
, OPT_Wpedantic
,
3588 "ISO C++ forbids calling %<::main%> from within program");
3590 return error_mark_node
;
3592 function
= build_addr_func (function
, complain
);
3598 function
= build_addr_func (function
, complain
);
3601 if (function
== error_mark_node
)
3602 return error_mark_node
;
3604 fntype
= TREE_TYPE (function
);
3606 if (TYPE_PTRMEMFUNC_P (fntype
))
3608 if (complain
& tf_error
)
3609 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
3610 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
3611 original
, original
);
3612 return error_mark_node
;
3615 is_method
= (TYPE_PTR_P (fntype
)
3616 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
3618 if (!(TYPE_PTRFN_P (fntype
)
3620 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
3622 if (complain
& tf_error
)
3624 if (!flag_diagnostics_show_caret
)
3625 error_at (input_location
,
3626 "%qE cannot be used as a function", original
);
3627 else if (DECL_P (original
))
3628 error_at (input_location
,
3629 "%qD cannot be used as a function", original
);
3631 error_at (input_location
,
3632 "expression cannot be used as a function");
3635 return error_mark_node
;
3638 /* fntype now gets the type of function pointed to. */
3639 fntype
= TREE_TYPE (fntype
);
3640 parm_types
= TYPE_ARG_TYPES (fntype
);
3644 allocated
= make_tree_vector ();
3645 params
= &allocated
;
3648 nargs
= convert_arguments (parm_types
, params
, fndecl
, LOOKUP_NORMAL
,
3651 return error_mark_node
;
3653 argarray
= (*params
)->address ();
3655 /* Check for errors in format strings and inappropriately
3657 check_function_arguments (input_location
, fntype
, nargs
, argarray
);
3659 ret
= build_cxx_call (function
, nargs
, argarray
, complain
);
3661 if (allocated
!= NULL
)
3662 release_tree_vector (allocated
);
3667 /* Subroutine of convert_arguments.
3668 Print an error message about a wrong number of arguments. */
3671 error_args_num (location_t loc
, tree fndecl
, bool too_many_p
)
3675 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
3677 if (DECL_NAME (fndecl
) == NULL_TREE
3678 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
3681 ? G_("too many arguments to constructor %q#D")
3682 : G_("too few arguments to constructor %q#D"),
3687 ? G_("too many arguments to member function %q#D")
3688 : G_("too few arguments to member function %q#D"),
3694 ? G_("too many arguments to function %q#D")
3695 : G_("too few arguments to function %q#D"),
3697 if (!DECL_IS_BUILTIN (fndecl
))
3698 inform (DECL_SOURCE_LOCATION (fndecl
), "declared here");
3702 if (c_dialect_objc () && objc_message_selector ())
3705 ? G_("too many arguments to method %q#D")
3706 : G_("too few arguments to method %q#D"),
3707 objc_message_selector ());
3709 error_at (loc
, too_many_p
? G_("too many arguments to function")
3710 : G_("too few arguments to function"));
3714 /* Convert the actual parameter expressions in the list VALUES to the
3715 types in the list TYPELIST. The converted expressions are stored
3716 back in the VALUES vector.
3717 If parmdecls is exhausted, or when an element has NULL as its type,
3718 perform the default conversions.
3720 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
3722 This is also where warnings about wrong number of args are generated.
3724 Returns the actual number of arguments processed (which might be less
3725 than the length of the vector), or -1 on error.
3727 In C++, unspecified trailing parameters can be filled in with their
3728 default arguments, if such were specified. Do so here. */
3731 convert_arguments (tree typelist
, vec
<tree
, va_gc
> **values
, tree fndecl
,
3732 int flags
, tsubst_flags_t complain
)
3737 /* Argument passing is always copy-initialization. */
3738 flags
|= LOOKUP_ONLYCONVERTING
;
3740 for (i
= 0, typetail
= typelist
;
3741 i
< vec_safe_length (*values
);
3744 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
3745 tree val
= (**values
)[i
];
3747 if (val
== error_mark_node
|| type
== error_mark_node
)
3750 if (type
== void_type_node
)
3752 if (complain
& tf_error
)
3754 error_args_num (input_location
, fndecl
, /*too_many_p=*/true);
3761 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3762 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3763 if (TREE_CODE (val
) == NOP_EXPR
3764 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3765 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3766 val
= TREE_OPERAND (val
, 0);
3768 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3770 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3771 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3772 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3773 val
= decay_conversion (val
, complain
);
3776 if (val
== error_mark_node
)
3781 /* Formal parm type is specified by a function prototype. */
3784 if (!COMPLETE_TYPE_P (complete_type (type
)))
3786 if (complain
& tf_error
)
3789 error ("parameter %P of %qD has incomplete type %qT",
3792 error ("parameter %P has incomplete type %qT", i
, type
);
3794 parmval
= error_mark_node
;
3798 parmval
= convert_for_initialization
3799 (NULL_TREE
, type
, val
, flags
,
3800 ICR_ARGPASS
, fndecl
, i
, complain
);
3801 parmval
= convert_for_arg_passing (type
, parmval
, complain
);
3804 if (parmval
== error_mark_node
)
3807 (**values
)[i
] = parmval
;
3811 if (fndecl
&& magic_varargs_p (fndecl
))
3812 /* Don't do ellipsis conversion for __built_in_constant_p
3813 as this will result in spurious errors for non-trivial
3815 val
= require_complete_type_sfinae (val
, complain
);
3817 val
= convert_arg_to_ellipsis (val
, complain
);
3819 (**values
)[i
] = val
;
3823 typetail
= TREE_CHAIN (typetail
);
3826 if (typetail
!= 0 && typetail
!= void_list_node
)
3828 /* See if there are default arguments that can be used. Because
3829 we hold default arguments in the FUNCTION_TYPE (which is so
3830 wrong), we can see default parameters here from deduced
3831 contexts (and via typeof) for indirect function calls.
3832 Fortunately we know whether we have a function decl to
3833 provide default arguments in a language conformant
3835 if (fndecl
&& TREE_PURPOSE (typetail
)
3836 && TREE_CODE (TREE_PURPOSE (typetail
)) != DEFAULT_ARG
)
3838 for (; typetail
!= void_list_node
; ++i
)
3840 /* After DR777, with explicit template args we can end up with a
3841 default argument followed by no default argument. */
3842 if (!TREE_PURPOSE (typetail
))
3845 = convert_default_arg (TREE_VALUE (typetail
),
3846 TREE_PURPOSE (typetail
),
3847 fndecl
, i
, complain
);
3849 if (parmval
== error_mark_node
)
3852 vec_safe_push (*values
, parmval
);
3853 typetail
= TREE_CHAIN (typetail
);
3854 /* ends with `...'. */
3855 if (typetail
== NULL_TREE
)
3860 if (typetail
&& typetail
!= void_list_node
)
3862 if (complain
& tf_error
)
3863 error_args_num (input_location
, fndecl
, /*too_many_p=*/false);
3871 /* Build a binary-operation expression, after performing default
3872 conversions on the operands. CODE is the kind of expression to
3873 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
3874 are the tree codes which correspond to ARG1 and ARG2 when issuing
3875 warnings about possibly misplaced parentheses. They may differ
3876 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3877 folding (e.g., if the parser sees "a | 1 + 1", it may call this
3878 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3879 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3880 ARG2_CODE as ERROR_MARK. */
3883 build_x_binary_op (location_t loc
, enum tree_code code
, tree arg1
,
3884 enum tree_code arg1_code
, tree arg2
,
3885 enum tree_code arg2_code
, tree
*overload_p
,
3886 tsubst_flags_t complain
)
3891 tree overload
= NULL_TREE
;
3896 if (processing_template_decl
)
3898 if (type_dependent_expression_p (arg1
)
3899 || type_dependent_expression_p (arg2
))
3900 return build_min_nt_loc (loc
, code
, arg1
, arg2
);
3901 arg1
= build_non_dependent_expr (arg1
);
3902 arg2
= build_non_dependent_expr (arg2
);
3905 if (code
== DOTSTAR_EXPR
)
3906 expr
= build_m_component_ref (arg1
, arg2
, complain
);
3908 expr
= build_new_op (loc
, code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
3909 &overload
, complain
);
3911 if (overload_p
!= NULL
)
3912 *overload_p
= overload
;
3914 /* Check for cases such as x+y<<z which users are likely to
3915 misinterpret. But don't warn about obj << x + y, since that is a
3916 common idiom for I/O. */
3917 if (warn_parentheses
3918 && (complain
& tf_warning
)
3919 && !processing_template_decl
3920 && !error_operand_p (arg1
)
3921 && !error_operand_p (arg2
)
3922 && (code
!= LSHIFT_EXPR
3923 || !CLASS_TYPE_P (TREE_TYPE (arg1
))))
3924 warn_about_parentheses (loc
, code
, arg1_code
, orig_arg1
,
3925 arg2_code
, orig_arg2
);
3927 if (processing_template_decl
&& expr
!= error_mark_node
)
3929 if (overload
!= NULL_TREE
)
3930 return (build_min_non_dep_op_overload
3931 (code
, expr
, overload
, orig_arg1
, orig_arg2
));
3933 return build_min_non_dep (code
, expr
, orig_arg1
, orig_arg2
);
3939 /* Build and return an ARRAY_REF expression. */
3942 build_x_array_ref (location_t loc
, tree arg1
, tree arg2
,
3943 tsubst_flags_t complain
)
3945 tree orig_arg1
= arg1
;
3946 tree orig_arg2
= arg2
;
3948 tree overload
= NULL_TREE
;
3950 if (processing_template_decl
)
3952 if (type_dependent_expression_p (arg1
)
3953 || type_dependent_expression_p (arg2
))
3954 return build_min_nt_loc (loc
, ARRAY_REF
, arg1
, arg2
,
3955 NULL_TREE
, NULL_TREE
);
3956 arg1
= build_non_dependent_expr (arg1
);
3957 arg2
= build_non_dependent_expr (arg2
);
3960 expr
= build_new_op (loc
, ARRAY_REF
, LOOKUP_NORMAL
, arg1
, arg2
,
3961 NULL_TREE
, &overload
, complain
);
3963 if (processing_template_decl
&& expr
!= error_mark_node
)
3965 if (overload
!= NULL_TREE
)
3966 return (build_min_non_dep_op_overload
3967 (ARRAY_REF
, expr
, overload
, orig_arg1
, orig_arg2
));
3969 return build_min_non_dep (ARRAY_REF
, expr
, orig_arg1
, orig_arg2
,
3970 NULL_TREE
, NULL_TREE
);
3975 /* Return whether OP is an expression of enum type cast to integer
3976 type. In C++ even unsigned enum types are cast to signed integer
3977 types. We do not want to issue warnings about comparisons between
3978 signed and unsigned types when one of the types is an enum type.
3979 Those warnings are always false positives in practice. */
3982 enum_cast_to_int (tree op
)
3984 if (CONVERT_EXPR_P (op
)
3985 && TREE_TYPE (op
) == integer_type_node
3986 && TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == ENUMERAL_TYPE
3987 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 0))))
3990 /* The cast may have been pushed into a COND_EXPR. */
3991 if (TREE_CODE (op
) == COND_EXPR
)
3992 return (enum_cast_to_int (TREE_OPERAND (op
, 1))
3993 || enum_cast_to_int (TREE_OPERAND (op
, 2)));
3998 /* For the c-common bits. */
4000 build_binary_op (location_t location
, enum tree_code code
, tree op0
, tree op1
,
4003 return cp_build_binary_op (location
, code
, op0
, op1
, tf_warning_or_error
);
4006 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
4007 into a value of TYPE type. Comparison is done via VEC_COND_EXPR. */
4010 build_vec_cmp (tree_code code
, tree type
,
4011 tree arg0
, tree arg1
)
4013 tree zero_vec
= build_zero_cst (type
);
4014 tree minus_one_vec
= build_minus_one_cst (type
);
4015 tree cmp_type
= build_same_sized_truth_vector_type(type
);
4016 tree cmp
= build2 (code
, cmp_type
, arg0
, arg1
);
4017 return build3 (VEC_COND_EXPR
, type
, cmp
, minus_one_vec
, zero_vec
);
4020 /* Possibly warn about an address never being NULL. */
4023 warn_for_null_address (location_t location
, tree op
, tsubst_flags_t complain
)
4026 || (complain
& tf_warning
) == 0
4027 || c_inhibit_evaluation_warnings
!= 0
4028 || TREE_NO_WARNING (op
))
4031 tree cop
= fold_non_dependent_expr (op
);
4033 if (TREE_CODE (cop
) == ADDR_EXPR
4034 && decl_with_nonnull_addr_p (TREE_OPERAND (cop
, 0))
4035 && !TREE_NO_WARNING (cop
))
4036 warning_at (location
, OPT_Waddress
, "the address of %qD will never "
4037 "be NULL", TREE_OPERAND (cop
, 0));
4039 if (CONVERT_EXPR_P (op
)
4040 && TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == REFERENCE_TYPE
)
4043 STRIP_NOPS (inner_op
);
4045 if (DECL_P (inner_op
))
4046 warning_at (location
, OPT_Waddress
,
4047 "the compiler can assume that the address of "
4048 "%qD will never be NULL", inner_op
);
4052 /* Build a binary-operation expression without default conversions.
4053 CODE is the kind of expression to build.
4054 LOCATION is the location_t of the operator in the source code.
4055 This function differs from `build' in several ways:
4056 the data type of the result is computed and recorded in it,
4057 warnings are generated if arg data types are invalid,
4058 special handling for addition and subtraction of pointers is known,
4059 and some optimization is done (operations on narrow ints
4060 are done in the narrower type when that gives the same result).
4061 Constant folding is also done before the result is returned.
4063 Note that the operands will never have enumeral types
4064 because either they have just had the default conversions performed
4065 or they have both just been converted to some other type in which
4066 the arithmetic is to be done.
4068 C++: must do special pointer arithmetic when implementing
4069 multiple inheritance, and deal with pointer to member functions. */
4072 cp_build_binary_op (location_t location
,
4073 enum tree_code code
, tree orig_op0
, tree orig_op1
,
4074 tsubst_flags_t complain
)
4077 enum tree_code code0
, code1
;
4079 const char *invalid_op_diag
;
4081 /* Expression code to give to the expression when it is built.
4082 Normally this is CODE, which is what the caller asked for,
4083 but in some special cases we change it. */
4084 enum tree_code resultcode
= code
;
4086 /* Data type in which the computation is to be performed.
4087 In the simplest cases this is the common type of the arguments. */
4088 tree result_type
= NULL
;
4090 /* Nonzero means operands have already been type-converted
4091 in whatever way is necessary.
4092 Zero means they need to be converted to RESULT_TYPE. */
4095 /* Nonzero means create the expression with this type, rather than
4097 tree build_type
= 0;
4099 /* Nonzero means after finally constructing the expression
4100 convert it to this type. */
4101 tree final_type
= 0;
4103 tree result
, result_ovl
;
4104 tree orig_type
= NULL
;
4106 /* Nonzero if this is an operation like MIN or MAX which can
4107 safely be computed in short if both args are promoted shorts.
4108 Also implies COMMON.
4109 -1 indicates a bitwise operation; this makes a difference
4110 in the exact conditions for when it is safe to do the operation
4111 in a narrower mode. */
4114 /* Nonzero if this is a comparison operation;
4115 if both args are promoted shorts, compare the original shorts.
4116 Also implies COMMON. */
4117 int short_compare
= 0;
4119 /* Nonzero means set RESULT_TYPE to the common type of the args. */
4122 /* True if both operands have arithmetic type. */
4123 bool arithmetic_types_p
;
4125 /* Apply default conversions. */
4129 /* Remember whether we're doing / or %. */
4130 bool doing_div_or_mod
= false;
4132 /* Remember whether we're doing << or >>. */
4133 bool doing_shift
= false;
4135 /* Tree holding instrumentation expression. */
4136 tree instrument_expr
= NULL
;
4138 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
4139 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
4140 || code
== TRUTH_XOR_EXPR
)
4142 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
4143 op0
= decay_conversion (op0
, complain
);
4144 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
4145 op1
= decay_conversion (op1
, complain
);
4149 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
4150 op0
= cp_default_conversion (op0
, complain
);
4151 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
4152 op1
= cp_default_conversion (op1
, complain
);
4155 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
4156 STRIP_TYPE_NOPS (op0
);
4157 STRIP_TYPE_NOPS (op1
);
4159 /* DTRT if one side is an overloaded function, but complain about it. */
4160 if (type_unknown_p (op0
))
4162 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, tf_none
);
4163 if (t
!= error_mark_node
)
4165 if (complain
& tf_error
)
4166 permerror (input_location
, "assuming cast to type %qT from overloaded function",
4171 if (type_unknown_p (op1
))
4173 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, tf_none
);
4174 if (t
!= error_mark_node
)
4176 if (complain
& tf_error
)
4177 permerror (input_location
, "assuming cast to type %qT from overloaded function",
4183 type0
= TREE_TYPE (op0
);
4184 type1
= TREE_TYPE (op1
);
4186 /* The expression codes of the data types of the arguments tell us
4187 whether the arguments are integers, floating, pointers, etc. */
4188 code0
= TREE_CODE (type0
);
4189 code1
= TREE_CODE (type1
);
4191 /* If an error was already reported for one of the arguments,
4192 avoid reporting another error. */
4193 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
4194 return error_mark_node
;
4196 if ((invalid_op_diag
4197 = targetm
.invalid_binary_op (code
, type0
, type1
)))
4199 if (complain
& tf_error
)
4200 error (invalid_op_diag
);
4201 return error_mark_node
;
4204 /* Issue warnings about peculiar, but valid, uses of NULL. */
4205 if ((orig_op0
== null_node
|| orig_op1
== null_node
)
4206 /* It's reasonable to use pointer values as operands of &&
4207 and ||, so NULL is no exception. */
4208 && code
!= TRUTH_ANDIF_EXPR
&& code
!= TRUTH_ORIF_EXPR
4209 && ( /* Both are NULL (or 0) and the operation was not a
4210 comparison or a pointer subtraction. */
4211 (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)
4212 && code
!= EQ_EXPR
&& code
!= NE_EXPR
&& code
!= MINUS_EXPR
)
4213 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
4214 || (!null_ptr_cst_p (orig_op0
)
4215 && !TYPE_PTR_OR_PTRMEM_P (type0
))
4216 || (!null_ptr_cst_p (orig_op1
)
4217 && !TYPE_PTR_OR_PTRMEM_P (type1
)))
4218 && (complain
& tf_warning
))
4220 source_location loc
=
4221 expansion_point_location_if_in_system_header (input_location
);
4223 warning_at (loc
, OPT_Wpointer_arith
, "NULL used in arithmetic");
4226 /* In case when one of the operands of the binary operation is
4227 a vector and another is a scalar -- convert scalar to vector. */
4228 if ((code0
== VECTOR_TYPE
) != (code1
== VECTOR_TYPE
))
4230 enum stv_conv convert_flag
= scalar_to_vector (location
, code
, op0
, op1
,
4231 complain
& tf_error
);
4233 switch (convert_flag
)
4236 return error_mark_node
;
4239 op0
= convert (TREE_TYPE (type1
), op0
);
4240 op0
= save_expr (op0
);
4241 op0
= build_vector_from_val (type1
, op0
);
4242 type0
= TREE_TYPE (op0
);
4243 code0
= TREE_CODE (type0
);
4249 op1
= convert (TREE_TYPE (type0
), op1
);
4250 op1
= save_expr (op1
);
4251 op1
= build_vector_from_val (type0
, op1
);
4252 type1
= TREE_TYPE (op1
);
4253 code1
= TREE_CODE (type1
);
4265 /* Subtraction of two similar pointers.
4266 We must subtract them as integers, then divide by object size. */
4267 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
4268 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
4270 return pointer_diff (location
, op0
, op1
,
4271 common_pointer_type (type0
, type1
), complain
);
4272 /* In all other cases except pointer - int, the usual arithmetic
4274 else if (!(code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
))
4279 /* The pointer - int case is just like pointer + int; fall
4283 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
4284 && (code0
== INTEGER_TYPE
|| code1
== INTEGER_TYPE
))
4288 ptr_operand
= ((code0
== POINTER_TYPE
) ? op0
: op1
);
4289 int_operand
= ((code0
== INTEGER_TYPE
) ? op0
: op1
);
4290 if (processing_template_decl
)
4292 result_type
= TREE_TYPE (ptr_operand
);
4295 return cp_pointer_int_sum (location
, code
,
4307 case TRUNC_DIV_EXPR
:
4309 case FLOOR_DIV_EXPR
:
4310 case ROUND_DIV_EXPR
:
4311 case EXACT_DIV_EXPR
:
4312 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
4313 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
4314 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4315 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
4317 enum tree_code tcode0
= code0
, tcode1
= code1
;
4318 tree cop1
= fold_non_dependent_expr (op1
);
4319 doing_div_or_mod
= true;
4320 warn_for_div_by_zero (location
, cop1
);
4322 if (tcode0
== COMPLEX_TYPE
|| tcode0
== VECTOR_TYPE
)
4323 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
4324 if (tcode1
== COMPLEX_TYPE
|| tcode1
== VECTOR_TYPE
)
4325 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
4327 if (!(tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
))
4328 resultcode
= RDIV_EXPR
;
4330 /* When dividing two signed integers, we have to promote to int.
4331 unless we divide by a constant != -1. Note that default
4332 conversion will have been performed on the operands at this
4333 point, so we have to dig out the original type to find out if
4335 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
4336 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
4337 || (TREE_CODE (op1
) == INTEGER_CST
4338 && ! integer_all_onesp (op1
)));
4347 if ((code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
4348 || (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
4349 && !VECTOR_FLOAT_TYPE_P (type0
)
4350 && !VECTOR_FLOAT_TYPE_P (type1
)))
4354 case TRUNC_MOD_EXPR
:
4355 case FLOOR_MOD_EXPR
:
4357 tree cop1
= fold_non_dependent_expr (op1
);
4358 doing_div_or_mod
= true;
4359 warn_for_div_by_zero (location
, cop1
);
4362 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
4363 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
4364 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
4366 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
4368 /* Although it would be tempting to shorten always here, that loses
4369 on some targets, since the modulo instruction is undefined if the
4370 quotient can't be represented in the computation mode. We shorten
4371 only if unsigned or if dividing by something we know != -1. */
4372 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
4373 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
4374 || (TREE_CODE (op1
) == INTEGER_CST
4375 && ! integer_all_onesp (op1
)));
4380 case TRUTH_ANDIF_EXPR
:
4381 case TRUTH_ORIF_EXPR
:
4382 case TRUTH_AND_EXPR
:
4384 if (!VECTOR_TYPE_P (type0
) && VECTOR_TYPE_P (type1
))
4386 if (!COMPARISON_CLASS_P (op1
))
4387 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
4388 build_zero_cst (type1
), complain
);
4389 if (code
== TRUTH_ANDIF_EXPR
)
4391 tree z
= build_zero_cst (TREE_TYPE (op1
));
4392 return build_conditional_expr (location
, op0
, op1
, z
, complain
);
4394 else if (code
== TRUTH_ORIF_EXPR
)
4396 tree m1
= build_all_ones_cst (TREE_TYPE (op1
));
4397 return build_conditional_expr (location
, op0
, m1
, op1
, complain
);
4402 if (VECTOR_TYPE_P (type0
))
4404 if (!COMPARISON_CLASS_P (op0
))
4405 op0
= cp_build_binary_op (EXPR_LOCATION (op0
), NE_EXPR
, op0
,
4406 build_zero_cst (type0
), complain
);
4407 if (!VECTOR_TYPE_P (type1
))
4409 tree m1
= build_all_ones_cst (TREE_TYPE (op0
));
4410 tree z
= build_zero_cst (TREE_TYPE (op0
));
4411 op1
= build_conditional_expr (location
, op1
, m1
, z
, complain
);
4413 else if (!COMPARISON_CLASS_P (op1
))
4414 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
4415 build_zero_cst (type1
), complain
);
4417 if (code
== TRUTH_ANDIF_EXPR
)
4418 code
= BIT_AND_EXPR
;
4419 else if (code
== TRUTH_ORIF_EXPR
)
4420 code
= BIT_IOR_EXPR
;
4424 return cp_build_binary_op (location
, code
, op0
, op1
, complain
);
4427 result_type
= boolean_type_node
;
4430 /* Shift operations: result has same type as first operand;
4431 always convert second operand to int.
4432 Also set SHORT_SHIFT if shifting rightward. */
4435 if (code0
== VECTOR_TYPE
&& code1
== INTEGER_TYPE
4436 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
4438 result_type
= type0
;
4441 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
4442 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
4443 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
4444 && TYPE_VECTOR_SUBPARTS (type0
) == TYPE_VECTOR_SUBPARTS (type1
))
4446 result_type
= type0
;
4449 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
4451 tree const_op1
= fold_non_dependent_expr (op1
);
4452 if (TREE_CODE (const_op1
) != INTEGER_CST
)
4454 result_type
= type0
;
4456 if (TREE_CODE (const_op1
) == INTEGER_CST
)
4458 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
4460 if ((complain
& tf_warning
)
4461 && c_inhibit_evaluation_warnings
== 0)
4462 warning (OPT_Wshift_count_negative
,
4463 "right shift count is negative");
4467 if (compare_tree_int (const_op1
, TYPE_PRECISION (type0
)) >= 0
4468 && (complain
& tf_warning
)
4469 && c_inhibit_evaluation_warnings
== 0)
4470 warning (OPT_Wshift_count_overflow
,
4471 "right shift count >= width of type");
4474 /* Avoid converting op1 to result_type later. */
4480 if (code0
== VECTOR_TYPE
&& code1
== INTEGER_TYPE
4481 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
4483 result_type
= type0
;
4486 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
4487 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
4488 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
4489 && TYPE_VECTOR_SUBPARTS (type0
) == TYPE_VECTOR_SUBPARTS (type1
))
4491 result_type
= type0
;
4494 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
4496 tree const_op0
= fold_non_dependent_expr (op0
);
4497 if (TREE_CODE (const_op0
) != INTEGER_CST
)
4499 tree const_op1
= fold_non_dependent_expr (op1
);
4500 if (TREE_CODE (const_op1
) != INTEGER_CST
)
4502 result_type
= type0
;
4504 if (TREE_CODE (const_op0
) == INTEGER_CST
4505 && tree_int_cst_sgn (const_op0
) < 0
4506 && (complain
& tf_warning
)
4507 && c_inhibit_evaluation_warnings
== 0)
4508 warning (OPT_Wshift_negative_value
,
4509 "left shift of negative value");
4510 if (TREE_CODE (const_op1
) == INTEGER_CST
)
4512 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
4514 if ((complain
& tf_warning
)
4515 && c_inhibit_evaluation_warnings
== 0)
4516 warning (OPT_Wshift_count_negative
,
4517 "left shift count is negative");
4519 else if (compare_tree_int (const_op1
,
4520 TYPE_PRECISION (type0
)) >= 0)
4522 if ((complain
& tf_warning
)
4523 && c_inhibit_evaluation_warnings
== 0)
4524 warning (OPT_Wshift_count_overflow
,
4525 "left shift count >= width of type");
4527 else if (TREE_CODE (const_op0
) == INTEGER_CST
4528 && (complain
& tf_warning
))
4529 maybe_warn_shift_overflow (location
, const_op0
, const_op1
);
4531 /* Avoid converting op1 to result_type later. */
4538 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
4540 result_type
= type0
;
4541 if (TREE_CODE (op1
) == INTEGER_CST
)
4543 if (tree_int_cst_lt (op1
, integer_zero_node
))
4545 if (complain
& tf_warning
)
4546 warning (0, (code
== LROTATE_EXPR
)
4547 ? G_("left rotate count is negative")
4548 : G_("right rotate count is negative"));
4550 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
4552 if (complain
& tf_warning
)
4553 warning (0, (code
== LROTATE_EXPR
)
4554 ? G_("left rotate count >= width of type")
4555 : G_("right rotate count >= width of type"));
4558 /* Convert the shift-count to an integer, regardless of
4559 size of value being shifted. */
4560 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
4561 op1
= cp_convert (integer_type_node
, op1
, complain
);
4567 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
4568 goto vector_compare
;
4569 if ((complain
& tf_warning
)
4570 && (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
)))
4571 warning (OPT_Wfloat_equal
,
4572 "comparing floating point with == or != is unsafe");
4573 if ((complain
& tf_warning
)
4574 && ((TREE_CODE (orig_op0
) == STRING_CST
4575 && !integer_zerop (cp_fully_fold (op1
)))
4576 || (TREE_CODE (orig_op1
) == STRING_CST
4577 && !integer_zerop (cp_fully_fold (op0
)))))
4578 warning (OPT_Waddress
, "comparison with string literal results "
4579 "in unspecified behavior");
4581 build_type
= boolean_type_node
;
4582 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
4583 || code0
== COMPLEX_TYPE
|| code0
== ENUMERAL_TYPE
)
4584 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4585 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
))
4587 else if (((code0
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type0
))
4588 && null_ptr_cst_p (orig_op1
))
4589 /* Handle, eg, (void*)0 (c++/43906), and more. */
4590 || (code0
== POINTER_TYPE
4591 && TYPE_PTR_P (type1
) && integer_zerop (op1
)))
4593 if (TYPE_PTR_P (type1
))
4594 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4595 CPO_COMPARISON
, complain
);
4597 result_type
= type0
;
4599 warn_for_null_address (location
, op0
, complain
);
4601 else if (((code1
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type1
))
4602 && null_ptr_cst_p (orig_op0
))
4603 /* Handle, eg, (void*)0 (c++/43906), and more. */
4604 || (code1
== POINTER_TYPE
4605 && TYPE_PTR_P (type0
) && integer_zerop (op0
)))
4607 if (TYPE_PTR_P (type0
))
4608 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4609 CPO_COMPARISON
, complain
);
4611 result_type
= type1
;
4613 warn_for_null_address (location
, op1
, complain
);
4615 else if ((code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
4616 || (TYPE_PTRDATAMEM_P (type0
) && TYPE_PTRDATAMEM_P (type1
)))
4617 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4618 CPO_COMPARISON
, complain
);
4619 else if (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
))
4620 /* One of the operands must be of nullptr_t type. */
4621 result_type
= TREE_TYPE (nullptr_node
);
4622 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4624 result_type
= type0
;
4625 if (complain
& tf_error
)
4626 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
4628 return error_mark_node
;
4630 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
4632 result_type
= type1
;
4633 if (complain
& tf_error
)
4634 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
4636 return error_mark_node
;
4638 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (orig_op1
))
4640 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
4641 == ptrmemfunc_vbit_in_delta
)
4643 tree pfn0
, delta0
, e1
, e2
;
4645 if (TREE_SIDE_EFFECTS (op0
))
4646 op0
= save_expr (op0
);
4648 pfn0
= pfn_from_ptrmemfunc (op0
);
4649 delta0
= delta_from_ptrmemfunc (op0
);
4650 e1
= cp_build_binary_op (location
,
4653 build_zero_cst (TREE_TYPE (pfn0
)),
4655 e2
= cp_build_binary_op (location
,
4661 if (complain
& tf_warning
)
4662 maybe_warn_zero_as_null_pointer_constant (op1
, input_location
);
4664 e2
= cp_build_binary_op (location
,
4665 EQ_EXPR
, e2
, integer_zero_node
,
4667 op0
= cp_build_binary_op (location
,
4668 TRUTH_ANDIF_EXPR
, e1
, e2
,
4670 op1
= cp_convert (TREE_TYPE (op0
), integer_one_node
, complain
);
4674 op0
= build_ptrmemfunc_access_expr (op0
, pfn_identifier
);
4675 op1
= cp_convert (TREE_TYPE (op0
), op1
, complain
);
4677 result_type
= TREE_TYPE (op0
);
4679 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (orig_op0
))
4680 return cp_build_binary_op (location
, code
, op1
, op0
, complain
);
4681 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
))
4684 /* E will be the final comparison. */
4686 /* E1 and E2 are for scratch. */
4694 type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4695 CPO_COMPARISON
, complain
);
4697 if (!same_type_p (TREE_TYPE (op0
), type
))
4698 op0
= cp_convert_and_check (type
, op0
, complain
);
4699 if (!same_type_p (TREE_TYPE (op1
), type
))
4700 op1
= cp_convert_and_check (type
, op1
, complain
);
4702 if (op0
== error_mark_node
|| op1
== error_mark_node
)
4703 return error_mark_node
;
4705 if (TREE_SIDE_EFFECTS (op0
))
4706 op0
= save_expr (op0
);
4707 if (TREE_SIDE_EFFECTS (op1
))
4708 op1
= save_expr (op1
);
4710 pfn0
= pfn_from_ptrmemfunc (op0
);
4711 pfn0
= cp_fully_fold (pfn0
);
4712 /* Avoid -Waddress warnings (c++/64877). */
4713 if (TREE_CODE (pfn0
) == ADDR_EXPR
)
4714 TREE_NO_WARNING (pfn0
) = 1;
4715 pfn1
= pfn_from_ptrmemfunc (op1
);
4716 pfn1
= cp_fully_fold (pfn1
);
4717 delta0
= delta_from_ptrmemfunc (op0
);
4718 delta1
= delta_from_ptrmemfunc (op1
);
4719 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
4720 == ptrmemfunc_vbit_in_delta
)
4725 && ((op0.delta == op1.delta)
4726 || (!op0.pfn && op0.delta & 1 == 0
4727 && op1.delta & 1 == 0))
4729 The reason for the `!op0.pfn' bit is that a NULL
4730 pointer-to-member is any member with a zero PFN and
4731 LSB of the DELTA field is 0. */
4733 e1
= cp_build_binary_op (location
, BIT_AND_EXPR
,
4737 e1
= cp_build_binary_op (location
,
4738 EQ_EXPR
, e1
, integer_zero_node
,
4740 e2
= cp_build_binary_op (location
, BIT_AND_EXPR
,
4744 e2
= cp_build_binary_op (location
,
4745 EQ_EXPR
, e2
, integer_zero_node
,
4747 e1
= cp_build_binary_op (location
,
4748 TRUTH_ANDIF_EXPR
, e2
, e1
,
4750 e2
= cp_build_binary_op (location
, EQ_EXPR
,
4752 build_zero_cst (TREE_TYPE (pfn0
)),
4754 e2
= cp_build_binary_op (location
,
4755 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
4756 e1
= cp_build_binary_op (location
,
4757 EQ_EXPR
, delta0
, delta1
, complain
);
4758 e1
= cp_build_binary_op (location
,
4759 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
4766 && (!op0.pfn || op0.delta == op1.delta))
4768 The reason for the `!op0.pfn' bit is that a NULL
4769 pointer-to-member is any member with a zero PFN; the
4770 DELTA field is unspecified. */
4772 e1
= cp_build_binary_op (location
,
4773 EQ_EXPR
, delta0
, delta1
, complain
);
4774 e2
= cp_build_binary_op (location
,
4777 build_zero_cst (TREE_TYPE (pfn0
)),
4779 e1
= cp_build_binary_op (location
,
4780 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
4782 e2
= build2 (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
4783 e
= cp_build_binary_op (location
,
4784 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
4785 if (code
== EQ_EXPR
)
4787 return cp_build_binary_op (location
,
4788 EQ_EXPR
, e
, integer_zero_node
, complain
);
4792 gcc_assert (!TYPE_PTRMEMFUNC_P (type0
)
4793 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
),
4795 gcc_assert (!TYPE_PTRMEMFUNC_P (type1
)
4796 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
),
4804 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
4805 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
4807 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
4808 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4809 CPO_COMPARISON
, complain
);
4816 if (TREE_CODE (orig_op0
) == STRING_CST
4817 || TREE_CODE (orig_op1
) == STRING_CST
)
4819 if (complain
& tf_warning
)
4820 warning (OPT_Waddress
, "comparison with string literal results "
4821 "in unspecified behavior");
4824 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
4828 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
4830 && !vector_types_compatible_elements_p (type0
, type1
))
4832 if (complain
& tf_error
)
4834 error_at (location
, "comparing vectors with different "
4836 inform (location
, "operand types are %qT and %qT",
4839 return error_mark_node
;
4842 if (TYPE_VECTOR_SUBPARTS (type0
) != TYPE_VECTOR_SUBPARTS (type1
))
4844 if (complain
& tf_error
)
4846 error_at (location
, "comparing vectors with different "
4847 "number of elements");
4848 inform (location
, "operand types are %qT and %qT",
4851 return error_mark_node
;
4854 /* It's not precisely specified how the usual arithmetic
4855 conversions apply to the vector types. Here, we use
4856 the unsigned type if one of the operands is signed and
4857 the other one is unsigned. */
4858 if (TYPE_UNSIGNED (type0
) != TYPE_UNSIGNED (type1
))
4860 if (!TYPE_UNSIGNED (type0
))
4861 op0
= build1 (VIEW_CONVERT_EXPR
, type1
, op0
);
4863 op1
= build1 (VIEW_CONVERT_EXPR
, type0
, op1
);
4864 warning_at (location
, OPT_Wsign_compare
, "comparison between "
4865 "types %qT and %qT", type0
, type1
);
4868 /* Always construct signed integer vector type. */
4869 intt
= c_common_type_for_size (GET_MODE_BITSIZE
4870 (TYPE_MODE (TREE_TYPE (type0
))), 0);
4873 if (complain
& tf_error
)
4874 error_at (location
, "could not find an integer type "
4875 "of the same size as %qT", TREE_TYPE (type0
));
4876 return error_mark_node
;
4878 result_type
= build_opaque_vector_type (intt
,
4879 TYPE_VECTOR_SUBPARTS (type0
));
4881 return build_vec_cmp (resultcode
, result_type
, op0
, op1
);
4883 build_type
= boolean_type_node
;
4884 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
4885 || code0
== ENUMERAL_TYPE
)
4886 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4887 || code1
== ENUMERAL_TYPE
))
4889 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
4890 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
4891 CPO_COMPARISON
, complain
);
4892 else if (code0
== POINTER_TYPE
&& null_ptr_cst_p (orig_op1
))
4894 result_type
= type0
;
4895 if (extra_warnings
&& (complain
& tf_warning
))
4896 warning (OPT_Wextra
,
4897 "ordered comparison of pointer with integer zero");
4899 else if (code1
== POINTER_TYPE
&& null_ptr_cst_p (orig_op0
))
4901 result_type
= type1
;
4902 if (extra_warnings
&& (complain
& tf_warning
))
4903 warning (OPT_Wextra
,
4904 "ordered comparison of pointer with integer zero");
4906 else if (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
))
4907 /* One of the operands must be of nullptr_t type. */
4908 result_type
= TREE_TYPE (nullptr_node
);
4909 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4911 result_type
= type0
;
4912 if (complain
& tf_error
)
4913 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
4915 return error_mark_node
;
4917 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
4919 result_type
= type1
;
4920 if (complain
& tf_error
)
4921 permerror (input_location
, "ISO C++ forbids comparison between pointer and integer");
4923 return error_mark_node
;
4927 case UNORDERED_EXPR
:
4934 build_type
= integer_type_node
;
4935 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
4937 if (complain
& tf_error
)
4938 error ("unordered comparison on non-floating point argument");
4939 return error_mark_node
;
4948 if (((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
4949 || code0
== ENUMERAL_TYPE
)
4950 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4951 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
)))
4952 arithmetic_types_p
= 1;
4955 arithmetic_types_p
= 0;
4956 /* Vector arithmetic is only allowed when both sides are vectors. */
4957 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
4959 if (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
4960 || !vector_types_compatible_elements_p (type0
, type1
))
4962 if (complain
& tf_error
)
4964 /* "location" already embeds the locations of the
4965 operands, so we don't need to add them separately
4967 rich_location
richloc (line_table
, location
);
4968 binary_op_error (&richloc
, code
, type0
, type1
);
4970 return error_mark_node
;
4972 arithmetic_types_p
= 1;
4975 /* Determine the RESULT_TYPE, if it is not already known. */
4977 && arithmetic_types_p
4978 && (shorten
|| common
|| short_compare
))
4980 result_type
= cp_common_type (type0
, type1
);
4981 if (complain
& tf_warning
)
4982 do_warn_double_promotion (result_type
, type0
, type1
,
4983 "implicit conversion from %qT to %qT "
4984 "to match other operand of binary "
4991 if (complain
& tf_error
)
4993 "invalid operands of types %qT and %qT to binary %qO",
4994 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
4995 return error_mark_node
;
4998 /* If we're in a template, the only thing we need to know is the
5000 if (processing_template_decl
)
5002 /* Since the middle-end checks the type when doing a build2, we
5003 need to build the tree in pieces. This built tree will never
5004 get out of the front-end as we replace it when instantiating
5006 tree tmp
= build2 (resultcode
,
5007 build_type
? build_type
: result_type
,
5009 TREE_OPERAND (tmp
, 0) = op0
;
5013 if (arithmetic_types_p
)
5015 bool first_complex
= (code0
== COMPLEX_TYPE
);
5016 bool second_complex
= (code1
== COMPLEX_TYPE
);
5017 int none_complex
= (!first_complex
&& !second_complex
);
5019 /* Adapted from patch for c/24581. */
5020 if (first_complex
!= second_complex
5021 && (code
== PLUS_EXPR
5022 || code
== MINUS_EXPR
5023 || code
== MULT_EXPR
5024 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
5025 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
5026 && flag_signed_zeros
)
5028 /* An operation on mixed real/complex operands must be
5029 handled specially, but the language-independent code can
5030 more easily optimize the plain complex arithmetic if
5031 -fno-signed-zeros. */
5032 tree real_type
= TREE_TYPE (result_type
);
5036 if (TREE_TYPE (op0
) != result_type
)
5037 op0
= cp_convert_and_check (result_type
, op0
, complain
);
5038 if (TREE_TYPE (op1
) != real_type
)
5039 op1
= cp_convert_and_check (real_type
, op1
, complain
);
5043 if (TREE_TYPE (op0
) != real_type
)
5044 op0
= cp_convert_and_check (real_type
, op0
, complain
);
5045 if (TREE_TYPE (op1
) != result_type
)
5046 op1
= cp_convert_and_check (result_type
, op1
, complain
);
5048 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
5049 return error_mark_node
;
5052 op0
= save_expr (op0
);
5053 real
= cp_build_unary_op (REALPART_EXPR
, op0
, true, complain
);
5054 imag
= cp_build_unary_op (IMAGPART_EXPR
, op0
, true, complain
);
5058 case TRUNC_DIV_EXPR
:
5059 op1
= save_expr (op1
);
5060 imag
= build2 (resultcode
, real_type
, imag
, op1
);
5064 real
= build2 (resultcode
, real_type
, real
, op1
);
5072 op1
= save_expr (op1
);
5073 real
= cp_build_unary_op (REALPART_EXPR
, op1
, true, complain
);
5074 imag
= cp_build_unary_op (IMAGPART_EXPR
, op1
, true, complain
);
5078 op0
= save_expr (op0
);
5079 imag
= build2 (resultcode
, real_type
, op0
, imag
);
5082 real
= build2 (resultcode
, real_type
, op0
, real
);
5085 real
= build2 (resultcode
, real_type
, op0
, real
);
5086 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
5092 result
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
5096 /* For certain operations (which identify themselves by shorten != 0)
5097 if both args were extended from the same smaller type,
5098 do the arithmetic in that type and then extend.
5100 shorten !=0 and !=1 indicates a bitwise operation.
5101 For them, this optimization is safe only if
5102 both args are zero-extended or both are sign-extended.
5103 Otherwise, we might change the result.
5104 E.g., (short)-1 | (unsigned short)-1 is (int)-1
5105 but calculated in (unsigned short) it would be (unsigned short)-1. */
5107 if (shorten
&& none_complex
)
5109 orig_type
= result_type
;
5110 final_type
= result_type
;
5111 result_type
= shorten_binary_op (result_type
, op0
, op1
,
5115 /* Comparison operations are shortened too but differently.
5116 They identify themselves by setting short_compare = 1. */
5120 /* We call shorten_compare only for diagnostic-reason. */
5121 tree xop0
= fold_simple (op0
), xop1
= fold_simple (op1
),
5122 xresult_type
= result_type
;
5123 enum tree_code xresultcode
= resultcode
;
5124 shorten_compare (location
, &xop0
, &xop1
, &xresult_type
,
5128 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
5129 && warn_sign_compare
5130 /* Do not warn until the template is instantiated; we cannot
5131 bound the ranges of the arguments until that point. */
5132 && !processing_template_decl
5133 && (complain
& tf_warning
)
5134 && c_inhibit_evaluation_warnings
== 0
5135 /* Even unsigned enum types promote to signed int. We don't
5136 want to issue -Wsign-compare warnings for this case. */
5137 && !enum_cast_to_int (orig_op0
)
5138 && !enum_cast_to_int (orig_op1
))
5140 tree oop0
= maybe_constant_value (orig_op0
);
5141 tree oop1
= maybe_constant_value (orig_op1
);
5143 if (TREE_CODE (oop0
) != INTEGER_CST
)
5144 oop0
= cp_fully_fold (orig_op0
);
5145 if (TREE_CODE (oop1
) != INTEGER_CST
)
5146 oop1
= cp_fully_fold (orig_op1
);
5147 warn_for_sign_compare (location
, oop0
, oop1
, op0
, op1
,
5148 result_type
, resultcode
);
5152 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
5153 Then the expression will be built.
5154 It will be given type FINAL_TYPE if that is nonzero;
5155 otherwise, it will be given type RESULT_TYPE. */
5158 if (TREE_TYPE (op0
) != result_type
)
5159 op0
= cp_convert_and_check (result_type
, op0
, complain
);
5160 if (TREE_TYPE (op1
) != result_type
)
5161 op1
= cp_convert_and_check (result_type
, op1
, complain
);
5163 if (op0
== error_mark_node
|| op1
== error_mark_node
)
5164 return error_mark_node
;
5167 if (build_type
== NULL_TREE
)
5168 build_type
= result_type
;
5170 if ((flag_sanitize
& (SANITIZE_SHIFT
| SANITIZE_DIVIDE
5171 | SANITIZE_FLOAT_DIVIDE
))
5172 && !processing_template_decl
5173 && do_ubsan_in_current_function ()
5174 && (doing_div_or_mod
|| doing_shift
))
5176 /* OP0 and/or OP1 might have side-effects. */
5177 op0
= cp_save_expr (op0
);
5178 op1
= cp_save_expr (op1
);
5179 op0
= fold_non_dependent_expr (op0
);
5180 op1
= fold_non_dependent_expr (op1
);
5181 if (doing_div_or_mod
&& (flag_sanitize
& (SANITIZE_DIVIDE
5182 | SANITIZE_FLOAT_DIVIDE
)))
5184 /* For diagnostics we want to use the promoted types without
5185 shorten_binary_op. So convert the arguments to the
5186 original result_type. */
5189 if (orig_type
!= NULL
&& result_type
!= orig_type
)
5191 cop0
= cp_convert (orig_type
, op0
, complain
);
5192 cop1
= cp_convert (orig_type
, op1
, complain
);
5194 instrument_expr
= ubsan_instrument_division (location
, cop0
, cop1
);
5196 else if (doing_shift
&& (flag_sanitize
& SANITIZE_SHIFT
))
5197 instrument_expr
= ubsan_instrument_shift (location
, code
, op0
, op1
);
5200 result
= build2_loc (location
, resultcode
, build_type
, op0
, op1
);
5201 if (final_type
!= 0)
5202 result
= cp_convert (final_type
, result
, complain
);
5204 if (instrument_expr
!= NULL
)
5205 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
5206 instrument_expr
, result
);
5208 if (!processing_template_decl
)
5210 op0
= cp_fully_fold (op0
);
5211 /* Only consider the second argument if the first isn't overflowed. */
5212 if (!CONSTANT_CLASS_P (op0
) || TREE_OVERFLOW_P (op0
))
5214 op1
= cp_fully_fold (op1
);
5215 if (!CONSTANT_CLASS_P (op1
) || TREE_OVERFLOW_P (op1
))
5218 else if (!CONSTANT_CLASS_P (op0
) || !CONSTANT_CLASS_P (op1
)
5219 || TREE_OVERFLOW_P (op0
) || TREE_OVERFLOW_P (op1
))
5222 result_ovl
= fold_build2 (resultcode
, build_type
, op0
, op1
);
5223 if (TREE_OVERFLOW_P (result_ovl
))
5224 overflow_warning (location
, result_ovl
);
5229 /* Build a VEC_PERM_EXPR.
5230 This is a simple wrapper for c_build_vec_perm_expr. */
5232 build_x_vec_perm_expr (location_t loc
,
5233 tree arg0
, tree arg1
, tree arg2
,
5234 tsubst_flags_t complain
)
5236 tree orig_arg0
= arg0
;
5237 tree orig_arg1
= arg1
;
5238 tree orig_arg2
= arg2
;
5239 if (processing_template_decl
)
5241 if (type_dependent_expression_p (arg0
)
5242 || type_dependent_expression_p (arg1
)
5243 || type_dependent_expression_p (arg2
))
5244 return build_min_nt_loc (loc
, VEC_PERM_EXPR
, arg0
, arg1
, arg2
);
5245 arg0
= build_non_dependent_expr (arg0
);
5247 arg1
= build_non_dependent_expr (arg1
);
5248 arg2
= build_non_dependent_expr (arg2
);
5250 tree exp
= c_build_vec_perm_expr (loc
, arg0
, arg1
, arg2
, complain
& tf_error
);
5251 if (processing_template_decl
&& exp
!= error_mark_node
)
5252 return build_min_non_dep (VEC_PERM_EXPR
, exp
, orig_arg0
,
5253 orig_arg1
, orig_arg2
);
5257 /* Return a tree for the sum or difference (RESULTCODE says which)
5258 of pointer PTROP and integer INTOP. */
5261 cp_pointer_int_sum (location_t loc
, enum tree_code resultcode
, tree ptrop
,
5262 tree intop
, tsubst_flags_t complain
)
5264 tree res_type
= TREE_TYPE (ptrop
);
5266 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
5267 in certain circumstance (when it's valid to do so). So we need
5268 to make sure it's complete. We don't need to check here, if we
5269 can actually complete it at all, as those checks will be done in
5270 pointer_int_sum() anyway. */
5271 complete_type (TREE_TYPE (res_type
));
5273 return pointer_int_sum (loc
, resultcode
, ptrop
,
5274 intop
, complain
& tf_warning_or_error
);
5277 /* Return a tree for the difference of pointers OP0 and OP1.
5278 The resulting tree has type int. */
5281 pointer_diff (location_t loc
, tree op0
, tree op1
, tree ptrtype
,
5282 tsubst_flags_t complain
)
5285 tree restype
= ptrdiff_type_node
;
5286 tree target_type
= TREE_TYPE (ptrtype
);
5288 if (!complete_type_or_else (target_type
, NULL_TREE
))
5289 return error_mark_node
;
5291 if (VOID_TYPE_P (target_type
))
5293 if (complain
& tf_error
)
5294 permerror (loc
, "ISO C++ forbids using pointer of "
5295 "type %<void *%> in subtraction");
5297 return error_mark_node
;
5299 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
5301 if (complain
& tf_error
)
5302 permerror (loc
, "ISO C++ forbids using pointer to "
5303 "a function in subtraction");
5305 return error_mark_node
;
5307 if (TREE_CODE (target_type
) == METHOD_TYPE
)
5309 if (complain
& tf_error
)
5310 permerror (loc
, "ISO C++ forbids using pointer to "
5311 "a method in subtraction");
5313 return error_mark_node
;
5316 /* First do the subtraction as integers;
5317 then drop through to build the divide operator. */
5319 op0
= cp_build_binary_op (loc
,
5321 cp_convert (restype
, op0
, complain
),
5322 cp_convert (restype
, op1
, complain
),
5325 /* This generates an error if op1 is a pointer to an incomplete type. */
5326 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
5328 if (complain
& tf_error
)
5329 error_at (loc
, "invalid use of a pointer to an incomplete type in "
5330 "pointer arithmetic");
5332 return error_mark_node
;
5335 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (op1
)))
5337 if (complain
& tf_error
)
5338 error_at (loc
, "arithmetic on pointer to an empty aggregate");
5340 return error_mark_node
;
5343 op1
= (TYPE_PTROB_P (ptrtype
)
5344 ? size_in_bytes_loc (loc
, target_type
)
5345 : integer_one_node
);
5347 /* Do the division. */
5349 result
= build2_loc (loc
, EXACT_DIV_EXPR
, restype
, op0
,
5350 cp_convert (restype
, op1
, complain
));
5354 /* Construct and perhaps optimize a tree representation
5355 for a unary operation. CODE, a tree_code, specifies the operation
5356 and XARG is the operand. */
5359 build_x_unary_op (location_t loc
, enum tree_code code
, cp_expr xarg
,
5360 tsubst_flags_t complain
)
5362 tree orig_expr
= xarg
;
5365 tree overload
= NULL_TREE
;
5367 if (processing_template_decl
)
5369 if (type_dependent_expression_p (xarg
))
5370 return build_min_nt_loc (loc
, code
, xarg
.get_value (), NULL_TREE
);
5372 xarg
= build_non_dependent_expr (xarg
);
5377 /* [expr.unary.op] says:
5379 The address of an object of incomplete type can be taken.
5381 (And is just the ordinary address operator, not an overloaded
5382 "operator &".) However, if the type is a template
5383 specialization, we must complete the type at this point so that
5384 an overloaded "operator &" will be available if required. */
5385 if (code
== ADDR_EXPR
5386 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
5387 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
5388 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
5389 || (TREE_CODE (xarg
) == OFFSET_REF
)))
5390 /* Don't look for a function. */;
5392 exp
= build_new_op (loc
, code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
,
5393 NULL_TREE
, &overload
, complain
);
5395 if (!exp
&& code
== ADDR_EXPR
)
5397 if (is_overloaded_fn (xarg
))
5399 tree fn
= get_first_fn (xarg
);
5400 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
5402 if (complain
& tf_error
)
5403 error (DECL_CONSTRUCTOR_P (fn
)
5404 ? G_("taking address of constructor %qE")
5405 : G_("taking address of destructor %qE"),
5407 return error_mark_node
;
5411 /* A pointer to member-function can be formed only by saying
5413 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
5414 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
5416 if (TREE_CODE (xarg
) != OFFSET_REF
5417 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
5419 if (complain
& tf_error
)
5421 error ("invalid use of %qE to form a "
5422 "pointer-to-member-function", xarg
.get_value ());
5423 if (TREE_CODE (xarg
) != OFFSET_REF
)
5424 inform (input_location
, " a qualified-id is required");
5426 return error_mark_node
;
5430 if (complain
& tf_error
)
5431 error ("parentheses around %qE cannot be used to form a"
5432 " pointer-to-member-function",
5435 return error_mark_node
;
5436 PTRMEM_OK_P (xarg
) = 1;
5440 if (TREE_CODE (xarg
) == OFFSET_REF
)
5442 ptrmem
= PTRMEM_OK_P (xarg
);
5444 if (!ptrmem
&& !flag_ms_extensions
5445 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
5447 /* A single non-static member, make sure we don't allow a
5448 pointer-to-member. */
5449 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
5450 TREE_OPERAND (xarg
, 0),
5451 ovl_cons (TREE_OPERAND (xarg
, 1), NULL_TREE
));
5452 PTRMEM_OK_P (xarg
) = ptrmem
;
5456 exp
= cp_build_addr_expr_strict (xarg
, complain
);
5459 if (processing_template_decl
&& exp
!= error_mark_node
)
5461 if (overload
!= NULL_TREE
)
5462 return (build_min_non_dep_op_overload
5463 (code
, exp
, overload
, orig_expr
, integer_zero_node
));
5465 exp
= build_min_non_dep (code
, exp
, orig_expr
,
5466 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
5468 if (TREE_CODE (exp
) == ADDR_EXPR
)
5469 PTRMEM_OK_P (exp
) = ptrmem
;
5473 /* Construct and perhaps optimize a tree representation
5474 for __builtin_addressof operation. ARG specifies the operand. */
5477 cp_build_addressof (location_t loc
, tree arg
, tsubst_flags_t complain
)
5479 tree orig_expr
= arg
;
5481 if (processing_template_decl
)
5483 if (type_dependent_expression_p (arg
))
5484 return build_min_nt_loc (loc
, ADDRESSOF_EXPR
, arg
, NULL_TREE
);
5486 arg
= build_non_dependent_expr (arg
);
5489 tree exp
= cp_build_addr_expr_strict (arg
, complain
);
5491 if (processing_template_decl
&& exp
!= error_mark_node
)
5492 exp
= build_min_non_dep (ADDRESSOF_EXPR
, exp
, orig_expr
, NULL_TREE
);
5496 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
5497 constants, where a null value is represented by an INTEGER_CST of
5501 cp_truthvalue_conversion (tree expr
)
5503 tree type
= TREE_TYPE (expr
);
5504 if (TYPE_PTR_OR_PTRMEM_P (type
)
5505 /* Avoid ICE on invalid use of non-static member function. */
5506 || TREE_CODE (expr
) == FUNCTION_DECL
)
5507 return build_binary_op (input_location
, NE_EXPR
, expr
, nullptr_node
, 1);
5509 return c_common_truthvalue_conversion (input_location
, expr
);
5512 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
5515 condition_conversion (tree expr
)
5518 if (processing_template_decl
)
5520 t
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
5521 tf_warning_or_error
, LOOKUP_NORMAL
);
5522 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
5526 /* Returns the address of T. This function will fold away
5527 ADDR_EXPR of INDIRECT_REF. */
5530 build_address (tree t
)
5532 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
5533 return error_mark_node
;
5534 gcc_checking_assert (TREE_CODE (t
) != CONSTRUCTOR
);
5535 t
= build_fold_addr_expr (t
);
5536 if (TREE_CODE (t
) != ADDR_EXPR
)
5541 /* Return a NOP_EXPR converting EXPR to TYPE. */
5544 build_nop (tree type
, tree expr
)
5546 if (type
== error_mark_node
|| error_operand_p (expr
))
5548 return build1_loc (EXPR_LOCATION (expr
), NOP_EXPR
, type
, expr
);
5551 /* Take the address of ARG, whatever that means under C++ semantics.
5552 If STRICT_LVALUE is true, require an lvalue; otherwise, allow xvalues
5553 and class rvalues as well.
5555 Nothing should call this function directly; instead, callers should use
5556 cp_build_addr_expr or cp_build_addr_expr_strict. */
5559 cp_build_addr_expr_1 (tree arg
, bool strict_lvalue
, tsubst_flags_t complain
)
5564 if (!arg
|| error_operand_p (arg
))
5565 return error_mark_node
;
5567 arg
= mark_lvalue_use (arg
);
5568 argtype
= lvalue_type (arg
);
5570 gcc_assert (!identifier_p (arg
) || !IDENTIFIER_OPNAME_P (arg
));
5572 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
5573 && !really_overloaded_fn (TREE_OPERAND (arg
, 1)))
5575 /* They're trying to take the address of a unique non-static
5576 member function. This is ill-formed (except in MS-land),
5577 but let's try to DTRT.
5578 Note: We only handle unique functions here because we don't
5579 want to complain if there's a static overload; non-unique
5580 cases will be handled by instantiate_type. But we need to
5581 handle this case here to allow casts on the resulting PMF.
5582 We could defer this in non-MS mode, but it's easier to give
5583 a useful error here. */
5585 /* Inside constant member functions, the `this' pointer
5586 contains an extra const qualifier. TYPE_MAIN_VARIANT
5587 is used here to remove this const from the diagnostics
5588 and the created OFFSET_REF. */
5589 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
5590 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
5591 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
5592 return error_mark_node
;
5594 if (! flag_ms_extensions
)
5596 tree name
= DECL_NAME (fn
);
5597 if (!(complain
& tf_error
))
5598 return error_mark_node
;
5599 else if (current_class_type
5600 && TREE_OPERAND (arg
, 0) == current_class_ref
)
5601 /* An expression like &memfn. */
5602 permerror (input_location
, "ISO C++ forbids taking the address of an unqualified"
5603 " or parenthesized non-static member function to form"
5604 " a pointer to member function. Say %<&%T::%D%>",
5607 permerror (input_location
, "ISO C++ forbids taking the address of a bound member"
5608 " function to form a pointer to member function."
5612 arg
= build_offset_ref (base
, fn
, /*address_p=*/true, complain
);
5615 /* Uninstantiated types are all functions. Taking the
5616 address of a function is a no-op, so just return the
5618 if (type_unknown_p (arg
))
5619 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
5621 if (TREE_CODE (arg
) == OFFSET_REF
)
5622 /* We want a pointer to member; bypass all the code for actually taking
5623 the address of something. */
5626 /* Anything not already handled and not a true memory reference
5628 if (TREE_CODE (argtype
) != FUNCTION_TYPE
5629 && TREE_CODE (argtype
) != METHOD_TYPE
)
5631 cp_lvalue_kind kind
= lvalue_kind (arg
);
5632 if (kind
== clk_none
)
5634 if (complain
& tf_error
)
5635 lvalue_error (input_location
, lv_addressof
);
5636 return error_mark_node
;
5638 if (strict_lvalue
&& (kind
& (clk_rvalueref
|clk_class
)))
5640 if (!(complain
& tf_error
))
5641 return error_mark_node
;
5642 if (kind
& clk_class
)
5643 /* Make this a permerror because we used to accept it. */
5644 permerror (input_location
, "taking address of temporary");
5646 error ("taking address of xvalue (rvalue reference)");
5650 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
5652 tree type
= build_pointer_type (TREE_TYPE (argtype
));
5653 arg
= build1 (CONVERT_EXPR
, type
, arg
);
5656 else if (pedantic
&& DECL_MAIN_P (arg
))
5659 /* Apparently a lot of autoconf scripts for C++ packages do this,
5660 so only complain if -Wpedantic. */
5661 if (complain
& (flag_pedantic_errors
? tf_error
: tf_warning
))
5662 pedwarn (input_location
, OPT_Wpedantic
,
5663 "ISO C++ forbids taking address of function %<::main%>");
5664 else if (flag_pedantic_errors
)
5665 return error_mark_node
;
5668 /* Let &* cancel out to simplify resulting code. */
5669 if (INDIRECT_REF_P (arg
))
5671 arg
= TREE_OPERAND (arg
, 0);
5672 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
5674 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
5675 arg
= build1 (CONVERT_EXPR
, type
, arg
);
5678 /* Don't let this be an lvalue. */
5683 /* ??? Cope with user tricks that amount to offsetof. */
5684 if (TREE_CODE (argtype
) != FUNCTION_TYPE
5685 && TREE_CODE (argtype
) != METHOD_TYPE
5686 && argtype
!= unknown_type_node
5687 && (val
= get_base_address (arg
))
5688 && COMPLETE_TYPE_P (TREE_TYPE (val
))
5689 && INDIRECT_REF_P (val
)
5690 && TREE_CONSTANT (TREE_OPERAND (val
, 0)))
5692 tree type
= build_pointer_type (argtype
);
5693 return fold_convert (type
, fold_offsetof_1 (arg
));
5696 /* Handle complex lvalues (when permitted)
5697 by reduction to simpler cases. */
5698 val
= unary_complex_lvalue (ADDR_EXPR
, arg
);
5702 switch (TREE_CODE (arg
))
5706 case FIX_TRUNC_EXPR
:
5707 /* We should have handled this above in the lvalue_kind check. */
5712 arg
= BASELINK_FUNCTIONS (arg
);
5716 arg
= OVL_CURRENT (arg
);
5721 /* Turn a reference to a non-static data member into a
5722 pointer-to-member. */
5727 gcc_assert (PTRMEM_OK_P (arg
));
5729 t
= TREE_OPERAND (arg
, 1);
5730 if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
5732 if (complain
& tf_error
)
5733 error ("cannot create pointer to reference member %qD", t
);
5734 return error_mark_node
;
5737 type
= build_ptrmem_type (context_for_name_lookup (t
),
5739 t
= make_ptrmem_cst (type
, TREE_OPERAND (arg
, 1));
5747 if (argtype
!= error_mark_node
)
5748 argtype
= build_pointer_type (argtype
);
5750 if (bitfield_p (arg
))
5752 if (complain
& tf_error
)
5753 error ("attempt to take address of bit-field");
5754 return error_mark_node
;
5757 /* In a template, we are processing a non-dependent expression
5758 so we can just form an ADDR_EXPR with the correct type. */
5759 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
5761 val
= build_address (arg
);
5762 if (TREE_CODE (arg
) == OFFSET_REF
)
5763 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
5765 else if (BASELINK_P (TREE_OPERAND (arg
, 1)))
5767 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
5769 /* We can only get here with a single static member
5771 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
5772 && DECL_STATIC_FUNCTION_P (fn
));
5773 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
5774 return error_mark_node
;
5775 val
= build_address (fn
);
5776 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
5777 /* Do not lose object's side effects. */
5778 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
5779 TREE_OPERAND (arg
, 0), val
);
5783 tree object
= TREE_OPERAND (arg
, 0);
5784 tree field
= TREE_OPERAND (arg
, 1);
5785 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5786 (TREE_TYPE (object
), decl_type_context (field
)));
5787 val
= build_address (arg
);
5790 if (TYPE_PTR_P (argtype
)
5791 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
5793 build_ptrmemfunc_type (argtype
);
5794 val
= build_ptrmemfunc (argtype
, val
, 0,
5802 /* Take the address of ARG if it has one, even if it's an rvalue. */
5805 cp_build_addr_expr (tree arg
, tsubst_flags_t complain
)
5807 return cp_build_addr_expr_1 (arg
, 0, complain
);
5810 /* Take the address of ARG, but only if it's an lvalue. */
5813 cp_build_addr_expr_strict (tree arg
, tsubst_flags_t complain
)
5815 return cp_build_addr_expr_1 (arg
, 1, complain
);
5818 /* C++: Must handle pointers to members.
5820 Perhaps type instantiation should be extended to handle conversion
5821 from aggregates to types we don't yet know we want? (Or are those
5822 cases typically errors which should be reported?)
5824 NOCONVERT suppresses the default promotions (such as from short to int). */
5827 cp_build_unary_op (enum tree_code code
, tree xarg
, bool noconvert
,
5828 tsubst_flags_t complain
)
5830 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
5832 location_t location
= EXPR_LOC_OR_LOC (arg
, input_location
);
5834 const char *errstring
= NULL
;
5836 const char *invalid_op_diag
;
5838 if (!arg
|| error_operand_p (arg
))
5839 return error_mark_node
;
5841 if ((invalid_op_diag
5842 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
5847 if (complain
& tf_error
)
5848 error (invalid_op_diag
);
5849 return error_mark_node
;
5854 case UNARY_PLUS_EXPR
:
5857 int flags
= WANT_ARITH
| WANT_ENUM
;
5858 /* Unary plus (but not unary minus) is allowed on pointers. */
5859 if (code
== UNARY_PLUS_EXPR
)
5860 flags
|= WANT_POINTER
;
5861 arg
= build_expr_type_conversion (flags
, arg
, true);
5863 errstring
= (code
== NEGATE_EXPR
5864 ? _("wrong type argument to unary minus")
5865 : _("wrong type argument to unary plus"));
5868 if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
5869 arg
= cp_perform_integral_promotions (arg
, complain
);
5871 /* Make sure the result is not an lvalue: a unary plus or minus
5872 expression is always a rvalue. */
5879 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
5884 arg
= cp_default_conversion (arg
, complain
);
5885 if (arg
== error_mark_node
)
5886 return error_mark_node
;
5889 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
5890 | WANT_VECTOR_OR_COMPLEX
,
5892 errstring
= _("wrong type argument to bit-complement");
5893 else if (!noconvert
&& CP_INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
5895 /* Warn if the expression has boolean value. */
5896 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
5897 && warning_at (location
, OPT_Wbool_operation
,
5898 "%<~%> on an expression of type bool"))
5899 inform (location
, "did you mean to use logical not (%<!%>)?");
5900 arg
= cp_perform_integral_promotions (arg
, complain
);
5905 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
5906 errstring
= _("wrong type argument to abs");
5907 else if (!noconvert
)
5909 arg
= cp_default_conversion (arg
, complain
);
5910 if (arg
== error_mark_node
)
5911 return error_mark_node
;
5916 /* Conjugating a real value is a no-op, but allow it anyway. */
5917 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
5918 errstring
= _("wrong type argument to conjugation");
5919 else if (!noconvert
)
5921 arg
= cp_default_conversion (arg
, complain
);
5922 if (arg
== error_mark_node
)
5923 return error_mark_node
;
5927 case TRUTH_NOT_EXPR
:
5928 if (VECTOR_TYPE_P (TREE_TYPE (arg
)))
5929 return cp_build_binary_op (input_location
, EQ_EXPR
, arg
,
5930 build_zero_cst (TREE_TYPE (arg
)), complain
);
5931 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
5933 val
= invert_truthvalue_loc (input_location
, arg
);
5934 if (arg
!= error_mark_node
)
5936 errstring
= _("in argument to unary !");
5944 arg
= build_real_imag_expr (input_location
, code
, arg
);
5947 case PREINCREMENT_EXPR
:
5948 case POSTINCREMENT_EXPR
:
5949 case PREDECREMENT_EXPR
:
5950 case POSTDECREMENT_EXPR
:
5951 /* Handle complex lvalues (when permitted)
5952 by reduction to simpler cases. */
5954 val
= unary_complex_lvalue (code
, arg
);
5958 arg
= mark_lvalue_use (arg
);
5960 /* Increment or decrement the real part of the value,
5961 and don't change the imaginary part. */
5962 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
5966 arg
= cp_stabilize_reference (arg
);
5967 real
= cp_build_unary_op (REALPART_EXPR
, arg
, true, complain
);
5968 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, true, complain
);
5969 real
= cp_build_unary_op (code
, real
, true, complain
);
5970 if (real
== error_mark_node
|| imag
== error_mark_node
)
5971 return error_mark_node
;
5972 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
5976 /* Report invalid types. */
5978 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
5981 if (code
== PREINCREMENT_EXPR
)
5982 errstring
= _("no pre-increment operator for type");
5983 else if (code
== POSTINCREMENT_EXPR
)
5984 errstring
= _("no post-increment operator for type");
5985 else if (code
== PREDECREMENT_EXPR
)
5986 errstring
= _("no pre-decrement operator for type");
5988 errstring
= _("no post-decrement operator for type");
5991 else if (arg
== error_mark_node
)
5992 return error_mark_node
;
5994 /* Report something read-only. */
5996 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
5997 || TREE_READONLY (arg
))
5999 if (complain
& tf_error
)
6000 cxx_readonly_error (arg
, ((code
== PREINCREMENT_EXPR
6001 || code
== POSTINCREMENT_EXPR
)
6002 ? lv_increment
: lv_decrement
));
6004 return error_mark_node
;
6009 tree declared_type
= unlowered_expr_type (arg
);
6011 argtype
= TREE_TYPE (arg
);
6013 /* ARM $5.2.5 last annotation says this should be forbidden. */
6014 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
6016 if (complain
& tf_error
)
6017 permerror (input_location
, (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
6018 ? G_("ISO C++ forbids incrementing an enum")
6019 : G_("ISO C++ forbids decrementing an enum"));
6021 return error_mark_node
;
6024 /* Compute the increment. */
6026 if (TYPE_PTR_P (argtype
))
6028 tree type
= complete_type (TREE_TYPE (argtype
));
6030 if (!COMPLETE_OR_VOID_TYPE_P (type
))
6032 if (complain
& tf_error
)
6033 error (((code
== PREINCREMENT_EXPR
6034 || code
== POSTINCREMENT_EXPR
))
6035 ? G_("cannot increment a pointer to incomplete type %qT")
6036 : G_("cannot decrement a pointer to incomplete type %qT"),
6037 TREE_TYPE (argtype
));
6039 return error_mark_node
;
6041 else if (!TYPE_PTROB_P (argtype
))
6043 if (complain
& tf_error
)
6044 pedwarn (input_location
, OPT_Wpointer_arith
,
6045 (code
== PREINCREMENT_EXPR
6046 || code
== POSTINCREMENT_EXPR
)
6047 ? G_("ISO C++ forbids incrementing a pointer of type %qT")
6048 : G_("ISO C++ forbids decrementing a pointer of type %qT"),
6051 return error_mark_node
;
6054 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
6057 inc
= VECTOR_TYPE_P (argtype
)
6058 ? build_one_cst (argtype
)
6061 inc
= cp_convert (argtype
, inc
, complain
);
6063 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
6064 need to ask Objective-C to build the increment or decrement
6065 expression for it. */
6066 if (objc_is_property_ref (arg
))
6067 return objc_build_incr_expr_for_property_ref (input_location
, code
,
6070 /* Complain about anything else that is not a true lvalue. */
6071 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
6072 || code
== POSTINCREMENT_EXPR
)
6073 ? lv_increment
: lv_decrement
),
6075 return error_mark_node
;
6077 /* Forbid using -- or ++ in C++17 on `bool'. */
6078 if (TREE_CODE (declared_type
) == BOOLEAN_TYPE
)
6080 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
6082 if (complain
& tf_error
)
6083 error ("use of an operand of type %qT in %<operator--%> "
6084 "is forbidden", boolean_type_node
);
6085 return error_mark_node
;
6089 if (cxx_dialect
>= cxx1z
)
6091 if (complain
& tf_error
)
6092 error ("use of an operand of type %qT in "
6093 "%<operator++%> is forbidden in C++1z",
6095 return error_mark_node
;
6097 /* Otherwise, [depr.incr.bool] says this is deprecated. */
6098 else if (!in_system_header_at (input_location
))
6099 warning (OPT_Wdeprecated
, "use of an operand of type %qT "
6100 "in %<operator++%> is deprecated",
6103 val
= boolean_increment (code
, arg
);
6105 else if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
6106 /* An rvalue has no cv-qualifiers. */
6107 val
= build2 (code
, cv_unqualified (TREE_TYPE (arg
)), arg
, inc
);
6109 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
6111 TREE_SIDE_EFFECTS (val
) = 1;
6116 /* Note that this operation never does default_conversion
6117 regardless of NOCONVERT. */
6118 return cp_build_addr_expr (arg
, complain
);
6127 argtype
= TREE_TYPE (arg
);
6128 return build1 (code
, argtype
, arg
);
6131 if (complain
& tf_error
)
6132 error ("%s", errstring
);
6133 return error_mark_node
;
6136 /* Hook for the c-common bits that build a unary op. */
6138 build_unary_op (location_t
/*location*/,
6139 enum tree_code code
, tree xarg
, bool noconvert
)
6141 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
6144 /* Apply unary lvalue-demanding operator CODE to the expression ARG
6145 for certain kinds of expressions which are not really lvalues
6146 but which we can accept as lvalues.
6148 If ARG is not a kind of expression we can handle, return
6152 unary_complex_lvalue (enum tree_code code
, tree arg
)
6154 /* Inside a template, making these kinds of adjustments is
6155 pointless; we are only concerned with the type of the
6157 if (processing_template_decl
)
6160 /* Handle (a, b) used as an "lvalue". */
6161 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
6163 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), false,
6164 tf_warning_or_error
);
6165 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
6166 TREE_OPERAND (arg
, 0), real_result
);
6169 /* Handle (a ? b : c) used as an "lvalue". */
6170 if (TREE_CODE (arg
) == COND_EXPR
6171 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
6172 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
6174 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
6175 if (TREE_CODE (arg
) == MODIFY_EXPR
6176 || TREE_CODE (arg
) == PREINCREMENT_EXPR
6177 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
6179 tree lvalue
= TREE_OPERAND (arg
, 0);
6180 if (TREE_SIDE_EFFECTS (lvalue
))
6182 lvalue
= cp_stabilize_reference (lvalue
);
6183 arg
= build2 (TREE_CODE (arg
), TREE_TYPE (arg
),
6184 lvalue
, TREE_OPERAND (arg
, 1));
6186 return unary_complex_lvalue
6187 (code
, build2 (COMPOUND_EXPR
, TREE_TYPE (lvalue
), arg
, lvalue
));
6190 if (code
!= ADDR_EXPR
)
6193 /* Handle (a = b) used as an "lvalue" for `&'. */
6194 if (TREE_CODE (arg
) == MODIFY_EXPR
6195 || TREE_CODE (arg
) == INIT_EXPR
)
6197 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), false,
6198 tf_warning_or_error
);
6199 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
6201 TREE_NO_WARNING (arg
) = 1;
6205 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
6206 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
6207 || TREE_CODE (arg
) == OFFSET_REF
)
6210 /* We permit compiler to make function calls returning
6211 objects of aggregate type look like lvalues. */
6215 if (TREE_CODE (targ
) == SAVE_EXPR
)
6216 targ
= TREE_OPERAND (targ
, 0);
6218 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
6220 if (TREE_CODE (arg
) == SAVE_EXPR
)
6223 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, tf_warning_or_error
);
6224 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
6227 if (TREE_CODE (arg
) == SAVE_EXPR
&& INDIRECT_REF_P (targ
))
6228 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
6229 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
6232 /* Don't let anything else be handled specially. */
6236 /* Mark EXP saying that we need to be able to take the
6237 address of it; it should not be allocated in a register.
6238 Value is true if successful.
6240 C++: we do not allow `current_class_ptr' to be addressable. */
6243 cxx_mark_addressable (tree exp
)
6248 switch (TREE_CODE (x
))
6255 x
= TREE_OPERAND (x
, 0);
6259 if (x
== current_class_ptr
)
6261 error ("cannot take the address of %<this%>, which is an rvalue expression");
6262 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
6268 /* Caller should not be trying to mark initialized
6269 constant fields addressable. */
6270 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
6271 || DECL_IN_AGGR_P (x
) == 0
6273 || DECL_EXTERNAL (x
));
6277 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
6278 && !DECL_ARTIFICIAL (x
))
6280 if (VAR_P (x
) && DECL_HARD_REGISTER (x
))
6283 ("address of explicit register variable %qD requested", x
);
6286 else if (extra_warnings
)
6288 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
6290 TREE_ADDRESSABLE (x
) = 1;
6295 TREE_ADDRESSABLE (x
) = 1;
6299 TREE_ADDRESSABLE (x
) = 1;
6303 TREE_ADDRESSABLE (x
) = 1;
6304 cxx_mark_addressable (TREE_OPERAND (x
, 0));
6312 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
6315 build_x_conditional_expr (location_t loc
, tree ifexp
, tree op1
, tree op2
,
6316 tsubst_flags_t complain
)
6318 tree orig_ifexp
= ifexp
;
6319 tree orig_op1
= op1
;
6320 tree orig_op2
= op2
;
6323 if (processing_template_decl
)
6325 /* The standard says that the expression is type-dependent if
6326 IFEXP is type-dependent, even though the eventual type of the
6327 expression doesn't dependent on IFEXP. */
6328 if (type_dependent_expression_p (ifexp
)
6329 /* As a GNU extension, the middle operand may be omitted. */
6330 || (op1
&& type_dependent_expression_p (op1
))
6331 || type_dependent_expression_p (op2
))
6332 return build_min_nt_loc (loc
, COND_EXPR
, ifexp
, op1
, op2
);
6333 ifexp
= build_non_dependent_expr (ifexp
);
6335 op1
= build_non_dependent_expr (op1
);
6336 op2
= build_non_dependent_expr (op2
);
6339 expr
= build_conditional_expr (loc
, ifexp
, op1
, op2
, complain
);
6340 if (processing_template_decl
&& expr
!= error_mark_node
)
6342 tree min
= build_min_non_dep (COND_EXPR
, expr
,
6343 orig_ifexp
, orig_op1
, orig_op2
);
6344 /* Remember that the result is an lvalue or xvalue. */
6345 if (glvalue_p (expr
) && !glvalue_p (min
))
6346 TREE_TYPE (min
) = cp_build_reference_type (TREE_TYPE (min
),
6348 expr
= convert_from_reference (min
);
6353 /* Given a list of expressions, return a compound expression
6354 that performs them all and returns the value of the last of them. */
6357 build_x_compound_expr_from_list (tree list
, expr_list_kind exp
,
6358 tsubst_flags_t complain
)
6360 tree expr
= TREE_VALUE (list
);
6362 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6363 && !CONSTRUCTOR_IS_DIRECT_INIT (expr
))
6365 if (complain
& tf_error
)
6366 pedwarn (EXPR_LOC_OR_LOC (expr
, input_location
), 0,
6367 "list-initializer for non-class type must not "
6368 "be parenthesized");
6370 return error_mark_node
;
6373 if (TREE_CHAIN (list
))
6375 if (complain
& tf_error
)
6379 permerror (input_location
, "expression list treated as compound "
6380 "expression in initializer");
6383 permerror (input_location
, "expression list treated as compound "
6384 "expression in mem-initializer");
6387 permerror (input_location
, "expression list treated as compound "
6388 "expression in functional cast");
6394 return error_mark_node
;
6396 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
6397 expr
= build_x_compound_expr (EXPR_LOCATION (TREE_VALUE (list
)),
6398 expr
, TREE_VALUE (list
), complain
);
6404 /* Like build_x_compound_expr_from_list, but using a VEC. */
6407 build_x_compound_expr_from_vec (vec
<tree
, va_gc
> *vec
, const char *msg
,
6408 tsubst_flags_t complain
)
6410 if (vec_safe_is_empty (vec
))
6412 else if (vec
->length () == 1)
6422 if (complain
& tf_error
)
6423 permerror (input_location
,
6424 "%s expression list treated as compound expression",
6427 return error_mark_node
;
6431 for (ix
= 1; vec
->iterate (ix
, &t
); ++ix
)
6432 expr
= build_x_compound_expr (EXPR_LOCATION (t
), expr
,
6439 /* Handle overloading of the ',' operator when needed. */
6442 build_x_compound_expr (location_t loc
, tree op1
, tree op2
,
6443 tsubst_flags_t complain
)
6446 tree orig_op1
= op1
;
6447 tree orig_op2
= op2
;
6448 tree overload
= NULL_TREE
;
6450 if (processing_template_decl
)
6452 if (type_dependent_expression_p (op1
)
6453 || type_dependent_expression_p (op2
))
6454 return build_min_nt_loc (loc
, COMPOUND_EXPR
, op1
, op2
);
6455 op1
= build_non_dependent_expr (op1
);
6456 op2
= build_non_dependent_expr (op2
);
6459 result
= build_new_op (loc
, COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
,
6460 NULL_TREE
, &overload
, complain
);
6462 result
= cp_build_compound_expr (op1
, op2
, complain
);
6464 if (processing_template_decl
&& result
!= error_mark_node
)
6466 if (overload
!= NULL_TREE
)
6467 return (build_min_non_dep_op_overload
6468 (COMPOUND_EXPR
, result
, overload
, orig_op1
, orig_op2
));
6470 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
6476 /* Like cp_build_compound_expr, but for the c-common bits. */
6479 build_compound_expr (location_t
/*loc*/, tree lhs
, tree rhs
)
6481 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
6484 /* Build a compound expression. */
6487 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
6489 lhs
= convert_to_void (lhs
, ICV_LEFT_OF_COMMA
, complain
);
6491 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
6492 return error_mark_node
;
6495 && (TREE_CODE (lhs
) == CILK_SPAWN_STMT
6496 || TREE_CODE (rhs
) == CILK_SPAWN_STMT
))
6498 location_t loc
= (EXPR_HAS_LOCATION (lhs
) ? EXPR_LOCATION (lhs
)
6499 : EXPR_LOCATION (rhs
));
6501 "spawned function call cannot be part of a comma expression");
6502 return error_mark_node
;
6505 if (TREE_CODE (rhs
) == TARGET_EXPR
)
6507 /* If the rhs is a TARGET_EXPR, then build the compound
6508 expression inside the target_expr's initializer. This
6509 helps the compiler to eliminate unnecessary temporaries. */
6510 tree init
= TREE_OPERAND (rhs
, 1);
6512 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
6513 TREE_OPERAND (rhs
, 1) = init
;
6518 if (type_unknown_p (rhs
))
6520 if (complain
& tf_error
)
6521 error ("no context to resolve type of %qE", rhs
);
6522 return error_mark_node
;
6525 return build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
6528 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
6529 casts away constness. CAST gives the type of cast. Returns true
6530 if the cast is ill-formed, false if it is well-formed.
6532 ??? This function warns for casting away any qualifier not just
6533 const. We would like to specify exactly what qualifiers are casted
6538 check_for_casting_away_constness (tree src_type
, tree dest_type
,
6539 enum tree_code cast
, tsubst_flags_t complain
)
6541 /* C-style casts are allowed to cast away constness. With
6542 WARN_CAST_QUAL, we still want to issue a warning. */
6543 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
6546 if (!casts_away_constness (src_type
, dest_type
, complain
))
6552 if (complain
& tf_warning
)
6553 warning (OPT_Wcast_qual
,
6554 "cast from type %qT to type %qT casts away qualifiers",
6555 src_type
, dest_type
);
6558 case STATIC_CAST_EXPR
:
6559 if (complain
& tf_error
)
6560 error ("static_cast from type %qT to type %qT casts away qualifiers",
6561 src_type
, dest_type
);
6564 case REINTERPRET_CAST_EXPR
:
6565 if (complain
& tf_error
)
6566 error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
6567 src_type
, dest_type
);
6576 Warns if the cast from expression EXPR to type TYPE is useless.
6579 maybe_warn_about_useless_cast (tree type
, tree expr
, tsubst_flags_t complain
)
6581 if (warn_useless_cast
6582 && complain
& tf_warning
)
6584 if ((TREE_CODE (type
) == REFERENCE_TYPE
6585 && (TYPE_REF_IS_RVALUE (type
)
6586 ? xvalue_p (expr
) : lvalue_p (expr
))
6587 && same_type_p (TREE_TYPE (expr
), TREE_TYPE (type
)))
6588 || same_type_p (TREE_TYPE (expr
), type
))
6589 warning (OPT_Wuseless_cast
, "useless cast to type %qT", type
);
6593 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
6594 (another pointer-to-member type in the same hierarchy) and return
6595 the converted expression. If ALLOW_INVERSE_P is permitted, a
6596 pointer-to-derived may be converted to pointer-to-base; otherwise,
6597 only the other direction is permitted. If C_CAST_P is true, this
6598 conversion is taking place as part of a C-style cast. */
6601 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
6602 bool c_cast_p
, tsubst_flags_t complain
)
6604 if (TYPE_PTRDATAMEM_P (type
))
6608 if (TREE_CODE (expr
) == PTRMEM_CST
)
6609 expr
= cplus_expand_constant (expr
);
6610 delta
= get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
)),
6611 TYPE_PTRMEM_CLASS_TYPE (type
),
6613 c_cast_p
, complain
);
6614 if (delta
== error_mark_node
)
6615 return error_mark_node
;
6617 if (!integer_zerop (delta
))
6619 tree cond
, op1
, op2
;
6621 cond
= cp_build_binary_op (input_location
,
6624 build_int_cst (TREE_TYPE (expr
), -1),
6626 op1
= build_nop (ptrdiff_type_node
, expr
);
6627 op2
= cp_build_binary_op (input_location
,
6628 PLUS_EXPR
, op1
, delta
,
6631 expr
= fold_build3_loc (input_location
,
6632 COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
6636 return build_nop (type
, expr
);
6639 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
6640 allow_inverse_p
, c_cast_p
, complain
);
6643 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
6644 this static_cast is being attempted as one of the possible casts
6645 allowed by a C-style cast. (In that case, accessibility of base
6646 classes is not considered, and it is OK to cast away
6647 constness.) Return the result of the cast. *VALID_P is set to
6648 indicate whether or not the cast was valid. */
6651 build_static_cast_1 (tree type
, tree expr
, bool c_cast_p
,
6652 bool *valid_p
, tsubst_flags_t complain
)
6658 /* Assume the cast is valid. */
6661 intype
= unlowered_expr_type (expr
);
6663 /* Save casted types in the function's used types hash table. */
6664 used_types_insert (type
);
6666 /* [expr.static.cast]
6668 An lvalue of type "cv1 B", where B is a class type, can be cast
6669 to type "reference to cv2 D", where D is a class derived (clause
6670 _class.derived_) from B, if a valid standard conversion from
6671 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
6672 same cv-qualification as, or greater cv-qualification than, cv1,
6673 and B is not a virtual base class of D. */
6674 /* We check this case before checking the validity of "TYPE t =
6675 EXPR;" below because for this case:
6678 struct D : public B { D(const B&); };
6680 void f() { static_cast<const D&>(b); }
6682 we want to avoid constructing a new D. The standard is not
6683 completely clear about this issue, but our interpretation is
6684 consistent with other compilers. */
6685 if (TREE_CODE (type
) == REFERENCE_TYPE
6686 && CLASS_TYPE_P (TREE_TYPE (type
))
6687 && CLASS_TYPE_P (intype
)
6688 && (TYPE_REF_IS_RVALUE (type
) || lvalue_p (expr
))
6689 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
6690 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
6691 build_pointer_type (TYPE_MAIN_VARIANT
6692 (TREE_TYPE (type
))),
6695 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
6699 /* There is a standard conversion from "D*" to "B*" even if "B"
6700 is ambiguous or inaccessible. If this is really a
6701 static_cast, then we check both for inaccessibility and
6702 ambiguity. However, if this is a static_cast being performed
6703 because the user wrote a C-style cast, then accessibility is
6705 base
= lookup_base (TREE_TYPE (type
), intype
,
6706 c_cast_p
? ba_unique
: ba_check
,
6708 expr
= build_address (expr
);
6710 if (flag_sanitize
& SANITIZE_VPTR
)
6713 = cp_ubsan_maybe_instrument_downcast (input_location
, type
,
6719 /* Convert from "B*" to "D*". This function will check that "B"
6720 is not a virtual base of "D". */
6721 expr
= build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false,
6724 /* Convert the pointer to a reference -- but then remember that
6725 there are no expressions with reference type in C++.
6727 We call rvalue so that there's an actual tree code
6728 (NON_LVALUE_EXPR) for the static_cast; otherwise, if the operand
6729 is a variable with the same type, the conversion would get folded
6730 away, leaving just the variable and causing lvalue_kind to give
6731 the wrong answer. */
6732 return convert_from_reference (rvalue (cp_fold_convert (type
, expr
)));
6735 /* "A glvalue of type cv1 T1 can be cast to type rvalue reference to
6736 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
6737 if (TREE_CODE (type
) == REFERENCE_TYPE
6738 && TYPE_REF_IS_RVALUE (type
)
6739 && (clk
= real_lvalue_p (expr
))
6740 && reference_related_p (TREE_TYPE (type
), intype
)
6741 && (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
6743 if (clk
== clk_ordinary
)
6745 /* Handle the (non-bit-field) lvalue case here by casting to
6746 lvalue reference and then changing it to an rvalue reference.
6747 Casting an xvalue to rvalue reference will be handled by the
6749 tree lref
= cp_build_reference_type (TREE_TYPE (type
), false);
6750 result
= (perform_direct_initialization_if_possible
6751 (lref
, expr
, c_cast_p
, complain
));
6752 result
= build1 (NON_LVALUE_EXPR
, type
, result
);
6753 return convert_from_reference (result
);
6756 /* For a bit-field or packed field, bind to a temporary. */
6757 expr
= rvalue (expr
);
6760 /* Resolve overloaded address here rather than once in
6761 implicit_conversion and again in the inverse code below. */
6762 if (TYPE_PTRMEMFUNC_P (type
) && type_unknown_p (expr
))
6764 expr
= instantiate_type (type
, expr
, complain
);
6765 intype
= TREE_TYPE (expr
);
6768 /* [expr.static.cast]
6770 Any expression can be explicitly converted to type cv void. */
6771 if (VOID_TYPE_P (type
))
6772 return convert_to_void (expr
, ICV_CAST
, complain
);
6775 An abstract class shall not be used ... as the type of an explicit
6777 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
6778 return error_mark_node
;
6780 /* [expr.static.cast]
6782 An expression e can be explicitly converted to a type T using a
6783 static_cast of the form static_cast<T>(e) if the declaration T
6784 t(e);" is well-formed, for some invented temporary variable
6786 result
= perform_direct_initialization_if_possible (type
, expr
,
6787 c_cast_p
, complain
);
6790 result
= convert_from_reference (result
);
6792 /* [expr.static.cast]
6794 If T is a reference type, the result is an lvalue; otherwise,
6795 the result is an rvalue. */
6796 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6798 result
= rvalue (result
);
6800 if (result
== expr
&& SCALAR_TYPE_P (type
))
6801 /* Leave some record of the cast. */
6802 result
= build_nop (type
, expr
);
6807 /* [expr.static.cast]
6809 The inverse of any standard conversion sequence (clause _conv_),
6810 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
6811 (_conv.array_), function-to-pointer (_conv.func_), and boolean
6812 (_conv.bool_) conversions, can be performed explicitly using
6813 static_cast subject to the restriction that the explicit
6814 conversion does not cast away constness (_expr.const.cast_), and
6815 the following additional rules for specific cases: */
6816 /* For reference, the conversions not excluded are: integral
6817 promotions, floating point promotion, integral conversions,
6818 floating point conversions, floating-integral conversions,
6819 pointer conversions, and pointer to member conversions. */
6822 A value of integral _or enumeration_ type can be explicitly
6823 converted to an enumeration type. */
6824 /* The effect of all that is that any conversion between any two
6825 types which are integral, floating, or enumeration types can be
6827 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6828 || SCALAR_FLOAT_TYPE_P (type
))
6829 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
6830 || SCALAR_FLOAT_TYPE_P (intype
)))
6831 return ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
, complain
);
6833 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
6834 && CLASS_TYPE_P (TREE_TYPE (type
))
6835 && CLASS_TYPE_P (TREE_TYPE (intype
))
6836 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
6837 (TREE_TYPE (intype
))),
6838 build_pointer_type (TYPE_MAIN_VARIANT
6839 (TREE_TYPE (type
))),
6845 && check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
,
6847 return error_mark_node
;
6848 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
6849 c_cast_p
? ba_unique
: ba_check
,
6851 expr
= build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false,
6854 if (flag_sanitize
& SANITIZE_VPTR
)
6857 = cp_ubsan_maybe_instrument_downcast (input_location
, type
,
6863 return cp_fold_convert (type
, expr
);
6866 if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
6867 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
6874 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
6875 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
6877 if (TYPE_PTRDATAMEM_P (type
))
6879 t1
= (build_ptrmem_type
6881 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
6882 t2
= (build_ptrmem_type
6884 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
6891 if (can_convert (t1
, t2
, complain
) || can_convert (t2
, t1
, complain
))
6894 && check_for_casting_away_constness (intype
, type
,
6897 return error_mark_node
;
6898 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
6899 c_cast_p
, complain
);
6903 /* [expr.static.cast]
6905 An rvalue of type "pointer to cv void" can be explicitly
6906 converted to a pointer to object type. A value of type pointer
6907 to object converted to "pointer to cv void" and back to the
6908 original pointer type will have its original value. */
6909 if (TYPE_PTR_P (intype
)
6910 && VOID_TYPE_P (TREE_TYPE (intype
))
6911 && TYPE_PTROB_P (type
))
6914 && check_for_casting_away_constness (intype
, type
, STATIC_CAST_EXPR
,
6916 return error_mark_node
;
6917 return build_nop (type
, expr
);
6921 return error_mark_node
;
6924 /* Return an expression representing static_cast<TYPE>(EXPR). */
6927 build_static_cast (tree type
, tree expr
, tsubst_flags_t complain
)
6932 if (type
== error_mark_node
|| expr
== error_mark_node
)
6933 return error_mark_node
;
6935 if (processing_template_decl
)
6937 expr
= build_min (STATIC_CAST_EXPR
, type
, expr
);
6938 /* We don't know if it will or will not have side effects. */
6939 TREE_SIDE_EFFECTS (expr
) = 1;
6940 return convert_from_reference (expr
);
6943 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6944 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
6945 if (TREE_CODE (type
) != REFERENCE_TYPE
6946 && TREE_CODE (expr
) == NOP_EXPR
6947 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
6948 expr
= TREE_OPERAND (expr
, 0);
6950 result
= build_static_cast_1 (type
, expr
, /*c_cast_p=*/false, &valid_p
,
6954 if (result
!= error_mark_node
)
6955 maybe_warn_about_useless_cast (type
, expr
, complain
);
6959 if (complain
& tf_error
)
6960 error ("invalid static_cast from type %qT to type %qT",
6961 TREE_TYPE (expr
), type
);
6962 return error_mark_node
;
6965 /* EXPR is an expression with member function or pointer-to-member
6966 function type. TYPE is a pointer type. Converting EXPR to TYPE is
6967 not permitted by ISO C++, but we accept it in some modes. If we
6968 are not in one of those modes, issue a diagnostic. Return the
6969 converted expression. */
6972 convert_member_func_to_ptr (tree type
, tree expr
, tsubst_flags_t complain
)
6977 intype
= TREE_TYPE (expr
);
6978 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
6979 || TREE_CODE (intype
) == METHOD_TYPE
);
6981 if (!(complain
& tf_warning_or_error
))
6982 return error_mark_node
;
6984 if (pedantic
|| warn_pmf2ptr
)
6985 pedwarn (input_location
, pedantic
? OPT_Wpedantic
: OPT_Wpmf_conversions
,
6986 "converting from %qT to %qT", intype
, type
);
6988 if (TREE_CODE (intype
) == METHOD_TYPE
)
6989 expr
= build_addr_func (expr
, complain
);
6990 else if (TREE_CODE (expr
) == PTRMEM_CST
)
6991 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
6994 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
6995 decl
= build_address (decl
);
6996 expr
= get_member_function_from_ptrfunc (&decl
, expr
, complain
);
6999 if (expr
== error_mark_node
)
7000 return error_mark_node
;
7002 return build_nop (type
, expr
);
7005 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
7006 If C_CAST_P is true, this reinterpret cast is being done as part of
7007 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
7008 indicate whether or not reinterpret_cast was valid. */
7011 build_reinterpret_cast_1 (tree type
, tree expr
, bool c_cast_p
,
7012 bool *valid_p
, tsubst_flags_t complain
)
7016 /* Assume the cast is invalid. */
7020 if (type
== error_mark_node
|| error_operand_p (expr
))
7021 return error_mark_node
;
7023 intype
= TREE_TYPE (expr
);
7025 /* Save casted types in the function's used types hash table. */
7026 used_types_insert (type
);
7028 /* [expr.reinterpret.cast]
7029 An lvalue expression of type T1 can be cast to the type
7030 "reference to T2" if an expression of type "pointer to T1" can be
7031 explicitly converted to the type "pointer to T2" using a
7032 reinterpret_cast. */
7033 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7035 if (! lvalue_p (expr
))
7037 if (complain
& tf_error
)
7038 error ("invalid cast of an rvalue expression of type "
7041 return error_mark_node
;
7044 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
7045 "B" are related class types; the reinterpret_cast does not
7046 adjust the pointer. */
7047 if (TYPE_PTR_P (intype
)
7048 && (complain
& tf_warning
)
7049 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
7050 COMPARE_BASE
| COMPARE_DERIVED
)))
7051 warning (0, "casting %qT to %qT does not dereference pointer",
7054 expr
= cp_build_addr_expr (expr
, complain
);
7056 if (warn_strict_aliasing
> 2)
7057 strict_aliasing_warning (TREE_TYPE (expr
), type
, expr
);
7059 if (expr
!= error_mark_node
)
7060 expr
= build_reinterpret_cast_1
7061 (build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
7063 if (expr
!= error_mark_node
)
7064 /* cp_build_indirect_ref isn't right for rvalue refs. */
7065 expr
= convert_from_reference (fold_convert (type
, expr
));
7069 /* As a G++ extension, we consider conversions from member
7070 functions, and pointers to member functions to
7071 pointer-to-function and pointer-to-void types. If
7072 -Wno-pmf-conversions has not been specified,
7073 convert_member_func_to_ptr will issue an error message. */
7074 if ((TYPE_PTRMEMFUNC_P (intype
)
7075 || TREE_CODE (intype
) == METHOD_TYPE
)
7076 && TYPE_PTR_P (type
)
7077 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
7078 || VOID_TYPE_P (TREE_TYPE (type
))))
7079 return convert_member_func_to_ptr (type
, expr
, complain
);
7081 /* If the cast is not to a reference type, the lvalue-to-rvalue,
7082 array-to-pointer, and function-to-pointer conversions are
7084 expr
= decay_conversion (expr
, complain
);
7086 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
7087 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
7088 if (TREE_CODE (expr
) == NOP_EXPR
7089 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
7090 expr
= TREE_OPERAND (expr
, 0);
7092 if (error_operand_p (expr
))
7093 return error_mark_node
;
7095 intype
= TREE_TYPE (expr
);
7097 /* [expr.reinterpret.cast]
7098 A pointer can be converted to any integral type large enough to
7099 hold it. ... A value of type std::nullptr_t can be converted to
7100 an integral type; the conversion has the same meaning and
7101 validity as a conversion of (void*)0 to the integral type. */
7102 if (CP_INTEGRAL_TYPE_P (type
)
7103 && (TYPE_PTR_P (intype
) || NULLPTR_TYPE_P (intype
)))
7105 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
7107 if (complain
& tf_error
)
7108 permerror (input_location
, "cast from %qT to %qT loses precision",
7111 return error_mark_node
;
7113 if (NULLPTR_TYPE_P (intype
))
7114 return build_int_cst (type
, 0);
7116 /* [expr.reinterpret.cast]
7117 A value of integral or enumeration type can be explicitly
7118 converted to a pointer. */
7119 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
7122 else if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
7123 || TYPE_PTR_OR_PTRMEM_P (type
))
7124 && same_type_p (type
, intype
))
7126 return rvalue (expr
);
7127 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
7128 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
7129 return build_nop (type
, expr
);
7130 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
7131 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
7136 && check_for_casting_away_constness (intype
, type
,
7137 REINTERPRET_CAST_EXPR
,
7139 return error_mark_node
;
7140 /* Warn about possible alignment problems. */
7141 if (STRICT_ALIGNMENT
&& warn_cast_align
7142 && (complain
& tf_warning
)
7143 && !VOID_TYPE_P (type
)
7144 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
7145 && COMPLETE_TYPE_P (TREE_TYPE (type
))
7146 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
7147 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (intype
)))
7148 warning (OPT_Wcast_align
, "cast from %qT to %qT "
7149 "increases required alignment of target type", intype
, type
);
7151 /* We need to strip nops here, because the front end likes to
7152 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
7154 if (warn_strict_aliasing
<= 2)
7155 strict_aliasing_warning (intype
, type
, sexpr
);
7157 return build_nop (type
, expr
);
7159 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
7160 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
7162 if (complain
& tf_warning
)
7163 /* C++11 5.2.10 p8 says that "Converting a function pointer to an
7164 object pointer type or vice versa is conditionally-supported." */
7165 warning (OPT_Wconditionally_supported
,
7166 "casting between pointer-to-function and pointer-to-object "
7167 "is conditionally-supported");
7168 return build_nop (type
, expr
);
7170 else if (VECTOR_TYPE_P (type
))
7171 return convert_to_vector (type
, expr
);
7172 else if (VECTOR_TYPE_P (intype
)
7173 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7174 return convert_to_integer_nofold (type
, expr
);
7179 if (complain
& tf_error
)
7180 error ("invalid cast from type %qT to type %qT", intype
, type
);
7181 return error_mark_node
;
7184 return cp_convert (type
, expr
, complain
);
7188 build_reinterpret_cast (tree type
, tree expr
, tsubst_flags_t complain
)
7192 if (type
== error_mark_node
|| expr
== error_mark_node
)
7193 return error_mark_node
;
7195 if (processing_template_decl
)
7197 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
7199 if (!TREE_SIDE_EFFECTS (t
)
7200 && type_dependent_expression_p (expr
))
7201 /* There might turn out to be side effects inside expr. */
7202 TREE_SIDE_EFFECTS (t
) = 1;
7203 return convert_from_reference (t
);
7206 r
= build_reinterpret_cast_1 (type
, expr
, /*c_cast_p=*/false,
7207 /*valid_p=*/NULL
, complain
);
7208 if (r
!= error_mark_node
)
7209 maybe_warn_about_useless_cast (type
, expr
, complain
);
7213 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
7214 return an appropriate expression. Otherwise, return
7215 error_mark_node. If the cast is not valid, and COMPLAIN is true,
7216 then a diagnostic will be issued. If VALID_P is non-NULL, we are
7217 performing a C-style cast, its value upon return will indicate
7218 whether or not the conversion succeeded. */
7221 build_const_cast_1 (tree dst_type
, tree expr
, tsubst_flags_t complain
,
7225 tree reference_type
;
7227 /* Callers are responsible for handling error_mark_node as a
7228 destination type. */
7229 gcc_assert (dst_type
!= error_mark_node
);
7230 /* In a template, callers should be building syntactic
7231 representations of casts, not using this machinery. */
7232 gcc_assert (!processing_template_decl
);
7234 /* Assume the conversion is invalid. */
7238 if (!POINTER_TYPE_P (dst_type
) && !TYPE_PTRDATAMEM_P (dst_type
))
7240 if (complain
& tf_error
)
7241 error ("invalid use of const_cast with type %qT, "
7242 "which is not a pointer, "
7243 "reference, nor a pointer-to-data-member type", dst_type
);
7244 return error_mark_node
;
7247 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
7249 if (complain
& tf_error
)
7250 error ("invalid use of const_cast with type %qT, which is a pointer "
7251 "or reference to a function type", dst_type
);
7252 return error_mark_node
;
7255 /* Save casted types in the function's used types hash table. */
7256 used_types_insert (dst_type
);
7258 src_type
= TREE_TYPE (expr
);
7259 /* Expressions do not really have reference types. */
7260 if (TREE_CODE (src_type
) == REFERENCE_TYPE
)
7261 src_type
= TREE_TYPE (src_type
);
7263 /* [expr.const.cast]
7265 For two object types T1 and T2, if a pointer to T1 can be explicitly
7266 converted to the type "pointer to T2" using a const_cast, then the
7267 following conversions can also be made:
7269 -- an lvalue of type T1 can be explicitly converted to an lvalue of
7270 type T2 using the cast const_cast<T2&>;
7272 -- a glvalue of type T1 can be explicitly converted to an xvalue of
7273 type T2 using the cast const_cast<T2&&>; and
7275 -- if T1 is a class type, a prvalue of type T1 can be explicitly
7276 converted to an xvalue of type T2 using the cast const_cast<T2&&>. */
7278 if (TREE_CODE (dst_type
) == REFERENCE_TYPE
)
7280 reference_type
= dst_type
;
7281 if (!TYPE_REF_IS_RVALUE (dst_type
)
7287 if (complain
& tf_error
)
7288 error ("invalid const_cast of an rvalue of type %qT to type %qT",
7289 src_type
, dst_type
);
7290 return error_mark_node
;
7292 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
7293 src_type
= build_pointer_type (src_type
);
7297 reference_type
= NULL_TREE
;
7298 /* If the destination type is not a reference type, the
7299 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
7300 conversions are performed. */
7301 src_type
= type_decays_to (src_type
);
7302 if (src_type
== error_mark_node
)
7303 return error_mark_node
;
7306 if (TYPE_PTR_P (src_type
) || TYPE_PTRDATAMEM_P (src_type
))
7308 if (comp_ptr_ttypes_const (dst_type
, src_type
))
7313 /* This cast is actually a C-style cast. Issue a warning if
7314 the user is making a potentially unsafe cast. */
7315 check_for_casting_away_constness (src_type
, dst_type
,
7316 CAST_EXPR
, complain
);
7320 expr
= cp_build_addr_expr (expr
, complain
);
7321 if (expr
== error_mark_node
)
7322 return error_mark_node
;
7323 expr
= build_nop (reference_type
, expr
);
7324 return convert_from_reference (expr
);
7328 expr
= decay_conversion (expr
, complain
);
7329 if (expr
== error_mark_node
)
7330 return error_mark_node
;
7332 /* build_c_cast puts on a NOP_EXPR to make the result not an
7333 lvalue. Strip such NOP_EXPRs if VALUE is being used in
7334 non-lvalue context. */
7335 if (TREE_CODE (expr
) == NOP_EXPR
7336 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
7337 expr
= TREE_OPERAND (expr
, 0);
7338 return build_nop (dst_type
, expr
);
7342 && !at_least_as_qualified_p (TREE_TYPE (dst_type
),
7343 TREE_TYPE (src_type
)))
7344 check_for_casting_away_constness (src_type
, dst_type
, CAST_EXPR
,
7348 if (complain
& tf_error
)
7349 error ("invalid const_cast from type %qT to type %qT",
7350 src_type
, dst_type
);
7351 return error_mark_node
;
7355 build_const_cast (tree type
, tree expr
, tsubst_flags_t complain
)
7359 if (type
== error_mark_node
|| error_operand_p (expr
))
7360 return error_mark_node
;
7362 if (processing_template_decl
)
7364 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
7366 if (!TREE_SIDE_EFFECTS (t
)
7367 && type_dependent_expression_p (expr
))
7368 /* There might turn out to be side effects inside expr. */
7369 TREE_SIDE_EFFECTS (t
) = 1;
7370 return convert_from_reference (t
);
7373 r
= build_const_cast_1 (type
, expr
, complain
, /*valid_p=*/NULL
);
7374 if (r
!= error_mark_node
)
7375 maybe_warn_about_useless_cast (type
, expr
, complain
);
7379 /* Like cp_build_c_cast, but for the c-common bits. */
7382 build_c_cast (location_t
/*loc*/, tree type
, tree expr
)
7384 return cp_build_c_cast (type
, expr
, tf_warning_or_error
);
7387 /* Like the "build_c_cast" used for c-common, but using cp_expr to
7388 preserve location information even for tree nodes that don't
7392 build_c_cast (location_t loc
, tree type
, cp_expr expr
)
7394 cp_expr result
= cp_build_c_cast (type
, expr
, tf_warning_or_error
);
7395 result
.set_location (loc
);
7399 /* Build an expression representing an explicit C-style cast to type
7400 TYPE of expression EXPR. */
7403 cp_build_c_cast (tree type
, tree expr
, tsubst_flags_t complain
)
7409 if (type
== error_mark_node
|| error_operand_p (expr
))
7410 return error_mark_node
;
7412 if (processing_template_decl
)
7414 tree t
= build_min (CAST_EXPR
, type
,
7415 tree_cons (NULL_TREE
, value
, NULL_TREE
));
7416 /* We don't know if it will or will not have side effects. */
7417 TREE_SIDE_EFFECTS (t
) = 1;
7418 return convert_from_reference (t
);
7421 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
7422 'Class') should always be retained, because this information aids
7423 in method lookup. */
7424 if (objc_is_object_ptr (type
)
7425 && objc_is_object_ptr (TREE_TYPE (expr
)))
7426 return build_nop (type
, expr
);
7428 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
7429 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
7430 if (TREE_CODE (type
) != REFERENCE_TYPE
7431 && TREE_CODE (value
) == NOP_EXPR
7432 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
7433 value
= TREE_OPERAND (value
, 0);
7435 if (TREE_CODE (type
) == ARRAY_TYPE
)
7437 /* Allow casting from T1* to T2[] because Cfront allows it.
7438 NIHCL uses it. It is not valid ISO C++ however. */
7439 if (TYPE_PTR_P (TREE_TYPE (expr
)))
7441 if (complain
& tf_error
)
7442 permerror (input_location
, "ISO C++ forbids casting to an array type %qT", type
);
7444 return error_mark_node
;
7445 type
= build_pointer_type (TREE_TYPE (type
));
7449 if (complain
& tf_error
)
7450 error ("ISO C++ forbids casting to an array type %qT", type
);
7451 return error_mark_node
;
7455 if (TREE_CODE (type
) == FUNCTION_TYPE
7456 || TREE_CODE (type
) == METHOD_TYPE
)
7458 if (complain
& tf_error
)
7459 error ("invalid cast to function type %qT", type
);
7460 return error_mark_node
;
7463 if (TYPE_PTR_P (type
)
7464 && TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
7465 /* Casting to an integer of smaller size is an error detected elsewhere. */
7466 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (value
))
7467 /* Don't warn about converting any constant. */
7468 && !TREE_CONSTANT (value
))
7469 warning_at (input_location
, OPT_Wint_to_pointer_cast
,
7470 "cast to pointer from integer of different size");
7472 /* A C-style cast can be a const_cast. */
7473 result
= build_const_cast_1 (type
, value
, complain
& tf_warning
,
7477 if (result
!= error_mark_node
)
7478 maybe_warn_about_useless_cast (type
, value
, complain
);
7482 /* Or a static cast. */
7483 result
= build_static_cast_1 (type
, value
, /*c_cast_p=*/true,
7484 &valid_p
, complain
);
7485 /* Or a reinterpret_cast. */
7487 result
= build_reinterpret_cast_1 (type
, value
, /*c_cast_p=*/true,
7488 &valid_p
, complain
);
7489 /* The static_cast or reinterpret_cast may be followed by a
7492 /* A valid cast may result in errors if, for example, a
7493 conversion to an ambiguous base class is required. */
7494 && !error_operand_p (result
))
7498 maybe_warn_about_useless_cast (type
, value
, complain
);
7500 /* Non-class rvalues always have cv-unqualified type. */
7501 if (!CLASS_TYPE_P (type
))
7502 type
= TYPE_MAIN_VARIANT (type
);
7503 result_type
= TREE_TYPE (result
);
7504 if (!CLASS_TYPE_P (result_type
) && TREE_CODE (type
) != REFERENCE_TYPE
)
7505 result_type
= TYPE_MAIN_VARIANT (result_type
);
7506 /* If the type of RESULT does not match TYPE, perform a
7507 const_cast to make it match. If the static_cast or
7508 reinterpret_cast succeeded, we will differ by at most
7509 cv-qualification, so the follow-on const_cast is guaranteed
7511 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
7513 result
= build_const_cast_1 (type
, result
, false, &valid_p
);
7514 gcc_assert (valid_p
);
7519 return error_mark_node
;
7522 /* For use from the C common bits. */
7524 build_modify_expr (location_t location
,
7525 tree lhs
, tree
/*lhs_origtype*/,
7526 enum tree_code modifycode
,
7527 location_t
/*rhs_location*/, tree rhs
,
7528 tree
/*rhs_origtype*/)
7530 return cp_build_modify_expr (location
, lhs
, modifycode
, rhs
,
7531 tf_warning_or_error
);
7534 /* Build an assignment expression of lvalue LHS from value RHS.
7535 MODIFYCODE is the code for a binary operator that we use
7536 to combine the old value of LHS with RHS to get the new value.
7537 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
7539 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
7542 cp_build_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
7543 tree rhs
, tsubst_flags_t complain
)
7547 tree lhstype
= TREE_TYPE (lhs
);
7548 tree olhstype
= lhstype
;
7549 bool plain_assign
= (modifycode
== NOP_EXPR
);
7551 /* Avoid duplicate error messages from operands that had errors. */
7552 if (error_operand_p (lhs
) || error_operand_p (rhs
))
7553 return error_mark_node
;
7555 /* Handle control structure constructs used as "lvalues". Note that we
7556 leave COMPOUND_EXPR on the LHS because it is sequenced after the RHS. */
7557 switch (TREE_CODE (lhs
))
7559 /* Handle --foo = 5; as these are valid constructs in C++. */
7560 case PREDECREMENT_EXPR
:
7561 case PREINCREMENT_EXPR
:
7562 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
7563 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
7564 cp_stabilize_reference (TREE_OPERAND (lhs
, 0)),
7565 TREE_OPERAND (lhs
, 1));
7566 lhs
= build2 (COMPOUND_EXPR
, lhstype
, lhs
, TREE_OPERAND (lhs
, 0));
7570 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
7571 lhs
= build2 (TREE_CODE (lhs
), TREE_TYPE (lhs
),
7572 cp_stabilize_reference (TREE_OPERAND (lhs
, 0)),
7573 TREE_OPERAND (lhs
, 1));
7574 lhs
= build2 (COMPOUND_EXPR
, lhstype
, lhs
, TREE_OPERAND (lhs
, 0));
7579 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
7580 when neither operand has side-effects. */
7581 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
7582 return error_mark_node
;
7584 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
7585 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
7587 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
7588 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
7590 TREE_OPERAND (lhs
, 0),
7591 TREE_OPERAND (lhs
, 1)),
7592 TREE_OPERAND (lhs
, 0),
7593 TREE_OPERAND (lhs
, 1));
7596 /* Handle (a ? b : c) used as an "lvalue". */
7599 /* Produce (a ? (b = rhs) : (c = rhs))
7600 except that the RHS goes through a save-expr
7601 so the code to compute it is only emitted once. */
7603 tree preeval
= NULL_TREE
;
7605 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
7607 if (complain
& tf_error
)
7608 error ("void value not ignored as it ought to be");
7609 return error_mark_node
;
7612 rhs
= stabilize_expr (rhs
, &preeval
);
7614 /* Check this here to avoid odd errors when trying to convert
7615 a throw to the type of the COND_EXPR. */
7616 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
7617 return error_mark_node
;
7619 cond
= build_conditional_expr
7620 (input_location
, TREE_OPERAND (lhs
, 0),
7621 cp_build_modify_expr (loc
, TREE_OPERAND (lhs
, 1),
7622 modifycode
, rhs
, complain
),
7623 cp_build_modify_expr (loc
, TREE_OPERAND (lhs
, 2),
7624 modifycode
, rhs
, complain
),
7627 if (cond
== error_mark_node
)
7629 /* Make sure the code to compute the rhs comes out
7630 before the split. */
7632 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (lhs
), preeval
, cond
);
7640 if (modifycode
== INIT_EXPR
)
7642 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
7643 /* Do the default thing. */;
7644 else if (TREE_CODE (rhs
) == CONSTRUCTOR
)
7646 /* Compound literal. */
7647 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
7648 /* Call convert to generate an error; see PR 11063. */
7649 rhs
= convert (lhstype
, rhs
);
7650 result
= build2 (INIT_EXPR
, lhstype
, lhs
, rhs
);
7651 TREE_SIDE_EFFECTS (result
) = 1;
7654 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
7655 /* Do the default thing. */;
7658 vec
<tree
, va_gc
> *rhs_vec
= make_tree_vector_single (rhs
);
7659 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
7660 &rhs_vec
, lhstype
, LOOKUP_NORMAL
,
7662 release_tree_vector (rhs_vec
);
7663 if (result
== NULL_TREE
)
7664 return error_mark_node
;
7670 lhs
= require_complete_type_sfinae (lhs
, complain
);
7671 if (lhs
== error_mark_node
)
7672 return error_mark_node
;
7674 if (modifycode
== NOP_EXPR
)
7676 if (c_dialect_objc ())
7678 result
= objc_maybe_build_modify_expr (lhs
, rhs
);
7683 /* `operator=' is not an inheritable operator. */
7684 if (! MAYBE_CLASS_TYPE_P (lhstype
))
7685 /* Do the default thing. */;
7688 result
= build_new_op (input_location
, MODIFY_EXPR
,
7689 LOOKUP_NORMAL
, lhs
, rhs
,
7690 make_node (NOP_EXPR
), /*overload=*/NULL
,
7692 if (result
== NULL_TREE
)
7693 return error_mark_node
;
7700 tree init
= NULL_TREE
;
7702 /* A binary op has been requested. Combine the old LHS
7703 value with the RHS producing the value we should actually
7704 store into the LHS. */
7705 gcc_assert (!((TREE_CODE (lhstype
) == REFERENCE_TYPE
7706 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
7707 || MAYBE_CLASS_TYPE_P (lhstype
)));
7709 /* Preevaluate the RHS to make sure its evaluation is complete
7710 before the lvalue-to-rvalue conversion of the LHS:
7712 [expr.ass] With respect to an indeterminately-sequenced
7713 function call, the operation of a compound assignment is a
7714 single evaluation. [ Note: Therefore, a function call shall
7715 not intervene between the lvalue-to-rvalue conversion and the
7716 side effect associated with any single compound assignment
7717 operator. -- end note ] */
7718 lhs
= cp_stabilize_reference (lhs
);
7720 rhs
= stabilize_expr (rhs
, &init
);
7721 newrhs
= cp_build_binary_op (loc
, modifycode
, lhs
, rhs
, complain
);
7722 if (newrhs
== error_mark_node
)
7724 if (complain
& tf_error
)
7725 error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode
,
7726 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
7727 return error_mark_node
;
7731 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), init
, newrhs
);
7733 /* Now it looks like a plain assignment. */
7734 modifycode
= NOP_EXPR
;
7735 if (c_dialect_objc ())
7737 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
7742 gcc_assert (TREE_CODE (lhstype
) != REFERENCE_TYPE
);
7743 gcc_assert (TREE_CODE (TREE_TYPE (newrhs
)) != REFERENCE_TYPE
);
7746 /* The left-hand side must be an lvalue. */
7747 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
7748 return error_mark_node
;
7750 /* Warn about modifying something that is `const'. Don't warn if
7751 this is initialization. */
7752 if (modifycode
!= INIT_EXPR
7753 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
7754 /* Functions are not modifiable, even though they are
7756 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
7757 || TREE_CODE (TREE_TYPE (lhs
)) == METHOD_TYPE
7758 /* If it's an aggregate and any field is const, then it is
7759 effectively const. */
7760 || (CLASS_TYPE_P (lhstype
)
7761 && C_TYPE_FIELDS_READONLY (lhstype
))))
7763 if (complain
& tf_error
)
7764 cxx_readonly_error (lhs
, lv_assign
);
7766 return error_mark_node
;
7769 /* If storing into a structure or union member, it may have been given a
7770 lowered bitfield type. We need to convert to the declared type first,
7771 so retrieve it now. */
7773 olhstype
= unlowered_expr_type (lhs
);
7775 /* Convert new value to destination type. */
7777 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
7781 if (BRACE_ENCLOSED_INITIALIZER_P (newrhs
))
7783 if (modifycode
!= INIT_EXPR
)
7785 if (complain
& tf_error
)
7786 error ("assigning to an array from an initializer list");
7787 return error_mark_node
;
7789 if (check_array_initializer (lhs
, lhstype
, newrhs
))
7790 return error_mark_node
;
7791 newrhs
= digest_init (lhstype
, newrhs
, complain
);
7792 if (newrhs
== error_mark_node
)
7793 return error_mark_node
;
7796 /* C++11 8.5/17: "If the destination type is an array of characters,
7797 an array of char16_t, an array of char32_t, or an array of wchar_t,
7798 and the initializer is a string literal...". */
7799 else if (TREE_CODE (newrhs
) == STRING_CST
7800 && char_type_p (TREE_TYPE (TYPE_MAIN_VARIANT (lhstype
)))
7801 && modifycode
== INIT_EXPR
)
7803 newrhs
= digest_init (lhstype
, newrhs
, complain
);
7804 if (newrhs
== error_mark_node
)
7805 return error_mark_node
;
7808 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
7809 TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))))
7811 if (complain
& tf_error
)
7812 error ("incompatible types in assignment of %qT to %qT",
7813 TREE_TYPE (rhs
), lhstype
);
7814 return error_mark_node
;
7817 /* Allow array assignment in compiler-generated code. */
7818 else if (!current_function_decl
7819 || !DECL_DEFAULTED_FN (current_function_decl
))
7821 /* This routine is used for both initialization and assignment.
7822 Make sure the diagnostic message differentiates the context. */
7823 if (complain
& tf_error
)
7825 if (modifycode
== INIT_EXPR
)
7826 error ("array used as initializer");
7828 error ("invalid array assignment");
7830 return error_mark_node
;
7833 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
7834 ? 1 + (modifycode
!= INIT_EXPR
): 0;
7835 return build_vec_init (lhs
, NULL_TREE
, newrhs
,
7836 /*explicit_value_init_p=*/false,
7837 from_array
, complain
);
7840 if (modifycode
== INIT_EXPR
)
7841 /* Calls with INIT_EXPR are all direct-initialization, so don't set
7842 LOOKUP_ONLYCONVERTING. */
7843 newrhs
= convert_for_initialization (lhs
, olhstype
, newrhs
, LOOKUP_NORMAL
,
7844 ICR_INIT
, NULL_TREE
, 0,
7847 newrhs
= convert_for_assignment (olhstype
, newrhs
, ICR_ASSIGN
,
7848 NULL_TREE
, 0, complain
, LOOKUP_IMPLICIT
);
7850 if (!same_type_p (lhstype
, olhstype
))
7851 newrhs
= cp_convert_and_check (lhstype
, newrhs
, complain
);
7853 if (modifycode
!= INIT_EXPR
)
7855 if (TREE_CODE (newrhs
) == CALL_EXPR
7856 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
7857 newrhs
= build_cplus_new (lhstype
, newrhs
, complain
);
7859 /* Can't initialize directly from a TARGET_EXPR, since that would
7860 cause the lhs to be constructed twice, and possibly result in
7861 accidental self-initialization. So we force the TARGET_EXPR to be
7862 expanded without a target. */
7863 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
7864 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
7865 TREE_OPERAND (newrhs
, 0));
7868 if (newrhs
== error_mark_node
)
7869 return error_mark_node
;
7871 if (c_dialect_objc () && flag_objc_gc
)
7873 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
7879 result
= build2 (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
7880 lhstype
, lhs
, newrhs
);
7882 TREE_SIDE_EFFECTS (result
) = 1;
7884 TREE_NO_WARNING (result
) = 1;
7890 build_x_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
7891 tree rhs
, tsubst_flags_t complain
)
7893 tree orig_lhs
= lhs
;
7894 tree orig_rhs
= rhs
;
7895 tree overload
= NULL_TREE
;
7896 tree op
= build_nt (modifycode
, NULL_TREE
, NULL_TREE
);
7898 if (processing_template_decl
)
7900 if (modifycode
== NOP_EXPR
7901 || type_dependent_expression_p (lhs
)
7902 || type_dependent_expression_p (rhs
))
7903 return build_min_nt_loc (loc
, MODOP_EXPR
, lhs
,
7904 build_min_nt_loc (loc
, modifycode
, NULL_TREE
,
7907 lhs
= build_non_dependent_expr (lhs
);
7908 rhs
= build_non_dependent_expr (rhs
);
7911 if (modifycode
!= NOP_EXPR
)
7913 tree rval
= build_new_op (loc
, MODIFY_EXPR
, LOOKUP_NORMAL
,
7914 lhs
, rhs
, op
, &overload
, complain
);
7917 if (rval
== error_mark_node
)
7919 TREE_NO_WARNING (rval
) = 1;
7920 if (processing_template_decl
)
7922 if (overload
!= NULL_TREE
)
7923 return (build_min_non_dep_op_overload
7924 (MODIFY_EXPR
, rval
, overload
, orig_lhs
, orig_rhs
));
7926 return (build_min_non_dep
7927 (MODOP_EXPR
, rval
, orig_lhs
, op
, orig_rhs
));
7932 return cp_build_modify_expr (loc
, lhs
, modifycode
, rhs
, complain
);
7935 /* Helper function for get_delta_difference which assumes FROM is a base
7936 class of TO. Returns a delta for the conversion of pointer-to-member
7937 of FROM to pointer-to-member of TO. If the conversion is invalid and
7938 tf_error is not set in COMPLAIN returns error_mark_node, otherwise
7939 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
7940 If C_CAST_P is true, this conversion is taking place as part of a
7944 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
,
7945 tsubst_flags_t complain
)
7950 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
,
7953 if (binfo
== error_mark_node
)
7955 if (!(complain
& tf_error
))
7956 return error_mark_node
;
7958 error (" in pointer to member function conversion");
7959 return size_zero_node
;
7963 if (kind
!= bk_via_virtual
)
7964 return BINFO_OFFSET (binfo
);
7966 /* FROM is a virtual base class of TO. Issue an error or warning
7967 depending on whether or not this is a reinterpret cast. */
7969 if (!(complain
& tf_error
))
7970 return error_mark_node
;
7972 error ("pointer to member conversion via virtual base %qT",
7973 BINFO_TYPE (binfo_from_vbase (binfo
)));
7975 return size_zero_node
;
7982 /* Get difference in deltas for different pointer to member function
7983 types. If the conversion is invalid and tf_error is not set in
7984 COMPLAIN, returns error_mark_node, otherwise returns an integer
7985 constant of type PTRDIFF_TYPE_NODE and its value is zero if the
7986 conversion is invalid. If ALLOW_INVERSE_P is true, then allow reverse
7987 conversions as well. If C_CAST_P is true this conversion is taking
7988 place as part of a C-style cast.
7990 Note that the naming of FROM and TO is kind of backwards; the return
7991 value is what we add to a TO in order to get a FROM. They are named
7992 this way because we call this function to find out how to convert from
7993 a pointer to member of FROM to a pointer to member of TO. */
7996 get_delta_difference (tree from
, tree to
,
7997 bool allow_inverse_p
,
7998 bool c_cast_p
, tsubst_flags_t complain
)
8002 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
8003 /* Pointer to member of incomplete class is permitted*/
8004 result
= size_zero_node
;
8006 result
= get_delta_difference_1 (from
, to
, c_cast_p
, complain
);
8008 if (result
== error_mark_node
)
8009 return error_mark_node
;
8013 if (!allow_inverse_p
)
8015 if (!(complain
& tf_error
))
8016 return error_mark_node
;
8018 error_not_base_type (from
, to
);
8019 error (" in pointer to member conversion");
8020 result
= size_zero_node
;
8024 result
= get_delta_difference_1 (to
, from
, c_cast_p
, complain
);
8026 if (result
== error_mark_node
)
8027 return error_mark_node
;
8030 result
= size_diffop_loc (input_location
,
8031 size_zero_node
, result
);
8034 if (!(complain
& tf_error
))
8035 return error_mark_node
;
8037 error_not_base_type (from
, to
);
8038 error (" in pointer to member conversion");
8039 result
= size_zero_node
;
8044 return convert_to_integer (ptrdiff_type_node
, result
);
8047 /* Return a constructor for the pointer-to-member-function TYPE using
8048 the other components as specified. */
8051 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
8056 vec
<constructor_elt
, va_gc
> *v
;
8058 /* Pull the FIELD_DECLs out of the type. */
8059 pfn_field
= TYPE_FIELDS (type
);
8060 delta_field
= DECL_CHAIN (pfn_field
);
8062 /* Make sure DELTA has the type we want. */
8063 delta
= convert_and_check (input_location
, delta_type_node
, delta
);
8065 /* Convert to the correct target type if necessary. */
8066 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
8068 /* Finish creating the initializer. */
8070 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
8071 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
8072 u
= build_constructor (type
, v
);
8073 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
8074 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
8075 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
8077 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
8082 /* Build a constructor for a pointer to member function. It can be
8083 used to initialize global variables, local variable, or used
8084 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
8087 If FORCE is nonzero, then force this conversion, even if
8088 we would rather not do it. Usually set when using an explicit
8089 cast. A C-style cast is being processed iff C_CAST_P is true.
8091 Return error_mark_node, if something goes wrong. */
8094 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
,
8095 tsubst_flags_t complain
)
8101 if (error_operand_p (pfn
))
8102 return error_mark_node
;
8104 pfn_type
= TREE_TYPE (pfn
);
8105 to_type
= build_ptrmemfunc_type (type
);
8107 /* Handle multiple conversions of pointer to member functions. */
8108 if (TYPE_PTRMEMFUNC_P (pfn_type
))
8110 tree delta
= NULL_TREE
;
8111 tree npfn
= NULL_TREE
;
8115 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
,
8116 LOOKUP_NORMAL
, complain
))
8118 if (complain
& tf_error
)
8119 error ("invalid conversion to type %qT from type %qT",
8122 return error_mark_node
;
8125 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
8126 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
8128 c_cast_p
, complain
);
8129 if (n
== error_mark_node
)
8130 return error_mark_node
;
8132 /* We don't have to do any conversion to convert a
8133 pointer-to-member to its own type. But, we don't want to
8134 just return a PTRMEM_CST if there's an explicit cast; that
8135 cast should make the expression an invalid template argument. */
8136 if (TREE_CODE (pfn
) != PTRMEM_CST
)
8138 if (same_type_p (to_type
, pfn_type
))
8140 else if (integer_zerop (n
))
8141 return build_reinterpret_cast (to_type
, pfn
,
8145 if (TREE_SIDE_EFFECTS (pfn
))
8146 pfn
= save_expr (pfn
);
8148 /* Obtain the function pointer and the current DELTA. */
8149 if (TREE_CODE (pfn
) == PTRMEM_CST
)
8150 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
8153 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
8154 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
8157 /* Just adjust the DELTA field. */
8158 gcc_assert (same_type_ignoring_top_level_qualifiers_p
8159 (TREE_TYPE (delta
), ptrdiff_type_node
));
8160 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
8161 n
= cp_build_binary_op (input_location
,
8162 LSHIFT_EXPR
, n
, integer_one_node
,
8164 delta
= cp_build_binary_op (input_location
,
8165 PLUS_EXPR
, delta
, n
, complain
);
8166 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
8169 /* Handle null pointer to member function conversions. */
8170 if (null_ptr_cst_p (pfn
))
8172 pfn
= cp_build_c_cast (type
, pfn
, complain
);
8173 return build_ptrmemfunc1 (to_type
,
8178 if (type_unknown_p (pfn
))
8179 return instantiate_type (type
, pfn
, complain
);
8181 fn
= TREE_OPERAND (pfn
, 0);
8182 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
8183 /* In a template, we will have preserved the
8185 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
8186 return make_ptrmem_cst (to_type
, fn
);
8189 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
8192 ??? There is no consistency as to the types returned for the above
8193 values. Some code acts as if it were a sizetype and some as if it were
8194 integer_type_node. */
8197 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
8199 tree type
= TREE_TYPE (cst
);
8200 tree fn
= PTRMEM_CST_MEMBER (cst
);
8201 tree ptr_class
, fn_class
;
8203 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
8205 /* The class that the function belongs to. */
8206 fn_class
= DECL_CONTEXT (fn
);
8208 /* The class that we're creating a pointer to member of. */
8209 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
8211 /* First, calculate the adjustment to the function's class. */
8212 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
8213 /*c_cast_p=*/0, tf_warning_or_error
);
8215 if (!DECL_VIRTUAL_P (fn
))
8216 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
),
8217 build_addr_func (fn
, tf_warning_or_error
));
8220 /* If we're dealing with a virtual function, we have to adjust 'this'
8221 again, to point to the base which provides the vtable entry for
8222 fn; the call will do the opposite adjustment. */
8223 tree orig_class
= DECL_CONTEXT (fn
);
8224 tree binfo
= binfo_or_else (orig_class
, fn_class
);
8225 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
8226 *delta
, BINFO_OFFSET (binfo
));
8228 /* We set PFN to the vtable offset at which the function can be
8229 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
8230 case delta is shifted left, and then incremented). */
8231 *pfn
= DECL_VINDEX (fn
);
8232 *pfn
= fold_build2 (MULT_EXPR
, integer_type_node
, *pfn
,
8233 TYPE_SIZE_UNIT (vtable_entry_type
));
8235 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
8237 case ptrmemfunc_vbit_in_pfn
:
8238 *pfn
= fold_build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
8242 case ptrmemfunc_vbit_in_delta
:
8243 *delta
= fold_build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
8244 *delta
, integer_one_node
);
8245 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
8246 *delta
, integer_one_node
);
8253 *pfn
= fold_convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
8257 /* Return an expression for PFN from the pointer-to-member function
8261 pfn_from_ptrmemfunc (tree t
)
8263 if (TREE_CODE (t
) == PTRMEM_CST
)
8268 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
8273 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
8276 /* Return an expression for DELTA from the pointer-to-member function
8280 delta_from_ptrmemfunc (tree t
)
8282 if (TREE_CODE (t
) == PTRMEM_CST
)
8287 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
8292 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
8295 /* Convert value RHS to type TYPE as preparation for an assignment to
8296 an lvalue of type TYPE. ERRTYPE indicates what kind of error the
8297 implicit conversion is. If FNDECL is non-NULL, we are doing the
8298 conversion in order to pass the PARMNUMth argument of FNDECL.
8299 If FNDECL is NULL, we are doing the conversion in function pointer
8300 argument passing, conversion in initialization, etc. */
8303 convert_for_assignment (tree type
, tree rhs
,
8304 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
8305 tsubst_flags_t complain
, int flags
)
8308 enum tree_code coder
;
8310 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
8311 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
8312 rhs
= TREE_OPERAND (rhs
, 0);
8314 /* Handle [dcl.init.list] direct-list-initialization from
8315 single element of enumeration with a fixed underlying type. */
8316 if (is_direct_enum_init (type
, rhs
))
8318 tree elt
= CONSTRUCTOR_ELT (rhs
, 0)->value
;
8319 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
8320 rhs
= cp_build_c_cast (type
, elt
, complain
);
8322 rhs
= error_mark_node
;
8325 rhstype
= TREE_TYPE (rhs
);
8326 coder
= TREE_CODE (rhstype
);
8328 if (VECTOR_TYPE_P (type
) && coder
== VECTOR_TYPE
8329 && vector_types_convertible_p (type
, rhstype
, true))
8331 rhs
= mark_rvalue_use (rhs
);
8332 return convert (type
, rhs
);
8335 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
8336 return error_mark_node
;
8337 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
8338 return error_mark_node
;
8340 /* The RHS of an assignment cannot have void type. */
8341 if (coder
== VOID_TYPE
)
8343 if (complain
& tf_error
)
8344 error ("void value not ignored as it ought to be");
8345 return error_mark_node
;
8348 if (c_dialect_objc ())
8352 tree rname
= fndecl
;
8363 selector
= objc_message_selector ();
8365 if (selector
&& parmno
> 1)
8372 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
8374 rhs
= mark_rvalue_use (rhs
);
8375 return convert (type
, rhs
);
8381 The expression is implicitly converted (clause _conv_) to the
8382 cv-unqualified type of the left operand.
8384 We allow bad conversions here because by the time we get to this point
8385 we are committed to doing the conversion. If we end up doing a bad
8386 conversion, convert_like will complain. */
8387 if (!can_convert_arg_bad (type
, rhstype
, rhs
, flags
, complain
))
8389 /* When -Wno-pmf-conversions is use, we just silently allow
8390 conversions from pointers-to-members to plain pointers. If
8391 the conversion doesn't work, cp_convert will complain. */
8393 && TYPE_PTR_P (type
)
8394 && TYPE_PTRMEMFUNC_P (rhstype
))
8395 rhs
= cp_convert (strip_top_quals (type
), rhs
, complain
);
8398 if (complain
& tf_error
)
8400 /* If the right-hand side has unknown type, then it is an
8401 overloaded function. Call instantiate_type to get error
8403 if (rhstype
== unknown_type_node
)
8404 instantiate_type (type
, rhs
, tf_warning_or_error
);
8406 error ("cannot convert %qT to %qT for argument %qP to %qD",
8407 rhstype
, type
, parmnum
, fndecl
);
8411 case ICR_DEFAULT_ARGUMENT
:
8412 error ("cannot convert %qT to %qT in default argument",
8416 error ("cannot convert %qT to %qT in argument passing",
8419 case ICR_CONVERTING
:
8420 error ("cannot convert %qT to %qT",
8424 error ("cannot convert %qT to %qT in initialization",
8428 error ("cannot convert %qT to %qT in return",
8432 error ("cannot convert %qT to %qT in assignment",
8438 if (TYPE_PTR_P (rhstype
)
8439 && TYPE_PTR_P (type
)
8440 && CLASS_TYPE_P (TREE_TYPE (rhstype
))
8441 && CLASS_TYPE_P (TREE_TYPE (type
))
8442 && !COMPLETE_TYPE_P (TREE_TYPE (rhstype
)))
8443 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL
8444 (TREE_TYPE (rhstype
))),
8445 "class type %qT is incomplete", TREE_TYPE (rhstype
));
8447 return error_mark_node
;
8450 if (warn_suggest_attribute_format
)
8452 const enum tree_code codel
= TREE_CODE (type
);
8453 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
8455 && check_missing_format_attribute (type
, rhstype
)
8456 && (complain
& tf_warning
))
8460 case ICR_DEFAULT_ARGUMENT
:
8462 warning (OPT_Wsuggest_attribute_format
,
8463 "parameter %qP of %qD might be a candidate "
8464 "for a format attribute", parmnum
, fndecl
);
8466 warning (OPT_Wsuggest_attribute_format
,
8467 "parameter might be a candidate "
8468 "for a format attribute");
8470 case ICR_CONVERTING
:
8471 warning (OPT_Wsuggest_attribute_format
,
8472 "target of conversion might be a candidate "
8473 "for a format attribute");
8476 warning (OPT_Wsuggest_attribute_format
,
8477 "target of initialization might be a candidate "
8478 "for a format attribute");
8481 warning (OPT_Wsuggest_attribute_format
,
8482 "return type might be a candidate "
8483 "for a format attribute");
8486 warning (OPT_Wsuggest_attribute_format
,
8487 "left-hand side of assignment might be a candidate "
8488 "for a format attribute");
8495 /* If -Wparentheses, warn about a = b = c when a has type bool and b
8497 if (warn_parentheses
8498 && TREE_CODE (type
) == BOOLEAN_TYPE
8499 && TREE_CODE (rhs
) == MODIFY_EXPR
8500 && !TREE_NO_WARNING (rhs
)
8501 && TREE_CODE (TREE_TYPE (rhs
)) != BOOLEAN_TYPE
8502 && (complain
& tf_warning
))
8504 location_t loc
= EXPR_LOC_OR_LOC (rhs
, input_location
);
8506 warning_at (loc
, OPT_Wparentheses
,
8507 "suggest parentheses around assignment used as truth value");
8508 TREE_NO_WARNING (rhs
) = 1;
8511 return perform_implicit_conversion_flags (strip_top_quals (type
), rhs
,
8515 /* Convert RHS to be of type TYPE.
8516 If EXP is nonzero, it is the target of the initialization.
8517 ERRTYPE indicates what kind of error the implicit conversion is.
8519 Two major differences between the behavior of
8520 `convert_for_assignment' and `convert_for_initialization'
8521 are that references are bashed in the former, while
8522 copied in the latter, and aggregates are assigned in
8523 the former (operator=) while initialized in the
8526 If using constructor make sure no conversion operator exists, if one does
8527 exist, an ambiguity exists. */
8530 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
8531 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
8532 tsubst_flags_t complain
)
8534 enum tree_code codel
= TREE_CODE (type
);
8536 enum tree_code coder
;
8538 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8539 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
8540 if (TREE_CODE (rhs
) == NOP_EXPR
8541 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
8542 && codel
!= REFERENCE_TYPE
)
8543 rhs
= TREE_OPERAND (rhs
, 0);
8545 if (type
== error_mark_node
8546 || rhs
== error_mark_node
8547 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
8548 return error_mark_node
;
8550 if (MAYBE_CLASS_TYPE_P (non_reference (type
)))
8552 else if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
8553 && TREE_CODE (type
) != ARRAY_TYPE
8554 && (TREE_CODE (type
) != REFERENCE_TYPE
8555 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
8556 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
8557 && !TYPE_REFFN_P (type
))
8558 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
8559 rhs
= decay_conversion (rhs
, complain
);
8561 rhstype
= TREE_TYPE (rhs
);
8562 coder
= TREE_CODE (rhstype
);
8564 if (coder
== ERROR_MARK
)
8565 return error_mark_node
;
8567 /* We accept references to incomplete types, so we can
8568 return here before checking if RHS is of complete type. */
8570 if (codel
== REFERENCE_TYPE
)
8572 /* This should eventually happen in convert_arguments. */
8573 int savew
= 0, savee
= 0;
8576 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
8577 rhs
= initialize_reference (type
, rhs
, flags
, complain
);
8580 && (warningcount
+ werrorcount
> savew
|| errorcount
> savee
))
8581 inform (DECL_SOURCE_LOCATION (fndecl
),
8582 "in passing argument %P of %qD", parmnum
, fndecl
);
8588 exp
= require_complete_type_sfinae (exp
, complain
);
8589 if (exp
== error_mark_node
)
8590 return error_mark_node
;
8592 rhstype
= non_reference (rhstype
);
8594 type
= complete_type (type
);
8596 if (DIRECT_INIT_EXPR_P (type
, rhs
))
8597 /* Don't try to do copy-initialization if we already have
8598 direct-initialization. */
8601 if (MAYBE_CLASS_TYPE_P (type
))
8602 return perform_implicit_conversion_flags (type
, rhs
, complain
, flags
);
8604 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
8608 /* If RETVAL is the address of, or a reference to, a local variable or
8609 temporary give an appropriate warning and return true. */
8612 maybe_warn_about_returning_address_of_local (tree retval
)
8614 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
8615 tree whats_returned
= fold_for_warn (retval
);
8619 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
8620 whats_returned
= TREE_OPERAND (whats_returned
, 1);
8621 else if (CONVERT_EXPR_P (whats_returned
)
8622 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
8623 whats_returned
= TREE_OPERAND (whats_returned
, 0);
8628 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
8630 whats_returned
= TREE_OPERAND (whats_returned
, 0);
8632 while (TREE_CODE (whats_returned
) == COMPONENT_REF
8633 || TREE_CODE (whats_returned
) == ARRAY_REF
)
8634 whats_returned
= TREE_OPERAND (whats_returned
, 0);
8636 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
8638 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
8639 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
8641 warning (OPT_Wreturn_local_addr
, "returning reference to temporary");
8644 if (VAR_P (whats_returned
)
8645 && DECL_NAME (whats_returned
)
8646 && TEMP_NAME_P (DECL_NAME (whats_returned
)))
8648 warning (OPT_Wreturn_local_addr
, "reference to non-lvalue returned");
8653 if (DECL_P (whats_returned
)
8654 && DECL_NAME (whats_returned
)
8655 && DECL_FUNCTION_SCOPE_P (whats_returned
)
8656 && !is_capture_proxy (whats_returned
)
8657 && !(TREE_STATIC (whats_returned
)
8658 || TREE_PUBLIC (whats_returned
)))
8660 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
8661 warning_at (DECL_SOURCE_LOCATION (whats_returned
),
8662 OPT_Wreturn_local_addr
,
8663 "reference to local variable %qD returned",
8665 else if (TREE_CODE (whats_returned
) == LABEL_DECL
)
8666 warning_at (DECL_SOURCE_LOCATION (whats_returned
),
8667 OPT_Wreturn_local_addr
, "address of label %qD returned",
8670 warning_at (DECL_SOURCE_LOCATION (whats_returned
),
8671 OPT_Wreturn_local_addr
, "address of local variable %qD "
8672 "returned", whats_returned
);
8679 /* Check that returning RETVAL from the current function is valid.
8680 Return an expression explicitly showing all conversions required to
8681 change RETVAL into the function return type, and to assign it to
8682 the DECL_RESULT for the function. Set *NO_WARNING to true if
8683 code reaches end of non-void function warning shouldn't be issued
8684 on this RETURN_EXPR. */
8687 check_return_expr (tree retval
, bool *no_warning
)
8690 /* The type actually returned by the function. */
8692 /* The type the function is declared to return, or void if
8693 the declared type is incomplete. */
8695 int fn_returns_value_p
;
8696 bool named_return_value_okay_p
;
8698 *no_warning
= false;
8700 if (flag_cilkplus
&& retval
&& contains_cilk_spawn_stmt (retval
))
8702 error_at (EXPR_LOCATION (retval
), "use of %<_Cilk_spawn%> in a return "
8703 "statement is not allowed");
8707 /* A `volatile' function is one that isn't supposed to return, ever.
8708 (This is a G++ extension, used to get better code for functions
8709 that call the `volatile' function.) */
8710 if (TREE_THIS_VOLATILE (current_function_decl
))
8711 warning (0, "function declared %<noreturn%> has a %<return%> statement");
8713 /* Check for various simple errors. */
8714 if (DECL_DESTRUCTOR_P (current_function_decl
))
8717 error ("returning a value from a destructor");
8720 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
8722 if (in_function_try_handler
)
8723 /* If a return statement appears in a handler of the
8724 function-try-block of a constructor, the program is ill-formed. */
8725 error ("cannot return from a handler of a function-try-block of a constructor");
8727 /* You can't return a value from a constructor. */
8728 error ("returning a value from a constructor");
8732 const tree saved_retval
= retval
;
8734 if (processing_template_decl
)
8736 current_function_returns_value
= 1;
8738 if (check_for_bare_parameter_packs (retval
))
8739 return error_mark_node
;
8741 if (WILDCARD_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl
)))
8742 || (retval
!= NULL_TREE
8743 && type_dependent_expression_p (retval
)))
8747 functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
8749 /* Deduce auto return type from a return statement. */
8750 if (current_function_auto_return_pattern
)
8755 if (!retval
&& !is_auto (current_function_auto_return_pattern
))
8757 /* Give a helpful error message. */
8758 error ("return-statement with no value, in function returning %qT",
8759 current_function_auto_return_pattern
);
8760 inform (input_location
, "only plain %<auto%> return type can be "
8761 "deduced to %<void%>");
8762 type
= error_mark_node
;
8764 else if (retval
&& BRACE_ENCLOSED_INITIALIZER_P (retval
))
8766 error ("returning initializer list");
8767 type
= error_mark_node
;
8773 auto_node
= type_uses_auto (current_function_auto_return_pattern
);
8774 type
= do_auto_deduction (current_function_auto_return_pattern
,
8778 if (type
== error_mark_node
)
8780 else if (functype
== current_function_auto_return_pattern
)
8781 apply_deduced_return_type (current_function_decl
, type
);
8782 else if (!same_type_p (type
, functype
))
8784 if (LAMBDA_FUNCTION_P (current_function_decl
))
8785 error ("inconsistent types %qT and %qT deduced for "
8786 "lambda return type", functype
, type
);
8788 error ("inconsistent deduction for auto return type: "
8789 "%qT and then %qT", functype
, type
);
8794 result
= DECL_RESULT (current_function_decl
);
8795 valtype
= TREE_TYPE (result
);
8796 gcc_assert (valtype
!= NULL_TREE
);
8797 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
8799 /* Check for a return statement with no return value in a function
8800 that's supposed to return a value. */
8801 if (!retval
&& fn_returns_value_p
)
8803 if (functype
!= error_mark_node
)
8804 permerror (input_location
, "return-statement with no value, in "
8805 "function returning %qT", valtype
);
8806 /* Remember that this function did return. */
8807 current_function_returns_value
= 1;
8808 /* And signal caller that TREE_NO_WARNING should be set on the
8809 RETURN_EXPR to avoid control reaches end of non-void function
8810 warnings in tree-cfg.c. */
8813 /* Check for a return statement with a value in a function that
8814 isn't supposed to return a value. */
8815 else if (retval
&& !fn_returns_value_p
)
8817 if (VOID_TYPE_P (TREE_TYPE (retval
)))
8818 /* You can return a `void' value from a function of `void'
8819 type. In that case, we have to evaluate the expression for
8820 its side-effects. */
8821 finish_expr_stmt (retval
);
8823 permerror (input_location
, "return-statement with a value, in function "
8824 "returning 'void'");
8825 current_function_returns_null
= 1;
8827 /* There's really no value to return, after all. */
8831 /* Remember that this function can sometimes return without a
8833 current_function_returns_null
= 1;
8835 /* Remember that this function did return a value. */
8836 current_function_returns_value
= 1;
8838 /* Check for erroneous operands -- but after giving ourselves a
8839 chance to provide an error about returning a value from a void
8841 if (error_operand_p (retval
))
8843 current_function_return_value
= error_mark_node
;
8844 return error_mark_node
;
8847 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
8848 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == NEW_EXPR
8849 || DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == VEC_NEW_EXPR
)
8850 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
8852 && retval
&& null_ptr_cst_p (retval
))
8853 warning (0, "%<operator new%> must not return NULL unless it is "
8854 "declared %<throw()%> (or -fcheck-new is in effect)");
8856 /* Effective C++ rule 15. See also start_function. */
8858 && DECL_NAME (current_function_decl
) == ansi_assopname(NOP_EXPR
))
8862 /* The function return type must be a reference to the current
8864 if (TREE_CODE (valtype
) == REFERENCE_TYPE
8865 && same_type_ignoring_top_level_qualifiers_p
8866 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
8868 /* Returning '*this' is obviously OK. */
8869 if (retval
== current_class_ref
)
8871 /* If we are calling a function whose return type is the same of
8872 the current class reference, it is ok. */
8873 else if (INDIRECT_REF_P (retval
)
8874 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
8879 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
8882 if (processing_template_decl
)
8884 /* We should not have changed the return value. */
8885 gcc_assert (retval
== saved_retval
);
8889 /* The fabled Named Return Value optimization, as per [class.copy]/15:
8891 [...] For a function with a class return type, if the expression
8892 in the return statement is the name of a local object, and the cv-
8893 unqualified type of the local object is the same as the function
8894 return type, an implementation is permitted to omit creating the tem-
8895 porary object to hold the function return value [...]
8897 So, if this is a value-returning function that always returns the same
8898 local variable, remember it.
8900 It might be nice to be more flexible, and choose the first suitable
8901 variable even if the function sometimes returns something else, but
8902 then we run the risk of clobbering the variable we chose if the other
8903 returned expression uses the chosen variable somehow. And people expect
8904 this restriction, anyway. (jason 2000-11-19)
8906 See finish_function and finalize_nrv for the rest of this optimization. */
8908 named_return_value_okay_p
=
8909 (retval
!= NULL_TREE
8910 /* Must be a local, automatic variable. */
8912 && DECL_CONTEXT (retval
) == current_function_decl
8913 && ! TREE_STATIC (retval
)
8914 /* And not a lambda or anonymous union proxy. */
8915 && !DECL_HAS_VALUE_EXPR_P (retval
)
8916 && (DECL_ALIGN (retval
) <= DECL_ALIGN (result
))
8917 /* The cv-unqualified type of the returned value must be the
8918 same as the cv-unqualified return type of the
8920 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval
))),
8921 (TYPE_MAIN_VARIANT (functype
)))
8922 /* And the returned value must be non-volatile. */
8923 && ! TYPE_VOLATILE (TREE_TYPE (retval
)));
8925 if (fn_returns_value_p
&& flag_elide_constructors
)
8927 if (named_return_value_okay_p
8928 && (current_function_return_value
== NULL_TREE
8929 || current_function_return_value
== retval
))
8930 current_function_return_value
= retval
;
8932 current_function_return_value
= error_mark_node
;
8935 /* We don't need to do any conversions when there's nothing being
8940 /* Do any required conversions. */
8941 if (retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
8942 /* No conversions are required. */
8946 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
8948 /* The functype's return type will have been set to void, if it
8949 was an incomplete type. Just treat this as 'return;' */
8950 if (VOID_TYPE_P (functype
))
8951 return error_mark_node
;
8953 /* If we had an id-expression obfuscated by force_paren_expr, we need
8954 to undo it so we can try to treat it as an rvalue below. */
8955 retval
= maybe_undo_parenthesized_ref (retval
);
8957 /* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
8958 treated as an rvalue for the purposes of overload resolution to
8959 favor move constructors over copy constructors.
8961 Note that these conditions are similar to, but not as strict as,
8962 the conditions for the named return value optimization. */
8963 if ((cxx_dialect
!= cxx98
)
8964 && ((VAR_P (retval
) && !DECL_HAS_VALUE_EXPR_P (retval
))
8965 || TREE_CODE (retval
) == PARM_DECL
)
8966 && DECL_CONTEXT (retval
) == current_function_decl
8967 && !TREE_STATIC (retval
)
8968 /* This is only interesting for class type. */
8969 && CLASS_TYPE_P (functype
))
8970 flags
= flags
| LOOKUP_PREFER_RVALUE
;
8972 /* First convert the value to the function's return type, then
8973 to the type of return value's location to handle the
8974 case that functype is smaller than the valtype. */
8975 retval
= convert_for_initialization
8976 (NULL_TREE
, functype
, retval
, flags
, ICR_RETURN
, NULL_TREE
, 0,
8977 tf_warning_or_error
);
8978 retval
= convert (valtype
, retval
);
8980 /* If the conversion failed, treat this just like `return;'. */
8981 if (retval
== error_mark_node
)
8983 /* We can't initialize a register from a AGGR_INIT_EXPR. */
8984 else if (! cfun
->returns_struct
8985 && TREE_CODE (retval
) == TARGET_EXPR
8986 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
8987 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
8988 TREE_OPERAND (retval
, 0));
8989 else if (maybe_warn_about_returning_address_of_local (retval
))
8990 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
8991 build_zero_cst (TREE_TYPE (retval
)));
8994 /* Actually copy the value returned into the appropriate location. */
8995 if (retval
&& retval
!= result
)
8996 retval
= build2 (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
9002 /* Returns nonzero if the pointer-type FROM can be converted to the
9003 pointer-type TO via a qualification conversion. If CONSTP is -1,
9004 then we return nonzero if the pointers are similar, and the
9005 cv-qualification signature of FROM is a proper subset of that of TO.
9007 If CONSTP is positive, then all outer pointers have been
9011 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
9013 bool to_more_cv_qualified
= false;
9014 bool is_opaque_pointer
= false;
9016 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
9018 if (TREE_CODE (to
) != TREE_CODE (from
))
9021 if (TREE_CODE (from
) == OFFSET_TYPE
9022 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
9023 TYPE_OFFSET_BASETYPE (to
)))
9026 /* Const and volatile mean something different for function types,
9027 so the usual checks are not appropriate. */
9028 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
9030 if (!at_least_as_qualified_p (to
, from
))
9033 if (!at_least_as_qualified_p (from
, to
))
9037 to_more_cv_qualified
= true;
9041 constp
&= TYPE_READONLY (to
);
9044 if (VECTOR_TYPE_P (to
))
9045 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
9047 if (!TYPE_PTR_P (to
) && !TYPE_PTRDATAMEM_P (to
))
9048 return ((constp
>= 0 || to_more_cv_qualified
)
9049 && (is_opaque_pointer
9050 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
9054 /* When comparing, say, char ** to char const **, this function takes
9055 the 'char *' and 'char const *'. Do not pass non-pointer/reference
9056 types to this function. */
9059 comp_ptr_ttypes (tree to
, tree from
)
9061 return comp_ptr_ttypes_real (to
, from
, 1);
9064 /* Returns true iff FNTYPE is a non-class type that involves
9065 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
9066 if a parameter type is ill-formed. */
9069 error_type_p (const_tree type
)
9073 switch (TREE_CODE (type
))
9079 case REFERENCE_TYPE
:
9081 return error_type_p (TREE_TYPE (type
));
9085 if (error_type_p (TREE_TYPE (type
)))
9087 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
9088 if (error_type_p (TREE_VALUE (t
)))
9093 if (TYPE_PTRMEMFUNC_P (type
))
9094 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type
));
9102 /* Returns true if to and from are (possibly multi-level) pointers to the same
9103 type or inheritance-related types, regardless of cv-quals. */
9106 ptr_reasonably_similar (const_tree to
, const_tree from
)
9108 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
9110 /* Any target type is similar enough to void. */
9111 if (VOID_TYPE_P (to
))
9112 return !error_type_p (from
);
9113 if (VOID_TYPE_P (from
))
9114 return !error_type_p (to
);
9116 if (TREE_CODE (to
) != TREE_CODE (from
))
9119 if (TREE_CODE (from
) == OFFSET_TYPE
9120 && comptypes (TYPE_OFFSET_BASETYPE (to
),
9121 TYPE_OFFSET_BASETYPE (from
),
9122 COMPARE_BASE
| COMPARE_DERIVED
))
9125 if (VECTOR_TYPE_P (to
)
9126 && vector_types_convertible_p (to
, from
, false))
9129 if (TREE_CODE (to
) == INTEGER_TYPE
9130 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
9133 if (TREE_CODE (to
) == FUNCTION_TYPE
)
9134 return !error_type_p (to
) && !error_type_p (from
);
9136 if (!TYPE_PTR_P (to
))
9138 /* When either type is incomplete avoid DERIVED_FROM_P,
9139 which may call complete_type (c++/57942). */
9140 bool b
= !COMPLETE_TYPE_P (to
) || !COMPLETE_TYPE_P (from
);
9142 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
9143 b
? COMPARE_STRICT
: COMPARE_BASE
| COMPARE_DERIVED
);
9148 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
9149 pointer-to-member types) are the same, ignoring cv-qualification at
9153 comp_ptr_ttypes_const (tree to
, tree from
)
9155 bool is_opaque_pointer
= false;
9157 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
9159 if (TREE_CODE (to
) != TREE_CODE (from
))
9162 if (TREE_CODE (from
) == OFFSET_TYPE
9163 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
9164 TYPE_OFFSET_BASETYPE (to
)))
9167 if (VECTOR_TYPE_P (to
))
9168 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
9170 if (!TYPE_PTR_P (to
))
9171 return (is_opaque_pointer
9172 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
9176 /* Returns the type qualifiers for this type, including the qualifiers on the
9177 elements for an array type. */
9180 cp_type_quals (const_tree type
)
9183 /* This CONST_CAST is okay because strip_array_types returns its
9184 argument unmodified and we assign it to a const_tree. */
9185 type
= strip_array_types (CONST_CAST_TREE (type
));
9186 if (type
== error_mark_node
9187 /* Quals on a FUNCTION_TYPE are memfn quals. */
9188 || TREE_CODE (type
) == FUNCTION_TYPE
)
9189 return TYPE_UNQUALIFIED
;
9190 quals
= TYPE_QUALS (type
);
9191 /* METHOD and REFERENCE_TYPEs should never have quals. */
9192 gcc_assert ((TREE_CODE (type
) != METHOD_TYPE
9193 && TREE_CODE (type
) != REFERENCE_TYPE
)
9194 || ((quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
))
9195 == TYPE_UNQUALIFIED
));
9199 /* Returns the function-ref-qualifier for TYPE */
9202 type_memfn_rqual (const_tree type
)
9204 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
9205 || TREE_CODE (type
) == METHOD_TYPE
);
9207 if (!FUNCTION_REF_QUALIFIED (type
))
9208 return REF_QUAL_NONE
;
9209 else if (FUNCTION_RVALUE_QUALIFIED (type
))
9210 return REF_QUAL_RVALUE
;
9212 return REF_QUAL_LVALUE
;
9215 /* Returns the function-cv-quals for TYPE, which must be a FUNCTION_TYPE or
9219 type_memfn_quals (const_tree type
)
9221 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9222 return TYPE_QUALS (type
);
9223 else if (TREE_CODE (type
) == METHOD_TYPE
)
9224 return cp_type_quals (class_of_this_parm (type
));
9229 /* Returns the FUNCTION_TYPE TYPE with its function-cv-quals changed to
9230 MEMFN_QUALS and its ref-qualifier to RQUAL. */
9233 apply_memfn_quals (tree type
, cp_cv_quals memfn_quals
, cp_ref_qualifier rqual
)
9235 /* Could handle METHOD_TYPE here if necessary. */
9236 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
9237 if (TYPE_QUALS (type
) == memfn_quals
9238 && type_memfn_rqual (type
) == rqual
)
9241 /* This should really have a different TYPE_MAIN_VARIANT, but that gets
9243 tree result
= build_qualified_type (type
, memfn_quals
);
9244 return build_ref_qualified_type (result
, rqual
);
9247 /* Returns nonzero if TYPE is const or volatile. */
9250 cv_qualified_p (const_tree type
)
9252 int quals
= cp_type_quals (type
);
9253 return (quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)) != 0;
9256 /* Returns nonzero if the TYPE contains a mutable member. */
9259 cp_has_mutable_p (const_tree type
)
9261 /* This CONST_CAST is okay because strip_array_types returns its
9262 argument unmodified and we assign it to a const_tree. */
9263 type
= strip_array_types (CONST_CAST_TREE(type
));
9265 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
9268 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
9269 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
9270 approximation. In particular, consider:
9273 struct S { int i; };
9274 const S s = { f(); }
9276 Here, we will make "s" as TREE_READONLY (because it is declared
9277 "const") -- only to reverse ourselves upon seeing that the
9278 initializer is non-constant. */
9281 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
9283 tree type
= TREE_TYPE (decl
);
9285 if (type
== error_mark_node
)
9288 if (TREE_CODE (decl
) == TYPE_DECL
)
9291 gcc_assert (!(TREE_CODE (type
) == FUNCTION_TYPE
9292 && type_quals
!= TYPE_UNQUALIFIED
));
9294 /* Avoid setting TREE_READONLY incorrectly. */
9295 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
9296 constructor can produce constant init, so rely on cp_finish_decl to
9297 clear TREE_READONLY if the variable has non-constant init. */
9299 /* If the type has (or might have) a mutable component, that component
9300 might be modified. */
9301 if (TYPE_HAS_MUTABLE_P (type
) || !COMPLETE_TYPE_P (type
))
9302 type_quals
&= ~TYPE_QUAL_CONST
;
9304 c_apply_type_quals_to_decl (type_quals
, decl
);
9307 /* Subroutine of casts_away_constness. Make T1 and T2 point at
9308 exemplar types such that casting T1 to T2 is casting away constness
9309 if and only if there is no implicit conversion from T1 to T2. */
9312 casts_away_constness_r (tree
*t1
, tree
*t2
, tsubst_flags_t complain
)
9317 /* [expr.const.cast]
9319 For multi-level pointer to members and multi-level mixed pointers
9320 and pointers to members (conv.qual), the "member" aspect of a
9321 pointer to member level is ignored when determining if a const
9322 cv-qualifier has been cast away. */
9323 /* [expr.const.cast]
9325 For two pointer types:
9327 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
9328 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
9331 casting from X1 to X2 casts away constness if, for a non-pointer
9332 type T there does not exist an implicit conversion (clause
9335 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
9339 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
9340 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRDATAMEM_P (*t1
))
9341 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRDATAMEM_P (*t2
)))
9343 *t1
= cp_build_qualified_type (void_type_node
,
9344 cp_type_quals (*t1
));
9345 *t2
= cp_build_qualified_type (void_type_node
,
9346 cp_type_quals (*t2
));
9350 quals1
= cp_type_quals (*t1
);
9351 quals2
= cp_type_quals (*t2
);
9353 if (TYPE_PTRDATAMEM_P (*t1
))
9354 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
9356 *t1
= TREE_TYPE (*t1
);
9357 if (TYPE_PTRDATAMEM_P (*t2
))
9358 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
9360 *t2
= TREE_TYPE (*t2
);
9362 casts_away_constness_r (t1
, t2
, complain
);
9363 *t1
= build_pointer_type (*t1
);
9364 *t2
= build_pointer_type (*t2
);
9365 *t1
= cp_build_qualified_type (*t1
, quals1
);
9366 *t2
= cp_build_qualified_type (*t2
, quals2
);
9369 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
9372 ??? This function returns non-zero if casting away qualifiers not
9373 just const. We would like to return to the caller exactly which
9374 qualifiers are casted away to give more accurate diagnostics.
9378 casts_away_constness (tree t1
, tree t2
, tsubst_flags_t complain
)
9380 if (TREE_CODE (t2
) == REFERENCE_TYPE
)
9382 /* [expr.const.cast]
9384 Casting from an lvalue of type T1 to an lvalue of type T2
9385 using a reference cast casts away constness if a cast from an
9386 rvalue of type "pointer to T1" to the type "pointer to T2"
9387 casts away constness. */
9388 t1
= (TREE_CODE (t1
) == REFERENCE_TYPE
? TREE_TYPE (t1
) : t1
);
9389 return casts_away_constness (build_pointer_type (t1
),
9390 build_pointer_type (TREE_TYPE (t2
)),
9394 if (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
9395 /* [expr.const.cast]
9397 Casting from an rvalue of type "pointer to data member of X
9398 of type T1" to the type "pointer to data member of Y of type
9399 T2" casts away constness if a cast from an rvalue of type
9400 "pointer to T1" to the type "pointer to T2" casts away
9402 return casts_away_constness
9403 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
9404 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)),
9407 /* Casting away constness is only something that makes sense for
9408 pointer or reference types. */
9409 if (!TYPE_PTR_P (t1
) || !TYPE_PTR_P (t2
))
9412 /* Top-level qualifiers don't matter. */
9413 t1
= TYPE_MAIN_VARIANT (t1
);
9414 t2
= TYPE_MAIN_VARIANT (t2
);
9415 casts_away_constness_r (&t1
, &t2
, complain
);
9416 if (!can_convert (t2
, t1
, complain
))
9422 /* If T is a REFERENCE_TYPE return the type to which T refers.
9423 Otherwise, return T itself. */
9426 non_reference (tree t
)
9428 if (t
&& TREE_CODE (t
) == REFERENCE_TYPE
)
9434 /* Return nonzero if REF is an lvalue valid for this language;
9435 otherwise, print an error message and return zero. USE says
9436 how the lvalue is being used and so selects the error message. */
9439 lvalue_or_else (tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
9441 cp_lvalue_kind kind
= lvalue_kind (ref
);
9443 if (kind
== clk_none
)
9445 if (complain
& tf_error
)
9446 lvalue_error (input_location
, use
);
9449 else if (kind
& (clk_rvalueref
|clk_class
))
9451 if (!(complain
& tf_error
))
9453 if (kind
& clk_class
)
9454 /* Make this a permerror because we used to accept it. */
9455 permerror (input_location
, "using temporary as lvalue");
9457 error ("using xvalue (rvalue reference) as lvalue");
9462 /* Return true if a user-defined literal operator is a raw operator. */
9465 check_raw_literal_operator (const_tree decl
)
9467 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9470 bool maybe_raw_p
= false;
9472 /* Count the number and type of arguments and check for ellipsis. */
9473 for (argtype
= argtypes
, arity
= 0;
9474 argtype
&& argtype
!= void_list_node
;
9475 ++arity
, argtype
= TREE_CHAIN (argtype
))
9477 tree t
= TREE_VALUE (argtype
);
9479 if (same_type_p (t
, const_string_type_node
))
9483 return false; /* Found ellipsis. */
9485 if (!maybe_raw_p
|| arity
!= 1)
9492 /* Return true if a user-defined literal operator has one of the allowed
9496 check_literal_operator_args (const_tree decl
,
9497 bool *long_long_unsigned_p
, bool *long_double_p
)
9499 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9501 *long_long_unsigned_p
= false;
9502 *long_double_p
= false;
9503 if (processing_template_decl
|| processing_specialization
)
9504 return argtypes
== void_list_node
;
9511 /* Count the number and type of arguments and check for ellipsis. */
9512 for (argtype
= argtypes
, arity
= 0;
9513 argtype
&& argtype
!= void_list_node
;
9514 argtype
= TREE_CHAIN (argtype
))
9516 tree t
= TREE_VALUE (argtype
);
9521 bool maybe_raw_p
= false;
9523 if (cp_type_quals (t
) != TYPE_QUAL_CONST
)
9525 t
= TYPE_MAIN_VARIANT (t
);
9526 if ((maybe_raw_p
= same_type_p (t
, char_type_node
))
9527 || same_type_p (t
, wchar_type_node
)
9528 || same_type_p (t
, char16_type_node
)
9529 || same_type_p (t
, char32_type_node
))
9531 argtype
= TREE_CHAIN (argtype
);
9534 t
= TREE_VALUE (argtype
);
9535 if (maybe_raw_p
&& argtype
== void_list_node
)
9537 else if (same_type_p (t
, size_type_node
))
9546 else if (same_type_p (t
, long_long_unsigned_type_node
))
9549 *long_long_unsigned_p
= true;
9551 else if (same_type_p (t
, long_double_type_node
))
9554 *long_double_p
= true;
9556 else if (same_type_p (t
, char_type_node
))
9558 else if (same_type_p (t
, wchar_type_node
))
9560 else if (same_type_p (t
, char16_type_node
))
9562 else if (same_type_p (t
, char32_type_node
))
9568 return false; /* Found ellipsis. */
9570 if (arity
!= max_arity
)
9577 /* Always returns false since unlike C90, C++ has no concept of implicit
9578 function declarations. */
9581 c_decl_implicit (const_tree
)