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 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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.
29 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
30 and to process initializations in declarations (since they work
31 like a strange sort of assignment). */
35 #include "coretypes.h"
45 #include "diagnostic.h"
48 static tree convert_for_assignment (tree, tree, const char *, tree, int);
49 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
50 static tree rationalize_conditional_expr (enum tree_code, tree);
51 static int comp_target_parms (tree, tree);
52 static int comp_ptr_ttypes_real (tree, tree, int);
53 static int comp_ptr_ttypes_const (tree, tree);
54 static int comp_ptr_ttypes_reinterpret (tree, tree);
55 static bool comp_except_types (tree, tree, bool);
56 static bool comp_array_types (tree, tree, bool);
57 static tree common_base_type (tree, tree);
58 static tree lookup_anon_field (tree, tree);
59 static tree pointer_diff (tree, tree, tree);
60 static tree qualify_type_recursive (tree, tree);
61 static tree get_delta_difference (tree, tree, int);
62 static int comp_cv_target_types (tree, tree, int);
63 static void casts_away_constness_r (tree *, tree *);
64 static bool casts_away_constness (tree, tree);
65 static void maybe_warn_about_returning_address_of_local (tree);
66 static tree strip_all_pointer_quals (tree);
67 static tree lookup_destructor (tree, tree, tree);
69 /* Return the target type of TYPE, which means return T for:
70 T*, T&, T[], T (...), and otherwise, just T. */
73 target_type (tree type)
75 type = non_reference (type);
76 while (TREE_CODE (type) == POINTER_TYPE
77 || TREE_CODE (type) == ARRAY_TYPE
78 || TREE_CODE (type) == FUNCTION_TYPE
79 || TREE_CODE (type) == METHOD_TYPE
80 || TREE_CODE (type) == OFFSET_TYPE)
81 type = TREE_TYPE (type);
85 /* Do `exp = require_complete_type (exp);' to make sure exp
86 does not have an incomplete type. (That includes void types.)
87 Returns the error_mark_node if the VALUE does not have
88 complete type when this function returns. */
91 require_complete_type (tree value)
95 if (processing_template_decl || value == error_mark_node)
98 if (TREE_CODE (value) == OVERLOAD)
99 type = unknown_type_node;
101 type = TREE_TYPE (value);
103 /* First, detect a valid value with a complete type. */
104 if (COMPLETE_TYPE_P (type))
107 if (complete_type_or_else (type, value))
110 return error_mark_node;
113 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
114 a template instantiation, do the instantiation. Returns TYPE,
115 whether or not it could be completed, unless something goes
116 horribly wrong, in which case the error_mark_node is returned. */
119 complete_type (tree type)
121 if (type == NULL_TREE)
122 /* Rather than crash, we return something sure to cause an error
124 return error_mark_node;
126 if (type == error_mark_node || COMPLETE_TYPE_P (type))
128 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
130 tree t = complete_type (TREE_TYPE (type));
131 if (COMPLETE_TYPE_P (t) && ! processing_template_decl)
133 TYPE_NEEDS_CONSTRUCTING (type)
134 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
135 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
136 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
138 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
139 instantiate_class_template (TYPE_MAIN_VARIANT (type));
144 /* Like complete_type, but issue an error if the TYPE cannot be completed.
145 VALUE is used for informative diagnostics. DIAG_TYPE indicates the type
146 of diagnostic: 0 for an error, 1 for a warning, 2 for a pedwarn.
147 Returns NULL_TREE if the type cannot be made complete. */
150 complete_type_or_diagnostic (tree type, tree value, int diag_type)
152 type = complete_type (type);
153 if (type == error_mark_node)
154 /* We already issued an error. */
156 else if (!COMPLETE_TYPE_P (type))
158 cxx_incomplete_type_diagnostic (value, type, diag_type);
165 /* Return truthvalue of whether type of EXP is instantiated. */
168 type_unknown_p (tree exp)
170 return (TREE_CODE (exp) == OVERLOAD
171 || TREE_CODE (exp) == TREE_LIST
172 || TREE_TYPE (exp) == unknown_type_node
173 /* Until we get the type of non type-dependent expressions
174 correct, we can have non-type dependent expressions with
177 && TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
178 && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node));
181 /* Return a pointer or pointer to member type similar to T1, with a
182 cv-qualification signature that is the union of the cv-qualification
183 signatures of T1 and T2: [expr.rel], [expr.eq]. */
186 qualify_type_recursive (tree t1, tree t2)
188 if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
189 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)))
196 tree attributes = (*targetm.merge_type_attributes) (t1, t2);
198 if (TYPE_PTRMEM_P (t1))
200 b1 = TYPE_PTRMEM_CLASS_TYPE (t1);
201 tt1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
202 tt2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
207 tt1 = TREE_TYPE (t1);
208 tt2 = TREE_TYPE (t2);
211 type_quals = (cp_type_quals (tt1) | cp_type_quals (tt2));
212 tgt = qualify_type_recursive (tt1, tt2);
213 tgt = cp_build_qualified_type (tgt, type_quals);
215 t1 = build_ptrmem_type (b1, tgt);
217 t1 = build_pointer_type (tgt);
218 t1 = build_type_attribute_variant (t1, attributes);
223 /* Return the common type of two parameter lists.
224 We assume that comptypes has already been done and returned 1;
225 if that isn't so, this may crash.
227 As an optimization, free the space we allocate if the parameter
228 lists are already common. */
231 commonparms (tree p1, tree p2)
233 tree oldargs = p1, newargs, n;
237 len = list_length (p1);
238 newargs = tree_last (p1);
240 if (newargs == void_list_node)
249 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
254 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
256 if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
258 TREE_PURPOSE (n) = TREE_PURPOSE (p1);
261 else if (! TREE_PURPOSE (p1))
263 if (TREE_PURPOSE (p2))
265 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
271 if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
273 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
275 if (TREE_VALUE (p1) != TREE_VALUE (p2))
278 TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
281 TREE_VALUE (n) = TREE_VALUE (p1);
289 /* Given a type, perhaps copied for a typedef,
290 find the "original" version of it. */
292 original_type (tree t)
294 while (TYPE_NAME (t) != NULL_TREE)
296 tree x = TYPE_NAME (t);
297 if (TREE_CODE (x) != TYPE_DECL)
299 x = DECL_ORIGINAL_TYPE (x);
307 /* T1 and T2 are arithmetic or enumeration types. Return the type
308 that will result from the "usual arithmetic conversions" on T1 and
309 T2 as described in [expr]. */
312 type_after_usual_arithmetic_conversions (tree t1, tree t2)
314 enum tree_code code1 = TREE_CODE (t1);
315 enum tree_code code2 = TREE_CODE (t2);
318 /* FIXME: Attributes. */
319 my_friendly_assert (ARITHMETIC_TYPE_P (t1)
320 || TREE_CODE (t1) == COMPLEX_TYPE
321 || TREE_CODE (t1) == ENUMERAL_TYPE,
323 my_friendly_assert (ARITHMETIC_TYPE_P (t2)
324 || TREE_CODE (t2) == COMPLEX_TYPE
325 || TREE_CODE (t2) == ENUMERAL_TYPE,
328 /* In what follows, we slightly generalize the rules given in [expr] so
329 as to deal with `long long' and `complex'. First, merge the
331 attributes = (*targetm.merge_type_attributes) (t1, t2);
333 /* If one type is complex, form the common type of the non-complex
334 components, then make that complex. Use T1 or T2 if it is the
336 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
338 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
339 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
341 = type_after_usual_arithmetic_conversions (subtype1, subtype2);
343 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
344 return build_type_attribute_variant (t1, attributes);
345 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
346 return build_type_attribute_variant (t2, attributes);
348 return build_type_attribute_variant (build_complex_type (subtype),
352 /* If only one is real, use it as the result. */
353 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
354 return build_type_attribute_variant (t1, attributes);
355 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
356 return build_type_attribute_variant (t2, attributes);
358 /* Perform the integral promotions. */
359 if (code1 != REAL_TYPE)
361 t1 = type_promotes_to (t1);
362 t2 = type_promotes_to (t2);
365 /* Both real or both integers; use the one with greater precision. */
366 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
367 return build_type_attribute_variant (t1, attributes);
368 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
369 return build_type_attribute_variant (t2, attributes);
371 /* The types are the same; no need to do anything fancy. */
372 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
373 return build_type_attribute_variant (t1, attributes);
375 if (code1 != REAL_TYPE)
377 /* If one is a sizetype, use it so size_binop doesn't blow up. */
378 if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
379 return build_type_attribute_variant (t1, attributes);
380 if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
381 return build_type_attribute_variant (t2, attributes);
383 /* If one is unsigned long long, then convert the other to unsigned
385 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
386 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
387 return build_type_attribute_variant (long_long_unsigned_type_node,
389 /* If one is a long long, and the other is an unsigned long, and
390 long long can represent all the values of an unsigned long, then
391 convert to a long long. Otherwise, convert to an unsigned long
392 long. Otherwise, if either operand is long long, convert the
395 Since we're here, we know the TYPE_PRECISION is the same;
396 therefore converting to long long cannot represent all the values
397 of an unsigned long, so we choose unsigned long long in that
399 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
400 || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
402 tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
403 ? long_long_unsigned_type_node
404 : long_long_integer_type_node);
405 return build_type_attribute_variant (t, attributes);
408 /* Go through the same procedure, but for longs. */
409 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
410 || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
411 return build_type_attribute_variant (long_unsigned_type_node,
413 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
414 || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
416 tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
417 ? long_unsigned_type_node : long_integer_type_node);
418 return build_type_attribute_variant (t, attributes);
420 /* Otherwise prefer the unsigned one. */
421 if (TREE_UNSIGNED (t1))
422 return build_type_attribute_variant (t1, attributes);
424 return build_type_attribute_variant (t2, attributes);
428 if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
429 || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
430 return build_type_attribute_variant (long_double_type_node,
432 if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
433 || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
434 return build_type_attribute_variant (double_type_node,
436 if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
437 || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
438 return build_type_attribute_variant (float_type_node,
441 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
442 the standard C++ floating-point types. Logic earlier in this
443 function has already eliminated the possibility that
444 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
445 compelling reason to choose one or the other. */
446 return build_type_attribute_variant (t1, attributes);
450 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
451 ARG1 and ARG2 are the values with those types. The LOCATION is a
452 string describing the current location, in case an error occurs. */
455 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
456 const char* location)
463 If one operand is a null pointer constant, the composite pointer
464 type is the type of the other operand. */
465 if (null_ptr_cst_p (arg1))
467 if (null_ptr_cst_p (arg2))
470 /* Deal with pointer-to-member functions in the same way as we deal
471 with pointers to functions. */
472 if (TYPE_PTRMEMFUNC_P (t1))
473 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
474 if (TYPE_PTRMEMFUNC_P (t2))
475 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
477 /* Merge the attributes. */
478 attributes = (*targetm.merge_type_attributes) (t1, t2);
484 If one of the operands has type "pointer to cv1 void*", then
485 the other has type "pointer to cv2T", and the composite pointer
486 type is "pointer to cv12 void", where cv12 is the union of cv1
489 If either type is a pointer to void, make sure it is T1. */
490 if (VOID_TYPE_P (TREE_TYPE (t2)))
497 /* Now, if T1 is a pointer to void, merge the qualifiers. */
498 if (VOID_TYPE_P (TREE_TYPE (t1)))
500 if (pedantic && TYPE_PTRFN_P (t2))
501 pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location);
504 result_type = cp_build_qualified_type (void_type_node,
506 | cp_type_quals (t2)));
507 result_type = build_pointer_type (result_type);
511 tree full1 = qualify_type_recursive (t1, t2);
512 tree full2 = qualify_type_recursive (t2, t1);
514 int val = comp_target_types (full1, full2, 1);
522 pedwarn ("%s between distinct pointer types `%T' and `%T' lacks a cast",
524 result_type = ptr_type_node;
528 return build_type_attribute_variant (result_type, attributes);
531 /* Return the merged type of two types.
532 We assume that comptypes has already been done and returned 1;
533 if that isn't so, this may crash.
535 This just combines attributes and default arguments; any other
536 differences would cause the two types to compare unalike. */
539 merge_types (tree t1, tree t2)
541 register enum tree_code code1;
542 register enum tree_code code2;
545 /* Save time if the two types are the same. */
548 if (original_type (t1) == original_type (t2))
551 /* If one type is nonsense, use the other. */
552 if (t1 == error_mark_node)
554 if (t2 == error_mark_node)
557 /* Merge the attributes. */
558 attributes = (*targetm.merge_type_attributes) (t1, t2);
560 /* Treat an enum type as the unsigned integer type of the same width. */
562 if (TYPE_PTRMEMFUNC_P (t1))
563 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
564 if (TYPE_PTRMEMFUNC_P (t2))
565 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
567 code1 = TREE_CODE (t1);
568 code2 = TREE_CODE (t2);
574 /* For two pointers, do this recursively on the target type. */
576 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
577 int quals = cp_type_quals (t1);
579 if (code1 == POINTER_TYPE)
580 t1 = build_pointer_type (target);
582 t1 = build_reference_type (target);
583 t1 = build_type_attribute_variant (t1, attributes);
584 t1 = cp_build_qualified_type (t1, quals);
586 if (TREE_CODE (target) == METHOD_TYPE)
587 t1 = build_ptrmemfunc_type (t1);
594 tree base = TYPE_OFFSET_BASETYPE (t1);
595 tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
596 t1 = build_offset_type (base, target);
602 tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
603 /* Save space: see if the result is identical to one of the args. */
604 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
605 return build_type_attribute_variant (t1, attributes);
606 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
607 return build_type_attribute_variant (t2, attributes);
608 /* Merge the element types, and have a size if either arg has one. */
609 t1 = build_cplus_array_type
610 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
615 /* Function types: prefer the one that specified arg types.
616 If both do, merge the arg types. Also merge the return types. */
618 tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
619 tree p1 = TYPE_ARG_TYPES (t1);
620 tree p2 = TYPE_ARG_TYPES (t2);
623 /* Save space: see if the result is identical to one of the args. */
624 if (valtype == TREE_TYPE (t1) && ! p2)
625 return build_type_attribute_variant (t1, attributes);
626 if (valtype == TREE_TYPE (t2) && ! p1)
627 return build_type_attribute_variant (t2, attributes);
629 /* Simple way if one arg fails to specify argument types. */
630 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
632 rval = build_function_type (valtype, p2);
633 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
634 rval = build_exception_variant (rval, raises);
635 return build_type_attribute_variant (rval, attributes);
637 raises = TYPE_RAISES_EXCEPTIONS (t1);
638 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
640 rval = build_function_type (valtype, p1);
642 rval = build_exception_variant (rval, raises);
643 return build_type_attribute_variant (rval, attributes);
646 rval = build_function_type (valtype, commonparms (p1, p2));
647 t1 = build_exception_variant (rval, raises);
653 /* Get this value the long way, since TYPE_METHOD_BASETYPE
654 is just the main variant of this. */
655 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
656 tree raises = TYPE_RAISES_EXCEPTIONS (t1);
659 /* If this was a member function type, get back to the
660 original type of type member function (i.e., without
661 the class instance variable up front. */
662 t1 = build_function_type (TREE_TYPE (t1),
663 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
664 t2 = build_function_type (TREE_TYPE (t2),
665 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
666 t3 = merge_types (t1, t2);
667 t3 = build_cplus_method_type (basetype, TREE_TYPE (t3),
668 TYPE_ARG_TYPES (t3));
669 t1 = build_exception_variant (t3, raises);
675 return build_type_attribute_variant (t1, attributes);
678 /* Return the common type of two types.
679 We assume that comptypes has already been done and returned 1;
680 if that isn't so, this may crash.
682 This is the type for the result of most arithmetic operations
683 if the operands have the given two types. */
686 common_type (tree t1, tree t2)
688 enum tree_code code1;
689 enum tree_code code2;
691 /* If one type is nonsense, bail. */
692 if (t1 == error_mark_node || t2 == error_mark_node)
693 return error_mark_node;
695 code1 = TREE_CODE (t1);
696 code2 = TREE_CODE (t2);
698 if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
699 || code1 == COMPLEX_TYPE)
700 && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
701 || code2 == COMPLEX_TYPE))
702 return type_after_usual_arithmetic_conversions (t1, t2);
704 else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
705 || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
706 || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
707 return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
714 /* Compare two exception specifier types for exactness or subsetness, if
715 allowed. Returns false for mismatch, true for match (same, or
718 [except.spec] "If a class X ... objects of class X or any class publicly
719 and unambiguously derived from X. Similarly, if a pointer type Y * ...
720 exceptions of type Y * or that are pointers to any type publicly and
721 unambiguously derived from Y. Otherwise a function only allows exceptions
722 that have the same type ..."
723 This does not mention cv qualifiers and is different to what throw
724 [except.throw] and catch [except.catch] will do. They will ignore the
725 top level cv qualifiers, and allow qualifiers in the pointer to class
728 We implement the letter of the standard. */
731 comp_except_types (tree a, tree b, bool exact)
733 if (same_type_p (a, b))
737 if (cp_type_quals (a) || cp_type_quals (b))
740 if (TREE_CODE (a) == POINTER_TYPE
741 && TREE_CODE (b) == POINTER_TYPE)
745 if (cp_type_quals (a) || cp_type_quals (b))
749 if (TREE_CODE (a) != RECORD_TYPE
750 || TREE_CODE (b) != RECORD_TYPE)
753 if (ACCESSIBLY_UNIQUELY_DERIVED_P (a, b))
759 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
760 If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
761 otherwise it must be exact. Exception lists are unordered, but
762 we've already filtered out duplicates. Most lists will be in order,
763 we should try to make use of that. */
766 comp_except_specs (tree t1, tree t2, bool exact)
775 if (t1 == NULL_TREE) /* T1 is ... */
776 return t2 == NULL_TREE || !exact;
777 if (!TREE_VALUE (t1)) /* t1 is EMPTY */
778 return t2 != NULL_TREE && !TREE_VALUE (t2);
779 if (t2 == NULL_TREE) /* T2 is ... */
781 if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
784 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
785 Count how many we find, to determine exactness. For exact matching and
786 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
788 for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
790 for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
792 tree a = TREE_VALUE (probe);
793 tree b = TREE_VALUE (t2);
795 if (comp_except_types (a, b, exact))
797 if (probe == base && exact)
798 base = TREE_CHAIN (probe);
803 if (probe == NULL_TREE)
806 return !exact || base == NULL_TREE || length == list_length (t1);
809 /* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if
810 [] can match [size]. */
813 comp_array_types (tree t1, tree t2, bool allow_redeclaration)
821 /* The type of the array elements must be the same. */
822 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
825 d1 = TYPE_DOMAIN (t1);
826 d2 = TYPE_DOMAIN (t2);
831 /* If one of the arrays is dimensionless, and the other has a
832 dimension, they are of different types. However, it is valid to
840 declarations for an array object can specify
841 array types that differ by the presence or absence of a major
842 array bound (_dcl.array_). */
844 return allow_redeclaration;
846 /* Check that the dimensions are the same. */
847 return (cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
848 && cp_tree_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)));
851 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
852 is a bitwise-or of the COMPARE_* flags. */
855 comptypes (tree t1, tree t2, int strict)
860 /* This should never happen. */
861 my_friendly_assert (t1 != error_mark_node, 307);
863 /* Suppress errors caused by previously reported errors */
864 if (t2 == error_mark_node)
867 my_friendly_assert (TYPE_P (t1) && TYPE_P (t2), 20030623);
869 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
870 current instantiation. */
871 if (TREE_CODE (t1) == TYPENAME_TYPE)
873 tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
875 if (resolved != error_mark_node)
879 if (TREE_CODE (t2) == TYPENAME_TYPE)
881 tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
883 if (resolved != error_mark_node)
887 /* If either type is the internal version of sizetype, use the
889 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
891 t1 = TYPE_DOMAIN (t1);
893 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
895 t2 = TYPE_DOMAIN (t2);
897 if (TYPE_PTRMEMFUNC_P (t1))
898 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
899 if (TYPE_PTRMEMFUNC_P (t2))
900 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
902 /* Different classes of types can't be compatible. */
903 if (TREE_CODE (t1) != TREE_CODE (t2))
906 /* Qualifiers must match. */
907 if (cp_type_quals (t1) != cp_type_quals (t2))
909 if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
912 /* Allow for two different type nodes which have essentially the same
913 definition. Note that we already checked for equality of the type
914 qualifiers (just above). */
916 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
919 if (!(*targetm.comp_type_attributes) (t1, t2))
922 switch (TREE_CODE (t1))
924 case TEMPLATE_TEMPLATE_PARM:
925 case BOUND_TEMPLATE_TEMPLATE_PARM:
926 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
927 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
929 if (!comp_template_parms
930 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
931 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
933 if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
935 /* Don't check inheritance. */
936 strict = COMPARE_STRICT;
941 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
942 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
943 || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
944 && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
947 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
949 else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
955 if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
956 strict & ~COMPARE_REDECLARATION))
962 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
966 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
968 return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
971 /* Target types must match incl. qualifiers. */
972 return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION));
974 case TEMPLATE_TYPE_PARM:
975 return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
976 && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2));
979 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
980 TYPENAME_TYPE_FULLNAME (t2)))
982 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
984 case UNBOUND_CLASS_TEMPLATE:
985 if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
987 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
990 return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
998 /* Subroutine of comp_target-types. Make sure that the cv-quals change
999 only in the same direction as the target type. */
1002 comp_cv_target_types (tree ttl, tree ttr, int nptrs)
1006 if (!at_least_as_qualified_p (ttl, ttr)
1007 && !at_least_as_qualified_p (ttr, ttl))
1008 /* The qualifications are incomparable. */
1011 if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr))
1012 return more_qualified_p (ttr, ttl) ? -1 : 1;
1014 t = comp_target_types (ttl, ttr, nptrs);
1015 if ((t == 1 && at_least_as_qualified_p (ttl, ttr))
1016 || (t == -1 && at_least_as_qualified_p (ttr, ttl)))
1022 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
1023 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
1024 converted to TTL. Return -1 means that TTL can be converted to TTR but
1027 NPTRS is the number of pointers we can strip off and keep cool.
1028 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
1029 but to not permit B** to convert to A**.
1031 This should go away. Callers should use can_convert or something
1032 similar instead. (jason 17 Apr 1997) */
1035 comp_target_types (tree ttl, tree ttr, int nptrs)
1037 ttl = TYPE_MAIN_VARIANT (ttl);
1038 ttr = TYPE_MAIN_VARIANT (ttr);
1039 if (same_type_p (ttl, ttr))
1042 if (TREE_CODE (ttr) != TREE_CODE (ttl))
1045 if ((TREE_CODE (ttr) == POINTER_TYPE
1046 || TREE_CODE (ttr) == REFERENCE_TYPE)
1047 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
1048 of the type pointed to. This is necessary for reference init
1049 semantics. We won't get here from a previous call with nptrs == 1;
1050 for multi-level pointers we end up in comp_ptr_ttypes. */
1053 int is_ptr = TREE_CODE (ttr) == POINTER_TYPE;
1055 ttl = TREE_TYPE (ttl);
1056 ttr = TREE_TYPE (ttr);
1060 if (TREE_CODE (ttl) == UNKNOWN_TYPE
1061 || TREE_CODE (ttr) == UNKNOWN_TYPE)
1063 else if (TREE_CODE (ttl) == VOID_TYPE
1064 && TREE_CODE (ttr) != FUNCTION_TYPE
1065 && TREE_CODE (ttr) != METHOD_TYPE
1066 && TREE_CODE (ttr) != OFFSET_TYPE)
1068 else if (TREE_CODE (ttr) == VOID_TYPE
1069 && TREE_CODE (ttl) != FUNCTION_TYPE
1070 && TREE_CODE (ttl) != METHOD_TYPE
1071 && TREE_CODE (ttl) != OFFSET_TYPE)
1073 else if (TREE_CODE (ttl) == POINTER_TYPE
1074 || TREE_CODE (ttl) == ARRAY_TYPE)
1076 if (comp_ptr_ttypes (ttl, ttr))
1078 else if (comp_ptr_ttypes (ttr, ttl))
1084 /* Const and volatile mean something different for function types,
1085 so the usual checks are not appropriate. */
1086 if (TREE_CODE (ttl) == FUNCTION_TYPE || TREE_CODE (ttl) == METHOD_TYPE)
1087 return comp_target_types (ttl, ttr, nptrs - 1);
1089 return comp_cv_target_types (ttl, ttr, nptrs - 1);
1092 my_friendly_assert (TREE_CODE (ttr) != ARRAY_TYPE, 20030617);
1093 if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
1100 if (!same_type_p (TREE_TYPE (ttl), TREE_TYPE (ttr)))
1105 switch (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
1114 argsl = TYPE_ARG_TYPES (ttl);
1115 argsr = TYPE_ARG_TYPES (ttr);
1117 /* Compare 'this' here, not in comp_target_parms. */
1118 if (TREE_CODE (ttr) == METHOD_TYPE)
1120 tree tl = TYPE_METHOD_BASETYPE (ttl);
1121 tree tr = TYPE_METHOD_BASETYPE (ttr);
1123 if (!same_or_base_type_p (tr, tl))
1125 if (same_or_base_type_p (tl, tr))
1131 argsl = TREE_CHAIN (argsl);
1132 argsr = TREE_CHAIN (argsr);
1135 switch (comp_target_parms (argsl, argsr))
1143 return saw_contra ? -1 : 1;
1146 else if (TREE_CODE (ttr) == OFFSET_TYPE)
1150 /* Contravariance: we can assign a pointer to base member to a pointer
1151 to derived member. Note difference from simple pointer case, where
1152 we can pass a pointer to derived to a pointer to base. */
1153 if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr),
1154 TYPE_OFFSET_BASETYPE (ttl)))
1156 else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl),
1157 TYPE_OFFSET_BASETYPE (ttr)))
1167 ttl = TREE_TYPE (ttl);
1168 ttr = TREE_TYPE (ttr);
1170 if (TREE_CODE (ttl) == POINTER_TYPE
1171 || TREE_CODE (ttl) == ARRAY_TYPE)
1173 if (comp_ptr_ttypes (ttl, ttr))
1179 if (comp_cv_target_types (ttl, ttr, nptrs) == 1)
1184 else if (IS_AGGR_TYPE (ttl))
1188 if (same_or_base_type_p (ttl, ttr))
1190 if (same_or_base_type_p (ttr, ttl))
1198 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1201 at_least_as_qualified_p (tree type1, tree type2)
1203 int q1 = cp_type_quals (type1);
1204 int q2 = cp_type_quals (type2);
1206 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1207 return (q1 & q2) == q2;
1210 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1213 more_qualified_p (tree type1, tree type2)
1215 int q1 = cp_type_quals (type1);
1216 int q2 = cp_type_quals (type2);
1218 return q1 != q2 && (q1 & q2) == q2;
1221 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1222 more cv-qualified that TYPE1, and 0 otherwise. */
1225 comp_cv_qualification (tree type1, tree type2)
1227 int q1 = cp_type_quals (type1);
1228 int q2 = cp_type_quals (type2);
1233 if ((q1 & q2) == q2)
1235 else if ((q1 & q2) == q1)
1241 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1242 subset of the cv-qualification signature of TYPE2, and the types
1243 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1246 comp_cv_qual_signature (tree type1, tree type2)
1248 if (comp_ptr_ttypes_real (type2, type1, -1))
1250 else if (comp_ptr_ttypes_real (type1, type2, -1))
1256 /* If two types share a common base type, return that basetype.
1257 If there is not a unique most-derived base type, this function
1258 returns ERROR_MARK_NODE. */
1261 common_base_type (tree tt1, tree tt2)
1263 tree best = NULL_TREE;
1266 /* If one is a baseclass of another, that's good enough. */
1267 if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1269 if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1272 /* Otherwise, try to find a unique baseclass of TT1
1273 that is shared by TT2, and follow that down. */
1274 for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
1276 tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
1277 tree trial = common_base_type (basetype, tt2);
1280 if (trial == error_mark_node)
1282 if (best == NULL_TREE)
1284 else if (best != trial)
1285 return error_mark_node;
1290 for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
1292 tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
1293 tree trial = common_base_type (tt1, basetype);
1296 if (trial == error_mark_node)
1298 if (best == NULL_TREE)
1300 else if (best != trial)
1301 return error_mark_node;
1307 /* Subroutines of `comptypes'. */
1309 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1310 equivalent in the sense that functions with those parameter types
1311 can have equivalent types. The two lists must be equivalent,
1312 element by element. */
1315 compparms (tree parms1, tree parms2)
1319 /* An unspecified parmlist matches any specified parmlist
1320 whose argument types don't need default promotions. */
1322 for (t1 = parms1, t2 = parms2;
1324 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1326 /* If one parmlist is shorter than the other,
1327 they fail to match. */
1330 if (!same_type_p (TREE_VALUE (t2), TREE_VALUE (t1)))
1336 /* This really wants return whether or not parameter type lists
1337 would make their owning functions assignment compatible or not.
1339 The return value is like for comp_target_types.
1341 This should go away, possibly with the exception of the empty parmlist
1342 conversion; there are no conversions between function types in C++.
1343 (jason 17 Apr 1997) */
1346 comp_target_parms (tree parms1, tree parms2)
1348 register tree t1 = parms1, t2 = parms2;
1349 int warn_contravariance = 0;
1351 /* In C, an unspecified parmlist matches any specified parmlist
1352 whose argument types don't need default promotions. This is not
1353 true for C++, but let's do it anyway for unfixed headers. */
1355 if (t1 == 0 && t2 != 0)
1357 pedwarn ("ISO C++ prohibits conversion from `%#T' to `(...)'",
1359 return self_promoting_args_p (t2);
1362 return self_promoting_args_p (t1);
1364 for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1368 /* If one parmlist is shorter than the other, they fail to match. */
1371 p1 = TREE_VALUE (t1);
1372 p2 = TREE_VALUE (t2);
1373 if (same_type_p (p1, p2))
1379 if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
1380 || (TREE_CODE (p1) == REFERENCE_TYPE
1381 && TREE_CODE (p2) == REFERENCE_TYPE))
1383 /* The following is wrong for contravariance,
1384 but many programs depend on it. */
1385 if (TREE_TYPE (p1) == void_type_node)
1387 if (TREE_TYPE (p2) == void_type_node)
1389 warn_contravariance = 1;
1392 if (IS_AGGR_TYPE (TREE_TYPE (p1))
1393 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (p1),
1397 /* Note backwards order due to contravariance. */
1398 if (comp_target_types (p2, p1, 1) <= 0)
1400 if (comp_target_types (p1, p2, 1) > 0)
1402 warn_contravariance = 1;
1408 return warn_contravariance ? -1 : 1;
1412 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
1414 enum tree_code type_code;
1416 const char *op_name;
1418 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
1419 if (processing_template_decl)
1420 return build_min (op, size_type_node, type);
1422 op_name = operator_name_info[(int) op].name;
1424 type = non_reference (type);
1425 type_code = TREE_CODE (type);
1427 if (type_code == METHOD_TYPE)
1429 if (complain && (pedantic || warn_pointer_arith))
1430 pedwarn ("invalid application of `%s' to a member function", op_name);
1431 value = size_one_node;
1433 else if (type_code == OFFSET_TYPE)
1436 error ("invalid application of `%s' to non-static member", op_name);
1437 value = size_zero_node;
1440 value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
1446 expr_sizeof (tree e)
1448 if (processing_template_decl)
1449 return build_min (SIZEOF_EXPR, size_type_node, e);
1451 if (TREE_CODE (e) == COMPONENT_REF
1452 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1453 error ("sizeof applied to a bit-field");
1454 if (is_overloaded_fn (e))
1456 pedwarn ("ISO C++ forbids applying `sizeof' to an expression of function type");
1457 return c_sizeof (char_type_node);
1459 else if (type_unknown_p (e))
1461 cxx_incomplete_type_error (e, TREE_TYPE (e));
1462 return c_sizeof (char_type_node);
1465 if (e == error_mark_node)
1468 return cxx_sizeof (TREE_TYPE (e));
1472 /* Perform the conversions in [expr] that apply when an lvalue appears
1473 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1474 function-to-pointer conversions.
1476 In addition manifest constants are replaced by their values. */
1479 decay_conversion (tree exp)
1482 register enum tree_code code;
1484 type = TREE_TYPE (exp);
1485 code = TREE_CODE (type);
1487 if (code == REFERENCE_TYPE)
1489 exp = convert_from_reference (exp);
1490 type = TREE_TYPE (exp);
1491 code = TREE_CODE (type);
1494 if (type == error_mark_node)
1495 return error_mark_node;
1497 if (type_unknown_p (exp))
1499 cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1500 return error_mark_node;
1503 /* Constants can be used directly unless they're not loadable. */
1504 if (TREE_CODE (exp) == CONST_DECL)
1505 exp = DECL_INITIAL (exp);
1506 /* Replace a nonvolatile const static variable with its value. We
1507 don't do this for arrays, though; we want the address of the
1508 first element of the array, not the address of the first element
1509 of its initializing constant. */
1510 else if (code != ARRAY_TYPE)
1512 exp = decl_constant_value (exp);
1513 type = TREE_TYPE (exp);
1516 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1517 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1519 if (code == VOID_TYPE)
1521 error ("void value not ignored as it ought to be");
1522 return error_mark_node;
1524 if (code == METHOD_TYPE)
1526 error ("invalid use of non-static member function");
1527 return error_mark_node;
1529 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1530 return build_unary_op (ADDR_EXPR, exp, 0);
1531 if (code == ARRAY_TYPE)
1536 if (TREE_CODE (exp) == INDIRECT_REF)
1538 /* Stripping away the INDIRECT_REF is not the right
1539 thing to do for references... */
1540 tree inner = TREE_OPERAND (exp, 0);
1541 if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
1543 inner = build1 (CONVERT_EXPR,
1544 build_pointer_type (TREE_TYPE
1545 (TREE_TYPE (inner))),
1547 TREE_CONSTANT (inner) = TREE_CONSTANT (TREE_OPERAND (inner, 0));
1549 return cp_convert (build_pointer_type (TREE_TYPE (type)), inner);
1552 if (TREE_CODE (exp) == COMPOUND_EXPR)
1554 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1555 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1556 TREE_OPERAND (exp, 0), op1);
1560 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1562 error ("invalid use of non-lvalue array");
1563 return error_mark_node;
1566 ptrtype = build_pointer_type (TREE_TYPE (type));
1568 if (TREE_CODE (exp) == VAR_DECL)
1570 /* ??? This is not really quite correct
1571 in that the type of the operand of ADDR_EXPR
1572 is not the target type of the type of the ADDR_EXPR itself.
1573 Question is, can this lossage be avoided? */
1574 adr = build1 (ADDR_EXPR, ptrtype, exp);
1575 if (!cxx_mark_addressable (exp))
1576 return error_mark_node;
1577 TREE_CONSTANT (adr) = staticp (exp);
1578 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1581 /* This way is better for a COMPONENT_REF since it can
1582 simplify the offset for a component. */
1583 adr = build_unary_op (ADDR_EXPR, exp, 1);
1584 return cp_convert (ptrtype, adr);
1587 /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1588 rvalues always have cv-unqualified types. */
1589 if (! CLASS_TYPE_P (type))
1590 exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1596 default_conversion (tree exp)
1598 exp = decay_conversion (exp);
1600 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1601 exp = perform_integral_promotions (exp);
1606 /* EXPR is an expression with an integral or enumeration type.
1607 Perform the integral promotions in [conv.prom], and return the
1611 perform_integral_promotions (tree expr)
1616 type = TREE_TYPE (expr);
1617 my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type), 20030703);
1618 promoted_type = type_promotes_to (type);
1619 if (type != promoted_type)
1620 expr = cp_convert (promoted_type, expr);
1624 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1628 inline_conversion (tree exp)
1630 if (TREE_CODE (exp) == FUNCTION_DECL)
1631 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1636 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1637 decay_conversion to one. */
1640 string_conv_p (tree totype, tree exp, int warn)
1644 if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1647 t = TREE_TYPE (totype);
1648 if (!same_type_p (t, char_type_node)
1649 && !same_type_p (t, wchar_type_node))
1652 if (TREE_CODE (exp) == STRING_CST)
1654 /* Make sure that we don't try to convert between char and wchar_t. */
1655 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1660 /* Is this a string constant which has decayed to 'const char *'? */
1661 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1662 if (!same_type_p (TREE_TYPE (exp), t))
1665 if (TREE_CODE (exp) != ADDR_EXPR
1666 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1670 /* This warning is not very useful, as it complains about printf. */
1671 if (warn && warn_write_strings)
1672 warning ("deprecated conversion from string constant to `%T'", totype);
1677 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1678 can, for example, use as an lvalue. This code used to be in
1679 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1680 expressions, where we're dealing with aggregates. But now it's again only
1681 called from unary_complex_lvalue. The case (in particular) that led to
1682 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1686 rationalize_conditional_expr (enum tree_code code, tree t)
1688 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1689 the first operand is always the one to be used if both operands
1690 are equal, so we know what conditional expression this used to be. */
1691 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1694 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1695 ? LE_EXPR : GE_EXPR),
1696 TREE_OPERAND (t, 0),
1697 TREE_OPERAND (t, 1)),
1698 build_unary_op (code, TREE_OPERAND (t, 0), 0),
1699 build_unary_op (code, TREE_OPERAND (t, 1), 0));
1703 build_conditional_expr (TREE_OPERAND (t, 0),
1704 build_unary_op (code, TREE_OPERAND (t, 1), 0),
1705 build_unary_op (code, TREE_OPERAND (t, 2), 0));
1708 /* Given the TYPE of an anonymous union field inside T, return the
1709 FIELD_DECL for the field. If not found return NULL_TREE. Because
1710 anonymous unions can nest, we must also search all anonymous unions
1711 that are directly reachable. */
1714 lookup_anon_field (tree t, tree type)
1718 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1720 if (TREE_STATIC (field))
1722 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1725 /* If we find it directly, return the field. */
1726 if (DECL_NAME (field) == NULL_TREE
1727 && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1732 /* Otherwise, it could be nested, search harder. */
1733 if (DECL_NAME (field) == NULL_TREE
1734 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1736 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1744 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
1745 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
1746 non-NULL, it indicates the path to the base used to name MEMBER.
1747 If PRESERVE_REFERENCE is true, the expression returned will have
1748 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
1749 returned will have the type referred to by the reference.
1751 This function does not perform access control; that is either done
1752 earlier by the parser when the name of MEMBER is resolved to MEMBER
1753 itself, or later when overload resolution selects one of the
1754 functions indicated by MEMBER. */
1757 build_class_member_access_expr (tree object, tree member,
1758 tree access_path, bool preserve_reference)
1762 tree result = NULL_TREE;
1764 if (object == error_mark_node || member == error_mark_node)
1765 return error_mark_node;
1767 if (TREE_CODE (member) == PSEUDO_DTOR_EXPR)
1770 my_friendly_assert (DECL_P (member) || BASELINK_P (member),
1775 The type of the first expression shall be "class object" (of a
1777 object_type = TREE_TYPE (object);
1778 if (!complete_type_or_else (object_type, object))
1779 return error_mark_node;
1780 if (!CLASS_TYPE_P (object_type))
1782 error ("request for member `%D' in `%E', which is of non-class type `%T'",
1783 member, object, object_type);
1784 return error_mark_node;
1787 /* The standard does not seem to actually say that MEMBER must be a
1788 member of OBJECT_TYPE. However, that is clearly what is
1790 if (DECL_P (member))
1792 member_scope = DECL_CLASS_CONTEXT (member);
1794 if (TREE_DEPRECATED (member))
1795 warn_deprecated_use (member);
1798 member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1799 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1800 presently be the anonymous union. Go outwards until we find a
1801 type related to OBJECT_TYPE. */
1802 while (ANON_AGGR_TYPE_P (member_scope)
1803 && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1805 member_scope = TYPE_CONTEXT (member_scope);
1806 if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1808 if (TREE_CODE (member) == FIELD_DECL)
1809 error ("invalid use of nonstatic data member '%E'", member);
1811 error ("`%D' is not a member of `%T'", member, object_type);
1812 return error_mark_node;
1815 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1816 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
1817 in the frontend; only _DECLs and _REFs are lvalues in the backend. */
1819 tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1821 object = build_indirect_ref (temp, NULL);
1824 /* In [expr.ref], there is an explicit list of the valid choices for
1825 MEMBER. We check for each of those cases here. */
1826 if (TREE_CODE (member) == VAR_DECL)
1828 /* A static data member. */
1830 /* If OBJECT has side-effects, they are supposed to occur. */
1831 if (TREE_SIDE_EFFECTS (object))
1832 result = build (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1834 else if (TREE_CODE (member) == FIELD_DECL)
1836 /* A non-static data member. */
1841 null_object_p = (TREE_CODE (object) == INDIRECT_REF
1842 && integer_zerop (TREE_OPERAND (object, 0)));
1844 /* Convert OBJECT to the type of MEMBER. */
1845 if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1846 TYPE_MAIN_VARIANT (member_scope)))
1851 binfo = lookup_base (access_path ? access_path : object_type,
1852 member_scope, ba_ignore, &kind);
1853 if (binfo == error_mark_node)
1854 return error_mark_node;
1856 /* It is invalid to try to get to a virtual base of a
1857 NULL object. The most common cause is invalid use of
1859 if (null_object_p && kind == bk_via_virtual)
1861 error ("invalid access to non-static data member `%D' of NULL object",
1863 error ("(perhaps the `offsetof' macro was used incorrectly)");
1864 return error_mark_node;
1867 /* Convert to the base. */
1868 object = build_base_path (PLUS_EXPR, object, binfo,
1870 /* If we found the base successfully then we should be able
1871 to convert to it successfully. */
1872 my_friendly_assert (object != error_mark_node,
1876 /* Complain about other invalid uses of offsetof, even though they will
1877 give the right answer. Note that we complain whether or not they
1878 actually used the offsetof macro, since there's no way to know at this
1879 point. So we just give a warning, instead of a pedwarn. */
1880 if (null_object_p && warn_invalid_offsetof
1881 && CLASSTYPE_NON_POD_P (object_type))
1883 warning ("invalid access to non-static data member `%D' of NULL object",
1885 warning ("(perhaps the `offsetof' macro was used incorrectly)");
1888 /* If MEMBER is from an anonymous aggregate, we have converted
1889 OBJECT so that it refers to the class containing the
1890 anonymous union. Generate a reference to the anonymous union
1891 itself, and recur to find MEMBER. */
1892 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1893 /* When this code is called from build_field_call, the
1894 object already has the type of the anonymous union.
1895 That is because the COMPONENT_REF was already
1896 constructed, and was then disassembled before calling
1897 build_field_call. After the function-call code is
1898 cleaned up, this waste can be eliminated. */
1899 && (!same_type_ignoring_top_level_qualifiers_p
1900 (TREE_TYPE (object), DECL_CONTEXT (member))))
1902 tree anonymous_union;
1904 anonymous_union = lookup_anon_field (TREE_TYPE (object),
1905 DECL_CONTEXT (member));
1906 object = build_class_member_access_expr (object,
1908 /*access_path=*/NULL_TREE,
1909 preserve_reference);
1912 /* Compute the type of the field, as described in [expr.ref]. */
1913 type_quals = TYPE_UNQUALIFIED;
1914 member_type = TREE_TYPE (member);
1915 if (TREE_CODE (member_type) != REFERENCE_TYPE)
1917 type_quals = (cp_type_quals (member_type)
1918 | cp_type_quals (object_type));
1920 /* A field is const (volatile) if the enclosing object, or the
1921 field itself, is const (volatile). But, a mutable field is
1922 not const, even within a const object. */
1923 if (DECL_MUTABLE_P (member))
1924 type_quals &= ~TYPE_QUAL_CONST;
1925 member_type = cp_build_qualified_type (member_type, type_quals);
1928 result = fold (build (COMPONENT_REF, member_type, object, member));
1930 /* Mark the expression const or volatile, as appropriate. Even
1931 though we've dealt with the type above, we still have to mark the
1932 expression itself. */
1933 if (type_quals & TYPE_QUAL_CONST)
1934 TREE_READONLY (result) = 1;
1935 else if (type_quals & TYPE_QUAL_VOLATILE)
1936 TREE_THIS_VOLATILE (result) = 1;
1938 else if (BASELINK_P (member))
1940 /* The member is a (possibly overloaded) member function. */
1944 /* If the MEMBER is exactly one static member function, then we
1945 know the type of the expression. Otherwise, we must wait
1946 until overload resolution has been performed. */
1947 functions = BASELINK_FUNCTIONS (member);
1948 if (TREE_CODE (functions) == FUNCTION_DECL
1949 && DECL_STATIC_FUNCTION_P (functions))
1950 type = TREE_TYPE (functions);
1952 type = unknown_type_node;
1953 /* Note that we do not convert OBJECT to the BASELINK_BINFO
1954 base. That will happen when the function is called. */
1955 result = build (COMPONENT_REF, type, object, member);
1957 else if (TREE_CODE (member) == CONST_DECL)
1959 /* The member is an enumerator. */
1961 /* If OBJECT has side-effects, they are supposed to occur. */
1962 if (TREE_SIDE_EFFECTS (object))
1963 result = build (COMPOUND_EXPR, TREE_TYPE (result),
1968 error ("invalid use of `%D'", member);
1969 return error_mark_node;
1972 if (!preserve_reference)
1975 If E2 is declared to have type "reference to T", then ... the
1976 type of E1.E2 is T. */
1977 result = convert_from_reference (result);
1982 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
1983 SCOPE is NULL, by OBJECT.~DTOR_NAME. */
1986 lookup_destructor (tree object, tree scope, tree dtor_name)
1988 tree object_type = TREE_TYPE (object);
1989 tree dtor_type = TREE_OPERAND (dtor_name, 0);
1991 if (scope && !check_dtor_name (scope, dtor_name))
1993 error ("qualified type `%T' does not match destructor name `~%T'",
1995 return error_mark_node;
1997 if (!same_type_p (dtor_type, TYPE_MAIN_VARIANT (object_type)))
1999 error ("destructor name `%T' does not match type `%T' of expression",
2000 dtor_type, object_type);
2001 return error_mark_node;
2003 if (!TYPE_HAS_DESTRUCTOR (object_type))
2004 return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope,
2006 return lookup_member (object_type, complete_dtor_identifier,
2007 /*protect=*/1, /*want_type=*/false);
2010 /* This function is called by the parser to process a class member
2011 access expression of the form OBJECT.NAME. NAME is a node used by
2012 the parser to represent a name; it is not yet a DECL. It may,
2013 however, be a BASELINK where the BASELINK_FUNCTIONS is a
2014 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
2015 there is no reason to do the lookup twice, so the parser keeps the
2019 finish_class_member_access_expr (tree object, tree name)
2024 tree access_path = NULL_TREE;
2025 tree orig_object = object;
2026 tree orig_name = name;
2028 if (object == error_mark_node || name == error_mark_node)
2029 return error_mark_node;
2031 object_type = TREE_TYPE (object);
2033 if (processing_template_decl)
2035 if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
2036 dependent_type_p (object_type)
2037 /* If NAME is "f<args>", where either 'f' or 'args' is
2038 dependent, then the expression is dependent. */
2039 || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2040 && dependent_template_id_p (TREE_OPERAND (name, 0),
2041 TREE_OPERAND (name, 1)))
2042 /* If NAME is "T::X" where "T" is dependent, then the
2043 expression is dependent. */
2044 || (TREE_CODE (name) == SCOPE_REF
2045 && TYPE_P (TREE_OPERAND (name, 0))
2046 && dependent_type_p (TREE_OPERAND (name, 0))))
2047 return build_min_nt (COMPONENT_REF, object, name);
2048 object = build_non_dependent_expr (object);
2051 if (TREE_CODE (object_type) == REFERENCE_TYPE)
2053 object = convert_from_reference (object);
2054 object_type = TREE_TYPE (object);
2059 The type of the first expression shall be "class object" (of a
2061 if (!complete_type_or_else (object_type, object))
2062 return error_mark_node;
2063 if (!CLASS_TYPE_P (object_type))
2065 error ("request for member `%D' in `%E', which is of non-class type `%T'",
2066 name, object, object_type);
2067 return error_mark_node;
2070 if (BASELINK_P (name))
2072 /* A member function that has already been looked up. */
2073 my_friendly_assert ((TREE_CODE (BASELINK_FUNCTIONS (name))
2074 == TEMPLATE_ID_EXPR),
2080 bool is_template_id = false;
2081 tree template_args = NULL_TREE;
2084 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2086 is_template_id = true;
2087 template_args = TREE_OPERAND (name, 1);
2088 name = TREE_OPERAND (name, 0);
2091 if (TREE_CODE (name) == SCOPE_REF)
2093 /* A qualified name. The qualifying class or namespace `S' has
2094 already been looked up; it is either a TYPE or a
2095 NAMESPACE_DECL. The member name is either an IDENTIFIER_NODE
2096 or a BIT_NOT_EXPR. */
2097 scope = TREE_OPERAND (name, 0);
2098 name = TREE_OPERAND (name, 1);
2099 my_friendly_assert ((CLASS_TYPE_P (scope)
2100 || TREE_CODE (scope) == NAMESPACE_DECL),
2102 my_friendly_assert ((TREE_CODE (name) == IDENTIFIER_NODE
2103 || TREE_CODE (name) == BIT_NOT_EXPR),
2106 /* If SCOPE is a namespace, then the qualified name does not
2107 name a member of OBJECT_TYPE. */
2108 if (TREE_CODE (scope) == NAMESPACE_DECL)
2110 error ("`%D::%D' is not a member of `%T'",
2111 scope, name, object_type);
2112 return error_mark_node;
2115 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
2116 access_path = lookup_base (object_type, scope, ba_check, NULL);
2117 if (!access_path || access_path == error_mark_node)
2118 return error_mark_node;
2123 access_path = object_type;
2126 if (TREE_CODE (name) == BIT_NOT_EXPR)
2127 member = lookup_destructor (object, scope, name);
2130 /* Look up the member. */
2131 member = lookup_member (access_path, name, /*protect=*/1,
2132 /*want_type=*/false);
2133 if (member == NULL_TREE)
2135 error ("'%D' has no member named '%E'", object_type, name);
2136 return error_mark_node;
2138 if (member == error_mark_node)
2139 return error_mark_node;
2144 tree template = member;
2146 if (BASELINK_P (template))
2147 template = lookup_template_function (template, template_args);
2150 error ("`%D' is not a member template function", name);
2151 return error_mark_node;
2156 if (TREE_DEPRECATED (member))
2157 warn_deprecated_use (member);
2159 expr = build_class_member_access_expr (object, member, access_path,
2160 /*preserve_reference=*/false);
2161 if (processing_template_decl && expr != error_mark_node)
2162 return build_min (COMPONENT_REF, TREE_TYPE (expr), orig_object,
2167 /* Return an expression for the MEMBER_NAME field in the internal
2168 representation of PTRMEM, a pointer-to-member function. (Each
2169 pointer-to-member function type gets its own RECORD_TYPE so it is
2170 more convenient to access the fields by name than by FIELD_DECL.)
2171 This routine converts the NAME to a FIELD_DECL and then creates the
2172 node for the complete expression. */
2175 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2181 /* This code is a stripped down version of
2182 build_class_member_access_expr. It does not work to use that
2183 routine directly because it expects the object to be of class
2185 ptrmem_type = TREE_TYPE (ptrmem);
2186 my_friendly_assert (TYPE_PTRMEMFUNC_P (ptrmem_type), 20020804);
2187 member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2188 /*want_type=*/false);
2189 member_type = cp_build_qualified_type (TREE_TYPE (member),
2190 cp_type_quals (ptrmem_type));
2191 return fold (build (COMPONENT_REF, member_type, ptrmem, member));
2194 /* Given an expression PTR for a pointer, return an expression
2195 for the value pointed to.
2196 ERRORSTRING is the name of the operator to appear in error messages.
2198 This function may need to overload OPERATOR_FNNAME.
2199 Must also handle REFERENCE_TYPEs for C++. */
2202 build_x_indirect_ref (tree expr, const char *errorstring)
2204 tree orig_expr = expr;
2207 if (processing_template_decl)
2209 if (type_dependent_expression_p (expr))
2210 return build_min_nt (INDIRECT_REF, expr);
2211 expr = build_non_dependent_expr (expr);
2214 rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2217 rval = build_indirect_ref (expr, errorstring);
2219 if (processing_template_decl && rval != error_mark_node)
2220 return build_min (INDIRECT_REF, TREE_TYPE (rval), orig_expr);
2226 build_indirect_ref (tree ptr, const char *errorstring)
2228 register tree pointer, type;
2230 if (ptr == error_mark_node)
2231 return error_mark_node;
2233 if (ptr == current_class_ptr)
2234 return current_class_ref;
2236 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2237 ? ptr : decay_conversion (ptr));
2238 type = TREE_TYPE (pointer);
2240 if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
2244 If the type of the expression is "pointer to T," the type
2245 of the result is "T."
2247 We must use the canonical variant because certain parts of
2248 the back end, like fold, do pointer comparisons between
2250 tree t = canonical_type_variant (TREE_TYPE (type));
2252 if (VOID_TYPE_P (t))
2254 /* A pointer to incomplete type (other than cv void) can be
2255 dereferenced [expr.unary.op]/1 */
2256 error ("`%T' is not a pointer-to-object type", type);
2257 return error_mark_node;
2259 else if (TREE_CODE (pointer) == ADDR_EXPR
2260 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2261 /* The POINTER was something like `&x'. We simplify `*&x' to
2263 return TREE_OPERAND (pointer, 0);
2266 tree ref = build1 (INDIRECT_REF, t, pointer);
2268 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2269 so that we get the proper error message if the result is used
2270 to assign to. Also, &* is supposed to be a no-op. */
2271 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2272 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2273 TREE_SIDE_EFFECTS (ref)
2274 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2278 /* `pointer' won't be an error_mark_node if we were given a
2279 pointer to member, so it's cool to check for this here. */
2280 else if (TYPE_PTRMEM_P (type) || TYPE_PTRMEMFUNC_P (type))
2281 error ("invalid use of `%s' on pointer to member", errorstring);
2282 else if (pointer != error_mark_node)
2285 error ("invalid type argument of `%s'", errorstring);
2287 error ("invalid type argument");
2289 return error_mark_node;
2292 /* This handles expressions of the form "a[i]", which denotes
2295 This is logically equivalent in C to *(a+i), but we may do it differently.
2296 If A is a variable or a member, we generate a primitive ARRAY_REF.
2297 This avoids forcing the array out of registers, and can work on
2298 arrays that are not lvalues (for example, members of structures returned
2301 If INDEX is of some user-defined type, it must be converted to
2302 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2303 will inherit the type of the array, which will be some pointer type. */
2306 build_array_ref (tree array, tree idx)
2310 error ("subscript missing in array reference");
2311 return error_mark_node;
2314 if (TREE_TYPE (array) == error_mark_node
2315 || TREE_TYPE (idx) == error_mark_node)
2316 return error_mark_node;
2318 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2320 switch (TREE_CODE (array))
2324 tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2325 return build (COMPOUND_EXPR, TREE_TYPE (value),
2326 TREE_OPERAND (array, 0), value);
2330 return build_conditional_expr
2331 (TREE_OPERAND (array, 0),
2332 build_array_ref (TREE_OPERAND (array, 1), idx),
2333 build_array_ref (TREE_OPERAND (array, 2), idx));
2339 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
2340 && TREE_CODE (array) != INDIRECT_REF)
2344 /* Subscripting with type char is likely to lose
2345 on a machine where chars are signed.
2346 So warn on any machine, but optionally.
2347 Don't warn for unsigned char since that type is safe.
2348 Don't warn for signed char because anyone who uses that
2349 must have done so deliberately. */
2350 if (warn_char_subscripts
2351 && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2352 warning ("array subscript has type `char'");
2354 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2356 error ("array subscript is not an integer");
2357 return error_mark_node;
2360 /* Apply integral promotions *after* noticing character types.
2361 (It is unclear why we do these promotions -- the standard
2362 does not say that we should. In fact, the natual thing would
2363 seem to be to convert IDX to ptrdiff_t; we're performing
2364 pointer arithmetic.) */
2365 idx = perform_integral_promotions (idx);
2367 /* An array that is indexed by a non-constant
2368 cannot be stored in a register; we must be able to do
2369 address arithmetic on its address.
2370 Likewise an array of elements of variable size. */
2371 if (TREE_CODE (idx) != INTEGER_CST
2372 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2373 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2376 if (!cxx_mark_addressable (array))
2377 return error_mark_node;
2380 /* An array that is indexed by a constant value which is not within
2381 the array bounds cannot be stored in a register either; because we
2382 would get a crash in store_bit_field/extract_bit_field when trying
2383 to access a non-existent part of the register. */
2384 if (TREE_CODE (idx) == INTEGER_CST
2385 && TYPE_VALUES (TREE_TYPE (array))
2386 && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
2388 if (!cxx_mark_addressable (array))
2389 return error_mark_node;
2392 if (pedantic && !lvalue_p (array))
2393 pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2395 /* Note in C++ it is valid to subscript a `register' array, since
2396 it is valid to take the address of something with that
2397 storage specification. */
2401 while (TREE_CODE (foo) == COMPONENT_REF)
2402 foo = TREE_OPERAND (foo, 0);
2403 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2404 warning ("subscripting array declared `register'");
2407 type = TREE_TYPE (TREE_TYPE (array));
2408 rval = build (ARRAY_REF, type, array, idx);
2409 /* Array ref is const/volatile if the array elements are
2410 or if the array is.. */
2411 TREE_READONLY (rval)
2412 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2413 TREE_SIDE_EFFECTS (rval)
2414 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2415 TREE_THIS_VOLATILE (rval)
2416 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2417 return require_complete_type (fold (rval));
2421 tree ar = default_conversion (array);
2422 tree ind = default_conversion (idx);
2424 /* Put the integer in IND to simplify error checking. */
2425 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2432 if (ar == error_mark_node)
2435 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2437 error ("subscripted value is neither array nor pointer");
2438 return error_mark_node;
2440 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2442 error ("array subscript is not an integer");
2443 return error_mark_node;
2446 return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2451 /* Resolve a pointer to member function. INSTANCE is the object
2452 instance to use, if the member points to a virtual member.
2454 This used to avoid checking for virtual functions if basetype
2455 has no virtual functions, according to an earlier ANSI draft.
2456 With the final ISO C++ rules, such an optimization is
2457 incorrect: A pointer to a derived member can be static_cast
2458 to pointer-to-base-member, as long as the dynamic object
2459 later has the right member. */
2462 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2464 if (TREE_CODE (function) == OFFSET_REF)
2465 function = TREE_OPERAND (function, 1);
2467 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2469 tree idx, delta, e1, e2, e3, vtbl, basetype;
2470 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2472 tree instance_ptr = *instance_ptrptr;
2473 tree instance_save_expr = 0;
2474 if (instance_ptr == error_mark_node)
2476 if (TREE_CODE (function) == PTRMEM_CST)
2478 /* Extracting the function address from a pmf is only
2479 allowed with -Wno-pmf-conversions. It only works for
2481 e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2482 e1 = convert (fntype, e1);
2487 error ("object missing in use of `%E'", function);
2488 return error_mark_node;
2492 if (TREE_SIDE_EFFECTS (instance_ptr))
2493 instance_ptr = instance_save_expr = save_expr (instance_ptr);
2495 if (TREE_SIDE_EFFECTS (function))
2496 function = save_expr (function);
2498 /* Start by extracting all the information from the PMF itself. */
2499 e3 = PFN_FROM_PTRMEMFUNC (function);
2500 delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2501 idx = build1 (NOP_EXPR, vtable_index_type, e3);
2502 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2504 case ptrmemfunc_vbit_in_pfn:
2505 e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2506 idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2509 case ptrmemfunc_vbit_in_delta:
2510 e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2511 delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2518 /* Convert down to the right base before using the instance. First
2520 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2521 basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2522 basetype, ba_check, NULL);
2523 instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2524 if (instance_ptr == error_mark_node)
2525 return error_mark_node;
2526 /* ...and then the delta in the PMF. */
2527 instance_ptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
2528 instance_ptr, delta);
2530 /* Hand back the adjusted 'this' argument to our caller. */
2531 *instance_ptrptr = instance_ptr;
2533 /* Next extract the vtable pointer from the object. */
2534 vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2536 vtbl = build_indirect_ref (vtbl, NULL);
2538 /* Finally, extract the function pointer from the vtable. */
2539 e2 = fold (build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
2540 e2 = build_indirect_ref (e2, NULL);
2541 TREE_CONSTANT (e2) = 1;
2543 /* When using function descriptors, the address of the
2544 vtable entry is treated as a function pointer. */
2545 if (TARGET_VTABLE_USES_DESCRIPTORS)
2546 e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2547 build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2549 TREE_TYPE (e2) = TREE_TYPE (e3);
2550 e1 = build_conditional_expr (e1, e2, e3);
2552 /* Make sure this doesn't get evaluated first inside one of the
2553 branches of the COND_EXPR. */
2554 if (instance_save_expr)
2555 e1 = build (COMPOUND_EXPR, TREE_TYPE (e1),
2556 instance_save_expr, e1);
2564 build_function_call (tree function, tree params)
2566 register tree fntype, fndecl;
2567 register tree coerced_params;
2569 tree name = NULL_TREE, assembler_name = NULL_TREE;
2571 tree original = function;
2573 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2574 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2575 if (TREE_CODE (function) == NOP_EXPR
2576 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2577 function = TREE_OPERAND (function, 0);
2579 if (TREE_CODE (function) == FUNCTION_DECL)
2581 name = DECL_NAME (function);
2582 assembler_name = DECL_ASSEMBLER_NAME (function);
2584 mark_used (function);
2587 /* Convert anything with function type to a pointer-to-function. */
2588 if (pedantic && DECL_MAIN_P (function))
2589 pedwarn ("ISO C++ forbids calling `::main' from within program");
2591 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2592 (because calling an inline function does not mean the function
2593 needs to be separately compiled). */
2595 if (DECL_INLINE (function))
2596 function = inline_conversion (function);
2598 function = build_addr_func (function);
2604 function = build_addr_func (function);
2607 if (function == error_mark_node)
2608 return error_mark_node;
2610 fntype = TREE_TYPE (function);
2612 if (TYPE_PTRMEMFUNC_P (fntype))
2614 error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2616 return error_mark_node;
2619 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2620 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2622 if (!((TREE_CODE (fntype) == POINTER_TYPE
2623 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2625 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2627 error ("`%E' cannot be used as a function", original);
2628 return error_mark_node;
2631 /* fntype now gets the type of function pointed to. */
2632 fntype = TREE_TYPE (fntype);
2634 /* Convert the parameters to the types declared in the
2635 function prototype, or apply default promotions. */
2637 coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2638 params, fndecl, LOOKUP_NORMAL);
2639 if (coerced_params == error_mark_node)
2640 return error_mark_node;
2642 /* Check for errors in format strings. */
2645 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
2647 /* Recognize certain built-in functions so we can make tree-codes
2648 other than CALL_EXPR. We do this when it enables fold-const.c
2649 to do something useful. */
2651 if (TREE_CODE (function) == ADDR_EXPR
2652 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2653 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2655 result = expand_tree_builtin (TREE_OPERAND (function, 0),
2656 params, coerced_params);
2661 return build_cxx_call (function, params, coerced_params);
2664 /* Convert the actual parameter expressions in the list VALUES
2665 to the types in the list TYPELIST.
2666 If parmdecls is exhausted, or when an element has NULL as its type,
2667 perform the default conversions.
2669 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2671 This is also where warnings about wrong number of args are generated.
2673 Return a list of expressions for the parameters as converted.
2675 Both VALUES and the returned value are chains of TREE_LIST nodes
2676 with the elements of the list in the TREE_VALUE slots of those nodes.
2678 In C++, unspecified trailing parameters can be filled in with their
2679 default arguments, if such were specified. Do so here. */
2682 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2684 register tree typetail, valtail;
2685 register tree result = NULL_TREE;
2686 const char *called_thing = 0;
2689 /* Argument passing is always copy-initialization. */
2690 flags |= LOOKUP_ONLYCONVERTING;
2694 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2696 if (DECL_NAME (fndecl) == NULL_TREE
2697 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2698 called_thing = "constructor";
2700 called_thing = "member function";
2703 called_thing = "function";
2706 for (valtail = values, typetail = typelist;
2708 valtail = TREE_CHAIN (valtail), i++)
2710 register tree type = typetail ? TREE_VALUE (typetail) : 0;
2711 register tree val = TREE_VALUE (valtail);
2713 if (val == error_mark_node)
2714 return error_mark_node;
2716 if (type == void_type_node)
2720 cp_error_at ("too many arguments to %s `%+#D'", called_thing,
2722 error ("at this point in file");
2725 error ("too many arguments to function");
2726 /* In case anybody wants to know if this argument
2729 TREE_TYPE (tree_last (result)) = error_mark_node;
2733 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2734 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2735 if (TREE_CODE (val) == NOP_EXPR
2736 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2737 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2738 val = TREE_OPERAND (val, 0);
2740 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2742 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2743 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2744 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2745 val = decay_conversion (val);
2748 if (val == error_mark_node)
2749 return error_mark_node;
2753 /* Formal parm type is specified by a function prototype. */
2756 if (!COMPLETE_TYPE_P (complete_type (type)))
2758 error ("parameter type of called function is incomplete");
2763 parmval = convert_for_initialization
2764 (NULL_TREE, type, val, flags,
2765 "argument passing", fndecl, i);
2766 parmval = convert_for_arg_passing (type, parmval);
2769 if (parmval == error_mark_node)
2770 return error_mark_node;
2772 result = tree_cons (NULL_TREE, parmval, result);
2776 if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
2777 val = convert_from_reference (val);
2779 if (fndecl && DECL_BUILT_IN (fndecl)
2780 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2781 /* Don't do ellipsis conversion for __built_in_constant_p
2782 as this will result in spurious warnings for non-POD
2784 val = require_complete_type (val);
2786 val = convert_arg_to_ellipsis (val);
2788 result = tree_cons (NULL_TREE, val, result);
2792 typetail = TREE_CHAIN (typetail);
2795 if (typetail != 0 && typetail != void_list_node)
2797 /* See if there are default arguments that can be used */
2798 if (TREE_PURPOSE (typetail)
2799 && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2801 for (; typetail != void_list_node; ++i)
2804 = convert_default_arg (TREE_VALUE (typetail),
2805 TREE_PURPOSE (typetail),
2808 if (parmval == error_mark_node)
2809 return error_mark_node;
2811 result = tree_cons (0, parmval, result);
2812 typetail = TREE_CHAIN (typetail);
2813 /* ends with `...'. */
2814 if (typetail == NULL_TREE)
2822 cp_error_at ("too few arguments to %s `%+#D'",
2823 called_thing, fndecl);
2824 error ("at this point in file");
2827 error ("too few arguments to function");
2828 return error_mark_list;
2832 return nreverse (result);
2835 /* Build a binary-operation expression, after performing default
2836 conversions on the operands. CODE is the kind of expression to build. */
2839 build_x_binary_op (enum tree_code code, tree arg1, tree arg2)
2848 if (processing_template_decl)
2850 if (type_dependent_expression_p (arg1)
2851 || type_dependent_expression_p (arg2))
2852 return build_min_nt (code, arg1, arg2);
2853 arg1 = build_non_dependent_expr (arg1);
2854 arg2 = build_non_dependent_expr (arg2);
2857 if (code == DOTSTAR_EXPR)
2858 expr = build_m_component_ref (arg1, arg2);
2860 expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
2862 if (processing_template_decl && expr != error_mark_node)
2863 return build_min (code, TREE_TYPE (expr), orig_arg1, orig_arg2);
2868 /* Build a binary-operation expression without default conversions.
2869 CODE is the kind of expression to build.
2870 This function differs from `build' in several ways:
2871 the data type of the result is computed and recorded in it,
2872 warnings are generated if arg data types are invalid,
2873 special handling for addition and subtraction of pointers is known,
2874 and some optimization is done (operations on narrow ints
2875 are done in the narrower type when that gives the same result).
2876 Constant folding is also done before the result is returned.
2878 Note that the operands will never have enumeral types
2879 because either they have just had the default conversions performed
2880 or they have both just been converted to some other type in which
2881 the arithmetic is to be done.
2883 C++: must do special pointer arithmetic when implementing
2884 multiple inheritance, and deal with pointer to member functions. */
2887 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2888 int convert_p ATTRIBUTE_UNUSED)
2891 register enum tree_code code0, code1;
2894 /* Expression code to give to the expression when it is built.
2895 Normally this is CODE, which is what the caller asked for,
2896 but in some special cases we change it. */
2897 register enum tree_code resultcode = code;
2899 /* Data type in which the computation is to be performed.
2900 In the simplest cases this is the common type of the arguments. */
2901 register tree result_type = NULL;
2903 /* Nonzero means operands have already been type-converted
2904 in whatever way is necessary.
2905 Zero means they need to be converted to RESULT_TYPE. */
2908 /* Nonzero means create the expression with this type, rather than
2910 tree build_type = 0;
2912 /* Nonzero means after finally constructing the expression
2913 convert it to this type. */
2914 tree final_type = 0;
2916 /* Nonzero if this is an operation like MIN or MAX which can
2917 safely be computed in short if both args are promoted shorts.
2918 Also implies COMMON.
2919 -1 indicates a bitwise operation; this makes a difference
2920 in the exact conditions for when it is safe to do the operation
2921 in a narrower mode. */
2924 /* Nonzero if this is a comparison operation;
2925 if both args are promoted shorts, compare the original shorts.
2926 Also implies COMMON. */
2927 int short_compare = 0;
2929 /* Nonzero if this is a right-shift operation, which can be computed on the
2930 original short and then promoted if the operand is a promoted short. */
2931 int short_shift = 0;
2933 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2936 /* Apply default conversions. */
2940 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2941 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2942 || code == TRUTH_XOR_EXPR)
2944 if (!really_overloaded_fn (op0))
2945 op0 = decay_conversion (op0);
2946 if (!really_overloaded_fn (op1))
2947 op1 = decay_conversion (op1);
2951 if (!really_overloaded_fn (op0))
2952 op0 = default_conversion (op0);
2953 if (!really_overloaded_fn (op1))
2954 op1 = default_conversion (op1);
2957 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2958 STRIP_TYPE_NOPS (op0);
2959 STRIP_TYPE_NOPS (op1);
2961 /* DTRT if one side is an overloaded function, but complain about it. */
2962 if (type_unknown_p (op0))
2964 tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2965 if (t != error_mark_node)
2967 pedwarn ("assuming cast to type `%T' from overloaded function",
2972 if (type_unknown_p (op1))
2974 tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2975 if (t != error_mark_node)
2977 pedwarn ("assuming cast to type `%T' from overloaded function",
2983 type0 = TREE_TYPE (op0);
2984 type1 = TREE_TYPE (op1);
2986 /* The expression codes of the data types of the arguments tell us
2987 whether the arguments are integers, floating, pointers, etc. */
2988 code0 = TREE_CODE (type0);
2989 code1 = TREE_CODE (type1);
2991 /* If an error was already reported for one of the arguments,
2992 avoid reporting another error. */
2994 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2995 return error_mark_node;
3000 /* Handle the pointer + int case. */
3001 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3002 return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
3003 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
3004 return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
3010 /* Subtraction of two similar pointers.
3011 We must subtract them as integers, then divide by object size. */
3012 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3013 && comp_target_types (type0, type1, 1))
3014 return pointer_diff (op0, op1, common_type (type0, type1));
3015 /* Handle pointer minus int. Just like pointer plus int. */
3016 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3017 return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
3026 case TRUNC_DIV_EXPR:
3028 case FLOOR_DIV_EXPR:
3029 case ROUND_DIV_EXPR:
3030 case EXACT_DIV_EXPR:
3031 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3032 || code0 == COMPLEX_TYPE)
3033 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3034 || code1 == COMPLEX_TYPE))
3036 if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
3037 warning ("division by zero in `%E / 0'", op0);
3038 else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
3039 warning ("division by zero in `%E / 0.'", op0);
3041 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
3042 resultcode = RDIV_EXPR;
3044 /* When dividing two signed integers, we have to promote to int.
3045 unless we divide by a constant != -1. Note that default
3046 conversion will have been performed on the operands at this
3047 point, so we have to dig out the original type to find out if
3049 shorten = ((TREE_CODE (op0) == NOP_EXPR
3050 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3051 || (TREE_CODE (op1) == INTEGER_CST
3052 && ! integer_all_onesp (op1)));
3059 case BIT_ANDTC_EXPR:
3062 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3066 case TRUNC_MOD_EXPR:
3067 case FLOOR_MOD_EXPR:
3068 if (code1 == INTEGER_TYPE && integer_zerop (op1))
3069 warning ("division by zero in `%E %% 0'", op0);
3070 else if (code1 == REAL_TYPE && real_zerop (op1))
3071 warning ("division by zero in `%E %% 0.'", op0);
3073 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3075 /* Although it would be tempting to shorten always here, that loses
3076 on some targets, since the modulo instruction is undefined if the
3077 quotient can't be represented in the computation mode. We shorten
3078 only if unsigned or if dividing by something we know != -1. */
3079 shorten = ((TREE_CODE (op0) == NOP_EXPR
3080 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3081 || (TREE_CODE (op1) == INTEGER_CST
3082 && ! integer_all_onesp (op1)));
3087 case TRUTH_ANDIF_EXPR:
3088 case TRUTH_ORIF_EXPR:
3089 case TRUTH_AND_EXPR:
3091 result_type = boolean_type_node;
3094 /* Shift operations: result has same type as first operand;
3095 always convert second operand to int.
3096 Also set SHORT_SHIFT if shifting rightward. */
3099 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3101 result_type = type0;
3102 if (TREE_CODE (op1) == INTEGER_CST)
3104 if (tree_int_cst_lt (op1, integer_zero_node))
3105 warning ("right shift count is negative");
3108 if (! integer_zerop (op1))
3110 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3111 warning ("right shift count >= width of type");
3114 /* Convert the shift-count to an integer, regardless of
3115 size of value being shifted. */
3116 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3117 op1 = cp_convert (integer_type_node, op1);
3118 /* Avoid converting op1 to result_type later. */
3124 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3126 result_type = type0;
3127 if (TREE_CODE (op1) == INTEGER_CST)
3129 if (tree_int_cst_lt (op1, integer_zero_node))
3130 warning ("left shift count is negative");
3131 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3132 warning ("left shift count >= width of type");
3134 /* Convert the shift-count to an integer, regardless of
3135 size of value being shifted. */
3136 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3137 op1 = cp_convert (integer_type_node, op1);
3138 /* Avoid converting op1 to result_type later. */
3145 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3147 result_type = type0;
3148 if (TREE_CODE (op1) == INTEGER_CST)
3150 if (tree_int_cst_lt (op1, integer_zero_node))
3151 warning ("%s rotate count is negative",
3152 (code == LROTATE_EXPR) ? "left" : "right");
3153 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3154 warning ("%s rotate count >= width of type",
3155 (code == LROTATE_EXPR) ? "left" : "right");
3157 /* Convert the shift-count to an integer, regardless of
3158 size of value being shifted. */
3159 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3160 op1 = cp_convert (integer_type_node, op1);
3166 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3167 warning ("comparing floating point with == or != is unsafe");
3169 build_type = boolean_type_node;
3170 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3171 || code0 == COMPLEX_TYPE)
3172 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3173 || code1 == COMPLEX_TYPE))
3175 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3176 result_type = composite_pointer_type (type0, type1, op0, op1,
3178 else if (code0 == POINTER_TYPE && null_ptr_cst_p (op1))
3179 result_type = type0;
3180 else if (code1 == POINTER_TYPE && null_ptr_cst_p (op0))
3181 result_type = type1;
3182 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3184 result_type = type0;
3185 error ("ISO C++ forbids comparison between pointer and integer");
3187 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3189 result_type = type1;
3190 error ("ISO C++ forbids comparison between pointer and integer");
3192 else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3194 op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3195 op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3196 result_type = TREE_TYPE (op0);
3198 else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3199 return cp_build_binary_op (code, op1, op0);
3200 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3201 && same_type_p (type0, type1))
3203 /* E will be the final comparison. */
3205 /* E1 and E2 are for scratch. */
3213 if (TREE_SIDE_EFFECTS (op0))
3214 op0 = save_expr (op0);
3215 if (TREE_SIDE_EFFECTS (op1))
3216 op1 = save_expr (op1);
3221 && (!op0.pfn || op0.delta == op1.delta))
3223 The reason for the `!op0.pfn' bit is that a NULL
3224 pointer-to-member is any member with a zero PFN; the
3225 DELTA field is unspecified. */
3226 pfn0 = pfn_from_ptrmemfunc (op0);
3227 pfn1 = pfn_from_ptrmemfunc (op1);
3228 delta0 = build_ptrmemfunc_access_expr (op0,
3230 delta1 = build_ptrmemfunc_access_expr (op1,
3232 e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3233 e2 = cp_build_binary_op (EQ_EXPR,
3235 cp_convert (TREE_TYPE (pfn0),
3236 integer_zero_node));
3237 e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3238 e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3239 e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3240 if (code == EQ_EXPR)
3242 return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3244 else if ((TYPE_PTRMEMFUNC_P (type0)
3245 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
3246 || (TYPE_PTRMEMFUNC_P (type1)
3247 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
3253 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3254 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3256 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3257 result_type = composite_pointer_type (type0, type1, op0, op1,
3265 build_type = boolean_type_node;
3266 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3267 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3269 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3270 result_type = composite_pointer_type (type0, type1, op0, op1,
3272 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3273 && integer_zerop (op1))
3274 result_type = type0;
3275 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3276 && integer_zerop (op0))
3277 result_type = type1;
3278 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3280 result_type = type0;
3281 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3283 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3285 result_type = type1;
3286 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3290 case UNORDERED_EXPR:
3297 build_type = integer_type_node;
3298 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3300 error ("unordered comparison on non-floating point argument");
3301 return error_mark_node;
3310 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3312 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
3314 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3316 if (shorten || common || short_compare)
3317 result_type = common_type (type0, type1);
3319 /* For certain operations (which identify themselves by shorten != 0)
3320 if both args were extended from the same smaller type,
3321 do the arithmetic in that type and then extend.
3323 shorten !=0 and !=1 indicates a bitwise operation.
3324 For them, this optimization is safe only if
3325 both args are zero-extended or both are sign-extended.
3326 Otherwise, we might change the result.
3327 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3328 but calculated in (unsigned short) it would be (unsigned short)-1. */
3330 if (shorten && none_complex)
3332 int unsigned0, unsigned1;
3333 tree arg0 = get_narrower (op0, &unsigned0);
3334 tree arg1 = get_narrower (op1, &unsigned1);
3335 /* UNS is 1 if the operation to be done is an unsigned one. */
3336 int uns = TREE_UNSIGNED (result_type);
3339 final_type = result_type;
3341 /* Handle the case that OP0 does not *contain* a conversion
3342 but it *requires* conversion to FINAL_TYPE. */
3344 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3345 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3346 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3347 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3349 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3351 /* For bitwise operations, signedness of nominal type
3352 does not matter. Consider only how operands were extended. */
3356 /* Note that in all three cases below we refrain from optimizing
3357 an unsigned operation on sign-extended args.
3358 That would not be valid. */
3360 /* Both args variable: if both extended in same way
3361 from same width, do it in that width.
3362 Do it unsigned if args were zero-extended. */
3363 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3364 < TYPE_PRECISION (result_type))
3365 && (TYPE_PRECISION (TREE_TYPE (arg1))
3366 == TYPE_PRECISION (TREE_TYPE (arg0)))
3367 && unsigned0 == unsigned1
3368 && (unsigned0 || !uns))
3369 result_type = c_common_signed_or_unsigned_type
3370 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3371 else if (TREE_CODE (arg0) == INTEGER_CST
3372 && (unsigned1 || !uns)
3373 && (TYPE_PRECISION (TREE_TYPE (arg1))
3374 < TYPE_PRECISION (result_type))
3375 && (type = c_common_signed_or_unsigned_type
3376 (unsigned1, TREE_TYPE (arg1)),
3377 int_fits_type_p (arg0, type)))
3379 else if (TREE_CODE (arg1) == INTEGER_CST
3380 && (unsigned0 || !uns)
3381 && (TYPE_PRECISION (TREE_TYPE (arg0))
3382 < TYPE_PRECISION (result_type))
3383 && (type = c_common_signed_or_unsigned_type
3384 (unsigned0, TREE_TYPE (arg0)),
3385 int_fits_type_p (arg1, type)))
3389 /* Shifts can be shortened if shifting right. */
3394 tree arg0 = get_narrower (op0, &unsigned_arg);
3396 final_type = result_type;
3398 if (arg0 == op0 && final_type == TREE_TYPE (op0))
3399 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3401 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3402 /* We can shorten only if the shift count is less than the
3403 number of bits in the smaller type size. */
3404 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3405 /* If arg is sign-extended and then unsigned-shifted,
3406 we can simulate this with a signed shift in arg's type
3407 only if the extended result is at least twice as wide
3408 as the arg. Otherwise, the shift could use up all the
3409 ones made by sign-extension and bring in zeros.
3410 We can't optimize that case at all, but in most machines
3411 it never happens because available widths are 2**N. */
3412 && (!TREE_UNSIGNED (final_type)
3414 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3415 <= TYPE_PRECISION (result_type))))
3417 /* Do an unsigned shift if the operand was zero-extended. */
3419 = c_common_signed_or_unsigned_type (unsigned_arg,
3421 /* Convert value-to-be-shifted to that type. */
3422 if (TREE_TYPE (op0) != result_type)
3423 op0 = cp_convert (result_type, op0);
3428 /* Comparison operations are shortened too but differently.
3429 They identify themselves by setting short_compare = 1. */
3433 /* Don't write &op0, etc., because that would prevent op0
3434 from being kept in a register.
3435 Instead, make copies of the our local variables and
3436 pass the copies by reference, then copy them back afterward. */
3437 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3438 enum tree_code xresultcode = resultcode;
3440 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3442 return cp_convert (boolean_type_node, val);
3443 op0 = xop0, op1 = xop1;
3445 resultcode = xresultcode;
3448 if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3449 && warn_sign_compare
3450 /* Do not warn until the template is instantiated; we cannot
3451 bound the ranges of the arguments until that point. */
3452 && !processing_template_decl)
3454 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
3455 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
3457 int unsignedp0, unsignedp1;
3458 tree primop0 = get_narrower (op0, &unsignedp0);
3459 tree primop1 = get_narrower (op1, &unsignedp1);
3461 /* Check for comparison of different enum types. */
3462 if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3463 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3464 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3465 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3467 warning ("comparison between types `%#T' and `%#T'",
3468 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3471 /* Give warnings for comparisons between signed and unsigned
3472 quantities that may fail. */
3473 /* Do the checking based on the original operand trees, so that
3474 casts will be considered, but default promotions won't be. */
3476 /* Do not warn if the comparison is being done in a signed type,
3477 since the signed type will only be chosen if it can represent
3478 all the values of the unsigned type. */
3479 if (! TREE_UNSIGNED (result_type))
3481 /* Do not warn if both operands are unsigned. */
3482 else if (op0_signed == op1_signed)
3484 /* Do not warn if the signed quantity is an unsuffixed
3485 integer literal (or some static constant expression
3486 involving such literals or a conditional expression
3487 involving such literals) and it is non-negative. */
3488 else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3489 || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3491 /* Do not warn if the comparison is an equality operation,
3492 the unsigned quantity is an integral constant and it does
3493 not use the most significant bit of result_type. */
3494 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3495 && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3496 && int_fits_type_p (orig_op1, c_common_signed_type
3498 || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3499 && int_fits_type_p (orig_op0, c_common_signed_type
3503 warning ("comparison between signed and unsigned integer expressions");
3505 /* Warn if two unsigned values are being compared in a size
3506 larger than their original size, and one (and only one) is the
3507 result of a `~' operator. This comparison will always fail.
3509 Also warn if one operand is a constant, and the constant does not
3510 have all bits set that are set in the ~ operand when it is
3513 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3514 ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3516 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3517 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3518 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3519 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3521 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3524 HOST_WIDE_INT constant, mask;
3528 if (host_integerp (primop0, 0))
3531 unsignedp = unsignedp1;
3532 constant = tree_low_cst (primop0, 0);
3537 unsignedp = unsignedp0;
3538 constant = tree_low_cst (primop1, 0);
3541 bits = TYPE_PRECISION (TREE_TYPE (primop));
3542 if (bits < TYPE_PRECISION (result_type)
3543 && bits < HOST_BITS_PER_LONG && unsignedp)
3545 mask = (~ (HOST_WIDE_INT) 0) << bits;
3546 if ((mask & constant) != mask)
3547 warning ("comparison of promoted ~unsigned with constant");
3550 else if (unsignedp0 && unsignedp1
3551 && (TYPE_PRECISION (TREE_TYPE (primop0))
3552 < TYPE_PRECISION (result_type))
3553 && (TYPE_PRECISION (TREE_TYPE (primop1))
3554 < TYPE_PRECISION (result_type)))
3555 warning ("comparison of promoted ~unsigned with unsigned");
3560 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3561 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3562 Then the expression will be built.
3563 It will be given type FINAL_TYPE if that is nonzero;
3564 otherwise, it will be given type RESULT_TYPE. */
3568 error ("invalid operands of types `%T' and `%T' to binary `%O'",
3569 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3570 return error_mark_node;
3573 /* Issue warnings about peculiar, but valid, uses of NULL. */
3574 if (/* It's reasonable to use pointer values as operands of &&
3575 and ||, so NULL is no exception. */
3576 !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3577 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3578 (orig_op0 == null_node
3579 && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3580 /* Or vice versa. */
3581 || (orig_op1 == null_node
3582 && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3583 /* Or, both are NULL and the operation was not a comparison. */
3584 || (orig_op0 == null_node && orig_op1 == null_node
3585 && code != EQ_EXPR && code != NE_EXPR)))
3586 /* Some sort of arithmetic operation involving NULL was
3587 performed. Note that pointer-difference and pointer-addition
3588 have already been handled above, and so we don't end up here in
3590 warning ("NULL used in arithmetic");
3594 if (TREE_TYPE (op0) != result_type)
3595 op0 = cp_convert (result_type, op0);
3596 if (TREE_TYPE (op1) != result_type)
3597 op1 = cp_convert (result_type, op1);
3599 if (op0 == error_mark_node || op1 == error_mark_node)
3600 return error_mark_node;
3603 if (build_type == NULL_TREE)
3604 build_type = result_type;
3607 register tree result = build (resultcode, build_type, op0, op1);
3608 register tree folded;
3610 folded = fold (result);
3611 if (folded == result)
3612 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3613 if (final_type != 0)
3614 return cp_convert (final_type, folded);
3619 /* Return a tree for the sum or difference (RESULTCODE says which)
3620 of pointer PTROP and integer INTOP. */
3623 cp_pointer_int_sum (enum tree_code resultcode, register tree ptrop,
3624 register tree intop)
3626 tree res_type = TREE_TYPE (ptrop);
3628 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3629 in certain circumstance (when it's valid to do so). So we need
3630 to make sure it's complete. We don't need to check here, if we
3631 can actually complete it at all, as those checks will be done in
3632 pointer_int_sum() anyway. */
3633 complete_type (TREE_TYPE (res_type));
3635 return pointer_int_sum (resultcode, ptrop, fold (intop));
3638 /* Return a tree for the difference of pointers OP0 and OP1.
3639 The resulting tree has type int. */
3642 pointer_diff (register tree op0, register tree op1, register tree ptrtype)
3644 register tree result, folded;
3645 tree restype = ptrdiff_type_node;
3646 tree target_type = TREE_TYPE (ptrtype);
3648 if (!complete_type_or_else (target_type, NULL_TREE))
3649 return error_mark_node;
3651 if (pedantic || warn_pointer_arith)
3653 if (TREE_CODE (target_type) == VOID_TYPE)
3654 pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
3655 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3656 pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3657 if (TREE_CODE (target_type) == METHOD_TYPE)
3658 pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3659 if (TREE_CODE (target_type) == OFFSET_TYPE)
3660 pedwarn ("ISO C++ forbids using pointer to a member in subtraction");
3663 /* First do the subtraction as integers;
3664 then drop through to build the divide operator. */
3666 op0 = cp_build_binary_op (MINUS_EXPR,
3667 cp_convert (restype, op0),
3668 cp_convert (restype, op1));
3670 /* This generates an error if op1 is a pointer to an incomplete type. */
3671 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3672 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3674 op1 = ((TREE_CODE (target_type) == VOID_TYPE
3675 || TREE_CODE (target_type) == FUNCTION_TYPE
3676 || TREE_CODE (target_type) == METHOD_TYPE
3677 || TREE_CODE (target_type) == OFFSET_TYPE)
3679 : size_in_bytes (target_type));
3681 /* Do the division. */
3683 result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3685 folded = fold (result);
3686 if (folded == result)
3687 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3691 /* Construct and perhaps optimize a tree representation
3692 for a unary operation. CODE, a tree_code, specifies the operation
3693 and XARG is the operand. */
3696 build_x_unary_op (enum tree_code code, tree xarg)
3698 tree orig_expr = xarg;
3702 if (processing_template_decl)
3704 if (type_dependent_expression_p (xarg))
3705 return build_min_nt (code, xarg, NULL_TREE);
3706 xarg = build_non_dependent_expr (xarg);
3711 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3713 if (code == ADDR_EXPR
3714 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3715 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg)))
3716 && !COMPLETE_TYPE_P (TREE_TYPE (xarg)))
3717 || (TREE_CODE (xarg) == OFFSET_REF)))
3718 /* don't look for a function */;
3720 exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE);
3721 if (!exp && code == ADDR_EXPR)
3723 /* A pointer to member-function can be formed only by saying
3725 if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3726 && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3728 if (TREE_CODE (xarg) != OFFSET_REF)
3730 error ("invalid use of '%E' to form a pointer-to-member-function. Use a qualified-id.",
3732 return error_mark_node;
3736 error ("parenthesis around '%E' cannot be used to form a pointer-to-member-function",
3738 PTRMEM_OK_P (xarg) = 1;
3742 if (TREE_CODE (xarg) == OFFSET_REF)
3744 ptrmem = PTRMEM_OK_P (xarg);
3746 if (!ptrmem && !flag_ms_extensions
3747 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3749 /* A single non-static member, make sure we don't allow a
3750 pointer-to-member. */
3751 xarg = build (OFFSET_REF, TREE_TYPE (xarg),
3752 TREE_OPERAND (xarg, 0),
3753 ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3754 PTRMEM_OK_P (xarg) = ptrmem;
3757 else if (TREE_CODE (xarg) == TARGET_EXPR)
3758 warning ("taking address of temporary");
3759 exp = build_unary_op (ADDR_EXPR, xarg, 0);
3760 if (TREE_CODE (exp) == ADDR_EXPR)
3761 PTRMEM_OK_P (exp) = ptrmem;
3764 if (processing_template_decl && exp != error_mark_node)
3765 return build_min (code, TREE_TYPE (exp), orig_expr, NULL_TREE);
3769 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3770 constants, where a null value is represented by an INTEGER_CST of
3774 cp_truthvalue_conversion (tree expr)
3776 tree type = TREE_TYPE (expr);
3777 if (TYPE_PTRMEM_P (type))
3778 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3780 return c_common_truthvalue_conversion (expr);
3783 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
3786 condition_conversion (tree expr)
3789 if (processing_template_decl)
3791 t = perform_implicit_conversion (boolean_type_node, expr);
3792 t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
3796 /* Return an ADDR_EXPR giving the address of T. This function
3797 attempts no optimizations or simplifications; it is a low-level
3801 build_address (tree t)
3805 if (error_operand_p (t) || !cxx_mark_addressable (t))
3806 return error_mark_node;
3808 addr = build1 (ADDR_EXPR,
3809 build_pointer_type (TREE_TYPE (t)),
3812 TREE_CONSTANT (addr) = 1;
3817 /* Return a NOP_EXPR converting EXPR to TYPE. */
3820 build_nop (tree type, tree expr)
3824 if (type == error_mark_node || error_operand_p (expr))
3827 nop = build1 (NOP_EXPR, type, expr);
3828 if (TREE_CONSTANT (expr))
3829 TREE_CONSTANT (nop) = 1;
3834 /* C++: Must handle pointers to members.
3836 Perhaps type instantiation should be extended to handle conversion
3837 from aggregates to types we don't yet know we want? (Or are those
3838 cases typically errors which should be reported?)
3840 NOCONVERT nonzero suppresses the default promotions
3841 (such as from short to int). */
3844 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3846 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3847 register tree arg = xarg;
3848 register tree argtype = 0;
3849 const char *errstring = NULL;
3852 if (arg == error_mark_node)
3853 return error_mark_node;
3858 /* This is used for unary plus, because a CONVERT_EXPR
3859 is enough to prevent anybody from looking inside for
3860 associativity, but won't generate any code. */
3861 if (!(arg = build_expr_type_conversion
3862 (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, true)))
3863 errstring = "wrong type argument to unary plus";
3867 arg = default_conversion (arg);
3868 arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3869 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3874 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3875 errstring = "wrong type argument to unary minus";
3876 else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3877 arg = perform_integral_promotions (arg);
3881 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3885 arg = default_conversion (arg);
3887 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3889 errstring = "wrong type argument to bit-complement";
3890 else if (!noconvert)
3891 arg = perform_integral_promotions (arg);
3895 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3896 errstring = "wrong type argument to abs";
3897 else if (!noconvert)
3898 arg = default_conversion (arg);
3902 /* Conjugating a real value is a no-op, but allow it anyway. */
3903 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3904 errstring = "wrong type argument to conjugation";
3905 else if (!noconvert)
3906 arg = default_conversion (arg);
3909 case TRUTH_NOT_EXPR:
3910 arg = cp_convert (boolean_type_node, arg);
3911 val = invert_truthvalue (arg);
3912 if (arg != error_mark_node)
3914 errstring = "in argument to unary !";
3921 if (TREE_CODE (arg) == COMPLEX_CST)
3922 return TREE_REALPART (arg);
3923 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3924 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3929 if (TREE_CODE (arg) == COMPLEX_CST)
3930 return TREE_IMAGPART (arg);
3931 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3932 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3934 return cp_convert (TREE_TYPE (arg), integer_zero_node);
3936 case PREINCREMENT_EXPR:
3937 case POSTINCREMENT_EXPR:
3938 case PREDECREMENT_EXPR:
3939 case POSTDECREMENT_EXPR:
3940 /* Handle complex lvalues (when permitted)
3941 by reduction to simpler cases. */
3943 val = unary_complex_lvalue (code, arg);
3947 /* Increment or decrement the real part of the value,
3948 and don't change the imaginary part. */
3949 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3953 arg = stabilize_reference (arg);
3954 real = build_unary_op (REALPART_EXPR, arg, 1);
3955 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3956 return build (COMPLEX_EXPR, TREE_TYPE (arg),
3957 build_unary_op (code, real, 1), imag);
3960 /* Report invalid types. */
3962 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3965 if (code == PREINCREMENT_EXPR)
3966 errstring ="no pre-increment operator for type";
3967 else if (code == POSTINCREMENT_EXPR)
3968 errstring ="no post-increment operator for type";
3969 else if (code == PREDECREMENT_EXPR)
3970 errstring ="no pre-decrement operator for type";
3972 errstring ="no post-decrement operator for type";
3976 /* Report something read-only. */
3978 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3979 || TREE_READONLY (arg))
3980 readonly_error (arg, ((code == PREINCREMENT_EXPR
3981 || code == POSTINCREMENT_EXPR)
3982 ? "increment" : "decrement"),
3987 tree result_type = TREE_TYPE (arg);
3989 arg = get_unwidened (arg, 0);
3990 argtype = TREE_TYPE (arg);
3992 /* ARM $5.2.5 last annotation says this should be forbidden. */
3993 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3994 pedwarn ("ISO C++ forbids %sing an enum",
3995 (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3996 ? "increment" : "decrement");
3998 /* Compute the increment. */
4000 if (TREE_CODE (argtype) == POINTER_TYPE)
4002 enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
4003 tree type = complete_type (TREE_TYPE (argtype));
4005 if (!COMPLETE_OR_VOID_TYPE_P (type))
4006 error ("cannot %s a pointer to incomplete type `%T'",
4007 ((code == PREINCREMENT_EXPR
4008 || code == POSTINCREMENT_EXPR)
4009 ? "increment" : "decrement"), TREE_TYPE (argtype));
4010 else if ((pedantic || warn_pointer_arith)
4011 && (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
4012 || tmp == VOID_TYPE || tmp == OFFSET_TYPE))
4013 pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
4014 ((code == PREINCREMENT_EXPR
4015 || code == POSTINCREMENT_EXPR)
4016 ? "increment" : "decrement"), argtype);
4017 inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4020 inc = integer_one_node;
4022 inc = cp_convert (argtype, inc);
4024 /* Handle incrementing a cast-expression. */
4026 switch (TREE_CODE (arg))
4031 case FIX_TRUNC_EXPR:
4032 case FIX_FLOOR_EXPR:
4033 case FIX_ROUND_EXPR:
4036 tree incremented, modify, value, compound;
4037 if (! lvalue_p (arg) && pedantic)
4038 pedwarn ("cast to non-reference type used as lvalue");
4039 arg = stabilize_reference (arg);
4040 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
4043 value = save_expr (arg);
4044 incremented = build (((code == PREINCREMENT_EXPR
4045 || code == POSTINCREMENT_EXPR)
4046 ? PLUS_EXPR : MINUS_EXPR),
4047 argtype, value, inc);
4049 modify = build_modify_expr (arg, NOP_EXPR, incremented);
4050 compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
4052 /* Eliminate warning about unused result of + or -. */
4053 TREE_NO_UNUSED_WARNING (compound) = 1;
4061 /* Complain about anything else that is not a true lvalue. */
4062 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4063 || code == POSTINCREMENT_EXPR)
4064 ? "increment" : "decrement")))
4065 return error_mark_node;
4067 /* Forbid using -- on `bool'. */
4068 if (TREE_TYPE (arg) == boolean_type_node)
4070 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4072 error ("invalid use of `--' on bool variable `%D'", arg);
4073 return error_mark_node;
4076 /* This will only work if someone can convince Kenner to accept
4077 my patch to expand_increment. (jason) */
4078 val = build (code, TREE_TYPE (arg), arg, inc);
4080 val = boolean_increment (code, arg);
4084 val = build (code, TREE_TYPE (arg), arg, inc);
4086 TREE_SIDE_EFFECTS (val) = 1;
4087 return cp_convert (result_type, val);
4091 /* Note that this operation never does default_conversion
4092 regardless of NOCONVERT. */
4094 argtype = lvalue_type (arg);
4095 if (TREE_CODE (argtype) == REFERENCE_TYPE)
4099 build_pointer_type (TREE_TYPE (argtype)), arg);
4100 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4103 else if (pedantic && DECL_MAIN_P (arg))
4105 pedwarn ("ISO C++ forbids taking address of function `::main'");
4107 /* Let &* cancel out to simplify resulting code. */
4108 if (TREE_CODE (arg) == INDIRECT_REF)
4110 /* We don't need to have `current_class_ptr' wrapped in a
4111 NON_LVALUE_EXPR node. */
4112 if (arg == current_class_ref)
4113 return current_class_ptr;
4115 arg = TREE_OPERAND (arg, 0);
4116 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4120 build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
4121 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4123 else if (lvalue_p (arg))
4124 /* Don't let this be an lvalue. */
4125 return non_lvalue (arg);
4129 /* For &x[y], return x+y */
4130 if (TREE_CODE (arg) == ARRAY_REF)
4132 if (!cxx_mark_addressable (TREE_OPERAND (arg, 0)))
4133 return error_mark_node;
4134 return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4135 TREE_OPERAND (arg, 1));
4138 /* Uninstantiated types are all functions. Taking the
4139 address of a function is a no-op, so just return the
4142 if (TREE_CODE (arg) == IDENTIFIER_NODE
4143 && IDENTIFIER_OPNAME_P (arg))
4146 /* We don't know the type yet, so just work around the problem.
4147 We know that this will resolve to an lvalue. */
4148 return build1 (ADDR_EXPR, unknown_type_node, arg);
4151 if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4152 && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4154 /* They're trying to take the address of a unique non-static
4155 member function. This is ill-formed (except in MS-land),
4156 but let's try to DTRT.
4157 Note: We only handle unique functions here because we don't
4158 want to complain if there's a static overload; non-unique
4159 cases will be handled by instantiate_type. But we need to
4160 handle this case here to allow casts on the resulting PMF.
4161 We could defer this in non-MS mode, but it's easier to give
4162 a useful error here. */
4164 /* Inside constant member functions, the `this' pointer
4165 contains an extra const qualifier. TYPE_MAIN_VARIANT
4166 is used here to remove this const from the diagnostics
4167 and the created OFFSET_REF. */
4168 tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4169 tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4171 if (! flag_ms_extensions)
4173 if (current_class_type
4174 && TREE_OPERAND (arg, 0) == current_class_ref)
4175 /* An expression like &memfn. */
4176 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4177 " or parenthesized non-static member function to form"
4178 " a pointer to member function. Say `&%T::%D'",
4181 pedwarn ("ISO C++ forbids taking the address of a bound member"
4182 " function to form a pointer to member function."
4186 arg = build_offset_ref (base, name);
4189 if (type_unknown_p (arg))
4190 return build1 (ADDR_EXPR, unknown_type_node, arg);
4192 /* Handle complex lvalues (when permitted)
4193 by reduction to simpler cases. */
4194 val = unary_complex_lvalue (code, arg);
4198 switch (TREE_CODE (arg))
4203 case FIX_TRUNC_EXPR:
4204 case FIX_FLOOR_EXPR:
4205 case FIX_ROUND_EXPR:
4207 if (! lvalue_p (arg) && pedantic)
4208 pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4215 /* Allow the address of a constructor if all the elements
4217 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4218 && TREE_CONSTANT (arg))
4220 /* Anything not already handled and not a true memory reference
4222 else if (TREE_CODE (argtype) != FUNCTION_TYPE
4223 && TREE_CODE (argtype) != METHOD_TYPE
4224 && !non_cast_lvalue_or_else (arg, "unary `&'"))
4225 return error_mark_node;
4227 if (argtype != error_mark_node)
4228 argtype = build_pointer_type (argtype);
4233 if (TREE_CODE (arg) == COMPONENT_REF
4234 && TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4235 arg = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4237 if (TREE_CODE (arg) != COMPONENT_REF)
4238 addr = build_address (arg);
4239 else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4241 error ("attempt to take address of bit-field structure member `%D'",
4242 TREE_OPERAND (arg, 1));
4243 return error_mark_node;
4247 /* Unfortunately we cannot just build an address
4248 expression here, because we would not handle
4249 address-constant-expressions or offsetof correctly. */
4250 tree field = TREE_OPERAND (arg, 1);
4251 tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4252 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
4253 decl_type_context (field),
4256 rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
4257 rval = build1 (NOP_EXPR, argtype, rval);
4258 TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
4259 addr = fold (build (PLUS_EXPR, argtype, rval,
4260 cp_convert (argtype, byte_position (field))));
4263 if (TREE_CODE (argtype) == POINTER_TYPE
4264 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4266 build_ptrmemfunc_type (argtype);
4267 addr = build_ptrmemfunc (argtype, addr, 0);
4280 argtype = TREE_TYPE (arg);
4281 return fold (build1 (code, argtype, arg));
4284 error ("%s", errstring);
4285 return error_mark_node;
4288 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4289 for certain kinds of expressions which are not really lvalues
4290 but which we can accept as lvalues.
4292 If ARG is not a kind of expression we can handle, return zero. */
4295 unary_complex_lvalue (enum tree_code code, tree arg)
4297 /* Handle (a, b) used as an "lvalue". */
4298 if (TREE_CODE (arg) == COMPOUND_EXPR)
4300 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4301 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4302 TREE_OPERAND (arg, 0), real_result);
4305 /* Handle (a ? b : c) used as an "lvalue". */
4306 if (TREE_CODE (arg) == COND_EXPR
4307 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4308 return rationalize_conditional_expr (code, arg);
4310 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
4311 if (TREE_CODE (arg) == MODIFY_EXPR
4312 || TREE_CODE (arg) == PREINCREMENT_EXPR
4313 || TREE_CODE (arg) == PREDECREMENT_EXPR)
4315 tree lvalue = TREE_OPERAND (arg, 0);
4316 if (TREE_SIDE_EFFECTS (lvalue))
4318 lvalue = stabilize_reference (lvalue);
4319 arg = build (TREE_CODE (arg), TREE_TYPE (arg),
4320 lvalue, TREE_OPERAND (arg, 1));
4322 return unary_complex_lvalue
4323 (code, build (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4326 if (code != ADDR_EXPR)
4329 /* Handle (a = b) used as an "lvalue" for `&'. */
4330 if (TREE_CODE (arg) == MODIFY_EXPR
4331 || TREE_CODE (arg) == INIT_EXPR)
4333 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4334 arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4335 TREE_NO_UNUSED_WARNING (arg) = 1;
4339 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4340 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4341 || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
4343 /* The representation of something of type OFFSET_TYPE
4344 is really the representation of a pointer to it.
4345 Here give the representation its true type. */
4348 my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4350 if (TREE_CODE (arg) != OFFSET_REF)
4353 t = TREE_OPERAND (arg, 1);
4355 /* Check all this code for right semantics. */
4356 if (TREE_CODE (t) == FUNCTION_DECL)
4358 if (DECL_DESTRUCTOR_P (t))
4359 error ("taking address of destructor");
4360 return build_unary_op (ADDR_EXPR, t, 0);
4362 if (TREE_CODE (t) == VAR_DECL)
4363 return build_unary_op (ADDR_EXPR, t, 0);
4368 if (TREE_OPERAND (arg, 0)
4369 && ! is_dummy_object (TREE_OPERAND (arg, 0))
4370 && TREE_CODE (t) != FIELD_DECL)
4372 error ("taking address of bound pointer-to-member expression");
4373 return error_mark_node;
4375 if (!PTRMEM_OK_P (arg))
4376 return build_unary_op (code, arg, 0);
4378 if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4380 error ("cannot create pointer to reference member `%D'", t);
4381 return error_mark_node;
4384 type = build_ptrmem_type (DECL_FIELD_CONTEXT (t), TREE_TYPE (t));
4385 t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4391 /* We permit compiler to make function calls returning
4392 objects of aggregate type look like lvalues. */
4396 if (TREE_CODE (targ) == SAVE_EXPR)
4397 targ = TREE_OPERAND (targ, 0);
4399 if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4401 if (TREE_CODE (arg) == SAVE_EXPR)
4404 targ = build_cplus_new (TREE_TYPE (arg), arg);
4405 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4408 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4409 return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4410 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4413 /* Don't let anything else be handled specially. */
4417 /* Mark EXP saying that we need to be able to take the
4418 address of it; it should not be allocated in a register.
4419 Value is true if successful.
4421 C++: we do not allow `current_class_ptr' to be addressable. */
4424 cxx_mark_addressable (tree exp)
4426 register tree x = exp;
4429 switch (TREE_CODE (x))
4436 x = TREE_OPERAND (x, 0);
4440 if (x == current_class_ptr)
4442 error ("cannot take the address of `this', which is an rvalue expression");
4443 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */
4449 /* Caller should not be trying to mark initialized
4450 constant fields addressable. */
4451 my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4452 || DECL_IN_AGGR_P (x) == 0
4454 || DECL_EXTERNAL (x), 314);
4459 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4460 && !DECL_ARTIFICIAL (x) && extra_warnings)
4461 warning ("address requested for `%D', which is declared `register'",
4463 TREE_ADDRESSABLE (x) = 1;
4464 put_var_into_stack (x, /*rescan=*/true);
4468 TREE_ADDRESSABLE (x) = 1;
4469 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4473 TREE_ADDRESSABLE (x) = 1;
4477 TREE_ADDRESSABLE (x) = 1;
4478 cxx_mark_addressable (TREE_OPERAND (x, 0));
4486 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4489 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4491 tree orig_ifexp = ifexp;
4492 tree orig_op1 = op1;
4493 tree orig_op2 = op2;
4496 if (processing_template_decl)
4498 /* The standard says that the expression is type-dependent if
4499 IFEXP is type-dependent, even though the eventual type of the
4500 expression doesn't dependent on IFEXP. */
4501 if (type_dependent_expression_p (ifexp)
4502 || type_dependent_expression_p (op1)
4503 || type_dependent_expression_p (op2))
4504 return build_min_nt (COND_EXPR, ifexp, op1, op2);
4505 ifexp = build_non_dependent_expr (ifexp);
4506 op1 = build_non_dependent_expr (op1);
4507 op2 = build_non_dependent_expr (op2);
4510 expr = build_conditional_expr (ifexp, op1, op2);
4511 if (processing_template_decl && expr != error_mark_node)
4512 return build_min (COND_EXPR, TREE_TYPE (expr),
4513 orig_ifexp, orig_op1, orig_op2);
4517 /* Handle overloading of the ',' operator when needed. Otherwise,
4518 this function just builds an expression list. */
4521 build_x_compound_expr (tree op1, tree op2)
4524 tree orig_op1 = op1;
4525 tree orig_op2 = op2;
4527 if (processing_template_decl)
4529 if (type_dependent_expression_p (op1)
4530 || type_dependent_expression_p (op2))
4531 return build_min_nt (COMPOUND_EXPR, op1, op2);
4532 op1 = build_non_dependent_expr (op1);
4533 op2 = build_non_dependent_expr (op2);
4536 result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE);
4539 if (! TREE_SIDE_EFFECTS (op1))
4541 /* FIXME: This test should be in the implicit cast to void
4543 /* the left-hand operand of a comma expression is like an expression
4544 statement: we should warn if it doesn't have any side-effects,
4545 unless it was explicitly cast to (void). */
4546 if (warn_unused_value
4547 && !(TREE_CODE (op1) == CONVERT_EXPR
4548 && VOID_TYPE_P (TREE_TYPE (op1))))
4549 warning("left-hand operand of comma expression has no effect");
4551 result = build_compound_expr (tree_cons (NULL_TREE,
4553 build_tree_list (NULL_TREE,
4557 if (processing_template_decl && result != error_mark_node)
4558 return build_min (COMPOUND_EXPR, TREE_TYPE (result),
4559 orig_op1, orig_op2);
4563 /* Given a list of expressions, return a compound expression
4564 that performs them all and returns the value of the last of them. */
4567 build_compound_expr (tree list)
4572 TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list));
4574 if (TREE_CHAIN (list) == 0)
4576 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4577 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4578 if (TREE_CODE (list) == NOP_EXPR
4579 && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0)))
4580 list = TREE_OPERAND (list, 0);
4582 return TREE_VALUE (list);
4585 first = TREE_VALUE (list);
4586 first = convert_to_void (first, "left-hand operand of comma");
4587 if (first == error_mark_node)
4588 return error_mark_node;
4590 rest = build_compound_expr (TREE_CHAIN (list));
4591 if (rest == error_mark_node)
4592 return error_mark_node;
4594 /* When pedantic, a compound expression cannot be a constant expression. */
4595 if (! TREE_SIDE_EFFECTS (first) && ! pedantic)
4598 return build (COMPOUND_EXPR, TREE_TYPE (rest), first, rest);
4601 /* Issue an error message if casting from SRC_TYPE to DEST_TYPE casts
4605 check_for_casting_away_constness (tree src_type, tree dest_type)
4607 if (casts_away_constness (src_type, dest_type))
4608 error ("static_cast from type `%T' to type `%T' casts away constness",
4609 src_type, dest_type);
4612 /* Return an expression representing static_cast<TYPE>(EXPR). */
4615 build_static_cast (tree type, tree expr)
4620 if (type == error_mark_node || expr == error_mark_node)
4621 return error_mark_node;
4623 if (processing_template_decl)
4625 tree t = build_min (STATIC_CAST_EXPR, type, expr);
4629 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4630 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4631 if (TREE_CODE (type) != REFERENCE_TYPE
4632 && TREE_CODE (expr) == NOP_EXPR
4633 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4634 expr = TREE_OPERAND (expr, 0);
4636 intype = TREE_TYPE (expr);
4638 /* [expr.static.cast]
4640 An lvalue of type "cv1 B", where B is a class type, can be cast
4641 to type "reference to cv2 D", where D is a class derived (clause
4642 _class.derived_) from B, if a valid standard conversion from
4643 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4644 same cv-qualification as, or greater cv-qualification than, cv1,
4645 and B is not a virtual base class of D. */
4646 /* We check this case before checking the validity of "TYPE t =
4647 EXPR;" below because for this case:
4650 struct D : public B { D(const B&); };
4652 void f() { static_cast<const D&>(b); }
4654 we want to avoid constructing a new D. The standard is not
4655 completely clear about this issue, but our interpretation is
4656 consistent with other compilers. */
4657 if (TREE_CODE (type) == REFERENCE_TYPE
4658 && CLASS_TYPE_P (TREE_TYPE (type))
4659 && CLASS_TYPE_P (intype)
4660 && real_non_cast_lvalue_p (expr)
4661 && DERIVED_FROM_P (intype, TREE_TYPE (type))
4662 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4663 build_pointer_type (TYPE_MAIN_VARIANT
4664 (TREE_TYPE (type))))
4665 && at_least_as_qualified_p (TREE_TYPE (type), intype))
4667 /* At this point we have checked all of the conditions except
4668 that B is not a virtual base class of D. That will be
4669 checked by build_base_path. */
4670 tree base = lookup_base (TREE_TYPE (type), intype, ba_any, NULL);
4672 /* Convert from B* to D*. */
4673 expr = build_base_path (MINUS_EXPR, build_address (expr),
4674 base, /*nonnull=*/false);
4675 /* Convert the pointer to a reference -- but then remember that
4676 there are no expressions with reference type in C++. */
4677 return convert_from_reference (build_nop (type, expr));
4680 /* [expr.static.cast]
4682 An expression e can be explicitly converted to a type T using a
4683 static_cast of the form static_cast<T>(e) if the declaration T
4684 t(e);" is well-formed, for some invented temporary variable
4686 result = perform_direct_initialization_if_possible (type, expr);
4688 return convert_from_reference (result);
4690 /* [expr.static.cast]
4692 Any expression can be explicitly converted to type cv void. */
4693 if (TREE_CODE (type) == VOID_TYPE)
4694 return convert_to_void (expr, /*implicit=*/NULL);
4696 /* [expr.static.cast]
4698 The inverse of any standard conversion sequence (clause _conv_),
4699 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4700 (_conv.array_), function-to-pointer (_conv.func_), and boolean
4701 (_conv.bool_) conversions, can be performed explicitly using
4702 static_cast subject to the restriction that the explicit
4703 conversion does not cast away constness (_expr.const.cast_), and
4704 the following additional rules for specific cases: */
4705 /* For reference, the conversions not excluded are: integral
4706 promotions, floating point promotion, integral conversions,
4707 floating point conversions, floating-integral conversions,
4708 pointer conversions, and pointer to member conversions. */
4709 if ((ARITHMETIC_TYPE_P (type) && ARITHMETIC_TYPE_P (intype))
4712 A value of integral _or enumeration_ type can be explicitly
4713 converted to an enumeration type. */
4714 || (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
4715 && INTEGRAL_OR_ENUMERATION_TYPE_P (intype)))
4716 /* Really, build_c_cast should defer to this function rather
4717 than the other way around. */
4718 return build_c_cast (type, expr);
4719 if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4720 && CLASS_TYPE_P (TREE_TYPE (type))
4721 && CLASS_TYPE_P (TREE_TYPE (intype))
4722 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4723 (TREE_TYPE (intype))),
4724 build_pointer_type (TYPE_MAIN_VARIANT
4725 (TREE_TYPE (type)))))
4729 check_for_casting_away_constness (intype, type);
4730 base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4731 ba_check | ba_quiet, NULL);
4732 return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4734 if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4735 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4742 c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4743 c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4745 if (TYPE_PTRMEM_P (type))
4747 t1 = (build_ptrmem_type
4749 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4750 t2 = (build_ptrmem_type
4752 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4759 if (can_convert (t1, t2))
4761 check_for_casting_away_constness (intype, type);
4762 if (TYPE_PTRMEM_P (type))
4764 if (TREE_CODE (expr) == PTRMEM_CST)
4765 expr = cplus_expand_constant (expr);
4766 expr = cp_build_binary_op (PLUS_EXPR,
4767 cp_convert (ptrdiff_type_node, expr),
4768 get_delta_difference (c1, c2,
4770 return build_nop (type, expr);
4773 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4778 /* [expr.static.cast]
4780 An rvalue of type "pointer to cv void" can be explicitly
4781 converted to a pointer to object type. A value of type pointer
4782 to object converted to "pointer to cv void" and back to the
4783 original pointer type will have its original value. */
4784 if (TREE_CODE (intype) == POINTER_TYPE
4785 && VOID_TYPE_P (TREE_TYPE (intype))
4786 && TYPE_PTROB_P (type))
4788 check_for_casting_away_constness (intype, type);
4789 return build_nop (type, expr);
4792 error ("invalid static_cast from type `%T' to type `%T'", intype, type);
4793 return error_mark_node;
4797 build_reinterpret_cast (tree type, tree expr)
4801 if (type == error_mark_node || expr == error_mark_node)
4802 return error_mark_node;
4804 if (processing_template_decl)
4806 tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4810 if (TREE_CODE (type) != REFERENCE_TYPE)
4812 expr = decay_conversion (expr);
4814 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4815 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4816 if (TREE_CODE (expr) == NOP_EXPR
4817 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4818 expr = TREE_OPERAND (expr, 0);
4821 intype = TREE_TYPE (expr);
4823 if (TREE_CODE (type) == REFERENCE_TYPE)
4825 if (! real_lvalue_p (expr))
4827 error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
4828 return error_mark_node;
4830 expr = build_unary_op (ADDR_EXPR, expr, 0);
4831 if (expr != error_mark_node)
4832 expr = build_reinterpret_cast
4833 (build_pointer_type (TREE_TYPE (type)), expr);
4834 if (expr != error_mark_node)
4835 expr = build_indirect_ref (expr, 0);
4838 else if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4839 return build_static_cast (type, expr);
4841 if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE
4842 || TREE_CODE (intype) == ENUMERAL_TYPE))
4844 else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
4846 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
4847 pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
4850 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
4851 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4853 expr = decl_constant_value (expr);
4854 return fold (build1 (NOP_EXPR, type, expr));
4856 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4857 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
4859 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type), TREE_TYPE (intype)))
4860 pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
4863 expr = decl_constant_value (expr);
4864 return fold (build1 (NOP_EXPR, type, expr));
4866 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
4867 || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
4869 pedwarn ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
4870 expr = decl_constant_value (expr);
4871 return fold (build1 (NOP_EXPR, type, expr));
4875 error ("invalid reinterpret_cast from type `%T' to type `%T'",
4877 return error_mark_node;
4880 return cp_convert (type, expr);
4884 build_const_cast (tree type, tree expr)
4888 if (type == error_mark_node || expr == error_mark_node)
4889 return error_mark_node;
4891 if (processing_template_decl)
4893 tree t = build_min (CONST_CAST_EXPR, type, expr);
4897 if (!POINTER_TYPE_P (type))
4898 error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
4899 else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4901 error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
4902 return error_mark_node;
4905 if (TREE_CODE (type) != REFERENCE_TYPE)
4907 expr = decay_conversion (expr);
4909 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4910 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4911 if (TREE_CODE (expr) == NOP_EXPR
4912 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4913 expr = TREE_OPERAND (expr, 0);
4916 intype = TREE_TYPE (expr);
4918 if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4919 return build_static_cast (type, expr);
4920 else if (TREE_CODE (type) == REFERENCE_TYPE)
4922 if (! real_lvalue_p (expr))
4924 error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
4925 return error_mark_node;
4928 if (comp_ptr_ttypes_const (TREE_TYPE (type), intype))
4930 expr = build_unary_op (ADDR_EXPR, expr, 0);
4931 expr = build1 (NOP_EXPR, type, expr);
4932 return convert_from_reference (expr);
4935 else if (TREE_CODE (type) == POINTER_TYPE
4936 && TREE_CODE (intype) == POINTER_TYPE
4937 && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
4938 return cp_convert (type, expr);
4940 error ("invalid const_cast from type `%T' to type `%T'", intype, type);
4941 return error_mark_node;
4944 /* Build an expression representing a cast to type TYPE of expression EXPR.
4946 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
4947 when doing the cast. */
4950 build_c_cast (tree type, tree expr)
4952 register tree value = expr;
4955 if (type == error_mark_node || expr == error_mark_node)
4956 return error_mark_node;
4958 if (processing_template_decl)
4960 tree t = build_min (CAST_EXPR, type,
4961 tree_cons (NULL_TREE, value, NULL_TREE));
4965 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4966 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
4967 if (TREE_CODE (type) != REFERENCE_TYPE
4968 && TREE_CODE (value) == NOP_EXPR
4969 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
4970 value = TREE_OPERAND (value, 0);
4972 if (TREE_CODE (type) == ARRAY_TYPE)
4974 /* Allow casting from T1* to T2[] because Cfront allows it.
4975 NIHCL uses it. It is not valid ISO C++ however. */
4976 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
4978 pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
4979 type = build_pointer_type (TREE_TYPE (type));
4983 error ("ISO C++ forbids casting to an array type `%T'", type);
4984 return error_mark_node;
4988 if (TREE_CODE (type) == FUNCTION_TYPE
4989 || TREE_CODE (type) == METHOD_TYPE)
4991 error ("invalid cast to function type `%T'", type);
4992 return error_mark_node;
4995 if (TREE_CODE (type) == VOID_TYPE)
4997 /* Conversion to void does not cause any of the normal function to
4998 * pointer, array to pointer and lvalue to rvalue decays. */
5000 value = convert_to_void (value, /*implicit=*/NULL);
5004 if (!complete_type_or_else (type, NULL_TREE))
5005 return error_mark_node;
5007 /* Convert functions and arrays to pointers and
5008 convert references to their expanded types,
5009 but don't convert any other types. If, however, we are
5010 casting to a class type, there's no reason to do this: the
5011 cast will only succeed if there is a converting constructor,
5012 and the default conversions will be done at that point. In
5013 fact, doing the default conversion here is actually harmful
5017 struct S { S(const A&); };
5019 since we don't want the array-to-pointer conversion done. */
5020 if (!IS_AGGR_TYPE (type))
5022 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5023 || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
5024 /* Don't do the default conversion on a ->* expression. */
5025 && ! (TREE_CODE (type) == POINTER_TYPE
5026 && bound_pmf_p (value)))
5027 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5028 || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5029 value = decay_conversion (value);
5031 else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5032 /* However, even for class types, we still need to strip away
5033 the reference type, since the call to convert_force below
5034 does not expect the input expression to be of reference
5036 value = convert_from_reference (value);
5038 otype = TREE_TYPE (value);
5040 /* Optionally warn about potentially worrisome casts. */
5043 && TREE_CODE (type) == POINTER_TYPE
5044 && TREE_CODE (otype) == POINTER_TYPE
5045 && !at_least_as_qualified_p (TREE_TYPE (type),
5047 warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
5050 if (TREE_CODE (type) == INTEGER_TYPE
5051 && TREE_CODE (otype) == POINTER_TYPE
5052 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
5053 warning ("cast from pointer to integer of different size");
5055 if (TREE_CODE (type) == POINTER_TYPE
5056 && TREE_CODE (otype) == INTEGER_TYPE
5057 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
5058 /* Don't warn about converting any constant. */
5059 && !TREE_CONSTANT (value))
5060 warning ("cast to pointer from integer of different size");
5062 if (TREE_CODE (type) == REFERENCE_TYPE)
5063 value = (convert_from_reference
5064 (convert_to_reference (type, value, CONV_C_CAST,
5065 LOOKUP_COMPLAIN, NULL_TREE)));
5070 value = decl_constant_value (value);
5073 value = convert_force (type, value, CONV_C_CAST);
5075 /* Ignore any integer overflow caused by the cast. */
5076 if (TREE_CODE (value) == INTEGER_CST)
5078 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
5079 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
5083 /* Warn about possible alignment problems. Do this here when we will have
5084 instantiated any necessary template types. */
5085 if (STRICT_ALIGNMENT && warn_cast_align
5086 && TREE_CODE (type) == POINTER_TYPE
5087 && TREE_CODE (otype) == POINTER_TYPE
5088 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5089 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5090 && COMPLETE_TYPE_P (TREE_TYPE (otype))
5091 && COMPLETE_TYPE_P (TREE_TYPE (type))
5092 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
5093 warning ("cast from `%T' to `%T' increases required alignment of target type",
5096 /* Always produce some operator for an explicit cast,
5097 so we can tell (for -pedantic) that the cast is no lvalue. */
5098 if (TREE_CODE (type) != REFERENCE_TYPE && value == expr
5099 && real_lvalue_p (value))
5100 value = non_lvalue (value);
5105 /* Build an assignment expression of lvalue LHS from value RHS.
5106 MODIFYCODE is the code for a binary operator that we use
5107 to combine the old value of LHS with RHS to get the new value.
5108 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5110 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5113 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5115 register tree result;
5117 tree lhstype = TREE_TYPE (lhs);
5118 tree olhstype = lhstype;
5121 /* Avoid duplicate error messages from operands that had errors. */
5122 if (lhs == error_mark_node || rhs == error_mark_node)
5123 return error_mark_node;
5125 /* Handle control structure constructs used as "lvalues". */
5126 switch (TREE_CODE (lhs))
5128 /* Handle --foo = 5; as these are valid constructs in C++ */
5129 case PREDECREMENT_EXPR:
5130 case PREINCREMENT_EXPR:
5131 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5132 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5133 stabilize_reference (TREE_OPERAND (lhs, 0)),
5134 TREE_OPERAND (lhs, 1));
5135 return build (COMPOUND_EXPR, lhstype,
5137 build_modify_expr (TREE_OPERAND (lhs, 0),
5140 /* Handle (a, b) used as an "lvalue". */
5142 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5144 if (newrhs == error_mark_node)
5145 return error_mark_node;
5146 return build (COMPOUND_EXPR, lhstype,
5147 TREE_OPERAND (lhs, 0), newrhs);
5150 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5151 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5152 stabilize_reference (TREE_OPERAND (lhs, 0)),
5153 TREE_OPERAND (lhs, 1));
5154 newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5155 if (newrhs == error_mark_node)
5156 return error_mark_node;
5157 return build (COMPOUND_EXPR, lhstype, lhs, newrhs);
5159 /* Handle (a ? b : c) used as an "lvalue". */
5162 /* Produce (a ? (b = rhs) : (c = rhs))
5163 except that the RHS goes through a save-expr
5164 so the code to compute it is only emitted once. */
5166 tree preeval = NULL_TREE;
5168 rhs = stabilize_expr (rhs, &preeval);
5170 /* Check this here to avoid odd errors when trying to convert
5171 a throw to the type of the COND_EXPR. */
5172 if (!lvalue_or_else (lhs, "assignment"))
5173 return error_mark_node;
5175 cond = build_conditional_expr
5176 (TREE_OPERAND (lhs, 0),
5177 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5178 TREE_OPERAND (lhs, 1)),
5180 build_modify_expr (cp_convert (TREE_TYPE (lhs),
5181 TREE_OPERAND (lhs, 2)),
5184 if (cond == error_mark_node)
5186 /* Make sure the code to compute the rhs comes out
5187 before the split. */
5188 return build (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5195 if (modifycode == INIT_EXPR)
5197 if (TREE_CODE (rhs) == CONSTRUCTOR)
5199 my_friendly_assert (same_type_p (TREE_TYPE (rhs), lhstype),
5201 result = build (INIT_EXPR, lhstype, lhs, rhs);
5202 TREE_SIDE_EFFECTS (result) = 1;
5205 else if (! IS_AGGR_TYPE (lhstype))
5206 /* Do the default thing */;
5209 result = build_special_member_call (lhs, complete_ctor_identifier,
5210 build_tree_list (NULL_TREE, rhs),
5211 TYPE_BINFO (lhstype),
5213 if (result == NULL_TREE)
5214 return error_mark_node;
5220 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5222 lhs = convert_from_reference (lhs);
5223 olhstype = lhstype = TREE_TYPE (lhs);
5225 lhs = require_complete_type (lhs);
5226 if (lhs == error_mark_node)
5227 return error_mark_node;
5229 if (modifycode == NOP_EXPR)
5231 /* `operator=' is not an inheritable operator. */
5232 if (! IS_AGGR_TYPE (lhstype))
5233 /* Do the default thing */;
5236 result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5237 lhs, rhs, make_node (NOP_EXPR));
5238 if (result == NULL_TREE)
5239 return error_mark_node;
5246 /* A binary op has been requested. Combine the old LHS
5247 value with the RHS producing the value we should actually
5248 store into the LHS. */
5250 my_friendly_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE),
5252 lhs = stabilize_reference (lhs);
5253 newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5254 if (newrhs == error_mark_node)
5256 error (" in evaluation of `%Q(%#T, %#T)'", modifycode,
5257 TREE_TYPE (lhs), TREE_TYPE (rhs));
5258 return error_mark_node;
5261 /* Now it looks like a plain assignment. */
5262 modifycode = NOP_EXPR;
5264 my_friendly_assert (TREE_CODE (lhstype) != REFERENCE_TYPE, 20011220);
5265 my_friendly_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE,
5269 /* Handle a cast used as an "lvalue".
5270 We have already performed any binary operator using the value as cast.
5271 Now convert the result to the cast type of the lhs,
5272 and then true type of the lhs and store it there;
5273 then convert result back to the cast type to be the value
5274 of the assignment. */
5276 switch (TREE_CODE (lhs))
5281 case FIX_TRUNC_EXPR:
5282 case FIX_FLOOR_EXPR:
5283 case FIX_ROUND_EXPR:
5286 tree inner_lhs = TREE_OPERAND (lhs, 0);
5289 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5290 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5291 || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5292 || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5293 newrhs = decay_conversion (newrhs);
5295 /* ISO C++ 5.4/1: The result is an lvalue if T is a reference
5296 type, otherwise the result is an rvalue. */
5297 if (! lvalue_p (lhs))
5298 pedwarn ("ISO C++ forbids cast to non-reference type used as lvalue");
5300 result = build_modify_expr (inner_lhs, NOP_EXPR,
5301 cp_convert (TREE_TYPE (inner_lhs),
5302 cp_convert (lhstype, newrhs)));
5303 if (result == error_mark_node)
5305 return cp_convert (TREE_TYPE (lhs), result);
5312 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5313 Reject anything strange now. */
5315 if (!lvalue_or_else (lhs, "assignment"))
5316 return error_mark_node;
5318 /* Warn about modifying something that is `const'. Don't warn if
5319 this is initialization. */
5320 if (modifycode != INIT_EXPR
5321 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5322 /* Functions are not modifiable, even though they are
5324 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5325 || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5326 /* If it's an aggregate and any field is const, then it is
5327 effectively const. */
5328 || (CLASS_TYPE_P (lhstype)
5329 && C_TYPE_FIELDS_READONLY (lhstype))))
5330 readonly_error (lhs, "assignment", 0);
5332 /* If storing into a structure or union member, it has probably been
5333 given type `int'. Compute the type that would go with the actual
5334 amount of storage the member occupies. */
5336 if (TREE_CODE (lhs) == COMPONENT_REF
5337 && (TREE_CODE (lhstype) == INTEGER_TYPE
5338 || TREE_CODE (lhstype) == REAL_TYPE
5339 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5341 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5343 /* If storing in a field that is in actuality a short or narrower
5344 than one, we must store in the field in its actual type. */
5346 if (lhstype != TREE_TYPE (lhs))
5348 lhs = copy_node (lhs);
5349 TREE_TYPE (lhs) = lhstype;
5353 /* Convert new value to destination type. */
5355 if (TREE_CODE (lhstype) == ARRAY_TYPE)
5359 if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5360 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5362 error ("incompatible types in assignment of `%T' to `%T'",
5363 TREE_TYPE (rhs), lhstype);
5364 return error_mark_node;
5367 /* Allow array assignment in compiler-generated code. */
5368 if (! DECL_ARTIFICIAL (current_function_decl))
5369 pedwarn ("ISO C++ forbids assignment of arrays");
5371 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5372 ? 1 + (modifycode != INIT_EXPR): 0;
5373 return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5376 if (modifycode == INIT_EXPR)
5377 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5378 "initialization", NULL_TREE, 0);
5381 /* Avoid warnings on enum bit fields. */
5382 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5383 && TREE_CODE (lhstype) == INTEGER_TYPE)
5385 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5387 newrhs = convert_force (lhstype, newrhs, 0);
5390 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5392 if (TREE_CODE (newrhs) == CALL_EXPR
5393 && TYPE_NEEDS_CONSTRUCTING (lhstype))
5394 newrhs = build_cplus_new (lhstype, newrhs);
5396 /* Can't initialize directly from a TARGET_EXPR, since that would
5397 cause the lhs to be constructed twice, and possibly result in
5398 accidental self-initialization. So we force the TARGET_EXPR to be
5399 expanded without a target. */
5400 if (TREE_CODE (newrhs) == TARGET_EXPR)
5401 newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5402 TREE_OPERAND (newrhs, 0));
5405 if (newrhs == error_mark_node)
5406 return error_mark_node;
5408 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5409 lhstype, lhs, newrhs);
5411 TREE_SIDE_EFFECTS (result) = 1;
5413 /* If we got the LHS in a different type for storing in,
5414 convert the result back to the nominal type of LHS
5415 so that the value we return always has the same type
5416 as the LHS argument. */
5418 if (olhstype == TREE_TYPE (result))
5420 /* Avoid warnings converting integral types back into enums
5421 for enum bit fields. */
5422 if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
5423 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5425 result = build (COMPOUND_EXPR, olhstype, result, olhs);
5426 TREE_NO_UNUSED_WARNING (result) = 1;
5429 return convert_for_assignment (olhstype, result, "assignment",
5434 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5436 if (processing_template_decl)
5437 return build_min_nt (MODOP_EXPR, lhs,
5438 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5440 if (modifycode != NOP_EXPR)
5442 tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5443 make_node (modifycode));
5447 return build_modify_expr (lhs, modifycode, rhs);
5451 /* Get difference in deltas for different pointer to member function
5452 types. Return integer_zero_node, if FROM cannot be converted to a
5453 TO type. If FORCE is true, then allow reverse conversions as well.
5455 Note that the naming of FROM and TO is kind of backwards; the return
5456 value is what we add to a TO in order to get a FROM. They are named
5457 this way because we call this function to find out how to convert from
5458 a pointer to member of FROM to a pointer to member of TO. */
5461 get_delta_difference (tree from, tree to, int force)
5463 tree delta = integer_zero_node;
5468 binfo = lookup_base (to, from, ba_check, &kind);
5469 if (kind == bk_inaccessible || kind == bk_ambig)
5471 error (" in pointer to member function conversion");
5478 error_not_base_type (from, to);
5479 error (" in pointer to member conversion");
5482 binfo = lookup_base (from, to, ba_check, &kind);
5485 virt_binfo = binfo_from_vbase (binfo);
5489 /* This is a reinterpret cast, we choose to do nothing. */
5490 warning ("pointer to member cast via virtual base `%T'",
5491 BINFO_TYPE (virt_binfo));
5494 delta = BINFO_OFFSET (binfo);
5495 delta = cp_convert (ptrdiff_type_node, delta);
5496 delta = cp_build_binary_op (MINUS_EXPR,
5503 virt_binfo = binfo_from_vbase (binfo);
5506 /* This is a reinterpret cast, we choose to do nothing. */
5508 warning ("pointer to member cast via virtual base `%T'",
5509 BINFO_TYPE (virt_binfo));
5511 error ("pointer to member conversion via virtual base `%T'",
5512 BINFO_TYPE (virt_binfo));
5515 delta = BINFO_OFFSET (binfo);
5517 return cp_convert (ptrdiff_type_node, delta);
5520 /* Return a constructor for the pointer-to-member-function TYPE using
5521 the other components as specified. */
5524 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5530 /* Pull the FIELD_DECLs out of the type. */
5531 pfn_field = TYPE_FIELDS (type);
5532 delta_field = TREE_CHAIN (pfn_field);
5534 /* Make sure DELTA has the type we want. */
5535 delta = convert_and_check (delta_type_node, delta);
5537 /* Finish creating the initializer. */
5538 u = tree_cons (pfn_field, pfn,
5539 build_tree_list (delta_field, delta));
5540 u = build_constructor (type, u);
5541 TREE_CONSTANT (u) = TREE_CONSTANT (pfn) && TREE_CONSTANT (delta);
5542 TREE_STATIC (u) = (TREE_CONSTANT (u)
5543 && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5545 && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5550 /* Build a constructor for a pointer to member function. It can be
5551 used to initialize global variables, local variable, or used
5552 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
5555 If FORCE is nonzero, then force this conversion, even if
5556 we would rather not do it. Usually set when using an explicit
5559 Return error_mark_node, if something goes wrong. */
5562 build_ptrmemfunc (tree type, tree pfn, int force)
5568 if (error_operand_p (pfn))
5569 return error_mark_node;
5571 pfn_type = TREE_TYPE (pfn);
5572 to_type = build_ptrmemfunc_type (type);
5574 /* Handle multiple conversions of pointer to member functions. */
5575 if (TYPE_PTRMEMFUNC_P (pfn_type))
5577 tree delta = NULL_TREE;
5578 tree npfn = NULL_TREE;
5582 && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5583 error ("invalid conversion to type `%T' from type `%T'",
5586 n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5587 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5590 /* We don't have to do any conversion to convert a
5591 pointer-to-member to its own type. But, we don't want to
5592 just return a PTRMEM_CST if there's an explicit cast; that
5593 cast should make the expression an invalid template argument. */
5594 if (TREE_CODE (pfn) != PTRMEM_CST)
5596 if (same_type_p (to_type, pfn_type))
5598 else if (integer_zerop (n))
5599 return build_reinterpret_cast (to_type, pfn);
5602 if (TREE_SIDE_EFFECTS (pfn))
5603 pfn = save_expr (pfn);
5605 /* Obtain the function pointer and the current DELTA. */
5606 if (TREE_CODE (pfn) == PTRMEM_CST)
5607 expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5610 npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5611 delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5614 /* Just adjust the DELTA field. */
5615 delta = cp_convert (ptrdiff_type_node, delta);
5616 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5617 n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5618 delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5619 return build_ptrmemfunc1 (to_type, delta, npfn);
5622 /* Handle null pointer to member function conversions. */
5623 if (integer_zerop (pfn))
5625 pfn = build_c_cast (type, integer_zero_node);
5626 return build_ptrmemfunc1 (to_type,
5631 if (type_unknown_p (pfn))
5632 return instantiate_type (type, pfn, tf_error | tf_warning);
5634 fn = TREE_OPERAND (pfn, 0);
5635 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5636 return make_ptrmem_cst (to_type, fn);
5639 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5642 ??? There is no consistency as to the types returned for the above
5643 values. Some code acts as if its a sizetype and some as if its
5644 integer_type_node. */
5647 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5649 tree type = TREE_TYPE (cst);
5650 tree fn = PTRMEM_CST_MEMBER (cst);
5651 tree ptr_class, fn_class;
5653 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5655 /* The class that the function belongs to. */
5656 fn_class = DECL_CONTEXT (fn);
5658 /* The class that we're creating a pointer to member of. */
5659 ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5661 /* First, calculate the adjustment to the function's class. */
5662 *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0);
5664 if (!DECL_VIRTUAL_P (fn))
5665 *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5668 /* If we're dealing with a virtual function, we have to adjust 'this'
5669 again, to point to the base which provides the vtable entry for
5670 fn; the call will do the opposite adjustment. */
5671 tree orig_class = DECL_CONTEXT (fn);
5672 tree binfo = binfo_or_else (orig_class, fn_class);
5673 *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5674 *delta, BINFO_OFFSET (binfo)));
5676 /* We set PFN to the vtable offset at which the function can be
5677 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5678 case delta is shifted left, and then incremented). */
5679 *pfn = DECL_VINDEX (fn);
5680 *pfn = fold (build (MULT_EXPR, integer_type_node, *pfn,
5681 TYPE_SIZE_UNIT (vtable_entry_type)));
5683 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5685 case ptrmemfunc_vbit_in_pfn:
5686 *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn,
5690 case ptrmemfunc_vbit_in_delta:
5691 *delta = fold (build (LSHIFT_EXPR, TREE_TYPE (*delta),
5692 *delta, integer_one_node));
5693 *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5694 *delta, integer_one_node));
5701 *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
5706 /* Return an expression for PFN from the pointer-to-member function
5710 pfn_from_ptrmemfunc (tree t)
5712 if (TREE_CODE (t) == PTRMEM_CST)
5717 expand_ptrmemfunc_cst (t, &delta, &pfn);
5722 return build_ptrmemfunc_access_expr (t, pfn_identifier);
5725 /* Expression EXPR is about to be implicitly converted to TYPE. Warn
5726 if this is a potentially dangerous thing to do. Returns a possibly
5730 dubious_conversion_warnings (tree type, tree expr,
5731 const char *errtype, tree fndecl, int parmnum)
5733 type = non_reference (type);
5735 /* Issue warnings about peculiar, but valid, uses of NULL. */
5736 if (ARITHMETIC_TYPE_P (type) && expr == null_node)
5739 warning ("passing NULL used for non-pointer %s %P of `%D'",
5740 errtype, parmnum, fndecl);
5742 warning ("%s to non-pointer type `%T' from NULL", errtype, type);
5745 /* Warn about assigning a floating-point type to an integer type. */
5746 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
5747 && TREE_CODE (type) == INTEGER_TYPE)
5750 warning ("passing `%T' for %s %P of `%D'",
5751 TREE_TYPE (expr), errtype, parmnum, fndecl);
5753 warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
5755 /* And warn about assigning a negative value to an unsigned
5757 else if (TREE_UNSIGNED (type) && TREE_CODE (type) != BOOLEAN_TYPE)
5759 if (TREE_CODE (expr) == INTEGER_CST
5760 && TREE_NEGATED_INT (expr))
5763 warning ("passing negative value `%E' for %s %P of `%D'",
5764 expr, errtype, parmnum, fndecl);
5766 warning ("%s of negative value `%E' to `%T'",
5767 errtype, expr, type);
5770 overflow_warning (expr);
5772 if (TREE_CONSTANT (expr))
5778 /* Convert value RHS to type TYPE as preparation for an assignment to
5779 an lvalue of type TYPE. ERRTYPE is a string to use in error
5780 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
5781 are doing the conversion in order to pass the PARMNUMth argument of
5785 convert_for_assignment (tree type, tree rhs,
5786 const char *errtype, tree fndecl, int parmnum)
5788 register enum tree_code codel = TREE_CODE (type);
5789 register tree rhstype;
5790 register enum tree_code coder;
5792 if (codel == OFFSET_TYPE)
5795 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
5796 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5797 rhs = TREE_OPERAND (rhs, 0);
5799 rhstype = TREE_TYPE (rhs);
5800 coder = TREE_CODE (rhstype);
5802 if (rhs == error_mark_node || rhstype == error_mark_node)
5803 return error_mark_node;
5804 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
5805 return error_mark_node;
5807 rhs = dubious_conversion_warnings (type, rhs, errtype, fndecl, parmnum);
5809 /* The RHS of an assignment cannot have void type. */
5810 if (coder == VOID_TYPE)
5812 error ("void value not ignored as it ought to be");
5813 return error_mark_node;
5816 /* Simplify the RHS if possible. */
5817 if (TREE_CODE (rhs) == CONST_DECL)
5818 rhs = DECL_INITIAL (rhs);
5820 /* We do not use decl_constant_value here because of this case:
5822 const char* const s = "s";
5824 The conversion rules for a string literal are more lax than for a
5825 variable; in particular, a string literal can be converted to a
5826 "char *" but the variable "s" cannot be converted in the same
5827 way. If the conversion is allowed, the optimization should be
5828 performed while creating the converted expression. */
5832 The expression is implicitly converted (clause _conv_) to the
5833 cv-unqualified type of the left operand.
5835 We allow bad conversions here because by the time we get to this point
5836 we are committed to doing the conversion. If we end up doing a bad
5837 conversion, convert_like will complain. */
5838 if (!can_convert_arg_bad (type, rhstype, rhs))
5840 /* When -Wno-pmf-conversions is use, we just silently allow
5841 conversions from pointers-to-members to plain pointers. If
5842 the conversion doesn't work, cp_convert will complain. */
5844 && TYPE_PTR_P (type)
5845 && TYPE_PTRMEMFUNC_P (rhstype))
5846 rhs = cp_convert (strip_top_quals (type), rhs);
5849 /* If the right-hand side has unknown type, then it is an
5850 overloaded function. Call instantiate_type to get error
5852 if (rhstype == unknown_type_node)
5853 instantiate_type (type, rhs, tf_error | tf_warning);
5855 error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
5856 rhstype, type, parmnum, fndecl);
5858 error ("cannot convert `%T' to `%T' in %s", rhstype, type,
5860 return error_mark_node;
5863 return perform_implicit_conversion (strip_top_quals (type), rhs);
5866 /* Convert RHS to be of type TYPE.
5867 If EXP is nonzero, it is the target of the initialization.
5868 ERRTYPE is a string to use in error messages.
5870 Two major differences between the behavior of
5871 `convert_for_assignment' and `convert_for_initialization'
5872 are that references are bashed in the former, while
5873 copied in the latter, and aggregates are assigned in
5874 the former (operator=) while initialized in the
5877 If using constructor make sure no conversion operator exists, if one does
5878 exist, an ambiguity exists.
5880 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
5883 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
5884 const char *errtype, tree fndecl, int parmnum)
5886 register enum tree_code codel = TREE_CODE (type);
5887 register tree rhstype;
5888 register enum tree_code coder;
5890 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5891 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
5892 if (TREE_CODE (rhs) == NOP_EXPR
5893 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
5894 && codel != REFERENCE_TYPE)
5895 rhs = TREE_OPERAND (rhs, 0);
5897 if (rhs == error_mark_node
5898 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
5899 return error_mark_node;
5901 if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
5902 rhs = convert_from_reference (rhs);
5904 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
5905 && TREE_CODE (type) != ARRAY_TYPE
5906 && (TREE_CODE (type) != REFERENCE_TYPE
5907 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
5908 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
5909 && (TREE_CODE (type) != REFERENCE_TYPE
5910 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
5911 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
5912 rhs = decay_conversion (rhs);
5914 rhstype = TREE_TYPE (rhs);
5915 coder = TREE_CODE (rhstype);
5917 if (coder == ERROR_MARK)
5918 return error_mark_node;
5920 /* We accept references to incomplete types, so we can
5921 return here before checking if RHS is of complete type. */
5923 if (codel == REFERENCE_TYPE)
5925 /* This should eventually happen in convert_arguments. */
5926 int savew = 0, savee = 0;
5929 savew = warningcount, savee = errorcount;
5930 rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE);
5933 if (warningcount > savew)
5934 cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5935 else if (errorcount > savee)
5936 cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5942 exp = require_complete_type (exp);
5943 if (exp == error_mark_node)
5944 return error_mark_node;
5946 rhstype = non_reference (rhstype);
5948 type = complete_type (type);
5950 if (IS_AGGR_TYPE (type))
5951 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
5953 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
5956 /* Expand an ASM statement with operands, handling output operands
5957 that are not variables or INDIRECT_REFS by transforming such
5958 cases into cases that expand_asm_operands can handle.
5960 Arguments are same as for expand_asm_operands.
5962 We don't do default conversions on all inputs, because it can screw
5963 up operands that are expected to be in memory. */
5966 c_expand_asm_operands (tree string, tree outputs, tree inputs, tree clobbers,
5967 int vol, const char *filename, int line)
5969 int noutputs = list_length (outputs);
5971 /* o[I] is the place that output number I should be written. */
5972 register tree *o = alloca (noutputs * sizeof (tree));
5975 /* Record the contents of OUTPUTS before it is modified. */
5976 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5977 o[i] = TREE_VALUE (tail);
5979 /* Generate the ASM_OPERANDS insn;
5980 store into the TREE_VALUEs of OUTPUTS some trees for
5981 where the values were actually stored. */
5982 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
5984 /* Copy all the intermediate outputs into the specified outputs. */
5985 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5987 if (o[i] != TREE_VALUE (tail))
5989 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
5990 const0_rtx, VOIDmode, EXPAND_NORMAL);
5993 /* Restore the original value so that it's correct the next
5994 time we expand this function. */
5995 TREE_VALUE (tail) = o[i];
5997 /* Detect modification of read-only values.
5998 (Otherwise done by build_modify_expr.) */
6001 tree type = TREE_TYPE (o[i]);
6002 if (type != error_mark_node
6003 && (CP_TYPE_CONST_P (type)
6004 || (CLASS_TYPE_P (type) && C_TYPE_FIELDS_READONLY (type))))
6005 readonly_error (o[i], "modification by `asm'", 1);
6009 /* Those MODIFY_EXPRs could do autoincrements. */
6013 /* If RETVAL is the address of, or a reference to, a local variable or
6014 temporary give an appropriate warning. */
6017 maybe_warn_about_returning_address_of_local (tree retval)
6019 tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6020 tree whats_returned = retval;
6024 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6025 whats_returned = TREE_OPERAND (whats_returned, 1);
6026 else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6027 || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6028 || TREE_CODE (whats_returned) == NOP_EXPR)
6029 whats_returned = TREE_OPERAND (whats_returned, 0);
6034 if (TREE_CODE (whats_returned) != ADDR_EXPR)
6036 whats_returned = TREE_OPERAND (whats_returned, 0);
6038 if (TREE_CODE (valtype) == REFERENCE_TYPE)
6040 if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6041 || TREE_CODE (whats_returned) == TARGET_EXPR)
6043 warning ("returning reference to temporary");
6046 if (TREE_CODE (whats_returned) == VAR_DECL
6047 && DECL_NAME (whats_returned)
6048 && TEMP_NAME_P (DECL_NAME (whats_returned)))
6050 warning ("reference to non-lvalue returned");
6055 if (TREE_CODE (whats_returned) == VAR_DECL
6056 && DECL_NAME (whats_returned)
6057 && DECL_FUNCTION_SCOPE_P (whats_returned)
6058 && !(TREE_STATIC (whats_returned)
6059 || TREE_PUBLIC (whats_returned)))
6061 if (TREE_CODE (valtype) == REFERENCE_TYPE)
6062 cp_warning_at ("reference to local variable `%D' returned",
6065 cp_warning_at ("address of local variable `%D' returned",
6071 /* Check that returning RETVAL from the current function is valid.
6072 Return an expression explicitly showing all conversions required to
6073 change RETVAL into the function return type, and to assign it to
6074 the DECL_RESULT for the function. */
6077 check_return_expr (tree retval)
6080 /* The type actually returned by the function, after any
6083 int fn_returns_value_p;
6085 /* A `volatile' function is one that isn't supposed to return, ever.
6086 (This is a G++ extension, used to get better code for functions
6087 that call the `volatile' function.) */
6088 if (TREE_THIS_VOLATILE (current_function_decl))
6089 warning ("function declared `noreturn' has a `return' statement");
6091 /* Check for various simple errors. */
6092 if (DECL_DESTRUCTOR_P (current_function_decl))
6095 error ("returning a value from a destructor");
6098 else if (DECL_CONSTRUCTOR_P (current_function_decl))
6100 if (in_function_try_handler)
6101 /* If a return statement appears in a handler of the
6102 function-try-block of a constructor, the program is ill-formed. */
6103 error ("cannot return from a handler of a function-try-block of a constructor");
6105 /* You can't return a value from a constructor. */
6106 error ("returning a value from a constructor");
6110 if (processing_template_decl)
6112 current_function_returns_value = 1;
6116 /* When no explicit return-value is given in a function with a named
6117 return value, the named return value is used. */
6118 result = DECL_RESULT (current_function_decl);
6119 valtype = TREE_TYPE (result);
6120 my_friendly_assert (valtype != NULL_TREE, 19990924);
6121 fn_returns_value_p = !VOID_TYPE_P (valtype);
6122 if (!retval && DECL_NAME (result) && fn_returns_value_p)
6125 /* Check for a return statement with no return value in a function
6126 that's supposed to return a value. */
6127 if (!retval && fn_returns_value_p)
6129 pedwarn ("return-statement with no value, in function returning '%T'",
6131 /* Clear this, so finish_function won't say that we reach the
6132 end of a non-void function (which we don't, we gave a
6134 current_function_returns_null = 0;
6136 /* Check for a return statement with a value in a function that
6137 isn't supposed to return a value. */
6138 else if (retval && !fn_returns_value_p)
6140 if (VOID_TYPE_P (TREE_TYPE (retval)))
6141 /* You can return a `void' value from a function of `void'
6142 type. In that case, we have to evaluate the expression for
6143 its side-effects. */
6144 finish_expr_stmt (retval);
6146 pedwarn ("return-statement with a value, in function "
6147 "returning 'void'");
6149 current_function_returns_null = 1;
6151 /* There's really no value to return, after all. */
6155 /* Remember that this function can sometimes return without a
6157 current_function_returns_null = 1;
6159 /* Remember that this function did return a value. */
6160 current_function_returns_value = 1;
6162 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6163 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6164 || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6165 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6167 && null_ptr_cst_p (retval))
6168 warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
6170 /* Effective C++ rule 15. See also start_function. */
6172 && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)
6173 && retval != current_class_ref)
6174 warning ("`operator=' should return a reference to `*this'");
6176 /* The fabled Named Return Value optimization, as per [class.copy]/15:
6178 [...] For a function with a class return type, if the expression
6179 in the return statement is the name of a local object, and the cv-
6180 unqualified type of the local object is the same as the function
6181 return type, an implementation is permitted to omit creating the tem-
6182 porary object to hold the function return value [...]
6184 So, if this is a value-returning function that always returns the same
6185 local variable, remember it.
6187 It might be nice to be more flexible, and choose the first suitable
6188 variable even if the function sometimes returns something else, but
6189 then we run the risk of clobbering the variable we chose if the other
6190 returned expression uses the chosen variable somehow. And people expect
6191 this restriction, anyway. (jason 2000-11-19)
6193 See finish_function, genrtl_start_function, and declare_return_variable
6194 for other pieces of this optimization. */
6196 if (fn_returns_value_p && flag_elide_constructors)
6198 if (retval != NULL_TREE
6199 && (current_function_return_value == NULL_TREE
6200 || current_function_return_value == retval)
6201 && TREE_CODE (retval) == VAR_DECL
6202 && DECL_CONTEXT (retval) == current_function_decl
6203 && ! TREE_STATIC (retval)
6204 && (DECL_ALIGN (retval)
6205 >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6206 && same_type_p ((TYPE_MAIN_VARIANT
6207 (TREE_TYPE (retval))),
6209 (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6210 current_function_return_value = retval;
6212 current_function_return_value = error_mark_node;
6215 /* We don't need to do any conversions when there's nothing being
6217 if (!retval || retval == error_mark_node)
6220 /* Do any required conversions. */
6221 if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6222 /* No conversions are required. */
6226 /* The type the function is declared to return. */
6227 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6229 /* First convert the value to the function's return type, then
6230 to the type of return value's location to handle the
6231 case that functype is smaller than the valtype. */
6232 retval = convert_for_initialization
6233 (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6234 "return", NULL_TREE, 0);
6235 retval = convert (valtype, retval);
6237 /* If the conversion failed, treat this just like `return;'. */
6238 if (retval == error_mark_node)
6240 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6241 else if (! current_function_returns_struct
6242 && TREE_CODE (retval) == TARGET_EXPR
6243 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6244 retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6245 TREE_OPERAND (retval, 0));
6247 maybe_warn_about_returning_address_of_local (retval);
6250 /* Actually copy the value returned into the appropriate location. */
6251 if (retval && retval != result)
6252 retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6258 /* Returns nonzero if the pointer-type FROM can be converted to the
6259 pointer-type TO via a qualification conversion. If CONSTP is -1,
6260 then we return nonzero if the pointers are similar, and the
6261 cv-qualification signature of FROM is a proper subset of that of TO.
6263 If CONSTP is positive, then all outer pointers have been
6267 comp_ptr_ttypes_real (tree to, tree from, int constp)
6269 int to_more_cv_qualified = 0;
6271 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6273 if (TREE_CODE (to) != TREE_CODE (from))
6276 if (TREE_CODE (from) == OFFSET_TYPE
6277 && same_type_p (TYPE_OFFSET_BASETYPE (from),
6278 TYPE_OFFSET_BASETYPE (to)))
6281 /* Const and volatile mean something different for function types,
6282 so the usual checks are not appropriate. */
6283 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6285 if (!at_least_as_qualified_p (to, from))
6288 if (!at_least_as_qualified_p (from, to))
6293 ++to_more_cv_qualified;
6297 constp &= TYPE_READONLY (to);
6300 if (TREE_CODE (to) != POINTER_TYPE)
6301 return ((constp >= 0 || to_more_cv_qualified)
6302 && same_type_ignoring_top_level_qualifiers_p (to, from));
6306 /* When comparing, say, char ** to char const **, this function takes
6307 the 'char *' and 'char const *'. Do not pass non-pointer/reference
6308 types to this function. */
6311 comp_ptr_ttypes (tree to, tree from)
6313 return comp_ptr_ttypes_real (to, from, 1);
6316 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6317 type or inheritance-related types, regardless of cv-quals. */
6320 ptr_reasonably_similar (tree to, tree from)
6322 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6324 /* Any target type is similar enough to void. */
6325 if (TREE_CODE (to) == VOID_TYPE
6326 || TREE_CODE (from) == VOID_TYPE)
6329 if (TREE_CODE (to) != TREE_CODE (from))
6332 if (TREE_CODE (from) == OFFSET_TYPE
6333 && comptypes (TYPE_OFFSET_BASETYPE (to),
6334 TYPE_OFFSET_BASETYPE (from),
6335 COMPARE_BASE | COMPARE_DERIVED))
6338 if (TREE_CODE (to) == INTEGER_TYPE
6339 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6342 if (TREE_CODE (to) == FUNCTION_TYPE)
6345 if (TREE_CODE (to) != POINTER_TYPE)
6347 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6348 COMPARE_BASE | COMPARE_DERIVED);
6352 /* Like comp_ptr_ttypes, for const_cast. */
6355 comp_ptr_ttypes_const (tree to, tree from)
6357 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6359 if (TREE_CODE (to) != TREE_CODE (from))
6362 if (TREE_CODE (from) == OFFSET_TYPE
6363 && same_type_p (TYPE_OFFSET_BASETYPE (from),
6364 TYPE_OFFSET_BASETYPE (to)))
6367 if (TREE_CODE (to) != POINTER_TYPE)
6368 return same_type_ignoring_top_level_qualifiers_p (to, from);
6372 /* Like comp_ptr_ttypes, for reinterpret_cast. */
6375 comp_ptr_ttypes_reinterpret (tree to, tree from)
6379 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6381 if (TREE_CODE (from) == OFFSET_TYPE)
6382 from = TREE_TYPE (from);
6383 if (TREE_CODE (to) == OFFSET_TYPE)
6384 to = TREE_TYPE (to);
6386 /* Const and volatile mean something different for function types,
6387 so the usual checks are not appropriate. */
6388 if (TREE_CODE (from) != FUNCTION_TYPE && TREE_CODE (from) != METHOD_TYPE
6389 && TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6391 if (!at_least_as_qualified_p (to, from))
6395 && !at_least_as_qualified_p (from, to))
6397 constp &= TYPE_READONLY (to);
6400 if (TREE_CODE (from) != POINTER_TYPE
6401 || TREE_CODE (to) != POINTER_TYPE)
6406 /* Returns the type qualifiers for this type, including the qualifiers on the
6407 elements for an array type. */
6410 cp_type_quals (tree type)
6412 type = strip_array_types (type);
6413 if (type == error_mark_node)
6414 return TYPE_UNQUALIFIED;
6415 return TYPE_QUALS (type);
6418 /* Returns nonzero if the TYPE contains a mutable member */
6421 cp_has_mutable_p (tree type)
6423 type = strip_array_types (type);
6425 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6428 /* Subroutine of casts_away_constness. Make T1 and T2 point at
6429 exemplar types such that casting T1 to T2 is casting away castness
6430 if and only if there is no implicit conversion from T1 to T2. */
6433 casts_away_constness_r (tree *t1, tree *t2)
6438 /* [expr.const.cast]
6440 For multi-level pointer to members and multi-level mixed pointers
6441 and pointers to members (conv.qual), the "member" aspect of a
6442 pointer to member level is ignored when determining if a const
6443 cv-qualifier has been cast away. */
6444 if (TYPE_PTRMEM_P (*t1))
6445 *t1 = build_pointer_type (TREE_TYPE (TREE_TYPE (*t1)));
6446 if (TYPE_PTRMEM_P (*t2))
6447 *t2 = build_pointer_type (TREE_TYPE (TREE_TYPE (*t2)));
6449 /* [expr.const.cast]
6451 For two pointer types:
6453 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
6454 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
6457 casting from X1 to X2 casts away constness if, for a non-pointer
6458 type T there does not exist an implicit conversion (clause
6461 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6465 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
6467 if (TREE_CODE (*t1) != POINTER_TYPE
6468 || TREE_CODE (*t2) != POINTER_TYPE)
6470 *t1 = cp_build_qualified_type (void_type_node,
6471 cp_type_quals (*t1));
6472 *t2 = cp_build_qualified_type (void_type_node,
6473 cp_type_quals (*t2));
6477 quals1 = cp_type_quals (*t1);
6478 quals2 = cp_type_quals (*t2);
6479 *t1 = TREE_TYPE (*t1);
6480 *t2 = TREE_TYPE (*t2);
6481 casts_away_constness_r (t1, t2);
6482 *t1 = build_pointer_type (*t1);
6483 *t2 = build_pointer_type (*t2);
6484 *t1 = cp_build_qualified_type (*t1, quals1);
6485 *t2 = cp_build_qualified_type (*t2, quals2);
6488 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6492 casts_away_constness (tree t1, tree t2)
6494 if (TREE_CODE (t2) == REFERENCE_TYPE)
6496 /* [expr.const.cast]
6498 Casting from an lvalue of type T1 to an lvalue of type T2
6499 using a reference cast casts away constness if a cast from an
6500 rvalue of type "pointer to T1" to the type "pointer to T2"
6501 casts away constness. */
6502 t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6503 return casts_away_constness (build_pointer_type (t1),
6504 build_pointer_type (TREE_TYPE (t2)));
6507 if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6508 /* [expr.const.cast]
6510 Casting from an rvalue of type "pointer to data member of X
6511 of type T1" to the type "pointer to data member of Y of type
6512 T2" casts away constness if a cast from an rvalue of type
6513 "pointer to T1" to the type "pointer to T2" casts away
6515 return casts_away_constness
6516 (build_pointer_type (TREE_TYPE (TREE_TYPE (t1))),
6517 build_pointer_type (TREE_TYPE (TREE_TYPE (t2))));
6519 /* Casting away constness is only something that makes sense for
6520 pointer or reference types. */
6521 if (TREE_CODE (t1) != POINTER_TYPE
6522 || TREE_CODE (t2) != POINTER_TYPE)
6525 /* Top-level qualifiers don't matter. */
6526 t1 = TYPE_MAIN_VARIANT (t1);
6527 t2 = TYPE_MAIN_VARIANT (t2);
6528 casts_away_constness_r (&t1, &t2);
6529 if (!can_convert (t2, t1))
6535 /* Returns TYPE with its cv qualifiers removed
6536 TYPE is T cv* .. *cv where T is not a pointer type,
6537 returns T * .. *. (If T is an array type, then the cv qualifiers
6538 above are those of the array members.) */
6541 strip_all_pointer_quals (tree type)
6543 if (TREE_CODE (type) == POINTER_TYPE)
6544 return build_pointer_type (strip_all_pointer_quals (TREE_TYPE (type)));
6545 else if (TREE_CODE (type) == OFFSET_TYPE)
6546 return build_offset_type (TYPE_OFFSET_BASETYPE (type),
6547 strip_all_pointer_quals (TREE_TYPE (type)));
6549 return TYPE_MAIN_VARIANT (type);
6552 /* If T is a REFERENCE_TYPE return the type to which T refers.
6553 Otherwise, return T itself. */
6556 non_reference (tree t)
6558 if (TREE_CODE (t) == REFERENCE_TYPE)