| blob | db8dd219ba8525006c1040508e9558fda87e69ad |
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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 /* High-level class interface. */
43 /* The various kinds of conversion. */
46 ck_identity,
47 ck_lvalue,
48 ck_qual,
49 ck_std,
50 ck_ptr,
51 ck_pmem,
52 ck_base,
53 ck_ref_bind,
54 ck_user,
55 ck_ambig,
56 ck_rvalue
59 /* The rank of the conversion. Order of the enumerals matters; better
60 conversions should come earlier in the list. */
63 cr_identity,
64 cr_exact,
65 cr_promotion,
66 cr_std,
67 cr_pbool,
68 cr_user,
69 cr_ellipsis,
70 cr_bad
73 /* An implicit conversion sequence, in the sense of [over.best.ics].
74 The first conversion to be performed is at the end of the chain.
75 That conversion is always a cr_identity conversion. */
79 /* The kind of conversion represented by this step. */
80 conversion_kind kind;
81 /* The rank of this conversion. */
82 conversion_rank rank;
87 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88 temporary should be created to hold the result of the
89 conversion. */
91 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92 copy constructor must be accessible, even though it is not being
93 used. */
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
98 /* The type of the expression resulting from the conversion. */
99 tree type;
101 /* The next conversion in the chain. Since the conversions are
102 arranged from outermost to innermost, the NEXT conversion will
103 actually be performed before this conversion. This variant is
104 used only when KIND is neither ck_identity nor ck_ambig. */
106 /* The expression at the beginning of the conversion chain. This
107 variant is used only if KIND is ck_identity or ck_ambig. */
108 tree expr;
110 /* The function candidate corresponding to this conversion
111 sequence. This field is only used if KIND is ck_user. */
113 };
115 #define CONVERSION_RANK(NODE) \
116 ((NODE)->bad_p ? cr_bad \
117 : (NODE)->ellipsis_p ? cr_ellipsis \
118 : (NODE)->user_conv_p ? cr_user \
119 : (NODE)->rank)
130 #define convert_like(CONV, EXPR) \
131 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
134 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
135 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
158 static void add_builtin_candidates
161 static void add_builtin_candidate
165 static void build_builtin_candidate
201 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
202 NAME can take many forms... */
204 bool
206 {
207 /* Just accept something we've already complained about. */
216 {
221 else
223 }
224 else
225 {
226 /* In the case of:
228 template <class T> struct S { ~S(); };
229 int i;
230 i.~S();
232 NAME will be a class template. */
235 }
240 }
242 /* We want the address of a function or method. We avoid creating a
243 pointer-to-member function. */
245 tree
247 {
250 /* We have to do these by hand to avoid real pointer to member
251 functions. */
253 {
255 {
259 }
261 }
262 else
266 }
268 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
269 POINTER_TYPE to those. Note, pointer to member function types
270 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
272 tree
274 {
277 tree tmp;
278 tree decl;
279 tree result_type;
280 tree fntype;
292 {
295 {
296 /* We invoke build_call directly for several library
297 functions. These may have been declared normally if
298 we're building libgcc, so we can't just check
299 DECL_ARTIFICIAL. */
304 }
305 }
306 else
309 /* We check both the decl and the type; a function may be known not to
310 throw without being declared throw(). */
324 /* Don't pass empty class objects by value. This is useful
325 for tags in STL, which are used to control overload resolution.
326 We don't need to handle other cases of copying empty classes. */
331 {
335 }
342 }
344 /* Build something of the form ptr->method (args)
345 or object.method (args). This can also build
346 calls to constructors, and find friends.
348 Member functions always take their class variable
349 as a pointer.
351 INSTANCE is a class instance.
353 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
355 PARMS help to figure out what that NAME really refers to.
357 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
358 down to the real instance type to use for access checking. We need this
359 information to get protected accesses correct.
361 FLAGS is the logical disjunction of zero or more LOOKUP_
362 flags. See cp-tree.h for more info.
364 If this is all OK, calls build_function_call with the resolved
365 member function.
367 This function must also handle being called to perform
368 initialization, promotion/coercion of arguments, and
369 instantiation of default parameters.
371 Note that NAME may refer to an instance variable name. If
372 `operator()()' is defined for the type of that field, then we return
373 that result. */
375 /* New overloading code. */
383 };
386 /* The FUNCTION_DECL that will be called if this candidate is
387 selected by overload resolution. */
388 tree fn;
389 /* The arguments to use when calling this function. */
390 tree args;
391 /* The implicit conversion sequences for each of the arguments to
392 FN. */
394 /* The number of implicit conversion sequences. */
396 /* If FN is a user-defined conversion, the standard conversion
397 sequence from the type returned by FN to the desired destination
398 type. */
401 /* If FN is a member function, the binfo indicating the path used to
402 qualify the name of FN at the call site. This path is used to
403 determine whether or not FN is accessible if it is selected by
404 overload resolution. The DECL_CONTEXT of FN will always be a
405 (possibly improper) base of this binfo. */
406 tree access_path;
407 /* If FN is a non-static member function, the binfo indicating the
408 subobject to which the `this' pointer should be converted if FN
409 is selected by overload resolution. The type pointed to the by
410 the `this' pointer must correspond to the most derived class
411 indicated by the CONVERSION_PATH. */
412 tree conversion_path;
413 tree template_decl;
416 };
418 /* Returns true iff T is a null pointer constant in the sense of
419 [conv.ptr]. */
421 bool
423 {
424 /* [conv.ptr]
426 A null pointer constant is an integral constant expression
427 (_expr.const_) rvalue of integer type that evaluates to zero. */
432 {
436 }
438 }
440 /* Returns nonzero if PARMLIST consists of only default parms and/or
441 ellipsis. */
443 bool
445 {
451 }
453 /* Allocate N bytes of memory from the conversion obstack. The memory
454 is zeroed before being returned. */
458 {
461 {
464 }
468 }
470 /* Dynamically allocate a conversion. */
474 {
479 }
481 #ifdef ENABLE_CHECKING
483 /* Make sure that all memory on the conversion obstack has been
484 freed. */
486 void
488 {
492 }
496 /* Dynamically allocate an array of N conversions. */
500 {
502 }
506 {
510 /* We can't use buildl1 here because CODE could be USER_CONV, which
511 takes two arguments. In that case, the caller is responsible for
512 filling in the second argument. */
518 {
534 }
540 }
542 /* Build a representation of the identity conversion from EXPR to
543 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
547 {
555 }
557 /* Converting from EXPR to TYPE was ambiguous in the sense that there
558 were multiple user-defined conversions to accomplish the job.
559 Build a conversion that indicates that ambiguity. */
563 {
571 }
573 tree
575 {
579 }
581 /* Returns the standard conversion path (see [conv]) from type FROM to type
582 TO, if any. For proper handling of null pointer constants, you must
583 also pass the expression EXPR to convert from. If C_CAST_P is true,
584 this conversion is coming from a C-style cast. */
589 {
596 {
599 }
605 {
610 }
617 {
621 }
623 {
627 }
629 {
631 {
632 tree bitfield_type;
636 }
638 }
640 /* Allow conversion between `__complex__' data types. */
642 {
643 /* The standard conversion sequence to convert FROM to TO is
644 the standard conversion sequence to perform componentwise
645 conversion. */
650 {
653 }
654 else
658 }
668 {
669 /* For backwards brain damage compatibility, allow interconversion of
670 pointers and integers with a pedwarn. */
673 }
675 {
676 /* For backwards brain damage compatibility, allow interconversion of
677 enums and integers with a pedwarn. */
680 }
683 {
684 tree to_pointee;
685 tree from_pointee;
690 ;
694 {
695 from = build_pointer_type
699 }
701 {
706 && (same_type_ignoring_top_level_qualifiers_p
709 {
713 }
716 }
719 /* [conv.ptr]
721 An rvalue of type "pointer to cv D," where D is a
722 class type, can be converted to an rvalue of type
723 "pointer to cv B," where B is a base class (clause
724 _class.derived_) of D. If B is an inaccessible
725 (clause _class.access_) or ambiguous
726 (_class.member.lookup_) base class of D, a program
727 that necessitates this conversion is ill-formed.
728 Therefore, we use DERIVED_FROM_P, and do not check
729 access or uniqueness. */
731 /* If FROM is not yet complete, then we must be parsing
732 the body of a class. We know what's derived from
733 what, but we can't actually perform a
734 derived-to-base conversion. For example, in:
736 struct D : public B {
737 static const int i = sizeof((B*)(D*)0);
738 };
740 the D*-to-B* conversion is a reinterpret_cast, not a
741 static_cast. */
743 {
744 from =
750 }
753 {
756 }
757 else
758 {
761 }
766 /* In a C-style cast, we ignore CV-qualification because we
767 are allowed to perform a static_cast followed by a
768 const_cast. */
773 /* converting from string constant to char *. */
776 {
779 }
780 else
784 }
786 {
806 }
808 {
809 /* [conv.bool]
811 An rvalue of arithmetic, enumeration, pointer, or pointer to
812 member type can be converted to an rvalue of type bool. */
817 {
825 }
828 }
829 /* We don't check for ENUMERAL_TYPE here because there are no standard
830 conversions to enum type. */
833 {
838 /* Give this a better rank if it's a promotion. */
842 }
849 {
853 /* The derived-to-base conversion indicates the initialization
854 of a parameter with base type from an object of a derived
855 type. A temporary object is created to hold the result of
856 the conversion. */
858 }
859 else
863 }
865 /* Returns nonzero if T1 is reference-related to T2. */
867 static bool
869 {
873 /* [dcl.init.ref]
875 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
876 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
877 of T2. */
881 }
883 /* Returns nonzero if T1 is reference-compatible with T2. */
885 static bool
887 {
888 /* [dcl.init.ref]
890 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
891 reference-related to T2 and cv1 is the same cv-qualification as,
892 or greater cv-qualification than, cv2. */
895 }
897 /* Determine whether or not the EXPR (of class type S) can be
898 converted to T as in [over.match.ref]. */
902 {
903 tree conversions;
904 tree arglist;
906 tree reference_type;
915 /* [over.match.ref]
917 Assuming that "cv1 T" is the underlying type of the reference
918 being initialized, and "cv S" is the type of the initializer
919 expression, with S a class type, the candidate functions are
920 selected as follows:
922 --The conversion functions of S and its base classes are
923 considered. Those that are not hidden within S and yield type
924 "reference to cv2 T2", where "cv1 T" is reference-compatible
925 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
927 The argument list has one argument, which is the initializer
928 expression. */
932 /* Conceptually, we should take the address of EXPR and put it in
933 the argument list. Unfortunately, however, that can result in
934 error messages, which we should not issue now because we are just
935 trying to find a conversion operator. Therefore, we use NULL,
936 cast to the appropriate type. */
943 {
947 {
953 /* If this is a template function, try to get an exact
954 match. */
956 {
959 NULL_TREE,
960 arglist,
961 reference_type,
964 LOOKUP_NORMAL,
965 DEDUCE_CONV);
968 {
969 /* Now, see if the conversion function really returns
970 an lvalue of the appropriate type. From the
971 point of view of unification, simply returning an
972 rvalue of the right type is good enough. */
977 {
980 }
981 }
982 }
988 LOOKUP_NORMAL);
991 {
993 /* Build a standard conversion sequence indicating the
994 binding from the reference type returned by the
995 function to the desired REFERENCE_TYPE. */
996 identity_conv
999 NULL_TREE);
1000 cand->second_conv
1001 = (direct_reference_binding
1004 }
1005 }
1007 }
1010 /* If none of the conversion functions worked out, let our caller
1011 know. */
1019 /* Now that we know that this is the function we're going to use fix
1020 the dummy first argument. */
1025 /* Build a user-defined conversion sequence representing the
1026 conversion. */
1032 /* Merge it with the standard conversion sequence from the
1033 conversion function's return type to the desired type. */
1040 }
1042 /* A reference of the indicated TYPE is being bound directly to the
1043 expression represented by the implicit conversion sequence CONV.
1044 Return a conversion sequence for this binding. */
1048 {
1049 tree t;
1056 /* [over.ics.rank]
1058 When a parameter of reference type binds directly
1059 (_dcl.init.ref_) to an argument expression, the implicit
1060 conversion sequence is the identity conversion, unless the
1061 argument expression has a type that is a derived class of the
1062 parameter type, in which case the implicit conversion sequence is
1063 a derived-to-base Conversion.
1065 If the parameter binds directly to the result of applying a
1066 conversion function to the argument expression, the implicit
1067 conversion sequence is a user-defined conversion sequence
1068 (_over.ics.user_), with the second standard conversion sequence
1069 either an identity conversion or, if the conversion function
1070 returns an entity of a type that is a derived class of the
1071 parameter type, a derived-to-base conversion. */
1073 {
1074 /* Represent the derived-to-base conversion. */
1076 /* We will actually be binding to the base-class subobject in
1077 the derived class, so we mark this conversion appropriately.
1078 That way, convert_like knows not to generate a temporary. */
1080 }
1082 }
1084 /* Returns the conversion path from type FROM to reference type TO for
1085 purposes of reference binding. For lvalue binding, either pass a
1086 reference type to FROM or an lvalue expression to EXPR. If the
1087 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1088 the conversion returned. */
1092 {
1101 {
1106 }
1109 {
1110 /* Anything with reference type is an lvalue. */
1113 }
1117 /* Figure out whether or not the types are reference-related and
1118 reference compatible. We have do do this after stripping
1119 references from FROM. */
1124 {
1125 /* [dcl.init.ref]
1127 If the initializer expression
1129 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1130 is reference-compatible with "cv2 T2,"
1132 the reference is bound directly to the initializer expression
1133 lvalue. */
1138 /* For the purposes of overload resolution, we ignore the fact
1139 this expression is a bitfield or packed field. (In particular,
1140 [over.ics.ref] says specifically that a function with a
1141 non-const reference parameter is viable even if the
1142 argument is a bitfield.)
1144 However, when we actually call the function we must create
1145 a temporary to which to bind the reference. If the
1146 reference is volatile, or isn't const, then we cannot make
1147 a temporary, so we just issue an error when the conversion
1148 actually occurs. */
1152 }
1154 {
1155 /* [dcl.init.ref]
1157 If the initializer expression
1159 -- has a class type (i.e., T2 is a class type) can be
1160 implicitly converted to an lvalue of type "cv3 T3," where
1161 "cv1 T1" is reference-compatible with "cv3 T3". (this
1162 conversion is selected by enumerating the applicable
1163 conversion functions (_over.match.ref_) and choosing the
1164 best one through overload resolution. (_over.match_).
1166 the reference is bound to the lvalue result of the conversion
1167 in the second case. */
1171 }
1173 /* From this point on, we conceptually need temporaries, even if we
1174 elide them. Only the cases above are "direct bindings". */
1178 /* [over.ics.rank]
1180 When a parameter of reference type is not bound directly to an
1181 argument expression, the conversion sequence is the one required
1182 to convert the argument expression to the underlying type of the
1183 reference according to _over.best.ics_. Conceptually, this
1184 conversion sequence corresponds to copy-initializing a temporary
1185 of the underlying type with the argument expression. Any
1186 difference in top-level cv-qualification is subsumed by the
1187 initialization itself and does not constitute a conversion. */
1189 /* [dcl.init.ref]
1191 Otherwise, the reference shall be to a non-volatile const type. */
1195 /* [dcl.init.ref]
1197 If the initializer expression is an rvalue, with T2 a class type,
1198 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1199 is bound in one of the following ways:
1201 -- The reference is bound to the object represented by the rvalue
1202 or to a sub-object within that object.
1204 -- ...
1206 We use the first alternative. The implicit conversion sequence
1207 is supposed to be same as we would obtain by generating a
1208 temporary. Fortunately, if the types are reference compatible,
1209 then this is either an identity conversion or the derived-to-base
1210 conversion, just as for direct binding. */
1212 {
1218 }
1220 /* [dcl.init.ref]
1222 Otherwise, a temporary of type "cv1 T1" is created and
1223 initialized from the initializer expression using the rules for a
1224 non-reference copy initialization. If T1 is reference-related to
1225 T2, cv1 must be the same cv-qualification as, or greater
1226 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1231 flags);
1236 /* This reference binding, unlike those above, requires the
1237 creation of a temporary. */
1241 }
1243 /* Returns the implicit conversion sequence (see [over.ics]) from type
1244 FROM to type TO. The optional expression EXPR may affect the
1245 conversion. FLAGS are the usual overloading flags. Only
1246 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1247 conversion is coming from a C-style cast. */
1252 {
1261 else
1271 {
1274 cand = build_user_type_conversion_1
1279 /* We used to try to bind a reference to a temporary here, but that
1280 is now handled by the recursive call to this function at the end
1281 of reference_binding. */
1283 }
1286 }
1288 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1289 functions. */
1297 {
1312 }
1314 /* Create an overload candidate for the function or method FN called with
1315 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1316 to implicit_conversion.
1318 CTYPE, if non-NULL, is the type we want to pretend this function
1319 comes from for purposes of overload resolution. */
1326 {
1331 tree orig_arglist;
1334 /* At this point we should not see any functions which haven't been
1335 explicitly declared, except for friend functions which will have
1336 been found using argument dependent lookup. */
1339 /* The `this', `in_chrg' and VTT arguments to constructors are not
1340 considered in overload resolution. */
1342 {
1346 }
1347 else
1353 /* 13.3.2 - Viable functions [over.match.viable]
1354 First, to be a viable function, a candidate function shall have enough
1355 parameters to agree in number with the arguments in the list.
1357 We need to check this first; otherwise, checking the ICSes might cause
1358 us to produce an ill-formed template instantiation. */
1362 {
1366 }
1371 /* Make sure there are default args for the rest of the parms. */
1378 /* Second, for F to be a viable function, there shall exist for each
1379 argument an implicit conversion sequence that converts that argument
1380 to the corresponding parameter of F. */
1386 {
1399 {
1402 /* The type of the implicit object parameter ('this') for
1403 overload resolution is not always the same as for the
1404 function itself; conversion functions are considered to
1405 be members of the class being converted, and functions
1406 introduced by a using-declaration are considered to be
1407 members of the class that uses them.
1409 Since build_over_call ignores the ICS for the `this'
1410 parameter, we can just change the parm type. */
1412 {
1413 parmtype
1417 }
1421 }
1422 else
1423 {
1426 }
1433 {
1436 }
1444 }
1446 out:
1449 }
1451 /* Create an overload candidate for the conversion function FN which will
1452 be invoked for expression OBJ, producing a pointer-to-function which
1453 will in turn be called with the argument list ARGLIST, and add it to
1454 CANDIDATES. FLAGS is passed on to implicit_conversion.
1456 Actually, we don't really care about FN; we care about the type it
1457 converts to. There may be multiple conversion functions that will
1458 convert to that type, and we rely on build_user_type_conversion_1 to
1459 choose the best one; so when we create our candidate, we record the type
1460 instead of the function. */
1465 {
1482 /* Don't bother looking up the same type twice. */
1487 {
1494 flags);
1500 else
1501 {
1504 }
1519 }
1529 }
1531 static void
1535 {
1549 {
1556 {
1558 /* We need something for printing the candidate. */
1560 }
1564 }
1566 /* For COND_EXPR we rearranged the arguments; undo that now. */
1568 {
1575 else
1577 }
1583 viable);
1584 }
1586 static bool
1588 {
1590 }
1592 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1594 static bool
1596 {
1597 /* [over.built]
1599 In this section, the term promoted integral type is used to refer
1600 to those integral types which are preserved by integral promotion
1601 (including e.g. int and long but excluding e.g. char).
1602 Similarly, the term promoted arithmetic type refers to promoted
1603 integral types plus floating types. */
1607 }
1609 /* Create any builtin operator overload candidates for the operator in
1610 question given the converted operand types TYPE1 and TYPE2. The other
1611 args are passed through from add_builtin_candidates to
1612 build_builtin_candidate.
1614 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1615 If CODE is requires candidates operands of the same type of the kind
1616 of which TYPE1 and TYPE2 are, we add both candidates
1617 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1619 static void
1623 {
1625 {
1633 }
1636 {
1638 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1639 and VQ is either volatile or empty, there exist candidate operator
1640 functions of the form
1641 VQ T& operator++(VQ T&);
1642 T operator++(VQ T&, int);
1643 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1644 type other than bool, and VQ is either volatile or empty, there exist
1645 candidate operator functions of the form
1646 VQ T& operator--(VQ T&);
1647 T operator--(VQ T&, int);
1648 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1649 complete object type, and VQ is either volatile or empty, there exist
1650 candidate operator functions of the form
1651 T*VQ& operator++(T*VQ&);
1652 T*VQ& operator--(T*VQ&);
1653 T* operator++(T*VQ&, int);
1654 T* operator--(T*VQ&, int); */
1663 {
1666 }
1669 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1670 exist candidate operator functions of the form
1672 T& operator*(T*);
1674 8 For every function type T, there exist candidate operator functions of
1675 the form
1676 T& operator*(T*); */
1685 /* 9 For every type T, there exist candidate operator functions of the form
1686 T* operator+(T*);
1688 10For every promoted arithmetic type T, there exist candidate operator
1689 functions of the form
1690 T operator+(T);
1691 T operator-(T); */
1701 /* 11For every promoted integral type T, there exist candidate operator
1702 functions of the form
1703 T operator~(T); */
1710 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1711 is the same type as C2 or is a derived class of C2, T is a complete
1712 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1713 there exist candidate operator functions of the form
1714 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1715 where CV12 is the union of CV1 and CV2. */
1720 {
1728 }
1731 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1732 didate operator functions of the form
1733 LR operator*(L, R);
1734 LR operator/(L, R);
1735 LR operator+(L, R);
1736 LR operator-(L, R);
1737 bool operator<(L, R);
1738 bool operator>(L, R);
1739 bool operator<=(L, R);
1740 bool operator>=(L, R);
1741 bool operator==(L, R);
1742 bool operator!=(L, R);
1743 where LR is the result of the usual arithmetic conversions between
1744 types L and R.
1746 14For every pair of types T and I, where T is a cv-qualified or cv-
1747 unqualified complete object type and I is a promoted integral type,
1748 there exist candidate operator functions of the form
1749 T* operator+(T*, I);
1750 T& operator[](T*, I);
1751 T* operator-(T*, I);
1752 T* operator+(I, T*);
1753 T& operator[](I, T*);
1755 15For every T, where T is a pointer to complete object type, there exist
1756 candidate operator functions of the form112)
1757 ptrdiff_t operator-(T, T);
1759 16For every pointer or enumeration type T, there exist candidate operator
1760 functions of the form
1761 bool operator<(T, T);
1762 bool operator>(T, T);
1763 bool operator<=(T, T);
1764 bool operator>=(T, T);
1765 bool operator==(T, T);
1766 bool operator!=(T, T);
1768 17For every pointer to member type T, there exist candidate operator
1769 functions of the form
1770 bool operator==(T, T);
1771 bool operator!=(T, T); */
1777 {
1780 }
1793 {
1796 }
1798 {
1801 }
1802 /* Fall through. */
1816 {
1819 }
1821 {
1824 }
1832 {
1835 }
1837 {
1840 }
1843 /* 18For every pair of promoted integral types L and R, there exist candi-
1844 date operator functions of the form
1845 LR operator%(L, R);
1846 LR operator&(L, R);
1847 LR operator^(L, R);
1848 LR operator|(L, R);
1849 L operator<<(L, R);
1850 L operator>>(L, R);
1851 where LR is the result of the usual arithmetic conversions between
1852 types L and R. */
1864 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1865 type, VQ is either volatile or empty, and R is a promoted arithmetic
1866 type, there exist candidate operator functions of the form
1867 VQ L& operator=(VQ L&, R);
1868 VQ L& operator*=(VQ L&, R);
1869 VQ L& operator/=(VQ L&, R);
1870 VQ L& operator+=(VQ L&, R);
1871 VQ L& operator-=(VQ L&, R);
1873 20For every pair T, VQ), where T is any type and VQ is either volatile
1874 or empty, there exist candidate operator functions of the form
1875 T*VQ& operator=(T*VQ&, T*);
1877 21For every pair T, VQ), where T is a pointer to member type and VQ is
1878 either volatile or empty, there exist candidate operator functions of
1879 the form
1880 VQ T& operator=(VQ T&, T);
1882 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1883 unqualified complete object type, VQ is either volatile or empty, and
1884 I is a promoted integral type, there exist candidate operator func-
1885 tions of the form
1886 T*VQ& operator+=(T*VQ&, I);
1887 T*VQ& operator-=(T*VQ&, I);
1889 23For every triple L, VQ, R), where L is an integral or enumeration
1890 type, VQ is either volatile or empty, and R is a promoted integral
1891 type, there exist candidate operator functions of the form
1893 VQ L& operator%=(VQ L&, R);
1894 VQ L& operator<<=(VQ L&, R);
1895 VQ L& operator>>=(VQ L&, R);
1896 VQ L& operator&=(VQ L&, R);
1897 VQ L& operator^=(VQ L&, R);
1898 VQ L& operator|=(VQ L&, R); */
1902 {
1906 {
1909 }
1935 {
1938 }
1943 }
1948 /* [over.built]
1950 For every pair of promoted arithmetic types L and R, there
1951 exist candidate operator functions of the form
1953 LR operator?(bool, L, R);
1955 where LR is the result of the usual arithmetic conversions
1956 between types L and R.
1958 For every type T, where T is a pointer or pointer-to-member
1959 type, there exist candidate operator functions of the form T
1960 operator?(bool, T, T); */
1964 /* That's OK. */
1967 /* Otherwise, the types should be pointers. */
1972 /* We don't check that the two types are the same; the logic
1973 below will actually create two candidates; one in which both
1974 parameter types are TYPE1, and one in which both parameter
1975 types are TYPE2. */
1980 }
1982 /* If we're dealing with two pointer types or two enumeral types,
1983 we need candidates for both of them. */
1992 {
1993 build_builtin_candidate
1995 build_builtin_candidate
1998 }
2000 build_builtin_candidate
2002 }
2004 tree
2006 {
2012 }
2014 /* There are three conditions of builtin candidates:
2016 1) bool-taking candidates. These are the same regardless of the input.
2017 2) pointer-pair taking candidates. These are generated for each type
2018 one of the input types converts to.
2019 3) arithmetic candidates. According to the standard, we should generate
2020 all of these, but I'm trying not to...
2022 Here we generate a superset of the possible candidates for this particular
2023 case. That is a subset of the full set the standard defines, plus some
2024 other cases which the standard disallows. add_builtin_candidate will
2025 filter out the invalid set. */
2027 static void
2031 {
2035 /* TYPES[i] is the set of possible builtin-operator parameter types
2036 we will consider for the Ith argument. These are represented as
2037 a TREE_LIST; the TREE_VALUE of each node is the potential
2038 parameter type. */
2042 {
2045 else
2047 }
2050 {
2051 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2052 and VQ is either volatile or empty, there exist candidate operator
2053 functions of the form
2054 VQ T& operator++(VQ T&); */
2064 /* 24There also exist candidate operator functions of the form
2065 bool operator!(bool);
2066 bool operator&&(bool, bool);
2067 bool operator||(bool, bool); */
2070 build_builtin_candidate
2077 build_builtin_candidate
2095 /* Fall through. */
2099 }
2104 {
2106 ;
2108 {
2109 tree convs;
2117 {
2124 }
2130 {
2143 {
2149 }
2153 }
2154 }
2155 else
2156 {
2162 {
2168 }
2170 }
2171 }
2173 /* Run through the possible parameter types of both arguments,
2174 creating candidates with those parameter types. */
2176 {
2179 add_builtin_candidate
2182 else
2183 add_builtin_candidate
2186 }
2187 }
2190 /* If TMPL can be successfully instantiated as indicated by
2191 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2193 TMPL is the template. EXPLICIT_TARGS are any explicit template
2194 arguments. ARGLIST is the arguments provided at the call-site.
2195 The RETURN_TYPE is the desired type for conversion operators. If
2196 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2197 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2198 add_conv_candidate. */
2205 unification_kind_t strict)
2206 {
2212 tree fn;
2214 /* We don't do deduction on the in-charge parameter, the VTT
2215 parameter or 'this'. */
2225 args_without_in_chrg,
2235 /* In [class.copy]:
2237 A member function template is never instantiated to perform the
2238 copy of a class object to an object of its class type.
2240 It's a little unclear what this means; the standard explicitly
2241 does allow a template to be used to copy a class. For example,
2242 in:
2244 struct A {
2245 A(A&);
2246 template <class T> A(const T&);
2247 };
2248 const A f ();
2249 void g () { A a (f ()); }
2251 the member template will be used to make the copy. The section
2252 quoted above appears in the paragraph that forbids constructors
2253 whose only parameter is (a possibly cv-qualified variant of) the
2254 class type, and a logical interpretation is that the intent was
2255 to forbid the instantiation of member templates which would then
2256 have that form. */
2258 {
2261 ctype))
2263 }
2266 /* Aha, this is a conversion function. */
2269 else
2274 /* This situation can occur if a member template of a template
2275 class is specialized. Then, instantiate_template might return
2276 an instantiation of the specialization, in which case the
2277 DECL_TI_TEMPLATE field will point at the original
2278 specialization. For example:
2280 template <class T> struct S { template <class U> void f(U);
2281 template <> void f(int) {}; };
2282 S<double> sd;
2283 sd.f(3);
2285 Here, TMPL will be template <class U> S<double>::f(U).
2286 And, instantiate template will give us the specialization
2287 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2288 for this will point at template <class T> template <> S<T>::f(int),
2289 so that we can find the definition. For the purposes of
2290 overload resolution, however, we want the original TMPL. */
2292 else
2296 }
2303 unification_kind_t strict)
2304 {
2305 return
2310 }
2317 {
2318 return
2322 }
2324 /* The CANDS are the set of candidates that were considered for
2325 overload resolution. Return the set of viable candidates. If none
2326 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2327 is true if a candidate should be considered viable only if it is
2328 strictly viable. */
2334 {
2345 {
2348 {
2354 }
2355 else
2357 }
2360 }
2362 static bool
2364 {
2369 }
2371 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2372 words, it is about to become the "this" pointer for a member
2373 function call. Take the address of the object. */
2375 static tree
2377 {
2378 /* In a template, we are only concerned about the type of the
2379 expression, so we can take a shortcut. */
2384 }
2386 /* Returns true iff functions are equivalent. Equivalent functions are
2387 not '==' only if one is a function-local extern function or if
2388 both are extern "C". */
2392 {
2397 }
2399 /* Print information about one overload candidate CANDIDATE. MSGSTR
2400 is the text to print before the candidate itself.
2402 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2403 to have been run through gettext by the caller. This wart makes
2404 life simpler in print_z_candidates and for the translators. */
2406 static void
2408 {
2410 {
2420 else
2423 }
2428 else
2430 }
2432 static void
2434 {
2439 /* There may be duplicates in the set of candidates. We put off
2440 checking this condition as long as possible, since we have no way
2441 to eliminate duplicates from a set of functions in less than n^2
2442 time. Now we are about to emit an error message, so it is more
2443 permissible to go slowly. */
2445 {
2447 /* Skip builtin candidates and conversion functions. */
2452 {
2456 else
2458 }
2459 }
2467 {
2468 /* Indent successive candidates by the width of the translation
2469 of the above string. */
2476 do
2477 {
2480 }
2482 }
2483 }
2485 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2486 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2487 the result of the conversion function to convert it to the final
2488 desired type. Merge the two sequences into a single sequence,
2489 and return the merged sequence. */
2493 {
2498 /* Find the end of the second conversion sequence. */
2503 /* Replace the identity conversion with the user conversion
2504 sequence. */
2507 /* The entire sequence is a user-conversion sequence. */
2511 }
2513 /* Returns the best overload candidate to perform the requested
2514 conversion. This function is used for three the overloading situations
2515 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2516 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2517 per [dcl.init.ref], so we ignore temporary bindings. */
2521 {
2530 /* We represent conversion within a hierarchy using RVALUE_CONV and
2531 BASE_CONV, as specified by [over.best.ics]; these become plain
2532 constructor calls, as specified in [dcl.init]. */
2546 {
2547 tree t;
2553 /* We should never try to call the abstract or base constructor
2554 from here. */
2558 }
2560 {
2570 flags,
2571 DEDUCE_CALL);
2572 else
2576 flags);
2580 }
2586 {
2587 tree fns;
2591 /* If we are called to convert to a reference type, we are trying to
2592 find an lvalue binding, so don't even consider temporaries. If
2593 we don't find an lvalue binding, the caller will try again to
2594 look for a temporary binding. */
2599 {
2602 /* [over.match.funcs] For conversion functions, the function
2603 is considered to be a member of the class of the implicit
2604 object argument for the purpose of defining the type of
2605 the implicit object parameter.
2607 So we pass fromtype as CTYPE to add_*_candidate. */
2611 NULL_TREE,
2614 conversion_path,
2615 flags,
2616 DEDUCE_CONV);
2617 else
2619 args,
2621 conversion_path,
2622 flags);
2625 {
2626 conversion *ics
2638 }
2639 }
2640 }
2648 {
2650 {
2654 }
2661 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2662 ambiguous conversion is no worse than another user-defined
2663 conversion. */
2666 }
2668 /* Build the user conversion sequence. */
2669 conv = build_conv
2676 /* Combine it with the second conversion sequence. */
2684 }
2686 tree
2688 {
2693 {
2698 }
2700 }
2702 /* Do any initial processing on the arguments to a function call. */
2704 static tree
2706 {
2707 tree t;
2709 {
2715 {
2718 }
2721 }
2723 }
2725 /* Perform overload resolution on FN, which is called with the ARGS.
2727 Return the candidate function selected by overload resolution, or
2728 NULL if the event that overload resolution failed. In the case
2729 that overload resolution fails, *CANDIDATES will be the set of
2730 candidates considered, and ANY_VIABLE_P will be set to true or
2731 false to indicate whether or not any of the candidates were
2732 viable.
2734 The ARGS should already have gone through RESOLVE_ARGS before this
2735 function is called. */
2739 tree args,
2742 {
2750 /* Check FN and ARGS. */
2758 {
2762 }
2764 /* Add the various candidate functions. */
2768 LOOKUP_NORMAL,
2769 candidates);
2777 }
2779 /* Return an expression for a call to FN (a namespace-scope function,
2780 or a static member function) with the ARGS. */
2782 tree
2784 {
2788 tree result;
2794 /* If this function was found without using argument dependent
2795 lookup, then we want to ignore any undeclared friend
2796 functions. */
2798 {
2803 {
2807 }
2808 }
2810 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2816 {
2824 else
2830 }
2831 else
2834 /* Free all the conversions we allocated. */
2838 }
2840 /* Build a call to a global operator new. FNNAME is the name of the
2841 operator (either "operator new" or "operator new[]") and ARGS are
2842 the arguments provided. *SIZE points to the total number of bytes
2843 required by the allocation, and is updated if that is changed here.
2844 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2845 function determines that no cookie should be used, after all,
2846 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2847 set, upon return, to the allocation function called. */
2849 tree
2853 {
2854 tree fns;
2866 /* Based on:
2868 [expr.new]
2870 If this lookup fails to find the name, or if the allocated type
2871 is not a class type, the allocation function's name is looked
2872 up in the global scope.
2874 we disregard block-scope declarations of "operator new". */
2877 /* Figure out what function is being called. */
2880 /* If no suitable function could be found, issue an error message
2881 and give up. */
2883 {
2887 else
2893 }
2895 /* If a cookie is required, add some extra space. Whether
2896 or not a cookie is required cannot be determined until
2897 after we know which function was called. */
2899 {
2902 {
2904 /* In G++ 3.2, the check was implemented incorrectly; it
2905 looked at the placement expression, rather than the
2906 type of the function. */
2909 ptr_type_node))
2911 }
2912 else
2913 {
2914 tree arg_types;
2917 /* Skip the size_t parameter. */
2919 /* Check the remaining parameters (if any). */
2923 ptr_type_node))
2925 }
2926 /* If we need a cookie, adjust the number of bytes allocated. */
2928 {
2929 /* Update the total size. */
2931 /* Update the argument list to reflect the adjusted size. */
2933 }
2934 else
2936 }
2938 /* Tell our caller which function we decided to call. */
2942 /* Build the CALL_EXPR. */
2944 }
2946 static tree
2948 {
2957 {
2958 /* It's no good looking for an overloaded operator() on a
2959 pointer-to-member-function. */
2960 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2962 }
2965 {
2969 }
2970 else
2978 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2982 {
2987 {
2995 else
2996 add_function_candidate
2999 }
3000 }
3005 {
3017 {
3020 add_template_conv_candidate
3024 else
3028 }
3029 }
3033 {
3037 }
3038 else
3039 {
3042 {
3046 }
3047 /* Since cand->fn will be a type, not a function, for a conversion
3048 function, we must be careful not to unconditionally look at
3049 DECL_NAME here. */
3053 else
3054 {
3058 }
3059 }
3061 /* Free all the conversions we allocated. */
3065 }
3067 static void
3070 {
3075 else
3079 {
3103 else
3107 }
3108 }
3110 /* Return the implicit conversion sequence that could be used to
3111 convert E1 to E2 in [expr.cond]. */
3115 {
3121 /* [expr.cond]
3123 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3124 implicitly converted (clause _conv_) to the type "reference to
3125 T2", subject to the constraint that in the conversion the
3126 reference must bind directly (_dcl.init.ref_) to E1. */
3128 {
3130 t1,
3131 e1,
3133 LOOKUP_NO_TEMP_BIND);
3136 }
3138 /* [expr.cond]
3140 If E1 and E2 have class type, and the underlying class types are
3141 the same or one is a base class of the other: E1 can be converted
3142 to match E2 if the class of T2 is the same type as, or a base
3143 class of, the class of T1, and the cv-qualification of T2 is the
3144 same cv-qualification as, or a greater cv-qualification than, the
3145 cv-qualification of T1. If the conversion is applied, E1 is
3146 changed to an rvalue of type T2 that still refers to the original
3147 source class object (or the appropriate subobject thereof). */
3150 {
3152 {
3157 else
3160 }
3161 else
3163 }
3164 else
3165 /* [expr.cond]
3167 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3168 converted to the type that expression E2 would have if E2 were
3169 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3171 LOOKUP_NORMAL);
3172 }
3174 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3175 arguments to the conditional expression. */
3177 tree
3179 {
3180 tree arg2_type;
3181 tree arg3_type;
3189 /* As a G++ extension, the second argument to the conditional can be
3190 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3191 c'.) If the second operand is omitted, make sure it is
3192 calculated only once. */
3194 {
3198 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3201 else
3203 }
3205 /* [expr.cond]
3207 The first expr ession is implicitly converted to bool (clause
3208 _conv_). */
3211 /* If something has already gone wrong, just pass that fact up the
3212 tree. */
3218 /* [expr.cond]
3220 If either the second or the third operand has type (possibly
3221 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3222 array-to-pointer (_conv.array_), and function-to-pointer
3223 (_conv.func_) standard conversions are performed on the second
3224 and third operands. */
3232 {
3233 /* Do the conversions. We don't these for `void' type arguments
3234 since it can't have any effect and since decay_conversion
3235 does not handle that case gracefully. */
3243 /* [expr.cond]
3245 One of the following shall hold:
3247 --The second or the third operand (but not both) is a
3248 throw-expression (_except.throw_); the result is of the
3249 type of the other and is an rvalue.
3251 --Both the second and the third operands have type void; the
3252 result is of type void and is an rvalue.
3254 We must avoid calling force_rvalue for expressions of type
3255 "void" because it will complain that their value is being
3256 used. */
3259 {
3264 }
3267 {
3272 }
3275 else
3276 {
3280 }
3284 }
3285 /* [expr.cond]
3287 Otherwise, if the second and third operand have different types,
3288 and either has (possibly cv-qualified) class type, an attempt is
3289 made to convert each of those operands to the type of the other. */
3292 {
3296 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3302 /* [expr.cond]
3304 If both can be converted, or one can be converted but the
3305 conversion is ambiguous, the program is ill-formed. If
3306 neither can be converted, the operands are left unchanged and
3307 further checking is performed as described below. If exactly
3308 one conversion is possible, that conversion is applied to the
3309 chosen operand and the converted operand is used in place of
3310 the original operand for the remainder of this section. */
3315 {
3319 }
3321 {
3325 }
3327 {
3331 }
3333 /* Free all the conversions we allocated. */
3339 /* If, after the conversion, both operands have class type,
3340 treat the cv-qualification of both operands as if it were the
3341 union of the cv-qualification of the operands.
3343 The standard is not clear about what to do in this
3344 circumstance. For example, if the first operand has type
3345 "const X" and the second operand has a user-defined
3346 conversion to "volatile X", what is the type of the second
3347 operand after this step? Making it be "const X" (matching
3348 the first operand) seems wrong, as that discards the
3349 qualification without actually performing a copy. Leaving it
3350 as "volatile X" seems wrong as that will result in the
3351 conditional expression failing altogether, even though,
3352 according to this step, the one operand could be converted to
3353 the type of the other. */
3361 }
3363 /* [expr.cond]
3365 If the second and third operands are lvalues and have the same
3366 type, the result is of that type and is an lvalue. */
3370 {
3373 }
3375 /* [expr.cond]
3377 Otherwise, the result is an rvalue. If the second and third
3378 operand do not have the same type, and either has (possibly
3379 cv-qualified) class type, overload resolution is used to
3380 determine the conversions (if any) to be applied to the operands
3381 (_over.match.oper_, _over.built_). */
3385 {
3390 /* Rearrange the arguments so that add_builtin_candidate only has
3391 to know about two args. In build_builtin_candidates, the
3392 arguments are unscrambled. */
3397 COND_EXPR,
3398 NOP_EXPR,
3400 args,
3401 LOOKUP_NORMAL);
3403 /* [expr.cond]
3405 If the overload resolution fails, the program is
3406 ill-formed. */
3409 {
3413 }
3416 {
3420 }
3422 /* [expr.cond]
3424 Otherwise, the conversions thus determined are applied, and
3425 the converted operands are used in place of the original
3426 operands for the remainder of this section. */
3433 }
3435 /* [expr.cond]
3437 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3438 and function-to-pointer (_conv.func_) standard conversions are
3439 performed on the second and third operands.
3441 We need to force the lvalue-to-rvalue conversion here for class types,
3442 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3443 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3444 regions. */
3457 /* [expr.cond]
3459 After those conversions, one of the following shall hold:
3461 --The second and third operands have the same type; the result is of
3462 that type. */
3465 /* [expr.cond]
3467 --The second and third operands have arithmetic or enumeration
3468 type; the usual arithmetic conversions are performed to bring
3469 them to a common type, and the result is of that type. */
3474 {
3475 /* In this case, there is always a common type. */
3477 arg3_type);
3492 }
3493 /* [expr.cond]
3495 --The second and third operands have pointer type, or one has
3496 pointer type and the other is a null pointer constant; pointer
3497 conversions (_conv.ptr_) and qualification conversions
3498 (_conv.qual_) are performed to bring them to their composite
3499 pointer type (_expr.rel_). The result is of the composite
3500 pointer type.
3502 --The second and third operands have pointer to member type, or
3503 one has pointer to member type and the other is a null pointer
3504 constant; pointer to member conversions (_conv.mem_) and
3505 qualification conversions (_conv.qual_) are performed to bring
3506 them to a common type, whose cv-qualification shall match the
3507 cv-qualification of either the second or the third operand.
3508 The result is of the common type. */
3516 {
3523 }
3526 {
3530 }
3532 valid_operands:
3535 /* We can't use result_type below, as fold might have returned a
3536 throw_expr. */
3539 {
3540 /* Expand both sides into the same slot, hopefully the target of
3541 the ?: expression. We used to check for TARGET_EXPRs here,
3542 but now we sometimes wrap them in NOP_EXPRs so the test would
3543 fail. */
3546 /* If this expression is an rvalue, but might be mistaken for an
3547 lvalue, we must add a NON_LVALUE_EXPR. */
3549 }
3552 }
3554 /* OPERAND is an operand to an expression. Perform necessary steps
3555 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3556 returned. */
3558 static tree
3560 {
3562 {
3565 /* Make sure the template type is instantiated now. */
3567 }
3570 }
3572 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3573 OVERLOAD) to the CANDIDATES, returning an updated list of
3574 CANDIDATES. The ARGS are the arguments provided to the call,
3575 without any implicit object parameter. The EXPLICIT_TARGS are
3576 explicit template arguments provided. TEMPLATE_ONLY is true if
3577 only template functions should be considered. CONVERSION_PATH,
3578 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3580 static void
3586 {
3587 tree ctype;
3588 tree non_static_args;
3591 /* Delay creating the implicit this parameter until it is needed. */
3595 {
3596 tree fn;
3597 tree fn_args;
3600 /* Figure out which set of arguments to use. */
3602 {
3603 /* If this function is a non-static member, prepend the implicit
3604 object parameter. */
3610 }
3611 else
3612 /* Otherwise, just use the list of arguments provided. */
3617 fn,
3618 ctype,
3619 explicit_targs,
3620 fn_args,
3621 NULL_TREE,
3622 access_path,
3623 conversion_path,
3624 flags,
3625 DEDUCE_CALL);
3628 fn,
3629 ctype,
3630 fn_args,
3631 access_path,
3632 conversion_path,
3633 flags);
3635 }
3636 }
3638 tree
3641 {
3659 {
3663 }
3664 else
3670 {
3675 /* Use build_op_new_call and build_op_delete_call instead. */
3683 }
3689 {
3696 }
3711 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3714 /* Add namespace-scope operators to the list of functions to
3715 consider. */
3719 /* Add class-member operators to the candidate set. */
3721 {
3722 tree fns;
3726 {
3729 }
3736 }
3738 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3739 to know about two args; a builtin candidate will always have a first
3740 parameter of type bool. We'll handle that in
3741 build_builtin_candidate. */
3743 {
3747 }
3748 else
3749 {
3753 }
3758 {
3761 /* For these, the built-in candidates set is empty
3762 [over.match.oper]/3. We don't want non-strict matches
3763 because exact matches are always possible with built-in
3764 operators. The built-in candidate set for COMPONENT_REF
3765 would be empty too, but since there are no such built-in
3766 operators, we accept non-strict matches for them. */
3773 }
3777 {
3779 {
3782 /* Look for an `operator++ (int)'. If they didn't have
3783 one, then we fall back to the old way of doing things. */
3787 fnname,
3791 else
3794 overloaded_p);
3797 /* The caller will deal with these. */
3807 {
3810 }
3813 }
3814 }
3815 else
3816 {
3819 {
3821 {
3824 }
3826 }
3828 {
3833 }
3834 else
3835 {
3836 /* Give any warnings we noticed during overload resolution. */
3838 {
3842 }
3844 /* Check for comparison of different enum types. */
3846 {
3857 {
3860 }
3864 }
3866 /* We need to strip any leading REF_BIND so that bitfields
3867 don't cause errors. This should not remove any important
3868 conversions, because builtins don't apply to class
3869 objects directly. */
3875 {
3880 }
3882 {
3887 }
3888 }
3889 }
3891 user_defined_result_ready:
3893 /* Free all the conversions we allocated. */
3899 builtin:
3901 {
3951 /* The caller will deal with these. */
3959 }
3961 }
3963 /* Build a call to operator delete. This has to be handled very specially,
3964 because the restrictions on what signatures match are different from all
3965 other call instances. For a normal delete, only a delete taking (void *)
3966 or (void *, size_t) is accepted. For a placement delete, only an exact
3967 match with the placement new is accepted.
3969 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3970 ADDR is the pointer to be deleted.
3971 SIZE is the size of the memory block to be deleted.
3972 GLOBAL_P is true if the delete-expression should not consider
3973 class-specific delete operators.
3974 PLACEMENT is the corresponding placement new call, or NULL_TREE.
3975 If PLACEMENT is non-NULL, then ALLOC_FN is the allocation function
3976 called to perform the placement new. */
3978 tree
3981 tree alloc_fn)
3982 {
3997 /* In [class.free]
3999 If the result of the lookup is ambiguous or inaccessible, or if
4000 the lookup selects a placement deallocation function, the
4001 program is ill-formed.
4003 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4004 {
4008 }
4009 else
4016 {
4017 /* Get the parameter types for the allocation function that is
4018 being called. */
4021 /* Also the second argument. */
4023 }
4024 else
4025 {
4026 /* First try it without the size argument. */
4029 }
4031 /* Strip const and volatile from addr. */
4034 /* We make two tries at finding a matching `operator delete'. On
4035 the first pass, we look for a one-operator (or placement)
4036 operator delete. If we're not doing placement delete, then on
4037 the second pass we look for a two-argument delete. */
4039 {
4040 /* Go through the `operator delete' functions looking for one
4041 with a matching type. */
4043 fn;
4045 {
4046 tree t;
4048 /* The first argument must be "void *". */
4053 /* On the first pass, check the rest of the arguments. */
4055 {
4058 {
4063 }
4066 }
4067 /* On the second pass, the second argument must be
4068 "size_t". */
4073 }
4075 /* If we found a match, we're done. */
4078 }
4080 /* If we have a matching function, call it. */
4082 {
4083 /* Make sure we have the actual function, and not an
4084 OVERLOAD. */
4087 /* If the FN is a member function, make sure that it is
4088 accessible. */
4094 else
4099 {
4100 /* The placement args might not be suitable for overload
4101 resolution at this point, so build the call directly. */
4104 }
4105 else
4107 }
4109 /* If we are doing placement delete we do nothing if we don't find a
4110 matching op delete. */
4117 }
4119 /* If the current scope isn't allowed to access DECL along
4120 BASETYPE_PATH, give an error. The most derived class in
4121 BASETYPE_PATH is the one used to qualify DECL. */
4123 bool
4125 {
4129 {
4134 else
4138 }
4141 }
4143 /* Check that a callable constructor to initialize a temporary of
4144 TYPE from an EXPR exists. */
4146 static void
4148 {
4150 complete_ctor_identifier,
4152 type,
4153 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4154 | LOOKUP_NO_CONVERSION
4156 }
4158 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4159 bitwise or of LOOKUP_* values. If any errors are warnings are
4160 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4161 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4162 to NULL. */
4164 static tree
4167 {
4172 complete_ctor_identifier,
4179 else
4182 }
4185 /* Perform the conversions in CONVS on the expression EXPR. FN and
4186 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4187 indicates the `this' argument of a method. INNER is nonzero when
4188 being called to continue a conversion chain. It is negative when a
4189 reference binding will be applied, positive otherwise. If
4190 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4191 conversions will be emitted if appropriate. If C_CAST_P is true,
4192 this conversion is coming from a C-style cast; in that case,
4193 conversions to inaccessible bases are permitted. */
4195 static tree
4199 {
4201 diagnostic_fn_t diagnostic_fn;
4207 {
4210 {
4212 {
4217 }
4224 }
4229 }
4232 {
4235 /* Issue warnings about peculiar, but valid, uses of NULL. */
4237 {
4241 else
4243 }
4245 /* Warn about assigning a floating-point type to an integer type. */
4248 {
4252 else
4254 }
4255 }
4258 {
4260 {
4263 tree args;
4266 {
4271 /* We should never try to call the abstract or base constructor
4272 from here. */
4276 }
4277 else
4281 /* If this is a constructor or a function returning an aggr type,
4282 we need to build up a TARGET_EXPR. */
4286 /* The result of the call is then used to direct-initialize the object
4287 that is the destination of the copy-initialization. [dcl.init]
4289 Note that this step is not reflected in the conversion sequence;
4290 it affects the semantics when we actually perform the
4291 conversion, but is not considered during overload resolution.
4293 If the target is a class, that means call a ctor. */
4296 {
4297 expr = (build_temp
4299 /* Core issue 84, now a DR, says that we don't
4300 allow UDCs for these args (which deliberately
4301 breaks copy-init of an auto_ptr<Base> from an
4302 auto_ptr<Derived>). */
4307 {
4309 diagnostic_fn
4312 else
4313 diagnostic_fn
4315 }
4317 }
4319 }
4323 /* Convert a constant to its underlying value, unless we are
4324 about to bind it to a reference, in which case we need to
4325 leave it as an lvalue. */
4332 /* Call build_user_type_conversion again for the error. */
4333 return build_user_type_conversion
4338 };
4343 c_cast_p);
4348 {
4353 /* Else fall through. */
4356 {
4357 /* We are going to bind a reference directly to a base-class
4358 subobject of EXPR. */
4361 /* Build an expression for `*((base*) &expr)'. */
4367 }
4369 /* Copy-initialization where the cv-unqualified version of the source
4370 type is the same class as, or a derived class of, the class of the
4371 destination [is treated as direct-initialization]. [dcl.init] */
4379 {
4382 /* If necessary, create a temporary. */
4384 {
4389 {
4390 /* If the reference is volatile or non-const, we
4391 cannot create a temporary. */
4398 else
4401 }
4402 /* If the source is a packed field, and we must use a copy
4403 constructor, then building the target expr will require
4404 binding the field to the reference parameter to the
4405 copy constructor, and we'll end up with an infinite
4406 loop. If we can use a bitwise copy, then we'll be
4407 OK. */
4411 {
4415 }
4417 }
4419 /* Take the address of the thing to which we will bind the
4420 reference. */
4425 /* Convert it to a pointer to the type referred to by the
4426 reference. This will adjust the pointer if a derived to
4427 base conversion is being performed. */
4429 expr);
4430 /* Convert the pointer to the desired reference type. */
4432 }
4438 /* Warn about deprecated conversion if appropriate. */
4450 c_cast_p);
4454 }
4458 else
4462 }
4464 /* Build a call to __builtin_trap. */
4466 static tree
4468 {
4474 }
4476 /* ARG is being passed to a varargs function. Perform any conversions
4477 required. Return the converted value. */
4479 tree
4481 {
4482 /* [expr.call]
4484 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4485 standard conversions are performed. */
4487 /* [expr.call]
4489 If the argument has integral or enumeration type that is subject
4490 to the integral promotions (_conv.prom_), or a floating point
4491 type that is subject to the floating point promotion
4492 (_conv.fpprom_), the value of the argument is converted to the
4493 promoted type before the call. */
4505 {
4506 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4507 here and do a bitwise copy, but now cp_expr_size will abort if we
4508 try to do that.
4509 If the call appears in the context of a sizeof expression,
4510 there is no need to emit a warning, since the expression won't be
4511 evaluated. We keep the builtin_trap just as a safety check. */
4517 integer_zero_node);
4518 }
4521 }
4523 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4525 tree
4527 {
4537 {
4538 /* Undefined behavior [expr.call] 5.2.2/7. */
4546 }
4549 }
4551 /* TYPE has been given to va_arg. Apply the default conversions which
4552 would have happened when passed via ellipsis. Return the promoted
4553 type, or the passed type if there is no change. */
4555 tree
4557 {
4558 tree promote;
4560 /* Perform the array-to-pointer and function-to-pointer
4561 conversions. */
4569 }
4571 /* ARG is a default argument expression being passed to a parameter of
4572 the indicated TYPE, which is a parameter to FN. Do any required
4573 conversions. Return the converted value. */
4575 tree
4577 {
4578 /* If the ARG is an unparsed default argument expression, the
4579 conversion cannot be performed. */
4581 {
4586 }
4594 {
4598 }
4599 else
4600 {
4601 /* This could get clobbered by the following call. */
4608 }
4611 }
4613 /* Returns the type which will really be used for passing an argument of
4614 type TYPE. */
4616 tree
4618 {
4619 /* Pass classes with copy ctors by invisible reference. */
4621 {
4623 /* There are no other pointers to this temporary. */
4625 }
4634 }
4636 /* Actually perform the appropriate conversion. */
4638 tree
4640 {
4642 ;
4643 /* Pass classes with copy ctors by invisible reference. */
4653 {
4662 }
4664 }
4666 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4667 which no conversions at all should be done. This is true for some
4668 builtins which don't act like normal functions. */
4670 static bool
4672 {
4675 {
4684 }
4687 }
4689 /* Subroutine of the various build_*_call functions. Overload resolution
4690 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4691 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4692 bitmask of various LOOKUP_* flags which apply to the call itself. */
4694 static tree
4696 {
4707 /* In a template, there is no need to perform all of the work that
4708 is normally done. We are only interested in the type of the call
4709 expression, i.e., the return type of the function. Any semantic
4710 errors will be deferred until the template is instantiated. */
4712 {
4713 tree expr;
4714 tree return_type;
4722 }
4724 /* Give any warnings we noticed during overload resolution. */
4726 {
4730 }
4733 {
4734 /* If FN is a template function, two cases must be considered.
4735 For example:
4737 struct A {
4738 protected:
4739 template <class T> void f();
4740 };
4741 template <class T> struct B {
4742 protected:
4743 void g();
4744 };
4745 struct C : A, B<int> {
4746 using A::f; // #1
4747 using B<int>::g; // #2
4748 };
4750 In case #1 where `A::f' is a member template, DECL_ACCESS is
4751 recorded in the primary template but not in its specialization.
4752 We check access of FN using its primary template.
4754 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4755 because it is a member of class template B, DECL_ACCESS is
4756 recorded in the specialization `B<int>::g'. We cannot use its
4757 primary template because `B<T>::g' and `B<int>::g' may have
4758 different access. */
4763 else
4765 }
4771 /* The implicit parameters to a constructor are not considered by overload
4772 resolution, and must be of the proper type. */
4774 {
4778 /* We should never try to call the abstract constructor. */
4782 {
4783 converted_args = tree_cons
4787 }
4788 }
4789 /* Bypass access control for 'this' parameter. */
4791 {
4794 tree converted_arg;
4795 tree base_binfo;
4801 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4802 X is called for an object that is not of type X, or of a type
4803 derived from X, the behavior is undefined.
4805 So we can assume that anything passed as 'this' is non-null, and
4806 optimize accordingly. */
4808 /* Convert to the base in which the function was declared. */
4814 /* Check that the base class is accessible. */
4820 /* If fn was found by a using declaration, the conversion path
4821 will be to the derived class, not the base declaring fn. We
4822 must convert from derived to base. */
4833 }
4837 {
4841 val = convert_like_with_context
4846 }
4848 /* Default arguments */
4850 converted_args
4855 converted_args);
4857 /* Ellipsis */
4859 {
4863 else
4866 }
4873 /* Avoid actually calling copy constructors and copy assignment operators,
4874 if possible. */
4879 {
4880 tree targ;
4884 /* Pull out the real argument, disregarding const-correctness. */
4891 {
4896 }
4897 else
4902 else
4905 /* [class.copy]: the copy constructor is implicitly defined even if
4906 the implementation elided its use. */
4910 /* If we're creating a temp and we already have one, don't create a
4911 new one. If we're not creating a temp but we get one, use
4912 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4913 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4914 temp or an INIT_EXPR otherwise. */
4916 {
4921 }
4924 {
4925 tree to = stabilize_reference
4930 }
4931 }
4935 {
4936 tree to = stabilize_reference
4943 {
4946 }
4947 else
4948 {
4949 /* We must only copy the non-tail padding parts.
4950 Use __builtin_memcpy for the bitwise copy. */
4963 }
4966 }
4971 {
4984 else
4987 }
4990 else
4994 }
4996 /* Build and return a call to FN, using ARGS. This function performs
4997 no overload resolution, conversion, or other high-level
4998 operations. */
5000 tree
5002 {
5003 tree fndecl;
5007 /* If this call might throw an exception, note that fact. */
5014 /* Some built-in function calls will be evaluated at compile-time in
5015 fold (). */
5028 }
5032 /* Make an expression which yields the address of the Java interface
5033 method FN. This is achieved by generating a call to libjava's
5034 _Jv_LookupInterfaceMethodIdx(). */
5036 static tree
5038 {
5044 {
5049 endlink)));
5050 java_iface_lookup_fn
5054 }
5056 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5057 This is the first entry in the vtable. */
5059 integer_zero_node);
5061 /* Get the java.lang.Class pointer for the interface being called. */
5066 {
5068 iface);
5070 }
5074 /* Determine the itable index of FN. */
5077 {
5082 i++;
5083 }
5091 java_iface_lookup_fn);
5093 }
5095 /* Returns the value to use for the in-charge parameter when making a
5096 call to a function with the indicated NAME.
5098 FIXME:Can't we find a neater way to do this mapping? */
5100 tree
5102 {
5113 /* This function should only be called with one of the names listed
5114 above. */
5117 }
5119 /* Build a call to a constructor, destructor, or an assignment
5120 operator for INSTANCE, an expression with class type. NAME
5121 indicates the special member function to call; ARGS are the
5122 arguments. BINFO indicates the base of INSTANCE that is to be
5123 passed as the `this' parameter to the member function called.
5125 FLAGS are the LOOKUP_* flags to use when processing the call.
5127 If NAME indicates a complete object constructor, INSTANCE may be
5128 NULL_TREE. In this case, the caller will call build_cplus_new to
5129 store the newly constructed object into a VAR_DECL. */
5131 tree
5134 {
5135 tree fns;
5136 /* The type of the subobject to be constructed or destroyed. */
5137 tree class_type;
5146 {
5147 /* Resolve the name. */
5152 }
5158 /* Handle the special case where INSTANCE is NULL_TREE. */
5160 {
5163 }
5164 else
5165 {
5171 /* Convert to the base class, if necessary. */
5174 {
5176 /* For constructors and destructors, either the base is
5177 non-virtual, or it is virtual but we are doing the
5178 conversion from a constructor or destructor for the
5179 complete object. In either case, we can convert
5180 statically. */
5182 else
5183 /* However, for assignment operators, we must convert
5184 dynamically if the base is virtual. */
5187 }
5188 }
5194 /* When making a call to a constructor or destructor for a subobject
5195 that uses virtual base classes, pass down a pointer to a VTT for
5196 the subobject. */
5200 {
5201 tree vtt;
5202 tree sub_vtt;
5204 /* If the current function is a complete object constructor
5205 or destructor, then we fetch the VTT directly.
5206 Otherwise, we look it up using the VTT we were given. */
5212 current_vtt_parm,
5213 vtt);
5219 }
5224 }
5226 /* Return the NAME, as a C string. The NAME indicates a function that
5227 is a member of TYPE. *FREE_P is set to true if the caller must
5228 free the memory returned.
5230 Rather than go through all of this, we should simply set the names
5231 of constructors and destructors appropriately, and dispense with
5232 ctor_identifier, dtor_identifier, etc. */
5236 {
5239 /* Assume that we will not allocate memory. */
5241 /* Constructors and destructors are special. */
5243 {
5244 pretty_name
5246 /* For a destructor, add the '~'. */
5250 {
5252 /* Remember that we need to free the memory allocated. */
5254 }
5255 }
5257 {
5260 TFF_PLAIN_IDENTIFIER),
5261 NULL);
5262 /* Remember that we need to free the memory allocated. */
5264 }
5265 else
5269 }
5271 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5272 be set, upon return, to the function called. */
5274 tree
5278 {
5282 tree access_binfo;
5283 tree optype;
5285 tree name;
5286 tree user_args;
5287 tree call;
5288 tree fn;
5289 tree class_type;
5292 tree orig_instance;
5293 tree orig_fns;
5294 tree orig_args;
5299 /* We don't know what function we're going to call, yet. */
5309 {
5312 }
5318 /* Dismantle the baselink to collect all the information we need. */
5325 {
5329 }
5340 {
5343 }
5345 /* The USER_ARGS are the arguments we will display to users if an
5346 error occurs. The USER_ARGS should not include any
5347 compiler-generated arguments. The "this" pointer hasn't been
5348 added yet. However, we must remove the VTT pointer if this is a
5349 call to a base-class constructor or destructor. */
5352 {
5353 /* Callers should explicitly indicate whether they want to construct
5354 the complete object or just the part without virtual bases. */
5356 /* Similarly for destructors. */
5358 /* Remove the VTT pointer, if present. */
5362 }
5364 /* Process the argument list. */
5371 /* It's OK to call destructors on cv-qualified objects. Therefore,
5372 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5374 {
5379 }
5384 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5388 {
5390 tree this_arglist;
5392 /* We can end up here for copy-init of same or base class. */
5399 else
5403 /* A member template. */
5405 class_type,
5406 explicit_targs,
5408 access_binfo,
5409 conversion_path,
5410 flags,
5411 DEDUCE_CALL);
5414 class_type,
5415 this_arglist,
5416 access_binfo,
5417 conversion_path,
5418 flags);
5419 }
5423 {
5426 else
5427 {
5437 }
5440 }
5441 else
5442 {
5445 {
5451 user_args);
5456 }
5457 else
5458 {
5466 /* This is not an error, it is runtime undefined
5467 behavior. */
5469 "abstract virtual %q#D called from constructor"
5471 fn);
5475 {
5477 fn);
5479 }
5480 else
5481 {
5485 /* Now we know what function is being called. */
5488 /* Build the actual CALL_EXPR. */
5490 /* In an expression of the form `a->f()' where `f' turns
5491 out to be a static member function, `a' is
5492 none-the-less evaluated. */
5498 }
5499 }
5500 }
5503 call = (build_min_non_dep
5508 /* Free all the conversions we allocated. */
5512 }
5514 /* Returns true iff standard conversion sequence ICS1 is a proper
5515 subsequence of ICS2. */
5517 static bool
5519 {
5520 /* We can assume that a conversion of the same code
5521 between the same types indicates a subsequence since we only get
5522 here if the types we are converting from are the same. */
5529 {
5537 /* At this point, ICS1 cannot be a proper subsequence of
5538 ICS2. We can get a USER_CONV when we are comparing the
5539 second standard conversion sequence of two user conversion
5540 sequences. */
5550 }
5551 }
5553 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5554 be any _TYPE nodes. */
5556 bool
5558 {
5563 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5564 considers every class derived from itself. */
5567 }
5569 /* We build the ICS for an implicit object parameter as a pointer
5570 conversion sequence. However, such a sequence should be compared
5571 as if it were a reference conversion sequence. If ICS is the
5572 implicit conversion sequence for an implicit object parameter,
5573 modify it accordingly. */
5575 static void
5577 {
5579 {
5580 /* [over.match.funcs]
5582 For non-static member functions, the type of the
5583 implicit object parameter is "reference to cv X"
5584 where X is the class of which the function is a
5585 member and cv is the cv-qualification on the member
5586 function declaration. */
5588 tree reference_type;
5590 /* The `this' parameter is a pointer to a class type. Make the
5591 implicit conversion talk about a reference to that same class
5592 type. */
5603 }
5604 }
5606 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5607 and return the type to which the reference refers. Otherwise,
5608 leave *ICS unchanged and return NULL_TREE. */
5610 static tree
5612 {
5614 {
5621 }
5624 }
5626 /* Compare two implicit conversion sequences according to the rules set out in
5627 [over.ics.rank]. Return values:
5629 1: ics1 is better than ics2
5630 -1: ics2 is better than ics1
5631 0: ics1 and ics2 are indistinguishable */
5633 static int
5635 {
5636 tree from_type1;
5637 tree from_type2;
5638 tree to_type1;
5639 tree to_type2;
5646 /* REF_BINDING is nonzero if the result of the conversion sequence
5647 is a reference type. In that case TARGET_TYPE is the
5648 type referred to by the reference. */
5649 tree target_type1;
5650 tree target_type2;
5652 /* Handle implicit object parameters. */
5656 /* Handle reference parameters. */
5660 /* [over.ics.rank]
5662 When comparing the basic forms of implicit conversion sequences (as
5663 defined in _over.best.ics_)
5665 --a standard conversion sequence (_over.ics.scs_) is a better
5666 conversion sequence than a user-defined conversion sequence
5667 or an ellipsis conversion sequence, and
5669 --a user-defined conversion sequence (_over.ics.user_) is a
5670 better conversion sequence than an ellipsis conversion sequence
5671 (_over.ics.ellipsis_). */
5681 {
5682 /* XXX Isn't this an extension? */
5683 /* Both ICS are bad. We try to make a decision based on what
5684 would have happened if they'd been good. */
5692 /* We couldn't make up our minds; try to figure it out below. */
5693 }
5696 /* Both conversions are ellipsis conversions. */
5699 /* User-defined conversion sequence U1 is a better conversion sequence
5700 than another user-defined conversion sequence U2 if they contain the
5701 same user-defined conversion operator or constructor and if the sec-
5702 ond standard conversion sequence of U1 is better than the second
5703 standard conversion sequence of U2. */
5706 {
5720 /* We can just fall through here, after setting up
5721 FROM_TYPE1 and FROM_TYPE2. */
5724 }
5725 else
5726 {
5730 /* We're dealing with two standard conversion sequences.
5732 [over.ics.rank]
5734 Standard conversion sequence S1 is a better conversion
5735 sequence than standard conversion sequence S2 if
5737 --S1 is a proper subsequence of S2 (comparing the conversion
5738 sequences in the canonical form defined by _over.ics.scs_,
5739 excluding any Lvalue Transformation; the identity
5740 conversion sequence is considered to be a subsequence of
5741 any non-identity conversion sequence */
5752 }
5755 {
5760 }
5761 /* Otherwise, one sequence cannot be a subsequence of the other; they
5762 don't start with the same type. This can happen when comparing the
5763 second standard conversion sequence in two user-defined conversion
5764 sequences. */
5766 /* [over.ics.rank]
5768 Or, if not that,
5770 --the rank of S1 is better than the rank of S2 (by the rules
5771 defined below):
5773 Standard conversion sequences are ordered by their ranks: an Exact
5774 Match is a better conversion than a Promotion, which is a better
5775 conversion than a Conversion.
5777 Two conversion sequences with the same rank are indistinguishable
5778 unless one of the following rules applies:
5780 --A conversion that is not a conversion of a pointer, or pointer
5781 to member, to bool is better than another conversion that is such
5782 a conversion.
5784 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5785 so that we do not have to check it explicitly. */
5798 {
5803 }
5804 /* The rules for pointers to members A::* are just like the rules
5805 for pointers A*, except opposite: if B is derived from A then
5806 A::* converts to B::*, not vice versa. For that reason, we
5807 switch the from_ and to_ variables here. */
5814 {
5819 }
5824 {
5825 /* This was one of the pointer or pointer-like conversions.
5827 [over.ics.rank]
5829 --If class B is derived directly or indirectly from class A,
5830 conversion of B* to A* is better than conversion of B* to
5831 void*, and conversion of A* to void* is better than
5832 conversion of B* to void*. */
5835 {
5837 deref_from_type2))
5840 deref_from_type1))
5842 }
5845 {
5847 {
5849 {
5851 deref_to_type1))
5853 }
5854 /* We know that DEREF_TO_TYPE1 is `void' here. */
5856 deref_to_type2))
5858 }
5859 }
5862 {
5863 /* [over.ics.rank]
5865 --If class B is derived directly or indirectly from class A
5866 and class C is derived directly or indirectly from B,
5868 --conversion of C* to B* is better than conversion of C* to
5869 A*,
5871 --conversion of B* to A* is better than conversion of C* to
5872 A* */
5874 {
5876 deref_to_type2))
5879 deref_to_type1))
5881 }
5883 {
5885 deref_from_type1))
5888 deref_from_type2))
5890 }
5891 }
5892 }
5895 {
5898 /* [over.ics.rank]
5900 --binding of an expression of type C to a reference of type
5901 B& is better than binding an expression of type C to a
5902 reference of type A&
5904 --conversion of C to B is better than conversion of C to A, */
5907 {
5912 }
5913 }
5916 {
5919 /* [over.ics.rank]
5921 --binding of an expression of type B to a reference of type
5922 A& is better than binding an expression of type C to a
5923 reference of type A&,
5925 --conversion of B to A is better than conversion of C to A */
5928 {
5933 }
5934 }
5936 /* [over.ics.rank]
5938 --S1 and S2 differ only in their qualification conversion and yield
5939 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5940 qualification signature of type T1 is a proper subset of the cv-
5941 qualification signature of type T2 */
5947 /* [over.ics.rank]
5949 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5950 types to which the references refer are the same type except for
5951 top-level cv-qualifiers, and the type to which the reference
5952 initialized by S2 refers is more cv-qualified than the type to
5953 which the reference initialized by S1 refers */
5959 /* Neither conversion sequence is better than the other. */
5961 }
5963 /* The source type for this standard conversion sequence. */
5965 static tree
5967 {
5969 {
5974 }
5976 }
5978 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5979 a pointer to LOSER and re-running joust to produce the warning if WINNER
5980 is actually used. */
5982 static void
5984 {
5990 }
5992 /* Compare two candidates for overloading as described in
5993 [over.match.best]. Return values:
5995 1: cand1 is better than cand2
5996 -1: cand2 is better than cand1
5997 0: cand1 and cand2 are indistinguishable */
5999 static int
6001 {
6007 /* Candidates that involve bad conversions are always worse than those
6008 that don't. */
6014 /* If we have two pseudo-candidates for conversions to the same type,
6015 or two candidates for the same function, arbitrarily pick one. */
6020 /* a viable function F1
6021 is defined to be a better function than another viable function F2 if
6022 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6023 ICSi(F2), and then */
6025 /* for some argument j, ICSj(F1) is a better conversion sequence than
6026 ICSj(F2) */
6028 /* For comparing static and non-static member functions, we ignore
6029 the implicit object parameter of the non-static function. The
6030 standard says to pretend that the static function has an object
6031 parm, but that won't work with operator overloading. */
6034 {
6042 else
6043 {
6046 }
6047 }
6050 {
6056 {
6069 {
6076 else
6081 {
6085 }
6086 else
6088 }
6091 {
6094 }
6096 }
6097 }
6099 /* warn about confusing overload resolution for user-defined conversions,
6100 either between a constructor and a conversion op, or between two
6101 conversion ops. */
6105 {
6111 else
6114 /* We don't want to complain about `X::operator T1 ()'
6115 beating `X::operator T2 () const', when T2 is a no less
6116 cv-qualified version of T1. */
6119 {
6124 {
6127 }
6130 }
6131 else
6137 {
6145 }
6146 else
6148 }
6153 /* or, if not that,
6154 F1 is a non-template function and F2 is a template function
6155 specialization. */
6162 /* or, if not that,
6163 F1 and F2 are template functions and the function template for F1 is
6164 more specialized than the template for F2 according to the partial
6165 ordering rules. */
6168 {
6169 winner = more_specialized_fn
6172 /* [temp.func.order]: The presence of unused ellipsis and default
6173 arguments has no effect on the partial ordering of function
6174 templates. add_function_candidate() will not have
6175 counted the "this" argument for constructors. */
6179 }
6181 /* or, if not that,
6182 the context is an initialization by user-defined conversion (see
6183 _dcl.init_ and _over.match.user_) and the standard conversion
6184 sequence from the return type of F1 to the destination type (i.e.,
6185 the type of the entity being initialized) is a better conversion
6186 sequence than the standard conversion sequence from the return type
6187 of F2 to the destination type. */
6190 {
6194 }
6196 /* Check whether we can discard a builtin candidate, either because we
6197 have two identical ones or matching builtin and non-builtin candidates.
6199 (Pedantically in the latter case the builtin which matched the user
6200 function should not be added to the overload set, but we spot it here.
6202 [over.match.oper]
6203 ... the builtin candidates include ...
6204 - do not have the same parameter type list as any non-template
6205 non-member candidate. */
6209 {
6215 {
6217 /* Two built-in candidates; arbitrarily pick one. */
6220 /* cand1 is built-in; prefer cand2. */
6222 else
6223 /* cand2 is built-in; prefer cand1. */
6225 }
6226 }
6228 /* If the two functions are the same (this can happen with declarations
6229 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6234 tweak:
6236 /* Extension: If the worst conversion for one candidate is worse than the
6237 worst conversion for the other, take the first. */
6239 {
6244 {
6249 }
6255 {
6257 {
6259 ISO C++ says that these are ambiguous, even \
6260 though the worst conversion for the first is better than \
6264 }
6265 else
6268 }
6269 }
6273 }
6275 /* Given a list of candidates for overloading, find the best one, if any.
6276 This algorithm has a worst case of O(2n) (winner is last), and a best
6277 case of O(n/2) (totally ambiguous); much better than a sorting
6278 algorithm. */
6282 {
6287 /* Walk through the list once, comparing each current champ to the next
6288 candidate, knocking out a candidate or two with each comparison. */
6291 {
6295 else
6296 {
6298 {
6303 }
6304 else
6305 {
6308 }
6311 }
6312 }
6314 /* Make sure the champ is better than all the candidates it hasn't yet
6315 been compared to. */
6318 challenger != champ
6321 {
6325 }
6328 }
6330 /* Returns nonzero if things of type FROM can be converted to TO. */
6332 bool
6334 {
6336 }
6338 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6340 bool
6342 {
6347 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6351 flags);
6354 /* Free all the conversions we allocated. */
6358 }
6360 /* Like can_convert_arg, but allows dubious conversions as well. */
6362 bool
6364 {
6368 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6370 /* Try to perform the conversion. */
6372 LOOKUP_NORMAL);
6373 /* Free all the conversions we allocated. */
6377 }
6379 /* Convert EXPR to TYPE. Return the converted expression.
6381 Note that we allow bad conversions here because by the time we get to
6382 this point we are committed to doing the conversion. If we end up
6383 doing a bad conversion, convert_like will complain. */
6385 tree
6387 {
6394 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6399 LOOKUP_NORMAL);
6401 {
6404 }
6406 {
6407 /* In a template, we are only concerned about determining the
6408 type of non-dependent expressions, so we do not have to
6409 perform the actual conversion. */
6412 }
6413 else
6416 /* Free all the conversions we allocated. */
6420 }
6422 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6423 permitted. If the conversion is valid, the converted expression is
6424 returned. Otherwise, NULL_TREE is returned, except in the case
6425 that TYPE is a class type; in that case, an error is issued. If
6426 C_CAST_P is true, then this direction initialization is taking
6427 place as part of a static_cast being attempted as part of a C-style
6428 cast. */
6430 tree
6432 tree expr,
6434 {
6440 /* [dcl.init]
6442 If the destination type is a (possibly cv-qualified) class type:
6444 -- If the initialization is direct-initialization ...,
6445 constructors are considered. ... If no constructor applies, or
6446 the overload resolution is ambiguous, the initialization is
6447 ill-formed. */
6449 {
6454 }
6456 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6460 c_cast_p,
6461 LOOKUP_NORMAL);
6464 else
6467 c_cast_p);
6469 /* Free all the conversions we allocated. */
6473 }
6475 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6476 is being bound to a temporary. Create and return a new VAR_DECL
6477 with the indicated TYPE; this variable will store the value to
6478 which the reference is bound. */
6480 tree
6482 {
6483 tree var;
6485 /* Create the variable. */
6488 /* Register the variable. */
6490 {
6491 /* Namespace-scope or local static; give it a mangled name. */
6492 tree name;
6499 }
6500 else
6501 /* Create a new cleanup level if necessary. */
6505 }
6507 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6508 initializing a variable of that TYPE. If DECL is non-NULL, it is
6509 the VAR_DECL being initialized with the EXPR. (In that case, the
6510 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6511 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6512 return, if *CLEANUP is no longer NULL, it will be an expression
6513 that should be pushed as a cleanup after the returned expression
6514 is used to initialize DECL.
6516 Return the converted expression. */
6518 tree
6520 {
6527 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6532 {
6538 else
6543 }
6545 /* If DECL is non-NULL, then this special rule applies:
6547 [class.temporary]
6549 The temporary to which the reference is bound or the temporary
6550 that is the complete object to which the reference is bound
6551 persists for the lifetime of the reference.
6553 The temporaries created during the evaluation of the expression
6554 initializing the reference, except the temporary to which the
6555 reference is bound, are destroyed at the end of the
6556 full-expression in which they are created.
6558 In that case, we store the converted expression into a new
6559 VAR_DECL in a new scope.
6561 However, we want to be careful not to create temporaries when
6562 they are not required. For example, given:
6564 struct B {};
6565 struct D : public B {};
6566 D f();
6567 const B& b = f();
6569 there is no need to copy the return value from "f"; we can just
6570 extend its lifetime. Similarly, given:
6572 struct S {};
6573 struct T { operator S(); };
6574 T t;
6575 const S& s = t;
6577 we can extend the lifetime of the return value of the conversion
6578 operator. */
6581 {
6582 tree var;
6583 tree base_conv_type;
6585 /* Skip over the REF_BIND. */
6587 /* If the next conversion is a BASE_CONV, skip that too -- but
6588 remember that the conversion was required. */
6590 {
6595 }
6596 else
6598 /* Perform the remainder of the conversion. */
6606 else
6607 {
6609 {
6610 tree init;
6611 tree type;
6613 /* Create the temporary variable. */
6617 /* If the rvalue is the result of a function call it will be
6618 a TARGET_EXPR. If it is some other construct (such as a
6619 member access expression where the underlying object is
6620 itself the result of a function call), turn it into a
6621 TARGET_EXPR here. It is important that EXPR be a
6622 TARGET_EXPR below since otherwise the INIT_EXPR will
6623 attempt to make a bitwise copy of EXPR to initialize
6624 VAR. */
6627 /* Create the INIT_EXPR that will initialize the temporary
6628 variable. */
6631 {
6635 /* We must be careful to destroy the temporary only
6636 after its initialization has taken place. If the
6637 initialization throws an exception, then the
6638 destructor should not be run. We cannot simply
6639 transform INIT into something like:
6641 (INIT, ({ CLEANUP_STMT; }))
6643 because emit_local_var always treats the
6644 initializer as a full-expression. Thus, the
6645 destructor would run too early; it would run at the
6646 end of initializing the reference variable, rather
6647 than at the end of the block enclosing the
6648 reference variable.
6650 The solution is to pass back a cleanup expression
6651 which the caller is responsible for attaching to
6652 the statement tree. */
6653 }
6654 else
6655 {
6659 static_aggregates);
6660 }
6661 /* Use its address to initialize the reference variable. */
6669 }
6670 else
6671 /* Take the address of EXPR. */
6673 /* If a BASE_CONV was required, perform it now. */
6675 expr = (perform_implicit_conversion
6678 }
6679 }
6680 else
6681 /* Perform the conversion. */
6684 /* Free all the conversions we allocated. */
6688 }