| blob | 3677262a370d5be945e58f61eee9e2d445ce6eb6 |
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
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) and
6 modified by Brendan Kehoe (brendan@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* High-level class interface. */
44 /* The various kinds of conversion. */
47 ck_identity,
48 ck_lvalue,
49 ck_qual,
50 ck_std,
51 ck_ptr,
52 ck_pmem,
53 ck_base,
54 ck_ref_bind,
55 ck_user,
56 ck_ambig,
57 ck_rvalue
60 /* The rank of the conversion. Order of the enumerals matters; better
61 conversions should come earlier in the list. */
64 cr_identity,
65 cr_exact,
66 cr_promotion,
67 cr_std,
68 cr_pbool,
69 cr_user,
70 cr_ellipsis,
71 cr_bad
74 /* An implicit conversion sequence, in the sense of [over.best.ics].
75 The first conversion to be performed is at the end of the chain.
76 That conversion is always a cr_identity conversion. */
80 /* The kind of conversion represented by this step. */
81 conversion_kind kind;
82 /* The rank of this conversion. */
83 conversion_rank rank;
88 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
89 temporary should be created to hold the result of the
90 conversion. */
92 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
93 from a pointer-to-derived to pointer-to-base is being performed. */
95 /* If KIND is ck_ref_bind, true when either an lvalue reference is
96 being bound to an lvalue expression or an rvalue reference is
97 being bound to an rvalue expression. */
99 /* The type of the expression resulting from the conversion. */
100 tree type;
102 /* The next conversion in the chain. Since the conversions are
103 arranged from outermost to innermost, the NEXT conversion will
104 actually be performed before this conversion. This variant is
105 used only when KIND is neither ck_identity nor ck_ambig. */
107 /* The expression at the beginning of the conversion chain. This
108 variant is used only if KIND is ck_identity or ck_ambig. */
109 tree expr;
111 /* The function candidate corresponding to this conversion
112 sequence. This field is only used if KIND is ck_user. */
114 };
116 #define CONVERSION_RANK(NODE) \
117 ((NODE)->bad_p ? cr_bad \
118 : (NODE)->ellipsis_p ? cr_ellipsis \
119 : (NODE)->user_conv_p ? cr_user \
120 : (NODE)->rank)
131 #define convert_like(CONV, EXPR) \
132 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
135 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
136 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
159 static void add_builtin_candidates
162 static void add_builtin_candidate
166 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. There are
271 two variants. build_call_a is the primitive taking an array of
272 arguments, while build_call_n is a wrapper that handles varargs. */
274 tree
276 {
279 else
280 {
290 }
291 }
293 tree
295 {
298 tree decl;
299 tree result_type;
300 tree fntype;
313 {
316 {
317 /* We invoke build_call directly for several library
318 functions. These may have been declared normally if
319 we're building libgcc, so we can't just check
320 DECL_ARTIFICIAL. */
325 }
326 }
327 else
330 /* We check both the decl and the type; a function may be known not to
331 throw without being declared throw(). */
345 /* Don't pass empty class objects by value. This is useful
346 for tags in STL, which are used to control overload resolution.
347 We don't need to handle other cases of copying empty classes. */
352 {
356 }
363 }
365 /* Build something of the form ptr->method (args)
366 or object.method (args). This can also build
367 calls to constructors, and find friends.
369 Member functions always take their class variable
370 as a pointer.
372 INSTANCE is a class instance.
374 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
376 PARMS help to figure out what that NAME really refers to.
378 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
379 down to the real instance type to use for access checking. We need this
380 information to get protected accesses correct.
382 FLAGS is the logical disjunction of zero or more LOOKUP_
383 flags. See cp-tree.h for more info.
385 If this is all OK, calls build_function_call with the resolved
386 member function.
388 This function must also handle being called to perform
389 initialization, promotion/coercion of arguments, and
390 instantiation of default parameters.
392 Note that NAME may refer to an instance variable name. If
393 `operator()()' is defined for the type of that field, then we return
394 that result. */
396 /* New overloading code. */
404 };
407 /* The FUNCTION_DECL that will be called if this candidate is
408 selected by overload resolution. */
409 tree fn;
410 /* The arguments to use when calling this function. */
411 tree args;
412 /* The implicit conversion sequences for each of the arguments to
413 FN. */
415 /* The number of implicit conversion sequences. */
417 /* If FN is a user-defined conversion, the standard conversion
418 sequence from the type returned by FN to the desired destination
419 type. */
422 /* If FN is a member function, the binfo indicating the path used to
423 qualify the name of FN at the call site. This path is used to
424 determine whether or not FN is accessible if it is selected by
425 overload resolution. The DECL_CONTEXT of FN will always be a
426 (possibly improper) base of this binfo. */
427 tree access_path;
428 /* If FN is a non-static member function, the binfo indicating the
429 subobject to which the `this' pointer should be converted if FN
430 is selected by overload resolution. The type pointed to the by
431 the `this' pointer must correspond to the most derived class
432 indicated by the CONVERSION_PATH. */
433 tree conversion_path;
434 tree template_decl;
437 };
439 /* Returns true iff T is a null pointer constant in the sense of
440 [conv.ptr]. */
442 bool
444 {
445 /* [conv.ptr]
447 A null pointer constant is an integral constant expression
448 (_expr.const_) rvalue of integer type that evaluates to zero. */
453 {
457 }
459 }
461 /* Returns nonzero if PARMLIST consists of only default parms and/or
462 ellipsis. */
464 bool
466 {
472 }
474 /* Allocate N bytes of memory from the conversion obstack. The memory
475 is zeroed before being returned. */
479 {
482 {
485 }
489 }
491 /* Dynamically allocate a conversion. */
495 {
500 }
502 #ifdef ENABLE_CHECKING
504 /* Make sure that all memory on the conversion obstack has been
505 freed. */
507 void
509 {
513 }
517 /* Dynamically allocate an array of N conversions. */
521 {
523 }
527 {
531 /* We can't use buildl1 here because CODE could be USER_CONV, which
532 takes two arguments. In that case, the caller is responsible for
533 filling in the second argument. */
539 {
555 }
561 }
563 /* Build a representation of the identity conversion from EXPR to
564 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
568 {
576 }
578 /* Converting from EXPR to TYPE was ambiguous in the sense that there
579 were multiple user-defined conversions to accomplish the job.
580 Build a conversion that indicates that ambiguity. */
584 {
592 }
594 tree
596 {
600 }
602 /* Returns the standard conversion path (see [conv]) from type FROM to type
603 TO, if any. For proper handling of null pointer constants, you must
604 also pass the expression EXPR to convert from. If C_CAST_P is true,
605 this conversion is coming from a C-style cast. */
610 {
617 {
620 }
626 {
631 }
638 {
642 }
644 {
646 {
647 tree bitfield_type;
650 {
653 }
654 }
656 }
658 /* Allow conversion between `__complex__' data types. */
660 {
661 /* The standard conversion sequence to convert FROM to TO is
662 the standard conversion sequence to perform componentwise
663 conversion. */
668 {
671 }
672 else
676 }
686 {
687 /* For backwards brain damage compatibility, allow interconversion of
688 pointers and integers with a pedwarn. */
691 }
693 {
694 /* For backwards brain damage compatibility, allow interconversion of
695 enums and integers with a pedwarn. */
698 }
701 {
702 tree to_pointee;
703 tree from_pointee;
708 ;
712 {
713 from = build_pointer_type
717 }
719 {
724 && (same_type_ignoring_top_level_qualifiers_p
727 {
731 }
734 }
737 /* [conv.ptr]
739 An rvalue of type "pointer to cv D," where D is a
740 class type, can be converted to an rvalue of type
741 "pointer to cv B," where B is a base class (clause
742 _class.derived_) of D. If B is an inaccessible
743 (clause _class.access_) or ambiguous
744 (_class.member.lookup_) base class of D, a program
745 that necessitates this conversion is ill-formed.
746 Therefore, we use DERIVED_FROM_P, and do not check
747 access or uniqueness. */
749 {
750 from =
756 }
759 {
762 }
763 else
764 {
767 }
772 /* In a C-style cast, we ignore CV-qualification because we
773 are allowed to perform a static_cast followed by a
774 const_cast. */
779 /* converting from string constant to char *. */
782 {
785 }
786 else
790 }
792 {
812 }
814 {
815 /* [conv.bool]
817 An rvalue of arithmetic, enumeration, pointer, or pointer to
818 member type can be converted to an rvalue of type bool. */
823 {
831 }
834 }
835 /* We don't check for ENUMERAL_TYPE here because there are no standard
836 conversions to enum type. */
837 /* As an extension, allow conversion to complex type. */
839 {
844 /* Give this a better rank if it's a promotion. */
848 }
854 {
858 /* The derived-to-base conversion indicates the initialization
859 of a parameter with base type from an object of a derived
860 type. A temporary object is created to hold the result of
861 the conversion unless we're binding directly to a reference. */
863 }
864 else
868 }
870 /* Returns nonzero if T1 is reference-related to T2. */
872 static bool
874 {
878 /* [dcl.init.ref]
880 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
881 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
882 of T2. */
886 }
888 /* Returns nonzero if T1 is reference-compatible with T2. */
890 static bool
892 {
893 /* [dcl.init.ref]
895 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
896 reference-related to T2 and cv1 is the same cv-qualification as,
897 or greater cv-qualification than, cv2. */
900 }
902 /* Determine whether or not the EXPR (of class type S) can be
903 converted to T as in [over.match.ref]. */
907 {
908 tree conversions;
909 tree arglist;
911 tree t;
920 /* [over.match.ref]
922 Assuming that "cv1 T" is the underlying type of the reference
923 being initialized, and "cv S" is the type of the initializer
924 expression, with S a class type, the candidate functions are
925 selected as follows:
927 --The conversion functions of S and its base classes are
928 considered. Those that are not hidden within S and yield type
929 "reference to cv2 T2", where "cv1 T" is reference-compatible
930 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
932 The argument list has one argument, which is the initializer
933 expression. */
937 /* Conceptually, we should take the address of EXPR and put it in
938 the argument list. Unfortunately, however, that can result in
939 error messages, which we should not issue now because we are just
940 trying to find a conversion operator. Therefore, we use NULL,
941 cast to the appropriate type. */
948 {
952 {
958 /* If this is a template function, try to get an exact
959 match. */
961 {
964 NULL_TREE,
965 arglist,
966 reference_type,
969 LOOKUP_NORMAL,
970 DEDUCE_CONV);
973 {
974 /* Now, see if the conversion function really returns
975 an lvalue of the appropriate type. From the
976 point of view of unification, simply returning an
977 rvalue of the right type is good enough. */
982 {
985 }
986 }
987 }
993 LOOKUP_NORMAL);
996 {
998 /* Build a standard conversion sequence indicating the
999 binding from the reference type returned by the
1000 function to the desired REFERENCE_TYPE. */
1001 identity_conv
1004 NULL_TREE);
1005 cand->second_conv
1006 = (direct_reference_binding
1012 }
1013 }
1015 }
1018 /* If none of the conversion functions worked out, let our caller
1019 know. */
1027 /* Now that we know that this is the function we're going to use fix
1028 the dummy first argument. */
1033 /* Build a user-defined conversion sequence representing the
1034 conversion. */
1040 /* Merge it with the standard conversion sequence from the
1041 conversion function's return type to the desired type. */
1048 }
1050 /* A reference of the indicated TYPE is being bound directly to the
1051 expression represented by the implicit conversion sequence CONV.
1052 Return a conversion sequence for this binding. */
1056 {
1057 tree t;
1064 /* [over.ics.rank]
1066 When a parameter of reference type binds directly
1067 (_dcl.init.ref_) to an argument expression, the implicit
1068 conversion sequence is the identity conversion, unless the
1069 argument expression has a type that is a derived class of the
1070 parameter type, in which case the implicit conversion sequence is
1071 a derived-to-base Conversion.
1073 If the parameter binds directly to the result of applying a
1074 conversion function to the argument expression, the implicit
1075 conversion sequence is a user-defined conversion sequence
1076 (_over.ics.user_), with the second standard conversion sequence
1077 either an identity conversion or, if the conversion function
1078 returns an entity of a type that is a derived class of the
1079 parameter type, a derived-to-base conversion. */
1081 {
1082 /* Represent the derived-to-base conversion. */
1084 /* We will actually be binding to the base-class subobject in
1085 the derived class, so we mark this conversion appropriately.
1086 That way, convert_like knows not to generate a temporary. */
1088 }
1090 }
1092 /* Returns the conversion path from type FROM to reference type TO for
1093 purposes of reference binding. For lvalue binding, either pass a
1094 reference type to FROM or an lvalue expression to EXPR. If the
1095 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1096 the conversion returned. If C_CAST_P is true, this
1097 conversion is coming from a C-style cast. */
1101 {
1105 tree tfrom;
1111 {
1116 }
1119 {
1120 /* Anything with reference type is an lvalue. */
1123 }
1131 /* Figure out whether or not the types are reference-related and
1132 reference compatible. We have do do this after stripping
1133 references from FROM. */
1135 /* If this is a C cast, first convert to an appropriately qualified
1136 type, so that we can later do a const_cast to the desired type. */
1142 /* Directly bind reference when target expression's type is compatible with
1143 the reference and expression is an lvalue. In DR391, the wording in
1144 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1145 const and rvalue references to rvalues of compatible class type. */
1147 && (lvalue_p
1151 {
1152 /* [dcl.init.ref]
1154 If the initializer expression
1156 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1157 is reference-compatible with "cv2 T2,"
1159 the reference is bound directly to the initializer expression
1160 lvalue.
1162 [...]
1163 If the initializer expression is an rvalue, with T2 a class type,
1164 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1165 is bound to the object represented by the rvalue or to a sub-object
1166 within that object. */
1172 /* The top-level caller requested that we pretend that the lvalue
1173 be treated as an rvalue. */
1175 else
1176 conv->rvaluedness_matches_p
1181 /* For the purposes of overload resolution, we ignore the fact
1182 this expression is a bitfield or packed field. (In particular,
1183 [over.ics.ref] says specifically that a function with a
1184 non-const reference parameter is viable even if the
1185 argument is a bitfield.)
1187 However, when we actually call the function we must create
1188 a temporary to which to bind the reference. If the
1189 reference is volatile, or isn't const, then we cannot make
1190 a temporary, so we just issue an error when the conversion
1191 actually occurs. */
1195 }
1196 /* [class.conv.fct] A conversion function is never used to convert a
1197 (possibly cv-qualified) object to the (possibly cv-qualified) same
1198 object type (or a reference to it), to a (possibly cv-qualified) base
1199 class of that type (or a reference to it).... */
1202 {
1203 /* [dcl.init.ref]
1205 If the initializer expression
1207 -- has a class type (i.e., T2 is a class type) can be
1208 implicitly converted to an lvalue of type "cv3 T3," where
1209 "cv1 T1" is reference-compatible with "cv3 T3". (this
1210 conversion is selected by enumerating the applicable
1211 conversion functions (_over.match.ref_) and choosing the
1212 best one through overload resolution. (_over.match_).
1214 the reference is bound to the lvalue result of the conversion
1215 in the second case. */
1219 }
1221 /* From this point on, we conceptually need temporaries, even if we
1222 elide them. Only the cases above are "direct bindings". */
1226 /* [over.ics.rank]
1228 When a parameter of reference type is not bound directly to an
1229 argument expression, the conversion sequence is the one required
1230 to convert the argument expression to the underlying type of the
1231 reference according to _over.best.ics_. Conceptually, this
1232 conversion sequence corresponds to copy-initializing a temporary
1233 of the underlying type with the argument expression. Any
1234 difference in top-level cv-qualification is subsumed by the
1235 initialization itself and does not constitute a conversion. */
1237 /* [dcl.init.ref]
1239 Otherwise, the reference shall be to a non-volatile const type.
1241 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1245 /* [dcl.init.ref]
1247 Otherwise, a temporary of type "cv1 T1" is created and
1248 initialized from the initializer expression using the rules for a
1249 non-reference copy initialization. If T1 is reference-related to
1250 T2, cv1 must be the same cv-qualification as, or greater
1251 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1255 /* We're generating a temporary now, but don't bind any more in the
1256 conversion (specifically, don't slice the temporary returned by a
1257 conversion operator). */
1261 flags);
1266 /* This reference binding, unlike those above, requires the
1267 creation of a temporary. */
1272 }
1274 /* Returns the implicit conversion sequence (see [over.ics]) from type
1275 FROM to type TO. The optional expression EXPR may affect the
1276 conversion. FLAGS are the usual overloading flags. Only
1277 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1278 conversion is coming from a C-style cast. */
1283 {
1292 else
1302 {
1311 /* We used to try to bind a reference to a temporary here, but that
1312 is now handled after the recursive call to this function at the end
1313 of reference_binding. */
1315 }
1318 }
1320 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1321 functions. */
1329 {
1344 }
1346 /* Create an overload candidate for the function or method FN called with
1347 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1348 to implicit_conversion.
1350 CTYPE, if non-NULL, is the type we want to pretend this function
1351 comes from for purposes of overload resolution. */
1358 {
1363 tree orig_arglist;
1366 /* At this point we should not see any functions which haven't been
1367 explicitly declared, except for friend functions which will have
1368 been found using argument dependent lookup. */
1371 /* The `this', `in_chrg' and VTT arguments to constructors are not
1372 considered in overload resolution. */
1374 {
1378 }
1379 else
1385 /* 13.3.2 - Viable functions [over.match.viable]
1386 First, to be a viable function, a candidate function shall have enough
1387 parameters to agree in number with the arguments in the list.
1389 We need to check this first; otherwise, checking the ICSes might cause
1390 us to produce an ill-formed template instantiation. */
1394 {
1398 }
1403 /* Make sure there are default args for the rest of the parms. */
1410 /* Second, for F to be a viable function, there shall exist for each
1411 argument an implicit conversion sequence that converts that argument
1412 to the corresponding parameter of F. */
1418 {
1431 {
1434 /* The type of the implicit object parameter ('this') for
1435 overload resolution is not always the same as for the
1436 function itself; conversion functions are considered to
1437 be members of the class being converted, and functions
1438 introduced by a using-declaration are considered to be
1439 members of the class that uses them.
1441 Since build_over_call ignores the ICS for the `this'
1442 parameter, we can just change the parm type. */
1444 {
1445 parmtype
1449 }
1453 }
1454 else
1455 {
1458 }
1465 {
1468 }
1476 }
1478 out:
1481 }
1483 /* Create an overload candidate for the conversion function FN which will
1484 be invoked for expression OBJ, producing a pointer-to-function which
1485 will in turn be called with the argument list ARGLIST, and add it to
1486 CANDIDATES. FLAGS is passed on to implicit_conversion.
1488 Actually, we don't really care about FN; we care about the type it
1489 converts to. There may be multiple conversion functions that will
1490 convert to that type, and we rely on build_user_type_conversion_1 to
1491 choose the best one; so when we create our candidate, we record the type
1492 instead of the function. */
1497 {
1514 /* Don't bother looking up the same type twice. */
1519 {
1526 flags);
1532 else
1533 {
1536 }
1551 }
1561 }
1563 static void
1567 {
1581 {
1588 {
1590 /* We need something for printing the candidate. */
1592 }
1596 }
1598 /* For COND_EXPR we rearranged the arguments; undo that now. */
1600 {
1607 else
1609 }
1615 viable);
1616 }
1618 static bool
1620 {
1622 }
1624 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1626 static bool
1628 {
1629 /* [over.built]
1631 In this section, the term promoted integral type is used to refer
1632 to those integral types which are preserved by integral promotion
1633 (including e.g. int and long but excluding e.g. char).
1634 Similarly, the term promoted arithmetic type refers to promoted
1635 integral types plus floating types. */
1639 }
1641 /* Create any builtin operator overload candidates for the operator in
1642 question given the converted operand types TYPE1 and TYPE2. The other
1643 args are passed through from add_builtin_candidates to
1644 build_builtin_candidate.
1646 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1647 If CODE is requires candidates operands of the same type of the kind
1648 of which TYPE1 and TYPE2 are, we add both candidates
1649 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1651 static void
1655 {
1657 {
1665 }
1668 {
1670 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1671 and VQ is either volatile or empty, there exist candidate operator
1672 functions of the form
1673 VQ T& operator++(VQ T&);
1674 T operator++(VQ T&, int);
1675 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1676 type other than bool, and VQ is either volatile or empty, there exist
1677 candidate operator functions of the form
1678 VQ T& operator--(VQ T&);
1679 T operator--(VQ T&, int);
1680 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1681 complete object type, and VQ is either volatile or empty, there exist
1682 candidate operator functions of the form
1683 T*VQ& operator++(T*VQ&);
1684 T*VQ& operator--(T*VQ&);
1685 T* operator++(T*VQ&, int);
1686 T* operator--(T*VQ&, int); */
1695 {
1698 }
1701 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1702 exist candidate operator functions of the form
1704 T& operator*(T*);
1706 8 For every function type T, there exist candidate operator functions of
1707 the form
1708 T& operator*(T*); */
1717 /* 9 For every type T, there exist candidate operator functions of the form
1718 T* operator+(T*);
1720 10For every promoted arithmetic type T, there exist candidate operator
1721 functions of the form
1722 T operator+(T);
1723 T operator-(T); */
1733 /* 11For every promoted integral type T, there exist candidate operator
1734 functions of the form
1735 T operator~(T); */
1742 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1743 is the same type as C2 or is a derived class of C2, T is a complete
1744 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1745 there exist candidate operator functions of the form
1746 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1747 where CV12 is the union of CV1 and CV2. */
1752 {
1760 }
1763 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1764 didate operator functions of the form
1765 LR operator*(L, R);
1766 LR operator/(L, R);
1767 LR operator+(L, R);
1768 LR operator-(L, R);
1769 bool operator<(L, R);
1770 bool operator>(L, R);
1771 bool operator<=(L, R);
1772 bool operator>=(L, R);
1773 bool operator==(L, R);
1774 bool operator!=(L, R);
1775 where LR is the result of the usual arithmetic conversions between
1776 types L and R.
1778 14For every pair of types T and I, where T is a cv-qualified or cv-
1779 unqualified complete object type and I is a promoted integral type,
1780 there exist candidate operator functions of the form
1781 T* operator+(T*, I);
1782 T& operator[](T*, I);
1783 T* operator-(T*, I);
1784 T* operator+(I, T*);
1785 T& operator[](I, T*);
1787 15For every T, where T is a pointer to complete object type, there exist
1788 candidate operator functions of the form112)
1789 ptrdiff_t operator-(T, T);
1791 16For every pointer or enumeration type T, there exist candidate operator
1792 functions of the form
1793 bool operator<(T, T);
1794 bool operator>(T, T);
1795 bool operator<=(T, T);
1796 bool operator>=(T, T);
1797 bool operator==(T, T);
1798 bool operator!=(T, T);
1800 17For every pointer to member type T, there exist candidate operator
1801 functions of the form
1802 bool operator==(T, T);
1803 bool operator!=(T, T); */
1809 {
1812 }
1825 {
1828 }
1830 {
1833 }
1834 /* Fall through. */
1851 {
1854 }
1858 {
1861 }
1869 {
1872 }
1874 {
1877 }
1880 /* 18For every pair of promoted integral types L and R, there exist candi-
1881 date operator functions of the form
1882 LR operator%(L, R);
1883 LR operator&(L, R);
1884 LR operator^(L, R);
1885 LR operator|(L, R);
1886 L operator<<(L, R);
1887 L operator>>(L, R);
1888 where LR is the result of the usual arithmetic conversions between
1889 types L and R. */
1901 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1902 type, VQ is either volatile or empty, and R is a promoted arithmetic
1903 type, there exist candidate operator functions of the form
1904 VQ L& operator=(VQ L&, R);
1905 VQ L& operator*=(VQ L&, R);
1906 VQ L& operator/=(VQ L&, R);
1907 VQ L& operator+=(VQ L&, R);
1908 VQ L& operator-=(VQ L&, R);
1910 20For every pair T, VQ), where T is any type and VQ is either volatile
1911 or empty, there exist candidate operator functions of the form
1912 T*VQ& operator=(T*VQ&, T*);
1914 21For every pair T, VQ), where T is a pointer to member type and VQ is
1915 either volatile or empty, there exist candidate operator functions of
1916 the form
1917 VQ T& operator=(VQ T&, T);
1919 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1920 unqualified complete object type, VQ is either volatile or empty, and
1921 I is a promoted integral type, there exist candidate operator func-
1922 tions of the form
1923 T*VQ& operator+=(T*VQ&, I);
1924 T*VQ& operator-=(T*VQ&, I);
1926 23For every triple L, VQ, R), where L is an integral or enumeration
1927 type, VQ is either volatile or empty, and R is a promoted integral
1928 type, there exist candidate operator functions of the form
1930 VQ L& operator%=(VQ L&, R);
1931 VQ L& operator<<=(VQ L&, R);
1932 VQ L& operator>>=(VQ L&, R);
1933 VQ L& operator&=(VQ L&, R);
1934 VQ L& operator^=(VQ L&, R);
1935 VQ L& operator|=(VQ L&, R); */
1939 {
1943 {
1946 }
1972 {
1975 }
1980 }
1985 /* [over.built]
1987 For every pair of promoted arithmetic types L and R, there
1988 exist candidate operator functions of the form
1990 LR operator?(bool, L, R);
1992 where LR is the result of the usual arithmetic conversions
1993 between types L and R.
1995 For every type T, where T is a pointer or pointer-to-member
1996 type, there exist candidate operator functions of the form T
1997 operator?(bool, T, T); */
2001 /* That's OK. */
2004 /* Otherwise, the types should be pointers. */
2009 /* We don't check that the two types are the same; the logic
2010 below will actually create two candidates; one in which both
2011 parameter types are TYPE1, and one in which both parameter
2012 types are TYPE2. */
2017 }
2019 /* If we're dealing with two pointer types or two enumeral types,
2020 we need candidates for both of them. */
2029 {
2030 build_builtin_candidate
2032 build_builtin_candidate
2035 }
2037 build_builtin_candidate
2039 }
2041 tree
2043 {
2049 }
2051 /* There are three conditions of builtin candidates:
2053 1) bool-taking candidates. These are the same regardless of the input.
2054 2) pointer-pair taking candidates. These are generated for each type
2055 one of the input types converts to.
2056 3) arithmetic candidates. According to the standard, we should generate
2057 all of these, but I'm trying not to...
2059 Here we generate a superset of the possible candidates for this particular
2060 case. That is a subset of the full set the standard defines, plus some
2061 other cases which the standard disallows. add_builtin_candidate will
2062 filter out the invalid set. */
2064 static void
2068 {
2072 /* TYPES[i] is the set of possible builtin-operator parameter types
2073 we will consider for the Ith argument. These are represented as
2074 a TREE_LIST; the TREE_VALUE of each node is the potential
2075 parameter type. */
2079 {
2082 else
2084 }
2087 {
2088 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2089 and VQ is either volatile or empty, there exist candidate operator
2090 functions of the form
2091 VQ T& operator++(VQ T&); */
2101 /* 24There also exist candidate operator functions of the form
2102 bool operator!(bool);
2103 bool operator&&(bool, bool);
2104 bool operator||(bool, bool); */
2107 build_builtin_candidate
2114 build_builtin_candidate
2132 /* Fall through. */
2136 }
2141 {
2143 ;
2145 {
2146 tree convs;
2154 {
2161 }
2167 {
2180 {
2186 }
2190 }
2191 }
2192 else
2193 {
2199 {
2205 }
2207 }
2208 }
2210 /* Run through the possible parameter types of both arguments,
2211 creating candidates with those parameter types. */
2213 {
2216 add_builtin_candidate
2219 else
2220 add_builtin_candidate
2223 }
2224 }
2227 /* If TMPL can be successfully instantiated as indicated by
2228 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2230 TMPL is the template. EXPLICIT_TARGS are any explicit template
2231 arguments. ARGLIST is the arguments provided at the call-site.
2232 The RETURN_TYPE is the desired type for conversion operators. If
2233 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2234 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2235 add_conv_candidate. */
2242 unification_kind_t strict)
2243 {
2249 tree fn;
2251 /* We don't do deduction on the in-charge parameter, the VTT
2252 parameter or 'this'. */
2262 args_without_in_chrg,
2272 /* In [class.copy]:
2274 A member function template is never instantiated to perform the
2275 copy of a class object to an object of its class type.
2277 It's a little unclear what this means; the standard explicitly
2278 does allow a template to be used to copy a class. For example,
2279 in:
2281 struct A {
2282 A(A&);
2283 template <class T> A(const T&);
2284 };
2285 const A f ();
2286 void g () { A a (f ()); }
2288 the member template will be used to make the copy. The section
2289 quoted above appears in the paragraph that forbids constructors
2290 whose only parameter is (a possibly cv-qualified variant of) the
2291 class type, and a logical interpretation is that the intent was
2292 to forbid the instantiation of member templates which would then
2293 have that form. */
2295 {
2298 ctype))
2300 }
2303 /* Aha, this is a conversion function. */
2306 else
2311 /* This situation can occur if a member template of a template
2312 class is specialized. Then, instantiate_template might return
2313 an instantiation of the specialization, in which case the
2314 DECL_TI_TEMPLATE field will point at the original
2315 specialization. For example:
2317 template <class T> struct S { template <class U> void f(U);
2318 template <> void f(int) {}; };
2319 S<double> sd;
2320 sd.f(3);
2322 Here, TMPL will be template <class U> S<double>::f(U).
2323 And, instantiate template will give us the specialization
2324 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2325 for this will point at template <class T> template <> S<T>::f(int),
2326 so that we can find the definition. For the purposes of
2327 overload resolution, however, we want the original TMPL. */
2329 else
2333 }
2340 unification_kind_t strict)
2341 {
2342 return
2347 }
2354 {
2355 return
2359 }
2361 /* The CANDS are the set of candidates that were considered for
2362 overload resolution. Return the set of viable candidates. If none
2363 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2364 is true if a candidate should be considered viable only if it is
2365 strictly viable. */
2371 {
2382 {
2385 {
2391 }
2392 else
2394 }
2397 }
2399 static bool
2401 {
2406 }
2408 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2409 words, it is about to become the "this" pointer for a member
2410 function call. Take the address of the object. */
2412 static tree
2414 {
2415 /* In a template, we are only concerned about the type of the
2416 expression, so we can take a shortcut. */
2421 }
2423 /* Returns true iff functions are equivalent. Equivalent functions are
2424 not '==' only if one is a function-local extern function or if
2425 both are extern "C". */
2429 {
2434 }
2436 /* Print information about one overload candidate CANDIDATE. MSGSTR
2437 is the text to print before the candidate itself.
2439 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2440 to have been run through gettext by the caller. This wart makes
2441 life simpler in print_z_candidates and for the translators. */
2443 static void
2445 {
2447 {
2457 else
2460 }
2465 else
2467 }
2469 static void
2471 {
2476 /* There may be duplicates in the set of candidates. We put off
2477 checking this condition as long as possible, since we have no way
2478 to eliminate duplicates from a set of functions in less than n^2
2479 time. Now we are about to emit an error message, so it is more
2480 permissible to go slowly. */
2482 {
2484 /* Skip builtin candidates and conversion functions. */
2489 {
2493 else
2495 }
2496 }
2504 {
2505 /* Indent successive candidates by the width of the translation
2506 of the above string. */
2513 do
2514 {
2517 }
2519 }
2520 }
2522 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2523 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2524 the result of the conversion function to convert it to the final
2525 desired type. Merge the two sequences into a single sequence,
2526 and return the merged sequence. */
2530 {
2535 /* Find the end of the second conversion sequence. */
2540 /* Replace the identity conversion with the user conversion
2541 sequence. */
2544 /* The entire sequence is a user-conversion sequence. */
2548 }
2550 /* Returns the best overload candidate to perform the requested
2551 conversion. This function is used for three the overloading situations
2552 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2553 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2554 per [dcl.init.ref], so we ignore temporary bindings. */
2558 {
2568 /* We represent conversion within a hierarchy using RVALUE_CONV and
2569 BASE_CONV, as specified by [over.best.ics]; these become plain
2570 constructor calls, as specified in [dcl.init]. */
2578 {
2583 {
2584 /* [class.conv.fct] A conversion function is never used to
2585 convert a (possibly cv-qualified) object to the (possibly
2586 cv-qualified) same object type (or a reference to it), to a
2587 (possibly cv-qualified) base class of that type (or a
2588 reference to it)... */
2589 }
2590 else
2592 }
2597 /* It's OK to bind a temporary for converting constructor arguments, but
2598 not in converting the return value of a conversion operator. */
2603 {
2604 tree t;
2610 /* We should never try to call the abstract or base constructor
2611 from here. */
2615 }
2617 {
2627 flags,
2628 DEDUCE_CALL);
2629 else
2633 flags);
2637 }
2643 {
2644 tree fns;
2647 /* If we are called to convert to a reference type, we are trying to
2648 find an lvalue binding, so don't even consider temporaries. If
2649 we don't find an lvalue binding, the caller will try again to
2650 look for a temporary binding. */
2655 {
2658 /* [over.match.funcs] For conversion functions, the function
2659 is considered to be a member of the class of the implicit
2660 object argument for the purpose of defining the type of
2661 the implicit object parameter.
2663 So we pass fromtype as CTYPE to add_*_candidate. */
2667 NULL_TREE,
2670 conversion_path,
2671 flags,
2672 DEDUCE_CONV);
2673 else
2675 args,
2677 conversion_path,
2678 flags);
2681 {
2682 conversion *ics
2694 }
2695 }
2696 }
2704 {
2706 {
2710 }
2717 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2718 ambiguous conversion is no worse than another user-defined
2719 conversion. */
2722 }
2724 /* Build the user conversion sequence. */
2725 conv = build_conv
2732 /* Combine it with the second conversion sequence. */
2740 }
2742 tree
2744 {
2749 {
2754 }
2756 }
2758 /* Do any initial processing on the arguments to a function call. */
2760 static tree
2762 {
2763 tree t;
2765 {
2771 {
2774 }
2777 }
2779 }
2781 /* Perform overload resolution on FN, which is called with the ARGS.
2783 Return the candidate function selected by overload resolution, or
2784 NULL if the event that overload resolution failed. In the case
2785 that overload resolution fails, *CANDIDATES will be the set of
2786 candidates considered, and ANY_VIABLE_P will be set to true or
2787 false to indicate whether or not any of the candidates were
2788 viable.
2790 The ARGS should already have gone through RESOLVE_ARGS before this
2791 function is called. */
2795 tree args,
2798 {
2806 /* Check FN and ARGS. */
2814 {
2818 }
2820 /* Add the various candidate functions. */
2824 LOOKUP_NORMAL,
2825 candidates);
2833 }
2835 /* Return an expression for a call to FN (a namespace-scope function,
2836 or a static member function) with the ARGS. */
2838 tree
2840 {
2844 tree result;
2850 /* If this function was found without using argument dependent
2851 lookup, then we want to ignore any undeclared friend
2852 functions. */
2854 {
2859 {
2863 }
2864 }
2866 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2872 {
2880 else
2886 }
2887 else
2890 /* Free all the conversions we allocated. */
2894 }
2896 /* Build a call to a global operator new. FNNAME is the name of the
2897 operator (either "operator new" or "operator new[]") and ARGS are
2898 the arguments provided. *SIZE points to the total number of bytes
2899 required by the allocation, and is updated if that is changed here.
2900 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2901 function determines that no cookie should be used, after all,
2902 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2903 set, upon return, to the allocation function called. */
2905 tree
2909 {
2910 tree fns;
2922 /* Based on:
2924 [expr.new]
2926 If this lookup fails to find the name, or if the allocated type
2927 is not a class type, the allocation function's name is looked
2928 up in the global scope.
2930 we disregard block-scope declarations of "operator new". */
2933 /* Figure out what function is being called. */
2936 /* If no suitable function could be found, issue an error message
2937 and give up. */
2939 {
2943 else
2949 }
2951 /* If a cookie is required, add some extra space. Whether
2952 or not a cookie is required cannot be determined until
2953 after we know which function was called. */
2955 {
2958 {
2960 /* In G++ 3.2, the check was implemented incorrectly; it
2961 looked at the placement expression, rather than the
2962 type of the function. */
2965 ptr_type_node))
2967 }
2968 else
2969 {
2970 tree arg_types;
2973 /* Skip the size_t parameter. */
2975 /* Check the remaining parameters (if any). */
2979 ptr_type_node))
2981 }
2982 /* If we need a cookie, adjust the number of bytes allocated. */
2984 {
2985 /* Update the total size. */
2987 /* Update the argument list to reflect the adjusted size. */
2989 }
2990 else
2992 }
2994 /* Tell our caller which function we decided to call. */
2998 /* Build the CALL_EXPR. */
3000 }
3002 static tree
3004 {
3013 {
3014 /* It's no good looking for an overloaded operator() on a
3015 pointer-to-member-function. */
3016 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3018 }
3021 {
3025 }
3026 else
3034 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3038 {
3043 {
3051 else
3052 add_function_candidate
3055 }
3056 }
3061 {
3073 {
3076 add_template_conv_candidate
3080 else
3084 }
3085 }
3089 {
3093 }
3094 else
3095 {
3098 {
3102 }
3103 /* Since cand->fn will be a type, not a function, for a conversion
3104 function, we must be careful not to unconditionally look at
3105 DECL_NAME here. */
3109 else
3110 {
3114 }
3115 }
3117 /* Free all the conversions we allocated. */
3121 }
3123 static void
3126 {
3131 else
3135 {
3159 else
3163 }
3164 }
3166 /* Return the implicit conversion sequence that could be used to
3167 convert E1 to E2 in [expr.cond]. */
3171 {
3177 /* [expr.cond]
3179 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3180 implicitly converted (clause _conv_) to the type "reference to
3181 T2", subject to the constraint that in the conversion the
3182 reference must bind directly (_dcl.init.ref_) to E1. */
3184 {
3186 t1,
3187 e1,
3189 LOOKUP_NO_TEMP_BIND);
3192 }
3194 /* [expr.cond]
3196 If E1 and E2 have class type, and the underlying class types are
3197 the same or one is a base class of the other: E1 can be converted
3198 to match E2 if the class of T2 is the same type as, or a base
3199 class of, the class of T1, and the cv-qualification of T2 is the
3200 same cv-qualification as, or a greater cv-qualification than, the
3201 cv-qualification of T1. If the conversion is applied, E1 is
3202 changed to an rvalue of type T2 that still refers to the original
3203 source class object (or the appropriate subobject thereof). */
3206 {
3208 {
3213 else
3216 }
3217 else
3219 }
3220 else
3221 /* [expr.cond]
3223 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3224 converted to the type that expression E2 would have if E2 were
3225 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3227 LOOKUP_NORMAL);
3228 }
3230 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3231 arguments to the conditional expression. */
3233 tree
3235 {
3236 tree arg2_type;
3237 tree arg3_type;
3245 /* As a G++ extension, the second argument to the conditional can be
3246 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3247 c'.) If the second operand is omitted, make sure it is
3248 calculated only once. */
3250 {
3254 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3257 else
3259 }
3261 /* [expr.cond]
3263 The first expr ession is implicitly converted to bool (clause
3264 _conv_). */
3267 /* If something has already gone wrong, just pass that fact up the
3268 tree. */
3274 /* [expr.cond]
3276 If either the second or the third operand has type (possibly
3277 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3278 array-to-pointer (_conv.array_), and function-to-pointer
3279 (_conv.func_) standard conversions are performed on the second
3280 and third operands. */
3284 {
3285 /* Do the conversions. We don't these for `void' type arguments
3286 since it can't have any effect and since decay_conversion
3287 does not handle that case gracefully. */
3295 /* [expr.cond]
3297 One of the following shall hold:
3299 --The second or the third operand (but not both) is a
3300 throw-expression (_except.throw_); the result is of the
3301 type of the other and is an rvalue.
3303 --Both the second and the third operands have type void; the
3304 result is of type void and is an rvalue.
3306 We must avoid calling force_rvalue for expressions of type
3307 "void" because it will complain that their value is being
3308 used. */
3311 {
3316 }
3319 {
3324 }
3327 else
3328 {
3331 "is of type %<void%>, "
3332 "but the third operand is neither a throw-expression "
3334 else
3336 "is of type %<void%>, "
3337 "but the second operand is neither a throw-expression "
3340 }
3344 }
3345 /* [expr.cond]
3347 Otherwise, if the second and third operand have different types,
3348 and either has (possibly cv-qualified) class type, an attempt is
3349 made to convert each of those operands to the type of the other. */
3352 {
3356 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3362 /* [expr.cond]
3364 If both can be converted, or one can be converted but the
3365 conversion is ambiguous, the program is ill-formed. If
3366 neither can be converted, the operands are left unchanged and
3367 further checking is performed as described below. If exactly
3368 one conversion is possible, that conversion is applied to the
3369 chosen operand and the converted operand is used in place of
3370 the original operand for the remainder of this section. */
3375 {
3379 }
3381 {
3385 /* Even if CONV2 is a valid conversion, the result of the
3386 conversion may be invalid. For example, if ARG3 has type
3387 "volatile X", and X does not have a copy constructor
3388 accepting a "volatile X&", then even if ARG2 can be
3389 converted to X, the conversion will fail. */
3392 }
3394 {
3400 }
3402 /* Free all the conversions we allocated. */
3408 /* If, after the conversion, both operands have class type,
3409 treat the cv-qualification of both operands as if it were the
3410 union of the cv-qualification of the operands.
3412 The standard is not clear about what to do in this
3413 circumstance. For example, if the first operand has type
3414 "const X" and the second operand has a user-defined
3415 conversion to "volatile X", what is the type of the second
3416 operand after this step? Making it be "const X" (matching
3417 the first operand) seems wrong, as that discards the
3418 qualification without actually performing a copy. Leaving it
3419 as "volatile X" seems wrong as that will result in the
3420 conditional expression failing altogether, even though,
3421 according to this step, the one operand could be converted to
3422 the type of the other. */
3430 }
3432 /* [expr.cond]
3434 If the second and third operands are lvalues and have the same
3435 type, the result is of that type and is an lvalue. */
3439 {
3442 }
3444 /* [expr.cond]
3446 Otherwise, the result is an rvalue. If the second and third
3447 operand do not have the same type, and either has (possibly
3448 cv-qualified) class type, overload resolution is used to
3449 determine the conversions (if any) to be applied to the operands
3450 (_over.match.oper_, _over.built_). */
3454 {
3459 /* Rearrange the arguments so that add_builtin_candidate only has
3460 to know about two args. In build_builtin_candidates, the
3461 arguments are unscrambled. */
3466 COND_EXPR,
3467 NOP_EXPR,
3469 args,
3470 LOOKUP_NORMAL);
3472 /* [expr.cond]
3474 If the overload resolution fails, the program is
3475 ill-formed. */
3478 {
3482 }
3485 {
3489 }
3491 /* [expr.cond]
3493 Otherwise, the conversions thus determined are applied, and
3494 the converted operands are used in place of the original
3495 operands for the remainder of this section. */
3502 }
3504 /* [expr.cond]
3506 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3507 and function-to-pointer (_conv.func_) standard conversions are
3508 performed on the second and third operands.
3510 We need to force the lvalue-to-rvalue conversion here for class types,
3511 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3512 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3513 regions. */
3526 /* [expr.cond]
3528 After those conversions, one of the following shall hold:
3530 --The second and third operands have the same type; the result is of
3531 that type. */
3534 /* [expr.cond]
3536 --The second and third operands have arithmetic or enumeration
3537 type; the usual arithmetic conversions are performed to bring
3538 them to a common type, and the result is of that type. */
3543 {
3544 /* In this case, there is always a common type. */
3546 arg3_type);
3561 }
3562 /* [expr.cond]
3564 --The second and third operands have pointer type, or one has
3565 pointer type and the other is a null pointer constant; pointer
3566 conversions (_conv.ptr_) and qualification conversions
3567 (_conv.qual_) are performed to bring them to their composite
3568 pointer type (_expr.rel_). The result is of the composite
3569 pointer type.
3571 --The second and third operands have pointer to member type, or
3572 one has pointer to member type and the other is a null pointer
3573 constant; pointer to member conversions (_conv.mem_) and
3574 qualification conversions (_conv.qual_) are performed to bring
3575 them to a common type, whose cv-qualification shall match the
3576 cv-qualification of either the second or the third operand.
3577 The result is of the common type. */
3585 {
3592 }
3595 {
3599 }
3601 valid_operands:
3604 /* We can't use result_type below, as fold might have returned a
3605 throw_expr. */
3608 {
3609 /* Expand both sides into the same slot, hopefully the target of
3610 the ?: expression. We used to check for TARGET_EXPRs here,
3611 but now we sometimes wrap them in NOP_EXPRs so the test would
3612 fail. */
3615 /* If this expression is an rvalue, but might be mistaken for an
3616 lvalue, we must add a NON_LVALUE_EXPR. */
3618 }
3621 }
3623 /* OPERAND is an operand to an expression. Perform necessary steps
3624 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3625 returned. */
3627 static tree
3629 {
3631 {
3634 /* Make sure the template type is instantiated now. */
3636 }
3639 }
3641 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3642 OVERLOAD) to the CANDIDATES, returning an updated list of
3643 CANDIDATES. The ARGS are the arguments provided to the call,
3644 without any implicit object parameter. The EXPLICIT_TARGS are
3645 explicit template arguments provided. TEMPLATE_ONLY is true if
3646 only template functions should be considered. CONVERSION_PATH,
3647 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3649 static void
3655 {
3656 tree ctype;
3657 tree non_static_args;
3660 /* Delay creating the implicit this parameter until it is needed. */
3664 {
3665 tree fn;
3666 tree fn_args;
3669 /* Figure out which set of arguments to use. */
3671 {
3672 /* If this function is a non-static member, prepend the implicit
3673 object parameter. */
3679 }
3680 else
3681 /* Otherwise, just use the list of arguments provided. */
3686 fn,
3687 ctype,
3688 explicit_targs,
3689 fn_args,
3690 NULL_TREE,
3691 access_path,
3692 conversion_path,
3693 flags,
3694 DEDUCE_CALL);
3697 fn,
3698 ctype,
3699 fn_args,
3700 access_path,
3701 conversion_path,
3702 flags);
3704 }
3705 }
3707 tree
3710 {
3729 {
3733 }
3734 else
3740 {
3745 /* Use build_op_new_call and build_op_delete_call instead. */
3759 }
3765 {
3772 }
3787 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3790 /* Add namespace-scope operators to the list of functions to
3791 consider. */
3795 /* Add class-member operators to the candidate set. */
3797 {
3798 tree fns;
3802 {
3805 }
3812 }
3814 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3815 to know about two args; a builtin candidate will always have a first
3816 parameter of type bool. We'll handle that in
3817 build_builtin_candidate. */
3819 {
3823 }
3824 else
3825 {
3829 }
3834 {
3837 /* For these, the built-in candidates set is empty
3838 [over.match.oper]/3. We don't want non-strict matches
3839 because exact matches are always possible with built-in
3840 operators. The built-in candidate set for COMPONENT_REF
3841 would be empty too, but since there are no such built-in
3842 operators, we accept non-strict matches for them. */
3849 }
3853 {
3855 {
3858 /* Look for an `operator++ (int)'. If they didn't have
3859 one, then we fall back to the old way of doing things. */
3863 fnname,
3867 else
3870 overloaded_p);
3873 /* The caller will deal with these. */
3883 {
3886 }
3889 }
3890 }
3891 else
3892 {
3895 {
3897 {
3900 }
3902 }
3904 {
3910 else
3912 }
3913 else
3914 {
3915 /* Give any warnings we noticed during overload resolution. */
3917 {
3921 }
3923 /* Check for comparison of different enum types. */
3925 {
3936 {
3939 }
3943 }
3945 /* We need to strip any leading REF_BIND so that bitfields
3946 don't cause errors. This should not remove any important
3947 conversions, because builtins don't apply to class
3948 objects directly. */
3954 {
3959 }
3961 {
3966 }
3969 {
3972 }
3973 }
3974 }
3976 user_defined_result_ready:
3978 /* Free all the conversions we allocated. */
3984 builtin:
3986 {
4040 /* The caller will deal with these. */
4048 }
4050 }
4052 /* Build a call to operator delete. This has to be handled very specially,
4053 because the restrictions on what signatures match are different from all
4054 other call instances. For a normal delete, only a delete taking (void *)
4055 or (void *, size_t) is accepted. For a placement delete, only an exact
4056 match with the placement new is accepted.
4058 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4059 ADDR is the pointer to be deleted.
4060 SIZE is the size of the memory block to be deleted.
4061 GLOBAL_P is true if the delete-expression should not consider
4062 class-specific delete operators.
4063 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4065 If this call to "operator delete" is being generated as part to
4066 deallocate memory allocated via a new-expression (as per [expr.new]
4067 which requires that if the initialization throws an exception then
4068 we call a deallocation function), then ALLOC_FN is the allocation
4069 function. */
4071 tree
4074 tree alloc_fn)
4075 {
4090 /* In [class.free]
4092 If the result of the lookup is ambiguous or inaccessible, or if
4093 the lookup selects a placement deallocation function, the
4094 program is ill-formed.
4096 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4097 {
4101 }
4102 else
4108 /* Strip const and volatile from addr. */
4112 {
4113 /* Get the parameter types for the allocation function that is
4114 being called. */
4117 }
4118 else
4119 {
4120 /* First try it without the size argument. */
4122 }
4124 /* We make two tries at finding a matching `operator delete'. On
4125 the first pass, we look for a one-operator (or placement)
4126 operator delete. If we're not doing placement delete, then on
4127 the second pass we look for a two-argument delete. */
4129 {
4130 /* Go through the `operator delete' functions looking for one
4131 with a matching type. */
4133 fn;
4135 {
4136 tree t;
4138 /* The first argument must be "void *". */
4143 /* On the first pass, check the rest of the arguments. */
4145 {
4148 {
4153 }
4156 }
4157 /* On the second pass, look for a function with exactly two
4158 arguments: "void *" and "size_t". */
4160 /* For "operator delete(void *, ...)" there will be
4161 no second argument, but we will not get an exact
4162 match above. */
4163 && t
4167 }
4169 /* If we found a match, we're done. */
4172 }
4174 /* If we have a matching function, call it. */
4176 {
4177 /* Make sure we have the actual function, and not an
4178 OVERLOAD. */
4181 /* If the FN is a member function, make sure that it is
4182 accessible. */
4187 {
4188 /* The placement args might not be suitable for overload
4189 resolution at this point, so build the call directly. */
4198 }
4199 else
4200 {
4201 tree args;
4204 else
4208 }
4209 }
4211 /* [expr.new]
4213 If no unambiguous matching deallocation function can be found,
4214 propagating the exception does not cause the object's memory to
4215 be freed. */
4217 {
4220 alloc_fn);
4222 }
4227 }
4229 /* If the current scope isn't allowed to access DECL along
4230 BASETYPE_PATH, give an error. The most derived class in
4231 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4232 the declaration to use in the error diagnostic. */
4234 bool
4236 {
4240 {
4245 else
4249 }
4252 }
4254 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4255 bitwise or of LOOKUP_* values. If any errors are warnings are
4256 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4257 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4258 to NULL. */
4260 static tree
4263 {
4268 complete_ctor_identifier,
4275 else
4278 }
4280 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4281 EXPR is implicitly converted to type TOTYPE.
4282 FN and ARGNUM are used for diagnostics. */
4284 static void
4286 {
4289 /* Issue warnings about peculiar, but valid, uses of NULL. */
4291 {
4295 else
4297 }
4299 /* Issue warnings if "false" is converted to a NULL pointer */
4304 }
4306 /* Perform the conversions in CONVS on the expression EXPR. FN and
4307 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4308 indicates the `this' argument of a method. INNER is nonzero when
4309 being called to continue a conversion chain. It is negative when a
4310 reference binding will be applied, positive otherwise. If
4311 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4312 conversions will be emitted if appropriate. If C_CAST_P is true,
4313 this conversion is coming from a C-style cast; in that case,
4314 conversions to inaccessible bases are permitted. */
4316 static tree
4320 {
4322 diagnostic_fn_t diagnostic_fn;
4329 {
4332 {
4334 {
4339 }
4346 }
4351 }
4357 {
4359 {
4364 /* Set user_conv_p on the argument conversions, so rvalue/base
4365 handling knows not to allow any more UDCs. */
4371 /* If this is a constructor or a function returning an aggr type,
4372 we need to build up a TARGET_EXPR. */
4376 /* The result of the call is then used to direct-initialize the object
4377 that is the destination of the copy-initialization. [dcl.init]
4379 Note that this step is not reflected in the conversion sequence;
4380 it affects the semantics when we actually perform the
4381 conversion, but is not considered during overload resolution.
4383 If the target is a class, that means call a ctor. */
4386 {
4387 expr = (build_temp
4389 /* Core issue 84, now a DR, says that we don't
4390 allow UDCs for these args (which deliberately
4391 breaks copy-init of an auto_ptr<Base> from an
4392 auto_ptr<Derived>). */
4397 {
4399 diagnostic_fn
4402 else
4403 diagnostic_fn
4405 }
4407 }
4409 }
4413 /* Convert a constant to its underlying value, unless we are
4414 about to bind it to a reference, in which case we need to
4415 leave it as an lvalue. */
4417 {
4420 /* If __null has been converted to an integer type, we do not
4421 want to warn about uses of EXPR as an integer, rather than
4422 as a pointer. */
4424 }
4427 /* Call build_user_type_conversion again for the error. */
4428 return build_user_type_conversion
4433 };
4438 c_cast_p);
4443 {
4448 /* Else fall through. */
4451 {
4452 /* We are going to bind a reference directly to a base-class
4453 subobject of EXPR. */
4454 /* Build an expression for `*((base*) &expr)'. */
4460 }
4462 /* Copy-initialization where the cv-unqualified version of the source
4463 type is the same class as, or a derived class of, the class of the
4464 destination [is treated as direct-initialization]. [dcl.init] */
4467 /* This conversion is being done in the context of a user-defined
4468 conversion, so don't allow any more. */
4476 {
4479 /* If necessary, create a temporary.
4481 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4482 that need temporaries, even when their types are reference
4483 compatible with the type of reference being bound, so the
4484 upcoming call to build_unary_op (ADDR_EXPR, expr, ...)
4485 doesn't fail. */
4489 {
4495 {
4496 /* If the reference is volatile or non-const, we
4497 cannot create a temporary. */
4504 else
4507 }
4508 /* If the source is a packed field, and we must use a copy
4509 constructor, then building the target expr will require
4510 binding the field to the reference parameter to the
4511 copy constructor, and we'll end up with an infinite
4512 loop. If we can use a bitwise copy, then we'll be
4513 OK. */
4517 {
4521 }
4525 }
4527 /* Take the address of the thing to which we will bind the
4528 reference. */
4533 /* Convert it to a pointer to the type referred to by the
4534 reference. This will adjust the pointer if a derived to
4535 base conversion is being performed. */
4537 expr);
4538 /* Convert the pointer to the desired reference type. */
4540 }
4546 /* Warn about deprecated conversion if appropriate. */
4558 c_cast_p);
4562 }
4566 else
4570 }
4572 /* Build a call to __builtin_trap. */
4574 static tree
4576 {
4582 }
4584 /* ARG is being passed to a varargs function. Perform any conversions
4585 required. Return the converted value. */
4587 tree
4589 {
4590 /* [expr.call]
4592 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4593 standard conversions are performed. */
4595 /* [expr.call]
4597 If the argument has integral or enumeration type that is subject
4598 to the integral promotions (_conv.prom_), or a floating point
4599 type that is subject to the floating point promotion
4600 (_conv.fpprom_), the value of the argument is converted to the
4601 promoted type before the call. */
4613 {
4614 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4615 here and do a bitwise copy, but now cp_expr_size will abort if we
4616 try to do that.
4617 If the call appears in the context of a sizeof expression,
4618 there is no need to emit a warning, since the expression won't be
4619 evaluated. We keep the builtin_trap just as a safety check. */
4625 integer_zero_node);
4626 }
4629 }
4631 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4633 tree
4635 {
4645 {
4646 /* Remove reference types so we don't ICE later on. */
4648 /* Undefined behavior [expr.call] 5.2.2/7. */
4656 }
4659 }
4661 /* TYPE has been given to va_arg. Apply the default conversions which
4662 would have happened when passed via ellipsis. Return the promoted
4663 type, or the passed type if there is no change. */
4665 tree
4667 {
4668 tree promote;
4670 /* Perform the array-to-pointer and function-to-pointer
4671 conversions. */
4679 }
4681 /* ARG is a default argument expression being passed to a parameter of
4682 the indicated TYPE, which is a parameter to FN. Do any required
4683 conversions. Return the converted value. */
4687 tree
4689 {
4691 tree t;
4693 /* If the ARG is an unparsed default argument expression, the
4694 conversion cannot be performed. */
4696 {
4701 }
4703 /* Detect recursion. */
4706 {
4709 }
4718 {
4722 }
4723 else
4724 {
4725 /* We must make a copy of ARG, in case subsequent processing
4726 alters any part of it. For example, during gimplification a
4727 cast of the form (T) &X::f (where "f" is a member function)
4728 will lead to replacing the PTRMEM_CST for &X::f with a
4729 VAR_DECL. We can avoid the copy for constants, since they
4730 are never modified in place. */
4736 }
4741 }
4743 /* Returns the type which will really be used for passing an argument of
4744 type TYPE. */
4746 tree
4748 {
4749 /* Pass classes with copy ctors by invisible reference. */
4751 {
4753 /* There are no other pointers to this temporary. */
4755 }
4764 }
4766 /* Actually perform the appropriate conversion. */
4768 tree
4770 {
4771 tree bitfield_type;
4773 /* If VAL is a bitfield, then -- since it has already been converted
4774 to TYPE -- it cannot have a precision greater than TYPE.
4776 If it has a smaller precision, we must widen it here. For
4777 example, passing "int f:3;" to a function expecting an "int" will
4778 not result in any conversion before this point.
4780 If the precision is the same we must not risk widening. For
4781 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
4782 often have type "int", even though the C++ type for the field is
4783 "long long". If the value is being passed to a function
4784 expecting an "int", then no conversions will be required. But,
4785 if we call convert_bitfield_to_declared_type, the bitfield will
4786 be converted to "long long". */
4793 ;
4794 /* Pass classes with copy ctors by invisible reference. */
4804 {
4813 }
4815 }
4817 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4818 which no conversions at all should be done. This is true for some
4819 builtins which don't act like normal functions. */
4821 static bool
4823 {
4826 {
4836 }
4839 }
4841 /* Subroutine of the various build_*_call functions. Overload resolution
4842 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4843 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4844 bitmask of various LOOKUP_* flags which apply to the call itself. */
4846 static tree
4848 {
4862 /* In a template, there is no need to perform all of the work that
4863 is normally done. We are only interested in the type of the call
4864 expression, i.e., the return type of the function. Any semantic
4865 errors will be deferred until the template is instantiated. */
4867 {
4868 tree expr;
4869 tree return_type;
4877 }
4879 /* Give any warnings we noticed during overload resolution. */
4881 {
4885 }
4888 {
4889 /* If FN is a template function, two cases must be considered.
4890 For example:
4892 struct A {
4893 protected:
4894 template <class T> void f();
4895 };
4896 template <class T> struct B {
4897 protected:
4898 void g();
4899 };
4900 struct C : A, B<int> {
4901 using A::f; // #1
4902 using B<int>::g; // #2
4903 };
4905 In case #1 where `A::f' is a member template, DECL_ACCESS is
4906 recorded in the primary template but not in its specialization.
4907 We check access of FN using its primary template.
4909 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4910 because it is a member of class template B, DECL_ACCESS is
4911 recorded in the specialization `B<int>::g'. We cannot use its
4912 primary template because `B<T>::g' and `B<int>::g' may have
4913 different access. */
4918 else
4920 }
4926 /* Find maximum size of vector to hold converted arguments. */
4933 /* The implicit parameters to a constructor are not considered by overload
4934 resolution, and must be of the proper type. */
4936 {
4940 /* We should never try to call the abstract constructor. */
4944 {
4948 }
4949 }
4950 /* Bypass access control for 'this' parameter. */
4952 {
4955 tree converted_arg;
4956 tree base_binfo;
4962 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4963 X is called for an object that is not of type X, or of a type
4964 derived from X, the behavior is undefined.
4966 So we can assume that anything passed as 'this' is non-null, and
4967 optimize accordingly. */
4969 /* Convert to the base in which the function was declared. */
4975 /* Check that the base class is accessible. */
4981 /* If fn was found by a using declaration, the conversion path
4982 will be to the derived class, not the base declaring fn. We
4983 must convert from derived to base. */
4994 }
4998 {
5003 /* Don't make a copy here if build_call is going to. */
5009 val = convert_like_with_context
5014 }
5016 /* Default arguments */
5021 /* Ellipsis */
5023 {
5027 else
5030 }
5038 /* Avoid actually calling copy constructors and copy assignment operators,
5039 if possible. */
5046 {
5047 tree targ;
5050 /* Pull out the real argument, disregarding const-correctness. */
5057 {
5062 }
5063 else
5068 else
5071 /* [class.copy]: the copy constructor is implicitly defined even if
5072 the implementation elided its use. */
5076 /* If we're creating a temp and we already have one, don't create a
5077 new one. If we're not creating a temp but we get one, use
5078 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5079 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5080 temp or an INIT_EXPR otherwise. */
5082 {
5087 }
5091 {
5092 tree to = stabilize_reference
5097 }
5098 }
5102 {
5103 tree to = stabilize_reference
5110 {
5113 }
5114 else
5115 {
5116 /* We must only copy the non-tail padding parts.
5117 Use __builtin_memcpy for the bitwise copy. */
5129 }
5132 }
5137 {
5138 tree t;
5144 /* Warn about deprecated virtual functions now, since we're about
5145 to throw away the decl. */
5155 else
5158 }
5161 else
5165 }
5167 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5168 This function performs no overload resolution, conversion, or other
5169 high-level operations. */
5171 tree
5173 {
5174 tree fndecl;
5178 /* If this call might throw an exception, note that fact. */
5185 /* Some built-in function calls will be evaluated at compile-time in
5186 fold (). */
5199 }
5203 /* Make an expression which yields the address of the Java interface
5204 method FN. This is achieved by generating a call to libjava's
5205 _Jv_LookupInterfaceMethodIdx(). */
5207 static tree
5209 {
5215 {
5220 endlink)));
5221 java_iface_lookup_fn
5225 }
5227 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5228 This is the first entry in the vtable. */
5230 integer_zero_node);
5232 /* Get the java.lang.Class pointer for the interface being called. */
5237 {
5239 iface);
5241 }
5245 /* Determine the itable index of FN. */
5248 {
5253 i++;
5254 }
5259 java_iface_lookup_fn);
5262 }
5264 /* Returns the value to use for the in-charge parameter when making a
5265 call to a function with the indicated NAME.
5267 FIXME:Can't we find a neater way to do this mapping? */
5269 tree
5271 {
5282 /* This function should only be called with one of the names listed
5283 above. */
5286 }
5288 /* Build a call to a constructor, destructor, or an assignment
5289 operator for INSTANCE, an expression with class type. NAME
5290 indicates the special member function to call; ARGS are the
5291 arguments. BINFO indicates the base of INSTANCE that is to be
5292 passed as the `this' parameter to the member function called.
5294 FLAGS are the LOOKUP_* flags to use when processing the call.
5296 If NAME indicates a complete object constructor, INSTANCE may be
5297 NULL_TREE. In this case, the caller will call build_cplus_new to
5298 store the newly constructed object into a VAR_DECL. */
5300 tree
5303 {
5304 tree fns;
5305 /* The type of the subobject to be constructed or destroyed. */
5306 tree class_type;
5315 {
5316 /* Resolve the name. */
5321 }
5327 /* Handle the special case where INSTANCE is NULL_TREE. */
5329 {
5332 }
5333 else
5334 {
5340 /* Convert to the base class, if necessary. */
5343 {
5345 /* For constructors and destructors, either the base is
5346 non-virtual, or it is virtual but we are doing the
5347 conversion from a constructor or destructor for the
5348 complete object. In either case, we can convert
5349 statically. */
5351 else
5352 /* However, for assignment operators, we must convert
5353 dynamically if the base is virtual. */
5356 }
5357 }
5363 /* When making a call to a constructor or destructor for a subobject
5364 that uses virtual base classes, pass down a pointer to a VTT for
5365 the subobject. */
5369 {
5370 tree vtt;
5371 tree sub_vtt;
5373 /* If the current function is a complete object constructor
5374 or destructor, then we fetch the VTT directly.
5375 Otherwise, we look it up using the VTT we were given. */
5381 current_vtt_parm,
5382 vtt);
5388 }
5393 }
5395 /* Return the NAME, as a C string. The NAME indicates a function that
5396 is a member of TYPE. *FREE_P is set to true if the caller must
5397 free the memory returned.
5399 Rather than go through all of this, we should simply set the names
5400 of constructors and destructors appropriately, and dispense with
5401 ctor_identifier, dtor_identifier, etc. */
5405 {
5408 /* Assume that we will not allocate memory. */
5410 /* Constructors and destructors are special. */
5412 {
5413 pretty_name
5415 /* For a destructor, add the '~'. */
5419 {
5421 /* Remember that we need to free the memory allocated. */
5423 }
5424 }
5426 {
5429 TFF_PLAIN_IDENTIFIER),
5430 NULL);
5431 /* Remember that we need to free the memory allocated. */
5433 }
5434 else
5438 }
5440 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5441 be set, upon return, to the function called. */
5443 tree
5447 {
5451 tree access_binfo;
5452 tree optype;
5454 tree name;
5455 tree user_args;
5456 tree call;
5457 tree fn;
5458 tree class_type;
5461 tree orig_instance;
5462 tree orig_fns;
5463 tree orig_args;
5468 /* We don't know what function we're going to call, yet. */
5478 {
5481 }
5487 /* Dismantle the baselink to collect all the information we need. */
5494 {
5498 }
5509 {
5512 }
5514 /* The USER_ARGS are the arguments we will display to users if an
5515 error occurs. The USER_ARGS should not include any
5516 compiler-generated arguments. The "this" pointer hasn't been
5517 added yet. However, we must remove the VTT pointer if this is a
5518 call to a base-class constructor or destructor. */
5521 {
5522 /* Callers should explicitly indicate whether they want to construct
5523 the complete object or just the part without virtual bases. */
5525 /* Similarly for destructors. */
5527 /* Remove the VTT pointer, if present. */
5531 }
5533 /* Process the argument list. */
5540 /* It's OK to call destructors and constructors on cv-qualified objects.
5541 Therefore, convert the INSTANCE_PTR to the unqualified type, if
5542 necessary. */
5545 {
5549 }
5556 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5560 {
5562 tree this_arglist;
5564 /* We can end up here for copy-init of same or base class. */
5571 else
5575 /* A member template. */
5577 class_type,
5578 explicit_targs,
5580 access_binfo,
5581 conversion_path,
5582 flags,
5583 DEDUCE_CALL);
5586 class_type,
5587 this_arglist,
5588 access_binfo,
5589 conversion_path,
5590 flags);
5591 }
5595 {
5598 else
5599 {
5609 }
5612 }
5613 else
5614 {
5617 {
5623 user_args);
5628 }
5629 else
5630 {
5638 /* This is not an error, it is runtime undefined
5639 behavior. */
5641 "abstract virtual %q#D called from constructor"
5643 fn);
5647 {
5649 fn);
5651 }
5652 else
5653 {
5657 /* Now we know what function is being called. */
5660 /* Build the actual CALL_EXPR. */
5662 /* In an expression of the form `a->f()' where `f' turns
5663 out to be a static member function, `a' is
5664 none-the-less evaluated. */
5673 /* An explicit call of the form "x->~X()" has type
5674 "void". However, on platforms where destructors
5675 return "this" (i.e., those where
5676 targetm.cxx.cdtor_returns_this is true), such calls
5677 will appear to have a return value of pointer type
5678 to the low-level call machinery. We do not want to
5679 change the low-level machinery, since we want to be
5680 able to optimize "delete f()" on such platforms as
5681 "operator delete(~X(f()))" (rather than generating
5682 "t = f(), ~X(t), operator delete (t)"). */
5684 }
5685 }
5686 }
5689 call = (build_min_non_dep_call_list
5692 orig_args));
5694 /* Free all the conversions we allocated. */
5698 }
5700 /* Returns true iff standard conversion sequence ICS1 is a proper
5701 subsequence of ICS2. */
5703 static bool
5705 {
5706 /* We can assume that a conversion of the same code
5707 between the same types indicates a subsequence since we only get
5708 here if the types we are converting from are the same. */
5715 {
5723 /* At this point, ICS1 cannot be a proper subsequence of
5724 ICS2. We can get a USER_CONV when we are comparing the
5725 second standard conversion sequence of two user conversion
5726 sequences. */
5736 }
5737 }
5739 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5740 be any _TYPE nodes. */
5742 bool
5744 {
5749 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5750 considers every class derived from itself. */
5753 }
5755 /* We build the ICS for an implicit object parameter as a pointer
5756 conversion sequence. However, such a sequence should be compared
5757 as if it were a reference conversion sequence. If ICS is the
5758 implicit conversion sequence for an implicit object parameter,
5759 modify it accordingly. */
5761 static void
5763 {
5765 {
5766 /* [over.match.funcs]
5768 For non-static member functions, the type of the
5769 implicit object parameter is "reference to cv X"
5770 where X is the class of which the function is a
5771 member and cv is the cv-qualification on the member
5772 function declaration. */
5774 tree reference_type;
5776 /* The `this' parameter is a pointer to a class type. Make the
5777 implicit conversion talk about a reference to that same class
5778 type. */
5791 }
5792 }
5794 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5795 and return the initial reference binding conversion. Otherwise,
5796 leave *ICS unchanged and return NULL. */
5800 {
5802 {
5808 }
5811 }
5813 /* Compare two implicit conversion sequences according to the rules set out in
5814 [over.ics.rank]. Return values:
5816 1: ics1 is better than ics2
5817 -1: ics2 is better than ics1
5818 0: ics1 and ics2 are indistinguishable */
5820 static int
5822 {
5823 tree from_type1;
5824 tree from_type2;
5825 tree to_type1;
5826 tree to_type2;
5833 /* REF_BINDING is nonzero if the result of the conversion sequence
5834 is a reference type. In that case REF_CONV is the reference
5835 binding conversion. */
5839 /* Handle implicit object parameters. */
5843 /* Handle reference parameters. */
5847 /* [over.ics.rank]
5849 When comparing the basic forms of implicit conversion sequences (as
5850 defined in _over.best.ics_)
5852 --a standard conversion sequence (_over.ics.scs_) is a better
5853 conversion sequence than a user-defined conversion sequence
5854 or an ellipsis conversion sequence, and
5856 --a user-defined conversion sequence (_over.ics.user_) is a
5857 better conversion sequence than an ellipsis conversion sequence
5858 (_over.ics.ellipsis_). */
5868 {
5869 /* XXX Isn't this an extension? */
5870 /* Both ICS are bad. We try to make a decision based on what
5871 would have happened if they'd been good. */
5879 /* We couldn't make up our minds; try to figure it out below. */
5880 }
5883 /* Both conversions are ellipsis conversions. */
5886 /* User-defined conversion sequence U1 is a better conversion sequence
5887 than another user-defined conversion sequence U2 if they contain the
5888 same user-defined conversion operator or constructor and if the sec-
5889 ond standard conversion sequence of U1 is better than the second
5890 standard conversion sequence of U2. */
5893 {
5907 /* We can just fall through here, after setting up
5908 FROM_TYPE1 and FROM_TYPE2. */
5911 }
5912 else
5913 {
5917 /* We're dealing with two standard conversion sequences.
5919 [over.ics.rank]
5921 Standard conversion sequence S1 is a better conversion
5922 sequence than standard conversion sequence S2 if
5924 --S1 is a proper subsequence of S2 (comparing the conversion
5925 sequences in the canonical form defined by _over.ics.scs_,
5926 excluding any Lvalue Transformation; the identity
5927 conversion sequence is considered to be a subsequence of
5928 any non-identity conversion sequence */
5939 }
5941 /* One sequence can only be a subsequence of the other if they start with
5942 the same type. They can start with different types when comparing the
5943 second standard conversion sequence in two user-defined conversion
5944 sequences. */
5946 {
5951 }
5953 /* [over.ics.rank]
5955 Or, if not that,
5957 --the rank of S1 is better than the rank of S2 (by the rules
5958 defined below):
5960 Standard conversion sequences are ordered by their ranks: an Exact
5961 Match is a better conversion than a Promotion, which is a better
5962 conversion than a Conversion.
5964 Two conversion sequences with the same rank are indistinguishable
5965 unless one of the following rules applies:
5967 --A conversion that is not a conversion of a pointer, or pointer
5968 to member, to bool is better than another conversion that is such
5969 a conversion.
5971 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5972 so that we do not have to check it explicitly. */
5981 /* A conversion from scalar arithmetic type to complex is worse than a
5982 conversion between scalar arithmetic types. */
5989 {
5992 else
5994 }
6000 {
6005 }
6006 /* The rules for pointers to members A::* are just like the rules
6007 for pointers A*, except opposite: if B is derived from A then
6008 A::* converts to B::*, not vice versa. For that reason, we
6009 switch the from_ and to_ variables here. */
6016 {
6021 }
6026 {
6027 /* This was one of the pointer or pointer-like conversions.
6029 [over.ics.rank]
6031 --If class B is derived directly or indirectly from class A,
6032 conversion of B* to A* is better than conversion of B* to
6033 void*, and conversion of A* to void* is better than
6034 conversion of B* to void*. */
6037 {
6039 deref_from_type2))
6042 deref_from_type1))
6044 }
6047 {
6049 {
6051 {
6053 deref_to_type1))
6055 }
6056 /* We know that DEREF_TO_TYPE1 is `void' here. */
6058 deref_to_type2))
6060 }
6061 }
6064 {
6065 /* [over.ics.rank]
6067 --If class B is derived directly or indirectly from class A
6068 and class C is derived directly or indirectly from B,
6070 --conversion of C* to B* is better than conversion of C* to
6071 A*,
6073 --conversion of B* to A* is better than conversion of C* to
6074 A* */
6076 {
6078 deref_to_type2))
6081 deref_to_type1))
6083 }
6085 {
6087 deref_from_type1))
6090 deref_from_type2))
6092 }
6093 }
6094 }
6097 {
6100 /* [over.ics.rank]
6102 --binding of an expression of type C to a reference of type
6103 B& is better than binding an expression of type C to a
6104 reference of type A&
6106 --conversion of C to B is better than conversion of C to A, */
6109 {
6114 }
6115 }
6118 {
6121 /* [over.ics.rank]
6123 --binding of an expression of type B to a reference of type
6124 A& is better than binding an expression of type C to a
6125 reference of type A&,
6127 --conversion of B to A is better than conversion of C to A */
6130 {
6135 }
6136 }
6138 /* [over.ics.rank]
6140 --S1 and S2 differ only in their qualification conversion and yield
6141 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6142 qualification signature of type T1 is a proper subset of the cv-
6143 qualification signature of type T2 */
6147 {
6151 }
6153 /* [over.ics.rank]
6155 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6156 to an implicit object parameter, and either S1 binds an lvalue reference
6157 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6158 reference to an rvalue and S2 binds an lvalue reference
6159 (C++0x draft standard, 13.3.3.2)
6161 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6162 types to which the references refer are the same type except for
6163 top-level cv-qualifiers, and the type to which the reference
6164 initialized by S2 refers is more cv-qualified than the type to
6165 which the reference initialized by S1 refers */
6168 {
6172 {
6177 }
6182 }
6184 /* Neither conversion sequence is better than the other. */
6186 }
6188 /* The source type for this standard conversion sequence. */
6190 static tree
6192 {
6194 {
6199 }
6201 }
6203 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6204 a pointer to LOSER and re-running joust to produce the warning if WINNER
6205 is actually used. */
6207 static void
6209 {
6215 }
6217 /* Compare two candidates for overloading as described in
6218 [over.match.best]. Return values:
6220 1: cand1 is better than cand2
6221 -1: cand2 is better than cand1
6222 0: cand1 and cand2 are indistinguishable */
6224 static int
6226 {
6232 /* Candidates that involve bad conversions are always worse than those
6233 that don't. */
6239 /* If we have two pseudo-candidates for conversions to the same type,
6240 or two candidates for the same function, arbitrarily pick one. */
6245 /* a viable function F1
6246 is defined to be a better function than another viable function F2 if
6247 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6248 ICSi(F2), and then */
6250 /* for some argument j, ICSj(F1) is a better conversion sequence than
6251 ICSj(F2) */
6253 /* For comparing static and non-static member functions, we ignore
6254 the implicit object parameter of the non-static function. The
6255 standard says to pretend that the static function has an object
6256 parm, but that won't work with operator overloading. */
6259 {
6267 else
6268 {
6271 }
6272 }
6275 {
6281 {
6294 {
6301 else
6306 {
6310 }
6311 else
6313 }
6316 {
6319 }
6321 }
6322 }
6324 /* warn about confusing overload resolution for user-defined conversions,
6325 either between a constructor and a conversion op, or between two
6326 conversion ops. */
6330 {
6336 else
6339 /* We don't want to complain about `X::operator T1 ()'
6340 beating `X::operator T2 () const', when T2 is a no less
6341 cv-qualified version of T1. */
6344 {
6349 {
6352 }
6355 }
6356 else
6362 {
6370 }
6371 else
6373 }
6378 /* or, if not that,
6379 F1 is a non-template function and F2 is a template function
6380 specialization. */
6387 /* or, if not that,
6388 F1 and F2 are template functions and the function template for F1 is
6389 more specialized than the template for F2 according to the partial
6390 ordering rules. */
6393 {
6394 winner = more_specialized_fn
6397 /* [temp.func.order]: The presence of unused ellipsis and default
6398 arguments has no effect on the partial ordering of function
6399 templates. add_function_candidate() will not have
6400 counted the "this" argument for constructors. */
6404 }
6406 /* or, if not that,
6407 the context is an initialization by user-defined conversion (see
6408 _dcl.init_ and _over.match.user_) and the standard conversion
6409 sequence from the return type of F1 to the destination type (i.e.,
6410 the type of the entity being initialized) is a better conversion
6411 sequence than the standard conversion sequence from the return type
6412 of F2 to the destination type. */
6415 {
6419 }
6421 /* Check whether we can discard a builtin candidate, either because we
6422 have two identical ones or matching builtin and non-builtin candidates.
6424 (Pedantically in the latter case the builtin which matched the user
6425 function should not be added to the overload set, but we spot it here.
6427 [over.match.oper]
6428 ... the builtin candidates include ...
6429 - do not have the same parameter type list as any non-template
6430 non-member candidate. */
6434 {
6440 {
6442 /* Two built-in candidates; arbitrarily pick one. */
6445 /* cand1 is built-in; prefer cand2. */
6447 else
6448 /* cand2 is built-in; prefer cand1. */
6450 }
6451 }
6453 /* If the two functions are the same (this can happen with declarations
6454 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6459 tweak:
6461 /* Extension: If the worst conversion for one candidate is worse than the
6462 worst conversion for the other, take the first. */
6464 {
6469 {
6474 }
6480 {
6482 {
6484 ISO C++ says that these are ambiguous, even \
6485 though the worst conversion for the first is better than \
6489 }
6490 else
6493 }
6494 }
6498 }
6500 /* Given a list of candidates for overloading, find the best one, if any.
6501 This algorithm has a worst case of O(2n) (winner is last), and a best
6502 case of O(n/2) (totally ambiguous); much better than a sorting
6503 algorithm. */
6507 {
6512 /* Walk through the list once, comparing each current champ to the next
6513 candidate, knocking out a candidate or two with each comparison. */
6516 {
6520 else
6521 {
6523 {
6528 }
6529 else
6530 {
6533 }
6536 }
6537 }
6539 /* Make sure the champ is better than all the candidates it hasn't yet
6540 been compared to. */
6543 challenger != champ
6546 {
6550 }
6553 }
6555 /* Returns nonzero if things of type FROM can be converted to TO. */
6557 bool
6559 {
6561 }
6563 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6565 bool
6567 {
6572 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6576 flags);
6579 /* Free all the conversions we allocated. */
6583 }
6585 /* Like can_convert_arg, but allows dubious conversions as well. */
6587 bool
6589 {
6593 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6595 /* Try to perform the conversion. */
6597 LOOKUP_NORMAL);
6598 /* Free all the conversions we allocated. */
6602 }
6604 /* Convert EXPR to TYPE. Return the converted expression.
6606 Note that we allow bad conversions here because by the time we get to
6607 this point we are committed to doing the conversion. If we end up
6608 doing a bad conversion, convert_like will complain. */
6610 tree
6612 {
6619 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6624 LOOKUP_NORMAL);
6626 {
6629 }
6631 {
6632 /* In a template, we are only concerned about determining the
6633 type of non-dependent expressions, so we do not have to
6634 perform the actual conversion. */
6637 }
6638 else
6641 /* Free all the conversions we allocated. */
6645 }
6647 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6648 permitted. If the conversion is valid, the converted expression is
6649 returned. Otherwise, NULL_TREE is returned, except in the case
6650 that TYPE is a class type; in that case, an error is issued. If
6651 C_CAST_P is true, then this direction initialization is taking
6652 place as part of a static_cast being attempted as part of a C-style
6653 cast. */
6655 tree
6657 tree expr,
6659 {
6665 /* [dcl.init]
6667 If the destination type is a (possibly cv-qualified) class type:
6669 -- If the initialization is direct-initialization ...,
6670 constructors are considered. ... If no constructor applies, or
6671 the overload resolution is ambiguous, the initialization is
6672 ill-formed. */
6674 {
6679 }
6681 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6685 c_cast_p,
6686 LOOKUP_NORMAL);
6689 else
6692 c_cast_p);
6694 /* Free all the conversions we allocated. */
6698 }
6700 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6701 is being bound to a temporary. Create and return a new VAR_DECL
6702 with the indicated TYPE; this variable will store the value to
6703 which the reference is bound. */
6705 tree
6707 {
6708 tree var;
6710 /* Create the variable. */
6713 /* Register the variable. */
6715 {
6716 /* Namespace-scope or local static; give it a mangled name. */
6717 tree name;
6724 }
6725 else
6726 /* Create a new cleanup level if necessary. */
6730 }
6732 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6733 initializing a variable of that TYPE. If DECL is non-NULL, it is
6734 the VAR_DECL being initialized with the EXPR. (In that case, the
6735 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6736 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6737 return, if *CLEANUP is no longer NULL, it will be an expression
6738 that should be pushed as a cleanup after the returned expression
6739 is used to initialize DECL.
6741 Return the converted expression. */
6743 tree
6745 {
6752 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6756 LOOKUP_NORMAL);
6758 {
6764 else
6769 }
6771 /* If DECL is non-NULL, then this special rule applies:
6773 [class.temporary]
6775 The temporary to which the reference is bound or the temporary
6776 that is the complete object to which the reference is bound
6777 persists for the lifetime of the reference.
6779 The temporaries created during the evaluation of the expression
6780 initializing the reference, except the temporary to which the
6781 reference is bound, are destroyed at the end of the
6782 full-expression in which they are created.
6784 In that case, we store the converted expression into a new
6785 VAR_DECL in a new scope.
6787 However, we want to be careful not to create temporaries when
6788 they are not required. For example, given:
6790 struct B {};
6791 struct D : public B {};
6792 D f();
6793 const B& b = f();
6795 there is no need to copy the return value from "f"; we can just
6796 extend its lifetime. Similarly, given:
6798 struct S {};
6799 struct T { operator S(); };
6800 T t;
6801 const S& s = t;
6803 we can extend the lifetime of the return value of the conversion
6804 operator. */
6807 {
6808 tree var;
6809 tree base_conv_type;
6811 /* Skip over the REF_BIND. */
6813 /* If the next conversion is a BASE_CONV, skip that too -- but
6814 remember that the conversion was required. */
6816 {
6819 }
6820 else
6822 /* Perform the remainder of the conversion. */
6830 else
6831 {
6833 {
6834 tree init;
6835 tree type;
6837 /* Create the temporary variable. */
6841 /* If the rvalue is the result of a function call it will be
6842 a TARGET_EXPR. If it is some other construct (such as a
6843 member access expression where the underlying object is
6844 itself the result of a function call), turn it into a
6845 TARGET_EXPR here. It is important that EXPR be a
6846 TARGET_EXPR below since otherwise the INIT_EXPR will
6847 attempt to make a bitwise copy of EXPR to initialize
6848 VAR. */
6851 /* Create the INIT_EXPR that will initialize the temporary
6852 variable. */
6855 {
6860 else
6863 /* We must be careful to destroy the temporary only
6864 after its initialization has taken place. If the
6865 initialization throws an exception, then the
6866 destructor should not be run. We cannot simply
6867 transform INIT into something like:
6869 (INIT, ({ CLEANUP_STMT; }))
6871 because emit_local_var always treats the
6872 initializer as a full-expression. Thus, the
6873 destructor would run too early; it would run at the
6874 end of initializing the reference variable, rather
6875 than at the end of the block enclosing the
6876 reference variable.
6878 The solution is to pass back a cleanup expression
6879 which the caller is responsible for attaching to
6880 the statement tree. */
6881 }
6882 else
6883 {
6887 static_aggregates);
6888 }
6889 /* Use its address to initialize the reference variable. */
6897 }
6898 else
6899 /* Take the address of EXPR. */
6901 /* If a BASE_CONV was required, perform it now. */
6903 expr = (perform_implicit_conversion
6906 }
6907 }
6908 else
6909 /* Perform the conversion. */
6912 /* Free all the conversions we allocated. */
6916 }