| blob | 9764ed369a2d68b4260d64b43c89ceb123cbd02c |
1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* This file is part of the C++ front end.
25 It contains routines to build C++ expressions given their operands,
26 including computing the types of the result, C and C++ specific error
27 checks, and some optimization. */
64 /* Do `exp = require_complete_type (exp);' to make sure exp
65 does not have an incomplete type. (That includes void types.)
66 Returns the error_mark_node if the VALUE does not have
67 complete type when this function returns. */
69 tree
71 {
72 tree type;
79 else
85 /* First, detect a valid value with a complete type. */
91 else
93 }
95 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
96 a template instantiation, do the instantiation. Returns TYPE,
97 whether or not it could be completed, unless something goes
98 horribly wrong, in which case the error_mark_node is returned. */
100 tree
102 {
104 /* Rather than crash, we return something sure to cause an error
105 at some point. */
109 ;
111 {
116 needs_constructing
118 has_nontrivial_dtor
121 {
124 }
125 }
130 }
132 /* Like complete_type, but issue an error if the TYPE cannot be completed.
133 VALUE is used for informative diagnostics.
134 Returns NULL_TREE if the type cannot be made complete. */
136 tree
138 {
141 /* We already issued an error. */
144 {
147 }
148 else
150 }
152 /* Return truthvalue of whether type of EXP is instantiated. */
154 int
156 {
159 }
161 \f
162 /* Return the common type of two parameter lists.
163 We assume that cp_comptypes has already been done and returned 1;
164 if that isn't so, this may crash.
166 As an optimization, free the space we allocate if the parameter
167 lists are already common. */
169 static tree
171 {
181 else
182 {
185 }
194 {
196 {
199 }
201 {
203 {
206 }
207 }
208 else
209 {
213 }
215 {
218 }
219 else
221 }
226 }
228 /* Given a type, perhaps copied for a typedef,
229 find the "original" version of it. */
230 static tree
232 {
236 {
244 }
246 }
248 /* T1 and T2 are arithmetic or enumeration types. Return the type
249 that will result from the "usual arithmetic conversions" on T1 and
250 T2 as described in [expr]. */
252 tree
254 {
257 tree attributes;
259 /* FIXME: Attributes. */
267 /* In what follows, we slightly generalize the rules given in [expr] so
268 as to deal with `long long' and `complex'. First, merge the
269 attributes. */
272 /* If one type is complex, form the common type of the non-complex
273 components, then make that complex. Use T1 or T2 if it is the
274 required type. */
276 {
279 tree subtype
286 else
288 attributes);
289 }
292 {
293 /* When we get here we should have two vectors of the same size.
294 Just prefer the unsigned one if present. */
297 else
299 }
301 /* If only one is real, use it as the result. */
307 /* Perform the integral promotions. */
309 {
312 }
314 /* Both real or both integers; use the one with greater precision. */
320 /* The types are the same; no need to do anything fancy. */
325 {
326 /* If one is unsigned long long, then convert the other to unsigned
327 long long. */
331 attributes);
332 /* If one is a long long, and the other is an unsigned long, and
333 long long can represent all the values of an unsigned long, then
334 convert to a long long. Otherwise, convert to an unsigned long
335 long. Otherwise, if either operand is long long, convert the
336 other to long long.
338 Since we're here, we know the TYPE_PRECISION is the same;
339 therefore converting to long long cannot represent all the values
340 of an unsigned long, so we choose unsigned long long in that
341 case. */
344 {
346 ? long_long_unsigned_type_node
349 }
351 /* Go through the same procedure, but for longs. */
355 attributes);
358 {
362 }
363 /* Otherwise prefer the unsigned one. */
366 else
368 }
369 else
370 {
374 attributes);
378 attributes);
382 attributes);
384 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
385 the standard C++ floating-point types. Logic earlier in this
386 function has already eliminated the possibility that
387 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
388 compelling reason to choose one or the other. */
390 }
391 }
393 /* Subroutine of composite_pointer_type to implement the recursive
394 case. See that function for documentation fo the parameters. */
396 static tree
398 {
399 tree pointee1;
400 tree pointee2;
401 tree result_type;
402 tree attributes;
404 /* Determine the types pointed to by T1 and T2. */
406 {
409 }
410 else
411 {
414 }
416 /* [expr.rel]
418 Otherwise, the composite pointer type is a pointer type
419 similar (_conv.qual_) to the type of one of the operands,
420 with a cv-qualification signature (_conv.qual_) that is the
421 union of the cv-qualification signatures of the operand
422 types. */
430 else
431 {
436 }
440 /* If the original types were pointers to members, so is the
441 result. */
443 {
450 result_type);
451 }
452 else
455 /* Merge the attributes. */
458 }
460 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
461 ARG1 and ARG2 are the values with those types. The LOCATION is a
462 string describing the current location, in case an error occurs.
464 This routine also implements the computation of a common type for
465 pointers-to-members as per [expr.eq]. */
467 tree
470 {
471 tree class1;
472 tree class2;
474 /* [expr.rel]
476 If one operand is a null pointer constant, the composite pointer
477 type is the type of the other operand. */
483 /* We have:
485 [expr.rel]
487 If one of the operands has type "pointer to cv1 void*", then
488 the other has type "pointer to cv2T", and the composite pointer
489 type is "pointer to cv12 void", where cv12 is the union of cv1
490 and cv2.
492 If either type is a pointer to void, make sure it is T1. */
494 {
495 tree t;
499 }
501 /* Now, if T1 is a pointer to void, merge the qualifiers. */
503 {
504 tree attributes;
505 tree result_type;
510 result_type
515 /* Merge the attributes. */
518 }
522 {
525 }
527 /* [expr.eq] permits the application of a pointer conversion to
528 bring the pointers to a common type. */
534 {
539 t2 = (build_pointer_type
542 t1 = (build_pointer_type
544 else
545 {
549 }
550 }
551 /* [expr.eq] permits the application of a pointer-to-member
552 conversion to change the class type of one of the types. */
556 {
564 else
565 {
569 }
570 }
573 }
575 /* Return the merged type of two types.
576 We assume that cp_comptypes has already been done and returned 1;
577 if that isn't so, this may crash.
579 This just combines attributes and default arguments; any other
580 differences would cause the two types to compare unalike. */
582 tree
584 {
587 tree attributes;
589 /* Save time if the two types are the same. */
595 /* If one type is nonsense, use the other. */
601 /* Merge the attributes. */
613 {
616 /* For two pointers, do this recursively on the target type. */
617 {
623 else
632 }
635 {
637 tree pointee;
642 pointee);
645 }
648 {
650 /* Save space: see if the result is identical to one of the args. */
655 /* Merge the element types, and have a size if either arg has one. */
656 t1 = build_cplus_array_type
659 }
662 /* Function types: prefer the one that specified arg types.
663 If both do, merge the arg types. Also merge the return types. */
664 {
670 /* Save space: see if the result is identical to one of the args. */
676 /* Simple way if one arg fails to specify argument types. */
678 {
683 }
686 {
691 }
696 }
699 {
700 /* Get this value the long way, since TYPE_METHOD_BASETYPE
701 is just the main variant of this. */
704 tree t3;
706 /* If this was a member function type, get back to the
707 original type of type member function (i.e., without
708 the class instance variable up front. */
718 }
721 /* There is no need to merge attributes into a TYPENAME_TYPE.
722 When the type is instantiated it will have whatever
723 attributes result from the instantiation. */
727 }
733 else
735 }
737 /* Return the common type of two types.
738 We assume that cp_comptypes has already been done and returned 1;
739 if that isn't so, this may crash.
741 This is the type for the result of most arithmetic operations
742 if the operands have the given two types. */
744 tree
746 {
750 /* If one type is nonsense, bail. */
768 else
770 }
771 \f
772 /* Compare two exception specifier types for exactness or subsetness, if
773 allowed. Returns false for mismatch, true for match (same, or
774 derived and !exact).
776 [except.spec] "If a class X ... objects of class X or any class publicly
777 and unambiguously derived from X. Similarly, if a pointer type Y * ...
778 exceptions of type Y * or that are pointers to any type publicly and
779 unambiguously derived from Y. Otherwise a function only allows exceptions
780 that have the same type ..."
781 This does not mention cv qualifiers and is different to what throw
782 [except.throw] and catch [except.catch] will do. They will ignore the
783 top level cv qualifiers, and allow qualifiers in the pointer to class
784 example.
786 We implement the letter of the standard. */
788 static bool
790 {
794 {
800 {
805 }
813 }
815 }
817 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
818 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
819 otherwise it must be exact. Exception lists are unordered, but
820 we've already filtered out duplicates. Most lists will be in order,
821 we should try to make use of that. */
823 bool
825 {
826 const_tree probe;
827 const_tree base;
842 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
843 Count how many we find, to determine exactness. For exact matching and
844 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
845 O(nm). */
847 {
849 {
854 {
857 length++;
859 }
860 }
863 }
865 }
867 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
868 [] can match [size]. */
870 static bool
872 {
873 tree d1;
874 tree d2;
880 /* The type of the array elements must be the same. */
890 /* If one of the arrays is dimensionless, and the other has a
891 dimension, they are of different types. However, it is valid to
892 write:
894 extern int a[];
895 int a[3];
897 by [basic.link]:
899 declarations for an array object can specify
900 array types that differ by the presence or absence of a major
901 array bound (_dcl.array_). */
905 /* Check that the dimensions are the same. */
914 {
915 /* With abi-1 we do not fold non-dependent array bounds, (and
916 consequently mangle them incorrectly). We must therefore
917 fold them here, to verify the domains have the same
918 value. */
921 }
927 }
929 /* Subroutine in cp_comptypes. */
931 static bool
933 {
937 /* Suppress errors caused by previously reported errors. */
943 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
944 current instantiation. */
956 /* Different classes of types can't be compatible. */
960 /* Qualifiers must match. For array types, we will check when we
961 recur on the array element types. */
966 /* Allow for two different type nodes which have essentially the same
967 definition. Note that we already checked for equality of the type
968 qualifiers (just above). */
977 /* Compare the types. Break out if they could be the same. */
979 {
982 /* All void and bool types are the same. */
988 /* With these nodes, we can't determine type equivalence by
989 looking at what is stored in the nodes themselves, because
990 two nodes might have different TYPE_MAIN_VARIANTs but still
991 represent the same type. For example, wchar_t and int could
992 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
993 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
994 and are distinct types. On the other hand, int and the
995 following typedef
997 typedef int INT __attribute((may_alias));
999 have identical properties, different TYPE_MAIN_VARIANTs, but
1000 represent the same type. The canonical type system keeps
1001 track of equivalence in this case, so we fall back on it. */
1017 /* Don't check inheritance. */
1019 /* Fall through. */
1047 /* fall through to checks for pointer types */
1065 /* Target types must match incl. qualifiers. */
1118 }
1120 /* If we get here, we know that from a target independent POV the
1121 types are the same. Make sure the target attributes are also
1122 the same. */
1124 }
1128 /* Type comparison function that matches the signature of comptypes
1129 from c-tree.h, which is used by the C front end and some of the
1130 C/C++ common bits. */
1131 int
1133 {
1135 }
1137 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1138 is a bitwise-or of the COMPARE_* flags. */
1140 bool
1142 {
1144 {
1152 /* At least one of the types requires structural equality, so
1153 perform a deep check. */
1156 #ifdef ENABLE_CHECKING
1158 {
1162 /* The two types are structurally equivalent, but their
1163 canonical types were different. This is a failure of the
1164 canonical type propagation code.*/
1165 internal_error
1169 /* Two types are structurally different, but the canonical
1170 types are the same. This means we were over-eager in
1171 assigning canonical types. */
1172 internal_error
1177 }
1178 #else
1181 #endif
1182 else
1184 }
1187 else
1189 }
1191 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1193 bool
1195 {
1199 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1201 }
1203 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1204 more cv-qualified that TYPE1, and 0 otherwise. */
1206 int
1208 {
1221 }
1223 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1224 subset of the cv-qualification signature of TYPE2, and the types
1225 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1227 int
1229 {
1234 else
1236 }
1237 \f
1238 /* Subroutines of `cp_comptypes'. */
1240 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1241 equivalent in the sense that functions with those parameter types
1242 can have equivalent types. The two lists must be equivalent,
1243 element by element. */
1245 bool
1247 {
1250 /* An unspecified parmlist matches any specified parmlist
1251 whose argument types don't need default promotions. */
1256 {
1257 /* If one parmlist is shorter than the other,
1258 they fail to match. */
1263 }
1265 }
1267 \f
1268 /* Process a sizeof or alignof expression where the operand is a
1269 type. */
1271 tree
1273 {
1274 tree value;
1283 {
1288 }
1294 /* VLA types will have a non-constant size. In the body of an
1295 uninstantiated template, we don't need to try to compute the
1296 value, because the sizeof expression is not an integral
1297 constant expression in that case. And, if we do try to
1298 compute the value, we'll likely end up with SAVE_EXPRs, which
1299 the template substitution machinery does not expect to see. */
1300 || (processing_template_decl
1303 {
1307 }
1311 complain);
1312 }
1314 /* Process a sizeof expression where the operand is an expression. */
1316 static tree
1318 {
1323 {
1329 }
1334 {
1337 }
1339 {
1343 }
1345 {
1348 }
1349 else
1353 }
1355 /* Implement the __alignof keyword: Return the minimum required
1356 alignment of E, measured in bytes. For VAR_DECL's and
1357 FIELD_DECL's return DECL_ALIGN (which can be set from an
1358 "aligned" __attribute__ specification). */
1360 static tree
1362 {
1363 tree t;
1369 {
1375 }
1382 {
1385 }
1390 {
1395 else
1397 }
1399 {
1402 }
1403 else
1407 }
1409 /* Process a sizeof or alignof expression E with code OP where the operand
1410 is an expression. */
1412 tree
1414 {
1417 else
1419 }
1420 \f
1421 /* EXPR is being used in a context that is not a function call.
1422 Enforce:
1424 [expr.ref]
1426 The expression can be used only as the left-hand operand of a
1427 member function call.
1429 [expr.mptr.operator]
1431 If the result of .* or ->* is a function, then that result can be
1432 used only as the operand for the function call operator ().
1434 by issuing an error message if appropriate. Returns true iff EXPR
1435 violates these rules. */
1437 bool
1439 {
1441 {
1444 }
1446 }
1448 /* If EXP is a reference to a bitfield, and the type of EXP does not
1449 match the declared type of the bitfield, return the declared type
1450 of the bitfield. Otherwise, return NULL_TREE. */
1452 tree
1454 {
1456 {
1472 {
1473 tree field;
1482 }
1489 /* Fallthrough. */
1493 }
1494 }
1496 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1497 bitfield with a lowered type, the type of EXP is returned, rather
1498 than NULL_TREE. */
1500 tree
1502 {
1503 tree type;
1510 }
1512 /* Perform the conversions in [expr] that apply when an lvalue appears
1513 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1514 function-to-pointer conversions. In addition, manifest constants
1515 are replaced by their values, and bitfield references are converted
1516 to their declared types.
1518 Although the returned value is being used as an rvalue, this
1519 function does not wrap the returned expression in a
1520 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1521 that the return value is no longer an lvalue. */
1523 tree
1525 {
1526 tree type;
1534 {
1537 }
1543 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1544 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1547 {
1550 }
1556 {
1557 tree adr;
1558 tree ptrtype;
1565 {
1569 }
1573 {
1576 }
1581 {
1586 }
1587 /* This way is better for a COMPONENT_REF since it can
1588 simplify the offset for a component. */
1591 }
1593 /* If a bitfield is used in a context where integral promotion
1594 applies, then the caller is expected to have used
1595 default_conversion. That function promotes bitfields correctly
1596 before calling this function. At this point, if we have a
1597 bitfield referenced, we may assume that is not subject to
1598 promotion, and that, therefore, the type of the resulting rvalue
1599 is the declared type of the bitfield. */
1602 /* We do not call rvalue() here because we do not want to wrap EXP
1603 in a NON_LVALUE_EXPR. */
1605 /* [basic.lval]
1607 Non-class rvalues always have cv-unqualified types. */
1613 }
1615 /* Perform prepatory conversions, as part of the "usual arithmetic
1616 conversions". In particular, as per [expr]:
1618 Whenever an lvalue expression appears as an operand of an
1619 operator that expects the rvalue for that operand, the
1620 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1621 standard conversions are applied to convert the expression to an
1622 rvalue.
1624 In addition, we perform integral promotions here, as those are
1625 applied to both operands to a binary operator before determining
1626 what additional conversions should apply. */
1628 tree
1630 {
1631 /* Perform the integral promotions first so that bitfield
1632 expressions (which may promote to "int", even if the bitfield is
1633 declared "unsigned") are promoted correctly. */
1636 /* Perform the other conversions. */
1640 }
1642 /* EXPR is an expression with an integral or enumeration type.
1643 Perform the integral promotions in [conv.prom], and return the
1644 converted value. */
1646 tree
1648 {
1649 tree type;
1650 tree promoted_type;
1652 /* [conv.prom]
1654 If the bitfield has an enumerated type, it is treated as any
1655 other value of that type for promotion purposes. */
1664 }
1666 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1667 or TREE_USED. */
1669 tree
1671 {
1676 }
1678 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1679 decay_conversion to one. */
1681 int
1683 {
1684 tree t;
1695 {
1696 /* Make sure that we don't try to convert between char and wchar_t. */
1699 }
1700 else
1701 {
1702 /* Is this a string constant which has decayed to 'const char *'? */
1710 }
1712 /* This warning is not very useful, as it complains about printf. */
1716 totype);
1719 }
1721 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1722 can, for example, use as an lvalue. This code used to be in
1723 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1724 expressions, where we're dealing with aggregates. But now it's again only
1725 called from unary_complex_lvalue. The case (in particular) that led to
1726 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1727 get it there. */
1729 static tree
1731 {
1732 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1733 the first operand is always the one to be used if both operands
1734 are equal, so we know what conditional expression this used to be. */
1736 {
1740 /* The following code is incorrect if either operand side-effects. */
1743 return
1751 }
1753 return
1757 }
1759 /* Given the TYPE of an anonymous union field inside T, return the
1760 FIELD_DECL for the field. If not found return NULL_TREE. Because
1761 anonymous unions can nest, we must also search all anonymous unions
1762 that are directly reachable. */
1764 tree
1766 {
1767 tree field;
1770 {
1776 /* If we find it directly, return the field. */
1779 {
1781 }
1783 /* Otherwise, it could be nested, search harder. */
1786 {
1790 }
1791 }
1793 }
1795 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1796 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1797 non-NULL, it indicates the path to the base used to name MEMBER.
1798 If PRESERVE_REFERENCE is true, the expression returned will have
1799 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1800 returned will have the type referred to by the reference.
1802 This function does not perform access control; that is either done
1803 earlier by the parser when the name of MEMBER is resolved to MEMBER
1804 itself, or later when overload resolution selects one of the
1805 functions indicated by MEMBER. */
1807 tree
1810 {
1811 tree object_type;
1812 tree member_scope;
1820 /* [expr.ref]
1822 The type of the first expression shall be "class object" (of a
1823 complete type). */
1829 {
1833 }
1835 /* The standard does not seem to actually say that MEMBER must be a
1836 member of OBJECT_TYPE. However, that is clearly what is
1837 intended. */
1839 {
1844 }
1845 else
1847 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1848 presently be the anonymous union. Go outwards until we find a
1849 type related to OBJECT_TYPE. */
1852 object_type))
1855 {
1858 else
1861 }
1863 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1864 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1865 in the front end; only _DECLs and _REFs are lvalues in the back end. */
1866 {
1870 }
1872 /* In [expr.ref], there is an explicit list of the valid choices for
1873 MEMBER. We check for each of those cases here. */
1875 {
1876 /* A static data member. */
1878 /* If OBJECT has side-effects, they are supposed to occur. */
1881 }
1883 {
1884 /* A non-static data member. */
1887 tree member_type;
1892 /* Convert OBJECT to the type of MEMBER. */
1895 {
1896 tree binfo;
1897 base_kind kind;
1904 /* It is invalid to try to get to a virtual base of a
1905 NULL object. The most common cause is invalid use of
1906 offsetof macro. */
1908 {
1911 member);
1914 }
1916 /* Convert to the base. */
1919 /* If we found the base successfully then we should be able
1920 to convert to it successfully. */
1922 }
1924 /* Complain about other invalid uses of offsetof, even though they will
1925 give the right answer. Note that we complain whether or not they
1926 actually used the offsetof macro, since there's no way to know at this
1927 point. So we just give a warning, instead of a pedwarn. */
1928 /* Do not produce this warning for base class field references, because
1929 we know for a fact that didn't come from offsetof. This does occur
1930 in various testsuite cases where a null object is passed where a
1931 vtable access is required. */
1936 {
1938 member);
1940 }
1942 /* If MEMBER is from an anonymous aggregate, we have converted
1943 OBJECT so that it refers to the class containing the
1944 anonymous union. Generate a reference to the anonymous union
1945 itself, and recur to find MEMBER. */
1947 /* When this code is called from build_field_call, the
1948 object already has the type of the anonymous union.
1949 That is because the COMPONENT_REF was already
1950 constructed, and was then disassembled before calling
1951 build_field_call. After the function-call code is
1952 cleaned up, this waste can be eliminated. */
1953 && (!same_type_ignoring_top_level_qualifiers_p
1955 {
1956 tree anonymous_union;
1961 anonymous_union,
1963 preserve_reference);
1964 }
1966 /* Compute the type of the field, as described in [expr.ref]. */
1970 {
1974 /* A field is const (volatile) if the enclosing object, or the
1975 field itself, is const (volatile). But, a mutable field is
1976 not const, even within a const object. */
1980 }
1983 NULL_TREE);
1986 /* Mark the expression const or volatile, as appropriate. Even
1987 though we've dealt with the type above, we still have to mark the
1988 expression itself. */
1993 }
1995 {
1996 /* The member is a (possibly overloaded) member function. */
1997 tree functions;
1998 tree type;
2000 /* If the MEMBER is exactly one static member function, then we
2001 know the type of the expression. Otherwise, we must wait
2002 until overload resolution has been performed. */
2007 else
2009 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2010 base. That will happen when the function is called. */
2012 }
2014 {
2015 /* The member is an enumerator. */
2017 /* If OBJECT has side-effects, they are supposed to occur. */
2021 }
2022 else
2023 {
2026 }
2029 /* [expr.ref]
2031 If E2 is declared to have type "reference to T", then ... the
2032 type of E1.E2 is T. */
2036 }
2038 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
2039 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
2041 static tree
2043 {
2046 tree expr;
2049 {
2053 }
2055 {
2059 }
2062 expr = (adjust_result_of_qualified_name_lookup
2065 }
2067 /* An expression of the form "A::template B" has been resolved to
2068 DECL. Issue a diagnostic if B is not a template or template
2069 specialization. */
2071 void
2073 {
2074 /* The standard says:
2076 [temp.names]
2078 If a name prefixed by the keyword template is not a member
2079 template, the program is ill-formed.
2081 DR 228 removed the restriction that the template be a member
2082 template.
2084 DR 96, if accepted would add the further restriction that explicit
2085 template arguments must be provided if the template keyword is
2086 used, but, as of 2005-10-16, that DR is still in "drafting". If
2087 this DR is accepted, then the semantic checks here can be
2088 simplified, as the entity named must in fact be a template
2089 specialization, rather than, as at present, a set of overloaded
2090 functions containing at least one template function. */
2093 {
2096 else
2097 {
2098 tree fns;
2103 {
2113 }
2116 }
2117 }
2118 }
2120 /* This function is called by the parser to process a class member
2121 access expression of the form OBJECT.NAME. NAME is a node used by
2122 the parser to represent a name; it is not yet a DECL. It may,
2123 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2124 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2125 there is no reason to do the lookup twice, so the parser keeps the
2126 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
2127 be a template via the use of the "A::template B" syntax. */
2129 tree
2131 {
2132 tree expr;
2133 tree object_type;
2134 tree member;
2142 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
2149 {
2152 /* If NAME is just an IDENTIFIER_NODE, then the expression
2153 is dependent. */
2155 /* If NAME is "f<args>", where either 'f' or 'args' is
2156 dependent, then the expression is dependent. */
2160 /* If NAME is "T::X" where "T" is dependent, then the
2161 expression is dependent. */
2167 }
2169 /* [expr.ref]
2171 The type of the first expression shall be "class object" (of a
2172 complete type). */
2177 {
2181 }
2184 /* A member function that has already been looked up. */
2186 else
2187 {
2190 tree scope;
2193 {
2202 }
2205 {
2206 /* A qualified name. The qualifying class or namespace `S'
2207 has already been looked up; it is either a TYPE or a
2208 NAMESPACE_DECL. */
2212 /* If SCOPE is a namespace, then the qualified name does not
2213 name a member of OBJECT_TYPE. */
2215 {
2219 }
2225 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2230 {
2233 }
2234 }
2235 else
2236 {
2239 }
2243 else
2244 {
2245 /* Look up the member. */
2249 {
2252 }
2255 }
2258 {
2263 else
2264 {
2267 }
2268 }
2269 }
2280 {
2282 {
2286 }
2289 NULL_TREE);
2290 }
2293 }
2295 /* Return an expression for the MEMBER_NAME field in the internal
2296 representation of PTRMEM, a pointer-to-member function. (Each
2297 pointer-to-member function type gets its own RECORD_TYPE so it is
2298 more convenient to access the fields by name than by FIELD_DECL.)
2299 This routine converts the NAME to a FIELD_DECL and then creates the
2300 node for the complete expression. */
2302 tree
2304 {
2305 tree ptrmem_type;
2306 tree member;
2307 tree member_type;
2309 /* This code is a stripped down version of
2310 build_class_member_access_expr. It does not work to use that
2311 routine directly because it expects the object to be of class
2312 type. */
2321 }
2323 /* Given an expression PTR for a pointer, return an expression
2324 for the value pointed to.
2325 ERRORSTRING is the name of the operator to appear in error messages.
2327 This function may need to overload OPERATOR_FNNAME.
2328 Must also handle REFERENCE_TYPEs for C++. */
2330 tree
2332 {
2334 tree rval;
2337 {
2341 }
2350 else
2352 }
2354 tree
2356 {
2370 {
2371 /* [expr.unary.op]
2373 If the type of the expression is "pointer to T," the type
2374 of the result is "T."
2376 We must use the canonical variant because certain parts of
2377 the back end, like fold, do pointer comparisons between
2378 types. */
2384 {
2385 /* If a warning is issued, mark it to avoid duplicates from
2386 the backend. This only needs to be done at
2387 warn_strict_aliasing > 2. */
2392 }
2395 {
2396 /* A pointer to incomplete type (other than cv void) can be
2397 dereferenced [expr.unary.op]/1 */
2400 }
2403 /* The POINTER was something like `&x'. We simplify `*&x' to
2404 `x'. */
2406 else
2407 {
2410 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2411 so that we get the proper error message if the result is used
2412 to assign to. Also, &* is supposed to be a no-op. */
2418 }
2419 }
2420 /* `pointer' won't be an error_mark_node if we were given a
2421 pointer to member, so it's cool to check for this here. */
2425 {
2428 else
2430 }
2432 }
2434 /* This handles expressions of the form "a[i]", which denotes
2435 an array reference.
2437 This is logically equivalent in C to *(a+i), but we may do it differently.
2438 If A is a variable or a member, we generate a primitive ARRAY_REF.
2439 This avoids forcing the array out of registers, and can work on
2440 arrays that are not lvalues (for example, members of structures returned
2441 by functions).
2443 If INDEX is of some user-defined type, it must be converted to
2444 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2445 will inherit the type of the array, which will be some pointer type. */
2447 tree
2449 {
2451 {
2454 }
2460 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2461 inside it. */
2463 {
2465 {
2469 }
2472 return build_conditional_expr
2479 }
2482 {
2488 {
2491 }
2493 /* Apply integral promotions *after* noticing character types.
2494 (It is unclear why we do these promotions -- the standard
2495 does not say that we should. In fact, the natural thing would
2496 seem to be to convert IDX to ptrdiff_t; we're performing
2497 pointer arithmetic.) */
2500 /* An array that is indexed by a non-constant
2501 cannot be stored in a register; we must be able to do
2502 address arithmetic on its address.
2503 Likewise an array of elements of variable size. */
2508 {
2511 }
2513 /* An array that is indexed by a constant value which is not within
2514 the array bounds cannot be stored in a register either; because we
2515 would get a crash in store_bit_field/extract_bit_field when trying
2516 to access a non-existent part of the register. */
2520 {
2523 }
2528 /* Note in C++ it is valid to subscript a `register' array, since
2529 it is valid to take the address of something with that
2530 storage specification. */
2532 {
2538 }
2542 /* Array ref is const/volatile if the array elements are
2543 or if the array is.. */
2551 }
2553 {
2557 /* Put the integer in IND to simplify error checking. */
2559 {
2563 }
2569 {
2572 }
2574 {
2577 }
2583 }
2584 }
2585 \f
2586 /* Resolve a pointer to member function. INSTANCE is the object
2587 instance to use, if the member points to a virtual member.
2589 This used to avoid checking for virtual functions if basetype
2590 has no virtual functions, according to an earlier ANSI draft.
2591 With the final ISO C++ rules, such an optimization is
2592 incorrect: A pointer to a derived member can be static_cast
2593 to pointer-to-base-member, as long as the dynamic object
2594 later has the right member. */
2596 tree
2598 {
2603 {
2610 {
2612 {
2613 /* Extracting the function address from a pmf is only
2614 allowed with -Wno-pmf-conversions. It only works for
2615 pmf constants. */
2619 }
2620 else
2621 {
2624 }
2625 }
2633 /* Start by extracting all the information from the PMF itself. */
2638 {
2651 }
2653 /* Convert down to the right base before using the instance. A
2654 special case is that in a pointer to member of class C, C may
2655 be incomplete. In that case, the function will of course be
2656 a member of C, and no conversion is required. In fact,
2657 lookup_base will fail in that case, because incomplete
2658 classes do not have BINFOs. */
2662 {
2669 }
2670 /* ...and then the delta in the PMF. */
2674 /* Hand back the adjusted 'this' argument to our caller. */
2677 /* Next extract the vtable pointer from the object. */
2679 instance_ptr);
2682 /* Finally, extract the function pointer from the vtable. */
2689 /* When using function descriptors, the address of the
2690 vtable entry is treated as a function pointer. */
2698 /* Make sure this doesn't get evaluated first inside one of the
2699 branches of the COND_EXPR. */
2705 }
2707 }
2709 tree
2711 {
2718 tree parm_types;
2720 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2721 expressions, like those used for ObjC messenger dispatches. */
2724 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2725 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2731 {
2737 /* Convert anything with function type to a pointer-to-function. */
2741 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2742 (because calling an inline function does not mean the function
2743 needs to be separately compiled). */
2747 else
2749 }
2750 else
2751 {
2755 }
2763 {
2766 original);
2768 }
2775 || is_method
2777 {
2780 }
2782 /* fntype now gets the type of function pointed to. */
2786 /* Allocate storage for converted arguments. */
2793 /* Convert the parameters to the types declared in the
2794 function prototype, or apply default promotions. */
2800 /* Check for errors in format strings and inappropriately
2801 null parameters. */
2804 parm_types);
2807 }
2808 \f
2809 /* Convert the actual parameter expressions in the list VALUES
2810 to the types in the list TYPELIST.
2811 If parmdecls is exhausted, or when an element has NULL as its type,
2812 perform the default conversions.
2814 Store the converted arguments in ARGARRAY. NARGS is the size of this array.
2816 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2818 This is also where warnings about wrong number of args are generated.
2820 Returns the actual number of arguments processed (which might be less
2821 than NARGS), or -1 on error.
2823 VALUES is a chain of TREE_LIST nodes with the elements of the list
2824 in the TREE_VALUE slots of those nodes.
2826 In C++, unspecified trailing parameters can be filled in with their
2827 default arguments, if such were specified. Do so here. */
2829 static int
2832 {
2837 /* Argument passing is always copy-initialization. */
2841 {
2843 {
2847 else
2849 }
2850 else
2852 }
2855 valtail;
2857 {
2865 {
2867 {
2870 }
2871 else
2874 }
2876 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2877 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2884 {
2889 }
2895 {
2896 /* Formal parm type is specified by a function prototype. */
2897 tree parmval;
2900 {
2904 else
2907 }
2908 else
2909 {
2910 parmval = convert_for_initialization
2914 }
2920 }
2921 else
2922 {
2925 /* Don't do ellipsis conversion for __built_in_constant_p
2926 as this will result in spurious warnings for non-POD
2927 types. */
2929 else
2933 }
2937 }
2940 {
2941 /* See if there are default arguments that can be used. Because
2942 we hold default arguments in the FUNCTION_TYPE (which is so
2943 wrong), we can see default parameters here from deduced
2944 contexts (and via typeof) for indirect function calls.
2945 Fortunately we know whether we have a function decl to
2946 provide default arguments in a language conformant
2947 manner. */
2950 {
2952 {
2953 tree parmval
2963 /* ends with `...'. */
2966 }
2967 }
2968 else
2969 {
2971 {
2974 }
2975 else
2978 }
2979 }
2983 }
2984 \f
2985 /* Build a binary-operation expression, after performing default
2986 conversions on the operands. CODE is the kind of expression to
2987 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
2988 are the tree codes which correspond to ARG1 and ARG2 when issuing
2989 warnings about possibly misplaced parentheses. They may differ
2990 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
2991 folding (e.g., if the parser sees "a | 1 + 1", it may call this
2992 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
2993 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
2994 ARG2_CODE as ERROR_MARK. */
2996 tree
2999 {
3000 tree orig_arg1;
3001 tree orig_arg2;
3002 tree expr;
3008 {
3014 }
3018 else
3020 overloaded_p);
3022 /* Check for cases such as x+y<<z which users are likely to
3023 misinterpret. But don't warn about obj << x + y, since that is a
3024 common idiom for I/O. */
3026 && !processing_template_decl
3037 }
3039 /* Build a binary-operation expression without default conversions.
3040 CODE is the kind of expression to build.
3041 This function differs from `build' in several ways:
3042 the data type of the result is computed and recorded in it,
3043 warnings are generated if arg data types are invalid,
3044 special handling for addition and subtraction of pointers is known,
3045 and some optimization is done (operations on narrow ints
3046 are done in the narrower type when that gives the same result).
3047 Constant folding is also done before the result is returned.
3049 Note that the operands will never have enumeral types
3050 because either they have just had the default conversions performed
3051 or they have both just been converted to some other type in which
3052 the arithmetic is to be done.
3054 C++: must do special pointer arithmetic when implementing
3055 multiple inheritance, and deal with pointer to member functions. */
3057 tree
3060 {
3066 /* Expression code to give to the expression when it is built.
3067 Normally this is CODE, which is what the caller asked for,
3068 but in some special cases we change it. */
3071 /* Data type in which the computation is to be performed.
3072 In the simplest cases this is the common type of the arguments. */
3075 /* Nonzero means operands have already been type-converted
3076 in whatever way is necessary.
3077 Zero means they need to be converted to RESULT_TYPE. */
3080 /* Nonzero means create the expression with this type, rather than
3081 RESULT_TYPE. */
3084 /* Nonzero means after finally constructing the expression
3085 convert it to this type. */
3088 tree result;
3090 /* Nonzero if this is an operation like MIN or MAX which can
3091 safely be computed in short if both args are promoted shorts.
3092 Also implies COMMON.
3093 -1 indicates a bitwise operation; this makes a difference
3094 in the exact conditions for when it is safe to do the operation
3095 in a narrower mode. */
3098 /* Nonzero if this is a comparison operation;
3099 if both args are promoted shorts, compare the original shorts.
3100 Also implies COMMON. */
3103 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3106 /* True if both operands have arithmetic type. */
3109 /* Apply default conversions. */
3116 {
3121 }
3122 else
3123 {
3128 }
3130 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3134 /* DTRT if one side is an overloaded function, but complain about it. */
3136 {
3139 {
3143 }
3144 }
3146 {
3149 {
3153 }
3154 }
3159 /* The expression codes of the data types of the arguments tell us
3160 whether the arguments are integers, floating, pointers, etc. */
3164 /* If an error was already reported for one of the arguments,
3165 avoid reporting another error. */
3172 {
3175 }
3178 {
3180 /* Subtraction of two similar pointers.
3181 We must subtract them as integers, then divide by object size. */
3186 /* In all other cases except pointer - int, the usual arithmetic
3187 rules aply. */
3189 {
3192 }
3193 /* The pointer - int case is just like pointer + int; fall
3194 through. */
3198 {
3199 tree ptr_operand;
3200 tree int_operand;
3204 {
3207 }
3209 ptr_operand,
3210 int_operand);
3211 }
3228 {
3240 else
3241 /* When dividing two signed integers, we have to promote to int.
3242 unless we divide by a constant != -1. Note that default
3243 conversion will have been performed on the operands at this
3244 point, so we have to dig out the original type to find out if
3245 it was unsigned. */
3252 }
3270 {
3271 /* Although it would be tempting to shorten always here, that loses
3272 on some targets, since the modulo instruction is undefined if the
3273 quotient can't be represented in the computation mode. We shorten
3274 only if unsigned or if dividing by something we know != -1. */
3280 }
3290 /* Shift operations: result has same type as first operand;
3291 always convert second operand to int.
3292 Also set SHORT_SHIFT if shifting rightward. */
3296 {
3299 {
3302 else
3303 {
3306 }
3307 }
3308 /* Convert the shift-count to an integer, regardless of
3309 size of value being shifted. */
3312 /* Avoid converting op1 to result_type later. */
3314 }
3319 {
3322 {
3327 }
3328 /* Convert the shift-count to an integer, regardless of
3329 size of value being shifted. */
3332 /* Avoid converting op1 to result_type later. */
3334 }
3340 {
3343 {
3352 }
3353 /* Convert the shift-count to an integer, regardless of
3354 size of value being shifted. */
3357 }
3381 {
3387 }
3390 {
3396 }
3398 {
3401 }
3403 {
3406 }
3408 {
3411 {
3415 pfn0,
3417 integer_zero_node));
3419 delta0,
3420 integer_one_node);
3424 }
3425 else
3426 {
3429 }
3431 }
3435 {
3436 tree type;
3437 /* E will be the final comparison. */
3438 tree e;
3439 /* E1 and E2 are for scratch. */
3440 tree e1;
3441 tree e2;
3442 tree pfn0;
3443 tree pfn1;
3444 tree delta0;
3445 tree delta1;
3468 {
3469 /* We generate:
3471 (op0.pfn == op1.pfn
3472 && ((op0.delta == op1.delta)
3473 || (!op0.pfn && op0.delta & 1 == 0
3474 && op1.delta & 1 == 0))
3476 The reason for the `!op0.pfn' bit is that a NULL
3477 pointer-to-member is any member with a zero PFN and
3478 LSB of the DELTA field is 0. */
3481 delta0,
3482 integer_one_node);
3485 delta1,
3486 integer_one_node);
3490 pfn0,
3492 integer_zero_node));
3496 }
3497 else
3498 {
3499 /* We generate:
3501 (op0.pfn == op1.pfn
3502 && (!op0.pfn || op0.delta == op1.delta))
3504 The reason for the `!op0.pfn' bit is that a NULL
3505 pointer-to-member is any member with a zero PFN; the
3506 DELTA field is unspecified. */
3510 pfn0,
3512 integer_zero_node));
3514 }
3520 }
3521 else
3522 {
3525 type1));
3528 type0));
3529 }
3565 {
3568 }
3570 {
3573 }
3585 {
3588 }
3594 }
3600 else
3601 {
3603 /* Vector arithmetic is only allowed when both sides are vectors. */
3605 {
3609 {
3612 }
3614 }
3615 }
3616 /* Determine the RESULT_TYPE, if it is not already known. */
3618 && arithmetic_types_p
3623 {
3627 }
3629 /* If we're in a template, the only thing we need to know is the
3630 RESULT_TYPE. */
3632 {
3633 /* Since the middle-end checks the type when doing a build2, we
3634 need to build the tree in pieces. This built tree will never
3635 get out of the front-end as we replace it when instantiating
3636 the template. */
3642 }
3645 {
3648 /* For certain operations (which identify themselves by shorten != 0)
3649 if both args were extended from the same smaller type,
3650 do the arithmetic in that type and then extend.
3652 shorten !=0 and !=1 indicates a bitwise operation.
3653 For them, this optimization is safe only if
3654 both args are zero-extended or both are sign-extended.
3655 Otherwise, we might change the result.
3656 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3657 but calculated in (unsigned short) it would be (unsigned short)-1. */
3660 {
3664 /* UNS is 1 if the operation to be done is an unsigned one. */
3666 tree type;
3670 /* Handle the case that OP0 does not *contain* a conversion
3671 but it *requires* conversion to FINAL_TYPE. */
3678 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3680 /* For bitwise operations, signedness of nominal type
3681 does not matter. Consider only how operands were extended. */
3685 /* Note that in all three cases below we refrain from optimizing
3686 an unsigned operation on sign-extended args.
3687 That would not be valid. */
3689 /* Both args variable: if both extended in same way
3690 from same width, do it in that width.
3691 Do it unsigned if args were zero-extended. */
3698 result_type = c_common_signed_or_unsigned_type
3716 }
3718 /* Comparison operations are shortened too but differently.
3719 They identify themselves by setting short_compare = 1. */
3722 {
3723 /* Don't write &op0, etc., because that would prevent op0
3724 from being kept in a register.
3725 Instead, make copies of the our local variables and
3726 pass the copies by reference, then copy them back afterward. */
3729 tree val
3736 }
3739 && warn_sign_compare
3740 /* Do not warn until the template is instantiated; we cannot
3741 bound the ranges of the arguments until that point. */
3743 {
3751 /* Check for comparison of different enum types. */
3756 {
3759 }
3761 /* Give warnings for comparisons between signed and unsigned
3762 quantities that may fail. */
3763 /* Do the checking based on the original operand trees, so that
3764 casts will be considered, but default promotions won't be. */
3766 /* Do not warn if the comparison is being done in a signed type,
3767 since the signed type will only be chosen if it can represent
3768 all the values of the unsigned type. */
3771 /* Do not warn if both operands are unsigned. */
3774 /* Do not warn if the signed quantity is an unsuffixed
3775 integer literal (or some static constant expression
3776 involving such literals or a conditional expression
3777 involving such literals) and it is non-negative. */
3781 /* Do not warn if the comparison is an equality operation,
3782 the unsigned quantity is an integral constant and it does
3783 not use the most significant bit of result_type. */
3792 else
3796 /* Warn if two unsigned values are being compared in a size
3797 larger than their original size, and one (and only one) is the
3798 result of a `~' operator. This comparison will always fail.
3800 Also warn if one operand is a constant, and the constant does not
3801 have all bits set that are set in the ~ operand when it is
3802 extended. */
3806 {
3813 {
3814 tree primop;
3820 {
3824 }
3825 else
3826 {
3830 }
3835 {
3839 }
3840 }
3847 }
3848 }
3849 }
3851 /* Issue warnings about peculiar, but valid, uses of NULL. */
3853 /* It's reasonable to use pointer values as operands of &&
3854 and ||, so NULL is no exception. */
3859 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
3862 /* Some sort of arithmetic operation involving NULL was
3863 performed. Note that pointer-difference and pointer-addition
3864 have already been handled above, and so we don't end up here in
3865 that case. */
3869 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3870 Then the expression will be built.
3871 It will be given type FINAL_TYPE if that is nonzero;
3872 otherwise, it will be given type RESULT_TYPE. */
3874 {
3882 }
3898 }
3899 \f
3900 /* Return a tree for the sum or difference (RESULTCODE says which)
3901 of pointer PTROP and integer INTOP. */
3903 static tree
3905 {
3908 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3909 in certain circumstance (when it's valid to do so). So we need
3910 to make sure it's complete. We don't need to check here, if we
3911 can actually complete it at all, as those checks will be done in
3912 pointer_int_sum() anyway. */
3917 }
3919 /* Return a tree for the difference of pointers OP0 and OP1.
3920 The resulting tree has type int. */
3922 static tree
3924 {
3925 tree result;
3933 {
3940 }
3942 /* First do the subtraction as integers;
3943 then drop through to build the divide operator. */
3949 /* This generates an error if op1 is a pointer to an incomplete type. */
3957 /* Do the division. */
3961 }
3962 \f
3963 /* Construct and perhaps optimize a tree representation
3964 for a unary operation. CODE, a tree_code, specifies the operation
3965 and XARG is the operand. */
3967 tree
3969 {
3971 tree exp;
3975 {
3980 }
3984 /* [expr.unary.op] says:
3986 The address of an object of incomplete type can be taken.
3988 (And is just the ordinary address operator, not an overloaded
3989 "operator &".) However, if the type is a template
3990 specialization, we must complete the type at this point so that
3991 an overloaded "operator &" will be available if required. */
3998 else
4002 {
4003 /* A pointer to member-function can be formed only by saying
4004 &X::mf. */
4007 {
4010 {
4012 xarg);
4016 }
4017 else
4018 {
4021 xarg);
4023 }
4024 }
4027 {
4032 {
4033 /* A single non-static member, make sure we don't allow a
4034 pointer-to-member. */
4039 }
4040 }
4044 }
4052 }
4054 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4055 constants, where a null value is represented by an INTEGER_CST of
4056 -1. */
4058 tree
4060 {
4064 else
4066 }
4068 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4070 tree
4072 {
4073 tree t;
4079 }
4081 /* Return an ADDR_EXPR giving the address of T. This function
4082 attempts no optimizations or simplifications; it is a low-level
4083 primitive. */
4085 tree
4087 {
4088 tree addr;
4096 }
4098 /* Return a NOP_EXPR converting EXPR to TYPE. */
4100 tree
4102 {
4106 }
4108 /* C++: Must handle pointers to members.
4110 Perhaps type instantiation should be extended to handle conversion
4111 from aggregates to types we don't yet know we want? (Or are those
4112 cases typically errors which should be reported?)
4114 NOCONVERT nonzero suppresses the default promotions
4115 (such as from short to int). */
4117 tree
4119 {
4120 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4124 tree val;
4132 ? CONVERT_EXPR
4135 {
4138 }
4141 {
4144 {
4146 /* Unary plus (but not unary minus) is allowed on pointers. */
4154 else
4155 {
4159 /* Make sure the result is not an lvalue: a unary plus or minus
4160 expression is always a rvalue. */
4162 }
4163 }
4168 {
4172 }
4189 /* Conjugating a real value is a no-op, but allow it anyway. */
4211 {
4214 }
4215 else
4222 {
4225 }
4226 else
4233 /* Handle complex lvalues (when permitted)
4234 by reduction to simpler cases. */
4240 /* Increment or decrement the real part of the value,
4241 and don't change the imaginary part. */
4243 {
4254 }
4256 /* Report invalid types. */
4260 {
4267 else
4270 }
4274 /* Report something read-only. */
4282 {
4283 tree inc;
4284 tree declared_type;
4292 /* ARM $5.2.5 last annotation says this should be forbidden. */
4298 /* Compute the increment. */
4301 {
4316 argtype);
4318 }
4319 else
4324 /* Complain about anything else that is not a true lvalue. */
4330 /* Forbid using -- on `bool'. */
4332 {
4334 {
4338 }
4340 }
4341 else
4346 }
4349 /* Note that this operation never does default_conversion
4350 regardless of NOCONVERT. */
4358 {
4362 }
4364 /* ARM $3.4 */
4367 /* Let &* cancel out to simplify resulting code. */
4369 {
4370 /* We don't need to have `current_class_ptr' wrapped in a
4371 NON_LVALUE_EXPR node. */
4377 {
4380 }
4381 else
4382 /* Don't let this be an lvalue. */
4385 }
4387 /* Uninstantiated types are all functions. Taking the
4388 address of a function is a no-op, so just return the
4389 argument. */
4396 {
4397 /* They're trying to take the address of a unique non-static
4398 member function. This is ill-formed (except in MS-land),
4399 but let's try to DTRT.
4400 Note: We only handle unique functions here because we don't
4401 want to complain if there's a static overload; non-unique
4402 cases will be handled by instantiate_type. But we need to
4403 handle this case here to allow casts on the resulting PMF.
4404 We could defer this in non-MS mode, but it's easier to give
4405 a useful error here. */
4407 /* Inside constant member functions, the `this' pointer
4408 contains an extra const qualifier. TYPE_MAIN_VARIANT
4409 is used here to remove this const from the diagnostics
4410 and the created OFFSET_REF. */
4416 {
4420 /* An expression like &memfn. */
4422 " or parenthesized non-static member function to form"
4425 else
4427 " function to form a pointer to member function."
4430 }
4432 }
4434 offset_ref:
4438 /* Handle complex lvalues (when permitted)
4439 by reduction to simpler cases. */
4445 {
4456 /* Fall through. */
4463 /* Turn a reference to a non-static data member into a
4464 pointer-to-member. */
4465 {
4466 tree type;
4467 tree t;
4474 {
4477 }
4483 }
4487 }
4489 /* Anything not already handled and not a true memory reference
4490 is an error. */
4500 /* In a template, we are processing a non-dependent expression
4501 so we can just form an ADDR_EXPR with the correct type. */
4503 {
4508 }
4511 {
4515 }
4517 {
4520 /* We can only get here with a single static member
4521 function. */
4527 /* Do not lose object's side effects. */
4530 }
4532 {
4536 }
4537 else
4538 {
4544 }
4548 {
4552 }
4558 }
4561 {
4565 }
4569 }
4571 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4572 for certain kinds of expressions which are not really lvalues
4573 but which we can accept as lvalues.
4575 If ARG is not a kind of expression we can handle, return
4576 NULL_TREE. */
4578 tree
4580 {
4581 /* Inside a template, making these kinds of adjustments is
4582 pointless; we are only concerned with the type of the
4583 expression. */
4587 /* Handle (a, b) used as an "lvalue". */
4589 {
4593 }
4595 /* Handle (a ? b : c) used as an "lvalue". */
4600 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4604 {
4607 {
4611 }
4612 return unary_complex_lvalue
4614 }
4619 /* Handle (a = b) used as an "lvalue" for `&'. */
4622 {
4628 }
4635 /* We permit compiler to make function calls returning
4636 objects of aggregate type look like lvalues. */
4637 {
4644 {
4647 else
4650 }
4655 }
4657 /* Don't let anything else be handled specially. */
4659 }
4660 \f
4661 /* Mark EXP saying that we need to be able to take the
4662 address of it; it should not be allocated in a register.
4663 Value is true if successful.
4665 C++: we do not allow `current_class_ptr' to be addressable. */
4667 bool
4669 {
4674 {
4685 {
4689 }
4690 /* Fall through. */
4693 /* Caller should not be trying to mark initialized
4694 constant fields addressable. */
4699 /* Fall through. */
4705 {
4707 {
4708 error
4711 }
4713 warning
4715 }
4734 }
4735 }
4736 \f
4737 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4739 tree
4741 {
4745 tree expr;
4748 {
4749 /* The standard says that the expression is type-dependent if
4750 IFEXP is type-dependent, even though the eventual type of the
4751 expression doesn't dependent on IFEXP. */
4753 /* As a GNU extension, the middle operand may be omitted. */
4761 }
4768 }
4769 \f
4770 /* Given a list of expressions, return a compound expression
4771 that performs them all and returns the value of the last of them. */
4774 {
4778 {
4784 }
4787 }
4789 /* Handle overloading of the ',' operator when needed. */
4791 tree
4793 {
4794 tree result;
4799 {
4805 }
4816 }
4818 /* Build a compound expression. */
4820 tree
4822 {
4829 {
4830 /* If the rhs is a TARGET_EXPR, then build the compound
4831 expression inside the target_expr's initializer. This
4832 helps the compiler to eliminate unnecessary temporaries. */
4839 }
4842 }
4844 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4845 casts away constness. DIAG_FN gives the function to call if we
4846 need to issue a diagnostic; if it is NULL, no diagnostic will be
4847 issued. DESCRIPTION explains what operation is taking place. */
4849 static void
4853 {
4857 }
4859 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4860 (another pointer-to-member type in the same hierarchy) and return
4861 the converted expression. If ALLOW_INVERSE_P is permitted, a
4862 pointer-to-derived may be converted to pointer-to-base; otherwise,
4863 only the other direction is permitted. If C_CAST_P is true, this
4864 conversion is taking place as part of a C-style cast. */
4866 tree
4869 {
4871 {
4872 tree delta;
4878 allow_inverse_p,
4879 c_cast_p);
4881 {
4885 expr,
4892 }
4895 }
4896 else
4899 }
4901 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
4902 a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
4903 Otherwise, return EXPR unchanged. */
4905 static tree
4907 {
4912 {
4914 /* Ensure constant sharing. */
4918 else
4919 {
4920 /* Avoid clobbering a shared constant. */
4923 }
4924 }
4926 }
4928 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
4929 this static_cast is being attempted as one of the possible casts
4930 allowed by a C-style cast. (In that case, accessibility of base
4931 classes is not considered, and it is OK to cast away
4932 constness.) Return the result of the cast. *VALID_P is set to
4933 indicate whether or not the cast was valid. */
4935 static tree
4938 {
4939 tree intype;
4940 tree result;
4941 tree orig;
4945 /* Assume the cast is valid. */
4950 /* Save casted types in the function's used types hash table. */
4953 /* Determine what to do when casting away constness. */
4955 {
4956 /* C-style casts are allowed to cast away constness. With
4957 WARN_CAST_QUAL, we still want to issue a warning. */
4960 }
4961 else
4962 {
4963 /* A static_cast may not cast away constness. */
4966 }
4968 /* [expr.static.cast]
4970 An lvalue of type "cv1 B", where B is a class type, can be cast
4971 to type "reference to cv2 D", where D is a class derived (clause
4972 _class.derived_) from B, if a valid standard conversion from
4973 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4974 same cv-qualification as, or greater cv-qualification than, cv1,
4975 and B is not a virtual base class of D. */
4976 /* We check this case before checking the validity of "TYPE t =
4977 EXPR;" below because for this case:
4979 struct B {};
4980 struct D : public B { D(const B&); };
4981 extern B& b;
4982 void f() { static_cast<const D&>(b); }
4984 we want to avoid constructing a new D. The standard is not
4985 completely clear about this issue, but our interpretation is
4986 consistent with other compilers. */
4995 && (c_cast_p
4997 {
4998 tree base;
5000 /* There is a standard conversion from "D*" to "B*" even if "B"
5001 is ambiguous or inaccessible. If this is really a
5002 static_cast, then we check both for inaccessibility and
5003 ambiguity. However, if this is a static_cast being performed
5004 because the user wrote a C-style cast, then accessibility is
5005 not considered. */
5008 NULL);
5010 /* Convert from "B*" to "D*". This function will check that "B"
5011 is not a virtual base of "D". */
5014 /* Convert the pointer to a reference -- but then remember that
5015 there are no expressions with reference type in C++. */
5017 }
5021 /* [expr.static.cast]
5023 An expression e can be explicitly converted to a type T using a
5024 static_cast of the form static_cast<T>(e) if the declaration T
5025 t(e);" is well-formed, for some invented temporary variable
5026 t. */
5028 c_cast_p);
5030 {
5033 /* Ignore any integer overflow caused by the cast. */
5036 /* [expr.static.cast]
5038 If T is a reference type, the result is an lvalue; otherwise,
5039 the result is an rvalue. */
5043 }
5045 /* [expr.static.cast]
5047 Any expression can be explicitly converted to type cv void. */
5051 /* [expr.static.cast]
5053 The inverse of any standard conversion sequence (clause _conv_),
5054 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5055 (_conv.array_), function-to-pointer (_conv.func_), and boolean
5056 (_conv.bool_) conversions, can be performed explicitly using
5057 static_cast subject to the restriction that the explicit
5058 conversion does not cast away constness (_expr.const.cast_), and
5059 the following additional rules for specific cases: */
5060 /* For reference, the conversions not excluded are: integral
5061 promotions, floating point promotion, integral conversions,
5062 floating point conversions, floating-integral conversions,
5063 pointer conversions, and pointer to member conversions. */
5064 /* DR 128
5066 A value of integral _or enumeration_ type can be explicitly
5067 converted to an enumeration type. */
5068 /* The effect of all that is that any conversion between any two
5069 types which are integral, floating, or enumeration types can be
5070 performed. */
5073 {
5076 /* Ignore any integer overflow caused by the cast. */
5079 }
5088 {
5089 tree base;
5095 NULL);
5097 }
5101 {
5102 tree c1;
5103 tree c2;
5104 tree t1;
5105 tree t2;
5111 {
5112 t1 = (build_ptrmem_type
5115 t2 = (build_ptrmem_type
5118 }
5119 else
5120 {
5123 }
5125 {
5128 desc);
5130 c_cast_p);
5131 }
5132 }
5134 /* [expr.static.cast]
5136 An rvalue of type "pointer to cv void" can be explicitly
5137 converted to a pointer to object type. A value of type pointer
5138 to object converted to "pointer to cv void" and back to the
5139 original pointer type will have its original value. */
5143 {
5147 }
5151 }
5153 /* Return an expression representing static_cast<TYPE>(EXPR). */
5155 tree
5157 {
5158 tree result;
5165 {
5167 /* We don't know if it will or will not have side effects. */
5170 }
5172 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5173 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5186 }
5188 /* EXPR is an expression with member function or pointer-to-member
5189 function type. TYPE is a pointer type. Converting EXPR to TYPE is
5190 not permitted by ISO C++, but we accept it in some modes. If we
5191 are not in one of those modes, issue a diagnostic. Return the
5192 converted expression. */
5194 tree
5196 {
5197 tree intype;
5198 tree decl;
5211 else
5212 {
5216 }
5219 }
5221 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5222 If C_CAST_P is true, this reinterpret cast is being done as part of
5223 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
5224 indicate whether or not reinterpret_cast was valid. */
5226 static tree
5229 {
5230 tree intype;
5232 /* Assume the cast is invalid. */
5241 /* Save casted types in the function's used types hash table. */
5244 /* [expr.reinterpret.cast]
5245 An lvalue expression of type T1 can be cast to the type
5246 "reference to T2" if an expression of type "pointer to T1" can be
5247 explicitly converted to the type "pointer to T2" using a
5248 reinterpret_cast. */
5250 {
5252 {
5257 }
5259 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5260 "B" are related class types; the reinterpret_cast does not
5261 adjust the pointer. */
5270 expr = build_reinterpret_cast_1
5272 valid_p);
5276 }
5278 /* As a G++ extension, we consider conversions from member
5279 functions, and pointers to member functions to
5280 pointer-to-function and pointer-to-void types. If
5281 -Wno-pmf-conversions has not been specified,
5282 convert_member_func_to_ptr will issue an error message. */
5290 /* If the cast is not to a reference type, the lvalue-to-rvalue,
5291 array-to-pointer, and function-to-pointer conversions are
5292 performed. */
5295 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5296 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5306 /* [expr.reinterpret.cast]
5307 A pointer can be converted to any integral type large enough to
5308 hold it. */
5310 {
5314 }
5315 /* [expr.reinterpret.cast]
5316 A value of integral or enumeration type can be explicitly
5317 converted to a pointer. */
5319 /* OK */
5320 ;
5326 {
5332 /* Warn about possible alignment problems. */
5343 /* We need to strip nops here, because the front end likes to
5344 create (int *)&a for array-to-pointer decay, instead of &a[0]. */
5350 }
5353 {
5355 /* Only issue a warning, as we have always supported this
5356 where possible, and it is necessary in some cases. DR 195
5357 addresses this issue, but as of 2004/10/26 is still in
5358 drafting. */
5361 }
5366 else
5367 {
5372 }
5375 }
5377 tree
5379 {
5384 {
5389 /* There might turn out to be side effects inside expr. */
5392 }
5396 }
5398 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
5399 return an appropriate expression. Otherwise, return
5400 error_mark_node. If the cast is not valid, and COMPLAIN is true,
5401 then a diagnostic will be issued. If VALID_P is non-NULL, we are
5402 performing a C-style cast, its value upon return will indicate
5403 whether or not the conversion succeeded. */
5405 static tree
5408 {
5409 tree src_type;
5410 tree reference_type;
5412 /* Callers are responsible for handling error_mark_node as a
5413 destination type. */
5415 /* In a template, callers should be building syntactic
5416 representations of casts, not using this machinery. */
5419 /* Assume the conversion is invalid. */
5424 {
5427 "which is not a pointer, "
5430 }
5433 {
5438 }
5440 /* Save casted types in the function's used types hash table. */
5444 /* Expressions do not really have reference types. */
5448 /* [expr.const.cast]
5450 An lvalue of type T1 can be explicitly converted to an lvalue of
5451 type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5452 types) if a pointer to T1 can be explicitly converted to the type
5453 pointer to T2 using a const_cast. */
5455 {
5458 {
5463 }
5466 }
5467 else
5468 {
5470 /* If the destination type is not a reference type, the
5471 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5472 conversions are performed. */
5476 }
5480 {
5482 {
5484 /* This cast is actually a C-style cast. Issue a warning if
5485 the user is making a potentially unsafe cast. */
5488 warning0,
5490 }
5492 {
5496 }
5497 else
5498 {
5500 /* build_c_cast puts on a NOP_EXPR to make the result not an
5501 lvalue. Strip such NOP_EXPRs if VALUE is being used in
5502 non-lvalue context. */
5507 }
5508 }
5514 }
5516 tree
5518 {
5523 {
5528 /* There might turn out to be side effects inside expr. */
5531 }
5535 }
5537 /* Build an expression representing an explicit C-style cast to type
5538 TYPE of expression EXPR. */
5540 tree
5542 {
5544 tree result;
5551 {
5554 /* We don't know if it will or will not have side effects. */
5557 }
5559 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5560 'Class') should always be retained, because this information aids
5561 in method lookup. */
5566 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5567 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5574 {
5575 /* Allow casting from T1* to T2[] because Cfront allows it.
5576 NIHCL uses it. It is not valid ISO C++ however. */
5578 {
5581 }
5582 else
5583 {
5586 }
5587 }
5591 {
5594 }
5596 /* A C-style cast can be a const_cast. */
5602 /* Or a static cast. */
5605 /* Or a reinterpret_cast. */
5609 /* The static_cast or reinterpret_cast may be followed by a
5610 const_cast. */
5612 /* A valid cast may result in errors if, for example, a
5613 conversion to am ambiguous base class is required. */
5615 {
5616 tree result_type;
5618 /* Non-class rvalues always have cv-unqualified type. */
5624 /* If the type of RESULT does not match TYPE, perform a
5625 const_cast to make it match. If the static_cast or
5626 reinterpret_cast succeeded, we will differ by at most
5627 cv-qualification, so the follow-on const_cast is guaranteed
5628 to succeed. */
5630 {
5633 }
5635 }
5638 }
5639 \f
5640 /* Build an assignment expression of lvalue LHS from value RHS.
5641 MODIFYCODE is the code for a binary operator that we use
5642 to combine the old value of LHS with RHS to get the new value.
5643 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5645 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5647 tree
5649 {
5650 tree result;
5657 /* Avoid duplicate error messages from operands that had errors. */
5661 /* Handle control structure constructs used as "lvalues". */
5663 {
5664 /* Handle --foo = 5; as these are valid constructs in C++. */
5672 lhs,
5676 /* Handle (a, b) used as an "lvalue". */
5697 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5698 when neither operand has side-effects. */
5707 boolean_type_node,
5712 /* Fall through. */
5714 /* Handle (a ? b : c) used as an "lvalue". */
5716 {
5717 /* Produce (a ? (b = rhs) : (c = rhs))
5718 except that the RHS goes through a save-expr
5719 so the code to compute it is only emitted once. */
5720 tree cond;
5724 {
5727 }
5731 /* Check this here to avoid odd errors when trying to convert
5732 a throw to the type of the COND_EXPR. */
5736 cond = build_conditional_expr
5745 /* Make sure the code to compute the rhs comes out
5746 before the split. */
5750 }
5754 }
5757 {
5759 {
5761 /* Call convert to generate an error; see PR 11063. */
5766 }
5769 else
5770 {
5777 }
5778 }
5779 else
5780 {
5786 {
5787 /* `operator=' is not an inheritable operator. */
5790 else
5791 {
5798 }
5800 }
5801 else
5802 {
5803 /* A binary op has been requested. Combine the old LHS
5804 value with the RHS producing the value we should actually
5805 store into the LHS. */
5811 {
5815 }
5817 /* Now it looks like a plain assignment. */
5819 }
5822 }
5824 /* The left-hand side must be an lvalue. */
5828 /* Warn about modifying something that is `const'. Don't warn if
5829 this is initialization. */
5832 /* Functions are not modifiable, even though they are
5833 lvalues. */
5836 /* If it's an aggregate and any field is const, then it is
5837 effectively const. */
5842 /* If storing into a structure or union member, it has probably been
5843 given type `int'. Compute the type that would go with the actual
5844 amount of storage the member occupies. */
5850 {
5853 /* If storing in a field that is in actuality a short or narrower
5854 than one, we must store in the field in its actual type. */
5857 {
5858 /* Avoid warnings converting integral types back into enums for
5859 enum bit fields. */
5862 {
5866 }
5869 }
5870 }
5872 /* Convert new value to destination type. */
5875 {
5880 {
5884 }
5886 /* Allow array assignment in compiler-generated code. */
5888 {
5889 /* This routine is used for both initialization and assignment.
5890 Make sure the diagnostic message differentiates the context. */
5893 else
5896 }
5902 from_array);
5903 }
5908 else
5909 {
5910 /* Avoid warnings on enum bit fields. */
5913 {
5917 }
5918 else
5925 /* Can't initialize directly from a TARGET_EXPR, since that would
5926 cause the lhs to be constructed twice, and possibly result in
5927 accidental self-initialization. So we force the TARGET_EXPR to be
5928 expanded without a target. */
5932 }
5938 {
5943 }
5952 /* If we got the LHS in a different type for storing in,
5953 convert the result back to the nominal type of LHS
5954 so that the value we return always has the same type
5955 as the LHS argument. */
5960 {
5964 }
5967 }
5969 tree
5971 {
5977 {
5982 {
5985 }
5986 }
5988 }
5990 /* Helper function for get_delta_difference which assumes FROM is a base
5991 class of TO. Returns a delta for the conversion of pointer-to-member
5992 of FROM to pointer-to-member of TO. If the conversion is invalid,
5993 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
5994 If C_CAST_P is true, this conversion is taking place as part of a C-style
5995 cast. */
5997 static tree
5999 {
6000 tree binfo;
6001 base_kind kind;
6005 {
6008 }
6010 {
6013 else
6014 /* FROM is a virtual base class of TO. Issue an error or warning
6015 depending on whether or not this is a reinterpret cast. */
6016 {
6021 }
6022 }
6023 else
6025 }
6027 /* Get difference in deltas for different pointer to member function
6028 types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If
6029 the conversion is invalid, the constant is zero. If
6030 ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6031 If C_CAST_P is true this conversion is taking place as part of a
6032 C-style cast.
6034 Note that the naming of FROM and TO is kind of backwards; the return
6035 value is what we add to a TO in order to get a FROM. They are named
6036 this way because we call this function to find out how to convert from
6037 a pointer to member of FROM to a pointer to member of TO. */
6039 static tree
6043 {
6044 tree result;
6047 /* Pointer to member of incomplete class is permitted*/
6049 else
6053 {
6055 {
6059 }
6060 else
6061 {
6066 else
6067 {
6071 }
6072 }
6073 }
6076 result));
6077 }
6079 /* Return a constructor for the pointer-to-member-function TYPE using
6080 the other components as specified. */
6082 tree
6084 {
6086 tree delta_field;
6087 tree pfn_field;
6090 /* Pull the FIELD_DECLs out of the type. */
6094 /* Make sure DELTA has the type we want. */
6097 /* Convert to the correct target type if necessary. */
6100 /* Finish creating the initializer. */
6113 }
6115 /* Build a constructor for a pointer to member function. It can be
6116 used to initialize global variables, local variable, or used
6117 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6118 want to be.
6120 If FORCE is nonzero, then force this conversion, even if
6121 we would rather not do it. Usually set when using an explicit
6122 cast. A C-style cast is being processed iff C_CAST_P is true.
6124 Return error_mark_node, if something goes wrong. */
6126 tree
6128 {
6129 tree fn;
6130 tree pfn_type;
6131 tree to_type;
6139 /* Handle multiple conversions of pointer to member functions. */
6141 {
6144 tree n;
6153 force,
6154 c_cast_p);
6156 /* We don't have to do any conversion to convert a
6157 pointer-to-member to its own type. But, we don't want to
6158 just return a PTRMEM_CST if there's an explicit cast; that
6159 cast should make the expression an invalid template argument. */
6161 {
6166 }
6171 /* Obtain the function pointer and the current DELTA. */
6174 else
6175 {
6178 }
6180 /* Just adjust the DELTA field. */
6187 }
6189 /* Handle null pointer to member function conversions. */
6191 {
6194 integer_zero_node,
6195 pfn);
6196 }
6203 /* In a template, we will have preserved the
6204 OFFSET_REF. */
6207 }
6209 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6210 given by CST.
6212 ??? There is no consistency as to the types returned for the above
6213 values. Some code acts as if it were a sizetype and some as if it were
6214 integer_type_node. */
6216 void
6218 {
6225 /* The class that the function belongs to. */
6228 /* The class that we're creating a pointer to member of. */
6231 /* First, calculate the adjustment to the function's class. */
6237 else
6238 {
6239 /* If we're dealing with a virtual function, we have to adjust 'this'
6240 again, to point to the base which provides the vtable entry for
6241 fn; the call will do the opposite adjustment. */
6248 /* We set PFN to the vtable offset at which the function can be
6249 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6250 case delta is shifted left, and then incremented). */
6257 {
6260 integer_one_node);
6275 }
6279 }
6280 }
6282 /* Return an expression for PFN from the pointer-to-member function
6283 given by T. */
6285 static tree
6287 {
6289 {
6290 tree delta;
6291 tree pfn;
6296 }
6299 }
6301 /* Return an expression for DELTA from the pointer-to-member function
6302 given by T. */
6304 static tree
6306 {
6308 {
6309 tree delta;
6310 tree pfn;
6315 }
6318 }
6320 /* Convert value RHS to type TYPE as preparation for an assignment to
6321 an lvalue of type TYPE. ERRTYPE is a string to use in error
6322 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6323 are doing the conversion in order to pass the PARMNUMth argument of
6324 FNDECL. */
6326 static tree
6329 {
6330 tree rhstype;
6333 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6349 /* The RHS of an assignment cannot have void type. */
6351 {
6354 }
6356 /* Simplify the RHS if possible. */
6361 {
6369 else
6370 {
6376 {
6379 }
6380 }
6384 }
6386 /* [expr.ass]
6388 The expression is implicitly converted (clause _conv_) to the
6389 cv-unqualified type of the left operand.
6391 We allow bad conversions here because by the time we get to this point
6392 we are committed to doing the conversion. If we end up doing a bad
6393 conversion, convert_like will complain. */
6395 {
6396 /* When -Wno-pmf-conversions is use, we just silently allow
6397 conversions from pointers-to-members to plain pointers. If
6398 the conversion doesn't work, cp_convert will complain. */
6403 else
6404 {
6405 /* If the right-hand side has unknown type, then it is an
6406 overloaded function. Call instantiate_type to get error
6407 messages. */
6413 else
6416 }
6417 }
6419 {
6426 errtype);
6427 }
6429 /* If -Wparentheses, warn about a = b = c when a has type bool and b
6430 does not. */
6436 {
6440 }
6443 }
6445 /* Convert RHS to be of type TYPE.
6446 If EXP is nonzero, it is the target of the initialization.
6447 ERRTYPE is a string to use in error messages.
6449 Two major differences between the behavior of
6450 `convert_for_assignment' and `convert_for_initialization'
6451 are that references are bashed in the former, while
6452 copied in the latter, and aggregates are assigned in
6453 the former (operator=) while initialized in the
6454 latter (X(X&)).
6456 If using constructor make sure no conversion operator exists, if one does
6457 exist, an ambiguity exists.
6459 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6461 tree
6464 {
6466 tree rhstype;
6469 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6470 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6497 /* We accept references to incomplete types, so we can
6498 return here before checking if RHS is of complete type. */
6501 {
6502 /* This should eventually happen in convert_arguments. */
6510 {
6515 }
6517 }
6532 }
6533 \f
6534 /* If RETVAL is the address of, or a reference to, a local variable or
6535 temporary give an appropriate warning. */
6537 static void
6539 {
6544 {
6551 else
6553 }
6560 {
6563 {
6566 }
6570 {
6573 }
6574 }
6585 {
6588 whats_returned);
6589 else
6591 whats_returned);
6593 }
6594 }
6596 /* Check that returning RETVAL from the current function is valid.
6597 Return an expression explicitly showing all conversions required to
6598 change RETVAL into the function return type, and to assign it to
6599 the DECL_RESULT for the function. Set *NO_WARNING to true if
6600 code reaches end of non-void function warning shouldn't be issued
6601 on this RETURN_EXPR. */
6603 tree
6605 {
6606 tree result;
6607 /* The type actually returned by the function, after any
6608 promotions. */
6609 tree valtype;
6615 /* A `volatile' function is one that isn't supposed to return, ever.
6616 (This is a G++ extension, used to get better code for functions
6617 that call the `volatile' function.) */
6621 /* Check for various simple errors. */
6623 {
6627 }
6629 {
6631 /* If a return statement appears in a handler of the
6632 function-try-block of a constructor, the program is ill-formed. */
6635 /* You can't return a value from a constructor. */
6638 }
6641 {
6646 }
6648 /* When no explicit return-value is given in a function with a named
6649 return value, the named return value is used. */
6657 /* Check for a return statement with no return value in a function
6658 that's supposed to return a value. */
6660 {
6662 valtype);
6663 /* Clear this, so finish_function won't say that we reach the
6664 end of a non-void function (which we don't, we gave a
6665 return!). */
6667 /* And signal caller that TREE_NO_WARNING should be set on the
6668 RETURN_EXPR to avoid control reaches end of non-void function
6669 warnings in tree-cfg.c. */
6671 }
6672 /* Check for a return statement with a value in a function that
6673 isn't supposed to return a value. */
6675 {
6677 /* You can return a `void' value from a function of `void'
6678 type. In that case, we have to evaluate the expression for
6679 its side-effects. */
6681 else
6687 /* There's really no value to return, after all. */
6689 }
6691 /* Remember that this function can sometimes return without a
6692 value. */
6694 else
6695 /* Remember that this function did return a value. */
6698 /* Check for erroneous operands -- but after giving ourselves a
6699 chance to provide an error about returning a value from a void
6700 function. */
6702 {
6705 }
6707 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6711 && ! flag_check_new
6716 /* Effective C++ rule 15. See also start_function. */
6719 {
6722 /* The function return type must be a reference to the current
6723 class. */
6725 && same_type_ignoring_top_level_qualifiers_p
6727 {
6728 /* Returning '*this' is obviously OK. */
6731 /* If we are calling a function whose return type is the same of
6732 the current class reference, it is ok. */
6736 }
6740 }
6742 /* The fabled Named Return Value optimization, as per [class.copy]/15:
6744 [...] For a function with a class return type, if the expression
6745 in the return statement is the name of a local object, and the cv-
6746 unqualified type of the local object is the same as the function
6747 return type, an implementation is permitted to omit creating the tem-
6748 porary object to hold the function return value [...]
6750 So, if this is a value-returning function that always returns the same
6751 local variable, remember it.
6753 It might be nice to be more flexible, and choose the first suitable
6754 variable even if the function sometimes returns something else, but
6755 then we run the risk of clobbering the variable we chose if the other
6756 returned expression uses the chosen variable somehow. And people expect
6757 this restriction, anyway. (jason 2000-11-19)
6759 See finish_function and finalize_nrv for the rest of this optimization. */
6761 named_return_value_okay_p =
6763 /* Must be a local, automatic variable. */
6770 /* The cv-unqualified type of the returned value must be the
6771 same as the cv-unqualified return type of the
6772 function. */
6774 (TYPE_MAIN_VARIANT
6776 /* And the returned value must be non-volatile. */
6780 {
6785 else
6787 }
6789 /* We don't need to do any conversions when there's nothing being
6790 returned. */
6794 /* Do any required conversions. */
6796 /* No conversions are required. */
6797 ;
6798 else
6799 {
6800 /* The type the function is declared to return. */
6804 /* The functype's return type will have been set to void, if it
6805 was an incomplete type. Just treat this as 'return;' */
6809 /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
6810 treated as an rvalue for the purposes of overload resolution to
6811 favor move constructors over copy constructors. */
6813 && named_return_value_okay_p
6814 /* The variable must not have the `volatile' qualifier. */
6816 /* The return type must be a class type. */
6820 /* First convert the value to the function's return type, then
6821 to the type of return value's location to handle the
6822 case that functype is smaller than the valtype. */
6823 retval = convert_for_initialization
6827 /* If the conversion failed, treat this just like `return;'. */
6830 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6836 else
6838 }
6840 /* Actually copy the value returned into the appropriate location. */
6845 }
6847 \f
6848 /* Returns nonzero if the pointer-type FROM can be converted to the
6849 pointer-type TO via a qualification conversion. If CONSTP is -1,
6850 then we return nonzero if the pointers are similar, and the
6851 cv-qualification signature of FROM is a proper subset of that of TO.
6853 If CONSTP is positive, then all outer pointers have been
6854 const-qualified. */
6856 static int
6858 {
6862 {
6871 /* Const and volatile mean something different for function types,
6872 so the usual checks are not appropriate. */
6874 {
6875 /* In Objective-C++, some types may have been 'volatilized' by
6876 the compiler for EH; when comparing them here, the volatile
6877 qualification must be ignored. */
6884 {
6888 }
6892 }
6897 }
6898 }
6900 /* When comparing, say, char ** to char const **, this function takes
6901 the 'char *' and 'char const *'. Do not pass non-pointer/reference
6902 types to this function. */
6904 int
6906 {
6908 }
6910 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6911 type or inheritance-related types, regardless of cv-quals. */
6913 int
6915 {
6917 {
6918 /* Any target type is similar enough to void. */
6944 return cp_comptypes
6947 }
6948 }
6950 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
6951 pointer-to-member types) are the same, ignoring cv-qualification at
6952 all levels. */
6954 bool
6956 {
6958 {
6969 }
6970 }
6972 /* Returns the type qualifiers for this type, including the qualifiers on the
6973 elements for an array type. */
6975 int
6977 {
6978 /* This CONST_CAST is okay because strip_array_types returns it's
6979 argument unmodified and we assign it to a const_tree. */
6984 }
6986 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
6987 arrays. */
6989 bool
6991 {
6992 /* This CONST_CAST is okay because strip_array_types returns it's
6993 argument unmodified and we assign it to a const_tree. */
6996 }
6998 /* Returns nonzero if the TYPE contains a mutable member. */
7000 bool
7002 {
7003 /* This CONST_CAST is okay because strip_array_types returns it's
7004 argument unmodified and we assign it to a const_tree. */
7008 }
7010 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7011 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
7012 approximation. In particular, consider:
7014 int f();
7015 struct S { int i; };
7016 const S s = { f(); }
7018 Here, we will make "s" as TREE_READONLY (because it is declared
7019 "const") -- only to reverse ourselves upon seeing that the
7020 initializer is non-constant. */
7022 void
7024 {
7032 {
7033 /* This was an error in C++98 (cv-qualifiers cannot be added to
7034 a function type), but DR 295 makes the code well-formed by
7035 dropping the extra qualifiers. */
7037 {
7041 }
7045 }
7047 /* Avoid setting TREE_READONLY incorrectly. */
7049 the object. */
7051 /* If the type isn't complete, we don't know yet if it will need
7052 constructing. */
7054 /* If the type has a mutable component, that component might be
7055 modified. */
7060 }
7062 /* Subroutine of casts_away_constness. Make T1 and T2 point at
7063 exemplar types such that casting T1 to T2 is casting away constness
7064 if and only if there is no implicit conversion from T1 to T2. */
7066 static void
7068 {
7072 /* [expr.const.cast]
7074 For multi-level pointer to members and multi-level mixed pointers
7075 and pointers to members (conv.qual), the "member" aspect of a
7076 pointer to member level is ignored when determining if a const
7077 cv-qualifier has been cast away. */
7078 /* [expr.const.cast]
7080 For two pointer types:
7082 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
7083 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
7084 K is min(N,M)
7086 casting from X1 to X2 casts away constness if, for a non-pointer
7087 type T there does not exist an implicit conversion (clause
7088 _conv_) from:
7090 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7092 to
7094 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
7097 {
7103 }
7110 else
7114 else
7122 }
7124 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7125 constness. */
7127 static bool
7129 {
7131 {
7132 /* [expr.const.cast]
7134 Casting from an lvalue of type T1 to an lvalue of type T2
7135 using a reference cast casts away constness if a cast from an
7136 rvalue of type "pointer to T1" to the type "pointer to T2"
7137 casts away constness. */
7141 }
7144 /* [expr.const.cast]
7146 Casting from an rvalue of type "pointer to data member of X
7147 of type T1" to the type "pointer to data member of Y of type
7148 T2" casts away constness if a cast from an rvalue of type
7149 "pointer to T1" to the type "pointer to T2" casts away
7150 constness. */
7151 return casts_away_constness
7155 /* Casting away constness is only something that makes sense for
7156 pointer or reference types. */
7161 /* Top-level qualifiers don't matter. */
7169 }
7171 /* If T is a REFERENCE_TYPE return the type to which T refers.
7172 Otherwise, return T itself. */
7174 tree
7176 {
7180 }
7183 /* Return nonzero if REF is an lvalue valid for this language;
7184 otherwise, print an error message and return zero. USE says
7185 how the lvalue is being used and so selects the error message. */
7187 int
7189 {
7196 }