| blob | ad39637c8b7a4b1b1b377b95a00831c43e6d58aa |
1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010, 2011, 2012
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com) and
7 modified by Brendan Kehoe (brendan@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
14 any later version.
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
26 /* High-level class interface. */
45 /* The various kinds of conversion. */
48 ck_identity,
49 ck_lvalue,
50 ck_qual,
51 ck_std,
52 ck_ptr,
53 ck_pmem,
54 ck_base,
55 ck_ref_bind,
56 ck_user,
57 ck_ambig,
58 ck_list,
59 ck_aggr,
60 ck_rvalue
63 /* The rank of the conversion. Order of the enumerals matters; better
64 conversions should come earlier in the list. */
67 cr_identity,
68 cr_exact,
69 cr_promotion,
70 cr_std,
71 cr_pbool,
72 cr_user,
73 cr_ellipsis,
74 cr_bad
77 /* An implicit conversion sequence, in the sense of [over.best.ics].
78 The first conversion to be performed is at the end of the chain.
79 That conversion is always a cr_identity conversion. */
83 /* The kind of conversion represented by this step. */
84 conversion_kind kind;
85 /* The rank of this conversion. */
86 conversion_rank rank;
90 /* True if this conversion would be permitted with a bending of
91 language standards, e.g. disregarding pointer qualifiers or
92 converting integers to pointers. */
94 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
95 temporary should be created to hold the result of the
96 conversion. */
98 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
99 from a pointer-to-derived to pointer-to-base is being performed. */
101 /* If KIND is ck_ref_bind, true when either an lvalue reference is
102 being bound to an lvalue expression or an rvalue reference is
103 being bound to an rvalue expression. If KIND is ck_rvalue,
104 true when we should treat an lvalue as an rvalue (12.8p33). If
105 KIND is ck_base, always false. */
108 /* The type of the expression resulting from the conversion. */
109 tree type;
111 /* The next conversion in the chain. Since the conversions are
112 arranged from outermost to innermost, the NEXT conversion will
113 actually be performed before this conversion. This variant is
114 used only when KIND is neither ck_identity, ck_ambig nor
115 ck_list. Please use the next_conversion function instead
116 of using this field directly. */
118 /* The expression at the beginning of the conversion chain. This
119 variant is used only if KIND is ck_identity or ck_ambig. */
120 tree expr;
121 /* The array of conversions for an initializer_list, so this
122 variant is used only when KIN D is ck_list. */
125 /* The function candidate corresponding to this conversion
126 sequence. This field is only used if KIND is ck_user. */
128 };
130 #define CONVERSION_RANK(NODE) \
131 ((NODE)->bad_p ? cr_bad \
132 : (NODE)->ellipsis_p ? cr_ellipsis \
133 : (NODE)->user_conv_p ? cr_user \
134 : (NODE)->rank)
136 #define BAD_CONVERSION_RANK(NODE) \
137 ((NODE)->ellipsis_p ? cr_ellipsis \
138 : (NODE)->user_conv_p ? cr_user \
139 : (NODE)->rank)
148 tsubst_flags_t);
152 #define convert_like(CONV, EXPR, COMPLAIN) \
153 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
156 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
157 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
165 tsubst_flags_t);
180 static void add_builtin_candidates
183 static void add_builtin_candidate
187 static void build_builtin_candidate
197 tsubst_flags_t);
200 tsubst_flags_t);
220 tsubst_flags_t);
225 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
226 NAME can take many forms... */
228 bool
230 {
231 /* Just accept something we've already complained about. */
240 {
246 else
248 }
249 else
250 {
251 /* In the case of:
253 template <class T> struct S { ~S(); };
254 int i;
255 i.~S();
257 NAME will be a class template. */
260 }
265 }
267 /* We want the address of a function or method. We avoid creating a
268 pointer-to-member function. */
270 tree
272 {
275 /* We have to do these by hand to avoid real pointer to member
276 functions. */
278 {
280 {
284 complain);
285 }
287 }
288 else
292 }
294 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
295 POINTER_TYPE to those. Note, pointer to member function types
296 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
297 two variants. build_call_a is the primitive taking an array of
298 arguments, while build_call_n is a wrapper that handles varargs. */
300 tree
302 {
305 else
306 {
316 }
317 }
319 /* Update various flags in cfun and the call itself based on what is being
320 called. Split out of build_call_a so that bot_manip can use it too. */
322 void
324 {
328 /* We check both the decl and the type; a function may be known not to
329 throw without being declared throw(). */
340 }
342 tree
344 {
345 tree decl;
346 tree result_type;
347 tree fntype;
357 /* An rvalue has no cv-qualifiers. */
368 {
369 /* We invoke build_call directly for several library
370 functions. These may have been declared normally if
371 we're building libgcc, so we can't just check
372 DECL_ARTIFICIAL. */
377 }
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 {
398 }
399 }
402 }
404 /* Build something of the form ptr->method (args)
405 or object.method (args). This can also build
406 calls to constructors, and find friends.
408 Member functions always take their class variable
409 as a pointer.
411 INSTANCE is a class instance.
413 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
415 PARMS help to figure out what that NAME really refers to.
417 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
418 down to the real instance type to use for access checking. We need this
419 information to get protected accesses correct.
421 FLAGS is the logical disjunction of zero or more LOOKUP_
422 flags. See cp-tree.h for more info.
424 If this is all OK, calls build_function_call with the resolved
425 member function.
427 This function must also handle being called to perform
428 initialization, promotion/coercion of arguments, and
429 instantiation of default parameters.
431 Note that NAME may refer to an instance variable name. If
432 `operator()()' is defined for the type of that field, then we return
433 that result. */
435 /* New overloading code. */
443 };
445 /* Information for providing diagnostics about why overloading failed. */
448 rr_none,
449 rr_arity,
450 rr_explicit_conversion,
451 rr_template_conversion,
452 rr_arg_conversion,
453 rr_bad_arg_conversion,
454 rr_template_unification,
455 rr_invalid_copy
456 };
459 /* The index of the argument, 0-based. */
461 /* The type of the actual argument. */
462 tree from_type;
463 /* The type of the formal argument. */
464 tree to_type;
465 };
470 /* Information about an arity mismatch. */
472 /* The expected number of arguments. */
474 /* The actual number of arguments in the call. */
476 /* Whether the call was a varargs call. */
479 /* Information about an argument conversion mismatch. */
481 /* Same, but for bad argument conversions. */
483 /* Information about template unification failures. These are the
484 parameters passed to fn_type_unification. */
486 tree tmpl;
487 tree explicit_targs;
491 tree return_type;
492 unification_kind_t strict;
495 /* Information about template instantiation failures. These are the
496 parameters passed to instantiate_template. */
498 tree tmpl;
499 tree targs;
502 };
505 /* The FUNCTION_DECL that will be called if this candidate is
506 selected by overload resolution. */
507 tree fn;
508 /* If not NULL_TREE, the first argument to use when calling this
509 function. */
510 tree first_arg;
511 /* The rest of the arguments to use when calling this function. If
512 there are no further arguments this may be NULL or it may be an
513 empty vector. */
515 /* The implicit conversion sequences for each of the arguments to
516 FN. */
518 /* The number of implicit conversion sequences. */
520 /* If FN is a user-defined conversion, the standard conversion
521 sequence from the type returned by FN to the desired destination
522 type. */
526 /* If FN is a member function, the binfo indicating the path used to
527 qualify the name of FN at the call site. This path is used to
528 determine whether or not FN is accessible if it is selected by
529 overload resolution. The DECL_CONTEXT of FN will always be a
530 (possibly improper) base of this binfo. */
531 tree access_path;
532 /* If FN is a non-static member function, the binfo indicating the
533 subobject to which the `this' pointer should be converted if FN
534 is selected by overload resolution. The type pointed to by
535 the `this' pointer must correspond to the most derived class
536 indicated by the CONVERSION_PATH. */
537 tree conversion_path;
538 tree template_decl;
539 tree explicit_targs;
542 };
544 /* Returns true iff T is a null pointer constant in the sense of
545 [conv.ptr]. */
547 bool
549 {
550 /* [conv.ptr]
552 A null pointer constant is an integral constant expression
553 (_expr.const_) rvalue of integer type that evaluates to zero or
554 an rvalue of type std::nullptr_t. */
558 {
559 /* Core issue 903 says only literal 0 is a null pointer constant. */
565 }
567 }
569 /* Returns true iff T is a null member pointer value (4.11). */
571 bool
573 {
582 else
584 }
586 /* Returns nonzero if PARMLIST consists of only default parms,
587 ellipsis, and/or undeduced parameter packs. */
589 bool
591 {
598 }
600 /* Allocate N bytes of memory from the conversion obstack. The memory
601 is zeroed before being returned. */
605 {
608 {
611 }
615 }
617 /* Allocate rejection reasons. */
621 {
626 }
630 {
636 }
640 {
647 }
651 {
658 }
662 {
668 }
672 {
678 }
685 {
692 /* Copy args to our own storage. */
700 }
704 {
706 }
710 {
713 }
715 /* Dynamically allocate a conversion. */
719 {
724 }
726 #ifdef ENABLE_CHECKING
728 /* Make sure that all memory on the conversion obstack has been
729 freed. */
731 void
733 {
737 }
741 /* Dynamically allocate an array of N conversions. */
745 {
747 }
751 {
755 /* Note that the caller is responsible for filling in t->cand for
756 user-defined conversions. */
762 {
778 }
784 }
786 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
787 specialization of std::initializer_list<T>, if such a conversion is
788 possible. */
792 {
798 tree val;
800 /* Within a list-initialization we can have more user-defined
801 conversions. */
803 /* But no narrowing conversions. */
807 {
808 conversion *sub
815 }
823 {
831 }
834 }
836 /* Return the next conversion of the conversion chain (if applicable),
837 or NULL otherwise. Please use this function instead of directly
838 accessing fields of struct conversion. */
842 {
849 }
851 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
852 is a valid aggregate initializer for array type ATYPE. */
854 static bool
856 {
860 {
866 else
868 complain);
871 }
873 }
875 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
876 aggregate class, if such a conversion is possible. */
880 {
891 {
893 tree val;
898 else
899 {
903 }
909 else
911 complain);
918 }
929 }
931 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
932 array type, if such a conversion is possible. */
936 {
941 tree val;
947 {
951 }
954 {
955 conversion *sub
967 }
976 }
978 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
979 complex type, if such a conversion is possible. */
983 tsubst_flags_t complain)
984 {
989 tree val;
998 {
999 conversion *sub
1011 }
1020 }
1022 /* Build a representation of the identity conversion from EXPR to
1023 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1027 {
1035 }
1037 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1038 were multiple user-defined conversions to accomplish the job.
1039 Build a conversion that indicates that ambiguity. */
1043 {
1051 }
1053 tree
1055 {
1059 }
1061 /* Returns the standard conversion path (see [conv]) from type FROM to type
1062 TO, if any. For proper handling of null pointer constants, you must
1063 also pass the expression EXPR to convert from. If C_CAST_P is true,
1064 this conversion is coming from a C-style cast. */
1069 {
1073 tree qualified_to;
1077 {
1080 }
1087 {
1093 }
1100 {
1104 }
1106 {
1108 {
1109 tree bitfield_type;
1112 {
1115 }
1116 }
1120 }
1122 /* Allow conversion between `__complex__' data types. */
1124 {
1125 /* The standard conversion sequence to convert FROM to TO is
1126 the standard conversion sequence to perform componentwise
1127 conversion. */
1132 {
1135 }
1136 else
1140 }
1143 {
1147 }
1149 /* [conv.ptr]
1150 A null pointer constant can be converted to a pointer type; ... A
1151 null pointer constant of integral type can be converted to an
1152 rvalue of type std::nullptr_t. */
1159 {
1160 /* For backwards brain damage compatibility, allow interconversion of
1161 pointers and integers with a pedwarn. */
1164 }
1166 {
1167 /* For backwards brain damage compatibility, allow interconversion of
1168 enums and integers with a pedwarn. */
1171 }
1174 {
1175 tree to_pointee;
1176 tree from_pointee;
1181 ;
1185 {
1187 from = build_pointer_type
1191 }
1193 {
1198 && (same_type_ignoring_top_level_qualifiers_p
1201 {
1205 }
1208 }
1211 /* [conv.ptr]
1213 An rvalue of type "pointer to cv D," where D is a
1214 class type, can be converted to an rvalue of type
1215 "pointer to cv B," where B is a base class (clause
1216 _class.derived_) of D. If B is an inaccessible
1217 (clause _class.access_) or ambiguous
1218 (_class.member.lookup_) base class of D, a program
1219 that necessitates this conversion is ill-formed.
1220 Therefore, we use DERIVED_FROM_P, and do not check
1221 access or uniqueness. */
1223 {
1224 from =
1230 }
1233 {
1236 }
1237 else
1238 {
1241 }
1246 /* In a C-style cast, we ignore CV-qualification because we
1247 are allowed to perform a static_cast followed by a
1248 const_cast. */
1253 /* converting from string constant to char *. */
1255 /* Allow conversions among compatible ObjC pointer types (base
1256 conversions have been already handled above). */
1261 {
1264 }
1265 else
1269 }
1271 {
1286 }
1288 {
1289 /* [conv.bool]
1291 An rvalue of arithmetic, unscoped enumeration, pointer, or
1292 pointer to member type can be converted to an rvalue of type
1293 bool. ... An rvalue of type std::nullptr_t can be converted
1294 to an rvalue of type bool; */
1300 {
1309 }
1312 }
1313 /* We don't check for ENUMERAL_TYPE here because there are no standard
1314 conversions to enum type. */
1315 /* As an extension, allow conversion to complex type. */
1317 {
1323 /* Give this a better rank if it's a promotion. */
1327 }
1333 {
1337 /* The derived-to-base conversion indicates the initialization
1338 of a parameter with base type from an object of a derived
1339 type. A temporary object is created to hold the result of
1340 the conversion unless we're binding directly to a reference. */
1342 }
1343 else
1350 }
1352 /* Returns nonzero if T1 is reference-related to T2. */
1354 bool
1356 {
1363 /* [dcl.init.ref]
1365 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1366 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1367 of T2. */
1371 }
1373 /* Returns nonzero if T1 is reference-compatible with T2. */
1375 static bool
1377 {
1378 /* [dcl.init.ref]
1380 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1381 reference-related to T2 and cv1 is the same cv-qualification as,
1382 or greater cv-qualification than, cv2. */
1385 }
1387 /* A reference of the indicated TYPE is being bound directly to the
1388 expression represented by the implicit conversion sequence CONV.
1389 Return a conversion sequence for this binding. */
1393 {
1394 tree t;
1401 /* [over.ics.rank]
1403 When a parameter of reference type binds directly
1404 (_dcl.init.ref_) to an argument expression, the implicit
1405 conversion sequence is the identity conversion, unless the
1406 argument expression has a type that is a derived class of the
1407 parameter type, in which case the implicit conversion sequence is
1408 a derived-to-base Conversion.
1410 If the parameter binds directly to the result of applying a
1411 conversion function to the argument expression, the implicit
1412 conversion sequence is a user-defined conversion sequence
1413 (_over.ics.user_), with the second standard conversion sequence
1414 either an identity conversion or, if the conversion function
1415 returns an entity of a type that is a derived class of the
1416 parameter type, a derived-to-base conversion. */
1418 {
1419 /* Represent the derived-to-base conversion. */
1421 /* We will actually be binding to the base-class subobject in
1422 the derived class, so we mark this conversion appropriately.
1423 That way, convert_like knows not to generate a temporary. */
1425 }
1427 }
1429 /* Returns the conversion path from type FROM to reference type TO for
1430 purposes of reference binding. For lvalue binding, either pass a
1431 reference type to FROM or an lvalue expression to EXPR. If the
1432 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1433 the conversion returned. If C_CAST_P is true, this
1434 conversion is coming from a C-style cast. */
1438 tsubst_flags_t complain)
1439 {
1443 tree tfrom;
1446 cp_lvalue_kind gl_kind;
1450 {
1455 }
1458 {
1464 {
1469 }
1470 }
1473 {
1478 else
1480 }
1482 {
1485 /* A class prvalue is not a glvalue. */
1487 }
1488 else
1496 /* Figure out whether or not the types are reference-related and
1497 reference compatible. We have do do this after stripping
1498 references from FROM. */
1500 /* If this is a C cast, first convert to an appropriately qualified
1501 type, so that we can later do a const_cast to the desired type. */
1507 /* Directly bind reference when target expression's type is compatible with
1508 the reference and expression is an lvalue. In DR391, the wording in
1509 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1510 const and rvalue references to rvalues of compatible class type.
1511 We should also do direct bindings for non-class xvalues. */
1513 && (is_lvalue
1517 && (gl_kind
1521 {
1522 /* [dcl.init.ref]
1524 If the initializer expression
1526 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1527 is reference-compatible with "cv2 T2,"
1529 the reference is bound directly to the initializer expression
1530 lvalue.
1532 [...]
1533 If the initializer expression is an rvalue, with T2 a class type,
1534 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1535 is bound to the object represented by the rvalue or to a sub-object
1536 within that object. */
1542 /* The top-level caller requested that we pretend that the lvalue
1543 be treated as an rvalue. */
1546 /* Handle rvalue reference to function properly. */
1547 conv->rvaluedness_matches_p
1549 else
1550 conv->rvaluedness_matches_p
1555 /* For the purposes of overload resolution, we ignore the fact
1556 this expression is a bitfield or packed field. (In particular,
1557 [over.ics.ref] says specifically that a function with a
1558 non-const reference parameter is viable even if the
1559 argument is a bitfield.)
1561 However, when we actually call the function we must create
1562 a temporary to which to bind the reference. If the
1563 reference is volatile, or isn't const, then we cannot make
1564 a temporary, so we just issue an error when the conversion
1565 actually occurs. */
1568 /* Don't allow binding of lvalues (other than function lvalues) to
1569 rvalue references. */
1576 }
1577 /* [class.conv.fct] A conversion function is never used to convert a
1578 (possibly cv-qualified) object to the (possibly cv-qualified) same
1579 object type (or a reference to it), to a (possibly cv-qualified) base
1580 class of that type (or a reference to it).... */
1583 {
1584 /* [dcl.init.ref]
1586 If the initializer expression
1588 -- has a class type (i.e., T2 is a class type) can be
1589 implicitly converted to an lvalue of type "cv3 T3," where
1590 "cv1 T1" is reference-compatible with "cv3 T3". (this
1591 conversion is selected by enumerating the applicable
1592 conversion functions (_over.match.ref_) and choosing the
1593 best one through overload resolution. (_over.match_).
1595 the reference is bound to the lvalue result of the conversion
1596 in the second case. */
1598 complain);
1601 }
1603 /* From this point on, we conceptually need temporaries, even if we
1604 elide them. Only the cases above are "direct bindings". */
1608 /* [over.ics.rank]
1610 When a parameter of reference type is not bound directly to an
1611 argument expression, the conversion sequence is the one required
1612 to convert the argument expression to the underlying type of the
1613 reference according to _over.best.ics_. Conceptually, this
1614 conversion sequence corresponds to copy-initializing a temporary
1615 of the underlying type with the argument expression. Any
1616 difference in top-level cv-qualification is subsumed by the
1617 initialization itself and does not constitute a conversion. */
1619 /* [dcl.init.ref]
1621 Otherwise, the reference shall be to a non-volatile const type.
1623 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1627 /* [dcl.init.ref]
1629 Otherwise, a temporary of type "cv1 T1" is created and
1630 initialized from the initializer expression using the rules for a
1631 non-reference copy initialization. If T1 is reference-related to
1632 T2, cv1 must be the same cv-qualification as, or greater
1633 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1637 /* We're generating a temporary now, but don't bind any more in the
1638 conversion (specifically, don't slice the temporary returned by a
1639 conversion operator). */
1642 /* Core issue 899: When [copy-]initializing a temporary to be bound
1643 to the first parameter of a copy constructor (12.8) called with
1644 a single argument in the context of direct-initialization,
1645 explicit conversion functions are also considered.
1647 So don't set LOOKUP_ONLYCONVERTING in that case. */
1658 /* This reference binding, unlike those above, requires the
1659 creation of a temporary. */
1664 }
1666 /* Returns the implicit conversion sequence (see [over.ics]) from type
1667 FROM to type TO. The optional expression EXPR may affect the
1668 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1669 true, this conversion is coming from a C-style cast. */
1674 {
1681 /* Other flags only apply to the primary function in overload
1682 resolution, or after we've chosen one. */
1687 /* FIXME: actually we don't want warnings either, but we can't just
1688 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1689 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1690 We really ought not to issue that warning until we've committed
1691 to that conversion. */
1696 else
1703 {
1707 /* As an extension, allow list-initialization of _Complex. */
1709 {
1713 }
1715 /* Allow conversion from an initializer-list with one element to a
1716 scalar type. */
1718 {
1720 tree elt;
1726 else
1732 {
1735 /* Too many levels of braces, i.e. '{{1}}'. */
1738 }
1739 }
1742 }
1748 {
1760 /* We used to try to bind a reference to a temporary here, but that
1761 is now handled after the recursive call to this function at the end
1762 of reference_binding. */
1764 }
1767 }
1769 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1770 functions. ARGS will not be changed until a single candidate is
1771 selected. */
1779 {
1796 }
1798 /* Return the number of remaining arguments in the parameter list
1799 beginning with ARG. */
1801 static int
1803 {
1808 n++;
1811 }
1813 /* Create an overload candidate for the function or method FN called
1814 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1815 FLAGS is passed on to implicit_conversion.
1817 This does not change ARGS.
1819 CTYPE, if non-NULL, is the type we want to pretend this function
1820 comes from for purposes of overload resolution. */
1827 tsubst_flags_t complain)
1828 {
1832 tree parmnode;
1838 /* At this point we should not see any functions which haven't been
1839 explicitly declared, except for friend functions which will have
1840 been found using argument dependent lookup. */
1843 /* The `this', `in_chrg' and VTT arguments to constructors are not
1844 considered in overload resolution. */
1846 {
1850 {
1853 }
1854 }
1855 else
1861 /* 13.3.2 - Viable functions [over.match.viable]
1862 First, to be a viable function, a candidate function shall have enough
1863 parameters to agree in number with the arguments in the list.
1865 We need to check this first; otherwise, checking the ICSes might cause
1866 us to produce an ill-formed template instantiation. */
1870 {
1874 }
1878 {
1882 }
1883 /* When looking for a function from a subobject from an implicit
1884 copy/move constructor/operator=, don't consider anything that takes (a
1885 reference to) an unrelated type. See c++/44909 and core 1092. */
1887 {
1893 else
1896 {
1899 ctype))
1901 }
1903 /* This only applies at the top level. */
1905 }
1910 /* Second, for F to be a viable function, there shall exist for each
1911 argument an implicit conversion sequence that converts that argument
1912 to the corresponding parameter of F. */
1917 {
1919 tree arg;
1928 else
1937 {
1943 /* The type of the implicit object parameter ('this') for
1944 overload resolution is not always the same as for the
1945 function itself; conversion functions are considered to
1946 be members of the class being converted, and functions
1947 introduced by a using-declaration are considered to be
1948 members of the class that uses them.
1950 Since build_over_call ignores the ICS for the `this'
1951 parameter, we can just change the parm type. */
1953 {
1954 parmtype = cp_build_qualified_type
1957 }
1959 /* Core issue 899: When [copy-]initializing a temporary to be bound
1960 to the first parameter of a copy constructor (12.8) called with
1961 a single argument in the context of direct-initialization,
1962 explicit conversion functions are also considered.
1964 So set LOOKUP_COPY_PARM to let reference_binding know that
1965 it's being called in that context. We generalize the above
1966 to handle move constructors and template constructors as well;
1967 the standardese should soon be updated similarly. */
1971 && (same_type_ignoring_top_level_qualifiers_p
1973 {
1976 /* We allow user-defined conversions within init-lists, but
1977 don't list-initialize the copy parm, as that would mean
1978 using two levels of braces for the same type. */
1982 }
1983 else
1989 }
1990 else
1991 {
1995 }
2002 {
2006 }
2009 {
2012 }
2013 }
2015 out:
2018 }
2020 /* Create an overload candidate for the conversion function FN which will
2021 be invoked for expression OBJ, producing a pointer-to-function which
2022 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2023 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2024 passed on to implicit_conversion.
2026 Actually, we don't really care about FN; we care about the type it
2027 converts to. There may be multiple conversion functions that will
2028 convert to that type, and we rely on build_user_type_conversion_1 to
2029 choose the best one; so when we create our candidate, we record the type
2030 instead of the function. */
2036 tsubst_flags_t complain)
2037 {
2055 /* Don't bother looking up the same type twice. */
2060 {
2068 else
2073 {
2077 }
2081 {
2085 }
2086 else
2087 {
2091 }
2098 {
2101 }
2108 }
2112 {
2116 }
2120 }
2122 static void
2126 {
2140 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2141 conversion ops are allowed. We handle that here by just checking for
2142 boolean_type_node because other operators don't ask for it. COND_EXPR
2143 also does contextual conversion to bool for the first operand, but we
2144 handle that in build_conditional_expr, and type1 here is operand 2. */
2149 {
2156 {
2158 /* We need something for printing the candidate. */
2162 }
2164 {
2168 }
2170 }
2172 /* For COND_EXPR we rearranged the arguments; undo that now. */
2174 {
2179 complain);
2182 else
2183 {
2186 boolean_type_node);
2187 }
2188 }
2195 }
2197 static bool
2199 {
2201 }
2203 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2205 static bool
2207 {
2208 /* [over.built]
2210 In this section, the term promoted integral type is used to refer
2211 to those integral types which are preserved by integral promotion
2212 (including e.g. int and long but excluding e.g. char).
2213 Similarly, the term promoted arithmetic type refers to promoted
2214 integral types plus floating types. */
2218 }
2220 /* Create any builtin operator overload candidates for the operator in
2221 question given the converted operand types TYPE1 and TYPE2. The other
2222 args are passed through from add_builtin_candidates to
2223 build_builtin_candidate.
2225 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2226 If CODE is requires candidates operands of the same type of the kind
2227 of which TYPE1 and TYPE2 are, we add both candidates
2228 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2230 static void
2234 tsubst_flags_t complain)
2235 {
2237 {
2245 }
2248 {
2250 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2251 and VQ is either volatile or empty, there exist candidate operator
2252 functions of the form
2253 VQ T& operator++(VQ T&);
2254 T operator++(VQ T&, int);
2255 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2256 type other than bool, and VQ is either volatile or empty, there exist
2257 candidate operator functions of the form
2258 VQ T& operator--(VQ T&);
2259 T operator--(VQ T&, int);
2260 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2261 complete object type, and VQ is either volatile or empty, there exist
2262 candidate operator functions of the form
2263 T*VQ& operator++(T*VQ&);
2264 T*VQ& operator--(T*VQ&);
2265 T* operator++(T*VQ&, int);
2266 T* operator--(T*VQ&, int); */
2275 {
2278 }
2281 /* 7 For every cv-qualified or cv-unqualified object type T, there
2282 exist candidate operator functions of the form
2284 T& operator*(T*);
2286 8 For every function type T, there exist candidate operator functions of
2287 the form
2288 T& operator*(T*); */
2298 /* 9 For every type T, there exist candidate operator functions of the form
2299 T* operator+(T*);
2301 10For every promoted arithmetic type T, there exist candidate operator
2302 functions of the form
2303 T operator+(T);
2304 T operator-(T); */
2314 /* 11For every promoted integral type T, there exist candidate operator
2315 functions of the form
2316 T operator~(T); */
2323 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2324 is the same type as C2 or is a derived class of C2, T is a complete
2325 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2326 there exist candidate operator functions of the form
2327 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2328 where CV12 is the union of CV1 and CV2. */
2333 {
2341 }
2344 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2345 didate operator functions of the form
2346 LR operator*(L, R);
2347 LR operator/(L, R);
2348 LR operator+(L, R);
2349 LR operator-(L, R);
2350 bool operator<(L, R);
2351 bool operator>(L, R);
2352 bool operator<=(L, R);
2353 bool operator>=(L, R);
2354 bool operator==(L, R);
2355 bool operator!=(L, R);
2356 where LR is the result of the usual arithmetic conversions between
2357 types L and R.
2359 14For every pair of types T and I, where T is a cv-qualified or cv-
2360 unqualified complete object type and I is a promoted integral type,
2361 there exist candidate operator functions of the form
2362 T* operator+(T*, I);
2363 T& operator[](T*, I);
2364 T* operator-(T*, I);
2365 T* operator+(I, T*);
2366 T& operator[](I, T*);
2368 15For every T, where T is a pointer to complete object type, there exist
2369 candidate operator functions of the form112)
2370 ptrdiff_t operator-(T, T);
2372 16For every pointer or enumeration type T, there exist candidate operator
2373 functions of the form
2374 bool operator<(T, T);
2375 bool operator>(T, T);
2376 bool operator<=(T, T);
2377 bool operator>=(T, T);
2378 bool operator==(T, T);
2379 bool operator!=(T, T);
2381 17For every pointer to member type T, there exist candidate operator
2382 functions of the form
2383 bool operator==(T, T);
2384 bool operator!=(T, T); */
2391 {
2394 }
2407 {
2410 }
2412 {
2415 }
2416 /* Fall through. */
2433 {
2436 }
2440 {
2443 }
2451 {
2454 }
2456 {
2459 }
2462 /* 18For every pair of promoted integral types L and R, there exist candi-
2463 date operator functions of the form
2464 LR operator%(L, R);
2465 LR operator&(L, R);
2466 LR operator^(L, R);
2467 LR operator|(L, R);
2468 L operator<<(L, R);
2469 L operator>>(L, R);
2470 where LR is the result of the usual arithmetic conversions between
2471 types L and R. */
2479 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2483 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2484 type, VQ is either volatile or empty, and R is a promoted arithmetic
2485 type, there exist candidate operator functions of the form
2486 VQ L& operator=(VQ L&, R);
2487 VQ L& operator*=(VQ L&, R);
2488 VQ L& operator/=(VQ L&, R);
2489 VQ L& operator+=(VQ L&, R);
2490 VQ L& operator-=(VQ L&, R);
2492 20For every pair T, VQ), where T is any type and VQ is either volatile
2493 or empty, there exist candidate operator functions of the form
2494 T*VQ& operator=(T*VQ&, T*);
2496 21For every pair T, VQ), where T is a pointer to member type and VQ is
2497 either volatile or empty, there exist candidate operator functions of
2498 the form
2499 VQ T& operator=(VQ T&, T);
2501 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2502 unqualified complete object type, VQ is either volatile or empty, and
2503 I is a promoted integral type, there exist candidate operator func-
2504 tions of the form
2505 T*VQ& operator+=(T*VQ&, I);
2506 T*VQ& operator-=(T*VQ&, I);
2508 23For every triple L, VQ, R), where L is an integral or enumeration
2509 type, VQ is either volatile or empty, and R is a promoted integral
2510 type, there exist candidate operator functions of the form
2512 VQ L& operator%=(VQ L&, R);
2513 VQ L& operator<<=(VQ L&, R);
2514 VQ L& operator>>=(VQ L&, R);
2515 VQ L& operator&=(VQ L&, R);
2516 VQ L& operator^=(VQ L&, R);
2517 VQ L& operator|=(VQ L&, R); */
2521 {
2525 {
2528 }
2541 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2554 {
2557 }
2562 }
2567 /* [over.built]
2569 For every pair of promoted arithmetic types L and R, there
2570 exist candidate operator functions of the form
2572 LR operator?(bool, L, R);
2574 where LR is the result of the usual arithmetic conversions
2575 between types L and R.
2577 For every type T, where T is a pointer or pointer-to-member
2578 type, there exist candidate operator functions of the form T
2579 operator?(bool, T, T); */
2583 /* That's OK. */
2586 /* Otherwise, the types should be pointers. */
2590 /* We don't check that the two types are the same; the logic
2591 below will actually create two candidates; one in which both
2592 parameter types are TYPE1, and one in which both parameter
2593 types are TYPE2. */
2604 }
2606 /* If we're dealing with two pointer types or two enumeral types,
2607 we need candidates for both of them. */
2616 {
2618 {
2620 error_mark_node,
2621 error_mark_node,
2622 CPO_CONVERSION,
2623 tf_none);
2625 {
2626 build_builtin_candidate
2630 }
2631 }
2633 build_builtin_candidate
2635 build_builtin_candidate
2638 }
2640 build_builtin_candidate
2642 }
2644 tree
2646 {
2652 }
2654 /* There are three conditions of builtin candidates:
2656 1) bool-taking candidates. These are the same regardless of the input.
2657 2) pointer-pair taking candidates. These are generated for each type
2658 one of the input types converts to.
2659 3) arithmetic candidates. According to the standard, we should generate
2660 all of these, but I'm trying not to...
2662 Here we generate a superset of the possible candidates for this particular
2663 case. That is a subset of the full set the standard defines, plus some
2664 other cases which the standard disallows. add_builtin_candidate will
2665 filter out the invalid set. */
2667 static void
2671 {
2675 /* TYPES[i] is the set of possible builtin-operator parameter types
2676 we will consider for the Ith argument. */
2681 {
2684 else
2686 }
2689 {
2690 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2691 and VQ is either volatile or empty, there exist candidate operator
2692 functions of the form
2693 VQ T& operator++(VQ T&); */
2703 /* 24There also exist candidate operator functions of the form
2704 bool operator!(bool);
2705 bool operator&&(bool, bool);
2706 bool operator||(bool, bool); */
2709 build_builtin_candidate
2716 build_builtin_candidate
2734 /* Fall through. */
2738 }
2744 {
2746 ;
2748 {
2749 tree convs;
2757 {
2762 }
2768 {
2781 {
2787 }
2791 }
2792 }
2793 else
2794 {
2799 {
2805 }
2807 }
2808 }
2810 /* Run through the possible parameter types of both arguments,
2811 creating candidates with those parameter types. */
2813 {
2815 tree u;
2819 add_builtin_candidate
2822 else
2823 add_builtin_candidate
2826 }
2830 }
2833 /* If TMPL can be successfully instantiated as indicated by
2834 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2836 TMPL is the template. EXPLICIT_TARGS are any explicit template
2837 arguments. ARGLIST is the arguments provided at the call-site.
2838 This does not change ARGLIST. The RETURN_TYPE is the desired type
2839 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2840 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2841 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2849 tsubst_flags_t complain)
2850 {
2860 tree arg;
2862 tree fn;
2866 /* We don't do deduction on the in-charge parameter, the VTT
2867 parameter or 'this'. */
2869 {
2872 else
2874 }
2879 {
2882 else
2884 }
2894 {
2897 }
2901 {
2904 }
2909 args_without_in_chrg,
2910 nargs_without_in_chrg,
2914 {
2915 /* Don't repeat unification later if it already resulted in errors. */
2919 nargs_without_in_chrg,
2921 else
2924 }
2926 /* In [class.copy]:
2928 A member function template is never instantiated to perform the
2929 copy of a class object to an object of its class type.
2931 It's a little unclear what this means; the standard explicitly
2932 does allow a template to be used to copy a class. For example,
2933 in:
2935 struct A {
2936 A(A&);
2937 template <class T> A(const T&);
2938 };
2939 const A f ();
2940 void g () { A a (f ()); }
2942 the member template will be used to make the copy. The section
2943 quoted above appears in the paragraph that forbids constructors
2944 whose only parameter is (a possibly cv-qualified variant of) the
2945 class type, and a logical interpretation is that the intent was
2946 to forbid the instantiation of member templates which would then
2947 have that form. */
2949 {
2952 ctype))
2953 {
2956 }
2957 }
2960 /* Aha, this is a conversion function. */
2963 else
2968 /* This situation can occur if a member template of a template
2969 class is specialized. Then, instantiate_template might return
2970 an instantiation of the specialization, in which case the
2971 DECL_TI_TEMPLATE field will point at the original
2972 specialization. For example:
2974 template <class T> struct S { template <class U> void f(U);
2975 template <> void f(int) {}; };
2976 S<double> sd;
2977 sd.f(3);
2979 Here, TMPL will be template <class U> S<double>::f(U).
2980 And, instantiate template will give us the specialization
2981 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2982 for this will point at template <class T> template <> S<T>::f(int),
2983 so that we can find the definition. For the purposes of
2984 overload resolution, however, we want the original TMPL. */
2986 else
2991 fail:
2994 }
3003 {
3004 return
3009 }
3018 {
3019 return
3023 complain);
3024 }
3026 /* The CANDS are the set of candidates that were considered for
3027 overload resolution. Return the set of viable candidates, or CANDS
3028 if none are viable. If any of the candidates were viable, set
3029 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3030 considered viable only if it is strictly viable. */
3036 {
3041 /* Be strict inside templates, since build_over_call won't actually
3042 do the conversions to get pedwarns. */
3052 {
3055 {
3061 }
3062 else
3064 }
3067 }
3069 static bool
3071 {
3076 }
3078 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3079 words, it is about to become the "this" pointer for a member
3080 function call. Take the address of the object. */
3082 static tree
3084 {
3085 /* In a template, we are only concerned about the type of the
3086 expression, so we can take a shortcut. */
3091 }
3093 /* Returns true iff functions are equivalent. Equivalent functions are
3094 not '==' only if one is a function-local extern function or if
3095 both are extern "C". */
3099 {
3108 }
3110 /* Print information about a candidate being rejected due to INFO. */
3112 static void
3114 {
3116 /* Conversion of implicit `this' argument failed. */
3120 else
3123 }
3125 /* Print information about a candidate with WANT parameters and we found
3126 HAVE. */
3128 static void
3130 {
3135 }
3137 /* Print information about one overload candidate CANDIDATE. MSGSTR
3138 is the text to print before the candidate itself.
3140 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3141 to have been run through gettext by the caller. This wart makes
3142 life simpler in print_z_candidates and for the translators. */
3144 static void
3147 {
3154 {
3165 else
3168 }
3175 else
3177 /* Give the user some information about why this candidate failed. */
3179 {
3183 {
3196 "cannot be converted to %qT with a qualification "
3202 "conversion function specialization to %qT is not an "
3207 /* We use template_unification_error_rejection if unification caused
3208 actual non-SFINAE errors, in which case we don't need to repeat
3209 them here. */
3211 {
3215 }
3216 /* Re-run template unification with diagnostics. */
3220 (make_tree_vec
3231 " a constructor taking a single argument of its own "
3236 /* This candidate didn't have any issues or we failed to
3237 handle a particular code. Either way... */
3239 }
3240 }
3241 }
3243 static void
3245 {
3253 /* Remove non-viable deleted candidates. */
3256 {
3261 else
3263 }
3264 /* ...if there are any non-deleted ones. */
3268 /* There may be duplicates in the set of candidates. We put off
3269 checking this condition as long as possible, since we have no way
3270 to eliminate duplicates from a set of functions in less than n^2
3271 time. Now we are about to emit an error message, so it is more
3272 permissible to go slowly. */
3274 {
3276 /* Skip builtin candidates and conversion functions. */
3281 {
3285 else
3287 }
3288 }
3291 n_candidates++;
3296 }
3298 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3299 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3300 the result of the conversion function to convert it to the final
3301 desired type. Merge the two sequences into a single sequence,
3302 and return the merged sequence. */
3306 {
3312 /* Find the end of the second conversion sequence. */
3314 {
3315 /* The entire sequence is a user-conversion sequence. */
3319 }
3321 /* Replace the identity conversion with the user conversion
3322 sequence. */
3326 }
3328 /* Handle overload resolution for initializing an object of class type from
3329 an initializer list. First we look for a suitable constructor that
3330 takes a std::initializer_list; if we don't find one, we then look for a
3331 non-list constructor.
3333 Parameters are as for add_candidates, except that the arguments are in
3334 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3335 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3337 static void
3344 tsubst_flags_t complain)
3345 {
3350 /* We're looking for a ctor for list-initialization. */
3352 /* And we don't allow narrowing conversions. We also use this flag to
3353 avoid the copy constructor call for copy-list-initialization. */
3356 /* Always use the default constructor if the list is empty (DR 990). */
3359 ;
3360 /* If the class has a list ctor, try passing the list as a single
3361 argument first, but only consider list ctors. */
3363 {
3371 }
3375 /* We aren't looking for list-ctors anymore. */
3377 /* We allow more user-defined conversions within an init-list. */
3383 }
3385 /* Returns the best overload candidate to perform the requested
3386 conversion. This function is used for three the overloading situations
3387 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3388 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3389 per [dcl.init.ref], so we ignore temporary bindings. */
3393 tsubst_flags_t complain)
3394 {
3396 tree fromtype;
3410 /* We represent conversion within a hierarchy using RVALUE_CONV and
3411 BASE_CONV, as specified by [over.best.ics]; these become plain
3412 constructor calls, as specified in [dcl.init]. */
3417 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3418 creating a garbage BASELINK; constructors can't be inherited. */
3422 {
3427 {
3428 /* [class.conv.fct] A conversion function is never used to
3429 convert a (possibly cv-qualified) object to the (possibly
3430 cv-qualified) same object type (or a reference to it), to a
3431 (possibly cv-qualified) base class of that type (or a
3432 reference to it)... */
3433 }
3434 else
3436 }
3443 /* It's OK to bind a temporary for converting constructor arguments, but
3444 not in converting the return value of a conversion operator. */
3449 {
3454 /* We should never try to call the abstract or base constructor
3455 from here. */
3460 {
3461 /* List-initialization. */
3465 }
3466 else
3467 {
3472 }
3475 {
3478 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3479 set, then this is copy-initialization. In that case, "The
3480 result of the call is then used to direct-initialize the
3481 object that is the destination of the copy-initialization."
3482 [dcl.init]
3484 We represent this in the conversion sequence with an
3485 rvalue conversion, which means a constructor call. */
3488 cand->second_conv
3490 }
3491 }
3497 {
3501 /* If we are called to convert to a reference type, we are trying to
3502 find a direct binding, so don't even consider temporaries. If
3503 we don't find a direct binding, the caller will try again to
3504 look for a temporary binding. */
3515 {
3517 conversion *ics
3519 rettype,
3522 complain);
3524 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3525 copy-initialization. In that case, "The result of the
3526 call is then used to direct-initialize the object that is
3527 the destination of the copy-initialization." [dcl.init]
3529 We represent this in the conversion sequence with an
3530 rvalue conversion, which means a constructor call. But
3531 don't add a second rvalue conversion if there's already
3532 one there. Which there really shouldn't be, but it's
3533 harmless since we'd add it here anyway. */
3541 {
3545 }
3548 {
3549 /* 13.3.1.5: For direct-initialization, those explicit
3550 conversion functions that are not hidden within S and
3551 yield type T or a type that can be converted to type T
3552 with a qualification conversion (4.4) are also candidate
3553 functions. */
3554 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3555 I've raised this issue with the committee. --jason 9/2011 */
3558 }
3560 {
3562 cand->reason
3565 }
3568 {
3569 /* 13.3.3.1.2: If the user-defined conversion is specified by
3570 a specialization of a conversion function template, the
3571 second standard conversion sequence shall have exact match
3572 rank. */
3575 }
3576 }
3577 }
3581 {
3585 }
3589 {
3591 {
3595 }
3602 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3603 ambiguous conversion is no worse than another user-defined
3604 conversion. */
3607 }
3609 /* Build the user conversion sequence. */
3610 conv = build_conv
3619 /* Remember that this was a list-initialization. */
3623 /* Combine it with the second conversion sequence. */
3628 }
3630 /* Wrapper for above. */
3632 tree
3634 tsubst_flags_t complain)
3635 {
3637 tree ret;
3643 {
3646 else
3647 {
3650 }
3651 }
3652 else
3657 }
3659 /* Subroutine of convert_nontype_argument.
3661 EXPR is an argument for a template non-type parameter of integral or
3662 enumeration type. Do any necessary conversions (that are permitted for
3663 non-type arguments) to convert it to the parameter type.
3665 If conversion is successful, returns the converted expression;
3666 otherwise, returns error_mark_node. */
3668 tree
3670 {
3673 tree t;
3681 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3688 /* for a non-type template-parameter of integral or
3689 enumeration type, integral promotions (4.5) and integral
3690 conversions (4.7) are applied. */
3691 /* It should be sufficient to check the outermost conversion step, since
3692 there are no qualification conversions to integer type. */
3695 {
3696 /* A conversion function is OK. If it isn't constexpr, we'll
3697 complain later that the argument isn't constant. */
3699 /* The lvalue-to-rvalue conversion is OK. */
3712 /* and fall through. */
3717 }
3721 else
3724 /* Free all the conversions we allocated. */
3728 }
3730 /* Do any initial processing on the arguments to a function call. */
3734 {
3736 tree arg;
3739 {
3743 {
3747 }
3750 }
3752 }
3754 /* Perform overload resolution on FN, which is called with the ARGS.
3756 Return the candidate function selected by overload resolution, or
3757 NULL if the event that overload resolution failed. In the case
3758 that overload resolution fails, *CANDIDATES will be the set of
3759 candidates considered, and ANY_VIABLE_P will be set to true or
3760 false to indicate whether or not any of the candidates were
3761 viable.
3763 The ARGS should already have gone through RESOLVE_ARGS before this
3764 function is called. */
3771 {
3773 tree explicit_targs;
3784 /* Check FN. */
3791 {
3795 }
3797 /* Add the various candidate functions. */
3802 LOOKUP_NORMAL,
3808 else
3813 }
3815 /* Print an error message about being unable to build a call to FN with
3816 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3817 be located; CANDIDATES is a possibly empty list of such
3818 functions. */
3820 static void
3823 {
3830 else
3835 }
3837 /* Return an expression for a call to FN (a namespace-scope function,
3838 or a static member function) with the ARGS. This may change
3839 ARGS. */
3841 tree
3843 tsubst_flags_t complain)
3844 {
3848 tree result;
3851 {
3855 }
3860 /* If this function was found without using argument dependent
3861 lookup, then we want to ignore any undeclared friend
3862 functions. */
3864 {
3869 {
3873 }
3874 }
3876 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3880 complain);
3883 {
3885 {
3892 }
3894 }
3895 else
3896 {
3898 /* If fn is template_id_expr, the call has explicit template arguments
3899 (e.g. func<int>(5)), communicate this info to build_over_call
3900 through flags so that later we can use it to decide whether to warn
3901 about peculiar null pointer conversion. */
3905 }
3907 /* Free all the conversions we allocated. */
3911 }
3913 /* Build a call to a global operator new. FNNAME is the name of the
3914 operator (either "operator new" or "operator new[]") and ARGS are
3915 the arguments provided. This may change ARGS. *SIZE points to the
3916 total number of bytes required by the allocation, and is updated if
3917 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3918 be used. If this function determines that no cookie should be
3919 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
3920 is not NULL_TREE, it is evaluated before calculating the final
3921 array size, and if it fails, the array size is replaced with
3922 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
3923 is non-NULL, it will be set, upon return, to the allocation
3924 function called. */
3926 tree
3930 {
3932 tree fns;
3939 /* Set to (size_t)-1 if the size check fails. */
3948 /* Based on:
3950 [expr.new]
3952 If this lookup fails to find the name, or if the allocated type
3953 is not a class type, the allocation function's name is looked
3954 up in the global scope.
3956 we disregard block-scope declarations of "operator new". */
3959 /* Figure out what function is being called. */
3961 complain);
3963 /* If no suitable function could be found, issue an error message
3964 and give up. */
3966 {
3970 }
3972 /* If a cookie is required, add some extra space. Whether
3973 or not a cookie is required cannot be determined until
3974 after we know which function was called. */
3976 {
3979 {
3980 /* In G++ 3.2, the check was implemented incorrectly; it
3981 looked at the placement expression, rather than the
3982 type of the function. */
3986 }
3987 else
3988 {
3989 tree arg_types;
3992 /* Skip the size_t parameter. */
3994 /* Check the remaining parameters (if any). */
3998 ptr_type_node))
4000 }
4001 /* If we need a cookie, adjust the number of bytes allocated. */
4003 {
4004 /* Update the total size. */
4006 /* Set to (size_t)-1 if the size check fails. */
4010 /* Update the argument list to reflect the adjusted size. */
4012 }
4013 else
4015 }
4017 /* Tell our caller which function we decided to call. */
4021 /* Build the CALL_EXPR. */
4023 }
4025 /* Build a new call to operator(). This may change ARGS. */
4027 static tree
4029 {
4043 {
4045 /* It's no good looking for an overloaded operator() on a
4046 pointer-to-member-function. */
4047 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
4049 }
4052 {
4056 }
4057 else
4061 {
4065 }
4067 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4071 {
4079 }
4084 {
4096 {
4103 add_template_conv_candidate
4107 else
4111 }
4112 }
4116 {
4118 {
4122 }
4124 }
4125 else
4126 {
4129 {
4131 {
4135 }
4137 }
4138 /* Since cand->fn will be a type, not a function, for a conversion
4139 function, we must be careful not to unconditionally look at
4140 DECL_NAME here. */
4144 else
4145 {
4147 complain);
4150 }
4151 }
4153 /* Free all the conversions we allocated. */
4157 }
4159 /* Wrapper for above. */
4161 tree
4163 {
4164 tree ret;
4169 }
4171 /* Called by op_error to prepare format strings suitable for the error
4172 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4173 and a suffix (controlled by NTYPES). */
4177 {
4187 else
4191 }
4193 static void
4196 {
4201 else
4205 {
4211 else
4223 else
4233 else
4244 else
4254 else
4259 else
4263 else
4268 }
4269 }
4271 /* Return the implicit conversion sequence that could be used to
4272 convert E1 to E2 in [expr.cond]. */
4276 {
4282 /* [expr.cond]
4284 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4285 implicitly converted (clause _conv_) to the type "lvalue reference to
4286 T2", subject to the constraint that in the conversion the
4287 reference must bind directly (_dcl.init.ref_) to an lvalue. */
4289 {
4291 t1,
4292 e1,
4294 LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND
4296 complain);
4299 }
4301 /* [expr.cond]
4303 If E1 and E2 have class type, and the underlying class types are
4304 the same or one is a base class of the other: E1 can be converted
4305 to match E2 if the class of T2 is the same type as, or a base
4306 class of, the class of T1, and the cv-qualification of T2 is the
4307 same cv-qualification as, or a greater cv-qualification than, the
4308 cv-qualification of T1. If the conversion is applied, E1 is
4309 changed to an rvalue of type T2 that still refers to the original
4310 source class object (or the appropriate subobject thereof). */
4313 {
4315 {
4320 else
4323 }
4324 else
4326 }
4327 else
4328 /* [expr.cond]
4330 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4331 converted to the type that expression E2 would have if E2 were
4332 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4335 }
4337 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4338 arguments to the conditional expression. */
4340 static tree
4342 tsubst_flags_t complain)
4343 {
4344 tree arg2_type;
4345 tree arg3_type;
4354 /* As a G++ extension, the second argument to the conditional can be
4355 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4356 c'.) If the second operand is omitted, make sure it is
4357 calculated only once. */
4359 {
4364 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4367 else
4369 }
4371 /* If something has already gone wrong, just pass that fact up the
4372 tree. */
4382 {
4393 {
4398 }
4402 {
4408 {
4412 {
4417 }
4419 {
4424 }
4427 }
4428 }
4434 {
4440 }
4446 }
4448 /* [expr.cond]
4450 The first expression is implicitly converted to bool (clause
4451 _conv_). */
4453 LOOKUP_NORMAL);
4457 /* [expr.cond]
4459 If either the second or the third operand has type (possibly
4460 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4461 array-to-pointer (_conv.array_), and function-to-pointer
4462 (_conv.func_) standard conversions are performed on the second
4463 and third operands. */
4467 {
4468 /* Do the conversions. We don't these for `void' type arguments
4469 since it can't have any effect and since decay_conversion
4470 does not handle that case gracefully. */
4478 /* [expr.cond]
4480 One of the following shall hold:
4482 --The second or the third operand (but not both) is a
4483 throw-expression (_except.throw_); the result is of the
4484 type of the other and is an rvalue.
4486 --Both the second and the third operands have type void; the
4487 result is of type void and is an rvalue.
4489 We must avoid calling force_rvalue for expressions of type
4490 "void" because it will complain that their value is being
4491 used. */
4494 {
4496 {
4500 }
4503 }
4506 {
4508 {
4512 }
4515 }
4518 else
4519 {
4521 {
4524 "is of type %<void%>, "
4525 "but the third operand is neither a throw-expression "
4527 else
4529 "is of type %<void%>, "
4530 "but the second operand is neither a throw-expression "
4532 }
4534 }
4538 }
4539 /* [expr.cond]
4541 Otherwise, if the second and third operand have different types,
4542 and either has (possibly cv-qualified) class type, an attempt is
4543 made to convert each of those operands to the type of the other. */
4546 {
4550 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4556 /* [expr.cond]
4558 If both can be converted, or one can be converted but the
4559 conversion is ambiguous, the program is ill-formed. If
4560 neither can be converted, the operands are left unchanged and
4561 further checking is performed as described below. If exactly
4562 one conversion is possible, that conversion is applied to the
4563 chosen operand and the converted operand is used in place of
4564 the original operand for the remainder of this section. */
4569 {
4573 }
4575 {
4579 /* Even if CONV2 is a valid conversion, the result of the
4580 conversion may be invalid. For example, if ARG3 has type
4581 "volatile X", and X does not have a copy constructor
4582 accepting a "volatile X&", then even if ARG2 can be
4583 converted to X, the conversion will fail. */
4586 }
4588 {
4594 }
4596 /* Free all the conversions we allocated. */
4602 /* If, after the conversion, both operands have class type,
4603 treat the cv-qualification of both operands as if it were the
4604 union of the cv-qualification of the operands.
4606 The standard is not clear about what to do in this
4607 circumstance. For example, if the first operand has type
4608 "const X" and the second operand has a user-defined
4609 conversion to "volatile X", what is the type of the second
4610 operand after this step? Making it be "const X" (matching
4611 the first operand) seems wrong, as that discards the
4612 qualification without actually performing a copy. Leaving it
4613 as "volatile X" seems wrong as that will result in the
4614 conditional expression failing altogether, even though,
4615 according to this step, the one operand could be converted to
4616 the type of the other. */
4624 }
4626 /* [expr.cond]
4628 If the second and third operands are lvalues and have the same
4629 type, the result is of that type and is an lvalue. */
4633 {
4638 }
4640 /* [expr.cond]
4642 Otherwise, the result is an rvalue. If the second and third
4643 operand do not have the same type, and either has (possibly
4644 cv-qualified) class type, overload resolution is used to
4645 determine the conversions (if any) to be applied to the operands
4646 (_over.match.oper_, _over.built_). */
4650 {
4655 /* Rearrange the arguments so that add_builtin_candidate only has
4656 to know about two args. In build_builtin_candidate, the
4657 arguments are unscrambled. */
4662 COND_EXPR,
4663 NOP_EXPR,
4665 args,
4668 /* [expr.cond]
4670 If the overload resolution fails, the program is
4671 ill-formed. */
4674 {
4676 {
4680 }
4682 }
4685 {
4687 {
4691 }
4693 }
4695 /* [expr.cond]
4697 Otherwise, the conversions thus determined are applied, and
4698 the converted operands are used in place of the original
4699 operands for the remainder of this section. */
4708 }
4710 /* [expr.cond]
4712 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4713 and function-to-pointer (_conv.func_) standard conversions are
4714 performed on the second and third operands.
4716 We need to force the lvalue-to-rvalue conversion here for class types,
4717 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4718 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4719 regions. */
4732 /* [expr.cond]
4734 After those conversions, one of the following shall hold:
4736 --The second and third operands have the same type; the result is of
4737 that type. */
4740 /* [expr.cond]
4742 --The second and third operands have arithmetic or enumeration
4743 type; the usual arithmetic conversions are performed to bring
4744 them to a common type, and the result is of that type. */
4749 {
4750 /* In this case, there is always a common type. */
4752 arg3_type);
4754 "implicit conversion from %qT to %qT to "
4756 input_location);
4760 {
4764 /* Two enumerators from the same enumeration can have different
4770 }
4776 {
4780 }
4784 }
4785 /* [expr.cond]
4787 --The second and third operands have pointer type, or one has
4788 pointer type and the other is a null pointer constant; pointer
4789 conversions (_conv.ptr_) and qualification conversions
4790 (_conv.qual_) are performed to bring them to their composite
4791 pointer type (_expr.rel_). The result is of the composite
4792 pointer type.
4794 --The second and third operands have pointer to member type, or
4795 one has pointer to member type and the other is a null pointer
4796 constant; pointer to member conversions (_conv.mem_) and
4797 qualification conversions (_conv.qual_) are performed to bring
4798 them to a common type, whose cv-qualification shall match the
4799 cv-qualification of either the second or the third operand.
4800 The result is of the common type. */
4808 {
4811 complain);
4816 }
4819 {
4824 }
4829 valid_operands:
4832 /* Avoid folding within decltype (c++/42013) and noexcept. */
4835 /* We can't use result_type below, as fold might have returned a
4836 throw_expr. */
4839 {
4840 /* Expand both sides into the same slot, hopefully the target of
4841 the ?: expression. We used to check for TARGET_EXPRs here,
4842 but now we sometimes wrap them in NOP_EXPRs so the test would
4843 fail. */
4846 /* If this expression is an rvalue, but might be mistaken for an
4847 lvalue, we must add a NON_LVALUE_EXPR. */
4849 }
4852 }
4854 /* Wrapper for above. */
4856 tree
4858 tsubst_flags_t complain)
4859 {
4860 tree ret;
4865 }
4867 /* OPERAND is an operand to an expression. Perform necessary steps
4868 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4869 returned. */
4871 static tree
4873 {
4875 {
4878 /* Make sure the template type is instantiated now. */
4880 }
4883 }
4885 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4886 OVERLOAD) to the CANDIDATES, returning an updated list of
4887 CANDIDATES. The ARGS are the arguments provided to the call;
4888 if FIRST_ARG is non-null it is the implicit object argument,
4889 otherwise the first element of ARGS is used if needed. The
4890 EXPLICIT_TARGS are explicit template arguments provided.
4891 TEMPLATE_ONLY is true if only template functions should be
4892 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4893 add_function_candidate. */
4895 static void
4897 tree return_type,
4902 tsubst_flags_t complain)
4903 {
4904 tree ctype;
4908 unification_kind_t strict;
4909 tree fn;
4914 /* Precalculate special handling of constructors and conversion ops. */
4917 {
4921 /* We're doing return_type(x). */
4923 else
4924 /* We're doing x.operator return_type(). */
4926 /* [over.match.funcs] For conversion functions, the function
4927 is considered to be a member of the class of the implicit
4928 object argument for the purpose of defining the type of
4929 the implicit object parameter. */
4931 }
4932 else
4933 {
4935 {
4937 /* For list-initialization we consider explicit constructors
4938 and complain if one is chosen. */
4939 check_converting
4942 }
4943 else
4944 {
4947 }
4950 }
4954 else
4955 /* Delay creating the implicit this parameter until it is needed. */
4959 {
4960 tree fn_first_arg;
4970 /* Figure out which set of arguments to use. */
4972 {
4973 /* If this function is a non-static member and we didn't get an
4974 implicit object argument, move it out of args. */
4976 {
4978 tree arg;
4985 }
4989 }
4990 else
4991 {
4992 /* Otherwise, just use the list of arguments provided. */
4995 }
4999 fn,
5000 ctype,
5001 explicit_targs,
5002 fn_first_arg,
5003 fn_args,
5004 return_type,
5005 access_path,
5006 conversion_path,
5007 flags,
5008 strict,
5009 complain);
5012 fn,
5013 ctype,
5014 fn_first_arg,
5015 fn_args,
5016 access_path,
5017 conversion_path,
5018 flags,
5019 complain);
5020 }
5021 }
5023 static tree
5026 {
5029 tree fnname;
5047 {
5051 }
5052 else
5058 {
5063 /* Use build_op_new_call and build_op_delete_call instead. */
5067 /* Use build_op_call instead. */
5074 /* These are saved for the sake of warn_logical_operator. */
5080 }
5086 /* Use build_conditional_expr instead. */
5102 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5105 /* Add namespace-scope operators to the list of functions to
5106 consider. */
5116 /* Add class-member operators to the candidate set. */
5118 {
5119 tree fns;
5123 {
5126 }
5134 }
5135 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5136 only non-member functions that have type T1 or reference to
5137 cv-qualified-opt T1 for the first argument, if the first argument
5138 has an enumeration type, or T2 or reference to cv-qualified-opt
5139 T2 for the second argument, if the the second argument has an
5140 enumeration type. Filter out those that don't match. */
5142 {
5146 {
5156 {
5162 && (same_type_ignoring_top_level_qualifiers_p
5167 }
5169 /* No argument has an appropriate type, so remove this
5170 candidate function from the list. */
5172 {
5175 }
5176 }
5177 }
5183 {
5186 /* For these, the built-in candidates set is empty
5187 [over.match.oper]/3. We don't want non-strict matches
5188 because exact matches are always possible with built-in
5189 operators. The built-in candidate set for COMPONENT_REF
5190 would be empty too, but since there are no such built-in
5191 operators, we accept non-strict matches for them. */
5198 }
5202 {
5204 {
5207 /* Don't try anything fancy if we're not allowed to produce
5208 errors. */
5212 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5213 distinguish between prefix and postfix ++ and
5214 operator++() was used for both, so we allow this with
5215 -fpermissive. */
5216 else
5217 {
5223 }
5230 else
5236 /* The caller will deal with these. */
5246 {
5247 /* If one of the arguments of the operator represents
5248 an invalid use of member function pointer, try to report
5249 a meaningful error ... */
5254 else
5255 {
5256 /* ... Otherwise, report the more generic
5257 "no matching operator found" error */
5260 }
5261 }
5264 }
5265 }
5266 else
5267 {
5270 {
5272 {
5275 }
5277 }
5279 {
5285 else
5287 }
5288 else
5289 {
5290 /* Give any warnings we noticed during overload resolution. */
5292 {
5296 }
5298 /* Check for comparison of different enum types. */
5300 {
5312 {
5316 }
5320 }
5322 /* We need to strip any leading REF_BIND so that bitfields
5323 don't cause errors. This should not remove any important
5324 conversions, because builtins don't apply to class
5325 objects directly. */
5332 {
5336 else
5339 /* We need to call warn_logical_operator before
5340 converting arg2 to a boolean_type, but after
5341 decaying an enumerator to its value. */
5348 }
5350 {
5355 }
5357 }
5358 }
5360 user_defined_result_ready:
5362 /* Free all the conversions we allocated. */
5368 builtin:
5370 {
5383 /* Fall through. */
5422 complain),
5425 /* The caller will deal with these. */
5433 }
5435 }
5437 /* Wrapper for above. */
5439 tree
5443 {
5444 tree ret;
5450 }
5452 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5453 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5455 static bool
5457 {
5458 /* A template instance is never a usual deallocation function,
5459 regardless of its signature. */
5464 /* If a class T has a member deallocation function named operator delete
5465 with exactly one parameter, then that function is a usual
5466 (non-placement) deallocation function. If class T does not declare
5467 such an operator delete but does declare a member deallocation
5468 function named operator delete with exactly two parameters, the second
5469 of which has type std::size_t (18.2), then this function is a usual
5470 deallocation function. */
5477 }
5479 /* Build a call to operator delete. This has to be handled very specially,
5480 because the restrictions on what signatures match are different from all
5481 other call instances. For a normal delete, only a delete taking (void *)
5482 or (void *, size_t) is accepted. For a placement delete, only an exact
5483 match with the placement new is accepted.
5485 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5486 ADDR is the pointer to be deleted.
5487 SIZE is the size of the memory block to be deleted.
5488 GLOBAL_P is true if the delete-expression should not consider
5489 class-specific delete operators.
5490 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5492 If this call to "operator delete" is being generated as part to
5493 deallocate memory allocated via a new-expression (as per [expr.new]
5494 which requires that if the initialization throws an exception then
5495 we call a deallocation function), then ALLOC_FN is the allocation
5496 function. */
5498 tree
5502 {
5516 /* In [class.free]
5518 If the result of the lookup is ambiguous or inaccessible, or if
5519 the lookup selects a placement deallocation function, the
5520 program is ill-formed.
5522 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5523 {
5527 }
5528 else
5534 /* Strip const and volatile from addr. */
5538 {
5539 /* "A declaration of a placement deallocation function matches the
5540 declaration of a placement allocation function if it has the same
5541 number of parameters and, after parameter transformations (8.3.5),
5542 all parameter types except the first are identical."
5544 So we build up the function type we want and ask instantiate_type
5545 to get it for us. */
5557 /* "If the lookup finds the two-parameter form of a usual deallocation
5558 function (3.7.4.2) and that function, considered as a placement
5559 deallocation function, would have been selected as a match for the
5560 allocation function, the program is ill-formed." */
5562 {
5563 /* But if the class has an operator delete (void *), then that is
5564 the usual deallocation function, so we shouldn't complain
5565 about using the operator delete (void *, size_t). */
5568 {
5573 }
5575 {
5578 }
5579 else
5581 ok:;
5582 }
5583 }
5584 else
5585 /* "Any non-placement deallocation function matches a non-placement
5586 allocation function. If the lookup finds a single matching
5587 deallocation function, that function will be called; otherwise, no
5588 deallocation function will be called." */
5591 {
5594 {
5596 /* "If a class T has a member deallocation function named
5597 operator delete with exactly one parameter, then that
5598 function is a usual (non-placement) deallocation
5599 function. If class T does not declare such an operator
5600 delete but does declare a member deallocation function named
5601 operator delete with exactly two parameters, the second of
5602 which has type std::size_t (18.2), then this function is a
5603 usual deallocation function."
5605 So (void*) beats (void*, size_t). */
5608 }
5609 }
5611 /* If we have a matching function, call it. */
5613 {
5616 /* If the FN is a member function, make sure that it is
5617 accessible. */
5620 complain);
5622 /* Core issue 901: It's ok to new a type with deleted delete. */
5627 {
5628 /* The placement args might not be suitable for overload
5629 resolution at this point, so build the call directly. */
5638 }
5639 else
5640 {
5641 tree ret;
5650 }
5651 }
5653 /* [expr.new]
5655 If no unambiguous matching deallocation function can be found,
5656 propagating the exception does not cause the object's memory to
5657 be freed. */
5659 {
5663 alloc_fn);
5665 }
5671 }
5673 /* If the current scope isn't allowed to access DECL along
5674 BASETYPE_PATH, give an error. The most derived class in
5675 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5676 the declaration to use in the error diagnostic. */
5678 bool
5680 tsubst_flags_t complain)
5681 {
5685 {
5687 {
5692 else
5695 }
5697 }
5700 }
5702 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5703 bitwise or of LOOKUP_* values. If any errors are warnings are
5704 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5705 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5706 to NULL. */
5708 static tree
5711 {
5724 else
5727 }
5729 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5730 EXPR is implicitly converted to type TOTYPE.
5731 FN and ARGNUM are used for diagnostics. */
5733 static void
5735 {
5736 /* Issue warnings about peculiar, but valid, uses of NULL. */
5739 {
5740 source_location loc =
5747 else
5750 }
5752 /* Issue warnings if "false" is converted to a NULL pointer */
5755 {
5758 "converting %<false%> to pointer type for argument %P "
5760 else
5763 }
5764 }
5766 /* Perform the conversions in CONVS on the expression EXPR. FN and
5767 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
5768 indicates the `this' argument of a method. INNER is nonzero when
5769 being called to continue a conversion chain. It is negative when a
5770 reference binding will be applied, positive otherwise. If
5771 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
5772 conversions will be emitted if appropriate. If C_CAST_P is true,
5773 this conversion is coming from a C-style cast; in that case,
5774 conversions to inaccessible bases are permitted. */
5776 static tree
5780 {
5782 diagnostic_t diag_kind;
5797 {
5800 /* Give a helpful error if this is bad because of excess braces. */
5808 {
5810 {
5817 complain);
5821 complain);
5822 else
5824 }
5826 {
5830 complain);
5832 }
5837 complain);
5840 }
5849 }
5855 {
5857 {
5862 /* If we're initializing from {}, it's value-initialization. */
5866 {
5871 {
5874 }
5876 }
5880 /* When converting from an init list we consider explicit
5881 constructors, but actually trying to call one is an error. */
5883 /* Unless this is for direct-list-initialization. */
5886 /* Unless we're calling it for value-initialization from an
5887 empty list, since that is handled separately in 8.5.4. */
5889 {
5892 }
5894 /* Set user_conv_p on the argument conversions, so rvalue/base
5895 handling knows not to allow any more UDCs. */
5901 /* If this is a constructor or a function returning an aggr type,
5902 we need to build up a TARGET_EXPR. */
5904 {
5907 /* Remember that this was list-initialization. */
5910 }
5913 }
5917 {
5923 else
5925 }
5929 /* Convert a constant to its underlying value, unless we are
5930 about to bind it to a reference, in which case we need to
5931 leave it as an lvalue. */
5933 {
5936 /* If __null has been converted to an integer type, we do not
5937 want to warn about uses of EXPR as an integer, rather than
5938 as a pointer. */
5940 }
5943 /* We leave bad_p off ck_ambig because overload resolution considers
5944 it valid, it just fails when we try to perform it. So we need to
5945 check complain here, too. */
5947 {
5948 /* Call build_user_type_conversion again for the error. */
5950 complain);
5953 }
5957 {
5958 /* Conversion to std::initializer_list<T>. */
5966 /* Convert all the elements. */
5968 {
5978 }
5979 /* Build up the array. */
5980 elttype = cp_build_qualified_type
5984 /* Take the address explicitly rather than via decay_conversion
5985 to avoid the error about taking the address of a temporary. */
5989 /* Build up the initializer_list object. */
5997 }
6001 {
6010 }
6013 complain);
6017 };
6022 c_cast_p,
6023 complain);
6028 {
6036 /* Else fall through. */
6039 {
6040 /* We are going to bind a reference directly to a base-class
6041 subobject of EXPR. */
6042 /* Build an expression for `*((base*) &expr)'. */
6048 }
6050 /* Copy-initialization where the cv-unqualified version of the source
6051 type is the same class as, or a derived class of, the class of the
6052 destination [is treated as direct-initialization]. [dcl.init] */
6055 /* This conversion is being done in the context of a user-defined
6056 conversion (i.e. the second step of copy-initialization), so
6057 don't allow any more. */
6063 /* Copy-list-initialization doesn't actually involve a copy. */
6072 {
6076 {
6085 }
6087 /* If necessary, create a temporary.
6089 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6090 that need temporaries, even when their types are reference
6091 compatible with the type of reference being bound, so the
6092 upcoming call to cp_build_addr_expr doesn't fail. */
6096 {
6097 /* Otherwise, a temporary of type "cv1 T1" is created and
6098 initialized from the initializer expression using the rules
6099 for a non-reference copy-initialization (8.5). */
6108 {
6109 /* If the reference is volatile or non-const, we
6110 cannot create a temporary. */
6117 else
6121 }
6122 /* If the source is a packed field, and we must use a copy
6123 constructor, then building the target expr will require
6124 binding the field to the reference parameter to the
6125 copy constructor, and we'll end up with an infinite
6126 loop. If we can use a bitwise copy, then we'll be
6127 OK. */
6131 {
6135 }
6137 {
6140 }
6142 }
6144 /* Take the address of the thing to which we will bind the
6145 reference. */
6150 /* Convert it to a pointer to the type referred to by the
6151 reference. This will adjust the pointer if a derived to
6152 base conversion is being performed. */
6155 /* Convert the pointer to the desired reference type. */
6157 }
6163 /* Warn about deprecated conversion if appropriate. */
6179 }
6186 else
6190 }
6192 /* ARG is being passed to a varargs function. Perform any conversions
6193 required. Return the converted value. */
6195 tree
6197 {
6198 tree arg_type;
6201 /* [expr.call]
6203 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6204 standard conversions are performed. */
6207 /* [expr.call]
6209 If the argument has integral or enumeration type that is subject
6210 to the integral promotions (_conv.prom_), or a floating point
6211 type that is subject to the floating point promotion
6212 (_conv.fpprom_), the value of the argument is converted to the
6213 promoted type before the call. */
6218 {
6222 "implicit conversion from %qT to %qT when passing "
6226 }
6230 {
6232 {
6237 }
6239 }
6245 /* In a template (or ill-formed code), we can have an incomplete type
6246 even after require_complete_type_sfinae, in which case we don't know
6247 whether it has trivial copy or not. */
6249 {
6250 /* Build up a real lvalue-to-rvalue conversion in case the
6251 copy constructor is trivial but not callable. */
6255 /* [expr.call] 5.2.2/7:
6256 Passing a potentially-evaluated argument of class type (Clause 9)
6257 with a non-trivial copy constructor or a non-trivial destructor
6258 with no corresponding parameter is conditionally-supported, with
6259 implementation-defined semantics.
6261 We used to just warn here and do a bitwise copy, but now
6262 cp_expr_size will abort if we try to do that.
6264 If the call appears in the context of a sizeof expression,
6265 it is not potentially-evaluated. */
6269 {
6273 else
6275 }
6276 }
6279 }
6281 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6283 tree
6285 {
6299 {
6300 /* Remove reference types so we don't ICE later on. */
6302 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
6308 }
6311 }
6313 /* TYPE has been given to va_arg. Apply the default conversions which
6314 would have happened when passed via ellipsis. Return the promoted
6315 type, or the passed type if there is no change. */
6317 tree
6319 {
6320 tree promote;
6322 /* Perform the array-to-pointer and function-to-pointer
6323 conversions. */
6331 }
6333 /* ARG is a default argument expression being passed to a parameter of
6334 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6335 zero-based argument number. Do any required conversions. Return
6336 the converted value. */
6339 void
6343 void
6347 tree
6349 tsubst_flags_t complain)
6350 {
6352 tree t;
6354 /* See through clones. */
6357 /* Detect recursion. */
6360 {
6364 }
6366 /* If the ARG is an unparsed default argument expression, the
6367 conversion cannot be performed. */
6369 {
6374 }
6381 /* Due to:
6383 [dcl.fct.default]
6385 The names in the expression are bound, and the semantic
6386 constraints are checked, at the point where the default
6387 expressions appears.
6389 we must not perform access checks here. */
6391 /* We must make a copy of ARG, in case subsequent processing
6392 alters any part of it. */
6395 {
6399 complain);
6400 }
6401 else
6402 {
6405 complain);
6407 }
6413 }
6415 /* Returns the type which will really be used for passing an argument of
6416 type TYPE. */
6418 tree
6420 {
6421 /* Pass classes with copy ctors by invisible reference. */
6423 {
6425 /* There are no other pointers to this temporary. */
6427 }
6436 }
6438 /* Actually perform the appropriate conversion. */
6440 tree
6442 {
6443 tree bitfield_type;
6445 /* If VAL is a bitfield, then -- since it has already been converted
6446 to TYPE -- it cannot have a precision greater than TYPE.
6448 If it has a smaller precision, we must widen it here. For
6449 example, passing "int f:3;" to a function expecting an "int" will
6450 not result in any conversion before this point.
6452 If the precision is the same we must not risk widening. For
6453 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6454 often have type "int", even though the C++ type for the field is
6455 "long long". If the value is being passed to a function
6456 expecting an "int", then no conversions will be required. But,
6457 if we call convert_bitfield_to_declared_type, the bitfield will
6458 be converted to "long long". */
6465 ;
6466 /* Pass classes with copy ctors by invisible reference. */
6477 {
6486 }
6488 }
6490 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6491 which no conversions at all should be done. This is true for some
6492 builtins which don't act like normal functions. */
6494 static bool
6496 {
6499 {
6509 }
6512 }
6514 /* Returns the decl of the dispatcher function if FN is a function version. */
6516 tree
6518 {
6528 {
6532 }
6537 }
6539 /* fn is a function version dispatcher that is marked used. Mark all the
6540 semantically identical function versions it will dispatch as used. */
6542 void
6544 {
6561 /* All semantically identical versions are chained. Traverse and mark each
6562 one of them as used. */
6565 {
6568 }
6569 }
6571 /* Subroutine of the various build_*_call functions. Overload resolution
6572 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6573 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6574 bitmask of various LOOKUP_* flags which apply to the call itself. */
6576 static tree
6578 {
6586 tree val;
6595 /* In a template, there is no need to perform all of the work that
6596 is normally done. We are only interested in the type of the call
6597 expression, i.e., the return type of the function. Any semantic
6598 errors will be deferred until the template is instantiated. */
6600 {
6602 tree return_type;
6610 else
6611 {
6614 tree arg;
6622 }
6632 }
6634 /* Give any warnings we noticed during overload resolution. */
6636 {
6640 }
6642 /* Make =delete work with SFINAE. */
6647 {
6648 tree access_fn;
6649 /* If FN is a template function, two cases must be considered.
6650 For example:
6652 struct A {
6653 protected:
6654 template <class T> void f();
6655 };
6656 template <class T> struct B {
6657 protected:
6658 void g();
6659 };
6660 struct C : A, B<int> {
6661 using A::f; // #1
6662 using B<int>::g; // #2
6663 };
6665 In case #1 where `A::f' is a member template, DECL_ACCESS is
6666 recorded in the primary template but not in its specialization.
6667 We check access of FN using its primary template.
6669 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
6670 because it is a member of class template B, DECL_ACCESS is
6671 recorded in the specialization `B<int>::g'. We cannot use its
6672 primary template because `B<T>::g' and `B<int>::g' may have
6673 different access. */
6677 else
6682 }
6684 /* If we're checking for implicit delete, don't bother with argument
6685 conversions. */
6687 {
6689 {
6693 }
6697 /* Reject bad conversions now. */
6699 /* else continue to get conversion error. */
6700 }
6702 /* Find maximum size of vector to hold converted arguments. */
6709 /* The implicit parameters to a constructor are not considered by overload
6710 resolution, and must be of the proper type. */
6712 {
6714 {
6717 }
6718 else
6719 {
6722 }
6724 /* We should never try to call the abstract constructor. */
6728 {
6732 }
6733 }
6734 /* Bypass access control for 'this' parameter. */
6736 {
6739 ? first_arg
6742 tree converted_arg;
6743 tree base_binfo;
6746 {
6750 else
6752 }
6754 /* See if the function member or the whole class type is declared
6755 final and the call can be devirtualized. */
6760 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
6761 X is called for an object that is not of type X, or of a type
6762 derived from X, the behavior is undefined.
6764 So we can assume that anything passed as 'this' is non-null, and
6765 optimize accordingly. */
6767 /* Convert to the base in which the function was declared. */
6770 arg,
6773 /* Check that the base class is accessible. */
6779 /* If fn was found by a using declaration, the conversion path
6780 will be to the derived class, not the base declaring fn. We
6781 must convert from derived to base. */
6792 else
6796 }
6801 {
6808 /* If the argument is NULL and used to (implicitly) instantiate a
6809 template function (and bind one of the template arguments to
6810 the type of 'long int'), we don't want to warn about passing NULL
6811 to non-pointer argument.
6812 For example, if we have this template function:
6814 template<typename T> void func(T x) {}
6816 we want to warn (when -Wconversion is enabled) in this case:
6818 void foo() {
6819 func<int>(NULL);
6820 }
6822 but not in this case:
6824 void foo() {
6825 func(NULL);
6826 }
6827 */
6834 /* Warn about initializer_list deduction that isn't currently in the
6835 working draft. */
6837 && flag_deduce_init_list
6841 {
6854 {
6861 }
6862 }
6865 conversion_warning
6866 ? complain
6872 else
6874 }
6876 /* Default arguments */
6878 {
6884 complain);
6885 }
6887 /* Ellipsis */
6889 {
6892 /* Do no conversions for magic varargs. */
6894 else
6897 }
6904 /* Avoid actually calling copy constructors and copy assignment operators,
6905 if possible. */
6912 {
6913 tree targ;
6915 tree fa;
6918 /* Pull out the real argument, disregarding const-correctness. */
6924 {
6929 }
6930 else
6935 else
6938 /* [class.copy]: the copy constructor is implicitly defined even if
6939 the implementation elided its use. */
6941 {
6944 }
6946 /* If we're creating a temp and we already have one, don't create a
6947 new one. If we're not creating a temp but we get one, use
6948 INIT_EXPR to collapse the temp into our target. Otherwise, if the
6949 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6950 temp or an INIT_EXPR otherwise. */
6953 {
6958 }
6960 {
6962 complain));
6966 }
6967 }
6971 {
6972 tree to = stabilize_reference
6979 {
6980 /* Avoid copying empty classes. */
6985 }
6987 {
6990 }
6991 else
6992 {
6993 /* We must only copy the non-tail padding parts. */
7001 build_index_type
7010 }
7013 }
7018 /* FIXME handle trivial default constructor, too. */
7020 /* For calls to a multi-versioned function, overload resolution
7021 returns the function with the highest target priority, that is,
7022 the version that will checked for dispatching first. If this
7023 version is inlinable, a direct call to this version can be made
7024 otherwise the call should go through the dispatcher. */
7028 {
7034 }
7040 {
7041 tree t;
7047 /* Warn about deprecated virtual functions now, since we're about
7048 to throw away the decl. */
7053 complain);
7059 else
7062 }
7063 else
7064 {
7068 }
7071 }
7073 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7074 This function performs no overload resolution, conversion, or other
7075 high-level operations. */
7077 tree
7079 tsubst_flags_t complain)
7080 {
7081 tree fndecl;
7084 /* Remember roughly where this call is. */
7091 /* Check that arguments to builtin functions match the expectations. */
7098 /* Some built-in function calls will be evaluated at compile-time in
7099 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7100 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7103 && current_function_decl
7119 }
7123 /* Make an expression which yields the address of the Java interface
7124 method FN. This is achieved by generating a call to libjava's
7125 _Jv_LookupInterfaceMethodIdx(). */
7127 static tree
7129 {
7135 {
7139 java_iface_lookup_fn
7142 }
7144 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7145 This is the first entry in the vtable. */
7147 tf_warning_or_error),
7148 integer_zero_node);
7150 /* Get the java.lang.Class pointer for the interface being called. */
7155 {
7157 iface);
7159 }
7163 /* Determine the itable index of FN. */
7166 {
7171 i++;
7172 }
7177 java_iface_lookup_fn);
7180 }
7182 /* Returns the value to use for the in-charge parameter when making a
7183 call to a function with the indicated NAME.
7185 FIXME:Can't we find a neater way to do this mapping? */
7187 tree
7189 {
7200 /* This function should only be called with one of the names listed
7201 above. */
7204 }
7206 /* Build a call to a constructor, destructor, or an assignment
7207 operator for INSTANCE, an expression with class type. NAME
7208 indicates the special member function to call; *ARGS are the
7209 arguments. ARGS may be NULL. This may change ARGS. BINFO
7210 indicates the base of INSTANCE that is to be passed as the `this'
7211 parameter to the member function called.
7213 FLAGS are the LOOKUP_* flags to use when processing the call.
7215 If NAME indicates a complete object constructor, INSTANCE may be
7216 NULL_TREE. In this case, the caller will call build_cplus_new to
7217 store the newly constructed object into a VAR_DECL. */
7219 tree
7222 {
7223 tree fns;
7224 /* The type of the subobject to be constructed or destroyed. */
7225 tree class_type;
7227 tree ret;
7236 {
7237 /* Resolve the name. */
7242 }
7248 /* Handle the special case where INSTANCE is NULL_TREE. */
7250 {
7253 }
7254 else
7255 {
7261 /* Convert to the base class, if necessary. */
7264 {
7266 /* For constructors and destructors, either the base is
7267 non-virtual, or it is virtual but we are doing the
7268 conversion from a constructor or destructor for the
7269 complete object. In either case, we can convert
7270 statically. */
7272 else
7273 /* However, for assignment operators, we must convert
7274 dynamically if the base is virtual. */
7277 }
7278 }
7284 /* When making a call to a constructor or destructor for a subobject
7285 that uses virtual base classes, pass down a pointer to a VTT for
7286 the subobject. */
7290 {
7291 tree vtt;
7292 tree sub_vtt;
7294 /* If the current function is a complete object constructor
7295 or destructor, then we fetch the VTT directly.
7296 Otherwise, we look it up using the VTT we were given. */
7304 current_vtt_parm,
7305 vtt);
7308 else
7312 {
7315 }
7318 }
7323 complain);
7329 }
7331 /* Return the NAME, as a C string. The NAME indicates a function that
7332 is a member of TYPE. *FREE_P is set to true if the caller must
7333 free the memory returned.
7335 Rather than go through all of this, we should simply set the names
7336 of constructors and destructors appropriately, and dispense with
7337 ctor_identifier, dtor_identifier, etc. */
7341 {
7344 /* Assume that we will not allocate memory. */
7346 /* Constructors and destructors are special. */
7348 {
7349 pretty_name
7351 /* For a destructor, add the '~'. */
7355 {
7357 /* Remember that we need to free the memory allocated. */
7359 }
7360 }
7362 {
7365 TFF_PLAIN_IDENTIFIER),
7366 NULL);
7367 /* Remember that we need to free the memory allocated. */
7369 }
7370 else
7374 }
7376 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7377 be set, upon return, to the function called. ARGS may be NULL.
7378 This may change ARGS. */
7380 static tree
7384 {
7388 tree access_binfo;
7389 tree optype;
7391 tree instance_ptr;
7392 tree name;
7395 tree call;
7396 tree fn;
7399 tree orig_instance;
7400 tree orig_fns;
7406 /* We don't know what function we're going to call, yet. */
7415 {
7419 }
7424 /* Dismantle the baselink to collect all the information we need. */
7431 {
7435 }
7446 {
7451 }
7454 /* Under DR 147 A::A() is an invalid constructor call,
7455 not a functional cast. */
7457 {
7467 complain);
7469 }
7471 /* Figure out whether to skip the first argument for the error
7472 message we will display to users if an error occurs. We don't
7473 want to display any compiler-generated arguments. The "this"
7474 pointer hasn't been added yet. However, we must remove the VTT
7475 pointer if this is a call to a base-class constructor or
7476 destructor. */
7479 {
7480 /* Callers should explicitly indicate whether they want to construct
7481 the complete object or just the part without virtual bases. */
7483 /* Similarly for destructors. */
7485 /* Remove the VTT pointer, if present. */
7489 }
7491 /* Process the argument list. */
7493 {
7497 }
7501 /* It's OK to call destructors and constructors on cv-qualified objects.
7502 Therefore, convert the INSTANCE_PTR to the unqualified type, if
7503 necessary. */
7506 {
7510 }
7516 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7519 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7520 initializer, not T({ }). */
7524 {
7531 /* If the initializer list has no elements and T is a class type with
7532 a default constructor, the object is value-initialized. Handle
7533 this here so we don't need to handle it wherever we use
7534 build_special_member_call. */
7537 /* For a user-provided default constructor, use the normal
7538 mechanisms so that protected access works. */
7543 /* If BASETYPE is an aggregate, we need to do aggregate
7544 initialization. */
7549 {
7550 tree ob;
7557 }
7559 /* Otherwise go ahead with overload resolution. */
7564 }
7565 else
7566 {
7570 }
7575 {
7577 {
7584 else
7585 {
7588 tree arglist;
7599 }
7601 }
7603 }
7604 else
7605 {
7608 {
7611 tree arglist;
7614 {
7620 arglist);
7624 }
7626 }
7627 else
7628 {
7637 /* This is not an error, it is runtime undefined
7638 behavior. */
7640 "pure virtual %q#D called from constructor"
7642 fn);
7646 {
7649 fn);
7651 }
7652 else
7653 {
7654 /* Optimize away vtable lookup if we know that this
7655 function can't be overridden. We need to check if
7656 the context and the instance type are the same,
7657 actually FN might be defined in a different class
7658 type because of a using-declaration. In this case, we
7659 do not want to perform a non-virtual call. */
7661 && same_type_ignoring_top_level_qualifiers_p
7667 /* Now we know what function is being called. */
7670 /* Build the actual CALL_EXPR. */
7672 /* In an expression of the form `a->f()' where `f' turns
7673 out to be a static member function, `a' is
7674 none-the-less evaluated. */
7683 /* An explicit call of the form "x->~X()" has type
7684 "void". However, on platforms where destructors
7685 return "this" (i.e., those where
7686 targetm.cxx.cdtor_returns_this is true), such calls
7687 will appear to have a return value of pointer type
7688 to the low-level call machinery. We do not want to
7689 change the low-level machinery, since we want to be
7690 able to optimize "delete f()" on such platforms as
7691 "operator delete(~X(f()))" (rather than generating
7692 "t = f(), ~X(t), operator delete (t)"). */
7694 }
7695 }
7696 }
7699 {
7705 {
7708 }
7711 call = (build_min_non_dep_call_vec
7715 orig_args));
7720 }
7722 /* Free all the conversions we allocated. */
7729 }
7731 /* Wrapper for above. */
7733 tree
7737 {
7738 tree ret;
7744 }
7746 /* Returns true iff standard conversion sequence ICS1 is a proper
7747 subsequence of ICS2. */
7749 static bool
7751 {
7752 /* We can assume that a conversion of the same code
7753 between the same types indicates a subsequence since we only get
7754 here if the types we are converting from are the same. */
7761 {
7771 /* At this point, ICS1 cannot be a proper subsequence of
7772 ICS2. We can get a USER_CONV when we are comparing the
7773 second standard conversion sequence of two user conversion
7774 sequences. */
7784 }
7785 }
7787 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
7788 be any _TYPE nodes. */
7790 bool
7792 {
7796 /* We only allow proper derivation here. The DERIVED_FROM_P macro
7797 considers every class derived from itself. */
7800 }
7802 /* We build the ICS for an implicit object parameter as a pointer
7803 conversion sequence. However, such a sequence should be compared
7804 as if it were a reference conversion sequence. If ICS is the
7805 implicit conversion sequence for an implicit object parameter,
7806 modify it accordingly. */
7808 static void
7810 {
7812 {
7813 /* [over.match.funcs]
7815 For non-static member functions, the type of the
7816 implicit object parameter is "reference to cv X"
7817 where X is the class of which the function is a
7818 member and cv is the cv-qualification on the member
7819 function declaration. */
7821 tree reference_type;
7823 /* The `this' parameter is a pointer to a class type. Make the
7824 implicit conversion talk about a reference to that same class
7825 type. */
7838 }
7839 }
7841 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7842 and return the initial reference binding conversion. Otherwise,
7843 leave *ICS unchanged and return NULL. */
7847 {
7849 {
7854 }
7857 }
7859 /* Compare two implicit conversion sequences according to the rules set out in
7860 [over.ics.rank]. Return values:
7862 1: ics1 is better than ics2
7863 -1: ics2 is better than ics1
7864 0: ics1 and ics2 are indistinguishable */
7866 static int
7868 {
7869 tree from_type1;
7870 tree from_type2;
7871 tree to_type1;
7872 tree to_type2;
7879 /* REF_BINDING is nonzero if the result of the conversion sequence
7880 is a reference type. In that case REF_CONV is the reference
7881 binding conversion. */
7885 /* Handle implicit object parameters. */
7889 /* Handle reference parameters. */
7893 /* List-initialization sequence L1 is a better conversion sequence than
7894 list-initialization sequence L2 if L1 converts to
7895 std::initializer_list<X> for some X and L2 does not. */
7901 /* [over.ics.rank]
7903 When comparing the basic forms of implicit conversion sequences (as
7904 defined in _over.best.ics_)
7906 --a standard conversion sequence (_over.ics.scs_) is a better
7907 conversion sequence than a user-defined conversion sequence
7908 or an ellipsis conversion sequence, and
7910 --a user-defined conversion sequence (_over.ics.user_) is a
7911 better conversion sequence than an ellipsis conversion sequence
7912 (_over.ics.ellipsis_). */
7922 {
7923 /* Both ICS are bad. We try to make a decision based on what would
7924 have happened if they'd been good. This is not an extension,
7925 we'll still give an error when we build up the call; this just
7926 helps us give a more helpful error message. */
7935 /* We couldn't make up our minds; try to figure it out below. */
7936 }
7939 /* Both conversions are ellipsis conversions. */
7942 /* User-defined conversion sequence U1 is a better conversion sequence
7943 than another user-defined conversion sequence U2 if they contain the
7944 same user-defined conversion operator or constructor and if the sec-
7945 ond standard conversion sequence of U1 is better than the second
7946 standard conversion sequence of U2. */
7948 /* Handle list-conversion with the same code even though it isn't always
7949 ranked as a user-defined conversion and it doesn't have a second
7950 standard conversion sequence; it will still have the desired effect.
7951 Specifically, we need to do the reference binding comparison at the
7952 end of this function. */
7955 {
7971 {
7974 }
7975 else
7976 {
7977 /* For ambiguous or aggregate conversions, use the target type as
7978 a proxy for the conversion function. */
7981 }
7983 /* We can just fall through here, after setting up
7984 FROM_TYPE1 and FROM_TYPE2. */
7987 }
7988 else
7989 {
7993 /* We're dealing with two standard conversion sequences.
7995 [over.ics.rank]
7997 Standard conversion sequence S1 is a better conversion
7998 sequence than standard conversion sequence S2 if
8000 --S1 is a proper subsequence of S2 (comparing the conversion
8001 sequences in the canonical form defined by _over.ics.scs_,
8002 excluding any Lvalue Transformation; the identity
8003 conversion sequence is considered to be a subsequence of
8004 any non-identity conversion sequence */
8015 }
8017 /* One sequence can only be a subsequence of the other if they start with
8018 the same type. They can start with different types when comparing the
8019 second standard conversion sequence in two user-defined conversion
8020 sequences. */
8022 {
8027 }
8029 /* [over.ics.rank]
8031 Or, if not that,
8033 --the rank of S1 is better than the rank of S2 (by the rules
8034 defined below):
8036 Standard conversion sequences are ordered by their ranks: an Exact
8037 Match is a better conversion than a Promotion, which is a better
8038 conversion than a Conversion.
8040 Two conversion sequences with the same rank are indistinguishable
8041 unless one of the following rules applies:
8043 --A conversion that does not a convert a pointer, pointer to member,
8044 or std::nullptr_t to bool is better than one that does.
8046 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8047 so that we do not have to check it explicitly. */
8056 /* A conversion from scalar arithmetic type to complex is worse than a
8057 conversion between scalar arithmetic types. */
8064 {
8067 else
8069 }
8075 {
8080 }
8081 /* The rules for pointers to members A::* are just like the rules
8082 for pointers A*, except opposite: if B is derived from A then
8083 A::* converts to B::*, not vice versa. For that reason, we
8084 switch the from_ and to_ variables here. */
8091 {
8096 }
8101 {
8102 /* This was one of the pointer or pointer-like conversions.
8104 [over.ics.rank]
8106 --If class B is derived directly or indirectly from class A,
8107 conversion of B* to A* is better than conversion of B* to
8108 void*, and conversion of A* to void* is better than
8109 conversion of B* to void*. */
8112 {
8114 deref_from_type2))
8117 deref_from_type1))
8119 }
8122 {
8124 {
8126 {
8128 deref_to_type1))
8130 }
8131 /* We know that DEREF_TO_TYPE1 is `void' here. */
8133 deref_to_type2))
8135 }
8136 }
8139 {
8140 /* [over.ics.rank]
8142 --If class B is derived directly or indirectly from class A
8143 and class C is derived directly or indirectly from B,
8145 --conversion of C* to B* is better than conversion of C* to
8146 A*,
8148 --conversion of B* to A* is better than conversion of C* to
8149 A* */
8151 {
8153 deref_to_type2))
8156 deref_to_type1))
8158 }
8160 {
8162 deref_from_type1))
8165 deref_from_type2))
8167 }
8168 }
8169 }
8172 {
8175 /* [over.ics.rank]
8177 --binding of an expression of type C to a reference of type
8178 B& is better than binding an expression of type C to a
8179 reference of type A&
8181 --conversion of C to B is better than conversion of C to A, */
8184 {
8189 }
8190 }
8193 {
8196 /* [over.ics.rank]
8198 --binding of an expression of type B to a reference of type
8199 A& is better than binding an expression of type C to a
8200 reference of type A&,
8202 --conversion of B to A is better than conversion of C to A */
8205 {
8210 }
8211 }
8213 /* [over.ics.rank]
8215 --S1 and S2 differ only in their qualification conversion and yield
8216 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8217 qualification signature of type T1 is a proper subset of the cv-
8218 qualification signature of type T2 */
8222 {
8226 }
8228 /* [over.ics.rank]
8230 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8231 to an implicit object parameter, and either S1 binds an lvalue reference
8232 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
8233 reference to an rvalue and S2 binds an lvalue reference
8234 (C++0x draft standard, 13.3.3.2)
8236 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8237 types to which the references refer are the same type except for
8238 top-level cv-qualifiers, and the type to which the reference
8239 initialized by S2 refers is more cv-qualified than the type to
8240 which the reference initialized by S1 refers.
8242 DR 1328 [over.match.best]: the context is an initialization by
8243 conversion function for direct reference binding (13.3.1.6) of a
8244 reference to function type, the return type of F1 is the same kind of
8245 reference (i.e. lvalue or rvalue) as the reference being initialized,
8246 and the return type of F2 is not. */
8249 {
8256 {
8259 }
8264 }
8266 /* Neither conversion sequence is better than the other. */
8268 }
8270 /* The source type for this standard conversion sequence. */
8272 static tree
8274 {
8276 {
8281 }
8283 }
8285 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8286 a pointer to LOSER and re-running joust to produce the warning if WINNER
8287 is actually used. */
8289 static void
8291 {
8297 }
8299 /* Compare two candidates for overloading as described in
8300 [over.match.best]. Return values:
8302 1: cand1 is better than cand2
8303 -1: cand2 is better than cand1
8304 0: cand1 and cand2 are indistinguishable */
8306 static int
8308 tsubst_flags_t complain)
8309 {
8315 /* Candidates that involve bad conversions are always worse than those
8316 that don't. */
8322 /* If we have two pseudo-candidates for conversions to the same type,
8323 or two candidates for the same function, arbitrarily pick one. */
8328 /* Prefer a non-deleted function over an implicitly deleted move
8329 constructor or assignment operator. This differs slightly from the
8330 wording for issue 1402 (which says the move op is ignored by overload
8331 resolution), but this way produces better error messages. */
8335 {
8342 }
8344 /* a viable function F1
8345 is defined to be a better function than another viable function F2 if
8346 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8347 ICSi(F2), and then */
8349 /* for some argument j, ICSj(F1) is a better conversion sequence than
8350 ICSj(F2) */
8352 /* For comparing static and non-static member functions, we ignore
8353 the implicit object parameter of the non-static function. The
8354 standard says to pretend that the static function has an object
8355 parm, but that won't work with operator overloading. */
8358 {
8364 /* We're comparing a near-match list constructor and a near-match
8365 non-list constructor. Just treat them as unordered. */
8372 else
8373 {
8376 }
8377 }
8380 {
8386 {
8388 && warn_sign_promo
8400 {
8407 else
8412 {
8416 }
8417 else
8419 }
8422 {
8425 }
8427 }
8428 }
8430 /* warn about confusing overload resolution for user-defined conversions,
8431 either between a constructor and a conversion op, or between two
8432 conversion ops. */
8437 {
8443 else
8446 /* We don't want to complain about `X::operator T1 ()'
8447 beating `X::operator T2 () const', when T2 is a no less
8448 cv-qualified version of T1. */
8451 {
8456 {
8459 }
8462 }
8463 else
8469 {
8476 {
8478 }
8479 }
8480 else
8482 }
8487 /* DR 495 moved this tiebreaker above the template ones. */
8488 /* or, if not that,
8489 the context is an initialization by user-defined conversion (see
8490 _dcl.init_ and _over.match.user_) and the standard conversion
8491 sequence from the return type of F1 to the destination type (i.e.,
8492 the type of the entity being initialized) is a better conversion
8493 sequence than the standard conversion sequence from the return type
8494 of F2 to the destination type. */
8497 {
8501 }
8503 /* or, if not that,
8504 F1 is a non-template function and F2 is a template function
8505 specialization. */
8512 /* or, if not that,
8513 F1 and F2 are template functions and the function template for F1 is
8514 more specialized than the template for F2 according to the partial
8515 ordering rules. */
8518 {
8519 winner = more_specialized_fn
8522 /* [temp.func.order]: The presence of unused ellipsis and default
8523 arguments has no effect on the partial ordering of function
8524 templates. add_function_candidate() will not have
8525 counted the "this" argument for constructors. */
8529 }
8531 /* Check whether we can discard a builtin candidate, either because we
8532 have two identical ones or matching builtin and non-builtin candidates.
8534 (Pedantically in the latter case the builtin which matched the user
8535 function should not be added to the overload set, but we spot it here.
8537 [over.match.oper]
8538 ... the builtin candidates include ...
8539 - do not have the same parameter type list as any non-template
8540 non-member candidate. */
8544 {
8550 {
8552 /* Two built-in candidates; arbitrarily pick one. */
8555 /* cand1 is built-in; prefer cand2. */
8557 else
8558 /* cand2 is built-in; prefer cand1. */
8560 }
8561 }
8563 /* For candidates of a multi-versioned function, make the version with
8564 the highest priority win. This version will be checked for dispatching
8565 first. If this version can be inlined into the caller, the front-end
8566 will simply make a direct call to this function. */
8572 {
8578 /* Check if cand1->fn and cand2->fn are versions of the same function. It
8579 is possible that cand1->fn and cand2->fn are function versions but of
8580 different functions. Check types to see if they are versions of the same
8581 function. */
8584 {
8585 /* Always make the version with the higher priority, more
8586 specialized, win. */
8590 else
8592 }
8593 }
8595 /* If the two function declarations represent the same function (this can
8596 happen with declarations in multiple scopes and arg-dependent lookup),
8597 arbitrarily choose one. But first make sure the default args we're
8598 using match. */
8601 {
8608 {
8609 /* Don't crash if the fn is variadic. */
8614 }
8622 {
8625 {
8627 {
8629 {
8631 "default argument mismatch in "
8637 }
8638 else
8640 }
8641 else
8644 }
8647 }
8650 }
8652 tweak:
8654 /* Extension: If the worst conversion for one candidate is worse than the
8655 worst conversion for the other, take the first. */
8657 {
8662 {
8667 }
8673 {
8674 /* Don't choose a deleted function over ambiguity. */
8678 {
8680 "ISO C++ says that these are ambiguous, even "
8681 "though the worst conversion for the first is better than "
8685 }
8686 else
8689 }
8690 }
8694 }
8696 /* Given a list of candidates for overloading, find the best one, if any.
8697 This algorithm has a worst case of O(2n) (winner is last), and a best
8698 case of O(n/2) (totally ambiguous); much better than a sorting
8699 algorithm. */
8703 {
8708 /* Walk through the list once, comparing each current champ to the next
8709 candidate, knocking out a candidate or two with each comparison. */
8712 {
8716 else
8717 {
8719 {
8724 }
8725 else
8726 {
8729 }
8732 }
8733 }
8735 /* Make sure the champ is better than all the candidates it hasn't yet
8736 been compared to. */
8739 challenger != champ
8742 {
8746 }
8749 }
8751 /* Returns nonzero if things of type FROM can be converted to TO. */
8753 bool
8755 {
8757 }
8759 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
8761 bool
8763 tsubst_flags_t complain)
8764 {
8769 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8776 /* Free all the conversions we allocated. */
8780 }
8782 /* Like can_convert_arg, but allows dubious conversions as well. */
8784 bool
8786 tsubst_flags_t complain)
8787 {
8791 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8793 /* Try to perform the conversion. */
8796 /* Free all the conversions we allocated. */
8800 }
8802 /* Convert EXPR to TYPE. Return the converted expression.
8804 Note that we allow bad conversions here because by the time we get to
8805 this point we are committed to doing the conversion. If we end up
8806 doing a bad conversion, convert_like will complain. */
8808 tree
8811 {
8819 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8827 {
8829 {
8830 /* If expr has unknown type, then it is an overloaded function.
8831 Call instantiate_type to get good error messages. */
8836 else
8839 }
8841 }
8843 {
8844 /* In a template, we are only concerned about determining the
8845 type of non-dependent expressions, so we do not have to
8846 perform the actual conversion. But for initializers, we
8847 need to be able to perform it at instantiation
8848 (or fold_non_dependent_expr) time. */
8852 }
8853 else
8856 /* Free all the conversions we allocated. */
8860 }
8862 tree
8864 {
8866 LOOKUP_IMPLICIT);
8867 }
8869 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8870 permitted. If the conversion is valid, the converted expression is
8871 returned. Otherwise, NULL_TREE is returned, except in the case
8872 that TYPE is a class type; in that case, an error is issued. If
8873 C_CAST_P is true, then this direct-initialization is taking
8874 place as part of a static_cast being attempted as part of a C-style
8875 cast. */
8877 tree
8879 tree expr,
8881 tsubst_flags_t complain)
8882 {
8888 /* [dcl.init]
8890 If the destination type is a (possibly cv-qualified) class type:
8892 -- If the initialization is direct-initialization ...,
8893 constructors are considered. ... If no constructor applies, or
8894 the overload resolution is ambiguous, the initialization is
8895 ill-formed. */
8897 {
8903 }
8905 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8909 c_cast_p,
8913 else
8916 c_cast_p,
8917 complain);
8919 /* Free all the conversions we allocated. */
8923 }
8925 /* When initializing a reference that lasts longer than a full-expression,
8926 this special rule applies:
8928 [class.temporary]
8930 The temporary to which the reference is bound or the temporary
8931 that is the complete object to which the reference is bound
8932 persists for the lifetime of the reference.
8934 The temporaries created during the evaluation of the expression
8935 initializing the reference, except the temporary to which the
8936 reference is bound, are destroyed at the end of the
8937 full-expression in which they are created.
8939 In that case, we store the converted expression into a new
8940 VAR_DECL in a new scope.
8942 However, we want to be careful not to create temporaries when
8943 they are not required. For example, given:
8945 struct B {};
8946 struct D : public B {};
8947 D f();
8948 const B& b = f();
8950 there is no need to copy the return value from "f"; we can just
8951 extend its lifetime. Similarly, given:
8953 struct S {};
8954 struct T { operator S(); };
8955 T t;
8956 const S& s = t;
8958 we can extend the lifetime of the return value of the conversion
8959 operator.
8961 The next several functions are involved in this lifetime extension. */
8963 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
8964 reference is being bound to a temporary. Create and return a new
8965 VAR_DECL with the indicated TYPE; this variable will store the value to
8966 which the reference is bound. */
8968 tree
8970 {
8971 tree var;
8973 /* Create the variable. */
8976 /* Register the variable. */
8979 {
8980 /* Namespace-scope or local static; give it a mangled name. */
8981 /* FIXME share comdat with decl? */
8982 tree name;
8990 }
8991 else
8992 /* Create a new cleanup level if necessary. */
8996 }
8998 /* EXPR is the initializer for a variable DECL of reference or
8999 std::initializer_list type. Create, push and return a new VAR_DECL
9000 for the initializer so that it will live as long as DECL. Any
9001 cleanup for the new variable is returned through CLEANUP, and the
9002 code to initialize the new variable is returned through INITP. */
9004 static tree
9007 {
9008 tree init;
9009 tree type;
9010 tree var;
9012 /* Create the temporary variable. */
9016 /* If the rvalue is the result of a function call it will be
9017 a TARGET_EXPR. If it is some other construct (such as a
9018 member access expression where the underlying object is
9019 itself the result of a function call), turn it into a
9020 TARGET_EXPR here. It is important that EXPR be a
9021 TARGET_EXPR below since otherwise the INIT_EXPR will
9022 attempt to make a bitwise copy of EXPR to initialize
9023 VAR. */
9029 {
9033 }
9035 /* Recursively extend temps in this initializer. */
9039 /* Any reference temp has a non-trivial initializer. */
9042 /* If the initializer is constant, put it in DECL_INITIAL so we get
9043 static initialization and use in constant expressions. */
9046 {
9048 {
9049 /* 5.19 says that a constant expression can include an
9050 lvalue-rvalue conversion applied to "a glvalue of literal type
9051 that refers to a non-volatile temporary object initialized
9052 with a constant expression". Rather than try to communicate
9053 that this VAR_DECL is a temporary, just mark it constexpr.
9055 Currently this is only useful for initializer_list temporaries,
9056 since reference vars can't appear in constant expressions. */
9060 }
9063 }
9064 else
9065 /* Create the INIT_EXPR that will initialize the temporary
9066 variable. */
9069 {
9074 else
9075 {
9079 }
9081 /* We must be careful to destroy the temporary only
9082 after its initialization has taken place. If the
9083 initialization throws an exception, then the
9084 destructor should not be run. We cannot simply
9085 transform INIT into something like:
9087 (INIT, ({ CLEANUP_STMT; }))
9089 because emit_local_var always treats the
9090 initializer as a full-expression. Thus, the
9091 destructor would run too early; it would run at the
9092 end of initializing the reference variable, rather
9093 than at the end of the block enclosing the
9094 reference variable.
9096 The solution is to pass back a cleanup expression
9097 which the caller is responsible for attaching to
9098 the statement tree. */
9099 }
9100 else
9101 {
9104 {
9107 tls_aggregates);
9108 else
9110 static_aggregates);
9111 }
9112 }
9116 }
9118 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9119 initializing a variable of that TYPE. */
9121 tree
9124 {
9132 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9138 {
9140 {
9149 else
9153 }
9155 }
9159 /* Perform the conversion. */
9162 /* Free all the conversions we allocated. */
9166 }
9168 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9169 which is bound either to a reference or a std::initializer_list. */
9171 static tree
9173 {
9178 {
9182 }
9185 /* Deal with binding to a subobject. */
9189 {
9195 }
9197 }
9199 /* INIT is part of the initializer for DECL. If there are any
9200 reference or initializer lists being initialized, extend their
9201 lifetime to match that of DECL. */
9203 tree
9205 {
9212 {
9213 /* The temporary array underlying a std::initializer_list
9214 is handled like a reference temporary. */
9219 {
9223 }
9224 }
9226 {
9232 }
9235 }
9237 /* Returns true iff TYPE is some variant of std::initializer_list. */
9239 bool
9241 {
9242 /* Look through typedefs. */
9249 }
9251 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9252 will accept an argument list of a single std::initializer_list<T>. */
9254 bool
9256 {
9258 tree arg;
9270 /* There are more non-defaulted parms. */
9274 }