| blob | 5606389f4bd7e9c9293bffccf62766a733aa7b31 |
1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 modified by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
46 /* The various kinds of conversion. */
49 ck_identity,
50 ck_lvalue,
51 ck_fnptr,
52 ck_qual,
53 ck_std,
54 ck_ptr,
55 ck_pmem,
56 ck_base,
57 ck_ref_bind,
58 ck_user,
59 ck_ambig,
60 ck_list,
61 ck_aggr,
62 ck_rvalue
63 };
65 /* The rank of the conversion. Order of the enumerals matters; better
66 conversions should come earlier in the list. */
69 cr_identity,
70 cr_exact,
71 cr_promotion,
72 cr_std,
73 cr_pbool,
74 cr_user,
75 cr_ellipsis,
76 cr_bad
77 };
79 /* An implicit conversion sequence, in the sense of [over.best.ics].
80 The first conversion to be performed is at the end of the chain.
81 That conversion is always a cr_identity conversion. */
84 /* The kind of conversion represented by this step. */
85 conversion_kind kind;
86 /* The rank of this conversion. */
87 conversion_rank rank;
91 /* True if this conversion would be permitted with a bending of
92 language standards, e.g. disregarding pointer qualifiers or
93 converting integers to pointers. */
95 /* If KIND is ck_ref_bind or ck_base, true to indicate that a
96 temporary should be created to hold the result of the
97 conversion. If KIND is ck_ambig or ck_user, true means force
98 copy-initialization. */
100 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
101 from a pointer-to-derived to pointer-to-base is being performed. */
103 /* If KIND is ck_ref_bind, true when either an lvalue reference is
104 being bound to an lvalue expression or an rvalue reference is
105 being bound to an rvalue expression. If KIND is ck_rvalue or ck_base,
106 true when we are treating an lvalue as an rvalue (12.8p33). If
107 ck_identity, we will be binding a reference directly or decaying to
108 a pointer. */
111 /* Whether check_narrowing should only check TREE_CONSTANTs; used
112 in build_converted_constant_expr. */
114 /* True if this conversion is taking place in a copy-initialization context
115 and we should only consider converting constructors. Only set in
116 ck_base and ck_rvalue. */
118 /* The type of the expression resulting from the conversion. */
119 tree type;
121 /* The next conversion in the chain. Since the conversions are
122 arranged from outermost to innermost, the NEXT conversion will
123 actually be performed before this conversion. This variant is
124 used only when KIND is neither ck_identity, ck_aggr, ck_ambig nor
125 ck_list. Please use the next_conversion function instead
126 of using this field directly. */
128 /* The expression at the beginning of the conversion chain. This
129 variant is used only if KIND is ck_identity, ck_aggr, or ck_ambig.
130 You can use conv_get_original_expr to get this expression. */
131 tree expr;
132 /* The array of conversions for an initializer_list, so this
133 variant is used only when KIN D is ck_list. */
136 /* The function candidate corresponding to this conversion
137 sequence. This field is only used if KIND is ck_user. */
139 };
141 #define CONVERSION_RANK(NODE) \
142 ((NODE)->bad_p ? cr_bad \
143 : (NODE)->ellipsis_p ? cr_ellipsis \
144 : (NODE)->user_conv_p ? cr_user \
145 : (NODE)->rank)
147 #define BAD_CONVERSION_RANK(NODE) \
148 ((NODE)->ellipsis_p ? cr_ellipsis \
149 : (NODE)->user_conv_p ? cr_user \
150 : (NODE)->rank)
159 tsubst_flags_t);
166 tsubst_flags_t);
170 tsubst_flags_t);
190 tsubst_flags_t);
192 tsubst_flags_t);
211 tsubst_flags_t);
218 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
219 NAME can take many forms... */
221 bool
223 {
224 /* Just accept something we've already complained about. */
233 {
238 else
240 }
241 else
242 {
243 /* In the case of:
245 template <class T> struct S { ~S(); };
246 int i;
247 i.~S();
249 NAME will be a class template. */
252 }
257 }
259 /* We want the address of a function or method. We avoid creating a
260 pointer-to-member function. */
262 tree
264 {
267 /* We have to do these by hand to avoid real pointer to member
268 functions. */
270 {
272 {
276 complain);
277 }
279 }
283 else
287 }
289 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
290 POINTER_TYPE to those. Note, pointer to member function types
291 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
292 two variants. build_call_a is the primitive taking an array of
293 arguments, while build_call_n is a wrapper that handles varargs. */
295 tree
297 {
300 else
301 {
311 }
312 }
314 /* Update various flags in cfun and the call itself based on what is being
315 called. Split out of build_call_a so that bot_manip can use it too. */
317 void
319 {
320 /* Handle both CALL_EXPRs and AGGR_INIT_EXPRs. */
323 /* We check both the decl and the type; a function may be known not to
324 throw without being declared throw(). */
334 {
340 }
343 }
345 tree
347 {
348 tree decl;
349 tree result_type;
350 tree fntype;
359 /* An rvalue has no cv-qualifiers. */
370 {
371 /* We invoke build_call directly for several library
372 functions. These may have been declared normally if
373 we're building libgcc, so we can't just check
374 DECL_ARTIFICIAL. */
379 }
385 /* Don't pass empty class objects by value. This is useful
386 for tags in STL, which are used to control overload resolution.
387 We don't need to handle other cases of copying empty classes. */
390 {
394 {
396 /* We're disconnecting the initializer from its target,
397 don't create a temporary. */
402 }
403 }
406 }
408 /* New overloading code. */
415 };
417 /* Information for providing diagnostics about why overloading failed. */
420 rr_none,
421 rr_arity,
422 rr_explicit_conversion,
423 rr_template_conversion,
424 rr_arg_conversion,
425 rr_bad_arg_conversion,
426 rr_template_unification,
427 rr_invalid_copy,
428 rr_inherited_ctor,
429 rr_constraint_failure
430 };
433 /* The index of the argument, 0-based. */
435 /* The actual argument or its type. */
436 tree from;
437 /* The type of the parameter. */
438 tree to_type;
439 /* The location of the argument. */
440 location_t loc;
441 };
446 /* Information about an arity mismatch. */
448 /* The expected number of arguments. */
450 /* The actual number of arguments in the call. */
452 /* Whether the call was a varargs call. */
455 /* Information about an argument conversion mismatch. */
457 /* Same, but for bad argument conversions. */
459 /* Information about template unification failures. These are the
460 parameters passed to fn_type_unification. */
462 tree tmpl;
463 tree explicit_targs;
467 tree return_type;
468 unification_kind_t strict;
471 /* Information about template instantiation failures. These are the
472 parameters passed to instantiate_template. */
474 tree tmpl;
475 tree targs;
478 };
481 /* The FUNCTION_DECL that will be called if this candidate is
482 selected by overload resolution. */
483 tree fn;
484 /* If not NULL_TREE, the first argument to use when calling this
485 function. */
486 tree first_arg;
487 /* The rest of the arguments to use when calling this function. If
488 there are no further arguments this may be NULL or it may be an
489 empty vector. */
491 /* The implicit conversion sequences for each of the arguments to
492 FN. */
494 /* The number of implicit conversion sequences. */
496 /* If FN is a user-defined conversion, the standard conversion
497 sequence from the type returned by FN to the desired destination
498 type. */
501 /* If FN is a member function, the binfo indicating the path used to
502 qualify the name of FN at the call site. This path is used to
503 determine whether or not FN is accessible if it is selected by
504 overload resolution. The DECL_CONTEXT of FN will always be a
505 (possibly improper) base of this binfo. */
506 tree access_path;
507 /* If FN is a non-static member function, the binfo indicating the
508 subobject to which the `this' pointer should be converted if FN
509 is selected by overload resolution. The type pointed to by
510 the `this' pointer must correspond to the most derived class
511 indicated by the CONVERSION_PATH. */
512 tree conversion_path;
513 tree template_decl;
514 tree explicit_targs;
519 /* The flags active in add_candidate. */
524 };
526 /* Returns true iff T is a null pointer constant in the sense of
527 [conv.ptr]. */
529 bool
531 {
534 /* [conv.ptr]
536 A null pointer constant is an integer literal ([lex.icon]) with value
537 zero or a prvalue of type std::nullptr_t. */
542 {
545 /* Core issue 903 says only literal 0 is a null pointer constant. */
552 }
554 {
559 }
562 }
564 /* Returns true iff T is a null member pointer value (4.11). */
566 bool
568 {
578 else
580 }
582 /* Returns nonzero if PARMLIST consists of only default parms,
583 ellipsis, and/or undeduced parameter packs. */
585 bool
587 {
594 }
596 /* Allocate N bytes of memory from the conversion obstack. The memory
597 is zeroed before being returned. */
601 {
604 {
607 }
611 }
613 /* Allocate rejection reasons. */
617 {
622 }
626 {
632 }
636 location_t loc)
637 {
645 }
649 location_t loc)
650 {
658 }
662 {
669 }
673 {
680 }
687 {
694 /* Copy args to our own storage. */
702 }
706 {
708 }
712 {
715 }
719 {
722 }
724 /* Build a constraint failure record. */
728 {
731 }
733 /* Dynamically allocate a conversion. */
737 {
742 }
744 /* Make sure that all memory on the conversion obstack has been
745 freed. */
747 void
749 {
753 }
755 /* Dynamically allocate an array of N conversions. */
759 {
761 }
765 {
769 /* Note that the caller is responsible for filling in t->cand for
770 user-defined conversions. */
776 {
793 }
799 }
801 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
802 specialization of std::initializer_list<T>, if such a conversion is
803 possible. */
807 {
813 tree val;
815 /* Within a list-initialization we can have more user-defined
816 conversions. */
818 /* But no narrowing conversions. */
821 /* Can't make an array of these types. */
828 {
829 conversion *sub
836 }
844 {
852 }
855 }
857 /* Return the next conversion of the conversion chain (if applicable),
858 or NULL otherwise. Please use this function instead of directly
859 accessing fields of struct conversion. */
863 {
871 }
873 /* Strip to the first ck_user, ck_ambig, ck_list, ck_aggr or ck_identity
874 encountered. */
878 {
887 }
889 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
890 is a valid aggregate initializer for array type ATYPE. */
892 static bool
894 {
898 {
904 else
906 complain);
909 }
911 }
913 /* Helper for build_aggr_conv. Return true if FIELD is in PSET, or if
914 FIELD has ANON_AGGR_TYPE_P and any initializable field in there recursively
915 is in PSET. */
917 static bool
919 {
925 {
931 }
933 }
935 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
936 aggregate class, if such a conversion is possible. */
940 {
947 /* We already called reshape_init in implicit_conversion. */
949 /* The conversions within the init-list aren't affected by the enclosing
950 context; they're always simple copy-initialization. */
953 /* For designated initializers, verify that each initializer is convertible
954 to corresponding TREE_TYPE (ce->index) and mark those FIELD_DECLs as
955 visited. In the following loop then ignore already visited
956 FIELD_DECLs. */
958 {
961 {
963 {
970 else
972 complain);
976 /* For unions, there should be just one initializer. */
978 {
982 }
984 }
985 else
987 }
988 }
991 {
993 tree val;
999 {
1002 }
1006 /* Value-initialization of reference is ill-formed. */
1008 else
1009 {
1013 }
1018 else
1020 complain);
1027 }
1039 }
1041 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
1042 array type, if such a conversion is possible. */
1046 {
1051 tree val;
1056 /* We might need to propagate the size from the element to the array. */
1061 {
1065 }
1070 {
1071 conversion *sub
1083 }
1092 }
1094 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1095 complex type, if such a conversion is possible. */
1099 tsubst_flags_t complain)
1100 {
1105 tree val;
1116 {
1117 conversion *sub
1129 }
1138 }
1140 /* Build a representation of the identity conversion from EXPR to
1141 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1145 {
1153 }
1155 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1156 were multiple user-defined conversions to accomplish the job.
1157 Build a conversion that indicates that ambiguity. */
1161 {
1169 }
1171 tree
1173 {
1177 }
1179 /* Returns the standard conversion path (see [conv]) from type FROM to type
1180 TO, if any. For proper handling of null pointer constants, you must
1181 also pass the expression EXPR to convert from. If C_CAST_P is true,
1182 this conversion is coming from a C-style cast. */
1187 {
1191 tree qualified_to;
1195 {
1198 }
1204 {
1206 {
1212 }
1214 {
1215 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1218 }
1219 }
1226 {
1229 /* Tell convert_like that we're using the address. */
1232 }
1233 /* Wrapping a ck_rvalue around a class prvalue (as a result of using
1234 obvalue_p) seems odd, since it's already a prvalue, but that's how we
1235 express the copy constructor call required by copy-initialization. */
1237 {
1239 {
1240 tree bitfield_type;
1243 {
1246 }
1247 }
1250 /* Tell convert_like to set LOOKUP_PREFER_RVALUE. */
1252 /* If we're performing copy-initialization, remember to skip
1253 explicit constructors. */
1256 }
1258 /* Allow conversion between `__complex__' data types. */
1260 {
1261 /* The standard conversion sequence to convert FROM to TO is
1262 the standard conversion sequence to perform componentwise
1263 conversion. */
1266 complain);
1269 {
1272 }
1273 else
1277 }
1280 {
1284 }
1286 /* [conv.ptr]
1287 A null pointer constant can be converted to a pointer type; ... A
1288 null pointer constant of integral type can be converted to an
1289 rvalue of type std::nullptr_t. */
1297 {
1298 /* For backwards brain damage compatibility, allow interconversion of
1299 pointers and integers with a pedwarn. */
1302 }
1304 {
1305 /* For backwards brain damage compatibility, allow interconversion of
1306 enums and integers with a pedwarn. */
1309 }
1312 {
1313 tree to_pointee;
1314 tree from_pointee;
1317 {
1321 /* Since this is the target of a pointer, it can't have function
1322 qualifiers, so any TYPE_QUALS must be for attributes const or
1323 noreturn. Strip them. */
1330 }
1331 else
1332 {
1335 }
1339 to_pointee))
1340 ;
1344 {
1346 /* Don't try to apply restrict to void. */
1351 }
1353 {
1360 && (same_type_ignoring_top_level_qualifiers_p
1362 {
1365 }
1366 else
1368 }
1371 /* [conv.ptr]
1373 An rvalue of type "pointer to cv D," where D is a
1374 class type, can be converted to an rvalue of type
1375 "pointer to cv B," where B is a base class (clause
1376 _class.derived_) of D. If B is an inaccessible
1377 (clause _class.access_) or ambiguous
1378 (_class.member.lookup_) base class of D, a program
1379 that necessitates this conversion is ill-formed.
1380 Therefore, we use DERIVED_FROM_P, and do not check
1381 access or uniqueness. */
1383 {
1384 from_pointee
1390 }
1395 /* In a C-style cast, we ignore CV-qualification because we
1396 are allowed to perform a static_cast followed by a
1397 const_cast. */
1402 /* converting from string constant to char *. */
1406 /* Allow conversions among compatible ObjC pointer types (base
1407 conversions have been already handled above). */
1412 {
1415 }
1416 else
1420 }
1422 {
1436 else
1440 {
1442 tbase,
1448 }
1451 }
1453 {
1454 /* [conv.bool]
1456 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1457 to member type can be converted to a prvalue of type bool. ...
1458 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1459 std::nullptr_t can be converted to a prvalue of type bool; */
1465 {
1478 }
1481 }
1482 /* We don't check for ENUMERAL_TYPE here because there are no standard
1483 conversions to enum type. */
1484 /* As an extension, allow conversion to complex type. */
1486 {
1492 /* If we're parsing an enum with no fixed underlying type, we're
1493 dealing with an incomplete type, which renders the conversion
1494 ill-formed. */
1505 /* Give this a better rank if it's a promotion.
1507 To handle CWG 1601, also bump the rank if we are converting
1508 an enumeration with a fixed underlying type to the underlying
1509 type. */
1514 }
1520 {
1524 /* The derived-to-base conversion indicates the initialization
1525 of a parameter with base type from an object of a derived
1526 type. A temporary object is created to hold the result of
1527 the conversion unless we're binding directly to a reference. */
1530 /* Tell convert_like to set LOOKUP_PREFER_RVALUE. */
1532 /* If we're performing copy-initialization, remember to skip
1533 explicit constructors. */
1536 }
1537 else
1544 }
1546 /* Returns nonzero if T1 is reference-related to T2. */
1548 bool
1550 {
1557 /* [dcl.init.ref]
1559 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1560 to "cv2 T2" if T1 is similar to T2, or T1 is a base class of T2. */
1564 }
1566 /* Returns nonzero if T1 is reference-compatible with T2. */
1568 bool
1570 {
1571 /* [dcl.init.ref]
1573 "cv1 T1" is reference compatible with "cv2 T2" if
1574 a prvalue of type "pointer to cv2 T2" can be converted to the type
1575 "pointer to cv1 T1" via a standard conversion sequence. */
1583 }
1585 /* Return true if converting FROM to TO would involve a qualification
1586 conversion. */
1588 static bool
1590 {
1591 /* If we're not convering a pointer to another one, we won't get
1592 a qualification conversion. */
1604 }
1606 /* A reference of the indicated TYPE is being bound directly to the
1607 expression represented by the implicit conversion sequence CONV.
1608 Return a conversion sequence for this binding. */
1612 {
1613 tree t;
1621 /* Mark the identity conv as to not decay to rvalue. */
1624 /* [over.ics.rank]
1626 When a parameter of reference type binds directly
1627 (_dcl.init.ref_) to an argument expression, the implicit
1628 conversion sequence is the identity conversion, unless the
1629 argument expression has a type that is a derived class of the
1630 parameter type, in which case the implicit conversion sequence is
1631 a derived-to-base Conversion.
1633 If the parameter binds directly to the result of applying a
1634 conversion function to the argument expression, the implicit
1635 conversion sequence is a user-defined conversion sequence
1636 (_over.ics.user_), with the second standard conversion sequence
1637 either an identity conversion or, if the conversion function
1638 returns an entity of a type that is a derived class of the
1639 parameter type, a derived-to-base conversion. */
1641 {
1642 /* Represent the derived-to-base conversion. */
1644 /* We will actually be binding to the base-class subobject in
1645 the derived class, so we mark this conversion appropriately.
1646 That way, convert_like knows not to generate a temporary. */
1648 }
1650 /* Represent the qualification conversion. After DR 2352
1651 #1 and #2 were indistinguishable conversion sequences:
1653 void f(int*); // #1
1654 void f(const int* const &); // #2
1655 void g(int* p) { f(p); }
1657 because the types "int *" and "const int *const" are
1658 reference-related and we were binding both directly and they
1659 had the same rank. To break it up, we add a ck_qual under the
1660 ck_ref_bind so that conversion sequence ranking chooses #1. */
1664 }
1666 /* Returns the conversion path from type FROM to reference type TO for
1667 purposes of reference binding. For lvalue binding, either pass a
1668 reference type to FROM or an lvalue expression to EXPR. If the
1669 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1670 the conversion returned. If C_CAST_P is true, this
1671 conversion is coming from a C-style cast. */
1675 tsubst_flags_t complain)
1676 {
1680 tree tfrom;
1683 cp_lvalue_kind gl_kind;
1687 {
1692 }
1696 {
1698 /* DR 1288: Otherwise, if the initializer list has a single element
1699 of type E and ... [T's] referenced type is reference-related to E,
1700 the object or reference is initialized from that element...
1702 ??? With P0388R4, we should bind 't' directly to U{}:
1703 using U = A[2];
1704 A (&&t)[] = {U{}};
1705 because A[] and A[2] are reference-related. But we don't do it
1706 because grok_reference_init has deduced the array size (to 1), and
1707 A[1] and A[2] aren't reference-related. */
1709 {
1715 {
1719 }
1720 }
1721 /* Otherwise, if T is a reference type, a prvalue temporary of the type
1722 referenced by T is copy-list-initialized, and the reference is bound
1723 to that temporary. */
1725 skip:;
1726 }
1729 {
1734 else
1736 }
1742 else
1745 /* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
1750 /* Same mask as real_lvalue_p. */
1757 /* Figure out whether or not the types are reference-related and
1758 reference compatible. We have to do this after stripping
1759 references from FROM. */
1761 /* If this is a C cast, first convert to an appropriately qualified
1762 type, so that we can later do a const_cast to the desired type. */
1768 /* Directly bind reference when target expression's type is compatible with
1769 the reference and expression is an lvalue. In DR391, the wording in
1770 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1771 const and rvalue references to rvalues of compatible class type.
1772 We should also do direct bindings for non-class xvalues. */
1774 {
1775 /* [dcl.init.ref]
1777 If the initializer expression
1779 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1780 is reference-compatible with "cv2 T2,"
1782 the reference is bound directly to the initializer expression
1783 lvalue.
1785 [...]
1786 If the initializer expression is an rvalue, with T2 a class type,
1787 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1788 is bound to the object represented by the rvalue or to a sub-object
1789 within that object. */
1795 /* Handle rvalue reference to function properly. */
1796 conv->rvaluedness_matches_p
1798 else
1799 conv->rvaluedness_matches_p
1804 /* For the purposes of overload resolution, we ignore the fact
1805 this expression is a bitfield or packed field. (In particular,
1806 [over.ics.ref] says specifically that a function with a
1807 non-const reference parameter is viable even if the
1808 argument is a bitfield.)
1810 However, when we actually call the function we must create
1811 a temporary to which to bind the reference. If the
1812 reference is volatile, or isn't const, then we cannot make
1813 a temporary, so we just issue an error when the conversion
1814 actually occurs. */
1817 /* Don't allow binding of lvalues (other than function lvalues) to
1818 rvalue references. */
1823 /* Nor the reverse. */
1825 /* Unless it's really an lvalue. */
1837 }
1838 /* [class.conv.fct] A conversion function is never used to convert a
1839 (possibly cv-qualified) object to the (possibly cv-qualified) same
1840 object type (or a reference to it), to a (possibly cv-qualified) base
1841 class of that type (or a reference to it).... */
1844 {
1845 /* [dcl.init.ref]
1847 If the initializer expression
1849 -- has a class type (i.e., T2 is a class type) can be
1850 implicitly converted to an lvalue of type "cv3 T3," where
1851 "cv1 T1" is reference-compatible with "cv3 T3". (this
1852 conversion is selected by enumerating the applicable
1853 conversion functions (_over.match.ref_) and choosing the
1854 best one through overload resolution. (_over.match_).
1856 the reference is bound to the lvalue result of the conversion
1857 in the second case. */
1859 complain);
1862 }
1864 /* From this point on, we conceptually need temporaries, even if we
1865 elide them. Only the cases above are "direct bindings". */
1869 /* [over.ics.rank]
1871 When a parameter of reference type is not bound directly to an
1872 argument expression, the conversion sequence is the one required
1873 to convert the argument expression to the underlying type of the
1874 reference according to _over.best.ics_. Conceptually, this
1875 conversion sequence corresponds to copy-initializing a temporary
1876 of the underlying type with the argument expression. Any
1877 difference in top-level cv-qualification is subsumed by the
1878 initialization itself and does not constitute a conversion. */
1880 /* [dcl.init.ref]
1882 Otherwise, the reference shall be an lvalue reference to a
1883 non-volatile const type, or the reference shall be an rvalue
1884 reference.
1886 We try below to treat this as a bad conversion to improve diagnostics,
1887 but if TO is an incomplete class, we need to reject this conversion
1888 now to avoid unnecessary instantiation. */
1893 /* We're generating a temporary now, but don't bind any more in the
1894 conversion (specifically, don't slice the temporary returned by a
1895 conversion operator). */
1898 /* Core issue 899: When [copy-]initializing a temporary to be bound
1899 to the first parameter of a copy constructor (12.8) called with
1900 a single argument in the context of direct-initialization,
1901 explicit conversion functions are also considered.
1903 So don't set LOOKUP_ONLYCONVERTING in that case. */
1914 {
1916 /* Remember this was copy-list-initialization. */
1919 /* If initializing the temporary used a conversion function,
1920 recalculate the second conversion sequence. */
1924 {
1926 /* A prvalue of non-class type is cv-unqualified. */
1930 conversion *new_second
1936 }
1937 }
1940 /* This reference binding, unlike those above, requires the
1941 creation of a temporary. */
1945 /* [dcl.init.ref]
1947 Otherwise, the reference shall be an lvalue reference to a
1948 non-volatile const type, or the reference shall be an rvalue
1949 reference. */
1953 /* [dcl.init.ref]
1955 Otherwise, a temporary of type "cv1 T1" is created and
1956 initialized from the initializer expression using the rules for a
1957 non-reference copy initialization. If T1 is reference-related to
1958 T2, cv1 must be the same cv-qualification as, or greater
1959 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1964 }
1966 /* Returns the implicit conversion sequence (see [over.ics]) from type
1967 FROM to type TO. The optional expression EXPR may affect the
1968 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1969 true, this conversion is coming from a C-style cast. */
1974 {
1981 /* Other flags only apply to the primary function in overload
1982 resolution, or after we've chosen one. */
1987 /* FIXME: actually we don't want warnings either, but we can't just
1988 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1989 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1990 We really ought not to issue that warning until we've committed
1991 to that conversion. */
1994 /* Call reshape_init early to remove redundant braces. */
1999 {
2004 }
2008 else
2015 {
2019 /* As an extension, allow list-initialization of _Complex. */
2022 {
2026 }
2028 /* Allow conversion from an initializer-list with one element to a
2029 scalar type. */
2031 {
2033 tree elt;
2039 else
2045 {
2048 /* Too many levels of braces, i.e. '{{1}}'. */
2051 }
2052 }
2055 }
2061 {
2071 {
2075 {
2076 /* "If C is not an initializer-list constructor and the
2077 initializer list has a single element of type cv U, where U is
2078 X or a class derived from X, the implicit conversion sequence
2079 has Exact Match rank if U is X, or Conversion rank if U is
2080 derived from X." */
2086 }
2088 }
2090 /* We used to try to bind a reference to a temporary here, but that
2091 is now handled after the recursive call to this function at the end
2092 of reference_binding. */
2094 }
2097 }
2099 /* Like implicit_conversion, but return NULL if the conversion is bad.
2101 This is not static so that check_non_deducible_conversion can call it within
2102 add_template_candidate_real as part of overload resolution; it should not be
2103 called outside of overload resolution. */
2105 conversion *
2108 {
2114 }
2116 /* Add a new entry to the list of candidates. Used by the add_*_candidate
2117 functions. ARGS will not be changed until a single candidate is
2118 selected. */
2127 {
2145 /* Swap the conversions for comparison in joust; we'll swap them back
2146 before build_over_call. */
2150 }
2152 /* Return the number of remaining arguments in the parameter list
2153 beginning with ARG. */
2155 int
2157 {
2162 n++;
2165 }
2167 /* [over.match.copy]: When initializing a temporary object (12.2) to be bound
2168 to the first parameter of a constructor where the parameter is of type
2169 "reference to possibly cv-qualified T" and the constructor is called with a
2170 single argument in the context of direct-initialization of an object of type
2171 "cv2 T", explicit conversion functions are also considered.
2173 So set LOOKUP_COPY_PARM to let reference_binding know that
2174 it's being called in that context. */
2176 int
2178 {
2180 tree t;
2183 && (same_type_ignoring_top_level_qualifiers_p
2185 {
2191 }
2192 else
2196 }
2198 /* Create an overload candidate for the function or method FN called
2199 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
2200 FLAGS is passed on to implicit_conversion.
2202 This does not change ARGS.
2204 CTYPE, if non-NULL, is the type we want to pretend this function
2205 comes from for purposes of overload resolution. */
2213 tsubst_flags_t complain)
2214 {
2217 tree parmnode;
2223 /* At this point we should not see any functions which haven't been
2224 explicitly declared, except for friend functions which will have
2225 been found using argument dependent lookup. */
2228 /* The `this', `in_chrg' and VTT arguments to constructors are not
2229 considered in overload resolution. */
2231 {
2233 /* Bring back parameters omitted from an inherited ctor. */
2235 else
2239 {
2242 }
2243 }
2244 else
2251 /* 13.3.2 - Viable functions [over.match.viable]
2252 First, to be a viable function, a candidate function shall have enough
2253 parameters to agree in number with the arguments in the list.
2255 We need to check this first; otherwise, checking the ICSes might cause
2256 us to produce an ill-formed template instantiation. */
2260 {
2264 }
2268 {
2272 }
2274 /* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
2275 parameter of type "reference to cv C" (including such a constructor
2276 instantiated from a template) is excluded from the set of candidate
2277 functions when used to construct an object of type D with an argument list
2278 containing a single argument if C is reference-related to D. */
2280 && flag_new_inheriting_ctors
2282 {
2288 {
2291 }
2292 }
2294 /* Second, for a function to be viable, its constraints must be
2295 satisfied. */
2297 {
2300 }
2302 /* When looking for a function from a subobject from an implicit
2303 copy/move constructor/operator=, don't consider anything that takes (a
2304 reference to) an unrelated type. See c++/44909 and core 1092. */
2306 {
2312 else
2315 {
2318 ctype))
2320 }
2322 /* This only applies at the top level. */
2324 }
2329 /* Third, for F to be a viable function, there shall exist for each
2330 argument an implicit conversion sequence that converts that argument
2331 to the corresponding parameter of F. */
2336 {
2338 tree arg;
2346 {
2347 /* Already set during deduction. */
2350 }
2354 else
2363 {
2368 /* The type of the implicit object parameter ('this') for
2369 overload resolution is not always the same as for the
2370 function itself; conversion functions are considered to
2371 be members of the class being converted, and functions
2372 introduced by a using-declaration are considered to be
2373 members of the class that uses them.
2375 Since build_over_call ignores the ICS for the `this'
2376 parameter, we can just change the parm type. */
2378 {
2379 parmtype = cp_build_qualified_type
2382 {
2383 /* If the function has a ref-qualifier, the implicit
2384 object parameter has reference type. */
2387 /* The special handling of 'this' conversions in compare_ics
2388 does not apply if there is a ref-qualifier. */
2390 }
2391 else
2392 {
2394 /* We don't use build_this here because we don't want to
2395 capture the object argument until we've chosen a
2396 non-static member function. */
2399 }
2400 }
2407 }
2408 else
2409 {
2413 }
2420 {
2425 }
2428 {
2433 }
2434 }
2436 out:
2439 }
2441 /* Create an overload candidate for the conversion function FN which will
2442 be invoked for expression OBJ, producing a pointer-to-function which
2443 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2444 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2445 passed on to implicit_conversion.
2447 Actually, we don't really care about FN; we care about the type it
2448 converts to. There may be multiple conversion functions that will
2449 convert to that type, and we rely on build_user_type_conversion_1 to
2450 choose the best one; so when we create our candidate, we record the type
2451 instead of the function. */
2457 tsubst_flags_t complain)
2458 {
2476 /* Don't bother looking up the same type twice. */
2481 {
2487 else
2492 {
2495 /* Leave the 'cand' field null; we'll figure out the conversion in
2496 convert_like if this candidate is chosen. */
2498 }
2502 {
2506 }
2507 else
2508 {
2512 }
2519 {
2523 }
2530 }
2534 {
2538 }
2542 }
2544 static void
2548 {
2562 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2563 conversion ops are allowed. We handle that here by just checking for
2564 boolean_type_node because other operators don't ask for it. COND_EXPR
2565 also does contextual conversion to bool for the first operand, but we
2566 handle that in build_conditional_expr, and type1 here is operand 2. */
2571 {
2575 {
2577 /* We need something for printing the candidate. */
2581 }
2583 {
2588 }
2590 }
2592 /* For COND_EXPR we rearranged the arguments; undo that now. */
2594 {
2599 complain);
2602 else
2603 {
2606 boolean_type_node,
2608 }
2609 }
2616 }
2618 static bool
2620 {
2622 }
2624 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2626 static bool
2628 {
2629 /* [over.built]
2631 In this section, the term promoted integral type is used to refer
2632 to those integral types which are preserved by integral promotion
2633 (including e.g. int and long but excluding e.g. char).
2634 Similarly, the term promoted arithmetic type refers to promoted
2635 integral types plus floating types. */
2639 }
2641 /* Create any builtin operator overload candidates for the operator in
2642 question given the converted operand types TYPE1 and TYPE2. The other
2643 args are passed through from add_builtin_candidates to
2644 build_builtin_candidate.
2646 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2647 If CODE is requires candidates operands of the same type of the kind
2648 of which TYPE1 and TYPE2 are, we add both candidates
2649 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2651 static void
2656 {
2658 {
2666 }
2669 {
2671 /* 4 For every pair (T, VQ), where T is an arithmetic type other than bool,
2672 and VQ is either volatile or empty, there exist candidate operator
2673 functions of the form
2674 VQ T& operator++(VQ T&);
2675 T operator++(VQ T&, int);
2676 5 For every pair (T, VQ), where T is an arithmetic type other than bool,
2677 and VQ is either volatile or empty, there exist candidate operator
2678 functions of the form
2679 VQ T& operator--(VQ T&);
2680 T operator--(VQ T&, int);
2681 6 For every pair (T, VQ), where T is a cv-qualified or cv-unqualified object
2682 type, and VQ is either volatile or empty, there exist candidate operator
2683 functions of the form
2684 T*VQ& operator++(T*VQ&);
2685 T*VQ& operator--(T*VQ&);
2686 T* operator++(T*VQ&, int);
2687 T* operator--(T*VQ&, int); */
2693 /* FALLTHRU */
2696 /* P0002R1, Remove deprecated operator++(bool) added "other than bool"
2697 to p4. */
2701 {
2704 }
2707 /* 7 For every cv-qualified or cv-unqualified object type T, there
2708 exist candidate operator functions of the form
2710 T& operator*(T*);
2713 8 For every function type T that does not have cv-qualifiers or
2714 a ref-qualifier, there exist candidate operator functions of the form
2715 T& operator*(T*); */
2724 /* 9 For every type T, there exist candidate operator functions of the form
2725 T* operator+(T*);
2727 10 For every floating-point or promoted integral type T, there exist
2728 candidate operator functions of the form
2729 T operator+(T);
2730 T operator-(T); */
2735 /* FALLTHRU */
2741 /* 11 For every promoted integral type T, there exist candidate operator
2742 functions of the form
2743 T operator~(T); */
2750 /* 12 For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, C1
2751 is the same type as C2 or is a derived class of C2, and T is an object
2752 type or a function type there exist candidate operator functions of the
2753 form
2754 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2755 where CV12 is the union of CV1 and CV2. */
2759 {
2767 }
2770 /* 13 For every pair of types L and R, where each of L and R is a floating-point
2771 or promoted integral type, there exist candidate operator functions of the
2772 form
2773 LR operator*(L, R);
2774 LR operator/(L, R);
2775 LR operator+(L, R);
2776 LR operator-(L, R);
2777 bool operator<(L, R);
2778 bool operator>(L, R);
2779 bool operator<=(L, R);
2780 bool operator>=(L, R);
2781 bool operator==(L, R);
2782 bool operator!=(L, R);
2783 where LR is the result of the usual arithmetic conversions between
2784 types L and R.
2786 14 For every integral type T there exists a candidate operator function of
2787 the form
2789 std::strong_ordering operator<=>(T, T);
2791 15 For every pair of floating-point types L and R, there exists a candidate
2792 operator function of the form
2794 std::partial_ordering operator<=>(L, R);
2796 16 For every cv-qualified or cv-unqualified object type T there exist
2797 candidate operator functions of the form
2798 T* operator+(T*, std::ptrdiff_t);
2799 T& operator[](T*, std::ptrdiff_t);
2800 T* operator-(T*, std::ptrdiff_t);
2801 T* operator+(std::ptrdiff_t, T*);
2802 T& operator[](std::ptrdiff_t, T*);
2804 17 For every T, where T is a pointer to object type, there exist candidate
2805 operator functions of the form
2806 std::ptrdiff_t operator-(T, T);
2808 18 For every T, where T is an enumeration type or a pointer type, there
2809 exist candidate operator functions of the form
2810 bool operator<(T, T);
2811 bool operator>(T, T);
2812 bool operator<=(T, T);
2813 bool operator>=(T, T);
2814 bool operator==(T, T);
2815 bool operator!=(T, T);
2816 R operator<=>(T, T);
2818 where R is the result type specified in [expr.spaceship].
2820 19 For every T, where T is a pointer-to-member type or std::nullptr_t,
2821 there exist candidate operator functions of the form
2822 bool operator==(T, T);
2823 bool operator!=(T, T); */
2830 {
2833 }
2834 /* FALLTHRU */
2841 /* This isn't exactly what's specified above for operator<=>, but it's
2842 close enough. In particular, we don't care about the return type
2843 specified above; it doesn't participate in overload resolution and it
2844 doesn't affect the semantics of the built-in operator. */
2854 {
2857 }
2859 {
2862 }
2863 /* Fall through. */
2879 {
2882 }
2885 {
2888 }
2894 /* FALLTHRU */
2897 {
2900 }
2902 {
2905 }
2908 /* 18For every pair of promoted integral types L and R, there exist candi-
2909 date operator functions of the form
2910 LR operator%(L, R);
2911 LR operator&(L, R);
2912 LR operator^(L, R);
2913 LR operator|(L, R);
2914 L operator<<(L, R);
2915 L operator>>(L, R);
2916 where LR is the result of the usual arithmetic conversions between
2917 types L and R. */
2925 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2929 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2930 type, VQ is either volatile or empty, and R is a promoted arithmetic
2931 type, there exist candidate operator functions of the form
2932 VQ L& operator=(VQ L&, R);
2933 VQ L& operator*=(VQ L&, R);
2934 VQ L& operator/=(VQ L&, R);
2935 VQ L& operator+=(VQ L&, R);
2936 VQ L& operator-=(VQ L&, R);
2938 20For every pair T, VQ), where T is any type and VQ is either volatile
2939 or empty, there exist candidate operator functions of the form
2940 T*VQ& operator=(T*VQ&, T*);
2942 21For every pair T, VQ), where T is a pointer to member type and VQ is
2943 either volatile or empty, there exist candidate operator functions of
2944 the form
2945 VQ T& operator=(VQ T&, T);
2947 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2948 unqualified complete object type, VQ is either volatile or empty, and
2949 I is a promoted integral type, there exist candidate operator func-
2950 tions of the form
2951 T*VQ& operator+=(T*VQ&, I);
2952 T*VQ& operator-=(T*VQ&, I);
2954 23For every triple L, VQ, R), where L is an integral or enumeration
2955 type, VQ is either volatile or empty, and R is a promoted integral
2956 type, there exist candidate operator functions of the form
2958 VQ L& operator%=(VQ L&, R);
2959 VQ L& operator<<=(VQ L&, R);
2960 VQ L& operator>>=(VQ L&, R);
2961 VQ L& operator&=(VQ L&, R);
2962 VQ L& operator^=(VQ L&, R);
2963 VQ L& operator|=(VQ L&, R); */
2967 {
2971 {
2974 }
2975 /* FALLTHRU */
2988 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
3001 {
3004 }
3009 }
3014 /* [over.built]
3016 For every pair of promoted arithmetic types L and R, there
3017 exist candidate operator functions of the form
3019 LR operator?(bool, L, R);
3021 where LR is the result of the usual arithmetic conversions
3022 between types L and R.
3024 For every type T, where T is a pointer or pointer-to-member
3025 type, there exist candidate operator functions of the form T
3026 operator?(bool, T, T); */
3030 /* That's OK. */
3033 /* Otherwise, the types should be pointers. */
3037 /* We don't check that the two types are the same; the logic
3038 below will actually create two candidates; one in which both
3039 parameter types are TYPE1, and one in which both parameter
3040 types are TYPE2. */
3051 }
3053 /* Make sure we don't create builtin candidates with dependent types. */
3057 {
3058 /* Try to recover if one of the types is non-dependent. But if
3059 there's only one type, there's nothing we can do. */
3062 /* And we lose if both are dependent. */
3065 /* Or if they have different forms. */
3073 }
3075 /* If we're dealing with two pointer types or two enumeral types,
3076 we need candidates for both of them. */
3085 {
3087 {
3090 error_mark_node,
3091 error_mark_node,
3092 CPO_CONVERSION,
3093 tf_none);
3095 {
3096 build_builtin_candidate
3100 }
3101 }
3103 build_builtin_candidate
3105 build_builtin_candidate
3108 }
3110 build_builtin_candidate
3112 }
3114 tree
3116 {
3122 }
3124 /* There are three conditions of builtin candidates:
3126 1) bool-taking candidates. These are the same regardless of the input.
3127 2) pointer-pair taking candidates. These are generated for each type
3128 one of the input types converts to.
3129 3) arithmetic candidates. According to the standard, we should generate
3130 all of these, but I'm trying not to...
3132 Here we generate a superset of the possible candidates for this particular
3133 case. That is a subset of the full set the standard defines, plus some
3134 other cases which the standard disallows. add_builtin_candidate will
3135 filter out the invalid set. */
3137 static void
3142 {
3146 /* TYPES[i] is the set of possible builtin-operator parameter types
3147 we will consider for the Ith argument. */
3154 {
3157 else
3159 }
3162 {
3163 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3164 and VQ is either volatile or empty, there exist candidate operator
3165 functions of the form
3166 VQ T& operator++(VQ T&); */
3176 /* 24There also exist candidate operator functions of the form
3177 bool operator!(bool);
3178 bool operator&&(bool, bool);
3179 bool operator||(bool, bool); */
3182 build_builtin_candidate
3189 build_builtin_candidate
3209 /* Fall through. */
3213 }
3221 {
3223 {
3224 tree convs;
3232 {
3237 }
3243 {
3256 {
3262 }
3266 }
3267 }
3268 else
3269 {
3274 {
3280 }
3282 }
3283 }
3285 /* Run through the possible parameter types of both arguments,
3286 creating candidates with those parameter types. */
3288 {
3290 tree u;
3294 add_builtin_candidate
3297 else
3298 add_builtin_candidate
3301 }
3305 }
3308 /* If TMPL can be successfully instantiated as indicated by
3309 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
3311 TMPL is the template. EXPLICIT_TARGS are any explicit template
3312 arguments. ARGLIST is the arguments provided at the call-site.
3313 This does not change ARGLIST. The RETURN_TYPE is the desired type
3314 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
3315 as for add_function_candidate. If an OBJ is supplied, FLAGS and
3316 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
3324 tsubst_flags_t complain)
3325 {
3335 tree arg;
3337 tree fn;
3342 /* We don't do deduction on the in-charge parameter, the VTT
3343 parameter or 'this'. */
3345 {
3349 /* We're deducing for a call to the result of a template conversion
3351 else
3353 }
3358 {
3361 else
3363 }
3371 {
3372 /* 12.8/6 says, "A declaration of a constructor for a class X is
3373 ill-formed if its first parameter is of type (optionally cv-qualified)
3374 X and either there are no other parameters or else all other
3375 parameters have default arguments. A member function template is never
3376 instantiated to produce such a constructor signature."
3378 So if we're trying to copy an object of the containing class, don't
3379 consider a template constructor that has a first parameter type that
3380 is just a template parameter, as we would deduce a signature that we
3381 would then reject in the code below. */
3383 {
3388 {
3392 }
3393 }
3394 }
3401 {
3404 }
3408 {
3411 }
3418 args_without_in_chrg,
3419 nargs_without_in_chrg,
3424 {
3425 /* Don't repeat unification later if it already resulted in errors. */
3429 nargs_without_in_chrg,
3431 else
3434 }
3436 /* Now the explicit specifier might have been deduced; check if this
3437 declaration is explicit. If it is and we're ignoring non-converting
3438 constructors, don't add this function to the set of candidates. */
3443 {
3446 ctype))
3447 {
3448 /* We're trying to produce a constructor with a prohibited signature,
3449 as discussed above; handle here any cases we didn't catch then,
3450 such as X(X<T>). */
3453 }
3454 }
3457 /* Aha, this is a conversion function. */
3460 else
3465 /* This situation can occur if a member template of a template
3466 class is specialized. Then, instantiate_template might return
3467 an instantiation of the specialization, in which case the
3468 DECL_TI_TEMPLATE field will point at the original
3469 specialization. For example:
3471 template <class T> struct S { template <class U> void f(U);
3472 template <> void f(int) {}; };
3473 S<double> sd;
3474 sd.f(3);
3476 Here, TMPL will be template <class U> S<double>::f(U).
3477 And, instantiate template will give us the specialization
3478 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3479 for this will point at template <class T> template <> S<T>::f(int),
3480 so that we can find the definition. For the purposes of
3481 overload resolution, however, we want the original TMPL. */
3483 else
3488 fail:
3491 }
3500 {
3501 return
3506 }
3508 /* Create an overload candidate for the conversion function template TMPL,
3509 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3510 pointer-to-function which will in turn be called with the argument list
3511 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3512 passed on to implicit_conversion. */
3516 tree obj,
3520 {
3521 /* Making this work broke PR 71117 and 85118, so until the committee resolves
3522 core issue 2189, let's disable this candidate if there are any call
3523 operators. */
3527 return
3531 complain);
3532 }
3534 /* The CANDS are the set of candidates that were considered for
3535 overload resolution. Return the set of viable candidates, or CANDS
3536 if none are viable. If any of the candidates were viable, set
3537 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3538 considered viable only if it is strictly viable. */
3544 {
3550 /* Be strict inside templates, since build_over_call won't actually
3551 do the conversions to get pedwarns. */
3561 {
3565 {
3566 /* Be strict in the presence of a viable candidate. Also if
3567 there are template candidates, so that we get deduction errors
3568 for them instead of silently preferring a bad conversion. */
3571 {
3572 /* Put any spliced near matches back onto the main list so
3573 that we see them if there is no strict match. */
3579 }
3580 }
3583 {
3591 }
3592 else
3594 }
3597 }
3599 static bool
3601 {
3606 }
3608 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3609 words, it is about to become the "this" pointer for a member
3610 function call. Take the address of the object. */
3612 static tree
3614 {
3615 /* In a template, we are only concerned about the type of the
3616 expression, so we can take a shortcut. */
3621 }
3623 /* Returns true iff functions are equivalent. Equivalent functions are
3624 not '==' only if one is a function-local extern function or if
3625 both are extern "C". */
3629 {
3638 }
3640 /* Print information about a candidate FN being rejected due to INFO. */
3642 static void
3644 tree fn)
3645 {
3650 {
3651 /* Conversion of implicit `this' argument failed. */
3653 /* A bad conversion for 'this' must be discarding cv-quals. */
3656 from);
3657 else
3661 }
3663 {
3668 tf_warning_or_error);
3669 }
3671 /* Conversion of conversion function return value failed. */
3674 else
3675 {
3680 }
3681 }
3683 /* Print information about a candidate with WANT parameters and we found
3684 HAVE. */
3686 static void
3688 {
3693 }
3695 /* Print information about one overload candidate CANDIDATE. MSGSTR
3696 is the text to print before the candidate itself.
3698 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3699 to have been run through gettext by the caller. This wart makes
3700 life simpler in print_z_candidates and for the translators. */
3702 static void
3705 {
3715 {
3726 else
3729 }
3740 else
3743 {
3746 }
3747 /* Give the user some information about why this candidate failed. */
3749 {
3753 {
3766 "cannot be converted to %qT with a qualification "
3772 "conversion function specialization to %qT is not an "
3777 /* We use template_unification_error_rejection if unification caused
3778 actual non-SFINAE errors, in which case we don't need to repeat
3779 them here. */
3781 {
3785 }
3786 /* Re-run template unification with diagnostics. */
3790 (make_tree_vec
3801 " a constructor taking a single argument of its own "
3809 "initialization from an expression of the same or derived "
3814 /* This candidate didn't have any issues or we failed to
3815 handle a particular code. Either way... */
3817 }
3818 }
3819 }
3821 static void
3823 {
3830 /* Remove non-viable deleted candidates. */
3833 {
3838 else
3840 }
3841 /* ...if there are any non-deleted ones. */
3845 /* There may be duplicates in the set of candidates. We put off
3846 checking this condition as long as possible, since we have no way
3847 to eliminate duplicates from a set of functions in less than n^2
3848 time. Now we are about to emit an error message, so it is more
3849 permissible to go slowly. */
3851 {
3853 /* Skip builtin candidates and conversion functions. */
3858 {
3862 else
3864 }
3865 }
3869 }
3871 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3872 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3873 the result of the conversion function to convert it to the final
3874 desired type. Merge the two sequences into a single sequence,
3875 and return the merged sequence. */
3879 {
3885 /* Find the end of the second conversion sequence. */
3887 {
3888 /* The entire sequence is a user-conversion sequence. */
3892 }
3895 /* We're binding a reference directly to the result of the conversion.
3896 build_user_type_conversion_1 stripped the REFERENCE_TYPE from the return
3897 type, but we want it back. */
3900 /* Replace the identity conversion with the user conversion
3901 sequence. */
3905 }
3907 /* Handle overload resolution for initializing an object of class type from
3908 an initializer list. First we look for a suitable constructor that
3909 takes a std::initializer_list; if we don't find one, we then look for a
3910 non-list constructor.
3912 Parameters are as for add_candidates, except that the arguments are in
3913 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3914 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3916 static void
3923 tsubst_flags_t complain)
3924 {
3927 /* We're looking for a ctor for list-initialization. */
3929 /* And we don't allow narrowing conversions. We also use this flag to
3930 avoid the copy constructor call for copy-list-initialization. */
3936 /* Always use the default constructor if the list is empty (DR 990). */
3939 ;
3940 /* If the class has a list ctor, try passing the list as a single
3941 argument first, but only consider list ctors. */
3943 {
3950 }
3953 {
3958 }
3960 /* Expand the CONSTRUCTOR into a new argument vec. */
3968 /* We aren't looking for list-ctors anymore. */
3970 /* We allow more user-defined conversions within an init-list. */
3976 }
3978 /* Returns the best overload candidate to perform the requested
3979 conversion. This function is used for three the overloading situations
3980 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3981 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3982 per [dcl.init.ref], so we ignore temporary bindings. */
3986 tsubst_flags_t complain)
3987 {
3989 tree fromtype;
4003 /* We represent conversion within a hierarchy using RVALUE_CONV and
4004 BASE_CONV, as specified by [over.best.ics]; these become plain
4005 constructor calls, as specified in [dcl.init]. */
4010 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
4011 creating a garbage BASELINK; constructors can't be inherited. */
4015 {
4020 {
4021 /* [class.conv.fct] A conversion function is never used to
4022 convert a (possibly cv-qualified) object to the (possibly
4023 cv-qualified) same object type (or a reference to it), to a
4024 (possibly cv-qualified) base class of that type (or a
4025 reference to it)... */
4026 }
4027 else
4029 }
4036 /* It's OK to bind a temporary for converting constructor arguments, but
4037 not in converting the return value of a conversion operator. */
4043 {
4048 /* We should never try to call the abstract or base constructor
4049 from here. */
4055 {
4056 /* List-initialization. */
4060 }
4061 else
4062 {
4066 }
4069 {
4072 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
4073 set, then this is copy-initialization. In that case, "The
4074 result of the call is then used to direct-initialize the
4075 object that is the destination of the copy-initialization."
4076 [dcl.init]
4078 We represent this in the conversion sequence with an
4079 rvalue conversion, which means a constructor call. */
4082 cand->second_conv
4084 }
4085 }
4088 {
4091 else
4093 }
4096 {
4100 /* If we are called to convert to a reference type, we are trying to
4101 find a direct binding, so don't even consider temporaries. If
4102 we don't find a direct binding, the caller will try again to
4103 look for a temporary binding. */
4114 {
4116 /* Already rejected, don't change to -1. */
4120 conversion *ics
4122 rettype,
4125 complain);
4127 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
4128 copy-initialization. In that case, "The result of the
4129 call is then used to direct-initialize the object that is
4130 the destination of the copy-initialization." [dcl.init]
4132 We represent this in the conversion sequence with an
4133 rvalue conversion, which means a constructor call. But
4134 don't add a second rvalue conversion if there's already
4135 one there. Which there really shouldn't be, but it's
4136 harmless since we'd add it here anyway. */
4144 {
4149 }
4151 /* Limit this to non-templates for now (PR90546). */
4154 {
4155 /* If we are called to convert to a reference type, we are trying
4156 to find a direct binding per [over.match.ref], so rvaluedness
4157 must match for non-functions. */
4159 }
4162 {
4163 /* 13.3.1.5: For direct-initialization, those explicit
4164 conversion functions that are not hidden within S and
4165 yield type T or a type that can be converted to type T
4166 with a qualification conversion (4.4) are also candidate
4167 functions. */
4168 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
4169 I've raised this issue with the committee. --jason 9/2011 */
4172 }
4174 {
4176 cand->reason
4180 }
4183 {
4184 /* 13.3.3.1.2: If the user-defined conversion is specified by
4185 a specialization of a conversion function template, the
4186 second standard conversion sequence shall have exact match
4187 rank. */
4190 }
4191 }
4192 }
4196 {
4200 }
4204 {
4206 {
4207 auto_diagnostic_group d;
4212 }
4221 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
4222 ambiguous conversion is no worse than another user-defined
4223 conversion. */
4226 }
4228 tree convtype;
4232 /* DR 5: [in the first step of copy-initialization]...if the function
4233 is a constructor, the call initializes a temporary of the
4234 cv-unqualified version of the destination type. */
4236 else
4238 /* Build the user conversion sequence. */
4239 conv = build_conv
4241 convtype,
4247 /* We're performing the maybe-rvalue overload resolution and
4248 a conversion function is in play. Reject converting the return
4249 value of the conversion function to a base class. */
4255 /* Remember that this was a list-initialization. */
4259 /* Combine it with the second conversion sequence. */
4264 }
4266 /* Wrapper for above. */
4268 tree
4270 tsubst_flags_t complain)
4271 {
4273 tree ret;
4279 {
4282 else
4283 {
4286 }
4287 }
4288 else
4293 }
4295 /* Give a helpful diagnostic when implicit_conversion fails. */
4297 static void
4299 {
4302 /* If expr has unknown type, then it is an overloaded function.
4303 Call instantiate_type to get good error messages. */
4313 else
4314 {
4319 }
4320 }
4322 /* Worker for build_converted_constant_expr. */
4324 static tree
4327 {
4330 tree t;
4336 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4342 /* A converted constant expression of type T is an expression, implicitly
4343 converted to type T, where the converted expression is a constant
4344 expression and the implicit conversion sequence contains only
4346 * user-defined conversions,
4347 * lvalue-to-rvalue conversions (7.1),
4348 * array-to-pointer conversions (7.2),
4349 * function-to-pointer conversions (7.3),
4350 * qualification conversions (7.5),
4351 * integral promotions (7.6),
4352 * integral conversions (7.8) other than narrowing conversions (11.6.4),
4353 * null pointer conversions (7.11) from std::nullptr_t,
4354 * null member pointer conversions (7.12) from std::nullptr_t, and
4355 * function pointer conversions (7.13),
4357 and where the reference binding (if any) binds directly. */
4362 {
4364 {
4365 /* A conversion function is OK. If it isn't constexpr, we'll
4366 complain later that the argument isn't constant. */
4368 /* List-initialization is OK. */
4370 /* The lvalue-to-rvalue conversion is OK. */
4372 /* Array-to-pointer and function-to-pointer. */
4374 /* Function pointer conversions. */
4376 /* Qualification conversions. */
4382 {
4388 }
4398 /* Integral promotion or conversion. */
4401 /* Conversion from nullptr to pointer or pointer-to-member. */
4407 /* fall through. */
4412 }
4413 }
4415 /* Avoid confusing convert_nontype_argument by introducing
4416 a redundant conversion to the same reference type. */
4419 {
4423 }
4426 {
4427 /* Don't copy a class in a template. */
4435 }
4436 else
4437 {
4441 }
4443 /* Free all the conversions we allocated. */
4447 }
4449 /* Subroutine of convert_nontype_argument.
4451 EXPR is an expression used in a context that requires a converted
4452 constant-expression, such as a template non-type parameter. Do any
4453 necessary conversions (that are permitted for converted
4454 constant-expressions) to convert it to the desired type.
4456 This function doesn't consider explicit conversion functions. If
4457 you mean to use "a contextually converted constant expression of type
4458 bool", use build_converted_constant_bool_expr.
4460 If conversion is successful, returns the converted expression;
4461 otherwise, returns error_mark_node. */
4463 tree
4465 {
4467 complain);
4468 }
4470 /* Used to create "a contextually converted constant expression of type
4471 bool". This differs from build_converted_constant_expr in that it
4472 also considers explicit conversion functions. */
4474 tree
4476 {
4479 }
4481 /* Do any initial processing on the arguments to a function call. */
4485 {
4487 tree arg;
4490 {
4494 {
4499 }
4502 }
4504 }
4506 /* Perform overload resolution on FN, which is called with the ARGS.
4508 Return the candidate function selected by overload resolution, or
4509 NULL if the event that overload resolution failed. In the case
4510 that overload resolution fails, *CANDIDATES will be the set of
4511 candidates considered, and ANY_VIABLE_P will be set to true or
4512 false to indicate whether or not any of the candidates were
4513 viable.
4515 The ARGS should already have gone through RESOLVE_ARGS before this
4516 function is called. */
4523 {
4525 tree explicit_targs;
4536 /* Check FN. */
4540 {
4544 }
4546 /* Add the various candidate functions. */
4551 LOOKUP_NORMAL,
4557 else
4562 }
4564 /* Print an error message about being unable to build a call to FN with
4565 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4566 be located; CANDIDATES is a possibly empty list of such
4567 functions. */
4569 static void
4572 {
4575 {
4578 }
4584 auto_diagnostic_group d;
4588 else
4593 }
4595 /* Return an expression for a call to FN (a namespace-scope function,
4596 or a static member function) with the ARGS. This may change
4597 ARGS. */
4599 tree
4601 tsubst_flags_t complain)
4602 {
4606 tree result;
4609 {
4613 }
4618 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4622 complain);
4625 {
4627 {
4628 // If there is a single (non-viable) function candidate,
4629 // let the error be diagnosed by cp_build_function_call_vec.
4634 // Otherwise, emit notes for non-viable candidates.
4636 }
4638 }
4639 else
4640 {
4642 }
4645 && result
4651 /* Free all the conversions we allocated. */
4655 }
4657 /* Build a call to a global operator new. FNNAME is the name of the
4658 operator (either "operator new" or "operator new[]") and ARGS are
4659 the arguments provided. This may change ARGS. *SIZE points to the
4660 total number of bytes required by the allocation, and is updated if
4661 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4662 be used. If this function determines that no cookie should be
4663 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4664 is not NULL_TREE, it is evaluated before calculating the final
4665 array size, and if it fails, the array size is replaced with
4666 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4667 is non-NULL, it will be set, upon return, to the allocation
4668 function called. */
4670 tree
4675 {
4677 tree fns;
4684 /* Set to (size_t)-1 if the size check fails. */
4686 {
4692 }
4698 /* Based on:
4700 [expr.new]
4702 If this lookup fails to find the name, or if the allocated type
4703 is not a class type, the allocation function's name is looked
4704 up in the global scope.
4706 we disregard block-scope declarations of "operator new". */
4711 {
4718 /* If no aligned allocation function matches, try again without the
4719 alignment. */
4720 }
4722 /* Figure out what function is being called. */
4725 complain);
4727 /* If no suitable function could be found, issue an error message
4728 and give up. */
4730 {
4734 }
4736 /* If a cookie is required, add some extra space. Whether
4737 or not a cookie is required cannot be determined until
4738 after we know which function was called. */
4740 {
4742 tree arg_types;
4745 /* Skip the size_t parameter. */
4747 /* Check the remaining parameters (if any). */
4751 ptr_type_node))
4753 /* If we need a cookie, adjust the number of bytes allocated. */
4755 {
4756 /* Update the total size. */
4759 {
4760 /* Set to (size_t)-1 if the size check fails. */
4764 }
4765 /* Update the argument list to reflect the adjusted size. */
4767 }
4768 else
4770 }
4772 /* Tell our caller which function we decided to call. */
4776 /* Build the CALL_EXPR. */
4778 }
4780 /* Build a new call to operator(). This may change ARGS. */
4782 static tree
4784 {
4801 {
4803 /* It's no good looking for an overloaded operator() on a
4804 pointer-to-member-function. */
4808 }
4811 {
4815 }
4816 else
4820 {
4824 }
4826 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4830 {
4838 }
4843 {
4851 {
4858 add_template_conv_candidate
4862 else
4866 }
4867 }
4869 /* Be strict here because if we choose a bad conversion candidate, the
4870 errors we get won't mention the call context. */
4873 {
4875 {
4876 auto_diagnostic_group d;
4880 }
4882 }
4883 else
4884 {
4887 {
4889 {
4890 auto_diagnostic_group d;
4894 }
4896 }
4901 else
4902 {
4906 else
4907 {
4910 }
4913 }
4914 }
4916 /* Free all the conversions we allocated. */
4920 }
4922 /* Wrapper for above. */
4924 tree
4926 {
4927 tree ret;
4932 }
4934 /* Called by op_error to prepare format strings suitable for the error
4935 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4936 and a suffix (controlled by NTYPES). */
4940 {
4950 else
4954 }
4956 static void
4960 {
4965 {
4971 else
4983 else
4993 else
5004 else
5013 else
5022 {
5027 }
5028 else
5033 else
5037 else
5042 }
5043 }
5045 /* Return the implicit conversion sequence that could be used to
5046 convert E1 to E2 in [expr.cond]. */
5050 {
5056 /* [expr.cond]
5058 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
5059 implicitly converted (clause _conv_) to the type "lvalue reference to
5060 T2", subject to the constraint that in the conversion the
5061 reference must bind directly (_dcl.init.ref_) to an lvalue.
5063 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
5064 implicitly converted to the type "rvalue reference to T2", subject to
5065 the constraint that the reference must bind directly. */
5067 {
5070 t1,
5071 e1,
5073 LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND
5075 complain);
5078 }
5080 /* If E2 is a prvalue or if neither of the conversions above can be done
5081 and at least one of the operands has (possibly cv-qualified) class
5082 type: */
5086 /* [expr.cond]
5088 If E1 and E2 have class type, and the underlying class types are
5089 the same or one is a base class of the other: E1 can be converted
5090 to match E2 if the class of T2 is the same type as, or a base
5091 class of, the class of T1, and the cv-qualification of T2 is the
5092 same cv-qualification as, or a greater cv-qualification than, the
5093 cv-qualification of T1. If the conversion is applied, E1 is
5094 changed to an rvalue of type T2 that still refers to the original
5095 source class object (or the appropriate subobject thereof). */
5098 {
5100 {
5105 else
5108 }
5109 else
5111 }
5112 else
5113 /* [expr.cond]
5115 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
5116 converted to the type that expression E2 would have if E2 were
5117 converted to an rvalue (or the type it has, if E2 is an rvalue). */
5120 }
5122 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
5123 arguments to the conditional expression. */
5125 static tree
5128 tsubst_flags_t complain)
5129 {
5130 tree arg2_type;
5131 tree arg3_type;
5140 /* As a G++ extension, the second argument to the conditional can be
5141 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
5142 c'.) If the second operand is omitted, make sure it is
5143 calculated only once. */
5145 {
5148 "ISO C++ forbids omitting the middle term of "
5154 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
5156 {
5159 }
5160 else
5162 }
5164 /* If something has already gone wrong, just pass that fact up the
5165 tree. */
5176 {
5179 /* If arg1 is another cond_expr choosing between -1 and 0,
5180 then we can use its comparison. It may help to avoid
5181 additional comparison, produce more accurate diagnostics
5182 and enables folding. */
5192 /* force_rvalue can return error_mark on valid arguments. */
5203 {
5204 /* Rely on the error messages of the scalar version. */
5213 {
5221 }
5225 /* We could pass complain & tf_warning to unsafe_conversion_p,
5226 but the warnings (like Wsign-conversion) have already been
5227 given by the scalar build_conditional_expr_1. We still check
5228 unsafe_conversion_p to forbid truncating long long -> float. */
5230 {
5235 }
5237 {
5242 }
5252 }
5256 {
5262 {
5266 {
5272 }
5274 {
5280 }
5283 }
5284 }
5292 {
5295 "incompatible vector types in conditional expression: "
5299 }
5302 {
5305 }
5307 }
5309 /* [expr.cond]
5311 The first expression is implicitly converted to bool (clause
5312 _conv_). */
5314 LOOKUP_NORMAL);
5318 /* [expr.cond]
5320 If either the second or the third operand has type (possibly
5321 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
5322 array-to-pointer (_conv.array_), and function-to-pointer
5323 (_conv.func_) standard conversions are performed on the second
5324 and third operands. */
5328 {
5329 /* 'void' won't help in resolving an overloaded expression on the
5330 other side, so require it to resolve by itself. */
5332 {
5335 }
5337 {
5340 }
5342 /* [expr.cond]
5344 One of the following shall hold:
5346 --The second or the third operand (but not both) is a
5347 throw-expression (_except.throw_); the result is of the type
5348 and value category of the other.
5350 --Both the second and the third operands have type void; the
5351 result is of type void and is a prvalue. */
5354 {
5357 }
5360 {
5363 }
5365 {
5368 }
5369 else
5370 {
5372 {
5375 "second operand to the conditional operator "
5376 "is of type %<void%>, but the third operand is "
5378 else
5380 "third operand to the conditional operator "
5381 "is of type %<void%>, but the second operand is "
5383 }
5385 }
5388 }
5389 /* [expr.cond]
5391 Otherwise, if the second and third operand have different types,
5392 and either has (possibly cv-qualified) class type, or if both are
5393 glvalues of the same value category and the same type except for
5394 cv-qualification, an attempt is made to convert each of those operands
5395 to the type of the other. */
5399 arg3_type)
5402 {
5407 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5413 /* [expr.cond]
5415 If both can be converted, or one can be converted but the
5416 conversion is ambiguous, the program is ill-formed. If
5417 neither can be converted, the operands are left unchanged and
5418 further checking is performed as described below. If exactly
5419 one conversion is possible, that conversion is applied to the
5420 chosen operand and the converted operand is used in place of
5421 the original operand for the remainder of this section. */
5426 {
5428 {
5436 else
5438 }
5440 }
5442 {
5446 /* Even if CONV2 is a valid conversion, the result of the
5447 conversion may be invalid. For example, if ARG3 has type
5448 "volatile X", and X does not have a copy constructor
5449 accepting a "volatile X&", then even if ARG2 can be
5450 converted to X, the conversion will fail. */
5454 }
5456 {
5463 }
5465 /* Free all the conversions we allocated. */
5471 /* If, after the conversion, both operands have class type,
5472 treat the cv-qualification of both operands as if it were the
5473 union of the cv-qualification of the operands.
5475 The standard is not clear about what to do in this
5476 circumstance. For example, if the first operand has type
5477 "const X" and the second operand has a user-defined
5478 conversion to "volatile X", what is the type of the second
5479 operand after this step? Making it be "const X" (matching
5480 the first operand) seems wrong, as that discards the
5481 qualification without actually performing a copy. Leaving it
5482 as "volatile X" seems wrong as that will result in the
5483 conditional expression failing altogether, even though,
5484 according to this step, the one operand could be converted to
5485 the type of the other. */
5493 }
5495 /* [expr.cond]
5497 If the second and third operands are glvalues of the same value
5498 category and have the same type, the result is of that type and
5499 value category. */
5503 {
5508 }
5510 /* [expr.cond]
5512 Otherwise, the result is an rvalue. If the second and third
5513 operand do not have the same type, and either has (possibly
5514 cv-qualified) class type, overload resolution is used to
5515 determine the conversions (if any) to be applied to the operands
5516 (_over.match.oper_, _over.built_). */
5520 {
5521 releasing_vec args;
5525 /* Rearrange the arguments so that add_builtin_candidate only has
5526 to know about two args. In build_builtin_candidate, the
5527 arguments are unscrambled. */
5532 COND_EXPR,
5533 NOP_EXPR,
5535 args,
5538 /* [expr.cond]
5540 If the overload resolution fails, the program is
5541 ill-formed. */
5544 {
5549 }
5552 {
5554 {
5555 auto_diagnostic_group d;
5558 }
5560 }
5562 /* [expr.cond]
5564 Otherwise, the conversions thus determined are applied, and
5565 the converted operands are used in place of the original
5566 operands for the remainder of this section. */
5575 }
5577 /* [expr.cond]
5579 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
5580 and function-to-pointer (_conv.func_) standard conversions are
5581 performed on the second and third operands.
5583 We need to force the lvalue-to-rvalue conversion here for class types,
5584 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
5585 that isn't wrapped with a TARGET_EXPR plays havoc with exception
5586 regions. */
5599 /* [expr.cond]
5601 After those conversions, one of the following shall hold:
5603 --The second and third operands have the same type; the result is of
5604 that type. */
5607 /* [expr.cond]
5609 --The second and third operands have arithmetic or enumeration
5610 type; the usual arithmetic conversions are performed to bring
5611 them to a common type, and the result is of that type. */
5616 {
5617 /* In this case, there is always a common type. */
5619 arg3_type);
5622 "implicit conversion from %qH to %qI to "
5624 loc);
5628 {
5635 /* Two enumerators from the same enumeration can have different
5641 }
5648 {
5652 }
5656 }
5657 /* [expr.cond]
5659 --The second and third operands have pointer type, or one has
5660 pointer type and the other is a null pointer constant; pointer
5661 conversions (_conv.ptr_) and qualification conversions
5662 (_conv.qual_) are performed to bring them to their composite
5663 pointer type (_expr.rel_). The result is of the composite
5664 pointer type.
5666 --The second and third operands have pointer to member type, or
5667 one has pointer to member type and the other is a null pointer
5668 constant; pointer to member conversions (_conv.mem_) and
5669 qualification conversions (_conv.qual_) are performed to bring
5670 them to a common type, whose cv-qualification shall match the
5671 cv-qualification of either the second or the third operand.
5672 The result is of the common type. */
5680 {
5684 complain);
5689 }
5692 {
5697 }
5702 valid_operands:
5704 {
5705 /* Let lvalue_kind know this was a glvalue. */
5708 }
5712 /* If the ARG2 and ARG3 are the same and don't have side-effects,
5713 warn here, because the COND_EXPR will be turned into ARG2. */
5720 /* We can't use result_type below, as fold might have returned a
5721 throw_expr. */
5724 {
5725 /* Expand both sides into the same slot, hopefully the target of
5726 the ?: expression. We used to check for TARGET_EXPRs here,
5727 but now we sometimes wrap them in NOP_EXPRs so the test would
5728 fail. */
5731 /* If this expression is an rvalue, but might be mistaken for an
5732 lvalue, we must add a NON_LVALUE_EXPR. */
5734 }
5735 else
5739 }
5741 /* Wrapper for above. */
5743 tree
5746 tsubst_flags_t complain)
5747 {
5748 tree ret;
5753 }
5755 /* OPERAND is an operand to an expression. Perform necessary steps
5756 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5757 returned. */
5759 static tree
5761 {
5763 {
5766 /* Make sure the template type is instantiated now. */
5768 }
5771 }
5773 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5774 OVERLOAD) to the CANDIDATES, returning an updated list of
5775 CANDIDATES. The ARGS are the arguments provided to the call;
5776 if FIRST_ARG is non-null it is the implicit object argument,
5777 otherwise the first element of ARGS is used if needed. The
5778 EXPLICIT_TARGS are explicit template arguments provided.
5779 TEMPLATE_ONLY is true if only template functions should be
5780 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5781 add_function_candidate. */
5783 static void
5785 tree return_type,
5790 tsubst_flags_t complain)
5791 {
5792 tree ctype;
5796 unification_kind_t strict;
5801 /* Precalculate special handling of constructors and conversion ops. */
5804 {
5808 /* We're doing return_type(x). */
5810 else
5811 /* We're doing x.operator return_type(). */
5813 /* [over.match.funcs] For conversion functions, the function
5814 is considered to be a member of the class of the implicit
5815 object argument for the purpose of defining the type of
5816 the implicit object parameter. */
5818 }
5819 else
5820 {
5822 {
5824 /* For list-initialization we consider explicit constructors
5825 and complain if one is chosen. */
5826 check_converting
5829 }
5832 }
5836 else
5837 /* Delay creating the implicit this parameter until it is needed. */
5841 {
5853 {
5854 /* Figure out where the object arg comes from. If this
5855 function is a non-static member and we didn't get an
5856 implicit object argument, move it out of args. */
5858 {
5860 tree arg;
5867 }
5871 }
5873 /* Don't bother reversing an operator with two identical parameters. */
5875 {
5880 }
5884 fn,
5885 ctype,
5886 explicit_targs,
5887 fn_first_arg,
5888 fn_args,
5889 return_type,
5890 access_path,
5891 conversion_path,
5892 flags,
5893 strict,
5894 complain);
5897 fn,
5898 ctype,
5899 fn_first_arg,
5900 fn_args,
5901 access_path,
5902 conversion_path,
5903 flags,
5904 NULL,
5905 complain);
5906 }
5907 }
5909 /* Returns 1 if P0145R2 says that the LHS of operator CODE is evaluated first,
5910 -1 if the RHS is evaluated first, or 0 if the order is unspecified. */
5912 static int
5914 {
5916 {
5917 // 5. b @= a
5921 // 6. a[b]
5925 // 1. a.b
5926 // Not overloadable (yet).
5927 // 2. a->b
5928 // Only one argument.
5929 // 3. a->*b
5931 // 7. a << b
5933 // 8. a >> b
5939 }
5940 }
5942 /* Subroutine of build_new_op_1: Add to CANDIDATES all candidates for the
5943 operator indicated by CODE/CODE2. This function calls itself recursively to
5944 handle C++20 rewritten comparison operator candidates. */
5946 static tree
5951 {
5956 /* LOOKUP_REWRITTEN is set when we're looking for the == or <=> operator to
5957 rewrite from, and also when we're looking for the e.g. < operator to use
5958 on the result of <=>. In the latter case, we don't want the flag set in
5959 the candidate, we just want to suppress looking for rewrites. */
5966 {
5967 /* =, ->, [], () must be non-static member functions. */
5971 /* FALLTHRU */
5979 }
5981 /* Add namespace-scope operators to the list of functions to
5982 consider. */
5984 {
5990 }
5992 /* Add class-member operators to the candidate set. */
5997 {
6008 }
6009 /* Per [over.match.oper]3.2, if no operand has a class type, then
6010 only non-member functions that have type T1 or reference to
6011 cv-qualified-opt T1 for the first argument, if the first argument
6012 has an enumeration type, or T2 or reference to cv-qualified-opt
6013 T2 for the second argument, if the second argument has an
6014 enumeration type. Filter out those that don't match. */
6016 {
6020 {
6028 {
6035 && (same_type_ignoring_top_level_qualifiers_p
6040 }
6042 /* No argument has an appropriate type, so remove this
6043 candidate function from the list. */
6045 {
6048 }
6049 }
6050 }
6053 {
6054 /* The standard says to rewrite built-in candidates, too,
6055 but there's no point. */
6059 /* Maybe add C++20 rewritten comparison candidates. */
6065 {
6080 }
6083 {
6086 /* Add rewritten candidates in same order. */
6092 /* Add rewritten candidates in reverse order. */
6100 /* Release the vec if we didn't add a candidate that uses it. */
6103 {
6106 }
6108 }
6109 }
6112 }
6114 static tree
6117 tsubst_flags_t complain)
6118 {
6138 {
6141 }
6149 {
6154 /* Use build_op_new_call and build_op_delete_call instead. */
6158 /* Use build_op_call instead. */
6165 /* These are saved for the sake of warn_logical_operator. */
6175 /* These are saved for the sake of maybe_warn_bool_compare. */
6182 }
6188 /* Use build_conditional_expr instead. */
6195 {
6198 }
6207 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6216 {
6219 /* For these, the built-in candidates set is empty
6220 [over.match.oper]/3. We don't want non-strict matches
6221 because exact matches are always possible with built-in
6222 operators. The built-in candidate set for COMPONENT_REF
6223 would be empty too, but since there are no such built-in
6224 operators, we accept non-strict matches for them. */
6231 }
6235 {
6237 {
6240 /* Don't try anything fancy if we're not allowed to produce
6241 errors. */
6245 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
6246 distinguish between prefix and postfix ++ and
6247 operator++() was used for both, so we allow this with
6248 -fpermissive. */
6249 else
6250 {
6257 }
6264 else
6270 /* The caller will deal with these. */
6281 {
6282 /* If one of the arguments of the operator represents
6283 an invalid use of member function pointer, try to report
6284 a meaningful error ... */
6289 else
6290 {
6291 /* ... Otherwise, report the more generic
6292 "no matching operator found" error */
6293 auto_diagnostic_group d;
6296 }
6297 }
6300 }
6301 }
6302 else
6303 {
6306 {
6308 {
6309 auto_diagnostic_group d;
6312 }
6314 }
6316 {
6322 else
6323 {
6326 /* We'll wrap this call in another one. */
6329 {
6330 /* We swapped these in add_candidate, swap them back now. */
6334 "current function recursively with reversed "
6336 }
6338 }
6343 {
6348 /* This prevents build_new_function_call from discarding this
6349 function during instantiation of the enclosing template. */
6352 /* Specify evaluation order as per P0145R2. */
6355 {
6366 }
6367 }
6369 /* If this was a C++20 rewritten comparison, adjust the result. */
6371 {
6372 /* FIXME build_min_non_dep_op_overload can't handle rewrites. */
6376 {
6381 /* If a rewritten operator== candidate is selected by
6382 overload resolution for an operator @, its return type
6383 shall be cv bool.... */
6385 {
6387 {
6388 auto_diagnostic_group d;
6394 }
6396 }
6398 /* !(y == x) or !(x == y) */
6403 /* If a rewritten operator<=> candidate is selected by
6404 overload resolution for an operator @, x @ y is
6405 interpreted as 0 @ (y <=> x) if the selected candidate is
6406 a synthesized candidate with reversed order of parameters,
6407 or (x <=> y) @ 0 otherwise, using the selected rewritten
6408 operator<=> candidate. */
6411 /* We're in the build_new_op call below for an outer
6412 reversed call; we don't need to do anything more. */
6419 {
6429 }
6434 }
6435 }
6436 }
6437 else
6438 {
6439 /* Give any warnings we noticed during overload resolution. */
6441 {
6445 }
6447 /* Check for comparison of different enum types. */
6449 {
6467 }
6469 /* "If a built-in candidate is selected by overload resolution, the
6470 operands of class type are converted to the types of the
6471 corresponding parameters of the selected operation function,
6472 except that the second standard conversion sequence of a
6473 user-defined conversion sequence (12.3.3.1.2) is not applied." */
6476 {
6479 }
6482 {
6485 {
6488 }
6489 }
6492 {
6495 {
6498 }
6499 }
6500 }
6501 }
6503 user_defined_result_ready:
6505 /* Free all the conversions we allocated. */
6511 builtin:
6513 {
6528 /* Fall through. */
6541 /* Fall through. */
6576 RO_ARROW_STAR,
6577 complain),
6580 /* The caller will deal with these. */
6588 }
6590 }
6592 /* Wrapper for above. */
6594 tree
6598 {
6599 tree ret;
6605 }
6607 /* CALL was returned by some call-building function; extract the actual
6608 CALL_EXPR from any bits that have been tacked on, e.g. by
6609 convert_from_reference. */
6611 tree
6613 {
6622 {
6623 /* C++20 rewritten comparison operators. */
6632 {
6636 else
6638 }
6641 }
6647 }
6649 /* Returns true if FN has two parameters, of which the second has type
6650 size_t. */
6652 static bool
6654 {
6662 }
6664 /* True if T, an allocation function, has std::align_val_t as its second
6665 argument. */
6667 bool
6669 {
6675 }
6677 /* True if T is std::destroying_delete_t. */
6679 static bool
6681 {
6684 }
6686 /* A deallocation function with at least two parameters whose second parameter
6687 type is of type std::destroying_delete_t is a destroying operator delete. A
6688 destroying operator delete shall be a class member function named operator
6689 delete. [ Note: Array deletion cannot use a destroying operator
6690 delete. --end note ] */
6692 tree
6694 {
6700 }
6702 struct dealloc_info
6703 {
6706 tree destroying;
6707 };
6709 /* Returns true iff T, an element of an OVERLOAD chain, is a usual deallocation
6710 function (3.7.4.2 [basic.stc.dynamic.deallocation]). If so, and DI is
6711 non-null, also set *DI. */
6713 static bool
6715 {
6718 /* A template instance is never a usual deallocation function,
6719 regardless of its signature. */
6724 /* A usual deallocation function is a deallocation function whose parameters
6725 after the first are
6726 - optionally, a parameter of type std::destroying_delete_t, then
6727 - optionally, a parameter of type std::size_t, then
6728 - optionally, a parameter of type std::align_val_t. */
6732 {
6735 }
6739 {
6742 }
6745 {
6748 }
6750 }
6752 /* Just return whether FN is a usual deallocation function. */
6754 bool
6756 {
6758 }
6760 /* Build a call to operator delete. This has to be handled very specially,
6761 because the restrictions on what signatures match are different from all
6762 other call instances. For a normal delete, only a delete taking (void *)
6763 or (void *, size_t) is accepted. For a placement delete, only an exact
6764 match with the placement new is accepted.
6766 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
6767 ADDR is the pointer to be deleted.
6768 SIZE is the size of the memory block to be deleted.
6769 GLOBAL_P is true if the delete-expression should not consider
6770 class-specific delete operators.
6771 PLACEMENT is the corresponding placement new call, or NULL_TREE.
6773 If this call to "operator delete" is being generated as part to
6774 deallocate memory allocated via a new-expression (as per [expr.new]
6775 which requires that if the initialization throws an exception then
6776 we call a deallocation function), then ALLOC_FN is the allocation
6777 function. */
6779 tree
6783 {
6786 dealloc_info di_fn = { };
6798 /* In [class.free]
6800 If the result of the lookup is ambiguous or inaccessible, or if
6801 the lookup selects a placement deallocation function, the
6802 program is ill-formed.
6804 Therefore, we ask lookup_fnfields to complain about ambiguity. */
6805 {
6809 }
6810 else
6816 /* Strip const and volatile from addr. */
6821 {
6822 /* "A declaration of a placement deallocation function matches the
6823 declaration of a placement allocation function if it has the same
6824 number of parameters and, after parameter transformations (8.3.5),
6825 all parameter types except the first are identical."
6827 So we build up the function type we want and ask instantiate_type
6828 to get it for us. */
6839 /* "If the lookup finds the two-parameter form of a usual deallocation
6840 function (3.7.4.2) and that function, considered as a placement
6841 deallocation function, would have been selected as a match for the
6842 allocation function, the program is ill-formed." */
6844 {
6852 /* But if the class has an operator delete (void *), then that is
6853 the usual deallocation function, so we shouldn't complain
6854 about using the operator delete (void *, size_t). */
6858 {
6863 }
6864 /* Before C++14 a two-parameter global deallocation function is
6865 always a placement deallocation function, but warn if
6866 -Wc++14-compat. */
6868 {
6870 {
6871 auto_diagnostic_group d;
6874 }
6876 }
6879 {
6880 auto_diagnostic_group d;
6882 {
6883 /* Only mention C++14 for namespace-scope delete. */
6886 else
6888 "%qD is a usual (non-placement) deallocation "
6890 }
6891 }
6892 else
6894 ok:;
6895 }
6896 }
6897 else
6898 /* "Any non-placement deallocation function matches a non-placement
6899 allocation function. If the lookup finds a single matching
6900 deallocation function, that function will be called; otherwise, no
6901 deallocation function will be called." */
6903 {
6905 dealloc_info di_elt;
6907 {
6909 {
6913 }
6915 /* -- If any of the deallocation functions is a destroying
6916 operator delete, all deallocation functions that are not
6917 destroying operator deletes are eliminated from further
6918 consideration. */
6920 {
6922 {
6925 }
6927 }
6929 /* -- If the type has new-extended alignment, a function with a
6930 parameter of type std::align_val_t is preferred; otherwise a
6931 function without such a parameter is preferred. If exactly one
6932 preferred function is found, that function is selected and the
6933 selection process terminates. If more than one preferred
6934 function is found, all non-preferred functions are eliminated
6935 from further consideration. */
6937 {
6940 {
6942 {
6945 }
6947 }
6948 }
6950 /* -- If the deallocation functions have class scope, the one
6951 without a parameter of type std::size_t is selected. */
6956 /* -- If the type is complete and if, for the second alternative
6957 (delete array) only, the operand is a pointer to a class type
6958 with a non-trivial destructor or a (possibly multi-dimensional)
6959 array thereof, the function with a parameter of type std::size_t
6960 is selected.
6962 -- Otherwise, it is unspecified whether a deallocation function
6963 with a parameter of type std::size_t is selected. */
6964 else
6965 {
6969 /* We need a cookie to determine the array size. */
6971 }
6974 {
6977 }
6978 }
6979 }
6981 /* If we have a matching function, call it. */
6983 {
6986 /* If the FN is a member function, make sure that it is
6987 accessible. */
6990 complain);
6992 /* Core issue 901: It's ok to new a type with deleted delete. */
6997 {
6998 /* The placement args might not be suitable for overload
6999 resolution at this point, so build the call directly. */
7009 }
7010 else
7011 {
7014 {
7015 /* Strip const and volatile from addr but retain the type of the
7016 object. */
7023 complain);
7024 }
7026 tree ret;
7027 releasing_vec args;
7034 {
7037 }
7040 }
7041 }
7043 /* [expr.new]
7045 If no unambiguous matching deallocation function can be found,
7046 propagating the exception does not cause the object's memory to
7047 be freed. */
7049 {
7053 alloc_fn);
7055 }
7061 }
7063 /* Issue diagnostics about a disallowed access of DECL, using DIAG_DECL
7064 in the diagnostics.
7066 If ISSUE_ERROR is true, then issue an error about the
7067 access, followed by a note showing the declaration.
7068 Otherwise, just show the note. */
7070 void
7072 {
7074 {
7079 }
7081 {
7086 }
7087 else
7088 {
7092 }
7093 }
7095 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
7096 bitwise or of LOOKUP_* values. If any errors are warnings are
7097 generated, set *DIAGNOSTIC_FN to "error" or "warning",
7098 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
7099 to NULL. */
7101 static tree
7104 {
7109 /* If the source is a packed field, calling the copy constructor will require
7110 binding the field to the reference parameter to the copy constructor, and
7111 we'll end up with an infinite loop. If we can use a bitwise copy, then
7112 do that now. */
7127 }
7129 /* Get any location for EXPR, falling back to input_location.
7131 If the result is in a system header and is the virtual location for
7132 a token coming from the expansion of a macro, unwind it to the
7133 location of the expansion point of the macro (e.g. to avoid the
7134 diagnostic being suppressed for expansions of NULL where "NULL" is
7135 in a system header). */
7137 static location_t
7139 {
7143 }
7145 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
7146 Also handle a subset of zero as null warnings.
7147 EXPR is implicitly converted to type TOTYPE.
7148 FN and ARGNUM are used for diagnostics. */
7150 static void
7152 {
7153 /* Issue warnings about peculiar, but valid, uses of NULL. */
7157 {
7160 {
7161 auto_diagnostic_group d;
7167 }
7168 else
7171 }
7173 /* Issue warnings if "false" is converted to a NULL pointer */
7176 {
7179 {
7180 auto_diagnostic_group d;
7182 "converting %<false%> to pointer type for argument "
7186 }
7187 else
7190 }
7191 /* Handle zero as null pointer warnings for cases other
7192 than EQ_EXPR and NE_EXPR */
7195 {
7198 }
7199 }
7201 /* We gave a diagnostic during a conversion. If this was in the second
7202 standard conversion sequence of a user-defined conversion sequence, say
7203 which user-defined conversion. */
7205 static void
7207 {
7211 {
7215 }
7216 }
7218 /* Locate the parameter with the given index within FNDECL.
7219 ARGNUM is zero based, -1 indicates the `this' argument of a method.
7220 Return the location of the FNDECL itself if there are problems. */
7222 location_t
7224 {
7225 /* The locations of implicitly-declared functions are likely to be
7226 more meaningful than those of their parameters. */
7231 tree param;
7233 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
7237 ;
7239 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
7240 return the location of FNDECL. */
7245 }
7247 /* If FNDECL is non-NULL, issue a note highlighting ARGNUM
7248 within its declaration (or the fndecl itself if something went
7249 wrong). */
7251 void
7253 {
7257 }
7259 /* Maybe warn about C++20 Conversions to arrays of unknown bound. C is
7260 the conversion, EXPR is the expression we're converting. */
7262 static void
7264 {
7278 }
7280 /* We call this recursively in convert_like_internal. */
7282 tsubst_flags_t);
7284 /* Perform the conversions in CONVS on the expression EXPR. FN and
7285 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
7286 indicates the `this' argument of a method. INNER is nonzero when
7287 being called to continue a conversion chain. It is negative when a
7288 reference binding will be applied, positive otherwise. If
7289 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
7290 conversions will be emitted if appropriate. If C_CAST_P is true,
7291 this conversion is coming from a C-style cast; in that case,
7292 conversions to inaccessible bases are permitted. */
7294 static tree
7297 tsubst_flags_t complain)
7298 {
7300 diagnostic_t diag_kind;
7316 {
7320 /* Give a helpful error if this is bad because of excess braces. */
7325 {
7331 }
7333 /* Give a helpful error if this is bad because a conversion to bool
7334 from std::nullptr_t requires direct-initialization. */
7342 {
7344 {
7345 auto_diagnostic_group d;
7348 totype);
7357 complain);
7358 else
7363 }
7365 {
7370 }
7377 }
7379 {
7385 }
7390 }
7396 {
7398 {
7402 /* We chose the surrogate function from add_conv_candidate, now we
7403 actually need to build the conversion. */
7409 /* When converting from an init list we consider explicit
7410 constructors, but actually trying to call one is an error. */
7413 /* Unless this is for direct-list-initialization. */
7415 /* And in C++98 a default constructor can't be explicit. */
7417 {
7423 {
7424 auto_diagnostic_group d;
7430 }
7431 else
7434 }
7436 /* If we're initializing from {}, it's value-initialization. */
7441 {
7448 {
7451 }
7453 }
7455 /* We don't know here whether EXPR is being used as an lvalue or
7456 rvalue, but we know it's read. */
7459 /* Pass LOOKUP_NO_CONVERSION so rvalue/base handling knows not to allow
7460 any more UDCs. */
7462 complain);
7464 /* If this is a constructor or a function returning an aggr type,
7465 we need to build up a TARGET_EXPR. */
7467 {
7470 /* Remember that this was list-initialization. */
7473 }
7476 }
7479 {
7485 else
7487 }
7496 /* If __null has been converted to an integer type, we do not want to
7497 continue to warn about uses of EXPR as an integer, rather than as a
7498 pointer. */
7502 /* We leave bad_p off ck_ambig because overload resolution considers
7503 it valid, it just fails when we try to perform it. So we need to
7504 check complain here, too. */
7506 {
7507 /* Call build_user_type_conversion again for the error. */
7513 }
7517 {
7518 /* Conversion to std::initializer_list<T>. */
7521 tree array;
7524 {
7529 /* Convert all the elements. */
7531 {
7543 }
7544 /* Build up the array. */
7545 elttype = cp_build_qualified_type
7549 /* Take the address explicitly rather than via decay_conversion
7550 to avoid the error about taking the address of a temporary. */
7552 }
7553 else
7560 /* Build up the initializer_list object. Note: fail gracefully
7561 if the object cannot be completed because, for example, no
7562 definition is provided (c++/80956). */
7573 }
7577 {
7586 }
7589 complain);
7596 };
7606 {
7610 {
7612 {
7613 auto_diagnostic_group d;
7616 }
7618 }
7623 /* Don't introduce copies when passing arguments along to the inherited
7624 constructor. */
7626 && flag_new_inheriting_ctors
7632 /* Copy-list-initialization doesn't actually involve a copy. */
7635 /* Fall through. */
7638 {
7639 /* We are going to bind a reference directly to a base-class
7640 subobject of EXPR. */
7641 /* Build an expression for `*((base*) &expr)'. */
7645 }
7647 /* Copy-initialization where the cv-unqualified version of the source
7648 type is the same class as, or a derived class of, the class of the
7649 destination [is treated as direct-initialization]. [dcl.init] */
7651 /* This conversion is being done in the context of a user-defined
7652 conversion (i.e. the second step of copy-initialization), so
7653 don't allow any more. */
7656 /* We might be performing a conversion of the argument
7657 to the user-defined conversion, i.e., not a conversion of the
7658 result of the user-defined conversion. In which case we skip
7659 explicit constructors. */
7663 /* standard_conversion got LOOKUP_PREFER_RVALUE. */
7667 {
7668 auto_diagnostic_group d;
7671 }
7676 {
7679 /* direct_reference_binding might have inserted a ck_qual under
7680 this ck_ref_bind for the benefit of conversion sequence ranking.
7681 Ignore the conversion; we'll create our own below. */
7684 {
7687 /* Strip the cast created by the ck_qual; cp_build_addr_expr
7688 below expects an lvalue. */
7690 }
7693 {
7695 auto_diagnostic_group d;
7705 {
7706 /* If we're converting from T[] to T[N], don't talk
7707 about discarding qualifiers. (Converting from T[N] to
7708 T[] is allowed by P0388R4.) */
7715 else
7718 }
7719 else
7725 }
7729 /* If necessary, create a temporary.
7731 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
7732 that need temporaries, even when their types are reference
7733 compatible with the type of reference being bound, so the
7734 upcoming call to cp_build_addr_expr doesn't fail. */
7738 {
7739 /* Otherwise, a temporary of type "cv1 T1" is created and
7740 initialized from the initializer expression using the rules
7741 for a non-reference copy-initialization (8.5). */
7749 {
7750 /* If the reference is volatile or non-const, we
7751 cannot create a temporary. */
7753 {
7760 else
7763 }
7765 }
7766 /* If the source is a packed field, and we must use a copy
7767 constructor, then building the target expr will require
7768 binding the field to the reference parameter to the
7769 copy constructor, and we'll end up with an infinite
7770 loop. If we can use a bitwise copy, then we'll be
7771 OK. */
7775 {
7779 }
7781 {
7784 }
7786 /* Creating &TARGET_EXPR<> in a template would break when
7787 tsubsting the expression, so use an IMPLICIT_CONV_EXPR
7788 instead. This can happen even when there's no class
7789 involved, e.g., when converting an integer to a reference
7790 type. */
7794 }
7796 /* Take the address of the thing to which we will bind the
7797 reference. */
7802 /* Convert it to a pointer to the type referred to by the
7803 reference. This will adjust the pointer if a derived to
7804 base conversion is being performed. */
7807 /* Convert the pointer to the desired reference type. */
7809 }
7815 /* ??? Should the address of a transaction-safe pointer point to the TM
7816 clone, and this conversion look up the primary function? */
7820 /* Warn about deprecated conversion if appropriate. */
7822 {
7825 }
7840 }
7850 else
7854 }
7856 /* Wrapper for convert_like_internal that handles creating
7857 IMPLICIT_CONV_EXPR. */
7859 static tree
7862 tsubst_flags_t complain)
7863 {
7864 /* Creating &TARGET_EXPR<> in a template breaks when substituting,
7865 and creating a CALL_EXPR in a template breaks in finish_call_expr
7866 so use an IMPLICIT_CONV_EXPR for this conversion. We would have
7867 created such codes e.g. when calling a user-defined conversion
7868 function. */
7873 {
7879 /* Do the normal processing to give the bad_p errors. But we still
7880 need to return the IMPLICIT_CONV_EXPR, unless we're returning
7881 error_mark_node. */
7882 }
7888 }
7890 /* Convenience wrapper for convert_like. */
7894 {
7898 }
7900 /* Convenience wrapper for convert_like. */
7904 tsubst_flags_t complain)
7905 {
7909 }
7911 /* ARG is being passed to a varargs function. Perform any conversions
7912 required. Return the converted value. */
7914 tree
7916 {
7920 /* [expr.call]
7922 If the argument has integral or enumeration type that is subject
7923 to the integral promotions (_conv.prom_), or a floating-point
7924 type that is subject to the floating-point promotion
7925 (_conv.fpprom_), the value of the argument is converted to the
7926 promoted type before the call. */
7931 {
7935 "implicit conversion from %qH to %qI when passing "
7940 }
7942 {
7946 else
7948 }
7950 {
7952 {
7954 complain);
7961 arg_type,
7965 }
7966 else
7968 }
7969 else
7970 /* [expr.call]
7972 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
7973 standard conversions are performed. */
7980 /* In a template (or ill-formed code), we can have an incomplete type
7981 even after require_complete_type_sfinae, in which case we don't know
7982 whether it has trivial copy or not. */
7985 {
7986 /* [expr.call] 5.2.2/7:
7987 Passing a potentially-evaluated argument of class type (Clause 9)
7988 with a non-trivial copy constructor or a non-trivial destructor
7989 with no corresponding parameter is conditionally-supported, with
7990 implementation-defined semantics.
7992 We support it as pass-by-invisible-reference, just like a normal
7993 value parameter.
7995 If the call appears in the context of a sizeof expression,
7996 it is not potentially-evaluated. */
7999 {
8003 "passing objects of non-trivially-copyable "
8005 arg_type);
8007 }
8008 /* Build up a real lvalue-to-rvalue conversion in case the
8009 copy constructor is trivial but not callable. */
8013 }
8016 }
8018 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
8020 tree
8022 {
8024 {
8028 }
8038 {
8041 }
8045 {
8046 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
8047 it as pass by invisible reference. */
8049 "receiving objects of non-trivially-copyable type %q#T "
8055 }
8059 /* Wrap the VA_ARG_EXPR in a TARGET_EXPR now so other code doesn't need to
8060 know how to handle it. */
8063 }
8065 /* TYPE has been given to va_arg. Apply the default conversions which
8066 would have happened when passed via ellipsis. Return the promoted
8067 type, or the passed type if there is no change. */
8069 tree
8071 {
8072 tree promote;
8074 /* Perform the array-to-pointer and function-to-pointer
8075 conversions. */
8083 }
8085 /* ARG is a default argument expression being passed to a parameter of
8086 the indicated TYPE, which is a parameter to FN. PARMNUM is the
8087 zero-based argument number. Do any required conversions. Return
8088 the converted value. */
8091 void
8095 void
8099 tree
8101 tsubst_flags_t complain)
8102 {
8104 tree t;
8106 /* See through clones. */
8108 /* And inheriting ctors. */
8112 /* Detect recursion. */
8115 {
8119 }
8121 /* If the ARG is an unparsed default argument expression, the
8122 conversion cannot be performed. */
8124 {
8129 }
8136 /* Due to:
8138 [dcl.fct.default]
8140 The names in the expression are bound, and the semantic
8141 constraints are checked, at the point where the default
8142 expressions appears.
8144 we must not perform access checks here. */
8146 /* We must make a copy of ARG, in case subsequent processing
8147 alters any part of it. */
8152 complain);
8159 }
8161 /* Returns the type which will really be used for passing an argument of
8162 type TYPE. */
8164 tree
8166 {
8167 /* Pass classes with copy ctors by invisible reference. */
8169 {
8171 /* There are no other pointers to this temporary. */
8173 }
8181 }
8183 /* Actually perform the appropriate conversion. */
8185 tree
8187 {
8188 tree bitfield_type;
8190 /* If VAL is a bitfield, then -- since it has already been converted
8191 to TYPE -- it cannot have a precision greater than TYPE.
8193 If it has a smaller precision, we must widen it here. For
8194 example, passing "int f:3;" to a function expecting an "int" will
8195 not result in any conversion before this point.
8197 If the precision is the same we must not risk widening. For
8198 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
8199 often have type "int", even though the C++ type for the field is
8200 "long long". If the value is being passed to a function
8201 expecting an "int", then no conversions will be required. But,
8202 if we call convert_bitfield_to_declared_type, the bitfield will
8203 be converted to "long long". */
8210 ;
8211 /* Pass classes with copy ctors by invisible reference. */
8220 {
8222 {
8230 "argument of function call might be a candidate "
8232 }
8234 }
8240 }
8242 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
8243 which just decay_conversion or no conversions at all should be done.
8244 This is true for some builtins which don't act like normal functions.
8245 Return 2 if no conversions at all should be done, 1 if just
8246 decay_conversion. Return 3 for special treatment of the 3rd argument
8247 for __builtin_*_overflow_p. */
8249 int
8251 {
8254 {
8269 }
8272 }
8274 /* Returns the decl of the dispatcher function if FN is a function version. */
8276 tree
8278 {
8288 {
8292 }
8297 }
8299 /* fn is a function version dispatcher that is marked used. Mark all the
8300 semantically identical function versions it will dispatch as used. */
8302 void
8304 {
8321 /* All semantically identical versions are chained. Traverse and mark each
8322 one of them as used. */
8325 {
8328 }
8329 }
8331 /* Build a call to "the copy constructor" for the type of A, even if it
8332 wouldn't be selected by normal overload resolution. Used for
8333 diagnostics. */
8335 static tree
8337 {
8347 }
8349 /* Return true iff T refers to a base or potentially-overlapping field, which
8350 cannot be used for return by invisible reference. We avoid doing C++17
8351 mandatory copy elision when this is true.
8353 This returns true even if the type of T has no tail padding that other data
8354 could be allocated into, because that depends on the particular ABI.
8355 unsafe_copy_elision_p, below, does consider whether there is padding. */
8357 bool
8359 {
8368 /* The middle-end will do the right thing for scalar types. */
8372 }
8374 /* We can't elide a copy from a function returning by value to a
8375 potentially-overlapping subobject, as the callee might clobber tail padding.
8376 Return true iff this could be that case. */
8378 static bool
8380 {
8381 /* Copy elision only happens with a TARGET_EXPR. */
8385 /* It's safe to elide the copy for a class with no tail padding. */
8389 /* It's safe to elide the copy if we aren't initializing a base object. */
8393 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
8397 {
8398 /* We'll end up copying from each of the arms of the COND_EXPR directly
8399 into the target, so look at them. */
8404 }
8407 }
8409 /* True iff C is a conversion that binds a reference to a prvalue. */
8411 static bool
8413 {
8430 }
8432 /* Call the trivial destructor for INSTANCE, which can be either an lvalue of
8433 class type or a pointer to class type. If NO_PTR_DEREF is true and
8434 INSTANCE has pointer type, clobber the pointer rather than what it points
8435 to. */
8437 tree
8439 {
8443 {
8444 no_clobber:
8446 }
8450 {
8454 }
8456 /* A trivial destructor should still clobber the object. */
8460 }
8462 /* Subroutine of the various build_*_call functions. Overload resolution
8463 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
8464 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
8465 bitmask of various LOOKUP_* flags which apply to the call itself. */
8467 static tree
8469 {
8477 tree val;
8486 /* In a template, there is no need to perform all of the work that
8487 is normally done. We are only interested in the type of the call
8488 expression, i.e., the return type of the function. Any semantic
8489 errors will be deferred until the template is instantiated. */
8491 {
8493 tree return_type;
8499 else
8500 /* Otherwise set TREE_USED for the benefit of -Wunused-function.
8501 See PR80598. */
8508 else
8509 {
8512 tree arg;
8520 }
8536 {
8543 {
8546 }
8547 /* Look through *(const T *)&obj. */
8549 {
8553 {
8558 }
8559 }
8562 obj_arg);
8563 }
8565 }
8567 /* Give any warnings we noticed during overload resolution. */
8569 {
8573 }
8575 /* Core issue 2327: P0135 doesn't say how to handle the case where the
8576 argument to the copy constructor ends up being a prvalue after
8577 conversion. Let's do the normal processing, but pretend we aren't
8578 actually using the copy constructor. */
8587 {
8590 }
8592 /* OK, we're actually calling this inherited constructor; set its deletedness
8593 appropriately. We can get away with doing this here because calling is
8594 the only way to refer to a constructor. */
8598 /* Make =delete work with SFINAE. */
8600 {
8604 }
8607 {
8608 tree access_fn;
8609 /* If FN is a template function, two cases must be considered.
8610 For example:
8612 struct A {
8613 protected:
8614 template <class T> void f();
8615 };
8616 template <class T> struct B {
8617 protected:
8618 void g();
8619 };
8620 struct C : A, B<int> {
8621 using A::f; // #1
8622 using B<int>::g; // #2
8623 };
8625 In case #1 where `A::f' is a member template, DECL_ACCESS is
8626 recorded in the primary template but not in its specialization.
8627 We check access of FN using its primary template.
8629 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
8630 because it is a member of class template B, DECL_ACCESS is
8631 recorded in the specialization `B<int>::g'. We cannot use its
8632 primary template because `B<T>::g' and `B<int>::g' may have
8633 different access. */
8637 else
8642 }
8644 /* If we're checking for implicit delete, don't bother with argument
8645 conversions. */
8647 {
8651 /* Reject bad conversions now. */
8653 /* else continue to get conversion error. */
8654 }
8656 not_really_used:
8658 /* N3276 magic doesn't apply to nested calls. */
8661 /* No-Cleanup doesn't apply to nested calls either. */
8665 /* Find maximum size of vector to hold converted arguments. */
8672 /* The implicit parameters to a constructor are not considered by overload
8673 resolution, and must be of the proper type. */
8675 {
8676 tree object_arg;
8678 {
8681 }
8682 else
8683 {
8686 }
8689 /* We should never try to call the abstract constructor. */
8693 {
8697 }
8701 {
8702 /* The implicit move specified in 15.8.3/3 fails "...if the type of
8703 the first parameter of the selected constructor is not an rvalue
8704 reference to the object's type (possibly cv-qualified)...." */
8707 /* Allow calling a by-value converting constructor even though it
8708 isn't permitted by the above, because we've allowed it since GCC 5
8709 (PR58051) and it's allowed in C++20. But don't call a copy
8710 constructor. */
8714 }
8715 }
8716 /* Bypass access control for 'this' parameter. */
8718 {
8720 ? first_arg
8728 {
8730 {
8731 auto_diagnostic_group d;
8736 }
8737 else
8739 }
8741 /* The class where FN is defined. */
8744 /* See if the function member or the whole class type is declared
8745 final and the call can be devirtualized. */
8749 /* [class.mfct.non-static]: If a non-static member function of a class
8750 X is called for an object that is not of type X, or of a type
8751 derived from X, the behavior is undefined.
8753 So we can assume that anything passed as 'this' is non-null, and
8754 optimize accordingly. */
8755 /* Check that the base class is accessible. */
8758 {
8763 else
8765 }
8766 /* If fn was found by a using declaration, the conversion path
8767 will be to the derived class, not the base declaring fn. We
8768 must convert to the base. */
8771 {
8775 }
8779 /* If we know the dynamic type of the object, look up the final overrider
8780 in the BINFO. */
8783 {
8786 }
8792 else
8796 }
8801 {
8808 /* If the argument is NULL and used to (implicitly) instantiate a
8809 template function (and bind one of the template arguments to
8810 the type of 'long int'), we don't want to warn about passing NULL
8811 to non-pointer argument.
8812 For example, if we have this template function:
8814 template<typename T> void func(T x) {}
8816 we want to warn (when -Wconversion is enabled) in this case:
8818 void foo() {
8819 func<int>(NULL);
8820 }
8822 but not in this case:
8824 void foo() {
8825 func(NULL);
8826 }
8827 */
8834 /* Set user_conv_p on the argument conversions, so rvalue/base handling
8835 knows not to allow any more UDCs. This needs to happen after we
8836 process cand->warnings. */
8845 arg_complain);
8850 else
8852 }
8854 /* Default arguments */
8856 {
8862 complain);
8866 }
8868 /* Ellipsis */
8871 {
8874 {
8875 /* Do no conversions for certain magic varargs. */
8879 }
8881 /* For other magic varargs only do decay_conversion. */
8886 {
8887 /* Avoid infinite recursion trying to call A(...). */
8889 /* Try to call the actual copy constructor for a good error. */
8892 }
8893 else
8898 }
8903 /* Avoid performing argument transformation if warnings are disabled.
8904 When tf_warning is set and at least one of the warnings is active
8905 the check_function_arguments function might warn about something. */
8909 && (warn_nonnull
8910 || warn_format
8911 || warn_suggest_attribute_format
8913 {
8917 {
8918 /* For -Wformat undo the implicit passing by hidden reference
8919 done by convert_arg_to_ellipsis. */
8923 else
8925 }
8929 }
8932 {
8933 /* Check for passing ellipsis arguments to an inherited constructor. We
8934 could handle this by open-coding the inherited constructor rather than
8935 defining it, but let's not bother now. */
8939 {
8941 {
8945 }
8947 }
8949 /* A base constructor inheriting from a virtual base doesn't get the
8950 inherited arguments, just this and __vtt. */
8953 }
8955 /* Avoid actually calling copy constructors and copy assignment operators,
8956 if possible. */
8963 /* It's unsafe to elide the constructor when handling
8964 a noexcept-expression, it may evaluate to the wrong
8965 value (c++/53025). */
8967 {
8968 tree targ;
8973 /* Pull out the real argument, disregarding const-correctness. */
8975 /* Strip the reference binding for the constructor parameter. */
8979 /* But don't strip any other reference bindings; binding a temporary to a
8980 reference prevents copy elision. */
8986 {
8991 }
8992 else
8997 else
9000 /* In C++17 we shouldn't be copying a TARGET_EXPR except into a
9001 potentially-overlapping subobject. */
9004 || force_elide
9005 /* It's from binding the ref parm to a packed field. */
9008 /* See unsafe_copy_elision_p. */
9014 /* [class.copy]: the copy constructor is implicitly defined even if the
9015 implementation elided its use. But don't warn about deprecation when
9016 eliding a temporary, as then no copy is actually performed. */
9021 {
9025 }
9026 else
9029 /* If we're creating a temp and we already have one, don't create a
9030 new one. If we're not creating a temp but we get one, use
9031 INIT_EXPR to collapse the temp into our target. Otherwise, if the
9032 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
9033 temp or an INIT_EXPR otherwise. */
9035 {
9040 }
9043 {
9047 }
9048 }
9052 {
9060 {
9061 /* Avoid copying empty classes. */
9064 }
9066 {
9070 "assignment from temporary %<initializer_list%> does "
9074 }
9075 else
9076 {
9077 /* We must only copy the non-tail padding parts. */
9086 build_index_type
9095 }
9100 }
9102 {
9106 {
9109 no_cleanup_complain);
9110 else
9112 }
9113 }
9121 /* Warn if the built-in writes to an object of a non-trivial type. */
9128 {
9129 tree t;
9136 complain);
9142 }
9143 else
9144 {
9145 /* If FN is marked deprecated, then we've already issued a deprecated-use
9146 warning from mark_used above, so avoid redundantly issuing another one
9147 from build_addr_func. */
9153 }
9159 {
9161 /* build_new_op_1 will clear this when appropriate. */
9163 }
9165 {
9169 }
9171 {
9180 {
9185 {
9188 }
9189 /* Look through *(const T *)&obj. */
9191 {
9195 {
9200 }
9201 }
9203 }
9204 }
9206 }
9208 namespace
9209 {
9211 /* Return the DECL of the first non-static subobject of class TYPE
9212 that satisfies the predicate PRED or null if none can be found. */
9215 tree
9217 {
9222 {
9229 }
9235 {
9241 }
9244 }
9246 struct NonPublicField
9247 {
9249 {
9251 }
9252 };
9254 /* Return the DECL of the first non-public subobject of class TYPE
9255 or null if none can be found. */
9259 {
9261 }
9263 struct NonTrivialField
9264 {
9266 {
9268 }
9269 };
9271 /* Return the DECL of the first non-trivial subobject of class TYPE
9272 or null if none can be found. */
9276 {
9278 }
9282 /* Return true if all copy and move assignment operator overloads for
9283 class TYPE are trivial and at least one of them is not deleted and,
9284 when ACCESS is set, accessible. Return false otherwise. Set
9285 HASASSIGN to true when the TYPE has a (not necessarily trivial)
9286 copy or move assignment. */
9288 static bool
9290 {
9294 /* Iterate over overloads of the assignment operator, checking
9295 accessible copy assignments for triviality. */
9298 {
9301 /* Skip operators that aren't copy assignments. */
9308 /* Skip template assignment operators and deleted functions. */
9318 /* Break early when both properties have been determined. */
9321 }
9323 /* Return true if they're all trivial and one of the expressions
9324 TYPE() = TYPE() or TYPE() = (TYPE&)() is valid. */
9329 }
9331 /* Return true if all copy and move ctor overloads for class TYPE are
9332 trivial and at least one of them is not deleted and, when ACCESS is
9333 set, accessible. Return false otherwise. Set each element of HASCTOR[]
9334 to true when the TYPE has a (not necessarily trivial) default and copy
9335 (or move) ctor, respectively. */
9337 static bool
9339 {
9344 {
9347 /* Skip template constructors. */
9353 /* Skip ctors other than default, copy, and move. */
9369 /* Break early when both properties have been determined. */
9372 }
9375 }
9377 /* Issue a warning on a call to the built-in function FNDECL if it is
9378 a raw memory write whose destination is not an object of (something
9379 like) trivial or standard layout type with a non-deleted assignment
9380 and copy ctor. Detects const correctness violations, corrupting
9381 references, virtual table pointers, and bypassing non-trivial
9382 assignments. */
9384 static void
9387 {
9388 /* Except for bcopy where it's second, the destination pointer is
9389 the first argument for all functions handled here. Compute
9390 the index of the destination and source arguments. */
9402 /* Determine the type of the pointed-to object and whether it's
9403 a complete class type. */
9409 /* Check to see if the raw memory call is made by a non-static member
9410 function with THIS as the destination argument for the destination
9411 type. If so, and if the class has no non-trivial bases or members,
9412 be more permissive. */
9416 {
9425 }
9427 /* True if the class is trivial. */
9430 /* Set to true if DESTYPE has an accessible copy assignment. */
9432 /* True if all of the class' overloaded copy assignment operators
9433 are all trivial (and not deleted) and at least one of them is
9434 accessible. */
9437 /* Set to true if DESTTYPE has an accessible default and copy ctor,
9438 respectively. */
9441 /* True if all of the class' overloaded copy constructors are all
9442 trivial (and not deleted) and at least one of them is accessible. */
9445 /* Set FLD to the first private/protected member of the class. */
9448 /* The warning format string. */
9450 /* A suggested alternative to offer instead of the raw memory call.
9451 Empty string when none can be come up with. */
9456 {
9459 {
9460 /* Diagnose setting non-copy-assignable or non-trivial types,
9461 or types with a private member, to (potentially) non-zero
9462 bytes. Since the value of the bytes being written is unknown,
9463 suggest using assignment instead (if one exists). Also warn
9464 for writes into objects for which zero-initialization doesn't
9465 mean all bits clear (pointer-to-member data, where null is all
9466 bits set). Since the value being written is (most likely)
9467 non-zero, simply suggest assignment (but not copy assignment). */
9475 {
9478 "%qD writing to an object of type %#qT with "
9481 }
9487 }
9488 /* Fall through. */
9491 /* Similarly to the above, diagnose clearing non-trivial or non-
9492 standard layout objects, or objects of types with no assignmenmt.
9493 Since the value being written is known to be zero, suggest either
9494 copy assignment, copy ctor, or default ctor as an alternative,
9495 depending on what's available. */
9518 /* Determine the type of the source object. */
9522 else
9525 /* Since it's impossible to determine wheter the byte copy is
9526 being used in place of assignment to an existing object or
9527 as a substitute for initialization, assume it's the former.
9528 Determine the best alternative to use instead depending on
9529 what's not deleted. */
9550 srctype))
9551 {
9552 /* Warn when copying into a non-trivial object from an object
9553 of a different type other than void or char. */
9555 "%qD copying an object of non-trivial type "
9558 }
9563 srctype))
9564 {
9567 "%qD copying an object of type %#qT with "
9568 "%qs member %qD from an array of %#qT; use "
9571 }
9573 {
9578 /* Finally, warn on partial copies. */
9579 unsigned HOST_WIDE_INT typesize
9585 "a non-trivial type %#qT leaves %wu "
9588 "a non-trivial type %#qT leaves %wu "
9591 }
9606 {
9610 /* Finally, warn on reallocation into insufficient space. */
9612 "%qD moving an object of non-trivial type "
9615 sz);
9616 }
9621 }
9624 {
9628 else
9631 }
9635 }
9637 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
9638 If FN is the result of resolving an overloaded target built-in,
9639 ORIG_FNDECL is the original function decl, otherwise it is null.
9640 This function performs no overload resolution, conversion, or other
9641 high-level operations. */
9643 tree
9646 {
9647 tree fndecl;
9649 /* Remember roughly where this call is. */
9658 /* Check that arguments to builtin functions match the expectations. */
9660 && !processing_template_decl
9662 {
9665 /* We need to take care that values to BUILT_IN_NORMAL
9666 are reduced. */
9673 }
9678 /* 5.2.2/11: If a function call is a prvalue of object type: if the
9679 function call is either the operand of a decltype-specifier or the
9680 right operand of a comma operator that is the operand of a
9681 decltype-specifier, a temporary object is not introduced for the
9682 prvalue. The type of the prvalue may be incomplete. */
9684 {
9690 {
9693 }
9694 }
9696 }
9698 /* Returns the value to use for the in-charge parameter when making a
9699 call to a function with the indicated NAME.
9701 FIXME:Can't we find a neater way to do this mapping? */
9703 tree
9705 {
9707 {
9711 }
9712 else
9713 {
9719 }
9722 }
9724 /* We've built up a constructor call RET. Complain if it delegates to the
9725 constructor we're currently compiling. */
9727 static void
9729 {
9735 }
9737 /* Build a call to a constructor, destructor, or an assignment
9738 operator for INSTANCE, an expression with class type. NAME
9739 indicates the special member function to call; *ARGS are the
9740 arguments. ARGS may be NULL. This may change ARGS. BINFO
9741 indicates the base of INSTANCE that is to be passed as the `this'
9742 parameter to the member function called.
9744 FLAGS are the LOOKUP_* flags to use when processing the call.
9746 If NAME indicates a complete object constructor, INSTANCE may be
9747 NULL_TREE. In this case, the caller will call build_cplus_new to
9748 store the newly constructed object into a VAR_DECL. */
9750 tree
9753 {
9754 tree fns;
9755 /* The type of the subobject to be constructed or destroyed. */
9756 tree class_type;
9758 tree ret;
9766 {
9769 /* Shortcut to avoid lazy destructor declaration. */
9771 }
9774 {
9775 /* Resolve the name. */
9780 }
9786 /* Handle the special case where INSTANCE is NULL_TREE. */
9789 else
9790 {
9791 /* Convert to the base class, if necessary. */
9794 {
9796 /* For constructors and destructors, either the base is
9797 non-virtual, or it is virtual but we are doing the
9798 conversion from a constructor or destructor for the
9799 complete object. In either case, we can convert
9800 statically. */
9802 else
9803 {
9804 /* However, for assignment operators, we must convert
9805 dynamically if the base is virtual. */
9809 }
9810 }
9811 }
9815 /* In C++17, "If the initializer expression is a prvalue and the
9816 cv-unqualified version of the source type is the same class as the class
9817 of the destination, the initializer expression is used to initialize the
9818 destination object." Handle that here to avoid doing overload
9819 resolution. */
9823 {
9833 && (same_type_ignoring_top_level_qualifiers_p
9835 {
9844 /* Avoid change of behavior on Wunused-var-2.C. */
9847 }
9848 }
9852 /* When making a call to a constructor or destructor for a subobject
9853 that uses virtual base classes, pass down a pointer to a VTT for
9854 the subobject. */
9858 {
9859 tree vtt;
9860 tree sub_vtt;
9862 /* If the current function is a complete object constructor
9863 or destructor, then we fetch the VTT directly.
9864 Otherwise, we look it up using the VTT we were given. */
9872 else
9876 {
9879 }
9882 }
9887 complain);
9898 }
9900 /* Return the NAME, as a C string. The NAME indicates a function that
9901 is a member of TYPE. *FREE_P is set to true if the caller must
9902 free the memory returned.
9904 Rather than go through all of this, we should simply set the names
9905 of constructors and destructors appropriately, and dispense with
9906 ctor_identifier, dtor_identifier, etc. */
9910 {
9913 /* Assume that we will not allocate memory. */
9915 /* Constructors and destructors are special. */
9917 {
9918 pretty_name
9920 /* For a destructor, add the '~'. */
9922 {
9924 /* Remember that we need to free the memory allocated. */
9926 }
9927 }
9929 {
9932 TFF_PLAIN_IDENTIFIER),
9933 NULL);
9934 /* Remember that we need to free the memory allocated. */
9936 }
9937 else
9941 }
9943 /* If CANDIDATES contains exactly one candidate, return it, otherwise
9944 return NULL. */
9948 {
9956 }
9958 /* If CANDIDATE is invalid due to a bad argument type, return the
9959 pertinent conversion_info.
9961 Otherwise, return NULL. */
9965 {
9966 /* Must be an rr_arg_conversion or rr_bad_arg_conversion. */
9973 {
9982 }
9983 }
9985 /* Issue an error and note complaining about a bad argument type at a
9986 callsite with a single candidate FNDECL.
9988 ARG_LOC is the location of the argument (or UNKNOWN_LOCATION, in which
9989 case input_location is used).
9990 FROM_TYPE is the type of the actual argument; TO_TYPE is the type of
9991 the formal parameter. */
9993 void
9997 {
9998 auto_diagnostic_group d;
10002 {
10005 }
10011 parmnum);
10012 }
10014 /* Subroutine of build_new_method_call_1, for where there are no viable
10015 candidates for the call. */
10017 static void
10020 tree explicit_targs,
10021 tree basetype,
10025 {
10026 auto_diagnostic_group d;
10033 else
10034 {
10035 /* Special-case for when there's a single candidate that's failing
10036 due to a bad argument type. */
10040 {
10048 }
10054 {
10057 }
10065 }
10067 }
10069 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
10070 be set, upon return, to the function called. ARGS may be NULL.
10071 This may change ARGS. */
10073 static tree
10077 {
10081 tree access_binfo;
10082 tree optype;
10084 tree name;
10087 tree call;
10088 tree fn;
10091 tree orig_instance;
10092 tree orig_fns;
10098 /* We don't know what function we're going to call, yet. */
10107 {
10111 }
10116 /* Dismantle the baselink to collect all the information we need. */
10123 {
10127 }
10136 /* Under DR 147 A::A() is an invalid constructor call,
10137 not a functional cast. */
10139 {
10145 auto_diagnostic_group d;
10153 complain);
10155 }
10158 {
10163 }
10165 /* Process the argument list. */
10167 {
10172 }
10174 /* Consider the object argument to be used even if we end up selecting a
10175 static member function. */
10178 /* Figure out whether to skip the first argument for the error
10179 message we will display to users if an error occurs. We don't
10180 want to display any compiler-generated arguments. The "this"
10181 pointer hasn't been added yet. However, we must remove the VTT
10182 pointer if this is a call to a base-class constructor or
10183 destructor. */
10186 {
10187 /* Callers should explicitly indicate whether they want to ctor
10188 the complete object or just the part without virtual bases. */
10191 /* Remove the VTT pointer, if present. */
10196 /* It's OK to call destructors and constructors on cv-qualified
10197 objects. Therefore, convert the INSTANCE to the unqualified
10198 type, if necessary. */
10200 {
10204 }
10205 }
10206 else
10209 /* For the overload resolution we need to find the actual `this`
10210 that would be captured if the call turns out to be to a
10211 non-static member function. Do not actually capture it at this
10212 point. */
10214 /* Constructors don't use the enclosing 'this'. */
10216 else
10219 /* Get the high-water mark for the CONVERSION_OBSTACK. */
10222 /* The number of arguments artificial parms in ARGS; we subtract one because
10223 there's no 'this' in ARGS. */
10226 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
10227 initializer, not T({ }). */
10231 {
10238 /* If the initializer list has no elements and T is a class type with
10239 a default constructor, the object is value-initialized. Handle
10240 this here so we don't need to handle it wherever we use
10241 build_special_member_call. */
10244 /* For a user-provided default constructor, use the normal
10245 mechanisms so that protected access works. */
10250 /* If BASETYPE is an aggregate, we need to do aggregate
10251 initialization. */
10253 {
10256 }
10259 {
10265 }
10267 /* Otherwise go ahead with overload resolution. */
10272 }
10273 else
10282 {
10283 /* [dcl.init], 17.6.2.2:
10285 Otherwise, if no constructor is viable, the destination type is
10286 a (possibly cv-qualified) aggregate class A, and the initializer
10287 is a parenthesized expression-list, the object is initialized as
10288 follows...
10290 We achieve this by building up a CONSTRUCTOR, as for list-init,
10291 and setting CONSTRUCTOR_IS_PAREN_INIT to distinguish between
10292 the two. */
10298 {
10299 /* Create a CONSTRUCTOR from ARGS, e.g. {1, 2} from <1, 2>. */
10301 user_args);
10306 else
10307 {
10314 }
10315 }
10320 skip_first_for_error,
10321 user_args);
10323 }
10324 else
10325 {
10328 {
10331 tree arglist;
10334 {
10339 auto_diagnostic_group d;
10343 else
10349 }
10351 }
10352 else
10353 {
10361 {
10362 /* This is not an error, it is runtime undefined
10363 behavior. */
10372 fn);
10373 }
10378 {
10383 {
10384 /* We captured 'this' in the current lambda now that
10385 we know we really need it. */
10387 }
10389 /* We can't tell until instantiation time whether we can use
10391 else
10392 {
10395 fn);
10397 }
10398 }
10401 {
10402 /* Now we know what function is being called. */
10405 /* Build the actual CALL_EXPR. */
10407 /* In an expression of the form `a->f()' where `f' turns
10408 out to be a static member function, `a' is
10409 none-the-less evaluated. */
10413 {
10414 /* But avoid the implicit lvalue-rvalue conversion when 'a'
10415 is volatile. */
10420 }
10424 /* An explicit call of the form "x->~X()" has type
10425 "void". However, on platforms where destructors
10426 return "this" (i.e., those where
10427 targetm.cxx.cdtor_returns_this is true), such calls
10428 will appear to have a return value of pointer type
10429 to the low-level call machinery. We do not want to
10430 change the low-level machinery, since we want to be
10431 able to optimize "delete f()" on such platforms as
10432 "operator delete(~X(f()))" (rather than generating
10433 "t = f(), ~X(t), operator delete (t)"). */
10435 }
10436 }
10437 }
10440 {
10446 {
10449 }
10452 call = (build_min_non_dep_call_vec
10456 orig_args));
10461 }
10463 /* Free all the conversions we allocated. */
10470 }
10472 /* Wrapper for above. */
10474 tree
10478 {
10479 tree ret;
10485 }
10487 /* Returns true iff standard conversion sequence ICS1 is a proper
10488 subsequence of ICS2. */
10490 static bool
10492 {
10493 /* We can assume that a conversion of the same code
10494 between the same types indicates a subsequence since we only get
10495 here if the types we are converting from are the same. */
10502 {
10512 /* At this point, ICS1 cannot be a proper subsequence of
10513 ICS2. We can get a USER_CONV when we are comparing the
10514 second standard conversion sequence of two user conversion
10515 sequences. */
10530 }
10531 }
10533 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
10534 be any _TYPE nodes. */
10536 bool
10538 {
10542 /* We only allow proper derivation here. The DERIVED_FROM_P macro
10543 considers every class derived from itself. */
10546 }
10548 /* We build the ICS for an implicit object parameter as a pointer
10549 conversion sequence. However, such a sequence should be compared
10550 as if it were a reference conversion sequence. If ICS is the
10551 implicit conversion sequence for an implicit object parameter,
10552 modify it accordingly. */
10554 static void
10556 {
10558 {
10559 /* [over.match.funcs]
10561 For non-static member functions, the type of the
10562 implicit object parameter is "reference to cv X"
10563 where X is the class of which the function is a
10564 member and cv is the cv-qualification on the member
10565 function declaration. */
10567 tree reference_type;
10569 /* The `this' parameter is a pointer to a class type. Make the
10570 implicit conversion talk about a reference to that same class
10571 type. */
10584 }
10585 }
10587 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
10588 and return the initial reference binding conversion. Otherwise,
10589 leave *ICS unchanged and return NULL. */
10593 {
10595 {
10600 }
10603 }
10605 /* Get the expression at the beginning of the conversion chain C. */
10607 static tree
10609 {
10614 }
10616 /* Return a tree representing the number of elements initialized by the
10617 list-initialization C. The caller must check that C converts to an
10618 array type. */
10620 static tree
10622 {
10623 /* If the array we're converting to has a dimension, we'll use that. */
10626 else
10627 {
10628 /* Otherwise, we look at how many elements the constructor we're
10629 initializing from has. */
10632 }
10633 }
10635 /* True iff C is a conversion that binds a reference or a pointer to
10636 an array of unknown bound. */
10640 {
10641 /* ck_ref_bind won't have the reference stripped. */
10643 /* ck_qual won't have the pointer stripped. */
10647 }
10649 /* Compare two implicit conversion sequences according to the rules set out in
10650 [over.ics.rank]. Return values:
10652 1: ics1 is better than ics2
10653 -1: ics2 is better than ics1
10654 0: ics1 and ics2 are indistinguishable */
10656 static int
10658 {
10659 tree from_type1;
10660 tree from_type2;
10661 tree to_type1;
10662 tree to_type2;
10669 /* REF_BINDING is nonzero if the result of the conversion sequence
10670 is a reference type. In that case REF_CONV is the reference
10671 binding conversion. */
10675 /* Compare badness before stripping the reference conversion. */
10681 /* Handle implicit object parameters. */
10685 /* Handle reference parameters. */
10689 /* List-initialization sequence L1 is a better conversion sequence than
10690 list-initialization sequence L2 if L1 converts to
10691 std::initializer_list<X> for some X and L2 does not. */
10697 /* [over.ics.rank]
10699 When comparing the basic forms of implicit conversion sequences (as
10700 defined in _over.best.ics_)
10702 --a standard conversion sequence (_over.ics.scs_) is a better
10703 conversion sequence than a user-defined conversion sequence
10704 or an ellipsis conversion sequence, and
10706 --a user-defined conversion sequence (_over.ics.user_) is a
10707 better conversion sequence than an ellipsis conversion sequence
10708 (_over.ics.ellipsis_). */
10709 /* Use BAD_CONVERSION_RANK because we already checked for a badness
10710 mismatch. If both ICS are bad, we try to make a decision based on
10711 what would have happened if they'd been good. This is not an
10712 extension, we'll still give an error when we build up the call; this
10713 just helps us give a more helpful error message. */
10723 /* Both conversions are ellipsis conversions. */
10726 /* User-defined conversion sequence U1 is a better conversion sequence
10727 than another user-defined conversion sequence U2 if they contain the
10728 same user-defined conversion operator or constructor and if the sec-
10729 ond standard conversion sequence of U1 is better than the second
10730 standard conversion sequence of U2. */
10732 /* Handle list-conversion with the same code even though it isn't always
10733 ranked as a user-defined conversion and it doesn't have a second
10734 standard conversion sequence; it will still have the desired effect.
10735 Specifically, we need to do the reference binding comparison at the
10736 end of this function. */
10740 {
10747 {
10752 }
10753 /* List-initialization sequence L1 is a better conversion sequence than
10754 list-initialization sequence L2 if
10756 -- L1 and L2 convert to arrays of the same element type, and either
10757 the number of elements n1 initialized by L1 is less than the number
10758 of elements n2 initialized by L2, or n1=n2 and L2 converts to an array
10759 of unknown bound and L1 does not. (Added in CWG 1307 and extended by
10760 P0388R4.) */
10764 {
10765 /* The type of the array elements must be the same. */
10775 /* The n1 == n2 case. */
10782 else
10784 }
10785 else
10786 {
10787 /* For ambiguous or aggregate conversions, use the target type as
10788 a proxy for the conversion function. */
10791 }
10793 /* We can just fall through here, after setting up
10794 FROM_TYPE1 and FROM_TYPE2. */
10797 }
10798 else
10799 {
10803 /* We're dealing with two standard conversion sequences.
10805 [over.ics.rank]
10807 Standard conversion sequence S1 is a better conversion
10808 sequence than standard conversion sequence S2 if
10810 --S1 is a proper subsequence of S2 (comparing the conversion
10811 sequences in the canonical form defined by _over.ics.scs_,
10812 excluding any Lvalue Transformation; the identity
10813 conversion sequence is considered to be a subsequence of
10814 any non-identity conversion sequence */
10825 }
10827 /* One sequence can only be a subsequence of the other if they start with
10828 the same type. They can start with different types when comparing the
10829 second standard conversion sequence in two user-defined conversion
10830 sequences. */
10832 {
10837 }
10839 /* [over.ics.rank]
10841 Or, if not that,
10843 --the rank of S1 is better than the rank of S2 (by the rules
10844 defined below):
10846 Standard conversion sequences are ordered by their ranks: an Exact
10847 Match is a better conversion than a Promotion, which is a better
10848 conversion than a Conversion.
10850 Two conversion sequences with the same rank are indistinguishable
10851 unless one of the following rules applies:
10853 --A conversion that does not a convert a pointer, pointer to member,
10854 or std::nullptr_t to bool is better than one that does.
10856 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
10857 so that we do not have to check it explicitly. */
10866 /* A conversion from scalar arithmetic type to complex is worse than a
10867 conversion between scalar arithmetic types. */
10874 {
10877 else
10879 }
10885 {
10890 }
10891 /* The rules for pointers to members A::* are just like the rules
10892 for pointers A*, except opposite: if B is derived from A then
10893 A::* converts to B::*, not vice versa. For that reason, we
10894 switch the from_ and to_ variables here. */
10901 {
10906 }
10911 {
10912 /* This was one of the pointer or pointer-like conversions.
10914 [over.ics.rank]
10916 --If class B is derived directly or indirectly from class A,
10917 conversion of B* to A* is better than conversion of B* to
10918 void*, and conversion of A* to void* is better than
10919 conversion of B* to void*. */
10922 {
10924 deref_from_type2))
10927 deref_from_type1))
10929 }
10932 {
10934 {
10936 {
10938 deref_to_type1))
10940 }
10941 /* We know that DEREF_TO_TYPE1 is `void' here. */
10943 deref_to_type2))
10945 }
10946 }
10949 {
10950 /* [over.ics.rank]
10952 --If class B is derived directly or indirectly from class A
10953 and class C is derived directly or indirectly from B,
10955 --conversion of C* to B* is better than conversion of C* to
10956 A*,
10958 --conversion of B* to A* is better than conversion of C* to
10959 A* */
10961 {
10963 deref_to_type2))
10966 deref_to_type1))
10968 }
10970 {
10972 deref_from_type1))
10975 deref_from_type2))
10977 }
10978 }
10979 }
10982 {
10985 /* [over.ics.rank]
10987 --binding of an expression of type C to a reference of type
10988 B& is better than binding an expression of type C to a
10989 reference of type A&
10991 --conversion of C to B is better than conversion of C to A, */
10994 {
10999 }
11000 }
11003 {
11006 /* [over.ics.rank]
11008 --binding of an expression of type B to a reference of type
11009 A& is better than binding an expression of type C to a
11010 reference of type A&,
11012 --conversion of B to A is better than conversion of C to A */
11015 {
11020 }
11021 }
11023 /* [over.ics.rank]
11025 --S1 and S2 differ only in their qualification conversion and yield
11026 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
11027 qualification signature of type T1 is a proper subset of the cv-
11028 qualification signature of type T2 */
11032 {
11036 }
11038 /* [over.ics.rank]
11040 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
11041 to an implicit object parameter of a non-static member function
11042 declared without a ref-qualifier, and either S1 binds an lvalue
11043 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
11044 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
11045 draft standard, 13.3.3.2)
11047 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
11048 types to which the references refer are the same type except for
11049 top-level cv-qualifiers, and the type to which the reference
11050 initialized by S2 refers is more cv-qualified than the type to
11051 which the reference initialized by S1 refers.
11053 DR 1328 [over.match.best]: the context is an initialization by
11054 conversion function for direct reference binding (13.3.1.6) of a
11055 reference to function type, the return type of F1 is the same kind of
11056 reference (i.e. lvalue or rvalue) as the reference being initialized,
11057 and the return type of F2 is not. */
11060 {
11067 {
11071 /* Don't prefer a bad conversion that drops cv-quals to a bad
11072 conversion with the wrong rvalueness. */
11076 }
11079 {
11080 /* Per P0388R4:
11082 void f (int(&)[]), // (1)
11083 f (int(&)[1]), // (2)
11084 f (int*); // (3)
11086 (2) is better than (1), but (3) should be equal to (1) and to
11087 (2). For that reason we don't use ck_qual for (1) which would
11088 give it the cr_exact rank while (3) remains ck_identity.
11089 Therefore we compare (1) and (2) here. For (1) we'll have
11091 ck_ref_bind <- ck_identity
11092 int[] & int[1]
11094 so to handle this we must look at ref_conv. */
11105 {
11106 /* Prefer the one that drops fewer cv-quals. */
11111 }
11113 }
11114 }
11116 /* [over.ics.rank]
11118 Per CWG 1601:
11119 -- A conversion that promotes an enumeration whose underlying type
11120 is fixed to its underlying type is better than one that promotes to
11121 the promoted underlying type, if the two are different. */
11127 {
11131 {
11138 }
11139 }
11141 /* Neither conversion sequence is better than the other. */
11143 }
11145 /* The source type for this standard conversion sequence. */
11147 static tree
11149 {
11151 }
11153 /* Note a warning about preferring WINNER to LOSER. We do this by storing
11154 a pointer to LOSER and re-running joust to produce the warning if WINNER
11155 is actually used. */
11157 static void
11159 {
11165 }
11167 /* CAND is a constructor candidate in joust in C++17 and up. If it copies a
11168 prvalue returned from a conversion function, replace CAND with the candidate
11169 for the conversion and return true. Otherwise, return false. */
11171 static bool
11173 {
11181 {
11186 {
11189 }
11190 }
11192 }
11194 /* True if the defining declarations of the two candidates have equivalent
11195 parameters. */
11197 bool
11199 {
11206 /* We don't look at c1->template_decl because that's only set for primary
11207 templates, not e.g. non-template member functions of class templates. */
11211 {
11218 }
11221 }
11223 /* Compare two candidates for overloading as described in
11224 [over.match.best]. Return values:
11226 1: cand1 is better than cand2
11227 -1: cand2 is better than cand1
11228 0: cand1 and cand2 are indistinguishable */
11230 static int
11232 tsubst_flags_t complain)
11233 {
11239 /* Candidates that involve bad conversions are always worse than those
11240 that don't. */
11246 /* If we have two pseudo-candidates for conversions to the same type,
11247 or two candidates for the same function, arbitrarily pick one. */
11253 /* Prefer a non-deleted function over an implicitly deleted move
11254 constructor or assignment operator. This differs slightly from the
11255 wording for issue 1402 (which says the move op is ignored by overload
11256 resolution), but this way produces better error messages. */
11260 {
11267 }
11269 /* a viable function F1
11270 is defined to be a better function than another viable function F2 if
11271 for all arguments i, ICSi(F1) is not a worse conversion sequence than
11272 ICSi(F2), and then */
11274 /* for some argument j, ICSj(F1) is a better conversion sequence than
11275 ICSj(F2) */
11277 /* For comparing static and non-static member functions, we ignore
11278 the implicit object parameter of the non-static function. The
11279 standard says to pretend that the static function has an object
11280 parm, but that won't work with operator overloading. */
11283 {
11289 /* We're comparing a near-match list constructor and a near-match
11290 non-list constructor. Just treat them as unordered. */
11297 else
11298 {
11301 }
11302 }
11304 /* Handle C++17 copy elision in [over.match.ctor] (direct-init) context. The
11305 standard currently says that only constructors are candidates, but if one
11306 copies a prvalue returned by a conversion function we want to treat the
11307 conversion as the candidate instead.
11309 Clang does something similar, as discussed at
11310 http://lists.isocpp.org/core/2017/10/3166.php
11311 http://lists.isocpp.org/core/2019/03/5721.php */
11317 {
11320 /* As a tiebreaker below we will prefer a constructor to a conversion
11321 operator exposed this way. */
11323 }
11326 {
11332 {
11334 && warn_sign_promo
11346 {
11353 else
11358 {
11362 }
11363 else
11365 }
11368 {
11369 /* Ambiguity between normal and reversed comparison operators
11370 with the same parameter types; prefer the normal one. */
11377 }
11379 }
11380 }
11382 /* warn about confusing overload resolution for user-defined conversions,
11383 either between a constructor and a conversion op, or between two
11384 conversion ops. */
11386 /* In C++17, the constructor might have been elided, which means that
11387 an originally null ->second_conv could become non-null. */
11391 {
11397 else
11400 /* We don't want to complain about `X::operator T1 ()'
11401 beating `X::operator T2 () const', when T2 is a no less
11402 cv-qualified version of T1. */
11405 {
11410 {
11413 }
11416 }
11417 else
11423 {
11427 auto_diagnostic_group d;
11431 {
11434 }
11435 }
11436 else
11438 }
11443 /* Put this tiebreaker first, so that we don't try to look at second_conv of
11444 a constructor candidate that doesn't have one. */
11448 /* DR 495 moved this tiebreaker above the template ones. */
11449 /* or, if not that,
11450 the context is an initialization by user-defined conversion (see
11451 _dcl.init_ and _over.match.user_) and the standard conversion
11452 sequence from the return type of F1 to the destination type (i.e.,
11453 the type of the entity being initialized) is a better conversion
11454 sequence than the standard conversion sequence from the return type
11455 of F2 to the destination type. */
11458 {
11462 }
11464 /* or, if not that,
11465 F1 is a non-template function and F2 is a template function
11466 specialization. */
11473 /* or, if not that,
11474 F1 and F2 are template functions and the function template for F1 is
11475 more specialized than the template for F2 according to the partial
11476 ordering rules. */
11479 {
11480 winner = more_specialized_fn
11483 /* [temp.func.order]: The presence of unused ellipsis and default
11484 arguments has no effect on the partial ordering of function
11485 templates. add_function_candidate() will not have
11486 counted the "this" argument for constructors. */
11490 }
11492 /* Concepts: F1 and F2 are non-template functions with the same
11493 parameter-type-lists, and F1 is more constrained than F2 according to the
11494 partial ordering of constraints described in 13.5.4. */
11499 {
11503 }
11505 /* F2 is a rewritten candidate (12.4.1.2) and F1 is not, or F1 and F2 are
11506 rewritten candidates, and F2 is a synthesized candidate with reversed
11507 order of parameters and F1 is not. */
11509 {
11516 }
11520 /* F1 is generated from a deduction-guide (13.3.1.8) and F2 is not */
11522 {
11524 /* We distinguish between candidates from an explicit deduction guide and
11525 candidates built from a constructor based on DECL_ARTIFICIAL. */
11532 {
11533 /* Prefer the special copy guide over a declared copy/move
11534 constructor. */
11540 /* Prefer a candidate generated from a non-template constructor. */
11545 }
11546 }
11548 /* F1 is a member of a class D, F2 is a member of a base class B of D, and
11549 for all arguments the corresponding parameters of F1 and F2 have the same
11550 type (CWG 2273/2277). */
11555 {
11569 {
11571 {
11576 }
11579 }
11580 }
11582 /* Check whether we can discard a builtin candidate, either because we
11583 have two identical ones or matching builtin and non-builtin candidates.
11585 (Pedantically in the latter case the builtin which matched the user
11586 function should not be added to the overload set, but we spot it here.
11588 [over.match.oper]
11589 ... the builtin candidates include ...
11590 - do not have the same parameter type list as any non-template
11591 non-member candidate. */
11594 {
11600 {
11602 /* Two built-in candidates; arbitrarily pick one. */
11605 /* cand1 is built-in; prefer cand2. */
11607 else
11608 /* cand2 is built-in; prefer cand1. */
11610 }
11611 }
11613 /* For candidates of a multi-versioned function, make the version with
11614 the highest priority win. This version will be checked for dispatching
11615 first. If this version can be inlined into the caller, the front-end
11616 will simply make a direct call to this function. */
11622 {
11628 /* Check if cand1->fn and cand2->fn are versions of the same function. It
11629 is possible that cand1->fn and cand2->fn are function versions but of
11630 different functions. Check types to see if they are versions of the same
11631 function. */
11634 {
11635 /* Always make the version with the higher priority, more
11636 specialized, win. */
11640 else
11642 }
11643 }
11645 /* If the two function declarations represent the same function (this can
11646 happen with declarations in multiple scopes and arg-dependent lookup),
11647 arbitrarily choose one. But first make sure the default args we're
11648 using match. */
11651 {
11658 {
11659 /* Don't crash if the fn is variadic. */
11664 }
11672 {
11675 {
11677 {
11679 {
11680 auto_diagnostic_group d;
11682 "default argument mismatch in "
11684 {
11689 }
11690 }
11691 else
11693 }
11694 else
11697 }
11700 }
11703 }
11705 tweak:
11707 /* Extension: If the worst conversion for one candidate is better than the
11708 worst conversion for the other, take the first. */
11710 {
11715 {
11720 }
11726 {
11727 /* Don't choose a deleted function over ambiguity. */
11731 {
11732 auto_diagnostic_group d;
11734 "ISO C++ says that these are ambiguous, even "
11735 "though the worst conversion for the first is "
11737 {
11740 }
11741 }
11742 else
11745 }
11746 }
11750 }
11752 /* Given a list of candidates for overloading, find the best one, if any.
11753 This algorithm has a worst case of O(2n) (winner is last), and a best
11754 case of O(n/2) (totally ambiguous); much better than a sorting
11755 algorithm. */
11759 {
11764 /* Walk through the list once, comparing each current champ to the next
11765 candidate, knocking out a candidate or two with each comparison. */
11768 {
11772 else
11773 {
11775 {
11780 }
11781 else
11782 {
11785 }
11788 }
11789 }
11791 /* Make sure the champ is better than all the candidates it hasn't yet
11792 been compared to. */
11795 challenger != champ
11798 {
11802 }
11805 }
11807 /* Returns nonzero if things of type FROM can be converted to TO. */
11809 bool
11811 {
11813 /* implicit_conversion only considers user-defined conversions
11814 if it has an expression for the call argument list. */
11818 }
11820 /* Returns nonzero if things of type FROM can be converted to TO with a
11821 standard conversion. */
11823 bool
11825 {
11827 }
11829 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
11831 bool
11833 tsubst_flags_t complain)
11834 {
11839 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11841 /* We want to discard any access checks done for this test,
11842 as we might not be in the appropriate access context and
11843 we'll do the check again when we actually perform the
11844 conversion. */
11851 /* Discard the access checks now. */
11853 /* Free all the conversions we allocated. */
11857 }
11859 /* Like can_convert_arg, but allows dubious conversions as well. */
11861 bool
11863 tsubst_flags_t complain)
11864 {
11868 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11870 /* Try to perform the conversion. */
11873 /* Free all the conversions we allocated. */
11877 }
11879 /* Convert EXPR to TYPE. Return the converted expression.
11881 Note that we allow bad conversions here because by the time we get to
11882 this point we are committed to doing the conversion. If we end up
11883 doing a bad conversion, convert_like will complain. */
11885 tree
11888 {
11895 else
11901 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11909 {
11913 }
11915 {
11916 /* In a template, we are only concerned about determining the
11917 type of non-dependent expressions, so we do not have to
11918 perform the actual conversion. But for initializers, we
11919 need to be able to perform it at instantiation
11920 (or instantiate_non_dependent_expr) time. */
11926 }
11927 else
11930 /* Free all the conversions we allocated. */
11934 }
11936 tree
11938 {
11940 LOOKUP_IMPLICIT);
11941 }
11943 /* Convert EXPR to TYPE (as a direct-initialization) if that is
11944 permitted. If the conversion is valid, the converted expression is
11945 returned. Otherwise, NULL_TREE is returned, except in the case
11946 that TYPE is a class type; in that case, an error is issued. If
11947 C_CAST_P is true, then this direct-initialization is taking
11948 place as part of a static_cast being attempted as part of a C-style
11949 cast. */
11951 tree
11953 tree expr,
11955 tsubst_flags_t complain)
11956 {
11962 /* [dcl.init]
11964 If the destination type is a (possibly cv-qualified) class type:
11966 -- If the initialization is direct-initialization ...,
11967 constructors are considered.
11969 -- If overload resolution is successful, the selected constructor
11970 is called to initialize the object, with the initializer expression
11971 or expression-list as its argument(s).
11973 -- Otherwise, if no constructor is viable, the destination type is
11974 a (possibly cv-qualified) aggregate class A, and the initializer is
11975 a parenthesized expression-list, the object is initialized as
11976 follows... */
11978 {
11983 }
11985 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11989 c_cast_p,
11994 {
11995 /* In a template, we are only concerned about determining the
11996 type of non-dependent expressions, so we do not have to
11997 perform the actual conversion. But for initializers, we
11998 need to be able to perform it at instantiation
11999 (or instantiate_non_dependent_expr) time. */
12002 }
12003 else
12008 /* Free all the conversions we allocated. */
12012 }
12014 /* When initializing a reference that lasts longer than a full-expression,
12015 this special rule applies:
12017 [class.temporary]
12019 The temporary to which the reference is bound or the temporary
12020 that is the complete object to which the reference is bound
12021 persists for the lifetime of the reference.
12023 The temporaries created during the evaluation of the expression
12024 initializing the reference, except the temporary to which the
12025 reference is bound, are destroyed at the end of the
12026 full-expression in which they are created.
12028 In that case, we store the converted expression into a new
12029 VAR_DECL in a new scope.
12031 However, we want to be careful not to create temporaries when
12032 they are not required. For example, given:
12034 struct B {};
12035 struct D : public B {};
12036 D f();
12037 const B& b = f();
12039 there is no need to copy the return value from "f"; we can just
12040 extend its lifetime. Similarly, given:
12042 struct S {};
12043 struct T { operator S(); };
12044 T t;
12045 const S& s = t;
12047 we can extend the lifetime of the return value of the conversion
12048 operator.
12050 The next several functions are involved in this lifetime extension. */
12052 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
12053 reference is being bound to a temporary. Create and return a new
12054 VAR_DECL with the indicated TYPE; this variable will store the value to
12055 which the reference is bound. */
12057 tree
12059 {
12062 /* Register the variable. */
12065 {
12066 /* Namespace-scope or local static; give it a mangled name. */
12068 /* If an initializer is visible to multiple translation units, those
12069 translation units must agree on the addresses of the
12070 temporaries. Therefore the temporaries must be given a consistent name
12071 and vague linkage. The mangled name of a temporary is the name of the
12072 non-temporary object in whose initializer they appear, prefixed with
12073 GR and suffixed with a sequence number mangled using the usual rules
12074 for a seq-id. Temporaries are numbered with a pre-order, depth-first,
12075 left-to-right walk of the complete initializer. */
12081 }
12082 else
12083 /* Create a new cleanup level if necessary. */
12087 }
12089 /* EXPR is the initializer for a variable DECL of reference or
12090 std::initializer_list type. Create, push and return a new VAR_DECL
12091 for the initializer so that it will live as long as DECL. Any
12092 cleanup for the new variable is returned through CLEANUP, and the
12093 code to initialize the new variable is returned through INITP. */
12095 static tree
12098 {
12099 tree init;
12100 tree type;
12101 tree var;
12103 /* Create the temporary variable. */
12107 /* If the rvalue is the result of a function call it will be
12108 a TARGET_EXPR. If it is some other construct (such as a
12109 member access expression where the underlying object is
12110 itself the result of a function call), turn it into a
12111 TARGET_EXPR here. It is important that EXPR be a
12112 TARGET_EXPR below since otherwise the INIT_EXPR will
12113 attempt to make a bitwise copy of EXPR to initialize
12114 VAR. */
12120 {
12124 }
12126 /* Recursively extend temps in this initializer. */
12129 cond_guard);
12131 /* Any reference temp has a non-trivial initializer. */
12134 /* If the initializer is constant, put it in DECL_INITIAL so we get
12135 static initialization and use in constant expressions. */
12137 /* As in store_init_value. */
12140 {
12142 {
12143 /* 5.19 says that a constant expression can include an
12144 lvalue-rvalue conversion applied to "a glvalue of literal type
12145 that refers to a non-volatile temporary object initialized
12146 with a constant expression". Rather than try to communicate
12147 that this VAR_DECL is a temporary, just mark it constexpr. */
12152 }
12155 }
12156 else
12157 /* Create the INIT_EXPR that will initialize the temporary
12158 variable. */
12161 {
12166 else
12167 {
12170 {
12172 {
12174 {
12179 boolean_false_node,
12180 tf_warning_or_error);
12182 }
12185 }
12187 }
12188 }
12190 /* We must be careful to destroy the temporary only
12191 after its initialization has taken place. If the
12192 initialization throws an exception, then the
12193 destructor should not be run. We cannot simply
12194 transform INIT into something like:
12196 (INIT, ({ CLEANUP_STMT; }))
12198 because emit_local_var always treats the
12199 initializer as a full-expression. Thus, the
12200 destructor would run too early; it would run at the
12201 end of initializing the reference variable, rather
12202 than at the end of the block enclosing the
12203 reference variable.
12205 The solution is to pass back a cleanup expression
12206 which the caller is responsible for attaching to
12207 the statement tree. */
12208 }
12209 else
12210 {
12213 {
12216 tls_aggregates);
12217 else
12219 static_aggregates);
12220 }
12221 else
12222 /* Check whether the dtor is callable. */
12224 }
12225 /* Avoid -Wunused-variable warning (c++/38958). */
12232 }
12234 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
12235 initializing a variable of that TYPE. */
12237 tree
12240 {
12248 /* Get the high-water mark for the CONVERSION_OBSTACK. */
12253 /* If this conversion failed, we're in C++20, and we have something like
12254 A& a(b) where A is an aggregate, try again, this time as A& a{b}. */
12257 {
12263 /* If this worked, use it. */
12266 }
12268 {
12270 {
12279 else
12283 }
12285 }
12288 /* Perform the conversion. */
12291 /* We gave an error in build_user_type_conversion_1. */
12293 else
12296 /* Free all the conversions we allocated. */
12300 }
12302 /* If *P is an xvalue expression, prevent temporary lifetime extension if it
12303 gets used to initialize a reference. */
12305 static tree
12307 {
12313 /* Change a TARGET_EXPR from prvalue to xvalue. */
12318 }
12320 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
12321 which is bound either to a reference or a std::initializer_list. */
12323 static tree
12326 {
12331 {
12334 cond_guard);
12336 }
12338 {
12345 {
12348 tf_warning_or_error);
12351 tf_warning_or_error);
12352 }
12359 {
12362 tf_warning_or_error);
12365 tf_warning_or_error);
12366 }
12368 }
12371 /* Deal with binding to a subobject. */
12376 {
12384 }
12386 }
12388 /* INIT is part of the initializer for DECL. If there are any
12389 reference or initializer lists being initialized, extend their
12390 lifetime to match that of DECL. */
12392 tree
12395 {
12401 else
12402 {
12407 {
12408 /* [dcl.init] When initializing an aggregate from a parenthesized list
12409 of values... a temporary object bound to a reference does not have
12410 its lifetime extended. */
12415 {
12416 /* The temporary array underlying a std::initializer_list
12417 is handled like a reference temporary. */
12420 cond_guard);
12422 }
12423 else
12424 {
12430 cond_guard);
12431 }
12435 }
12436 }
12439 }
12441 /* Returns true iff an initializer for TYPE could contain temporaries that
12442 need to be extended because they are bound to references or
12443 std::initializer_list. */
12445 bool
12447 {
12452 {
12459 }
12461 }
12463 /* Returns true iff TYPE is some variant of std::initializer_list. */
12465 bool
12467 {
12472 /* Look through typedefs. */
12477 }
12479 /* Returns true iff DECL is a list constructor: i.e. a constructor which
12480 will accept an argument list of a single std::initializer_list<T>. */
12482 bool
12484 {
12486 tree arg;
12498 /* There are more non-defaulted parms. */
12502 }