842 return build_conv (ck_std, to, conv); 843 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE) 844 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from) 845 && is_properly_derived_from (from, to)) 846 { 847 if (conv->kind == ck_rvalue) 848 conv = conv->u.next; 849 conv = build_conv (ck_base, to, conv); 850 /* The derived-to-base conversion indicates the initialization 851 of a parameter with base type from an object of a derived 852 type. A temporary object is created to hold the result of 853 the conversion. */ 854 conv->need_temporary_p = true; 855 } 856 else 857 return NULL; 858 859 return conv; 860} 861 862/* Returns nonzero if T1 is reference-related to T2. */ 863 864static bool 865reference_related_p (tree t1, tree t2) 866{ 867 t1 = TYPE_MAIN_VARIANT (t1); 868 t2 = TYPE_MAIN_VARIANT (t2); 869 870 /* [dcl.init.ref] 871 872 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related 873 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class 874 of T2. */ 875 return (same_type_p (t1, t2) 876 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2) 877 && DERIVED_FROM_P (t1, t2))); 878} 879 880/* Returns nonzero if T1 is reference-compatible with T2. */ 881 882static bool 883reference_compatible_p (tree t1, tree t2) 884{ 885 /* [dcl.init.ref] 886 887 "cv1 T1" is reference compatible with "cv2 T2" if T1 is 888 reference-related to T2 and cv1 is the same cv-qualification as, 889 or greater cv-qualification than, cv2. */ 890 return (reference_related_p (t1, t2) 891 && at_least_as_qualified_p (t1, t2)); 892} 893 894/* Determine whether or not the EXPR (of class type S) can be 895 converted to T as in [over.match.ref]. */ 896 897static conversion * 898convert_class_to_reference (tree t, tree s, tree expr) 899{ 900 tree conversions; 901 tree arglist; 902 conversion *conv; 903 tree reference_type; 904 struct z_candidate *candidates; 905 struct z_candidate *cand; 906 bool any_viable_p; 907 908 conversions = lookup_conversions (s); 909 if (!conversions) 910 return NULL; 911 912 /* [over.match.ref] 913 914 Assuming that "cv1 T" is the underlying type of the reference 915 being initialized, and "cv S" is the type of the initializer 916 expression, with S a class type, the candidate functions are 917 selected as follows: 918 919 --The conversion functions of S and its base classes are 920 considered. Those that are not hidden within S and yield type 921 "reference to cv2 T2", where "cv1 T" is reference-compatible 922 (_dcl.init.ref_) with "cv2 T2", are candidate functions. 923 924 The argument list has one argument, which is the initializer 925 expression. */ 926 927 candidates = 0; 928 929 /* Conceptually, we should take the address of EXPR and put it in 930 the argument list. Unfortunately, however, that can result in 931 error messages, which we should not issue now because we are just 932 trying to find a conversion operator. Therefore, we use NULL, 933 cast to the appropriate type. */ 934 arglist = build_int_cst (build_pointer_type (s), 0); 935 arglist = build_tree_list (NULL_TREE, arglist); 936 937 reference_type = build_reference_type (t); 938 939 while (conversions) 940 { 941 tree fns = TREE_VALUE (conversions); 942 943 for (; fns; fns = OVL_NEXT (fns)) 944 { 945 tree f = OVL_CURRENT (fns); 946 tree t2 = TREE_TYPE (TREE_TYPE (f)); 947 948 cand = NULL; 949 950 /* If this is a template function, try to get an exact 951 match. */ 952 if (TREE_CODE (f) == TEMPLATE_DECL) 953 { 954 cand = add_template_candidate (&candidates, 955 f, s, 956 NULL_TREE, 957 arglist, 958 reference_type, 959 TYPE_BINFO (s), 960 TREE_PURPOSE (conversions), 961 LOOKUP_NORMAL, 962 DEDUCE_CONV); 963 964 if (cand) 965 { 966 /* Now, see if the conversion function really returns 967 an lvalue of the appropriate type. From the 968 point of view of unification, simply returning an 969 rvalue of the right type is good enough. */ 970 f = cand->fn; 971 t2 = TREE_TYPE (TREE_TYPE (f)); 972 if (TREE_CODE (t2) != REFERENCE_TYPE 973 || !reference_compatible_p (t, TREE_TYPE (t2))) 974 { 975 candidates = candidates->next; 976 cand = NULL; 977 } 978 } 979 } 980 else if (TREE_CODE (t2) == REFERENCE_TYPE 981 && reference_compatible_p (t, TREE_TYPE (t2))) 982 cand = add_function_candidate (&candidates, f, s, arglist, 983 TYPE_BINFO (s), 984 TREE_PURPOSE (conversions), 985 LOOKUP_NORMAL); 986 987 if (cand) 988 { 989 conversion *identity_conv; 990 /* Build a standard conversion sequence indicating the 991 binding from the reference type returned by the 992 function to the desired REFERENCE_TYPE. */ 993 identity_conv 994 = build_identity_conv (TREE_TYPE (TREE_TYPE 995 (TREE_TYPE (cand->fn))), 996 NULL_TREE); 997 cand->second_conv 998 = (direct_reference_binding 999 (reference_type, identity_conv)); 1000 cand->second_conv->bad_p |= cand->convs[0]->bad_p; 1001 } 1002 } 1003 conversions = TREE_CHAIN (conversions); 1004 } 1005 1006 candidates = splice_viable (candidates, pedantic, &any_viable_p); 1007 /* If none of the conversion functions worked out, let our caller 1008 know. */ 1009 if (!any_viable_p) 1010 return NULL; 1011 1012 cand = tourney (candidates); 1013 if (!cand) 1014 return NULL; 1015 1016 /* Now that we know that this is the function we're going to use fix 1017 the dummy first argument. */ 1018 cand->args = tree_cons (NULL_TREE, 1019 build_this (expr), 1020 TREE_CHAIN (cand->args)); 1021 1022 /* Build a user-defined conversion sequence representing the 1023 conversion. */ 1024 conv = build_conv (ck_user, 1025 TREE_TYPE (TREE_TYPE (cand->fn)), 1026 build_identity_conv (TREE_TYPE (expr), expr)); 1027 conv->cand = cand; 1028 1029 /* Merge it with the standard conversion sequence from the 1030 conversion function's return type to the desired type. */ 1031 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv); 1032 1033 if (cand->viable == -1) 1034 conv->bad_p = true; 1035 1036 return cand->second_conv; 1037} 1038 1039/* A reference of the indicated TYPE is being bound directly to the 1040 expression represented by the implicit conversion sequence CONV. 1041 Return a conversion sequence for this binding. */ 1042 1043static conversion * 1044direct_reference_binding (tree type, conversion *conv) 1045{ 1046 tree t; 1047 1048 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE); 1049 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE); 1050 1051 t = TREE_TYPE (type); 1052 1053 /* [over.ics.rank] 1054 1055 When a parameter of reference type binds directly 1056 (_dcl.init.ref_) to an argument expression, the implicit 1057 conversion sequence is the identity conversion, unless the 1058 argument expression has a type that is a derived class of the 1059 parameter type, in which case the implicit conversion sequence is 1060 a derived-to-base Conversion. 1061 1062 If the parameter binds directly to the result of applying a 1063 conversion function to the argument expression, the implicit 1064 conversion sequence is a user-defined conversion sequence 1065 (_over.ics.user_), with the second standard conversion sequence 1066 either an identity conversion or, if the conversion function 1067 returns an entity of a type that is a derived class of the 1068 parameter type, a derived-to-base conversion. */ 1069 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type)) 1070 { 1071 /* Represent the derived-to-base conversion. */ 1072 conv = build_conv (ck_base, t, conv); 1073 /* We will actually be binding to the base-class subobject in 1074 the derived class, so we mark this conversion appropriately. 1075 That way, convert_like knows not to generate a temporary. */ 1076 conv->need_temporary_p = false; 1077 } 1078 return build_conv (ck_ref_bind, type, conv); 1079} 1080 1081/* Returns the conversion path from type FROM to reference type TO for 1082 purposes of reference binding. For lvalue binding, either pass a 1083 reference type to FROM or an lvalue expression to EXPR. If the 1084 reference will be bound to a temporary, NEED_TEMPORARY_P is set for 1085 the conversion returned. If C_CAST_P is true, this 1086 conversion is coming from a C-style cast. */ 1087 1088static conversion * 1089reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags) 1090{ 1091 conversion *conv = NULL; 1092 tree to = TREE_TYPE (rto); 1093 tree from = rfrom; 1094 bool related_p; 1095 bool compatible_p; 1096 cp_lvalue_kind lvalue_p = clk_none; 1097 1098 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr)) 1099 { 1100 expr = instantiate_type (to, expr, tf_none); 1101 if (expr == error_mark_node) 1102 return NULL; 1103 from = TREE_TYPE (expr); 1104 } 1105 1106 if (TREE_CODE (from) == REFERENCE_TYPE) 1107 { 1108 /* Anything with reference type is an lvalue. */ 1109 lvalue_p = clk_ordinary; 1110 from = TREE_TYPE (from); 1111 } 1112 else if (expr) 1113 lvalue_p = real_lvalue_p (expr); 1114 1115 /* Figure out whether or not the types are reference-related and 1116 reference compatible. We have do do this after stripping 1117 references from FROM. */ 1118 related_p = reference_related_p (to, from); 1119 /* If this is a C cast, first convert to an appropriately qualified 1120 type, so that we can later do a const_cast to the desired type. */ 1121 if (related_p && c_cast_p 1122 && !at_least_as_qualified_p (to, from)) 1123 to = build_qualified_type (to, cp_type_quals (from)); 1124 compatible_p = reference_compatible_p (to, from); 1125 1126 if (lvalue_p && compatible_p) 1127 { 1128 /* [dcl.init.ref] 1129 1130 If the initializer expression 1131 1132 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1" 1133 is reference-compatible with "cv2 T2," 1134 1135 the reference is bound directly to the initializer expression 1136 lvalue. */ 1137 conv = build_identity_conv (from, expr); 1138 conv = direct_reference_binding (rto, conv); 1139 if ((lvalue_p & clk_bitfield) != 0 1140 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to))) 1141 /* For the purposes of overload resolution, we ignore the fact 1142 this expression is a bitfield or packed field. (In particular, 1143 [over.ics.ref] says specifically that a function with a 1144 non-const reference parameter is viable even if the 1145 argument is a bitfield.) 1146 1147 However, when we actually call the function we must create 1148 a temporary to which to bind the reference. If the 1149 reference is volatile, or isn't const, then we cannot make 1150 a temporary, so we just issue an error when the conversion 1151 actually occurs. */ 1152 conv->need_temporary_p = true; 1153 1154 return conv; 1155 } 1156 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION)) 1157 { 1158 /* [dcl.init.ref] 1159 1160 If the initializer expression 1161 1162 -- has a class type (i.e., T2 is a class type) can be 1163 implicitly converted to an lvalue of type "cv3 T3," where 1164 "cv1 T1" is reference-compatible with "cv3 T3". (this 1165 conversion is selected by enumerating the applicable 1166 conversion functions (_over.match.ref_) and choosing the 1167 best one through overload resolution. (_over.match_). 1168 1169 the reference is bound to the lvalue result of the conversion 1170 in the second case. */ 1171 conv = convert_class_to_reference (to, from, expr); 1172 if (conv) 1173 return conv; 1174 } 1175 1176 /* From this point on, we conceptually need temporaries, even if we 1177 elide them. Only the cases above are "direct bindings". */ 1178 if (flags & LOOKUP_NO_TEMP_BIND) 1179 return NULL; 1180 1181 /* [over.ics.rank] 1182 1183 When a parameter of reference type is not bound directly to an 1184 argument expression, the conversion sequence is the one required 1185 to convert the argument expression to the underlying type of the 1186 reference according to _over.best.ics_. Conceptually, this 1187 conversion sequence corresponds to copy-initializing a temporary 1188 of the underlying type with the argument expression. Any 1189 difference in top-level cv-qualification is subsumed by the 1190 initialization itself and does not constitute a conversion. */ 1191 1192 /* [dcl.init.ref] 1193 1194 Otherwise, the reference shall be to a non-volatile const type. */ 1195 if (!CP_TYPE_CONST_NON_VOLATILE_P (to)) 1196 return NULL; 1197 1198 /* [dcl.init.ref] 1199 1200 If the initializer expression is an rvalue, with T2 a class type, 1201 and "cv1 T1" is reference-compatible with "cv2 T2", the reference 1202 is bound in one of the following ways: 1203 1204 -- The reference is bound to the object represented by the rvalue 1205 or to a sub-object within that object. 1206 1207 -- ... 1208 1209 We use the first alternative. The implicit conversion sequence 1210 is supposed to be same as we would obtain by generating a 1211 temporary. Fortunately, if the types are reference compatible, 1212 then this is either an identity conversion or the derived-to-base 1213 conversion, just as for direct binding. */ 1214 if (CLASS_TYPE_P (from) && compatible_p) 1215 { 1216 conv = build_identity_conv (from, expr); 1217 conv = direct_reference_binding (rto, conv); 1218 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)) 1219 conv->u.next->check_copy_constructor_p = true; 1220 return conv; 1221 } 1222 1223 /* [dcl.init.ref] 1224 1225 Otherwise, a temporary of type "cv1 T1" is created and 1226 initialized from the initializer expression using the rules for a 1227 non-reference copy initialization. If T1 is reference-related to 1228 T2, cv1 must be the same cv-qualification as, or greater 1229 cv-qualification than, cv2; otherwise, the program is ill-formed. */ 1230 if (related_p && !at_least_as_qualified_p (to, from)) 1231 return NULL; 1232 1233 conv = implicit_conversion (to, from, expr, c_cast_p, 1234 flags); 1235 if (!conv) 1236 return NULL; 1237 1238 conv = build_conv (ck_ref_bind, rto, conv); 1239 /* This reference binding, unlike those above, requires the 1240 creation of a temporary. */ 1241 conv->need_temporary_p = true; 1242 1243 return conv; 1244} 1245 1246/* Returns the implicit conversion sequence (see [over.ics]) from type 1247 FROM to type TO. The optional expression EXPR may affect the 1248 conversion. FLAGS are the usual overloading flags. Only 1249 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this 1250 conversion is coming from a C-style cast. */ 1251 1252static conversion * 1253implicit_conversion (tree to, tree from, tree expr, bool c_cast_p, 1254 int flags) 1255{ 1256 conversion *conv; 1257 1258 if (from == error_mark_node || to == error_mark_node 1259 || expr == error_mark_node) 1260 return NULL; 1261 1262 if (TREE_CODE (to) == REFERENCE_TYPE) 1263 conv = reference_binding (to, from, expr, c_cast_p, flags); 1264 else 1265 conv = standard_conversion (to, from, expr, c_cast_p, flags); 1266 1267 if (conv) 1268 return conv; 1269 1270 if (expr != NULL_TREE 1271 && (IS_AGGR_TYPE (from) 1272 || IS_AGGR_TYPE (to)) 1273 && (flags & LOOKUP_NO_CONVERSION) == 0) 1274 { 1275 struct z_candidate *cand; 1276 1277 cand = build_user_type_conversion_1 1278 (to, expr, LOOKUP_ONLYCONVERTING); 1279 if (cand) 1280 conv = cand->second_conv; 1281 1282 /* We used to try to bind a reference to a temporary here, but that 1283 is now handled by the recursive call to this function at the end 1284 of reference_binding. */ 1285 return conv; 1286 } 1287 1288 return NULL; 1289} 1290 1291/* Add a new entry to the list of candidates. Used by the add_*_candidate 1292 functions. */ 1293 1294static struct z_candidate * 1295add_candidate (struct z_candidate **candidates, 1296 tree fn, tree args, 1297 size_t num_convs, conversion **convs, 1298 tree access_path, tree conversion_path, 1299 int viable) 1300{ 1301 struct z_candidate *cand = (struct z_candidate *) 1302 conversion_obstack_alloc (sizeof (struct z_candidate)); 1303 1304 cand->fn = fn; 1305 cand->args = args; 1306 cand->convs = convs; 1307 cand->num_convs = num_convs; 1308 cand->access_path = access_path; 1309 cand->conversion_path = conversion_path; 1310 cand->viable = viable; 1311 cand->next = *candidates; 1312 *candidates = cand; 1313 1314 return cand; 1315} 1316 1317/* Create an overload candidate for the function or method FN called with 1318 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on 1319 to implicit_conversion. 1320 1321 CTYPE, if non-NULL, is the type we want to pretend this function 1322 comes from for purposes of overload resolution. */ 1323 1324static struct z_candidate * 1325add_function_candidate (struct z_candidate **candidates, 1326 tree fn, tree ctype, tree arglist, 1327 tree access_path, tree conversion_path, 1328 int flags) 1329{ 1330 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn)); 1331 int i, len; 1332 conversion **convs; 1333 tree parmnode, argnode; 1334 tree orig_arglist; 1335 int viable = 1; 1336 1337 /* At this point we should not see any functions which haven't been 1338 explicitly declared, except for friend functions which will have 1339 been found using argument dependent lookup. */ 1340 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn)); 1341 1342 /* The `this', `in_chrg' and VTT arguments to constructors are not 1343 considered in overload resolution. */ 1344 if (DECL_CONSTRUCTOR_P (fn)) 1345 { 1346 parmlist = skip_artificial_parms_for (fn, parmlist); 1347 orig_arglist = arglist; 1348 arglist = skip_artificial_parms_for (fn, arglist); 1349 } 1350 else 1351 orig_arglist = arglist; 1352 1353 len = list_length (arglist); 1354 convs = alloc_conversions (len); 1355 1356 /* 13.3.2 - Viable functions [over.match.viable] 1357 First, to be a viable function, a candidate function shall have enough 1358 parameters to agree in number with the arguments in the list. 1359 1360 We need to check this first; otherwise, checking the ICSes might cause 1361 us to produce an ill-formed template instantiation. */ 1362 1363 parmnode = parmlist; 1364 for (i = 0; i < len; ++i) 1365 { 1366 if (parmnode == NULL_TREE || parmnode == void_list_node) 1367 break; 1368 parmnode = TREE_CHAIN (parmnode); 1369 } 1370 1371 if (i < len && parmnode) 1372 viable = 0; 1373 1374 /* Make sure there are default args for the rest of the parms. */ 1375 else if (!sufficient_parms_p (parmnode)) 1376 viable = 0; 1377 1378 if (! viable) 1379 goto out; 1380 1381 /* Second, for F to be a viable function, there shall exist for each 1382 argument an implicit conversion sequence that converts that argument 1383 to the corresponding parameter of F. */ 1384 1385 parmnode = parmlist; 1386 argnode = arglist; 1387 1388 for (i = 0; i < len; ++i) 1389 { 1390 tree arg = TREE_VALUE (argnode); 1391 tree argtype = lvalue_type (arg); 1392 conversion *t; 1393 int is_this; 1394 1395 if (parmnode == void_list_node) 1396 break; 1397 1398 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) 1399 && ! DECL_CONSTRUCTOR_P (fn)); 1400 1401 if (parmnode) 1402 { 1403 tree parmtype = TREE_VALUE (parmnode); 1404 1405 /* The type of the implicit object parameter ('this') for 1406 overload resolution is not always the same as for the 1407 function itself; conversion functions are considered to 1408 be members of the class being converted, and functions 1409 introduced by a using-declaration are considered to be 1410 members of the class that uses them. 1411 1412 Since build_over_call ignores the ICS for the `this' 1413 parameter, we can just change the parm type. */ 1414 if (ctype && is_this) 1415 { 1416 parmtype 1417 = build_qualified_type (ctype, 1418 TYPE_QUALS (TREE_TYPE (parmtype))); 1419 parmtype = build_pointer_type (parmtype); 1420 } 1421 1422 t = implicit_conversion (parmtype, argtype, arg, 1423 /*c_cast_p=*/false, flags); 1424 } 1425 else 1426 { 1427 t = build_identity_conv (argtype, arg); 1428 t->ellipsis_p = true; 1429 } 1430 1431 if (t && is_this) 1432 t->this_p = true; 1433 1434 convs[i] = t; 1435 if (! t) 1436 { 1437 viable = 0; 1438 break; 1439 } 1440 1441 if (t->bad_p) 1442 viable = -1; 1443 1444 if (parmnode) 1445 parmnode = TREE_CHAIN (parmnode); 1446 argnode = TREE_CHAIN (argnode); 1447 } 1448 1449 out: 1450 return add_candidate (candidates, fn, orig_arglist, len, convs, 1451 access_path, conversion_path, viable); 1452} 1453 1454/* Create an overload candidate for the conversion function FN which will 1455 be invoked for expression OBJ, producing a pointer-to-function which 1456 will in turn be called with the argument list ARGLIST, and add it to 1457 CANDIDATES. FLAGS is passed on to implicit_conversion. 1458 1459 Actually, we don't really care about FN; we care about the type it 1460 converts to. There may be multiple conversion functions that will 1461 convert to that type, and we rely on build_user_type_conversion_1 to 1462 choose the best one; so when we create our candidate, we record the type 1463 instead of the function. */ 1464 1465static struct z_candidate * 1466add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, 1467 tree arglist, tree access_path, tree conversion_path) 1468{ 1469 tree totype = TREE_TYPE (TREE_TYPE (fn)); 1470 int i, len, viable, flags; 1471 tree parmlist, parmnode, argnode; 1472 conversion **convs; 1473 1474 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; ) 1475 parmlist = TREE_TYPE (parmlist); 1476 parmlist = TYPE_ARG_TYPES (parmlist); 1477 1478 len = list_length (arglist) + 1; 1479 convs = alloc_conversions (len); 1480 parmnode = parmlist; 1481 argnode = arglist; 1482 viable = 1; 1483 flags = LOOKUP_NORMAL; 1484 1485 /* Don't bother looking up the same type twice. */ 1486 if (*candidates && (*candidates)->fn == totype) 1487 return NULL; 1488 1489 for (i = 0; i < len; ++i) 1490 { 1491 tree arg = i == 0 ? obj : TREE_VALUE (argnode); 1492 tree argtype = lvalue_type (arg); 1493 conversion *t; 1494 1495 if (i == 0) 1496 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false, 1497 flags); 1498 else if (parmnode == void_list_node) 1499 break; 1500 else if (parmnode) 1501 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, 1502 /*c_cast_p=*/false, flags); 1503 else 1504 { 1505 t = build_identity_conv (argtype, arg); 1506 t->ellipsis_p = true; 1507 } 1508 1509 convs[i] = t; 1510 if (! t) 1511 break; 1512 1513 if (t->bad_p) 1514 viable = -1; 1515 1516 if (i == 0) 1517 continue; 1518 1519 if (parmnode) 1520 parmnode = TREE_CHAIN (parmnode); 1521 argnode = TREE_CHAIN (argnode); 1522 } 1523 1524 if (i < len) 1525 viable = 0; 1526 1527 if (!sufficient_parms_p (parmnode)) 1528 viable = 0; 1529 1530 return add_candidate (candidates, totype, arglist, len, convs, 1531 access_path, conversion_path, viable); 1532} 1533 1534static void 1535build_builtin_candidate (struct z_candidate **candidates, tree fnname, 1536 tree type1, tree type2, tree *args, tree *argtypes, 1537 int flags) 1538{ 1539 conversion *t; 1540 conversion **convs; 1541 size_t num_convs; 1542 int viable = 1, i; 1543 tree types[2]; 1544 1545 types[0] = type1; 1546 types[1] = type2; 1547 1548 num_convs = args[2] ? 3 : (args[1] ? 2 : 1); 1549 convs = alloc_conversions (num_convs); 1550 1551 for (i = 0; i < 2; ++i) 1552 { 1553 if (! args[i]) 1554 break; 1555 1556 t = implicit_conversion (types[i], argtypes[i], args[i], 1557 /*c_cast_p=*/false, flags); 1558 if (! t) 1559 { 1560 viable = 0; 1561 /* We need something for printing the candidate. */ 1562 t = build_identity_conv (types[i], NULL_TREE); 1563 } 1564 else if (t->bad_p) 1565 viable = 0; 1566 convs[i] = t; 1567 } 1568 1569 /* For COND_EXPR we rearranged the arguments; undo that now. */ 1570 if (args[2]) 1571 { 1572 convs[2] = convs[1]; 1573 convs[1] = convs[0]; 1574 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], 1575 /*c_cast_p=*/false, flags); 1576 if (t) 1577 convs[0] = t; 1578 else 1579 viable = 0; 1580 } 1581 1582 add_candidate (candidates, fnname, /*args=*/NULL_TREE, 1583 num_convs, convs, 1584 /*access_path=*/NULL_TREE, 1585 /*conversion_path=*/NULL_TREE, 1586 viable); 1587} 1588 1589static bool 1590is_complete (tree t) 1591{ 1592 return COMPLETE_TYPE_P (complete_type (t)); 1593} 1594 1595/* Returns nonzero if TYPE is a promoted arithmetic type. */ 1596 1597static bool 1598promoted_arithmetic_type_p (tree type) 1599{ 1600 /* [over.built] 1601 1602 In this section, the term promoted integral type is used to refer 1603 to those integral types which are preserved by integral promotion 1604 (including e.g. int and long but excluding e.g. char). 1605 Similarly, the term promoted arithmetic type refers to promoted 1606 integral types plus floating types. */ 1607 return ((INTEGRAL_TYPE_P (type) 1608 && same_type_p (type_promotes_to (type), type)) 1609 || TREE_CODE (type) == REAL_TYPE); 1610} 1611 1612/* Create any builtin operator overload candidates for the operator in 1613 question given the converted operand types TYPE1 and TYPE2. The other 1614 args are passed through from add_builtin_candidates to 1615 build_builtin_candidate. 1616 1617 TYPE1 and TYPE2 may not be permissible, and we must filter them. 1618 If CODE is requires candidates operands of the same type of the kind 1619 of which TYPE1 and TYPE2 are, we add both candidates 1620 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */ 1621 1622static void 1623add_builtin_candidate (struct z_candidate **candidates, enum tree_code code, 1624 enum tree_code code2, tree fnname, tree type1, 1625 tree type2, tree *args, tree *argtypes, int flags) 1626{ 1627 switch (code) 1628 { 1629 case POSTINCREMENT_EXPR: 1630 case POSTDECREMENT_EXPR: 1631 args[1] = integer_zero_node; 1632 type2 = integer_type_node; 1633 break; 1634 default: 1635 break; 1636 } 1637 1638 switch (code) 1639 { 1640 1641/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type, 1642 and VQ is either volatile or empty, there exist candidate operator 1643 functions of the form 1644 VQ T& operator++(VQ T&); 1645 T operator++(VQ T&, int); 1646 5 For every pair T, VQ), where T is an enumeration type or an arithmetic 1647 type other than bool, and VQ is either volatile or empty, there exist 1648 candidate operator functions of the form 1649 VQ T& operator--(VQ T&); 1650 T operator--(VQ T&, int); 1651 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified 1652 complete object type, and VQ is either volatile or empty, there exist 1653 candidate operator functions of the form 1654 T*VQ& operator++(T*VQ&); 1655 T*VQ& operator--(T*VQ&); 1656 T* operator++(T*VQ&, int); 1657 T* operator--(T*VQ&, int); */ 1658 1659 case POSTDECREMENT_EXPR: 1660 case PREDECREMENT_EXPR: 1661 if (TREE_CODE (type1) == BOOLEAN_TYPE) 1662 return; 1663 case POSTINCREMENT_EXPR: 1664 case PREINCREMENT_EXPR: 1665 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1)) 1666 { 1667 type1 = build_reference_type (type1); 1668 break; 1669 } 1670 return; 1671 1672/* 7 For every cv-qualified or cv-unqualified complete object type T, there 1673 exist candidate operator functions of the form 1674 1675 T& operator*(T*); 1676 1677 8 For every function type T, there exist candidate operator functions of 1678 the form 1679 T& operator*(T*); */ 1680 1681 case INDIRECT_REF: 1682 if (TREE_CODE (type1) == POINTER_TYPE 1683 && (TYPE_PTROB_P (type1) 1684 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)) 1685 break; 1686 return; 1687 1688/* 9 For every type T, there exist candidate operator functions of the form 1689 T* operator+(T*); 1690 1691 10For every promoted arithmetic type T, there exist candidate operator 1692 functions of the form 1693 T operator+(T); 1694 T operator-(T); */ 1695 1696 case UNARY_PLUS_EXPR: /* unary + */ 1697 if (TREE_CODE (type1) == POINTER_TYPE) 1698 break; 1699 case NEGATE_EXPR: 1700 if (ARITHMETIC_TYPE_P (type1)) 1701 break; 1702 return; 1703 1704/* 11For every promoted integral type T, there exist candidate operator 1705 functions of the form 1706 T operator~(T); */ 1707 1708 case BIT_NOT_EXPR: 1709 if (INTEGRAL_TYPE_P (type1)) 1710 break; 1711 return; 1712 1713/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1 1714 is the same type as C2 or is a derived class of C2, T is a complete 1715 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs, 1716 there exist candidate operator functions of the form 1717 CV12 T& operator->*(CV1 C1*, CV2 T C2::*); 1718 where CV12 is the union of CV1 and CV2. */ 1719 1720 case MEMBER_REF: 1721 if (TREE_CODE (type1) == POINTER_TYPE 1722 && TYPE_PTR_TO_MEMBER_P (type2)) 1723 { 1724 tree c1 = TREE_TYPE (type1); 1725 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2); 1726 1727 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1) 1728 && (TYPE_PTRMEMFUNC_P (type2) 1729 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2)))) 1730 break; 1731 } 1732 return; 1733 1734/* 13For every pair of promoted arithmetic types L and R, there exist can- 1735 didate operator functions of the form 1736 LR operator*(L, R); 1737 LR operator/(L, R); 1738 LR operator+(L, R); 1739 LR operator-(L, R); 1740 bool operator<(L, R); 1741 bool operator>(L, R); 1742 bool operator<=(L, R); 1743 bool operator>=(L, R); 1744 bool operator==(L, R); 1745 bool operator!=(L, R); 1746 where LR is the result of the usual arithmetic conversions between 1747 types L and R. 1748 1749 14For every pair of types T and I, where T is a cv-qualified or cv- 1750 unqualified complete object type and I is a promoted integral type, 1751 there exist candidate operator functions of the form 1752 T* operator+(T*, I); 1753 T& operator[](T*, I); 1754 T* operator-(T*, I); 1755 T* operator+(I, T*); 1756 T& operator[](I, T*); 1757 1758 15For every T, where T is a pointer to complete object type, there exist 1759 candidate operator functions of the form112) 1760 ptrdiff_t operator-(T, T); 1761 1762 16For every pointer or enumeration type T, there exist candidate operator 1763 functions of the form 1764 bool operator<(T, T); 1765 bool operator>(T, T); 1766 bool operator<=(T, T); 1767 bool operator>=(T, T); 1768 bool operator==(T, T); 1769 bool operator!=(T, T); 1770 1771 17For every pointer to member type T, there exist candidate operator 1772 functions of the form 1773 bool operator==(T, T); 1774 bool operator!=(T, T); */ 1775 1776 case MINUS_EXPR: 1777 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2)) 1778 break; 1779 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) 1780 { 1781 type2 = ptrdiff_type_node; 1782 break; 1783 } 1784 case MULT_EXPR: 1785 case TRUNC_DIV_EXPR: 1786 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) 1787 break; 1788 return; 1789 1790 case EQ_EXPR: 1791 case NE_EXPR: 1792 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)) 1793 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))) 1794 break; 1795 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1])) 1796 { 1797 type2 = type1; 1798 break; 1799 } 1800 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0])) 1801 { 1802 type1 = type2; 1803 break; 1804 } 1805 /* Fall through. */ 1806 case LT_EXPR: 1807 case GT_EXPR: 1808 case LE_EXPR: 1809 case GE_EXPR: 1810 case MAX_EXPR: 1811 case MIN_EXPR: 1812 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) 1813 break; 1814 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) 1815 break; 1816 if (TREE_CODE (type1) == ENUMERAL_TYPE 1817 && TREE_CODE (type2) == ENUMERAL_TYPE) 1818 break; 1819 if (TYPE_PTR_P (type1) 1820 && null_ptr_cst_p (args[1]) 1821 && !uses_template_parms (type1)) 1822 { 1823 type2 = type1; 1824 break; 1825 } 1826 if (null_ptr_cst_p (args[0]) 1827 && TYPE_PTR_P (type2) 1828 && !uses_template_parms (type2)) 1829 { 1830 type1 = type2; 1831 break; 1832 } 1833 return; 1834 1835 case PLUS_EXPR: 1836 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) 1837 break; 1838 case ARRAY_REF: 1839 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2)) 1840 { 1841 type1 = ptrdiff_type_node; 1842 break; 1843 } 1844 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) 1845 { 1846 type2 = ptrdiff_type_node; 1847 break; 1848 } 1849 return; 1850 1851/* 18For every pair of promoted integral types L and R, there exist candi- 1852 date operator functions of the form 1853 LR operator%(L, R); 1854 LR operator&(L, R); 1855 LR operator^(L, R); 1856 LR operator|(L, R); 1857 L operator<<(L, R); 1858 L operator>>(L, R); 1859 where LR is the result of the usual arithmetic conversions between 1860 types L and R. */ 1861 1862 case TRUNC_MOD_EXPR: 1863 case BIT_AND_EXPR: 1864 case BIT_IOR_EXPR: 1865 case BIT_XOR_EXPR: 1866 case LSHIFT_EXPR: 1867 case RSHIFT_EXPR: 1868 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2)) 1869 break; 1870 return; 1871 1872/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration 1873 type, VQ is either volatile or empty, and R is a promoted arithmetic 1874 type, there exist candidate operator functions of the form 1875 VQ L& operator=(VQ L&, R); 1876 VQ L& operator*=(VQ L&, R); 1877 VQ L& operator/=(VQ L&, R); 1878 VQ L& operator+=(VQ L&, R); 1879 VQ L& operator-=(VQ L&, R); 1880 1881 20For every pair T, VQ), where T is any type and VQ is either volatile 1882 or empty, there exist candidate operator functions of the form 1883 T*VQ& operator=(T*VQ&, T*); 1884 1885 21For every pair T, VQ), where T is a pointer to member type and VQ is 1886 either volatile or empty, there exist candidate operator functions of 1887 the form 1888 VQ T& operator=(VQ T&, T); 1889 1890 22For every triple T, VQ, I), where T is a cv-qualified or cv- 1891 unqualified complete object type, VQ is either volatile or empty, and 1892 I is a promoted integral type, there exist candidate operator func- 1893 tions of the form 1894 T*VQ& operator+=(T*VQ&, I); 1895 T*VQ& operator-=(T*VQ&, I); 1896 1897 23For every triple L, VQ, R), where L is an integral or enumeration 1898 type, VQ is either volatile or empty, and R is a promoted integral 1899 type, there exist candidate operator functions of the form 1900 1901 VQ L& operator%=(VQ L&, R); 1902 VQ L& operator<<=(VQ L&, R); 1903 VQ L& operator>>=(VQ L&, R); 1904 VQ L& operator&=(VQ L&, R); 1905 VQ L& operator^=(VQ L&, R); 1906 VQ L& operator|=(VQ L&, R); */ 1907 1908 case MODIFY_EXPR: 1909 switch (code2) 1910 { 1911 case PLUS_EXPR: 1912 case MINUS_EXPR: 1913 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2)) 1914 { 1915 type2 = ptrdiff_type_node; 1916 break; 1917 } 1918 case MULT_EXPR: 1919 case TRUNC_DIV_EXPR: 1920 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) 1921 break; 1922 return; 1923 1924 case TRUNC_MOD_EXPR: 1925 case BIT_AND_EXPR: 1926 case BIT_IOR_EXPR: 1927 case BIT_XOR_EXPR: 1928 case LSHIFT_EXPR: 1929 case RSHIFT_EXPR: 1930 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2)) 1931 break; 1932 return; 1933 1934 case NOP_EXPR: 1935 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) 1936 break; 1937 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)) 1938 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) 1939 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)) 1940 || ((TYPE_PTRMEMFUNC_P (type1) 1941 || TREE_CODE (type1) == POINTER_TYPE) 1942 && null_ptr_cst_p (args[1]))) 1943 { 1944 type2 = type1; 1945 break; 1946 } 1947 return; 1948 1949 default: 1950 gcc_unreachable (); 1951 } 1952 type1 = build_reference_type (type1); 1953 break; 1954 1955 case COND_EXPR: 1956 /* [over.built] 1957 1958 For every pair of promoted arithmetic types L and R, there 1959 exist candidate operator functions of the form 1960 1961 LR operator?(bool, L, R); 1962 1963 where LR is the result of the usual arithmetic conversions 1964 between types L and R. 1965 1966 For every type T, where T is a pointer or pointer-to-member 1967 type, there exist candidate operator functions of the form T 1968 operator?(bool, T, T); */ 1969 1970 if (promoted_arithmetic_type_p (type1) 1971 && promoted_arithmetic_type_p (type2)) 1972 /* That's OK. */ 1973 break; 1974 1975 /* Otherwise, the types should be pointers. */ 1976 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1)) 1977 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2))) 1978 return; 1979 1980 /* We don't check that the two types are the same; the logic 1981 below will actually create two candidates; one in which both 1982 parameter types are TYPE1, and one in which both parameter 1983 types are TYPE2. */ 1984 break; 1985 1986 default: 1987 gcc_unreachable (); 1988 } 1989 1990 /* If we're dealing with two pointer types or two enumeral types, 1991 we need candidates for both of them. */ 1992 if (type2 && !same_type_p (type1, type2) 1993 && TREE_CODE (type1) == TREE_CODE (type2) 1994 && (TREE_CODE (type1) == REFERENCE_TYPE 1995 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2)) 1996 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)) 1997 || TYPE_PTRMEMFUNC_P (type1) 1998 || IS_AGGR_TYPE (type1) 1999 || TREE_CODE (type1) == ENUMERAL_TYPE)) 2000 { 2001 build_builtin_candidate 2002 (candidates, fnname, type1, type1, args, argtypes, flags); 2003 build_builtin_candidate 2004 (candidates, fnname, type2, type2, args, argtypes, flags); 2005 return; 2006 } 2007 2008 build_builtin_candidate 2009 (candidates, fnname, type1, type2, args, argtypes, flags); 2010} 2011 2012tree 2013type_decays_to (tree type) 2014{ 2015 if (TREE_CODE (type) == ARRAY_TYPE) 2016 return build_pointer_type (TREE_TYPE (type)); 2017 if (TREE_CODE (type) == FUNCTION_TYPE) 2018 return build_pointer_type (type); 2019 return type; 2020} 2021 2022/* There are three conditions of builtin candidates: 2023 2024 1) bool-taking candidates. These are the same regardless of the input. 2025 2) pointer-pair taking candidates. These are generated for each type 2026 one of the input types converts to. 2027 3) arithmetic candidates. According to the standard, we should generate 2028 all of these, but I'm trying not to... 2029 2030 Here we generate a superset of the possible candidates for this particular 2031 case. That is a subset of the full set the standard defines, plus some 2032 other cases which the standard disallows. add_builtin_candidate will 2033 filter out the invalid set. */ 2034 2035static void 2036add_builtin_candidates (struct z_candidate **candidates, enum tree_code code, 2037 enum tree_code code2, tree fnname, tree *args, 2038 int flags) 2039{ 2040 int ref1, i; 2041 int enum_p = 0; 2042 tree type, argtypes[3]; 2043 /* TYPES[i] is the set of possible builtin-operator parameter types 2044 we will consider for the Ith argument. These are represented as 2045 a TREE_LIST; the TREE_VALUE of each node is the potential 2046 parameter type. */ 2047 tree types[2]; 2048 2049 for (i = 0; i < 3; ++i) 2050 { 2051 if (args[i]) 2052 argtypes[i] = lvalue_type (args[i]); 2053 else 2054 argtypes[i] = NULL_TREE; 2055 } 2056 2057 switch (code) 2058 { 2059/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type, 2060 and VQ is either volatile or empty, there exist candidate operator 2061 functions of the form 2062 VQ T& operator++(VQ T&); */ 2063 2064 case POSTINCREMENT_EXPR: 2065 case PREINCREMENT_EXPR: 2066 case POSTDECREMENT_EXPR: 2067 case PREDECREMENT_EXPR: 2068 case MODIFY_EXPR: 2069 ref1 = 1; 2070 break; 2071 2072/* 24There also exist candidate operator functions of the form 2073 bool operator!(bool); 2074 bool operator&&(bool, bool); 2075 bool operator||(bool, bool); */ 2076 2077 case TRUTH_NOT_EXPR: 2078 build_builtin_candidate 2079 (candidates, fnname, boolean_type_node, 2080 NULL_TREE, args, argtypes, flags); 2081 return; 2082 2083 case TRUTH_ORIF_EXPR: 2084 case TRUTH_ANDIF_EXPR: 2085 build_builtin_candidate 2086 (candidates, fnname, boolean_type_node, 2087 boolean_type_node, args, argtypes, flags); 2088 return; 2089 2090 case ADDR_EXPR: 2091 case COMPOUND_EXPR: 2092 case COMPONENT_REF: 2093 return; 2094 2095 case COND_EXPR: 2096 case EQ_EXPR: 2097 case NE_EXPR: 2098 case LT_EXPR: 2099 case LE_EXPR: 2100 case GT_EXPR: 2101 case GE_EXPR: 2102 enum_p = 1; 2103 /* Fall through. */ 2104 2105 default: 2106 ref1 = 0; 2107 } 2108 2109 types[0] = types[1] = NULL_TREE; 2110 2111 for (i = 0; i < 2; ++i) 2112 { 2113 if (! args[i]) 2114 ; 2115 else if (IS_AGGR_TYPE (argtypes[i])) 2116 { 2117 tree convs; 2118 2119 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR) 2120 return; 2121 2122 convs = lookup_conversions (argtypes[i]); 2123 2124 if (code == COND_EXPR) 2125 { 2126 if (real_lvalue_p (args[i])) 2127 types[i] = tree_cons 2128 (NULL_TREE, build_reference_type (argtypes[i]), types[i]); 2129 2130 types[i] = tree_cons 2131 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]); 2132 } 2133 2134 else if (! convs) 2135 return; 2136 2137 for (; convs; convs = TREE_CHAIN (convs)) 2138 { 2139 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs)))); 2140 2141 if (i == 0 && ref1 2142 && (TREE_CODE (type) != REFERENCE_TYPE 2143 || CP_TYPE_CONST_P (TREE_TYPE (type)))) 2144 continue; 2145 2146 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE) 2147 types[i] = tree_cons (NULL_TREE, type, types[i]); 2148 2149 type = non_reference (type); 2150 if (i != 0 || ! ref1) 2151 { 2152 type = TYPE_MAIN_VARIANT (type_decays_to (type)); 2153 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE) 2154 types[i] = tree_cons (NULL_TREE, type, types[i]); 2155 if (INTEGRAL_TYPE_P (type)) 2156 type = type_promotes_to (type); 2157 } 2158 2159 if (! value_member (type, types[i])) 2160 types[i] = tree_cons (NULL_TREE, type, types[i]); 2161 } 2162 } 2163 else 2164 { 2165 if (code == COND_EXPR && real_lvalue_p (args[i])) 2166 types[i] = tree_cons 2167 (NULL_TREE, build_reference_type (argtypes[i]), types[i]); 2168 type = non_reference (argtypes[i]); 2169 if (i != 0 || ! ref1) 2170 { 2171 type = TYPE_MAIN_VARIANT (type_decays_to (type)); 2172 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE) 2173 types[i] = tree_cons (NULL_TREE, type, types[i]); 2174 if (INTEGRAL_TYPE_P (type)) 2175 type = type_promotes_to (type); 2176 } 2177 types[i] = tree_cons (NULL_TREE, type, types[i]); 2178 } 2179 } 2180 2181 /* Run through the possible parameter types of both arguments, 2182 creating candidates with those parameter types. */ 2183 for (; types[0]; types[0] = TREE_CHAIN (types[0])) 2184 { 2185 if (types[1]) 2186 for (type = types[1]; type; type = TREE_CHAIN (type)) 2187 add_builtin_candidate 2188 (candidates, code, code2, fnname, TREE_VALUE (types[0]), 2189 TREE_VALUE (type), args, argtypes, flags); 2190 else 2191 add_builtin_candidate 2192 (candidates, code, code2, fnname, TREE_VALUE (types[0]), 2193 NULL_TREE, args, argtypes, flags); 2194 } 2195} 2196 2197 2198/* If TMPL can be successfully instantiated as indicated by 2199 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES. 2200 2201 TMPL is the template. EXPLICIT_TARGS are any explicit template 2202 arguments. ARGLIST is the arguments provided at the call-site. 2203 The RETURN_TYPE is the desired type for conversion operators. If 2204 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate. 2205 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for 2206 add_conv_candidate. */ 2207 2208static struct z_candidate* 2209add_template_candidate_real (struct z_candidate **candidates, tree tmpl, 2210 tree ctype, tree explicit_targs, tree arglist, 2211 tree return_type, tree access_path, 2212 tree conversion_path, int flags, tree obj, 2213 unification_kind_t strict) 2214{ 2215 int ntparms = DECL_NTPARMS (tmpl); 2216 tree targs = make_tree_vec (ntparms); 2217 tree args_without_in_chrg = arglist; 2218 struct z_candidate *cand; 2219 int i; 2220 tree fn; 2221 2222 /* We don't do deduction on the in-charge parameter, the VTT 2223 parameter or 'this'. */ 2224 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl)) 2225 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg); 2226 2227 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl) 2228 || DECL_BASE_CONSTRUCTOR_P (tmpl)) 2229 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl))) 2230 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg); 2231 2232 i = fn_type_unification (tmpl, explicit_targs, targs, 2233 args_without_in_chrg, 2234 return_type, strict, flags); 2235 2236 if (i != 0) 2237 return NULL; 2238 2239 fn = instantiate_template (tmpl, targs, tf_none); 2240 if (fn == error_mark_node) 2241 return NULL; 2242 2243 /* In [class.copy]: 2244 2245 A member function template is never instantiated to perform the 2246 copy of a class object to an object of its class type. 2247 2248 It's a little unclear what this means; the standard explicitly 2249 does allow a template to be used to copy a class. For example, 2250 in: 2251 2252 struct A { 2253 A(A&); 2254 template <class T> A(const T&); 2255 }; 2256 const A f (); 2257 void g () { A a (f ()); } 2258 2259 the member template will be used to make the copy. The section 2260 quoted above appears in the paragraph that forbids constructors 2261 whose only parameter is (a possibly cv-qualified variant of) the 2262 class type, and a logical interpretation is that the intent was 2263 to forbid the instantiation of member templates which would then 2264 have that form. */ 2265 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2) 2266 { 2267 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn); 2268 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)), 2269 ctype)) 2270 return NULL; 2271 } 2272 2273 if (obj != NULL_TREE) 2274 /* Aha, this is a conversion function. */ 2275 cand = add_conv_candidate (candidates, fn, obj, access_path, 2276 conversion_path, arglist); 2277 else 2278 cand = add_function_candidate (candidates, fn, ctype, 2279 arglist, access_path, 2280 conversion_path, flags); 2281 if (DECL_TI_TEMPLATE (fn) != tmpl) 2282 /* This situation can occur if a member template of a template 2283 class is specialized. Then, instantiate_template might return 2284 an instantiation of the specialization, in which case the 2285 DECL_TI_TEMPLATE field will point at the original 2286 specialization. For example: 2287 2288 template <class T> struct S { template <class U> void f(U); 2289 template <> void f(int) {}; }; 2290 S<double> sd; 2291 sd.f(3); 2292 2293 Here, TMPL will be template <class U> S<double>::f(U). 2294 And, instantiate template will give us the specialization 2295 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field 2296 for this will point at template <class T> template <> S<T>::f(int), 2297 so that we can find the definition. For the purposes of 2298 overload resolution, however, we want the original TMPL. */ 2299 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE); 2300 else 2301 cand->template_decl = DECL_TEMPLATE_INFO (fn); 2302 2303 return cand; 2304} 2305 2306 2307static struct z_candidate * 2308add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype, 2309 tree explicit_targs, tree arglist, tree return_type, 2310 tree access_path, tree conversion_path, int flags, 2311 unification_kind_t strict) 2312{ 2313 return 2314 add_template_candidate_real (candidates, tmpl, ctype, 2315 explicit_targs, arglist, return_type, 2316 access_path, conversion_path, 2317 flags, NULL_TREE, strict); 2318} 2319 2320 2321static struct z_candidate * 2322add_template_conv_candidate (struct z_candidate **candidates, tree tmpl, 2323 tree obj, tree arglist, tree return_type, 2324 tree access_path, tree conversion_path) 2325{ 2326 return 2327 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE, 2328 arglist, return_type, access_path, 2329 conversion_path, 0, obj, DEDUCE_CONV); 2330} 2331 2332/* The CANDS are the set of candidates that were considered for 2333 overload resolution. Return the set of viable candidates. If none 2334 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P 2335 is true if a candidate should be considered viable only if it is 2336 strictly viable. */ 2337 2338static struct z_candidate* 2339splice_viable (struct z_candidate *cands, 2340 bool strict_p, 2341 bool *any_viable_p) 2342{ 2343 struct z_candidate *viable; 2344 struct z_candidate **last_viable; 2345 struct z_candidate **cand; 2346 2347 viable = NULL; 2348 last_viable = &viable; 2349 *any_viable_p = false; 2350 2351 cand = &cands; 2352 while (*cand) 2353 { 2354 struct z_candidate *c = *cand; 2355 if (strict_p ? c->viable == 1 : c->viable) 2356 { 2357 *last_viable = c; 2358 *cand = c->next; 2359 c->next = NULL; 2360 last_viable = &c->next; 2361 *any_viable_p = true; 2362 } 2363 else 2364 cand = &c->next; 2365 } 2366 2367 return viable ? viable : cands; 2368} 2369 2370static bool 2371any_strictly_viable (struct z_candidate *cands) 2372{ 2373 for (; cands; cands = cands->next) 2374 if (cands->viable == 1) 2375 return true; 2376 return false; 2377} 2378 2379/* OBJ is being used in an expression like "OBJ.f (...)". In other 2380 words, it is about to become the "this" pointer for a member 2381 function call. Take the address of the object. */ 2382 2383static tree 2384build_this (tree obj) 2385{ 2386 /* In a template, we are only concerned about the type of the 2387 expression, so we can take a shortcut. */ 2388 if (processing_template_decl) 2389 return build_address (obj); 2390 2391 return build_unary_op (ADDR_EXPR, obj, 0); 2392} 2393 2394/* Returns true iff functions are equivalent. Equivalent functions are 2395 not '==' only if one is a function-local extern function or if 2396 both are extern "C". */ 2397 2398static inline int 2399equal_functions (tree fn1, tree fn2) 2400{ 2401 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2) 2402 || DECL_EXTERN_C_FUNCTION_P (fn1)) 2403 return decls_match (fn1, fn2); 2404 return fn1 == fn2; 2405} 2406 2407/* Print information about one overload candidate CANDIDATE. MSGSTR 2408 is the text to print before the candidate itself. 2409 2410 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected 2411 to have been run through gettext by the caller. This wart makes 2412 life simpler in print_z_candidates and for the translators. */ 2413 2414static void 2415print_z_candidate (const char *msgstr, struct z_candidate *candidate) 2416{ 2417 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE) 2418 { 2419 if (candidate->num_convs == 3) 2420 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn, 2421 candidate->convs[0]->type, 2422 candidate->convs[1]->type, 2423 candidate->convs[2]->type); 2424 else if (candidate->num_convs == 2) 2425 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn, 2426 candidate->convs[0]->type, 2427 candidate->convs[1]->type); 2428 else 2429 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn, 2430 candidate->convs[0]->type); 2431 } 2432 else if (TYPE_P (candidate->fn)) 2433 inform ("%s %T <conversion>", msgstr, candidate->fn); 2434 else if (candidate->viable == -1) 2435 inform ("%s %+#D <near match>", msgstr, candidate->fn); 2436 else 2437 inform ("%s %+#D", msgstr, candidate->fn); 2438} 2439 2440static void 2441print_z_candidates (struct z_candidate *candidates) 2442{ 2443 const char *str; 2444 struct z_candidate *cand1; 2445 struct z_candidate **cand2; 2446 2447 /* There may be duplicates in the set of candidates. We put off 2448 checking this condition as long as possible, since we have no way 2449 to eliminate duplicates from a set of functions in less than n^2 2450 time. Now we are about to emit an error message, so it is more 2451 permissible to go slowly. */ 2452 for (cand1 = candidates; cand1; cand1 = cand1->next) 2453 { 2454 tree fn = cand1->fn; 2455 /* Skip builtin candidates and conversion functions. */ 2456 if (TREE_CODE (fn) != FUNCTION_DECL) 2457 continue; 2458 cand2 = &cand1->next; 2459 while (*cand2) 2460 { 2461 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL 2462 && equal_functions (fn, (*cand2)->fn)) 2463 *cand2 = (*cand2)->next; 2464 else 2465 cand2 = &(*cand2)->next; 2466 } 2467 } 2468 2469 if (!candidates) 2470 return; 2471 2472 str = _("candidates are:"); 2473 print_z_candidate (str, candidates); 2474 if (candidates->next) 2475 { 2476 /* Indent successive candidates by the width of the translation 2477 of the above string. */ 2478 size_t len = gcc_gettext_width (str) + 1; 2479 char *spaces = (char *) alloca (len); 2480 memset (spaces, ' ', len-1); 2481 spaces[len - 1] = '\0'; 2482 2483 candidates = candidates->next; 2484 do 2485 { 2486 print_z_candidate (spaces, candidates); 2487 candidates = candidates->next; 2488 } 2489 while (candidates); 2490 } 2491} 2492 2493/* USER_SEQ is a user-defined conversion sequence, beginning with a 2494 USER_CONV. STD_SEQ is the standard conversion sequence applied to 2495 the result of the conversion function to convert it to the final 2496 desired type. Merge the two sequences into a single sequence, 2497 and return the merged sequence. */ 2498 2499static conversion * 2500merge_conversion_sequences (conversion *user_seq, conversion *std_seq) 2501{ 2502 conversion **t; 2503 2504 gcc_assert (user_seq->kind == ck_user); 2505 2506 /* Find the end of the second conversion sequence. */ 2507 t = &(std_seq); 2508 while ((*t)->kind != ck_identity) 2509 t = &((*t)->u.next); 2510 2511 /* Replace the identity conversion with the user conversion 2512 sequence. */ 2513 *t = user_seq; 2514 2515 /* The entire sequence is a user-conversion sequence. */ 2516 std_seq->user_conv_p = true; 2517 2518 return std_seq; 2519} 2520 2521/* Returns the best overload candidate to perform the requested 2522 conversion. This function is used for three the overloading situations 2523 described in [over.match.copy], [over.match.conv], and [over.match.ref]. 2524 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as 2525 per [dcl.init.ref], so we ignore temporary bindings. */ 2526 2527static struct z_candidate * 2528build_user_type_conversion_1 (tree totype, tree expr, int flags) 2529{ 2530 struct z_candidate *candidates, *cand; 2531 tree fromtype = TREE_TYPE (expr); 2532 tree ctors = NULL_TREE; 2533 tree conv_fns = NULL_TREE; 2534 conversion *conv = NULL; 2535 tree args = NULL_TREE; 2536 bool any_viable_p; 2537 2538 /* We represent conversion within a hierarchy using RVALUE_CONV and 2539 BASE_CONV, as specified by [over.best.ics]; these become plain 2540 constructor calls, as specified in [dcl.init]. */ 2541 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype) 2542 || !DERIVED_FROM_P (totype, fromtype)); 2543 2544 if (IS_AGGR_TYPE (totype)) 2545 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0); 2546 2547 if (IS_AGGR_TYPE (fromtype)) 2548 conv_fns = lookup_conversions (fromtype); 2549 2550 candidates = 0; 2551 flags |= LOOKUP_NO_CONVERSION; 2552 2553 if (ctors) 2554 { 2555 tree t; 2556 2557 ctors = BASELINK_FUNCTIONS (ctors); 2558 2559 t = build_int_cst (build_pointer_type (totype), 0); 2560 args = build_tree_list (NULL_TREE, expr); 2561 /* We should never try to call the abstract or base constructor 2562 from here. */ 2563 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors)) 2564 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors))); 2565 args = tree_cons (NULL_TREE, t, args); 2566 } 2567 for (; ctors; ctors = OVL_NEXT (ctors)) 2568 { 2569 tree ctor = OVL_CURRENT (ctors); 2570 if (DECL_NONCONVERTING_P (ctor)) 2571 continue; 2572 2573 if (TREE_CODE (ctor) == TEMPLATE_DECL) 2574 cand = add_template_candidate (&candidates, ctor, totype, 2575 NULL_TREE, args, NULL_TREE, 2576 TYPE_BINFO (totype), 2577 TYPE_BINFO (totype), 2578 flags, 2579 DEDUCE_CALL); 2580 else 2581 cand = add_function_candidate (&candidates, ctor, totype, 2582 args, TYPE_BINFO (totype), 2583 TYPE_BINFO (totype), 2584 flags); 2585 2586 if (cand) 2587 cand->second_conv = build_identity_conv (totype, NULL_TREE); 2588 } 2589 2590 if (conv_fns) 2591 args = build_tree_list (NULL_TREE, build_this (expr)); 2592 2593 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns)) 2594 { 2595 tree fns; 2596 tree conversion_path = TREE_PURPOSE (conv_fns); 2597 int convflags = LOOKUP_NO_CONVERSION; 2598 2599 /* If we are called to convert to a reference type, we are trying to 2600 find an lvalue binding, so don't even consider temporaries. If 2601 we don't find an lvalue binding, the caller will try again to 2602 look for a temporary binding. */ 2603 if (TREE_CODE (totype) == REFERENCE_TYPE) 2604 convflags |= LOOKUP_NO_TEMP_BIND; 2605 2606 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns)) 2607 { 2608 tree fn = OVL_CURRENT (fns); 2609 2610 /* [over.match.funcs] For conversion functions, the function 2611 is considered to be a member of the class of the implicit 2612 object argument for the purpose of defining the type of 2613 the implicit object parameter. 2614 2615 So we pass fromtype as CTYPE to add_*_candidate. */ 2616 2617 if (TREE_CODE (fn) == TEMPLATE_DECL) 2618 cand = add_template_candidate (&candidates, fn, fromtype, 2619 NULL_TREE, 2620 args, totype, 2621 TYPE_BINFO (fromtype), 2622 conversion_path, 2623 flags, 2624 DEDUCE_CONV); 2625 else 2626 cand = add_function_candidate (&candidates, fn, fromtype, 2627 args, 2628 TYPE_BINFO (fromtype), 2629 conversion_path, 2630 flags); 2631 2632 if (cand) 2633 { 2634 conversion *ics 2635 = implicit_conversion (totype, 2636 TREE_TYPE (TREE_TYPE (cand->fn)), 2637 0, 2638 /*c_cast_p=*/false, convflags); 2639 2640 cand->second_conv = ics; 2641 2642 if (!ics) 2643 cand->viable = 0; 2644 else if (candidates->viable == 1 && ics->bad_p) 2645 cand->viable = -1; 2646 } 2647 } 2648 } 2649 2650 candidates = splice_viable (candidates, pedantic, &any_viable_p); 2651 if (!any_viable_p) 2652 return NULL; 2653 2654 cand = tourney (candidates); 2655 if (cand == 0) 2656 { 2657 if (flags & LOOKUP_COMPLAIN) 2658 { 2659 error ("conversion from %qT to %qT is ambiguous", 2660 fromtype, totype); 2661 print_z_candidates (candidates); 2662 } 2663 2664 cand = candidates; /* any one will do */ 2665 cand->second_conv = build_ambiguous_conv (totype, expr); 2666 cand->second_conv->user_conv_p = true; 2667 if (!any_strictly_viable (candidates)) 2668 cand->second_conv->bad_p = true; 2669 /* If there are viable candidates, don't set ICS_BAD_FLAG; an 2670 ambiguous conversion is no worse than another user-defined 2671 conversion. */ 2672 2673 return cand; 2674 } 2675 2676 /* Build the user conversion sequence. */ 2677 conv = build_conv 2678 (ck_user, 2679 (DECL_CONSTRUCTOR_P (cand->fn) 2680 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))), 2681 build_identity_conv (TREE_TYPE (expr), expr)); 2682 conv->cand = cand; 2683 2684 /* Combine it with the second conversion sequence. */ 2685 cand->second_conv = merge_conversion_sequences (conv, 2686 cand->second_conv); 2687 2688 if (cand->viable == -1) 2689 cand->second_conv->bad_p = true; 2690 2691 return cand; 2692} 2693 2694tree 2695build_user_type_conversion (tree totype, tree expr, int flags) 2696{ 2697 struct z_candidate *cand 2698 = build_user_type_conversion_1 (totype, expr, flags); 2699 2700 if (cand) 2701 { 2702 if (cand->second_conv->kind == ck_ambig) 2703 return error_mark_node; 2704 expr = convert_like (cand->second_conv, expr); 2705 return convert_from_reference (expr); 2706 } 2707 return NULL_TREE; 2708} 2709 2710/* Do any initial processing on the arguments to a function call. */ 2711 2712static tree 2713resolve_args (tree args) 2714{ 2715 tree t; 2716 for (t = args; t; t = TREE_CHAIN (t)) 2717 { 2718 tree arg = TREE_VALUE (t); 2719 2720 if (error_operand_p (arg)) 2721 return error_mark_node; 2722 else if (VOID_TYPE_P (TREE_TYPE (arg))) 2723 { 2724 error ("invalid use of void expression"); 2725 return error_mark_node; 2726 } 2727 else if (invalid_nonstatic_memfn_p (arg)) 2728 return error_mark_node; 2729 } 2730 return args; 2731} 2732 2733/* Perform overload resolution on FN, which is called with the ARGS. 2734 2735 Return the candidate function selected by overload resolution, or 2736 NULL if the event that overload resolution failed. In the case 2737 that overload resolution fails, *CANDIDATES will be the set of 2738 candidates considered, and ANY_VIABLE_P will be set to true or 2739 false to indicate whether or not any of the candidates were 2740 viable. 2741 2742 The ARGS should already have gone through RESOLVE_ARGS before this 2743 function is called. */ 2744 2745static struct z_candidate * 2746perform_overload_resolution (tree fn, 2747 tree args, 2748 struct z_candidate **candidates, 2749 bool *any_viable_p) 2750{ 2751 struct z_candidate *cand; 2752 tree explicit_targs = NULL_TREE; 2753 int template_only = 0; 2754 2755 *candidates = NULL; 2756 *any_viable_p = true; 2757 2758 /* Check FN and ARGS. */ 2759 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL 2760 || TREE_CODE (fn) == TEMPLATE_DECL 2761 || TREE_CODE (fn) == OVERLOAD 2762 || TREE_CODE (fn) == TEMPLATE_ID_EXPR); 2763 gcc_assert (!args || TREE_CODE (args) == TREE_LIST); 2764 2765 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) 2766 { 2767 explicit_targs = TREE_OPERAND (fn, 1); 2768 fn = TREE_OPERAND (fn, 0); 2769 template_only = 1; 2770 } 2771 2772 /* Add the various candidate functions. */ 2773 add_candidates (fn, args, explicit_targs, template_only, 2774 /*conversion_path=*/NULL_TREE, 2775 /*access_path=*/NULL_TREE, 2776 LOOKUP_NORMAL, 2777 candidates); 2778 2779 *candidates = splice_viable (*candidates, pedantic, any_viable_p); 2780 if (!*any_viable_p) 2781 return NULL; 2782 2783 cand = tourney (*candidates); 2784 return cand; 2785} 2786 2787/* Return an expression for a call to FN (a namespace-scope function, 2788 or a static member function) with the ARGS. */ 2789 2790tree 2791build_new_function_call (tree fn, tree args, bool koenig_p) 2792{ 2793 struct z_candidate *candidates, *cand; 2794 bool any_viable_p; 2795 void *p; 2796 tree result; 2797 2798 args = resolve_args (args); 2799 if (args == error_mark_node) 2800 return error_mark_node; 2801 2802 /* If this function was found without using argument dependent 2803 lookup, then we want to ignore any undeclared friend 2804 functions. */ 2805 if (!koenig_p) 2806 { 2807 tree orig_fn = fn; 2808 2809 fn = remove_hidden_names (fn); 2810 if (!fn) 2811 { 2812 error ("no matching function for call to %<%D(%A)%>", 2813 DECL_NAME (OVL_CURRENT (orig_fn)), args); 2814 return error_mark_node; 2815 } 2816 } 2817 2818 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 2819 p = conversion_obstack_alloc (0); 2820 2821 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p); 2822 2823 if (!cand) 2824 { 2825 if (!any_viable_p && candidates && ! candidates->next) 2826 return build_function_call (candidates->fn, args); 2827 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) 2828 fn = TREE_OPERAND (fn, 0); 2829 if (!any_viable_p) 2830 error ("no matching function for call to %<%D(%A)%>", 2831 DECL_NAME (OVL_CURRENT (fn)), args); 2832 else 2833 error ("call of overloaded %<%D(%A)%> is ambiguous", 2834 DECL_NAME (OVL_CURRENT (fn)), args); 2835 if (candidates) 2836 print_z_candidates (candidates); 2837 result = error_mark_node; 2838 } 2839 else 2840 result = build_over_call (cand, LOOKUP_NORMAL); 2841 2842 /* Free all the conversions we allocated. */ 2843 obstack_free (&conversion_obstack, p); 2844 2845 return result; 2846} 2847 2848/* Build a call to a global operator new. FNNAME is the name of the 2849 operator (either "operator new" or "operator new[]") and ARGS are 2850 the arguments provided. *SIZE points to the total number of bytes 2851 required by the allocation, and is updated if that is changed here. 2852 *COOKIE_SIZE is non-NULL if a cookie should be used. If this 2853 function determines that no cookie should be used, after all, 2854 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be 2855 set, upon return, to the allocation function called. */ 2856 2857tree 2858build_operator_new_call (tree fnname, tree args, 2859 tree *size, tree *cookie_size, 2860 tree *fn) 2861{ 2862 tree fns; 2863 struct z_candidate *candidates; 2864 struct z_candidate *cand; 2865 bool any_viable_p; 2866 2867 if (fn) 2868 *fn = NULL_TREE; 2869 args = tree_cons (NULL_TREE, *size, args); 2870 args = resolve_args (args); 2871 if (args == error_mark_node) 2872 return args; 2873 2874 /* Based on: 2875 2876 [expr.new] 2877 2878 If this lookup fails to find the name, or if the allocated type 2879 is not a class type, the allocation function's name is looked 2880 up in the global scope. 2881 2882 we disregard block-scope declarations of "operator new". */ 2883 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false); 2884 2885 /* Figure out what function is being called. */ 2886 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p); 2887 2888 /* If no suitable function could be found, issue an error message 2889 and give up. */ 2890 if (!cand) 2891 { 2892 if (!any_viable_p) 2893 error ("no matching function for call to %<%D(%A)%>", 2894 DECL_NAME (OVL_CURRENT (fns)), args); 2895 else 2896 error ("call of overloaded %<%D(%A)%> is ambiguous", 2897 DECL_NAME (OVL_CURRENT (fns)), args); 2898 if (candidates) 2899 print_z_candidates (candidates); 2900 return error_mark_node; 2901 } 2902 2903 /* If a cookie is required, add some extra space. Whether 2904 or not a cookie is required cannot be determined until 2905 after we know which function was called. */ 2906 if (*cookie_size) 2907 { 2908 bool use_cookie = true; 2909 if (!abi_version_at_least (2)) 2910 { 2911 tree placement = TREE_CHAIN (args); 2912 /* In G++ 3.2, the check was implemented incorrectly; it 2913 looked at the placement expression, rather than the 2914 type of the function. */ 2915 if (placement && !TREE_CHAIN (placement) 2916 && same_type_p (TREE_TYPE (TREE_VALUE (placement)), 2917 ptr_type_node)) 2918 use_cookie = false; 2919 } 2920 else 2921 { 2922 tree arg_types; 2923 2924 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn)); 2925 /* Skip the size_t parameter. */ 2926 arg_types = TREE_CHAIN (arg_types); 2927 /* Check the remaining parameters (if any). */ 2928 if (arg_types 2929 && TREE_CHAIN (arg_types) == void_list_node 2930 && same_type_p (TREE_VALUE (arg_types), 2931 ptr_type_node)) 2932 use_cookie = false; 2933 } 2934 /* If we need a cookie, adjust the number of bytes allocated. */ 2935 if (use_cookie) 2936 { 2937 /* Update the total size. */ 2938 *size = size_binop (PLUS_EXPR, *size, *cookie_size); 2939 /* Update the argument list to reflect the adjusted size. */ 2940 TREE_VALUE (args) = *size; 2941 } 2942 else 2943 *cookie_size = NULL_TREE; 2944 } 2945 2946 /* Tell our caller which function we decided to call. */ 2947 if (fn) 2948 *fn = cand->fn; 2949 2950 /* Build the CALL_EXPR. */ 2951 return build_over_call (cand, LOOKUP_NORMAL); 2952} 2953 2954static tree 2955build_object_call (tree obj, tree args) 2956{ 2957 struct z_candidate *candidates = 0, *cand; 2958 tree fns, convs, mem_args = NULL_TREE; 2959 tree type = TREE_TYPE (obj); 2960 bool any_viable_p; 2961 tree result = NULL_TREE; 2962 void *p; 2963 2964 if (TYPE_PTRMEMFUNC_P (type)) 2965 { 2966 /* It's no good looking for an overloaded operator() on a 2967 pointer-to-member-function. */ 2968 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj); 2969 return error_mark_node; 2970 } 2971 2972 if (TYPE_BINFO (type)) 2973 { 2974 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1); 2975 if (fns == error_mark_node) 2976 return error_mark_node; 2977 } 2978 else 2979 fns = NULL_TREE; 2980 2981 args = resolve_args (args); 2982 2983 if (args == error_mark_node) 2984 return error_mark_node; 2985 2986 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 2987 p = conversion_obstack_alloc (0); 2988 2989 if (fns) 2990 { 2991 tree base = BINFO_TYPE (BASELINK_BINFO (fns)); 2992 mem_args = tree_cons (NULL_TREE, build_this (obj), args); 2993 2994 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns)) 2995 { 2996 tree fn = OVL_CURRENT (fns); 2997 if (TREE_CODE (fn) == TEMPLATE_DECL) 2998 add_template_candidate (&candidates, fn, base, NULL_TREE, 2999 mem_args, NULL_TREE, 3000 TYPE_BINFO (type), 3001 TYPE_BINFO (type), 3002 LOOKUP_NORMAL, DEDUCE_CALL); 3003 else 3004 add_function_candidate 3005 (&candidates, fn, base, mem_args, TYPE_BINFO (type), 3006 TYPE_BINFO (type), LOOKUP_NORMAL); 3007 } 3008 } 3009 3010 convs = lookup_conversions (type); 3011 3012 for (; convs; convs = TREE_CHAIN (convs)) 3013 { 3014 tree fns = TREE_VALUE (convs); 3015 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns))); 3016 3017 if ((TREE_CODE (totype) == POINTER_TYPE 3018 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) 3019 || (TREE_CODE (totype) == REFERENCE_TYPE 3020 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) 3021 || (TREE_CODE (totype) == REFERENCE_TYPE 3022 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE 3023 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE)) 3024 for (; fns; fns = OVL_NEXT (fns)) 3025 { 3026 tree fn = OVL_CURRENT (fns); 3027 if (TREE_CODE (fn) == TEMPLATE_DECL) 3028 add_template_conv_candidate 3029 (&candidates, fn, obj, args, totype, 3030 /*access_path=*/NULL_TREE, 3031 /*conversion_path=*/NULL_TREE); 3032 else 3033 add_conv_candidate (&candidates, fn, obj, args, 3034 /*conversion_path=*/NULL_TREE, 3035 /*access_path=*/NULL_TREE); 3036 } 3037 } 3038 3039 candidates = splice_viable (candidates, pedantic, &any_viable_p); 3040 if (!any_viable_p) 3041 { 3042 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args); 3043 print_z_candidates (candidates); 3044 result = error_mark_node; 3045 } 3046 else 3047 { 3048 cand = tourney (candidates); 3049 if (cand == 0) 3050 { 3051 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args); 3052 print_z_candidates (candidates); 3053 result = error_mark_node; 3054 } 3055 /* Since cand->fn will be a type, not a function, for a conversion 3056 function, we must be careful not to unconditionally look at 3057 DECL_NAME here. */ 3058 else if (TREE_CODE (cand->fn) == FUNCTION_DECL 3059 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR) 3060 result = build_over_call (cand, LOOKUP_NORMAL); 3061 else 3062 { 3063 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1); 3064 obj = convert_from_reference (obj); 3065 result = build_function_call (obj, args); 3066 } 3067 } 3068 3069 /* Free all the conversions we allocated. */ 3070 obstack_free (&conversion_obstack, p); 3071 3072 return result; 3073} 3074 3075static void 3076op_error (enum tree_code code, enum tree_code code2, 3077 tree arg1, tree arg2, tree arg3, const char *problem) 3078{ 3079 const char *opname; 3080 3081 if (code == MODIFY_EXPR) 3082 opname = assignment_operator_name_info[code2].name; 3083 else 3084 opname = operator_name_info[code].name; 3085 3086 switch (code) 3087 { 3088 case COND_EXPR: 3089 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>", 3090 problem, arg1, arg2, arg3); 3091 break; 3092 3093 case POSTINCREMENT_EXPR: 3094 case POSTDECREMENT_EXPR: 3095 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname); 3096 break; 3097 3098 case ARRAY_REF: 3099 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2); 3100 break; 3101 3102 case REALPART_EXPR: 3103 case IMAGPART_EXPR: 3104 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1); 3105 break; 3106 3107 default: 3108 if (arg2) 3109 error ("%s for %<operator%s%> in %<%E %s %E%>", 3110 problem, opname, arg1, opname, arg2); 3111 else 3112 error ("%s for %<operator%s%> in %<%s%E%>", 3113 problem, opname, opname, arg1); 3114 break; 3115 } 3116} 3117 3118/* Return the implicit conversion sequence that could be used to 3119 convert E1 to E2 in [expr.cond]. */ 3120 3121static conversion * 3122conditional_conversion (tree e1, tree e2) 3123{ 3124 tree t1 = non_reference (TREE_TYPE (e1)); 3125 tree t2 = non_reference (TREE_TYPE (e2)); 3126 conversion *conv; 3127 bool good_base; 3128 3129 /* [expr.cond] 3130 3131 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be 3132 implicitly converted (clause _conv_) to the type "reference to 3133 T2", subject to the constraint that in the conversion the 3134 reference must bind directly (_dcl.init.ref_) to E1. */ 3135 if (real_lvalue_p (e2)) 3136 { 3137 conv = implicit_conversion (build_reference_type (t2), 3138 t1, 3139 e1, 3140 /*c_cast_p=*/false, 3141 LOOKUP_NO_TEMP_BIND); 3142 if (conv) 3143 return conv; 3144 } 3145 3146 /* [expr.cond] 3147 3148 If E1 and E2 have class type, and the underlying class types are 3149 the same or one is a base class of the other: E1 can be converted 3150 to match E2 if the class of T2 is the same type as, or a base 3151 class of, the class of T1, and the cv-qualification of T2 is the 3152 same cv-qualification as, or a greater cv-qualification than, the 3153 cv-qualification of T1. If the conversion is applied, E1 is 3154 changed to an rvalue of type T2 that still refers to the original 3155 source class object (or the appropriate subobject thereof). */ 3156 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2) 3157 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2))) 3158 { 3159 if (good_base && at_least_as_qualified_p (t2, t1)) 3160 { 3161 conv = build_identity_conv (t1, e1); 3162 if (!same_type_p (TYPE_MAIN_VARIANT (t1), 3163 TYPE_MAIN_VARIANT (t2))) 3164 conv = build_conv (ck_base, t2, conv); 3165 else 3166 conv = build_conv (ck_rvalue, t2, conv); 3167 return conv; 3168 } 3169 else 3170 return NULL; 3171 } 3172 else 3173 /* [expr.cond] 3174 3175 Otherwise: E1 can be converted to match E2 if E1 can be implicitly 3176 converted to the type that expression E2 would have if E2 were 3177 converted to an rvalue (or the type it has, if E2 is an rvalue). */ 3178 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false, 3179 LOOKUP_NORMAL); 3180} 3181 3182/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three 3183 arguments to the conditional expression. */ 3184 3185tree 3186build_conditional_expr (tree arg1, tree arg2, tree arg3) 3187{ 3188 tree arg2_type; 3189 tree arg3_type; 3190 tree result = NULL_TREE; 3191 tree result_type = NULL_TREE; 3192 bool lvalue_p = true; 3193 struct z_candidate *candidates = 0; 3194 struct z_candidate *cand; 3195 void *p; 3196 3197 /* As a G++ extension, the second argument to the conditional can be 3198 omitted. (So that `a ? : c' is roughly equivalent to `a ? a : 3199 c'.) If the second operand is omitted, make sure it is 3200 calculated only once. */ 3201 if (!arg2) 3202 { 3203 if (pedantic) 3204 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression"); 3205 3206 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */ 3207 if (real_lvalue_p (arg1)) 3208 arg2 = arg1 = stabilize_reference (arg1); 3209 else 3210 arg2 = arg1 = save_expr (arg1); 3211 } 3212 3213 /* [expr.cond] 3214 3215 The first expr ession is implicitly converted to bool (clause 3216 _conv_). */ 3217 arg1 = perform_implicit_conversion (boolean_type_node, arg1); 3218 3219 /* If something has already gone wrong, just pass that fact up the 3220 tree. */ 3221 if (error_operand_p (arg1) 3222 || error_operand_p (arg2) 3223 || error_operand_p (arg3)) 3224 return error_mark_node; 3225 3226 /* [expr.cond] 3227 3228 If either the second or the third operand has type (possibly 3229 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_), 3230 array-to-pointer (_conv.array_), and function-to-pointer 3231 (_conv.func_) standard conversions are performed on the second 3232 and third operands. */ 3233 arg2_type = unlowered_expr_type (arg2); 3234 arg3_type = unlowered_expr_type (arg3); 3235 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type)) 3236 { 3237 /* Do the conversions. We don't these for `void' type arguments 3238 since it can't have any effect and since decay_conversion 3239 does not handle that case gracefully. */ 3240 if (!VOID_TYPE_P (arg2_type)) 3241 arg2 = decay_conversion (arg2); 3242 if (!VOID_TYPE_P (arg3_type)) 3243 arg3 = decay_conversion (arg3); 3244 arg2_type = TREE_TYPE (arg2); 3245 arg3_type = TREE_TYPE (arg3); 3246 3247 /* [expr.cond] 3248 3249 One of the following shall hold: 3250 3251 --The second or the third operand (but not both) is a 3252 throw-expression (_except.throw_); the result is of the 3253 type of the other and is an rvalue. 3254 3255 --Both the second and the third operands have type void; the 3256 result is of type void and is an rvalue. 3257 3258 We must avoid calling force_rvalue for expressions of type 3259 "void" because it will complain that their value is being 3260 used. */ 3261 if (TREE_CODE (arg2) == THROW_EXPR 3262 && TREE_CODE (arg3) != THROW_EXPR) 3263 { 3264 if (!VOID_TYPE_P (arg3_type)) 3265 arg3 = force_rvalue (arg3); 3266 arg3_type = TREE_TYPE (arg3); 3267 result_type = arg3_type; 3268 } 3269 else if (TREE_CODE (arg2) != THROW_EXPR 3270 && TREE_CODE (arg3) == THROW_EXPR) 3271 { 3272 if (!VOID_TYPE_P (arg2_type)) 3273 arg2 = force_rvalue (arg2); 3274 arg2_type = TREE_TYPE (arg2); 3275 result_type = arg2_type; 3276 } 3277 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type)) 3278 result_type = void_type_node; 3279 else 3280 { 3281 error ("%qE has type %<void%> and is not a throw-expression", 3282 VOID_TYPE_P (arg2_type) ? arg2 : arg3); 3283 return error_mark_node; 3284 } 3285 3286 lvalue_p = false; 3287 goto valid_operands; 3288 } 3289 /* [expr.cond] 3290 3291 Otherwise, if the second and third operand have different types, 3292 and either has (possibly cv-qualified) class type, an attempt is 3293 made to convert each of those operands to the type of the other. */ 3294 else if (!same_type_p (arg2_type, arg3_type) 3295 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) 3296 { 3297 conversion *conv2; 3298 conversion *conv3; 3299 3300 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 3301 p = conversion_obstack_alloc (0); 3302 3303 conv2 = conditional_conversion (arg2, arg3); 3304 conv3 = conditional_conversion (arg3, arg2); 3305 3306 /* [expr.cond] 3307 3308 If both can be converted, or one can be converted but the 3309 conversion is ambiguous, the program is ill-formed. If 3310 neither can be converted, the operands are left unchanged and 3311 further checking is performed as described below. If exactly 3312 one conversion is possible, that conversion is applied to the 3313 chosen operand and the converted operand is used in place of 3314 the original operand for the remainder of this section. */ 3315 if ((conv2 && !conv2->bad_p 3316 && conv3 && !conv3->bad_p) 3317 || (conv2 && conv2->kind == ck_ambig) 3318 || (conv3 && conv3->kind == ck_ambig)) 3319 { 3320 error ("operands to ?: have different types %qT and %qT", 3321 arg2_type, arg3_type); 3322 result = error_mark_node; 3323 } 3324 else if (conv2 && (!conv2->bad_p || !conv3)) 3325 { 3326 arg2 = convert_like (conv2, arg2); 3327 arg2 = convert_from_reference (arg2); 3328 arg2_type = TREE_TYPE (arg2); 3329 /* Even if CONV2 is a valid conversion, the result of the 3330 conversion may be invalid. For example, if ARG3 has type 3331 "volatile X", and X does not have a copy constructor 3332 accepting a "volatile X&", then even if ARG2 can be 3333 converted to X, the conversion will fail. */ 3334 if (error_operand_p (arg2)) 3335 result = error_mark_node; 3336 } 3337 else if (conv3 && (!conv3->bad_p || !conv2)) 3338 { 3339 arg3 = convert_like (conv3, arg3); 3340 arg3 = convert_from_reference (arg3); 3341 arg3_type = TREE_TYPE (arg3); 3342 if (error_operand_p (arg3)) 3343 result = error_mark_node; 3344 } 3345 3346 /* Free all the conversions we allocated. */ 3347 obstack_free (&conversion_obstack, p); 3348 3349 if (result) 3350 return result; 3351 3352 /* If, after the conversion, both operands have class type, 3353 treat the cv-qualification of both operands as if it were the 3354 union of the cv-qualification of the operands. 3355 3356 The standard is not clear about what to do in this 3357 circumstance. For example, if the first operand has type 3358 "const X" and the second operand has a user-defined 3359 conversion to "volatile X", what is the type of the second 3360 operand after this step? Making it be "const X" (matching 3361 the first operand) seems wrong, as that discards the 3362 qualification without actually performing a copy. Leaving it 3363 as "volatile X" seems wrong as that will result in the 3364 conditional expression failing altogether, even though, 3365 according to this step, the one operand could be converted to 3366 the type of the other. */ 3367 if ((conv2 || conv3) 3368 && CLASS_TYPE_P (arg2_type) 3369 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type)) 3370 arg2_type = arg3_type = 3371 cp_build_qualified_type (arg2_type, 3372 TYPE_QUALS (arg2_type) 3373 | TYPE_QUALS (arg3_type)); 3374 } 3375 3376 /* [expr.cond] 3377 3378 If the second and third operands are lvalues and have the same 3379 type, the result is of that type and is an lvalue. */ 3380 if (real_lvalue_p (arg2) 3381 && real_lvalue_p (arg3) 3382 && same_type_p (arg2_type, arg3_type)) 3383 { 3384 result_type = arg2_type; 3385 goto valid_operands; 3386 } 3387 3388 /* [expr.cond] 3389 3390 Otherwise, the result is an rvalue. If the second and third 3391 operand do not have the same type, and either has (possibly 3392 cv-qualified) class type, overload resolution is used to 3393 determine the conversions (if any) to be applied to the operands 3394 (_over.match.oper_, _over.built_). */ 3395 lvalue_p = false; 3396 if (!same_type_p (arg2_type, arg3_type) 3397 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) 3398 { 3399 tree args[3]; 3400 conversion *conv; 3401 bool any_viable_p; 3402 3403 /* Rearrange the arguments so that add_builtin_candidate only has 3404 to know about two args. In build_builtin_candidates, the 3405 arguments are unscrambled. */ 3406 args[0] = arg2; 3407 args[1] = arg3; 3408 args[2] = arg1; 3409 add_builtin_candidates (&candidates, 3410 COND_EXPR, 3411 NOP_EXPR, 3412 ansi_opname (COND_EXPR), 3413 args, 3414 LOOKUP_NORMAL); 3415 3416 /* [expr.cond] 3417 3418 If the overload resolution fails, the program is 3419 ill-formed. */ 3420 candidates = splice_viable (candidates, pedantic, &any_viable_p); 3421 if (!any_viable_p) 3422 { 3423 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); 3424 print_z_candidates (candidates); 3425 return error_mark_node; 3426 } 3427 cand = tourney (candidates); 3428 if (!cand) 3429 { 3430 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); 3431 print_z_candidates (candidates); 3432 return error_mark_node; 3433 } 3434 3435 /* [expr.cond] 3436 3437 Otherwise, the conversions thus determined are applied, and 3438 the converted operands are used in place of the original 3439 operands for the remainder of this section. */ 3440 conv = cand->convs[0]; 3441 arg1 = convert_like (conv, arg1); 3442 conv = cand->convs[1]; 3443 arg2 = convert_like (conv, arg2); 3444 conv = cand->convs[2]; 3445 arg3 = convert_like (conv, arg3); 3446 } 3447 3448 /* [expr.cond] 3449 3450 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_), 3451 and function-to-pointer (_conv.func_) standard conversions are 3452 performed on the second and third operands. 3453 3454 We need to force the lvalue-to-rvalue conversion here for class types, 3455 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues 3456 that isn't wrapped with a TARGET_EXPR plays havoc with exception 3457 regions. */ 3458 3459 arg2 = force_rvalue (arg2); 3460 if (!CLASS_TYPE_P (arg2_type)) 3461 arg2_type = TREE_TYPE (arg2); 3462 3463 arg3 = force_rvalue (arg3); 3464 if (!CLASS_TYPE_P (arg2_type)) 3465 arg3_type = TREE_TYPE (arg3); 3466 3467 if (arg2 == error_mark_node || arg3 == error_mark_node) 3468 return error_mark_node; 3469 3470 /* [expr.cond] 3471 3472 After those conversions, one of the following shall hold: 3473 3474 --The second and third operands have the same type; the result is of 3475 that type. */ 3476 if (same_type_p (arg2_type, arg3_type)) 3477 result_type = arg2_type; 3478 /* [expr.cond] 3479 3480 --The second and third operands have arithmetic or enumeration 3481 type; the usual arithmetic conversions are performed to bring 3482 them to a common type, and the result is of that type. */ 3483 else if ((ARITHMETIC_TYPE_P (arg2_type) 3484 || TREE_CODE (arg2_type) == ENUMERAL_TYPE) 3485 && (ARITHMETIC_TYPE_P (arg3_type) 3486 || TREE_CODE (arg3_type) == ENUMERAL_TYPE)) 3487 { 3488 /* In this case, there is always a common type. */ 3489 result_type = type_after_usual_arithmetic_conversions (arg2_type, 3490 arg3_type); 3491 3492 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE 3493 && TREE_CODE (arg3_type) == ENUMERAL_TYPE) 3494 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT", 3495 arg2_type, arg3_type); 3496 else if (extra_warnings 3497 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE 3498 && !same_type_p (arg3_type, type_promotes_to (arg2_type))) 3499 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE 3500 && !same_type_p (arg2_type, type_promotes_to (arg3_type))))) 3501 warning (0, "enumeral and non-enumeral type in conditional expression"); 3502 3503 arg2 = perform_implicit_conversion (result_type, arg2); 3504 arg3 = perform_implicit_conversion (result_type, arg3); 3505 } 3506 /* [expr.cond] 3507 3508 --The second and third operands have pointer type, or one has 3509 pointer type and the other is a null pointer constant; pointer 3510 conversions (_conv.ptr_) and qualification conversions 3511 (_conv.qual_) are performed to bring them to their composite 3512 pointer type (_expr.rel_). The result is of the composite 3513 pointer type. 3514 3515 --The second and third operands have pointer to member type, or 3516 one has pointer to member type and the other is a null pointer 3517 constant; pointer to member conversions (_conv.mem_) and 3518 qualification conversions (_conv.qual_) are performed to bring 3519 them to a common type, whose cv-qualification shall match the 3520 cv-qualification of either the second or the third operand. 3521 The result is of the common type. */ 3522 else if ((null_ptr_cst_p (arg2) 3523 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type))) 3524 || (null_ptr_cst_p (arg3) 3525 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type))) 3526 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type)) 3527 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type)) 3528 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type))) 3529 { 3530 result_type = composite_pointer_type (arg2_type, arg3_type, arg2, 3531 arg3, "conditional expression"); 3532 if (result_type == error_mark_node) 3533 return error_mark_node; 3534 arg2 = perform_implicit_conversion (result_type, arg2); 3535 arg3 = perform_implicit_conversion (result_type, arg3); 3536 } 3537 3538 if (!result_type) 3539 { 3540 error ("operands to ?: have different types %qT and %qT", 3541 arg2_type, arg3_type); 3542 return error_mark_node; 3543 } 3544 3545 valid_operands: 3546 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1, 3547 arg2, arg3)); 3548 /* We can't use result_type below, as fold might have returned a 3549 throw_expr. */ 3550 3551 if (!lvalue_p) 3552 { 3553 /* Expand both sides into the same slot, hopefully the target of 3554 the ?: expression. We used to check for TARGET_EXPRs here, 3555 but now we sometimes wrap them in NOP_EXPRs so the test would 3556 fail. */ 3557 if (CLASS_TYPE_P (TREE_TYPE (result))) 3558 result = get_target_expr (result); 3559 /* If this expression is an rvalue, but might be mistaken for an 3560 lvalue, we must add a NON_LVALUE_EXPR. */ 3561 result = rvalue (result); 3562 } 3563 3564 return result; 3565} 3566 3567/* OPERAND is an operand to an expression. Perform necessary steps 3568 required before using it. If OPERAND is NULL_TREE, NULL_TREE is 3569 returned. */ 3570 3571static tree 3572prep_operand (tree operand) 3573{ 3574 if (operand) 3575 { 3576 if (CLASS_TYPE_P (TREE_TYPE (operand)) 3577 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand))) 3578 /* Make sure the template type is instantiated now. */ 3579 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand))); 3580 } 3581 3582 return operand; 3583} 3584 3585/* Add each of the viable functions in FNS (a FUNCTION_DECL or 3586 OVERLOAD) to the CANDIDATES, returning an updated list of 3587 CANDIDATES. The ARGS are the arguments provided to the call, 3588 without any implicit object parameter. The EXPLICIT_TARGS are 3589 explicit template arguments provided. TEMPLATE_ONLY is true if 3590 only template functions should be considered. CONVERSION_PATH, 3591 ACCESS_PATH, and FLAGS are as for add_function_candidate. */ 3592 3593static void 3594add_candidates (tree fns, tree args, 3595 tree explicit_targs, bool template_only, 3596 tree conversion_path, tree access_path, 3597 int flags, 3598 struct z_candidate **candidates) 3599{ 3600 tree ctype; 3601 tree non_static_args; 3602 3603 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE; 3604 /* Delay creating the implicit this parameter until it is needed. */ 3605 non_static_args = NULL_TREE; 3606 3607 while (fns) 3608 { 3609 tree fn; 3610 tree fn_args; 3611 3612 fn = OVL_CURRENT (fns); 3613 /* Figure out which set of arguments to use. */ 3614 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 3615 { 3616 /* If this function is a non-static member, prepend the implicit 3617 object parameter. */ 3618 if (!non_static_args) 3619 non_static_args = tree_cons (NULL_TREE, 3620 build_this (TREE_VALUE (args)), 3621 TREE_CHAIN (args)); 3622 fn_args = non_static_args; 3623 } 3624 else 3625 /* Otherwise, just use the list of arguments provided. */ 3626 fn_args = args; 3627 3628 if (TREE_CODE (fn) == TEMPLATE_DECL) 3629 add_template_candidate (candidates, 3630 fn, 3631 ctype, 3632 explicit_targs, 3633 fn_args, 3634 NULL_TREE, 3635 access_path, 3636 conversion_path, 3637 flags, 3638 DEDUCE_CALL); 3639 else if (!template_only) 3640 add_function_candidate (candidates, 3641 fn, 3642 ctype, 3643 fn_args, 3644 access_path, 3645 conversion_path, 3646 flags); 3647 fns = OVL_NEXT (fns); 3648 } 3649} 3650 3651tree 3652build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, 3653 bool *overloaded_p) 3654{ 3655 struct z_candidate *candidates = 0, *cand; 3656 tree arglist, fnname; 3657 tree args[3]; 3658 tree result = NULL_TREE; 3659 bool result_valid_p = false; 3660 enum tree_code code2 = NOP_EXPR; 3661 conversion *conv; 3662 void *p; 3663 bool strict_p; 3664 bool any_viable_p; 3665 3666 if (error_operand_p (arg1) 3667 || error_operand_p (arg2) 3668 || error_operand_p (arg3)) 3669 return error_mark_node; 3670 3671 if (code == MODIFY_EXPR) 3672 { 3673 code2 = TREE_CODE (arg3); 3674 arg3 = NULL_TREE; 3675 fnname = ansi_assopname (code2); 3676 } 3677 else 3678 fnname = ansi_opname (code); 3679 3680 arg1 = prep_operand (arg1); 3681 3682 switch (code) 3683 { 3684 case NEW_EXPR: 3685 case VEC_NEW_EXPR: 3686 case VEC_DELETE_EXPR: 3687 case DELETE_EXPR: 3688 /* Use build_op_new_call and build_op_delete_call instead. */ 3689 gcc_unreachable (); 3690 3691 case CALL_EXPR: 3692 return build_object_call (arg1, arg2); 3693 3694 default: 3695 break; 3696 } 3697 3698 arg2 = prep_operand (arg2); 3699 arg3 = prep_operand (arg3); 3700 3701 if (code == COND_EXPR) 3702 { 3703 if (arg2 == NULL_TREE 3704 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE 3705 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE 3706 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2)) 3707 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3)))) 3708 goto builtin; 3709 } 3710 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1)) 3711 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2)))) 3712 goto builtin; 3713 3714 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) 3715 arg2 = integer_zero_node; 3716 3717 arglist = NULL_TREE; 3718 if (arg3) 3719 arglist = tree_cons (NULL_TREE, arg3, arglist); 3720 if (arg2) 3721 arglist = tree_cons (NULL_TREE, arg2, arglist); 3722 arglist = tree_cons (NULL_TREE, arg1, arglist); 3723 3724 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 3725 p = conversion_obstack_alloc (0); 3726 3727 /* Add namespace-scope operators to the list of functions to 3728 consider. */ 3729 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true), 3730 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE, 3731 flags, &candidates); 3732 /* Add class-member operators to the candidate set. */ 3733 if (CLASS_TYPE_P (TREE_TYPE (arg1))) 3734 { 3735 tree fns; 3736 3737 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1); 3738 if (fns == error_mark_node) 3739 { 3740 result = error_mark_node; 3741 goto user_defined_result_ready; 3742 } 3743 if (fns) 3744 add_candidates (BASELINK_FUNCTIONS (fns), arglist, 3745 NULL_TREE, false, 3746 BASELINK_BINFO (fns), 3747 TYPE_BINFO (TREE_TYPE (arg1)), 3748 flags, &candidates); 3749 } 3750 3751 /* Rearrange the arguments for ?: so that add_builtin_candidate only has 3752 to know about two args; a builtin candidate will always have a first 3753 parameter of type bool. We'll handle that in 3754 build_builtin_candidate. */ 3755 if (code == COND_EXPR) 3756 { 3757 args[0] = arg2; 3758 args[1] = arg3; 3759 args[2] = arg1; 3760 } 3761 else 3762 { 3763 args[0] = arg1; 3764 args[1] = arg2; 3765 args[2] = NULL_TREE; 3766 } 3767 3768 add_builtin_candidates (&candidates, code, code2, fnname, args, flags); 3769 3770 switch (code) 3771 { 3772 case COMPOUND_EXPR: 3773 case ADDR_EXPR: 3774 /* For these, the built-in candidates set is empty 3775 [over.match.oper]/3. We don't want non-strict matches 3776 because exact matches are always possible with built-in 3777 operators. The built-in candidate set for COMPONENT_REF 3778 would be empty too, but since there are no such built-in 3779 operators, we accept non-strict matches for them. */ 3780 strict_p = true; 3781 break; 3782 3783 default: 3784 strict_p = pedantic; 3785 break; 3786 } 3787 3788 candidates = splice_viable (candidates, strict_p, &any_viable_p); 3789 if (!any_viable_p) 3790 { 3791 switch (code) 3792 { 3793 case POSTINCREMENT_EXPR: 3794 case POSTDECREMENT_EXPR: 3795 /* Look for an `operator++ (int)'. If they didn't have 3796 one, then we fall back to the old way of doing things. */ 3797 if (flags & LOOKUP_COMPLAIN) 3798 pedwarn ("no %<%D(int)%> declared for postfix %qs, " 3799 "trying prefix operator instead", 3800 fnname, 3801 operator_name_info[code].name); 3802 if (code == POSTINCREMENT_EXPR) 3803 code = PREINCREMENT_EXPR; 3804 else 3805 code = PREDECREMENT_EXPR; 3806 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE, 3807 overloaded_p); 3808 break; 3809 3810 /* The caller will deal with these. */ 3811 case ADDR_EXPR: 3812 case COMPOUND_EXPR: 3813 case COMPONENT_REF: 3814 result = NULL_TREE; 3815 result_valid_p = true; 3816 break; 3817 3818 default: 3819 if (flags & LOOKUP_COMPLAIN) 3820 { 3821 op_error (code, code2, arg1, arg2, arg3, "no match"); 3822 print_z_candidates (candidates); 3823 } 3824 result = error_mark_node; 3825 break; 3826 } 3827 } 3828 else 3829 { 3830 cand = tourney (candidates); 3831 if (cand == 0) 3832 { 3833 if (flags & LOOKUP_COMPLAIN) 3834 { 3835 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload"); 3836 print_z_candidates (candidates); 3837 } 3838 result = error_mark_node; 3839 } 3840 else if (TREE_CODE (cand->fn) == FUNCTION_DECL) 3841 { 3842 if (overloaded_p) 3843 *overloaded_p = true; 3844 3845 result = build_over_call (cand, LOOKUP_NORMAL); 3846 } 3847 else 3848 { 3849 /* Give any warnings we noticed during overload resolution. */ 3850 if (cand->warnings) 3851 { 3852 struct candidate_warning *w; 3853 for (w = cand->warnings; w; w = w->next) 3854 joust (cand, w->loser, 1); 3855 } 3856 3857 /* Check for comparison of different enum types. */ 3858 switch (code) 3859 { 3860 case GT_EXPR: 3861 case LT_EXPR: 3862 case GE_EXPR: 3863 case LE_EXPR: 3864 case EQ_EXPR: 3865 case NE_EXPR: 3866 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE 3867 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE 3868 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) 3869 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))) 3870 { 3871 warning (0, "comparison between %q#T and %q#T", 3872 TREE_TYPE (arg1), TREE_TYPE (arg2)); 3873 } 3874 break; 3875 default: 3876 break; 3877 } 3878 3879 /* We need to strip any leading REF_BIND so that bitfields 3880 don't cause errors. This should not remove any important 3881 conversions, because builtins don't apply to class 3882 objects directly. */ 3883 conv = cand->convs[0]; 3884 if (conv->kind == ck_ref_bind) 3885 conv = conv->u.next; 3886 arg1 = convert_like (conv, arg1); 3887 if (arg2) 3888 { 3889 conv = cand->convs[1]; 3890 if (conv->kind == ck_ref_bind) 3891 conv = conv->u.next; 3892 arg2 = convert_like (conv, arg2); 3893 } 3894 if (arg3) 3895 { 3896 conv = cand->convs[2]; 3897 if (conv->kind == ck_ref_bind) 3898 conv = conv->u.next; 3899 arg3 = convert_like (conv, arg3); 3900 } 3901 } 3902 } 3903 3904 user_defined_result_ready: 3905 3906 /* Free all the conversions we allocated. */ 3907 obstack_free (&conversion_obstack, p); 3908 3909 if (result || result_valid_p) 3910 return result; 3911 3912 builtin: 3913 switch (code) 3914 { 3915 case MODIFY_EXPR: 3916 return build_modify_expr (arg1, code2, arg2); 3917 3918 case INDIRECT_REF: 3919 return build_indirect_ref (arg1, "unary *"); 3920 3921 case PLUS_EXPR: 3922 case MINUS_EXPR: 3923 case MULT_EXPR: 3924 case TRUNC_DIV_EXPR: 3925 case GT_EXPR: 3926 case LT_EXPR: 3927 case GE_EXPR: 3928 case LE_EXPR: 3929 case EQ_EXPR: 3930 case NE_EXPR: 3931 case MAX_EXPR: 3932 case MIN_EXPR: 3933 case LSHIFT_EXPR: 3934 case RSHIFT_EXPR: 3935 case TRUNC_MOD_EXPR: 3936 case BIT_AND_EXPR: 3937 case BIT_IOR_EXPR: 3938 case BIT_XOR_EXPR: 3939 case TRUTH_ANDIF_EXPR: 3940 case TRUTH_ORIF_EXPR: 3941 return cp_build_binary_op (code, arg1, arg2); 3942 3943 case UNARY_PLUS_EXPR: 3944 case NEGATE_EXPR: 3945 case BIT_NOT_EXPR: 3946 case TRUTH_NOT_EXPR: 3947 case PREINCREMENT_EXPR: 3948 case POSTINCREMENT_EXPR: 3949 case PREDECREMENT_EXPR: 3950 case POSTDECREMENT_EXPR: 3951 case REALPART_EXPR: 3952 case IMAGPART_EXPR: 3953 return build_unary_op (code, arg1, candidates != 0); 3954 3955 case ARRAY_REF: 3956 return build_array_ref (arg1, arg2); 3957 3958 case COND_EXPR: 3959 return build_conditional_expr (arg1, arg2, arg3); 3960 3961 case MEMBER_REF: 3962 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2); 3963 3964 /* The caller will deal with these. */ 3965 case ADDR_EXPR: 3966 case COMPONENT_REF: 3967 case COMPOUND_EXPR: 3968 return NULL_TREE; 3969 3970 default: 3971 gcc_unreachable (); 3972 } 3973 return NULL_TREE; 3974} 3975 3976/* Build a call to operator delete. This has to be handled very specially, 3977 because the restrictions on what signatures match are different from all 3978 other call instances. For a normal delete, only a delete taking (void *) 3979 or (void *, size_t) is accepted. For a placement delete, only an exact 3980 match with the placement new is accepted. 3981 3982 CODE is either DELETE_EXPR or VEC_DELETE_EXPR. 3983 ADDR is the pointer to be deleted. 3984 SIZE is the size of the memory block to be deleted. 3985 GLOBAL_P is true if the delete-expression should not consider 3986 class-specific delete operators. 3987 PLACEMENT is the corresponding placement new call, or NULL_TREE. 3988 3989 If this call to "operator delete" is being generated as part to 3990 deallocate memory allocated via a new-expression (as per [expr.new] 3991 which requires that if the initialization throws an exception then 3992 we call a deallocation function), then ALLOC_FN is the allocation 3993 function. */ 3994 3995tree 3996build_op_delete_call (enum tree_code code, tree addr, tree size, 3997 bool global_p, tree placement, 3998 tree alloc_fn) 3999{ 4000 tree fn = NULL_TREE; 4001 tree fns, fnname, argtypes, args, type; 4002 int pass; 4003 4004 if (addr == error_mark_node) 4005 return error_mark_node; 4006 4007 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr))); 4008 4009 fnname = ansi_opname (code); 4010 4011 if (CLASS_TYPE_P (type) 4012 && COMPLETE_TYPE_P (complete_type (type)) 4013 && !global_p) 4014 /* In [class.free] 4015 4016 If the result of the lookup is ambiguous or inaccessible, or if 4017 the lookup selects a placement deallocation function, the 4018 program is ill-formed. 4019 4020 Therefore, we ask lookup_fnfields to complain about ambiguity. */ 4021 { 4022 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1); 4023 if (fns == error_mark_node) 4024 return error_mark_node; 4025 } 4026 else 4027 fns = NULL_TREE; 4028 4029 if (fns == NULL_TREE) 4030 fns = lookup_name_nonclass (fnname); 4031 4032 if (placement) 4033 { 4034 /* Get the parameter types for the allocation function that is 4035 being called. */ 4036 gcc_assert (alloc_fn != NULL_TREE); 4037 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn))); 4038 /* Also the second argument. */ 4039 args = TREE_CHAIN (TREE_OPERAND (placement, 1)); 4040 } 4041 else 4042 { 4043 /* First try it without the size argument. */ 4044 argtypes = void_list_node; 4045 args = NULL_TREE; 4046 } 4047 4048 /* Strip const and volatile from addr. */ 4049 addr = cp_convert (ptr_type_node, addr); 4050 4051 /* We make two tries at finding a matching `operator delete'. On 4052 the first pass, we look for a one-operator (or placement) 4053 operator delete. If we're not doing placement delete, then on 4054 the second pass we look for a two-argument delete. */ 4055 for (pass = 0; pass < (placement ? 1 : 2); ++pass) 4056 { 4057 /* Go through the `operator delete' functions looking for one 4058 with a matching type. */ 4059 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; 4060 fn; 4061 fn = OVL_NEXT (fn)) 4062 { 4063 tree t; 4064 4065 /* The first argument must be "void *". */ 4066 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn))); 4067 if (!same_type_p (TREE_VALUE (t), ptr_type_node)) 4068 continue; 4069 t = TREE_CHAIN (t); 4070 /* On the first pass, check the rest of the arguments. */ 4071 if (pass == 0) 4072 { 4073 tree a = argtypes; 4074 while (a && t) 4075 { 4076 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t))) 4077 break; 4078 a = TREE_CHAIN (a); 4079 t = TREE_CHAIN (t); 4080 } 4081 if (!a && !t) 4082 break; 4083 } 4084 /* On the second pass, look for a function with exactly two 4085 arguments: "void *" and "size_t". */ 4086 else if (pass == 1 4087 /* For "operator delete(void *, ...)" there will be 4088 no second argument, but we will not get an exact 4089 match above. */ 4090 && t 4091 && same_type_p (TREE_VALUE (t), sizetype) 4092 && TREE_CHAIN (t) == void_list_node) 4093 break; 4094 } 4095 4096 /* If we found a match, we're done. */ 4097 if (fn) 4098 break; 4099 } 4100 4101 /* If we have a matching function, call it. */ 4102 if (fn) 4103 { 4104 /* Make sure we have the actual function, and not an 4105 OVERLOAD. */ 4106 fn = OVL_CURRENT (fn); 4107 4108 /* If the FN is a member function, make sure that it is 4109 accessible. */ 4110 if (DECL_CLASS_SCOPE_P (fn)) 4111 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn); 4112 4113 if (pass == 0) 4114 args = tree_cons (NULL_TREE, addr, args); 4115 else 4116 args = tree_cons (NULL_TREE, addr, 4117 build_tree_list (NULL_TREE, size)); 4118 4119 if (placement) 4120 { 4121 /* The placement args might not be suitable for overload 4122 resolution at this point, so build the call directly. */ 4123 mark_used (fn); 4124 return build_cxx_call (fn, args); 4125 } 4126 else 4127 return build_function_call (fn, args); 4128 } 4129 4130 /* [expr.new] 4131 4132 If no unambiguous matching deallocation function can be found, 4133 propagating the exception does not cause the object's memory to 4134 be freed. */ 4135 if (alloc_fn) 4136 { 4137 if (!placement) 4138 warning (0, "no corresponding deallocation function for `%D'", 4139 alloc_fn); 4140 return NULL_TREE; 4141 } 4142 4143 error ("no suitable %<operator %s%> for %qT", 4144 operator_name_info[(int)code].name, type); 4145 return error_mark_node; 4146} 4147 4148/* If the current scope isn't allowed to access DECL along 4149 BASETYPE_PATH, give an error. The most derived class in 4150 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is 4151 the declaration to use in the error diagnostic. */ 4152 4153bool 4154enforce_access (tree basetype_path, tree decl, tree diag_decl) 4155{ 4156 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO); 4157 4158 if (!accessible_p (basetype_path, decl, true)) 4159 { 4160 if (TREE_PRIVATE (decl)) 4161 error ("%q+#D is private", diag_decl); 4162 else if (TREE_PROTECTED (decl)) 4163 error ("%q+#D is protected", diag_decl); 4164 else 4165 error ("%q+#D is inaccessible", diag_decl); 4166 error ("within this context"); 4167 return false; 4168 } 4169 4170 return true; 4171} 4172 4173/* Check that a callable constructor to initialize a temporary of 4174 TYPE from an EXPR exists. */ 4175 4176static void 4177check_constructor_callable (tree type, tree expr) 4178{ 4179 build_special_member_call (NULL_TREE, 4180 complete_ctor_identifier, 4181 build_tree_list (NULL_TREE, expr), 4182 type, 4183 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING 4184 | LOOKUP_NO_CONVERSION 4185 | LOOKUP_CONSTRUCTOR_CALLABLE); 4186} 4187 4188/* Initialize a temporary of type TYPE with EXPR. The FLAGS are a 4189 bitwise or of LOOKUP_* values. If any errors are warnings are 4190 generated, set *DIAGNOSTIC_FN to "error" or "warning", 4191 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN 4192 to NULL. */ 4193 4194static tree 4195build_temp (tree expr, tree type, int flags, 4196 diagnostic_fn_t *diagnostic_fn) 4197{ 4198 int savew, savee; 4199 4200 savew = warningcount, savee = errorcount; 4201 expr = build_special_member_call (NULL_TREE, 4202 complete_ctor_identifier, 4203 build_tree_list (NULL_TREE, expr), 4204 type, flags); 4205 if (warningcount > savew) 4206 *diagnostic_fn = warning0; 4207 else if (errorcount > savee) 4208 *diagnostic_fn = error; 4209 else 4210 *diagnostic_fn = NULL; 4211 return expr; 4212} 4213 4214 4215/* Perform the conversions in CONVS on the expression EXPR. FN and 4216 ARGNUM are used for diagnostics. ARGNUM is zero based, -1 4217 indicates the `this' argument of a method. INNER is nonzero when 4218 being called to continue a conversion chain. It is negative when a 4219 reference binding will be applied, positive otherwise. If 4220 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious 4221 conversions will be emitted if appropriate. If C_CAST_P is true, 4222 this conversion is coming from a C-style cast; in that case, 4223 conversions to inaccessible bases are permitted. */ 4224 4225static tree 4226convert_like_real (conversion *convs, tree expr, tree fn, int argnum, 4227 int inner, bool issue_conversion_warnings, 4228 bool c_cast_p) 4229{ 4230 tree totype = convs->type; 4231 diagnostic_fn_t diagnostic_fn; 4232 4233 if (convs->bad_p 4234 && convs->kind != ck_user 4235 && convs->kind != ck_ambig 4236 && convs->kind != ck_ref_bind) 4237 { 4238 conversion *t = convs; 4239 for (; t; t = convs->u.next) 4240 { 4241 if (t->kind == ck_user || !t->bad_p) 4242 { 4243 expr = convert_like_real (t, expr, fn, argnum, 1, 4244 /*issue_conversion_warnings=*/false, 4245 /*c_cast_p=*/false); 4246 break; 4247 } 4248 else if (t->kind == ck_ambig) 4249 return convert_like_real (t, expr, fn, argnum, 1, 4250 /*issue_conversion_warnings=*/false, 4251 /*c_cast_p=*/false); 4252 else if (t->kind == ck_identity) 4253 break; 4254 } 4255 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype); 4256 if (fn) 4257 pedwarn (" initializing argument %P of %qD", argnum, fn); 4258 return cp_convert (totype, expr); 4259 } 4260 4261 if (issue_conversion_warnings) 4262 { 4263 tree t = non_reference (totype); 4264 4265 /* Issue warnings about peculiar, but valid, uses of NULL. */ 4266 if (ARITHMETIC_TYPE_P (t) && expr == null_node) 4267 { 4268 if (fn) 4269 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD", 4270 argnum, fn); 4271 else 4272 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t); 4273 } 4274 4275 /* Warn about assigning a floating-point type to an integer type. */ 4276 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE 4277 && TREE_CODE (t) == INTEGER_TYPE) 4278 { 4279 if (fn) 4280 warning (OPT_Wconversion, "passing %qT for argument %P to %qD", 4281 TREE_TYPE (expr), argnum, fn); 4282 else 4283 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr)); 4284 } 4285 } 4286 4287 switch (convs->kind) 4288 { 4289 case ck_user: 4290 { 4291 struct z_candidate *cand = convs->cand; 4292 tree convfn = cand->fn; 4293 tree args; 4294 4295 if (DECL_CONSTRUCTOR_P (convfn)) 4296 { 4297 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)), 4298 0); 4299 4300 args = build_tree_list (NULL_TREE, expr); 4301 /* We should never try to call the abstract or base constructor 4302 from here. */ 4303 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn) 4304 && !DECL_HAS_VTT_PARM_P (convfn)); 4305 args = tree_cons (NULL_TREE, t, args); 4306 } 4307 else 4308 args = build_this (expr); 4309 expr = build_over_call (cand, LOOKUP_NORMAL); 4310 4311 /* If this is a constructor or a function returning an aggr type, 4312 we need to build up a TARGET_EXPR. */ 4313 if (DECL_CONSTRUCTOR_P (convfn)) 4314 expr = build_cplus_new (totype, expr); 4315 4316 /* The result of the call is then used to direct-initialize the object 4317 that is the destination of the copy-initialization. [dcl.init] 4318 4319 Note that this step is not reflected in the conversion sequence; 4320 it affects the semantics when we actually perform the 4321 conversion, but is not considered during overload resolution. 4322 4323 If the target is a class, that means call a ctor. */ 4324 if (IS_AGGR_TYPE (totype) 4325 && (inner >= 0 || !lvalue_p (expr))) 4326 { 4327 expr = (build_temp 4328 (expr, totype, 4329 /* Core issue 84, now a DR, says that we don't 4330 allow UDCs for these args (which deliberately 4331 breaks copy-init of an auto_ptr<Base> from an 4332 auto_ptr<Derived>). */ 4333 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION, 4334 &diagnostic_fn)); 4335 4336 if (diagnostic_fn) 4337 { 4338 if (fn) 4339 diagnostic_fn 4340 (" initializing argument %P of %qD from result of %qD", 4341 argnum, fn, convfn); 4342 else 4343 diagnostic_fn 4344 (" initializing temporary from result of %qD", convfn); 4345 } 4346 expr = build_cplus_new (totype, expr); 4347 } 4348 return expr; 4349 } 4350 case ck_identity: 4351 if (type_unknown_p (expr)) 4352 expr = instantiate_type (totype, expr, tf_warning_or_error); 4353 /* Convert a constant to its underlying value, unless we are 4354 about to bind it to a reference, in which case we need to 4355 leave it as an lvalue. */ 4356 if (inner >= 0) 4357 expr = decl_constant_value (expr); 4358 if (convs->check_copy_constructor_p) 4359 check_constructor_callable (totype, expr); 4360 return expr; 4361 case ck_ambig: 4362 /* Call build_user_type_conversion again for the error. */ 4363 return build_user_type_conversion 4364 (totype, convs->u.expr, LOOKUP_NORMAL); 4365 4366 default: 4367 break; 4368 }; 4369 4370 expr = convert_like_real (convs->u.next, expr, fn, argnum, 4371 convs->kind == ck_ref_bind ? -1 : 1, 4372 /*issue_conversion_warnings=*/false, 4373 c_cast_p); 4374 if (expr == error_mark_node) 4375 return error_mark_node; 4376 4377 switch (convs->kind) 4378 { 4379 case ck_rvalue: 4380 expr = convert_bitfield_to_declared_type (expr); 4381 if (! IS_AGGR_TYPE (totype)) 4382 return expr; 4383 /* Else fall through. */ 4384 case ck_base: 4385 if (convs->kind == ck_base && !convs->need_temporary_p) 4386 { 4387 /* We are going to bind a reference directly to a base-class 4388 subobject of EXPR. */ 4389 if (convs->check_copy_constructor_p) 4390 check_constructor_callable (TREE_TYPE (expr), expr); 4391 /* Build an expression for `*((base*) &expr)'. */ 4392 expr = build_unary_op (ADDR_EXPR, expr, 0); 4393 expr = convert_to_base (expr, build_pointer_type (totype), 4394 !c_cast_p, /*nonnull=*/true); 4395 expr = build_indirect_ref (expr, "implicit conversion"); 4396 return expr; 4397 } 4398 4399 /* Copy-initialization where the cv-unqualified version of the source 4400 type is the same class as, or a derived class of, the class of the 4401 destination [is treated as direct-initialization]. [dcl.init] */ 4402 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, 4403 &diagnostic_fn); 4404 if (diagnostic_fn && fn) 4405 diagnostic_fn (" initializing argument %P of %qD", argnum, fn); 4406 return build_cplus_new (totype, expr); 4407 4408 case ck_ref_bind: 4409 { 4410 tree ref_type = totype; 4411 4412 /* If necessary, create a temporary. */ 4413 if (convs->need_temporary_p || !lvalue_p (expr)) 4414 { 4415 tree type = convs->u.next->type; 4416 cp_lvalue_kind lvalue = real_lvalue_p (expr); 4417 4418 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))) 4419 { 4420 /* If the reference is volatile or non-const, we 4421 cannot create a temporary. */ 4422 if (lvalue & clk_bitfield) 4423 error ("cannot bind bitfield %qE to %qT", 4424 expr, ref_type); 4425 else if (lvalue & clk_packed) 4426 error ("cannot bind packed field %qE to %qT", 4427 expr, ref_type); 4428 else 4429 error ("cannot bind rvalue %qE to %qT", expr, ref_type); 4430 return error_mark_node; 4431 } 4432 /* If the source is a packed field, and we must use a copy 4433 constructor, then building the target expr will require 4434 binding the field to the reference parameter to the 4435 copy constructor, and we'll end up with an infinite 4436 loop. If we can use a bitwise copy, then we'll be 4437 OK. */ 4438 if ((lvalue & clk_packed) 4439 && CLASS_TYPE_P (type) 4440 && !TYPE_HAS_TRIVIAL_INIT_REF (type)) 4441 { 4442 error ("cannot bind packed field %qE to %qT", 4443 expr, ref_type); 4444 return error_mark_node; 4445 } 4446 expr = build_target_expr_with_type (expr, type); 4447 } 4448 4449 /* Take the address of the thing to which we will bind the 4450 reference. */ 4451 expr = build_unary_op (ADDR_EXPR, expr, 1); 4452 if (expr == error_mark_node) 4453 return error_mark_node; 4454 4455 /* Convert it to a pointer to the type referred to by the 4456 reference. This will adjust the pointer if a derived to 4457 base conversion is being performed. */ 4458 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)), 4459 expr); 4460 /* Convert the pointer to the desired reference type. */ 4461 return build_nop (ref_type, expr); 4462 } 4463 4464 case ck_lvalue: 4465 return decay_conversion (expr); 4466 4467 case ck_qual: 4468 /* Warn about deprecated conversion if appropriate. */ 4469 string_conv_p (totype, expr, 1); 4470 break; 4471 4472 case ck_ptr: 4473 if (convs->base_p) 4474 expr = convert_to_base (expr, totype, !c_cast_p, 4475 /*nonnull=*/false); 4476 return build_nop (totype, expr); 4477 4478 case ck_pmem: 4479 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false, 4480 c_cast_p); 4481 4482 default: 4483 break; 4484 } 4485 4486 if (issue_conversion_warnings) 4487 expr = convert_and_check (totype, expr); 4488 else 4489 expr = convert (totype, expr); 4490 4491 return expr; 4492} 4493 4494/* Build a call to __builtin_trap. */ 4495 4496static tree 4497call_builtin_trap (void) 4498{ 4499 tree fn = implicit_built_in_decls[BUILT_IN_TRAP]; 4500 4501 gcc_assert (fn != NULL); 4502 fn = build_call (fn, NULL_TREE); 4503 return fn; 4504} 4505 4506/* ARG is being passed to a varargs function. Perform any conversions 4507 required. Return the converted value. */ 4508 4509tree 4510convert_arg_to_ellipsis (tree arg) 4511{ 4512 /* [expr.call] 4513 4514 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 4515 standard conversions are performed. */ 4516 arg = decay_conversion (arg); 4517 /* [expr.call] 4518 4519 If the argument has integral or enumeration type that is subject 4520 to the integral promotions (_conv.prom_), or a floating point 4521 type that is subject to the floating point promotion 4522 (_conv.fpprom_), the value of the argument is converted to the 4523 promoted type before the call. */ 4524 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE 4525 && (TYPE_PRECISION (TREE_TYPE (arg)) 4526 < TYPE_PRECISION (double_type_node))) 4527 arg = convert_to_real (double_type_node, arg); 4528 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg))) 4529 arg = perform_integral_promotions (arg); 4530 4531 arg = require_complete_type (arg); 4532 4533 if (arg != error_mark_node 4534 && !pod_type_p (TREE_TYPE (arg))) 4535 { 4536 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn 4537 here and do a bitwise copy, but now cp_expr_size will abort if we 4538 try to do that. 4539 If the call appears in the context of a sizeof expression, 4540 there is no need to emit a warning, since the expression won't be 4541 evaluated. We keep the builtin_trap just as a safety check. */ 4542 if (!skip_evaluation) 4543 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; " 4544 "call will abort at runtime", TREE_TYPE (arg)); 4545 arg = call_builtin_trap (); 4546 arg = build2 (COMPOUND_EXPR, integer_type_node, arg, 4547 integer_zero_node); 4548 } 4549 4550 return arg; 4551} 4552 4553/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */ 4554 4555tree 4556build_x_va_arg (tree expr, tree type) 4557{ 4558 if (processing_template_decl) 4559 return build_min (VA_ARG_EXPR, type, expr); 4560 4561 type = complete_type_or_else (type, NULL_TREE); 4562 4563 if (expr == error_mark_node || !type) 4564 return error_mark_node; 4565 4566 if (! pod_type_p (type)) 4567 { 4568 /* Remove reference types so we don't ICE later on. */ 4569 tree type1 = non_reference (type); 4570 /* Undefined behavior [expr.call] 5.2.2/7. */ 4571 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; " 4572 "call will abort at runtime", type); 4573 expr = convert (build_pointer_type (type1), null_node); 4574 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), 4575 call_builtin_trap (), expr); 4576 expr = build_indirect_ref (expr, NULL); 4577 return expr; 4578 } 4579 4580 return build_va_arg (expr, type); 4581} 4582 4583/* TYPE has been given to va_arg. Apply the default conversions which 4584 would have happened when passed via ellipsis. Return the promoted 4585 type, or the passed type if there is no change. */ 4586 4587tree 4588cxx_type_promotes_to (tree type) 4589{ 4590 tree promote; 4591 4592 /* Perform the array-to-pointer and function-to-pointer 4593 conversions. */ 4594 type = type_decays_to (type); 4595 4596 promote = type_promotes_to (type); 4597 if (same_type_p (type, promote)) 4598 promote = type; 4599 4600 return promote; 4601} 4602 4603/* ARG is a default argument expression being passed to a parameter of 4604 the indicated TYPE, which is a parameter to FN. Do any required 4605 conversions. Return the converted value. */ 4606 4607tree 4608convert_default_arg (tree type, tree arg, tree fn, int parmnum) 4609{ 4610 /* If the ARG is an unparsed default argument expression, the 4611 conversion cannot be performed. */ 4612 if (TREE_CODE (arg) == DEFAULT_ARG) 4613 { 4614 error ("the default argument for parameter %d of %qD has " 4615 "not yet been parsed", 4616 parmnum, fn); 4617 return error_mark_node; 4618 } 4619 4620 if (fn && DECL_TEMPLATE_INFO (fn)) 4621 arg = tsubst_default_argument (fn, type, arg); 4622 4623 arg = break_out_target_exprs (arg); 4624 4625 if (TREE_CODE (arg) == CONSTRUCTOR) 4626 { 4627 arg = digest_init (type, arg); 4628 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, 4629 "default argument", fn, parmnum); 4630 } 4631 else 4632 { 4633 /* We must make a copy of ARG, in case subsequent processing 4634 alters any part of it. For example, during gimplification a 4635 cast of the form (T) &X::f (where "f" is a member function) 4636 will lead to replacing the PTRMEM_CST for &X::f with a 4637 VAR_DECL. We can avoid the copy for constants, since they 4638 are never modified in place. */ 4639 if (!CONSTANT_CLASS_P (arg)) 4640 arg = unshare_expr (arg); 4641 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, 4642 "default argument", fn, parmnum); 4643 arg = convert_for_arg_passing (type, arg); 4644 } 4645 4646 return arg; 4647} 4648 4649/* Returns the type which will really be used for passing an argument of 4650 type TYPE. */ 4651 4652tree 4653type_passed_as (tree type) 4654{ 4655 /* Pass classes with copy ctors by invisible reference. */ 4656 if (TREE_ADDRESSABLE (type)) 4657 { 4658 type = build_reference_type (type); 4659 /* There are no other pointers to this temporary. */ 4660 type = build_qualified_type (type, TYPE_QUAL_RESTRICT); 4661 } 4662 else if (targetm.calls.promote_prototypes (type) 4663 && INTEGRAL_TYPE_P (type) 4664 && COMPLETE_TYPE_P (type) 4665 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), 4666 TYPE_SIZE (integer_type_node))) 4667 type = integer_type_node; 4668 4669 return type; 4670} 4671 4672/* Actually perform the appropriate conversion. */ 4673 4674tree 4675convert_for_arg_passing (tree type, tree val) 4676{ 4677 tree bitfield_type; 4678 4679 /* If VAL is a bitfield, then -- since it has already been converted 4680 to TYPE -- it cannot have a precision greater than TYPE. 4681 4682 If it has a smaller precision, we must widen it here. For 4683 example, passing "int f:3;" to a function expecting an "int" will 4684 not result in any conversion before this point. 4685 4686 If the precision is the same we must not risk widening. For 4687 example, the COMPONENT_REF for a 32-bit "long long" bitfield will 4688 often have type "int", even though the C++ type for the field is 4689 "long long". If the value is being passed to a function 4690 expecting an "int", then no conversions will be required. But, 4691 if we call convert_bitfield_to_declared_type, the bitfield will 4692 be converted to "long long". */ 4693 bitfield_type = is_bitfield_expr_with_lowered_type (val); 4694 if (bitfield_type 4695 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)) 4696 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val); 4697 4698 if (val == error_mark_node) 4699 ; 4700 /* Pass classes with copy ctors by invisible reference. */ 4701 else if (TREE_ADDRESSABLE (type)) 4702 val = build1 (ADDR_EXPR, build_reference_type (type), val); 4703 else if (targetm.calls.promote_prototypes (type) 4704 && INTEGRAL_TYPE_P (type) 4705 && COMPLETE_TYPE_P (type) 4706 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), 4707 TYPE_SIZE (integer_type_node))) 4708 val = perform_integral_promotions (val); 4709 if (warn_missing_format_attribute) 4710 { 4711 tree rhstype = TREE_TYPE (val); 4712 const enum tree_code coder = TREE_CODE (rhstype); 4713 const enum tree_code codel = TREE_CODE (type); 4714 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4715 && coder == codel 4716 && check_missing_format_attribute (type, rhstype)) 4717 warning (OPT_Wmissing_format_attribute, 4718 "argument of function call might be a candidate for a format attribute"); 4719 } 4720 return val; 4721} 4722 4723/* Returns true iff FN is a function with magic varargs, i.e. ones for 4724 which no conversions at all should be done. This is true for some 4725 builtins which don't act like normal functions. */ 4726 4727static bool 4728magic_varargs_p (tree fn) 4729{ 4730 if (DECL_BUILT_IN (fn)) 4731 switch (DECL_FUNCTION_CODE (fn)) 4732 { 4733 case BUILT_IN_CLASSIFY_TYPE: 4734 case BUILT_IN_CONSTANT_P: 4735 case BUILT_IN_NEXT_ARG: 4736 case BUILT_IN_STDARG_START: 4737 case BUILT_IN_VA_START: 4738 return true; 4739 4740 default:; 4741 } 4742 4743 return false; 4744} 4745 4746/* Subroutine of the various build_*_call functions. Overload resolution 4747 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly. 4748 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a 4749 bitmask of various LOOKUP_* flags which apply to the call itself. */ 4750 4751static tree 4752build_over_call (struct z_candidate *cand, int flags) 4753{ 4754 tree fn = cand->fn; 4755 tree args = cand->args; 4756 conversion **convs = cand->convs; 4757 conversion *conv; 4758 tree converted_args = NULL_TREE; 4759 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn)); 4760 tree arg, val; 4761 int i = 0; 4762 int is_method = 0; 4763 4764 /* In a template, there is no need to perform all of the work that 4765 is normally done. We are only interested in the type of the call 4766 expression, i.e., the return type of the function. Any semantic 4767 errors will be deferred until the template is instantiated. */ 4768 if (processing_template_decl) 4769 { 4770 tree expr; 4771 tree return_type; 4772 return_type = TREE_TYPE (TREE_TYPE (fn)); 4773 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE); 4774 if (TREE_THIS_VOLATILE (fn) && cfun) 4775 current_function_returns_abnormally = 1; 4776 if (!VOID_TYPE_P (return_type)) 4777 require_complete_type (return_type); 4778 return convert_from_reference (expr); 4779 } 4780 4781 /* Give any warnings we noticed during overload resolution. */ 4782 if (cand->warnings) 4783 { 4784 struct candidate_warning *w; 4785 for (w = cand->warnings; w; w = w->next) 4786 joust (cand, w->loser, 1); 4787 } 4788 4789 if (DECL_FUNCTION_MEMBER_P (fn)) 4790 { 4791 /* If FN is a template function, two cases must be considered. 4792 For example: 4793 4794 struct A { 4795 protected: 4796 template <class T> void f(); 4797 }; 4798 template <class T> struct B { 4799 protected: 4800 void g(); 4801 }; 4802 struct C : A, B<int> { 4803 using A::f; // #1 4804 using B<int>::g; // #2 4805 }; 4806 4807 In case #1 where `A::f' is a member template, DECL_ACCESS is 4808 recorded in the primary template but not in its specialization. 4809 We check access of FN using its primary template. 4810 4811 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply 4812 because it is a member of class template B, DECL_ACCESS is 4813 recorded in the specialization `B<int>::g'. We cannot use its 4814 primary template because `B<T>::g' and `B<int>::g' may have 4815 different access. */ 4816 if (DECL_TEMPLATE_INFO (fn) 4817 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn))) 4818 perform_or_defer_access_check (cand->access_path, 4819 DECL_TI_TEMPLATE (fn), fn); 4820 else 4821 perform_or_defer_access_check (cand->access_path, fn, fn); 4822 } 4823 4824 if (args && TREE_CODE (args) != TREE_LIST) 4825 args = build_tree_list (NULL_TREE, args); 4826 arg = args; 4827 4828 /* The implicit parameters to a constructor are not considered by overload 4829 resolution, and must be of the proper type. */ 4830 if (DECL_CONSTRUCTOR_P (fn)) 4831 { 4832 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args); 4833 arg = TREE_CHAIN (arg); 4834 parm = TREE_CHAIN (parm); 4835 /* We should never try to call the abstract constructor. */ 4836 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn)); 4837 4838 if (DECL_HAS_VTT_PARM_P (fn)) 4839 { 4840 converted_args = tree_cons 4841 (NULL_TREE, TREE_VALUE (arg), converted_args); 4842 arg = TREE_CHAIN (arg); 4843 parm = TREE_CHAIN (parm); 4844 } 4845 } 4846 /* Bypass access control for 'this' parameter. */ 4847 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) 4848 { 4849 tree parmtype = TREE_VALUE (parm); 4850 tree argtype = TREE_TYPE (TREE_VALUE (arg)); 4851 tree converted_arg; 4852 tree base_binfo; 4853 4854 if (convs[i]->bad_p) 4855 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers", 4856 TREE_TYPE (argtype), fn); 4857 4858 /* [class.mfct.nonstatic]: If a nonstatic member function of a class 4859 X is called for an object that is not of type X, or of a type 4860 derived from X, the behavior is undefined. 4861 4862 So we can assume that anything passed as 'this' is non-null, and 4863 optimize accordingly. */ 4864 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE); 4865 /* Convert to the base in which the function was declared. */ 4866 gcc_assert (cand->conversion_path != NULL_TREE); 4867 converted_arg = build_base_path (PLUS_EXPR, 4868 TREE_VALUE (arg), 4869 cand->conversion_path, 4870 1); 4871 /* Check that the base class is accessible. */ 4872 if (!accessible_base_p (TREE_TYPE (argtype), 4873 BINFO_TYPE (cand->conversion_path), true)) 4874 error ("%qT is not an accessible base of %qT", 4875 BINFO_TYPE (cand->conversion_path), 4876 TREE_TYPE (argtype)); 4877 /* If fn was found by a using declaration, the conversion path 4878 will be to the derived class, not the base declaring fn. We 4879 must convert from derived to base. */ 4880 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)), 4881 TREE_TYPE (parmtype), ba_unique, NULL); 4882 converted_arg = build_base_path (PLUS_EXPR, converted_arg, 4883 base_binfo, 1); 4884 4885 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args); 4886 parm = TREE_CHAIN (parm); 4887 arg = TREE_CHAIN (arg); 4888 ++i; 4889 is_method = 1; 4890 } 4891 4892 for (; arg && parm; 4893 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i) 4894 { 4895 tree type = TREE_VALUE (parm); 4896 4897 conv = convs[i]; 4898 4899 /* Don't make a copy here if build_call is going to. */ 4900 if (conv->kind == ck_rvalue 4901 && !TREE_ADDRESSABLE (complete_type (type))) 4902 conv = conv->u.next; 4903 4904 val = convert_like_with_context 4905 (conv, TREE_VALUE (arg), fn, i - is_method); 4906 4907 val = convert_for_arg_passing (type, val); 4908 converted_args = tree_cons (NULL_TREE, val, converted_args); 4909 } 4910 4911 /* Default arguments */ 4912 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++) 4913 converted_args 4914 = tree_cons (NULL_TREE, 4915 convert_default_arg (TREE_VALUE (parm), 4916 TREE_PURPOSE (parm), 4917 fn, i - is_method), 4918 converted_args); 4919 4920 /* Ellipsis */ 4921 for (; arg; arg = TREE_CHAIN (arg)) 4922 { 4923 tree a = TREE_VALUE (arg); 4924 if (magic_varargs_p (fn)) 4925 /* Do no conversions for magic varargs. */; 4926 else 4927 a = convert_arg_to_ellipsis (a); 4928 converted_args = tree_cons (NULL_TREE, a, converted_args); 4929 } 4930 4931 converted_args = nreverse (converted_args); 4932 4933 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)), 4934 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn))); 4935 4936 /* Avoid actually calling copy constructors and copy assignment operators, 4937 if possible. */ 4938 4939 if (! flag_elide_constructors) 4940 /* Do things the hard way. */; 4941 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn)) 4942 { 4943 tree targ; 4944 arg = skip_artificial_parms_for (fn, converted_args); 4945 arg = TREE_VALUE (arg); 4946 4947 /* Pull out the real argument, disregarding const-correctness. */ 4948 targ = arg; 4949 while (TREE_CODE (targ) == NOP_EXPR 4950 || TREE_CODE (targ) == NON_LVALUE_EXPR 4951 || TREE_CODE (targ) == CONVERT_EXPR) 4952 targ = TREE_OPERAND (targ, 0); 4953 if (TREE_CODE (targ) == ADDR_EXPR) 4954 { 4955 targ = TREE_OPERAND (targ, 0); 4956 if (!same_type_ignoring_top_level_qualifiers_p 4957 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ))) 4958 targ = NULL_TREE; 4959 } 4960 else 4961 targ = NULL_TREE; 4962 4963 if (targ) 4964 arg = targ; 4965 else 4966 arg = build_indirect_ref (arg, 0); 4967 4968 /* [class.copy]: the copy constructor is implicitly defined even if 4969 the implementation elided its use. */ 4970 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn))) 4971 mark_used (fn); 4972 4973 /* If we're creating a temp and we already have one, don't create a 4974 new one. If we're not creating a temp but we get one, use 4975 INIT_EXPR to collapse the temp into our target. Otherwise, if the 4976 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a 4977 temp or an INIT_EXPR otherwise. */ 4978 if (integer_zerop (TREE_VALUE (args))) 4979 { 4980 if (TREE_CODE (arg) == TARGET_EXPR) 4981 return arg; 4982 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))) 4983 return build_target_expr_with_type (arg, DECL_CONTEXT (fn)); 4984 } 4985 else if (TREE_CODE (arg) == TARGET_EXPR 4986 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))) 4987 { 4988 tree to = stabilize_reference 4989 (build_indirect_ref (TREE_VALUE (args), 0)); 4990 4991 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg); 4992 return val; 4993 } 4994 } 4995 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR 4996 && copy_fn_p (fn) 4997 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn))) 4998 { 4999 tree to = stabilize_reference 5000 (build_indirect_ref (TREE_VALUE (converted_args), 0)); 5001 tree type = TREE_TYPE (to); 5002 tree as_base = CLASSTYPE_AS_BASE (type); 5003 5004 arg = TREE_VALUE (TREE_CHAIN (converted_args)); 5005 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base))) 5006 { 5007 arg = build_indirect_ref (arg, 0); 5008 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg); 5009 } 5010 else 5011 { 5012 /* We must only copy the non-tail padding parts. 5013 Use __builtin_memcpy for the bitwise copy. */ 5014 5015 tree args, t; 5016 5017 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL); 5018 args = tree_cons (NULL, arg, args); 5019 t = build_unary_op (ADDR_EXPR, to, 0); 5020 args = tree_cons (NULL, t, args); 5021 t = implicit_built_in_decls[BUILT_IN_MEMCPY]; 5022 t = build_call (t, args); 5023 5024 t = convert (TREE_TYPE (TREE_VALUE (args)), t); 5025 val = build_indirect_ref (t, 0); 5026 } 5027 5028 return val; 5029 } 5030 5031 mark_used (fn); 5032 5033 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0) 5034 { 5035 tree t, *p = &TREE_VALUE (converted_args); 5036 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)), 5037 DECL_CONTEXT (fn), 5038 ba_any, NULL); 5039 gcc_assert (binfo && binfo != error_mark_node); 5040 5041 *p = build_base_path (PLUS_EXPR, *p, binfo, 1); 5042 if (TREE_SIDE_EFFECTS (*p)) 5043 *p = save_expr (*p); 5044 t = build_pointer_type (TREE_TYPE (fn)); 5045 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn))) 5046 fn = build_java_interface_fn_ref (fn, *p); 5047 else 5048 fn = build_vfn_ref (*p, DECL_VINDEX (fn)); 5049 TREE_TYPE (fn) = t; 5050 } 5051 else if (DECL_INLINE (fn)) 5052 fn = inline_conversion (fn); 5053 else 5054 fn = build_addr_func (fn); 5055 5056 return build_cxx_call (fn, converted_args); 5057} 5058 5059/* Build and return a call to FN, using ARGS. This function performs 5060 no overload resolution, conversion, or other high-level 5061 operations. */ 5062 5063tree 5064build_cxx_call (tree fn, tree args) 5065{ 5066 tree fndecl; 5067 5068 fn = build_call (fn, args); 5069 5070 /* If this call might throw an exception, note that fact. */ 5071 fndecl = get_callee_fndecl (fn); 5072 if ((!fndecl || !TREE_NOTHROW (fndecl)) 5073 && at_function_scope_p () 5074 && cfun) 5075 cp_function_chain->can_throw = 1; 5076 5077 /* Some built-in function calls will be evaluated at compile-time in 5078 fold (). */ 5079 fn = fold_if_not_in_template (fn); 5080 5081 if (VOID_TYPE_P (TREE_TYPE (fn))) 5082 return fn; 5083 5084 fn = require_complete_type (fn); 5085 if (fn == error_mark_node) 5086 return error_mark_node; 5087 5088 if (IS_AGGR_TYPE (TREE_TYPE (fn))) 5089 fn = build_cplus_new (TREE_TYPE (fn), fn); 5090 return convert_from_reference (fn); 5091} 5092 5093static GTY(()) tree java_iface_lookup_fn; 5094 5095/* Make an expression which yields the address of the Java interface 5096 method FN. This is achieved by generating a call to libjava's 5097 _Jv_LookupInterfaceMethodIdx(). */ 5098 5099static tree 5100build_java_interface_fn_ref (tree fn, tree instance) 5101{ 5102 tree lookup_args, lookup_fn, method, idx; 5103 tree klass_ref, iface, iface_ref; 5104 int i; 5105 5106 if (!java_iface_lookup_fn) 5107 { 5108 tree endlink = build_void_list_node (); 5109 tree t = tree_cons (NULL_TREE, ptr_type_node, 5110 tree_cons (NULL_TREE, ptr_type_node, 5111 tree_cons (NULL_TREE, java_int_type_node, 5112 endlink))); 5113 java_iface_lookup_fn 5114 = builtin_function ("_Jv_LookupInterfaceMethodIdx", 5115 build_function_type (ptr_type_node, t), 5116 0, NOT_BUILT_IN, NULL, NULL_TREE); 5117 } 5118 5119 /* Look up the pointer to the runtime java.lang.Class object for `instance'. 5120 This is the first entry in the vtable. */ 5121 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0), 5122 integer_zero_node); 5123 5124 /* Get the java.lang.Class pointer for the interface being called. */ 5125 iface = DECL_CONTEXT (fn); 5126 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false); 5127 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL 5128 || DECL_CONTEXT (iface_ref) != iface) 5129 { 5130 error ("could not find class$ field in java interface type %qT", 5131 iface); 5132 return error_mark_node; 5133 } 5134 iface_ref = build_address (iface_ref); 5135 iface_ref = convert (build_pointer_type (iface), iface_ref); 5136 5137 /* Determine the itable index of FN. */ 5138 i = 1; 5139 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method)) 5140 { 5141 if (!DECL_VIRTUAL_P (method)) 5142 continue; 5143 if (fn == method) 5144 break; 5145 i++; 5146 } 5147 idx = build_int_cst (NULL_TREE, i); 5148 5149 lookup_args = tree_cons (NULL_TREE, klass_ref, 5150 tree_cons (NULL_TREE, iface_ref, 5151 build_tree_list (NULL_TREE, idx))); 5152 lookup_fn = build1 (ADDR_EXPR, 5153 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)), 5154 java_iface_lookup_fn); 5155 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE); 5156} 5157 5158/* Returns the value to use for the in-charge parameter when making a 5159 call to a function with the indicated NAME. 5160 5161 FIXME:Can't we find a neater way to do this mapping? */ 5162 5163tree 5164in_charge_arg_for_name (tree name) 5165{ 5166 if (name == base_ctor_identifier 5167 || name == base_dtor_identifier) 5168 return integer_zero_node; 5169 else if (name == complete_ctor_identifier) 5170 return integer_one_node; 5171 else if (name == complete_dtor_identifier) 5172 return integer_two_node; 5173 else if (name == deleting_dtor_identifier) 5174 return integer_three_node; 5175 5176 /* This function should only be called with one of the names listed 5177 above. */ 5178 gcc_unreachable (); 5179 return NULL_TREE; 5180} 5181 5182/* Build a call to a constructor, destructor, or an assignment 5183 operator for INSTANCE, an expression with class type. NAME 5184 indicates the special member function to call; ARGS are the 5185 arguments. BINFO indicates the base of INSTANCE that is to be 5186 passed as the `this' parameter to the member function called. 5187 5188 FLAGS are the LOOKUP_* flags to use when processing the call. 5189 5190 If NAME indicates a complete object constructor, INSTANCE may be 5191 NULL_TREE. In this case, the caller will call build_cplus_new to 5192 store the newly constructed object into a VAR_DECL. */ 5193 5194tree 5195build_special_member_call (tree instance, tree name, tree args, 5196 tree binfo, int flags) 5197{ 5198 tree fns; 5199 /* The type of the subobject to be constructed or destroyed. */ 5200 tree class_type; 5201 5202 gcc_assert (name == complete_ctor_identifier 5203 || name == base_ctor_identifier 5204 || name == complete_dtor_identifier 5205 || name == base_dtor_identifier 5206 || name == deleting_dtor_identifier 5207 || name == ansi_assopname (NOP_EXPR)); 5208 if (TYPE_P (binfo)) 5209 { 5210 /* Resolve the name. */ 5211 if (!complete_type_or_else (binfo, NULL_TREE)) 5212 return error_mark_node; 5213 5214 binfo = TYPE_BINFO (binfo); 5215 } 5216 5217 gcc_assert (binfo != NULL_TREE); 5218 5219 class_type = BINFO_TYPE (binfo); 5220 5221 /* Handle the special case where INSTANCE is NULL_TREE. */ 5222 if (name == complete_ctor_identifier && !instance) 5223 { 5224 instance = build_int_cst (build_pointer_type (class_type), 0); 5225 instance = build1 (INDIRECT_REF, class_type, instance); 5226 } 5227 else 5228 { 5229 if (name == complete_dtor_identifier 5230 || name == base_dtor_identifier 5231 || name == deleting_dtor_identifier) 5232 gcc_assert (args == NULL_TREE); 5233 5234 /* Convert to the base class, if necessary. */ 5235 if (!same_type_ignoring_top_level_qualifiers_p 5236 (TREE_TYPE (instance), BINFO_TYPE (binfo))) 5237 { 5238 if (name != ansi_assopname (NOP_EXPR)) 5239 /* For constructors and destructors, either the base is 5240 non-virtual, or it is virtual but we are doing the 5241 conversion from a constructor or destructor for the 5242 complete object. In either case, we can convert 5243 statically. */ 5244 instance = convert_to_base_statically (instance, binfo); 5245 else 5246 /* However, for assignment operators, we must convert 5247 dynamically if the base is virtual. */ 5248 instance = build_base_path (PLUS_EXPR, instance, 5249 binfo, /*nonnull=*/1); 5250 } 5251 } 5252 5253 gcc_assert (instance != NULL_TREE); 5254 5255 fns = lookup_fnfields (binfo, name, 1); 5256 5257 /* When making a call to a constructor or destructor for a subobject 5258 that uses virtual base classes, pass down a pointer to a VTT for 5259 the subobject. */ 5260 if ((name == base_ctor_identifier 5261 || name == base_dtor_identifier) 5262 && CLASSTYPE_VBASECLASSES (class_type)) 5263 { 5264 tree vtt; 5265 tree sub_vtt; 5266 5267 /* If the current function is a complete object constructor 5268 or destructor, then we fetch the VTT directly. 5269 Otherwise, we look it up using the VTT we were given. */ 5270 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type)); 5271 vtt = decay_conversion (vtt); 5272 vtt = build3 (COND_EXPR, TREE_TYPE (vtt), 5273 build2 (EQ_EXPR, boolean_type_node, 5274 current_in_charge_parm, integer_zero_node), 5275 current_vtt_parm, 5276 vtt); 5277 gcc_assert (BINFO_SUBVTT_INDEX (binfo)); 5278 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt, 5279 BINFO_SUBVTT_INDEX (binfo)); 5280 5281 args = tree_cons (NULL_TREE, sub_vtt, args); 5282 } 5283 5284 return build_new_method_call (instance, fns, args, 5285 TYPE_BINFO (BINFO_TYPE (binfo)), 5286 flags, /*fn=*/NULL); 5287} 5288 5289/* Return the NAME, as a C string. The NAME indicates a function that 5290 is a member of TYPE. *FREE_P is set to true if the caller must 5291 free the memory returned. 5292 5293 Rather than go through all of this, we should simply set the names 5294 of constructors and destructors appropriately, and dispense with 5295 ctor_identifier, dtor_identifier, etc. */ 5296 5297static char * 5298name_as_c_string (tree name, tree type, bool *free_p) 5299{ 5300 char *pretty_name; 5301 5302 /* Assume that we will not allocate memory. */ 5303 *free_p = false; 5304 /* Constructors and destructors are special. */ 5305 if (IDENTIFIER_CTOR_OR_DTOR_P (name)) 5306 { 5307 pretty_name 5308 = (char *) IDENTIFIER_POINTER (constructor_name (type)); 5309 /* For a destructor, add the '~'. */ 5310 if (name == complete_dtor_identifier 5311 || name == base_dtor_identifier 5312 || name == deleting_dtor_identifier) 5313 { 5314 pretty_name = concat ("~", pretty_name, NULL); 5315 /* Remember that we need to free the memory allocated. */ 5316 *free_p = true; 5317 } 5318 } 5319 else if (IDENTIFIER_TYPENAME_P (name)) 5320 { 5321 pretty_name = concat ("operator ", 5322 type_as_string (TREE_TYPE (name), 5323 TFF_PLAIN_IDENTIFIER), 5324 NULL); 5325 /* Remember that we need to free the memory allocated. */ 5326 *free_p = true; 5327 } 5328 else 5329 pretty_name = (char *) IDENTIFIER_POINTER (name); 5330 5331 return pretty_name; 5332} 5333 5334/* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will 5335 be set, upon return, to the function called. */ 5336 5337tree 5338build_new_method_call (tree instance, tree fns, tree args, 5339 tree conversion_path, int flags, 5340 tree *fn_p) 5341{ 5342 struct z_candidate *candidates = 0, *cand; 5343 tree explicit_targs = NULL_TREE; 5344 tree basetype = NULL_TREE; 5345 tree access_binfo; 5346 tree optype; 5347 tree mem_args = NULL_TREE, instance_ptr; 5348 tree name; 5349 tree user_args; 5350 tree call; 5351 tree fn; 5352 tree class_type; 5353 int template_only = 0; 5354 bool any_viable_p; 5355 tree orig_instance; 5356 tree orig_fns; 5357 tree orig_args; 5358 void *p; 5359 5360 gcc_assert (instance != NULL_TREE); 5361 5362 /* We don't know what function we're going to call, yet. */ 5363 if (fn_p) 5364 *fn_p = NULL_TREE; 5365 5366 if (error_operand_p (instance) 5367 || error_operand_p (fns) 5368 || args == error_mark_node) 5369 return error_mark_node; 5370 5371 if (!BASELINK_P (fns)) 5372 { 5373 error ("call to non-function %qD", fns); 5374 return error_mark_node; 5375 } 5376 5377 orig_instance = instance; 5378 orig_fns = fns; 5379 orig_args = args; 5380 5381 /* Dismantle the baselink to collect all the information we need. */ 5382 if (!conversion_path) 5383 conversion_path = BASELINK_BINFO (fns); 5384 access_binfo = BASELINK_ACCESS_BINFO (fns); 5385 optype = BASELINK_OPTYPE (fns); 5386 fns = BASELINK_FUNCTIONS (fns); 5387 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR) 5388 { 5389 explicit_targs = TREE_OPERAND (fns, 1); 5390 fns = TREE_OPERAND (fns, 0); 5391 template_only = 1; 5392 } 5393 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL 5394 || TREE_CODE (fns) == TEMPLATE_DECL 5395 || TREE_CODE (fns) == OVERLOAD); 5396 fn = get_first_fn (fns); 5397 name = DECL_NAME (fn); 5398 5399 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance)); 5400 gcc_assert (CLASS_TYPE_P (basetype)); 5401 5402 if (processing_template_decl) 5403 { 5404 instance = build_non_dependent_expr (instance); 5405 args = build_non_dependent_args (orig_args); 5406 } 5407 5408 /* The USER_ARGS are the arguments we will display to users if an 5409 error occurs. The USER_ARGS should not include any 5410 compiler-generated arguments. The "this" pointer hasn't been 5411 added yet. However, we must remove the VTT pointer if this is a 5412 call to a base-class constructor or destructor. */ 5413 user_args = args; 5414 if (IDENTIFIER_CTOR_OR_DTOR_P (name)) 5415 { 5416 /* Callers should explicitly indicate whether they want to construct 5417 the complete object or just the part without virtual bases. */ 5418 gcc_assert (name != ctor_identifier); 5419 /* Similarly for destructors. */ 5420 gcc_assert (name != dtor_identifier); 5421 /* Remove the VTT pointer, if present. */ 5422 if ((name == base_ctor_identifier || name == base_dtor_identifier) 5423 && CLASSTYPE_VBASECLASSES (basetype)) 5424 user_args = TREE_CHAIN (user_args); 5425 } 5426 5427 /* Process the argument list. */ 5428 args = resolve_args (args); 5429 if (args == error_mark_node) 5430 return error_mark_node; 5431 5432 instance_ptr = build_this (instance); 5433 5434 /* It's OK to call destructors on cv-qualified objects. Therefore, 5435 convert the INSTANCE_PTR to the unqualified type, if necessary. */ 5436 if (DECL_DESTRUCTOR_P (fn)) 5437 { 5438 tree type = build_pointer_type (basetype); 5439 if (!same_type_p (type, TREE_TYPE (instance_ptr))) 5440 instance_ptr = build_nop (type, instance_ptr); 5441 name = complete_dtor_identifier; 5442 } 5443 5444 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE); 5445 mem_args = tree_cons (NULL_TREE, instance_ptr, args); 5446 5447 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 5448 p = conversion_obstack_alloc (0); 5449 5450 for (fn = fns; fn; fn = OVL_NEXT (fn)) 5451 { 5452 tree t = OVL_CURRENT (fn); 5453 tree this_arglist; 5454 5455 /* We can end up here for copy-init of same or base class. */ 5456 if ((flags & LOOKUP_ONLYCONVERTING) 5457 && DECL_NONCONVERTING_P (t)) 5458 continue; 5459 5460 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) 5461 this_arglist = mem_args; 5462 else 5463 this_arglist = args; 5464 5465 if (TREE_CODE (t) == TEMPLATE_DECL) 5466 /* A member template. */ 5467 add_template_candidate (&candidates, t, 5468 class_type, 5469 explicit_targs, 5470 this_arglist, optype, 5471 access_binfo, 5472 conversion_path, 5473 flags, 5474 DEDUCE_CALL); 5475 else if (! template_only) 5476 add_function_candidate (&candidates, t, 5477 class_type, 5478 this_arglist, 5479 access_binfo, 5480 conversion_path, 5481 flags); 5482 } 5483 5484 candidates = splice_viable (candidates, pedantic, &any_viable_p); 5485 if (!any_viable_p) 5486 { 5487 if (!COMPLETE_TYPE_P (basetype)) 5488 cxx_incomplete_type_error (instance_ptr, basetype); 5489 else 5490 { 5491 char *pretty_name; 5492 bool free_p; 5493 5494 pretty_name = name_as_c_string (name, basetype, &free_p); 5495 error ("no matching function for call to %<%T::%s(%A)%#V%>", 5496 basetype, pretty_name, user_args, 5497 TREE_TYPE (TREE_TYPE (instance_ptr))); 5498 if (free_p) 5499 free (pretty_name); 5500 } 5501 print_z_candidates (candidates); 5502 call = error_mark_node; 5503 } 5504 else 5505 { 5506 cand = tourney (candidates); 5507 if (cand == 0) 5508 { 5509 char *pretty_name; 5510 bool free_p; 5511 5512 pretty_name = name_as_c_string (name, basetype, &free_p); 5513 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name, 5514 user_args); 5515 print_z_candidates (candidates); 5516 if (free_p) 5517 free (pretty_name); 5518 call = error_mark_node; 5519 } 5520 else 5521 { 5522 fn = cand->fn; 5523 5524 if (!(flags & LOOKUP_NONVIRTUAL) 5525 && DECL_PURE_VIRTUAL_P (fn) 5526 && instance == current_class_ref 5527 && (DECL_CONSTRUCTOR_P (current_function_decl) 5528 || DECL_DESTRUCTOR_P (current_function_decl))) 5529 /* This is not an error, it is runtime undefined 5530 behavior. */ 5531 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ? 5532 "abstract virtual %q#D called from constructor" 5533 : "abstract virtual %q#D called from destructor"), 5534 fn); 5535 5536 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE 5537 && is_dummy_object (instance_ptr)) 5538 { 5539 error ("cannot call member function %qD without object", 5540 fn); 5541 call = error_mark_node; 5542 } 5543 else 5544 { 5545 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL) 5546 && resolves_to_fixed_type_p (instance, 0)) 5547 flags |= LOOKUP_NONVIRTUAL; 5548 /* Now we know what function is being called. */ 5549 if (fn_p) 5550 *fn_p = fn; 5551 /* Build the actual CALL_EXPR. */ 5552 call = build_over_call (cand, flags); 5553 /* In an expression of the form `a->f()' where `f' turns 5554 out to be a static member function, `a' is 5555 none-the-less evaluated. */ 5556 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE 5557 && !is_dummy_object (instance_ptr) 5558 && TREE_SIDE_EFFECTS (instance_ptr)) 5559 call = build2 (COMPOUND_EXPR, TREE_TYPE (call), 5560 instance_ptr, call); 5561 else if (call != error_mark_node 5562 && DECL_DESTRUCTOR_P (cand->fn) 5563 && !VOID_TYPE_P (TREE_TYPE (call))) 5564 /* An explicit call of the form "x->~X()" has type 5565 "void". However, on platforms where destructors 5566 return "this" (i.e., those where 5567 targetm.cxx.cdtor_returns_this is true), such calls 5568 will appear to have a return value of pointer type 5569 to the low-level call machinery. We do not want to 5570 change the low-level machinery, since we want to be 5571 able to optimize "delete f()" on such platforms as 5572 "operator delete(~X(f()))" (rather than generating 5573 "t = f(), ~X(t), operator delete (t)"). */ 5574 call = build_nop (void_type_node, call); 5575 } 5576 } 5577 } 5578 5579 if (processing_template_decl && call != error_mark_node) 5580 call = (build_min_non_dep 5581 (CALL_EXPR, call, 5582 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE), 5583 orig_args, NULL_TREE)); 5584 5585 /* Free all the conversions we allocated. */ 5586 obstack_free (&conversion_obstack, p); 5587 5588 return call; 5589} 5590 5591/* Returns true iff standard conversion sequence ICS1 is a proper 5592 subsequence of ICS2. */ 5593 5594static bool 5595is_subseq (conversion *ics1, conversion *ics2) 5596{ 5597 /* We can assume that a conversion of the same code 5598 between the same types indicates a subsequence since we only get 5599 here if the types we are converting from are the same. */ 5600 5601 while (ics1->kind == ck_rvalue 5602 || ics1->kind == ck_lvalue) 5603 ics1 = ics1->u.next; 5604 5605 while (1) 5606 { 5607 while (ics2->kind == ck_rvalue 5608 || ics2->kind == ck_lvalue) 5609 ics2 = ics2->u.next; 5610 5611 if (ics2->kind == ck_user 5612 || ics2->kind == ck_ambig 5613 || ics2->kind == ck_identity) 5614 /* At this point, ICS1 cannot be a proper subsequence of 5615 ICS2. We can get a USER_CONV when we are comparing the 5616 second standard conversion sequence of two user conversion 5617 sequences. */ 5618 return false; 5619 5620 ics2 = ics2->u.next; 5621 5622 if (ics2->kind == ics1->kind 5623 && same_type_p (ics2->type, ics1->type) 5624 && same_type_p (ics2->u.next->type, 5625 ics1->u.next->type)) 5626 return true; 5627 } 5628} 5629 5630/* Returns nonzero iff DERIVED is derived from BASE. The inputs may 5631 be any _TYPE nodes. */ 5632 5633bool 5634is_properly_derived_from (tree derived, tree base) 5635{ 5636 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived)) 5637 || !IS_AGGR_TYPE_CODE (TREE_CODE (base))) 5638 return false; 5639 5640 /* We only allow proper derivation here. The DERIVED_FROM_P macro 5641 considers every class derived from itself. */ 5642 return (!same_type_ignoring_top_level_qualifiers_p (derived, base) 5643 && DERIVED_FROM_P (base, derived)); 5644} 5645 5646/* We build the ICS for an implicit object parameter as a pointer 5647 conversion sequence. However, such a sequence should be compared 5648 as if it were a reference conversion sequence. If ICS is the 5649 implicit conversion sequence for an implicit object parameter, 5650 modify it accordingly. */ 5651 5652static void 5653maybe_handle_implicit_object (conversion **ics) 5654{ 5655 if ((*ics)->this_p) 5656 { 5657 /* [over.match.funcs] 5658 5659 For non-static member functions, the type of the 5660 implicit object parameter is "reference to cv X" 5661 where X is the class of which the function is a 5662 member and cv is the cv-qualification on the member 5663 function declaration. */ 5664 conversion *t = *ics; 5665 tree reference_type; 5666 5667 /* The `this' parameter is a pointer to a class type. Make the 5668 implicit conversion talk about a reference to that same class 5669 type. */ 5670 reference_type = TREE_TYPE (t->type); 5671 reference_type = build_reference_type (reference_type); 5672 5673 if (t->kind == ck_qual) 5674 t = t->u.next; 5675 if (t->kind == ck_ptr) 5676 t = t->u.next; 5677 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE); 5678 t = direct_reference_binding (reference_type, t); 5679 *ics = t; 5680 } 5681} 5682 5683/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion, 5684 and return the type to which the reference refers. Otherwise, 5685 leave *ICS unchanged and return NULL_TREE. */ 5686 5687static tree 5688maybe_handle_ref_bind (conversion **ics) 5689{ 5690 if ((*ics)->kind == ck_ref_bind) 5691 { 5692 conversion *old_ics = *ics; 5693 tree type = TREE_TYPE (old_ics->type); 5694 *ics = old_ics->u.next; 5695 (*ics)->user_conv_p = old_ics->user_conv_p; 5696 (*ics)->bad_p = old_ics->bad_p; 5697 return type; 5698 } 5699 5700 return NULL_TREE; 5701} 5702 5703/* Compare two implicit conversion sequences according to the rules set out in 5704 [over.ics.rank]. Return values: 5705 5706 1: ics1 is better than ics2 5707 -1: ics2 is better than ics1 5708 0: ics1 and ics2 are indistinguishable */ 5709 5710static int 5711compare_ics (conversion *ics1, conversion *ics2) 5712{ 5713 tree from_type1; 5714 tree from_type2; 5715 tree to_type1; 5716 tree to_type2; 5717 tree deref_from_type1 = NULL_TREE; 5718 tree deref_from_type2 = NULL_TREE; 5719 tree deref_to_type1 = NULL_TREE; 5720 tree deref_to_type2 = NULL_TREE; 5721 conversion_rank rank1, rank2; 5722 5723 /* REF_BINDING is nonzero if the result of the conversion sequence 5724 is a reference type. In that case TARGET_TYPE is the 5725 type referred to by the reference. */ 5726 tree target_type1; 5727 tree target_type2; 5728 5729 /* Handle implicit object parameters. */ 5730 maybe_handle_implicit_object (&ics1); 5731 maybe_handle_implicit_object (&ics2); 5732 5733 /* Handle reference parameters. */ 5734 target_type1 = maybe_handle_ref_bind (&ics1); 5735 target_type2 = maybe_handle_ref_bind (&ics2); 5736 5737 /* [over.ics.rank] 5738 5739 When comparing the basic forms of implicit conversion sequences (as 5740 defined in _over.best.ics_) 5741 5742 --a standard conversion sequence (_over.ics.scs_) is a better 5743 conversion sequence than a user-defined conversion sequence 5744 or an ellipsis conversion sequence, and 5745 5746 --a user-defined conversion sequence (_over.ics.user_) is a 5747 better conversion sequence than an ellipsis conversion sequence 5748 (_over.ics.ellipsis_). */ 5749 rank1 = CONVERSION_RANK (ics1); 5750 rank2 = CONVERSION_RANK (ics2); 5751 5752 if (rank1 > rank2) 5753 return -1; 5754 else if (rank1 < rank2) 5755 return 1; 5756 5757 if (rank1 == cr_bad) 5758 { 5759 /* XXX Isn't this an extension? */ 5760 /* Both ICS are bad. We try to make a decision based on what 5761 would have happened if they'd been good. */ 5762 if (ics1->user_conv_p > ics2->user_conv_p 5763 || ics1->rank > ics2->rank) 5764 return -1; 5765 else if (ics1->user_conv_p < ics2->user_conv_p 5766 || ics1->rank < ics2->rank) 5767 return 1; 5768 5769 /* We couldn't make up our minds; try to figure it out below. */ 5770 } 5771 5772 if (ics1->ellipsis_p) 5773 /* Both conversions are ellipsis conversions. */ 5774 return 0; 5775 5776 /* User-defined conversion sequence U1 is a better conversion sequence 5777 than another user-defined conversion sequence U2 if they contain the 5778 same user-defined conversion operator or constructor and if the sec- 5779 ond standard conversion sequence of U1 is better than the second 5780 standard conversion sequence of U2. */ 5781 5782 if (ics1->user_conv_p) 5783 { 5784 conversion *t1; 5785 conversion *t2; 5786 5787 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next) 5788 if (t1->kind == ck_ambig) 5789 return 0; 5790 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next) 5791 if (t2->kind == ck_ambig) 5792 return 0; 5793 5794 if (t1->cand->fn != t2->cand->fn) 5795 return 0; 5796 5797 /* We can just fall through here, after setting up 5798 FROM_TYPE1 and FROM_TYPE2. */ 5799 from_type1 = t1->type; 5800 from_type2 = t2->type; 5801 } 5802 else 5803 { 5804 conversion *t1; 5805 conversion *t2; 5806 5807 /* We're dealing with two standard conversion sequences. 5808 5809 [over.ics.rank] 5810 5811 Standard conversion sequence S1 is a better conversion 5812 sequence than standard conversion sequence S2 if 5813 5814 --S1 is a proper subsequence of S2 (comparing the conversion 5815 sequences in the canonical form defined by _over.ics.scs_, 5816 excluding any Lvalue Transformation; the identity 5817 conversion sequence is considered to be a subsequence of 5818 any non-identity conversion sequence */ 5819 5820 t1 = ics1; 5821 while (t1->kind != ck_identity) 5822 t1 = t1->u.next; 5823 from_type1 = t1->type; 5824 5825 t2 = ics2; 5826 while (t2->kind != ck_identity) 5827 t2 = t2->u.next; 5828 from_type2 = t2->type; 5829 } 5830 5831 if (same_type_p (from_type1, from_type2)) 5832 { 5833 if (is_subseq (ics1, ics2)) 5834 return 1; 5835 if (is_subseq (ics2, ics1)) 5836 return -1; 5837 } 5838 /* Otherwise, one sequence cannot be a subsequence of the other; they 5839 don't start with the same type. This can happen when comparing the 5840 second standard conversion sequence in two user-defined conversion 5841 sequences. */ 5842 5843 /* [over.ics.rank] 5844 5845 Or, if not that, 5846 5847 --the rank of S1 is better than the rank of S2 (by the rules 5848 defined below): 5849 5850 Standard conversion sequences are ordered by their ranks: an Exact 5851 Match is a better conversion than a Promotion, which is a better 5852 conversion than a Conversion. 5853 5854 Two conversion sequences with the same rank are indistinguishable 5855 unless one of the following rules applies: 5856 5857 --A conversion that is not a conversion of a pointer, or pointer 5858 to member, to bool is better than another conversion that is such 5859 a conversion. 5860 5861 The ICS_STD_RANK automatically handles the pointer-to-bool rule, 5862 so that we do not have to check it explicitly. */ 5863 if (ics1->rank < ics2->rank) 5864 return 1; 5865 else if (ics2->rank < ics1->rank) 5866 return -1; 5867 5868 to_type1 = ics1->type; 5869 to_type2 = ics2->type; 5870 5871 if (TYPE_PTR_P (from_type1) 5872 && TYPE_PTR_P (from_type2) 5873 && TYPE_PTR_P (to_type1) 5874 && TYPE_PTR_P (to_type2)) 5875 { 5876 deref_from_type1 = TREE_TYPE (from_type1); 5877 deref_from_type2 = TREE_TYPE (from_type2); 5878 deref_to_type1 = TREE_TYPE (to_type1); 5879 deref_to_type2 = TREE_TYPE (to_type2); 5880 } 5881 /* The rules for pointers to members A::* are just like the rules 5882 for pointers A*, except opposite: if B is derived from A then 5883 A::* converts to B::*, not vice versa. For that reason, we 5884 switch the from_ and to_ variables here. */ 5885 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2) 5886 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2)) 5887 || (TYPE_PTRMEMFUNC_P (from_type1) 5888 && TYPE_PTRMEMFUNC_P (from_type2) 5889 && TYPE_PTRMEMFUNC_P (to_type1) 5890 && TYPE_PTRMEMFUNC_P (to_type2))) 5891 { 5892 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1); 5893 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2); 5894 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1); 5895 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2); 5896 } 5897 5898 if (deref_from_type1 != NULL_TREE 5899 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1)) 5900 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2))) 5901 { 5902 /* This was one of the pointer or pointer-like conversions. 5903 5904 [over.ics.rank] 5905 5906 --If class B is derived directly or indirectly from class A, 5907 conversion of B* to A* is better than conversion of B* to 5908 void*, and conversion of A* to void* is better than 5909 conversion of B* to void*. */ 5910 if (TREE_CODE (deref_to_type1) == VOID_TYPE 5911 && TREE_CODE (deref_to_type2) == VOID_TYPE) 5912 { 5913 if (is_properly_derived_from (deref_from_type1, 5914 deref_from_type2)) 5915 return -1; 5916 else if (is_properly_derived_from (deref_from_type2, 5917 deref_from_type1)) 5918 return 1; 5919 } 5920 else if (TREE_CODE (deref_to_type1) == VOID_TYPE 5921 || TREE_CODE (deref_to_type2) == VOID_TYPE) 5922 { 5923 if (same_type_p (deref_from_type1, deref_from_type2)) 5924 { 5925 if (TREE_CODE (deref_to_type2) == VOID_TYPE) 5926 { 5927 if (is_properly_derived_from (deref_from_type1, 5928 deref_to_type1)) 5929 return 1; 5930 } 5931 /* We know that DEREF_TO_TYPE1 is `void' here. */ 5932 else if (is_properly_derived_from (deref_from_type1, 5933 deref_to_type2)) 5934 return -1; 5935 } 5936 } 5937 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1)) 5938 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2))) 5939 { 5940 /* [over.ics.rank] 5941 5942 --If class B is derived directly or indirectly from class A 5943 and class C is derived directly or indirectly from B, 5944 5945 --conversion of C* to B* is better than conversion of C* to 5946 A*, 5947 5948 --conversion of B* to A* is better than conversion of C* to 5949 A* */ 5950 if (same_type_p (deref_from_type1, deref_from_type2)) 5951 { 5952 if (is_properly_derived_from (deref_to_type1, 5953 deref_to_type2)) 5954 return 1; 5955 else if (is_properly_derived_from (deref_to_type2, 5956 deref_to_type1)) 5957 return -1; 5958 } 5959 else if (same_type_p (deref_to_type1, deref_to_type2)) 5960 { 5961 if (is_properly_derived_from (deref_from_type2, 5962 deref_from_type1)) 5963 return 1; 5964 else if (is_properly_derived_from (deref_from_type1, 5965 deref_from_type2)) 5966 return -1; 5967 } 5968 } 5969 } 5970 else if (CLASS_TYPE_P (non_reference (from_type1)) 5971 && same_type_p (from_type1, from_type2)) 5972 { 5973 tree from = non_reference (from_type1); 5974 5975 /* [over.ics.rank] 5976 5977 --binding of an expression of type C to a reference of type 5978 B& is better than binding an expression of type C to a 5979 reference of type A& 5980 5981 --conversion of C to B is better than conversion of C to A, */ 5982 if (is_properly_derived_from (from, to_type1) 5983 && is_properly_derived_from (from, to_type2)) 5984 { 5985 if (is_properly_derived_from (to_type1, to_type2)) 5986 return 1; 5987 else if (is_properly_derived_from (to_type2, to_type1)) 5988 return -1; 5989 } 5990 } 5991 else if (CLASS_TYPE_P (non_reference (to_type1)) 5992 && same_type_p (to_type1, to_type2)) 5993 { 5994 tree to = non_reference (to_type1); 5995 5996 /* [over.ics.rank] 5997 5998 --binding of an expression of type B to a reference of type 5999 A& is better than binding an expression of type C to a 6000 reference of type A&, 6001 6002 --conversion of B to A is better than conversion of C to A */ 6003 if (is_properly_derived_from (from_type1, to) 6004 && is_properly_derived_from (from_type2, to)) 6005 { 6006 if (is_properly_derived_from (from_type2, from_type1)) 6007 return 1; 6008 else if (is_properly_derived_from (from_type1, from_type2)) 6009 return -1; 6010 } 6011 } 6012 6013 /* [over.ics.rank] 6014 6015 --S1 and S2 differ only in their qualification conversion and yield 6016 similar types T1 and T2 (_conv.qual_), respectively, and the cv- 6017 qualification signature of type T1 is a proper subset of the cv- 6018 qualification signature of type T2 */ 6019 if (ics1->kind == ck_qual 6020 && ics2->kind == ck_qual 6021 && same_type_p (from_type1, from_type2)) 6022 return comp_cv_qual_signature (to_type1, to_type2); 6023 6024 /* [over.ics.rank] 6025 6026 --S1 and S2 are reference bindings (_dcl.init.ref_), and the 6027 types to which the references refer are the same type except for 6028 top-level cv-qualifiers, and the type to which the reference 6029 initialized by S2 refers is more cv-qualified than the type to 6030 which the reference initialized by S1 refers */ 6031 6032 if (target_type1 && target_type2 6033 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2)) 6034 return comp_cv_qualification (target_type2, target_type1); 6035 6036 /* Neither conversion sequence is better than the other. */ 6037 return 0; 6038} 6039 6040/* The source type for this standard conversion sequence. */ 6041 6042static tree 6043source_type (conversion *t) 6044{ 6045 for (;; t = t->u.next) 6046 { 6047 if (t->kind == ck_user 6048 || t->kind == ck_ambig 6049 || t->kind == ck_identity) 6050 return t->type; 6051 } 6052 gcc_unreachable (); 6053} 6054 6055/* Note a warning about preferring WINNER to LOSER. We do this by storing 6056 a pointer to LOSER and re-running joust to produce the warning if WINNER 6057 is actually used. */ 6058 6059static void 6060add_warning (struct z_candidate *winner, struct z_candidate *loser) 6061{ 6062 candidate_warning *cw = (candidate_warning *) 6063 conversion_obstack_alloc (sizeof (candidate_warning)); 6064 cw->loser = loser; 6065 cw->next = winner->warnings; 6066 winner->warnings = cw; 6067} 6068 6069/* Compare two candidates for overloading as described in 6070 [over.match.best]. Return values: 6071 6072 1: cand1 is better than cand2 6073 -1: cand2 is better than cand1 6074 0: cand1 and cand2 are indistinguishable */ 6075 6076static int 6077joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn) 6078{ 6079 int winner = 0; 6080 int off1 = 0, off2 = 0; 6081 size_t i; 6082 size_t len; 6083 6084 /* Candidates that involve bad conversions are always worse than those 6085 that don't. */ 6086 if (cand1->viable > cand2->viable) 6087 return 1; 6088 if (cand1->viable < cand2->viable) 6089 return -1; 6090 6091 /* If we have two pseudo-candidates for conversions to the same type, 6092 or two candidates for the same function, arbitrarily pick one. */ 6093 if (cand1->fn == cand2->fn 6094 && (IS_TYPE_OR_DECL_P (cand1->fn))) 6095 return 1; 6096 6097 /* a viable function F1 6098 is defined to be a better function than another viable function F2 if 6099 for all arguments i, ICSi(F1) is not a worse conversion sequence than 6100 ICSi(F2), and then */ 6101 6102 /* for some argument j, ICSj(F1) is a better conversion sequence than 6103 ICSj(F2) */ 6104 6105 /* For comparing static and non-static member functions, we ignore 6106 the implicit object parameter of the non-static function. The 6107 standard says to pretend that the static function has an object 6108 parm, but that won't work with operator overloading. */ 6109 len = cand1->num_convs; 6110 if (len != cand2->num_convs) 6111 { 6112 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn); 6113 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn); 6114 6115 gcc_assert (static_1 != static_2); 6116 6117 if (static_1) 6118 off2 = 1; 6119 else 6120 { 6121 off1 = 1; 6122 --len; 6123 } 6124 } 6125 6126 for (i = 0; i < len; ++i) 6127 { 6128 conversion *t1 = cand1->convs[i + off1]; 6129 conversion *t2 = cand2->convs[i + off2]; 6130 int comp = compare_ics (t1, t2); 6131 6132 if (comp != 0) 6133 { 6134 if (warn_sign_promo 6135 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2) 6136 == cr_std + cr_promotion) 6137 && t1->kind == ck_std 6138 && t2->kind == ck_std 6139 && TREE_CODE (t1->type) == INTEGER_TYPE 6140 && TREE_CODE (t2->type) == INTEGER_TYPE 6141 && (TYPE_PRECISION (t1->type) 6142 == TYPE_PRECISION (t2->type)) 6143 && (TYPE_UNSIGNED (t1->u.next->type) 6144 || (TREE_CODE (t1->u.next->type) 6145 == ENUMERAL_TYPE))) 6146 { 6147 tree type = t1->u.next->type; 6148 tree type1, type2; 6149 struct z_candidate *w, *l; 6150 if (comp > 0) 6151 type1 = t1->type, type2 = t2->type, 6152 w = cand1, l = cand2; 6153 else 6154 type1 = t2->type, type2 = t1->type, 6155 w = cand2, l = cand1; 6156 6157 if (warn) 6158 { 6159 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT", 6160 type, type1, type2); 6161 warning (OPT_Wsign_promo, " in call to %qD", w->fn); 6162 } 6163 else 6164 add_warning (w, l); 6165 } 6166 6167 if (winner && comp != winner) 6168 { 6169 winner = 0; 6170 goto tweak; 6171 } 6172 winner = comp; 6173 } 6174 } 6175 6176 /* warn about confusing overload resolution for user-defined conversions, 6177 either between a constructor and a conversion op, or between two 6178 conversion ops. */ 6179 if (winner && warn_conversion && cand1->second_conv 6180 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn)) 6181 && winner != compare_ics (cand1->second_conv, cand2->second_conv)) 6182 { 6183 struct z_candidate *w, *l; 6184 bool give_warning = false; 6185 6186 if (winner == 1) 6187 w = cand1, l = cand2; 6188 else 6189 w = cand2, l = cand1; 6190 6191 /* We don't want to complain about `X::operator T1 ()' 6192 beating `X::operator T2 () const', when T2 is a no less 6193 cv-qualified version of T1. */ 6194 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn) 6195 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn)) 6196 { 6197 tree t = TREE_TYPE (TREE_TYPE (l->fn)); 6198 tree f = TREE_TYPE (TREE_TYPE (w->fn)); 6199 6200 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t)) 6201 { 6202 t = TREE_TYPE (t); 6203 f = TREE_TYPE (f); 6204 } 6205 if (!comp_ptr_ttypes (t, f)) 6206 give_warning = true; 6207 } 6208 else 6209 give_warning = true; 6210 6211 if (!give_warning) 6212 /*NOP*/; 6213 else if (warn) 6214 { 6215 tree source = source_type (w->convs[0]); 6216 if (! DECL_CONSTRUCTOR_P (w->fn)) 6217 source = TREE_TYPE (source); 6218 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn); 6219 warning (OPT_Wconversion, " for conversion from %qT to %qT", 6220 source, w->second_conv->type); 6221 inform (" because conversion sequence for the argument is better"); 6222 } 6223 else 6224 add_warning (w, l); 6225 } 6226 6227 if (winner) 6228 return winner; 6229 6230 /* or, if not that, 6231 F1 is a non-template function and F2 is a template function 6232 specialization. */ 6233 6234 if (!cand1->template_decl && cand2->template_decl) 6235 return 1; 6236 else if (cand1->template_decl && !cand2->template_decl) 6237 return -1; 6238 6239 /* or, if not that, 6240 F1 and F2 are template functions and the function template for F1 is 6241 more specialized than the template for F2 according to the partial 6242 ordering rules. */ 6243 6244 if (cand1->template_decl && cand2->template_decl) 6245 { 6246 winner = more_specialized_fn 6247 (TI_TEMPLATE (cand1->template_decl), 6248 TI_TEMPLATE (cand2->template_decl), 6249 /* [temp.func.order]: The presence of unused ellipsis and default 6250 arguments has no effect on the partial ordering of function 6251 templates. add_function_candidate() will not have 6252 counted the "this" argument for constructors. */ 6253 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn)); 6254 if (winner) 6255 return winner; 6256 } 6257 6258 /* or, if not that, 6259 the context is an initialization by user-defined conversion (see 6260 _dcl.init_ and _over.match.user_) and the standard conversion 6261 sequence from the return type of F1 to the destination type (i.e., 6262 the type of the entity being initialized) is a better conversion 6263 sequence than the standard conversion sequence from the return type 6264 of F2 to the destination type. */ 6265 6266 if (cand1->second_conv) 6267 { 6268 winner = compare_ics (cand1->second_conv, cand2->second_conv); 6269 if (winner) 6270 return winner; 6271 } 6272 6273 /* Check whether we can discard a builtin candidate, either because we 6274 have two identical ones or matching builtin and non-builtin candidates. 6275 6276 (Pedantically in the latter case the builtin which matched the user 6277 function should not be added to the overload set, but we spot it here. 6278 6279 [over.match.oper] 6280 ... the builtin candidates include ... 6281 - do not have the same parameter type list as any non-template 6282 non-member candidate. */ 6283 6284 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE 6285 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE) 6286 { 6287 for (i = 0; i < len; ++i) 6288 if (!same_type_p (cand1->convs[i]->type, 6289 cand2->convs[i]->type)) 6290 break; 6291 if (i == cand1->num_convs) 6292 { 6293 if (cand1->fn == cand2->fn) 6294 /* Two built-in candidates; arbitrarily pick one. */ 6295 return 1; 6296 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE) 6297 /* cand1 is built-in; prefer cand2. */ 6298 return -1; 6299 else 6300 /* cand2 is built-in; prefer cand1. */ 6301 return 1; 6302 } 6303 } 6304 6305 /* If the two functions are the same (this can happen with declarations 6306 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */ 6307 if (DECL_P (cand1->fn) && DECL_P (cand2->fn) 6308 && equal_functions (cand1->fn, cand2->fn)) 6309 return 1; 6310 6311tweak: 6312 6313 /* Extension: If the worst conversion for one candidate is worse than the 6314 worst conversion for the other, take the first. */ 6315 if (!pedantic) 6316 { 6317 conversion_rank rank1 = cr_identity, rank2 = cr_identity; 6318 struct z_candidate *w = 0, *l = 0; 6319 6320 for (i = 0; i < len; ++i) 6321 { 6322 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1) 6323 rank1 = CONVERSION_RANK (cand1->convs[i+off1]); 6324 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2) 6325 rank2 = CONVERSION_RANK (cand2->convs[i + off2]); 6326 } 6327 if (rank1 < rank2) 6328 winner = 1, w = cand1, l = cand2; 6329 if (rank1 > rank2) 6330 winner = -1, w = cand2, l = cand1; 6331 if (winner) 6332 { 6333 if (warn) 6334 { 6335 pedwarn ("\ 6336ISO C++ says that these are ambiguous, even \ 6337though the worst conversion for the first is better than \ 6338the worst conversion for the second:"); 6339 print_z_candidate (_("candidate 1:"), w); 6340 print_z_candidate (_("candidate 2:"), l); 6341 } 6342 else 6343 add_warning (w, l); 6344 return winner; 6345 } 6346 } 6347 6348 gcc_assert (!winner); 6349 return 0; 6350} 6351 6352/* Given a list of candidates for overloading, find the best one, if any. 6353 This algorithm has a worst case of O(2n) (winner is last), and a best 6354 case of O(n/2) (totally ambiguous); much better than a sorting 6355 algorithm. */ 6356 6357static struct z_candidate * 6358tourney (struct z_candidate *candidates) 6359{ 6360 struct z_candidate *champ = candidates, *challenger; 6361 int fate; 6362 int champ_compared_to_predecessor = 0; 6363 6364 /* Walk through the list once, comparing each current champ to the next 6365 candidate, knocking out a candidate or two with each comparison. */ 6366 6367 for (challenger = champ->next; challenger; ) 6368 { 6369 fate = joust (champ, challenger, 0); 6370 if (fate == 1) 6371 challenger = challenger->next; 6372 else 6373 { 6374 if (fate == 0) 6375 { 6376 champ = challenger->next; 6377 if (champ == 0) 6378 return NULL; 6379 champ_compared_to_predecessor = 0; 6380 } 6381 else 6382 { 6383 champ = challenger; 6384 champ_compared_to_predecessor = 1; 6385 } 6386 6387 challenger = champ->next; 6388 } 6389 } 6390 6391 /* Make sure the champ is better than all the candidates it hasn't yet 6392 been compared to. */ 6393 6394 for (challenger = candidates; 6395 challenger != champ 6396 && !(champ_compared_to_predecessor && challenger->next == champ); 6397 challenger = challenger->next) 6398 { 6399 fate = joust (champ, challenger, 0); 6400 if (fate != 1) 6401 return NULL; 6402 } 6403 6404 return champ; 6405} 6406 6407/* Returns nonzero if things of type FROM can be converted to TO. */ 6408 6409bool 6410can_convert (tree to, tree from) 6411{ 6412 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL); 6413} 6414 6415/* Returns nonzero if ARG (of type FROM) can be converted to TO. */ 6416 6417bool 6418can_convert_arg (tree to, tree from, tree arg, int flags) 6419{ 6420 conversion *t; 6421 void *p; 6422 bool ok_p; 6423 6424 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 6425 p = conversion_obstack_alloc (0); 6426 6427 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false, 6428 flags); 6429 ok_p = (t && !t->bad_p); 6430 6431 /* Free all the conversions we allocated. */ 6432 obstack_free (&conversion_obstack, p); 6433 6434 return ok_p; 6435} 6436 6437/* Like can_convert_arg, but allows dubious conversions as well. */ 6438 6439bool 6440can_convert_arg_bad (tree to, tree from, tree arg) 6441{ 6442 conversion *t; 6443 void *p; 6444 6445 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 6446 p = conversion_obstack_alloc (0); 6447 /* Try to perform the conversion. */ 6448 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false, 6449 LOOKUP_NORMAL); 6450 /* Free all the conversions we allocated. */ 6451 obstack_free (&conversion_obstack, p); 6452 6453 return t != NULL; 6454} 6455 6456/* Convert EXPR to TYPE. Return the converted expression. 6457 6458 Note that we allow bad conversions here because by the time we get to 6459 this point we are committed to doing the conversion. If we end up 6460 doing a bad conversion, convert_like will complain. */ 6461 6462tree 6463perform_implicit_conversion (tree type, tree expr) 6464{ 6465 conversion *conv; 6466 void *p; 6467 6468 if (error_operand_p (expr)) 6469 return error_mark_node; 6470 6471 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 6472 p = conversion_obstack_alloc (0); 6473 6474 conv = implicit_conversion (type, TREE_TYPE (expr), expr, 6475 /*c_cast_p=*/false, 6476 LOOKUP_NORMAL); 6477 if (!conv) 6478 { 6479 error ("could not convert %qE to %qT", expr, type); 6480 expr = error_mark_node; 6481 } 6482 else if (processing_template_decl) 6483 { 6484 /* In a template, we are only concerned about determining the 6485 type of non-dependent expressions, so we do not have to 6486 perform the actual conversion. */ 6487 if (TREE_TYPE (expr) != type) 6488 expr = build_nop (type, expr); 6489 } 6490 else 6491 expr = convert_like (conv, expr); 6492 6493 /* Free all the conversions we allocated. */ 6494 obstack_free (&conversion_obstack, p); 6495 6496 return expr; 6497} 6498 6499/* Convert EXPR to TYPE (as a direct-initialization) if that is 6500 permitted. If the conversion is valid, the converted expression is 6501 returned. Otherwise, NULL_TREE is returned, except in the case 6502 that TYPE is a class type; in that case, an error is issued. If 6503 C_CAST_P is true, then this direction initialization is taking 6504 place as part of a static_cast being attempted as part of a C-style 6505 cast. */ 6506 6507tree 6508perform_direct_initialization_if_possible (tree type, 6509 tree expr, 6510 bool c_cast_p) 6511{ 6512 conversion *conv; 6513 void *p; 6514 6515 if (type == error_mark_node || error_operand_p (expr)) 6516 return error_mark_node; 6517 /* [dcl.init] 6518 6519 If the destination type is a (possibly cv-qualified) class type: 6520 6521 -- If the initialization is direct-initialization ..., 6522 constructors are considered. ... If no constructor applies, or 6523 the overload resolution is ambiguous, the initialization is 6524 ill-formed. */ 6525 if (CLASS_TYPE_P (type)) 6526 { 6527 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, 6528 build_tree_list (NULL_TREE, expr), 6529 type, LOOKUP_NORMAL); 6530 return build_cplus_new (type, expr); 6531 } 6532 6533 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 6534 p = conversion_obstack_alloc (0); 6535 6536 conv = implicit_conversion (type, TREE_TYPE (expr), expr, 6537 c_cast_p, 6538 LOOKUP_NORMAL); 6539 if (!conv || conv->bad_p) 6540 expr = NULL_TREE; 6541 else 6542 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0, 6543 /*issue_conversion_warnings=*/false, 6544 c_cast_p); 6545 6546 /* Free all the conversions we allocated. */ 6547 obstack_free (&conversion_obstack, p); 6548 6549 return expr; 6550} 6551 6552/* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference 6553 is being bound to a temporary. Create and return a new VAR_DECL 6554 with the indicated TYPE; this variable will store the value to 6555 which the reference is bound. */ 6556 6557tree 6558make_temporary_var_for_ref_to_temp (tree decl, tree type) 6559{ 6560 tree var; 6561 6562 /* Create the variable. */ 6563 var = create_temporary_var (type); 6564 6565 /* Register the variable. */ 6566 if (TREE_STATIC (decl)) 6567 { 6568 /* Namespace-scope or local static; give it a mangled name. */ 6569 tree name; 6570 6571 TREE_STATIC (var) = 1; 6572 name = mangle_ref_init_variable (decl); 6573 DECL_NAME (var) = name; 6574 SET_DECL_ASSEMBLER_NAME (var, name); 6575 var = pushdecl_top_level (var); 6576 } 6577 else 6578 /* Create a new cleanup level if necessary. */ 6579 maybe_push_cleanup_level (type); 6580 6581 return var; 6582} 6583 6584/* Convert EXPR to the indicated reference TYPE, in a way suitable for 6585 initializing a variable of that TYPE. If DECL is non-NULL, it is 6586 the VAR_DECL being initialized with the EXPR. (In that case, the 6587 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must 6588 also be non-NULL, and with *CLEANUP initialized to NULL. Upon 6589 return, if *CLEANUP is no longer NULL, it will be an expression 6590 that should be pushed as a cleanup after the returned expression 6591 is used to initialize DECL. 6592 6593 Return the converted expression. */ 6594 6595tree 6596initialize_reference (tree type, tree expr, tree decl, tree *cleanup) 6597{ 6598 conversion *conv; 6599 void *p; 6600 6601 if (type == error_mark_node || error_operand_p (expr)) 6602 return error_mark_node; 6603 6604 /* Get the high-water mark for the CONVERSION_OBSTACK. */ 6605 p = conversion_obstack_alloc (0); 6606 6607 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false, 6608 LOOKUP_NORMAL); 6609 if (!conv || conv->bad_p) 6610 { 6611 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST) 6612 && !real_lvalue_p (expr)) 6613 error ("invalid initialization of non-const reference of " 6614 "type %qT from a temporary of type %qT", 6615 type, TREE_TYPE (expr)); 6616 else 6617 error ("invalid initialization of reference of type " 6618 "%qT from expression of type %qT", type, 6619 TREE_TYPE (expr)); 6620 return error_mark_node; 6621 } 6622 6623 /* If DECL is non-NULL, then this special rule applies: 6624 6625 [class.temporary] 6626 6627 The temporary to which the reference is bound or the temporary 6628 that is the complete object to which the reference is bound 6629 persists for the lifetime of the reference. 6630 6631 The temporaries created during the evaluation of the expression 6632 initializing the reference, except the temporary to which the 6633 reference is bound, are destroyed at the end of the 6634 full-expression in which they are created. 6635 6636 In that case, we store the converted expression into a new 6637 VAR_DECL in a new scope. 6638 6639 However, we want to be careful not to create temporaries when 6640 they are not required. For example, given: 6641 6642 struct B {}; 6643 struct D : public B {}; 6644 D f(); 6645 const B& b = f(); 6646 6647 there is no need to copy the return value from "f"; we can just 6648 extend its lifetime. Similarly, given: 6649 6650 struct S {}; 6651 struct T { operator S(); }; 6652 T t; 6653 const S& s = t; 6654 6655 we can extend the lifetime of the return value of the conversion 6656 operator. */ 6657 gcc_assert (conv->kind == ck_ref_bind); 6658 if (decl) 6659 { 6660 tree var; 6661 tree base_conv_type; 6662 6663 /* Skip over the REF_BIND. */ 6664 conv = conv->u.next; 6665 /* If the next conversion is a BASE_CONV, skip that too -- but 6666 remember that the conversion was required. */ 6667 if (conv->kind == ck_base) 6668 { 6669 if (conv->check_copy_constructor_p) 6670 check_constructor_callable (TREE_TYPE (expr), expr); 6671 base_conv_type = conv->type; 6672 conv = conv->u.next; 6673 } 6674 else 6675 base_conv_type = NULL_TREE; 6676 /* Perform the remainder of the conversion. */ 6677 expr = convert_like_real (conv, expr, 6678 /*fn=*/NULL_TREE, /*argnum=*/0, 6679 /*inner=*/-1, 6680 /*issue_conversion_warnings=*/true, 6681 /*c_cast_p=*/false); 6682 if (error_operand_p (expr)) 6683 expr = error_mark_node; 6684 else 6685 { 6686 if (!real_lvalue_p (expr)) 6687 { 6688 tree init; 6689 tree type; 6690 6691 /* Create the temporary variable. */ 6692 type = TREE_TYPE (expr); 6693 var = make_temporary_var_for_ref_to_temp (decl, type); 6694 layout_decl (var, 0); 6695 /* If the rvalue is the result of a function call it will be 6696 a TARGET_EXPR. If it is some other construct (such as a 6697 member access expression where the underlying object is 6698 itself the result of a function call), turn it into a 6699 TARGET_EXPR here. It is important that EXPR be a 6700 TARGET_EXPR below since otherwise the INIT_EXPR will 6701 attempt to make a bitwise copy of EXPR to initialize 6702 VAR. */ 6703 if (TREE_CODE (expr) != TARGET_EXPR) 6704 expr = get_target_expr (expr); 6705 /* Create the INIT_EXPR that will initialize the temporary 6706 variable. */ 6707 init = build2 (INIT_EXPR, type, var, expr); 6708 if (at_function_scope_p ()) 6709 { 6710 add_decl_expr (var); 6711 *cleanup = cxx_maybe_build_cleanup (var); 6712 6713 /* We must be careful to destroy the temporary only 6714 after its initialization has taken place. If the 6715 initialization throws an exception, then the 6716 destructor should not be run. We cannot simply 6717 transform INIT into something like: 6718 6719 (INIT, ({ CLEANUP_STMT; })) 6720 6721 because emit_local_var always treats the 6722 initializer as a full-expression. Thus, the 6723 destructor would run too early; it would run at the 6724 end of initializing the reference variable, rather 6725 than at the end of the block enclosing the 6726 reference variable. 6727 6728 The solution is to pass back a cleanup expression 6729 which the caller is responsible for attaching to 6730 the statement tree. */ 6731 } 6732 else 6733 { 6734 rest_of_decl_compilation (var, /*toplev=*/1, at_eof); 6735 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 6736 static_aggregates = tree_cons (NULL_TREE, var, 6737 static_aggregates); 6738 } 6739 /* Use its address to initialize the reference variable. */ 6740 expr = build_address (var); 6741 if (base_conv_type) 6742 expr = convert_to_base (expr, 6743 build_pointer_type (base_conv_type), 6744 /*check_access=*/true, 6745 /*nonnull=*/true); 6746 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr); 6747 } 6748 else 6749 /* Take the address of EXPR. */ 6750 expr = build_unary_op (ADDR_EXPR, expr, 0); 6751 /* If a BASE_CONV was required, perform it now. */ 6752 if (base_conv_type) 6753 expr = (perform_implicit_conversion 6754 (build_pointer_type (base_conv_type), expr)); 6755 expr = build_nop (type, expr); 6756 } 6757 } 6758 else 6759 /* Perform the conversion. */ 6760 expr = convert_like (conv, expr); 6761 6762 /* Free all the conversions we allocated. */ 6763 obstack_free (&conversion_obstack, p); 6764 6765 return expr; 6766} 6767 6768#include "gt-cp-call.h"
|