1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
42 extern void compiler_error ();
44 static tree convert_for_assignment PROTO((tree, tree, char*, tree,
46 static tree pointer_int_sum PROTO((enum tree_code, tree, tree));
47 static tree rationalize_conditional_expr PROTO((enum tree_code, tree));
48 static int comp_target_parms PROTO((tree, tree, int));
49 static int comp_ptr_ttypes_real PROTO((tree, tree, int));
50 static int comp_ptr_ttypes_const PROTO((tree, tree));
51 static int comp_ptr_ttypes_reinterpret PROTO((tree, tree));
52 static int comp_array_types PROTO((int (*) (tree, tree, int), tree,
54 static tree build_ptrmemfunc1 PROTO((tree, tree, tree, tree, tree));
55 static tree common_base_type PROTO((tree, tree));
57 static tree convert_sequence PROTO((tree, tree));
59 static tree lookup_anon_field PROTO((tree, tree));
60 static tree pointer_diff PROTO((tree, tree, tree));
61 static tree qualify_type PROTO((tree, tree));
62 static tree get_delta_difference PROTO((tree, tree, int));
64 /* Return the target type of TYPE, which meas return T for:
65 T*, T&, T[], T (...), and otherwise, just T. */
71 if (TREE_CODE (type) == REFERENCE_TYPE)
72 type = TREE_TYPE (type);
73 while (TREE_CODE (type) == POINTER_TYPE
74 || TREE_CODE (type) == ARRAY_TYPE
75 || TREE_CODE (type) == FUNCTION_TYPE
76 || TREE_CODE (type) == METHOD_TYPE
77 || TREE_CODE (type) == OFFSET_TYPE)
78 type = TREE_TYPE (type);
82 /* Do `exp = require_complete_type (exp);' to make sure exp
83 does not have an incomplete type. (That includes void types.)
84 Returns the error_mark_node if the VALUE does not have
85 complete type when this function returns. */
88 require_complete_type (value)
93 if (processing_template_decl)
96 if (TREE_CODE (value) == OVERLOAD)
97 type = unknown_type_node;
99 type = TREE_TYPE (value);
101 /* First, detect a valid value with a complete type. */
102 if (TYPE_SIZE (type) != 0
103 && type != void_type_node
104 && ! (TYPE_LANG_SPECIFIC (type)
105 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))
106 && TYPE_SIZE (SIGNATURE_TYPE (type)) == 0))
109 /* If we see X::Y, we build an OFFSET_TYPE which has
110 not been laid out. Try to avoid an error by interpreting
111 it as this->X::Y, if reasonable. */
112 if (TREE_CODE (value) == OFFSET_REF
113 && current_class_ref != 0
114 && TREE_OPERAND (value, 0) == current_class_ref)
116 tree base, member = TREE_OPERAND (value, 1);
117 tree basetype = TYPE_OFFSET_BASETYPE (type);
118 my_friendly_assert (TREE_CODE (member) == FIELD_DECL, 305);
119 base = convert_pointer_to (basetype, current_class_ptr);
120 value = build (COMPONENT_REF, TREE_TYPE (member),
121 build_indirect_ref (base, NULL_PTR), member);
122 return require_complete_type (value);
125 if (complete_type_or_else (type))
128 return error_mark_node;
131 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
132 a template instantiation, do the instantiation. Returns TYPE,
133 whether or not it could be completed, unless something goes
134 horribly wrong, in which case the error_mark_node is returned. */
140 if (type == NULL_TREE)
141 /* Rather than crash, we return something sure to cause an error
143 return error_mark_node;
145 if (type == error_mark_node || TYPE_SIZE (type) != NULL_TREE)
147 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
149 tree t = complete_type (TREE_TYPE (type));
150 if (TYPE_SIZE (t) != NULL_TREE && ! processing_template_decl)
152 TYPE_NEEDS_CONSTRUCTING (type)
153 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
154 TYPE_NEEDS_DESTRUCTOR (type)
155 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
157 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
158 instantiate_class_template (TYPE_MAIN_VARIANT (type));
163 /* Like complete_type, but issue an error if the TYPE cannot be
164 completed. Returns NULL_TREE if the type cannot be made
168 complete_type_or_else (type)
171 type = complete_type (type);
172 if (type == error_mark_node)
173 /* We already issued an error. */
175 else if (!TYPE_SIZE (type))
177 incomplete_type_error (NULL_TREE, type);
184 /* Return truthvalue of whether type of EXP is instantiated. */
190 return (TREE_CODE (exp) == OVERLOAD
191 || TREE_CODE (exp) == TREE_LIST
192 || TREE_TYPE (exp) == unknown_type_node
193 || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
194 && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node));
197 /* Return truthvalue of whether T is function (or pfn) type. */
203 return (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE
204 || (TREE_CODE (t) == POINTER_TYPE
205 && (TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE
206 || TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE)));
209 /* Return a variant of TYPE which has all the type qualifiers of LIKE
210 as well as those of TYPE. */
213 qualify_type (type, like)
216 /* @@ Must do member pointers here. */
217 return cp_build_qualified_type (type, (CP_TYPE_QUALS (type)
218 | CP_TYPE_QUALS (like)));
221 /* Return the common type of two parameter lists.
222 We assume that comptypes has already been done and returned 1;
223 if that isn't so, this may crash.
225 As an optimization, free the space we allocate if the parameter
226 lists are already common. */
232 tree oldargs = p1, newargs, n;
235 char *first_obj = (char *) oballoc (0);
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) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
281 TREE_VALUE (n) = TREE_VALUE (p1);
292 /* Given a type, perhaps copied for a typedef,
293 find the "original" version of it. */
298 while (TYPE_NAME (t) != NULL_TREE)
300 tree x = TYPE_NAME (t);
301 if (TREE_CODE (x) != TYPE_DECL)
303 x = DECL_ORIGINAL_TYPE (x);
311 /* Return the common type of two types.
312 We assume that comptypes has already been done and returned 1;
313 if that isn't so, this may crash.
315 This is the type for the result of most arithmetic operations
316 if the operands have the given two types.
318 We do not deal with enumeral types here because they have already been
319 converted to integer types. */
325 register enum tree_code code1;
326 register enum tree_code code2;
329 /* Save time if the two types are the same. */
332 t1 = original_type (t1);
333 t2 = original_type (t2);
337 /* If one type is nonsense, use the other. */
338 if (t1 == error_mark_node)
340 if (t2 == error_mark_node)
343 /* Merge the attributes. */
344 attributes = merge_machine_type_attributes (t1, t2);
346 { register tree a1, a2;
347 a1 = TYPE_ATTRIBUTES (t1);
348 a2 = TYPE_ATTRIBUTES (t2);
350 /* Either one unset? Take the set one. */
352 if (!(attributes = a1))
355 /* One that completely contains the other? Take it. */
357 else if (a2 && !attribute_list_contained (a1, a2))
359 if (attribute_list_contained (a2, a1))
363 /* Pick the longest list, and hang on the other list. */
364 /* ??? For the moment we punt on the issue of attrs with args. */
366 if (list_length (a1) < list_length (a2))
367 attributes = a2, a2 = a1;
369 for (; a2; a2 = TREE_CHAIN (a2))
370 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
371 attributes) == NULL_TREE)
374 TREE_CHAIN (a1) = attributes;
381 /* Treat an enum type as the unsigned integer type of the same width. */
383 if (TREE_CODE (t1) == ENUMERAL_TYPE)
384 t1 = type_for_size (TYPE_PRECISION (t1), 1);
385 if (TREE_CODE (t2) == ENUMERAL_TYPE)
386 t2 = type_for_size (TYPE_PRECISION (t2), 1);
388 if (TYPE_PTRMEMFUNC_P (t1))
389 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
390 if (TYPE_PTRMEMFUNC_P (t2))
391 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
393 code1 = TREE_CODE (t1);
394 code2 = TREE_CODE (t2);
396 /* If one type is complex, form the common type of the non-complex
397 components, then make that complex. Use T1 or T2 if it is the
399 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
401 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
402 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
403 tree subtype = common_type (subtype1, subtype2);
405 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
406 return build_type_attribute_variant (t1, attributes);
407 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
408 return build_type_attribute_variant (t2, attributes);
410 return build_type_attribute_variant (build_complex_type (subtype),
418 /* If only one is real, use it as the result. */
420 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
421 return build_type_attribute_variant (t1, attributes);
423 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
424 return build_type_attribute_variant (t2, attributes);
426 /* Both real or both integers; use the one with greater precision. */
428 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
429 return build_type_attribute_variant (t1, attributes);
430 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
431 return build_type_attribute_variant (t2, attributes);
433 /* Same precision. Prefer longs to ints even when same size. */
435 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
436 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
437 return build_type_attribute_variant (long_unsigned_type_node,
440 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
441 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
443 /* But preserve unsignedness from the other type,
444 since long cannot hold all the values of an unsigned int. */
445 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
446 t1 = long_unsigned_type_node;
448 t1 = long_integer_type_node;
449 return build_type_attribute_variant (t1, attributes);
452 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
453 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
454 return build_type_attribute_variant (long_double_type_node,
457 /* Otherwise prefer the unsigned one. */
459 if (TREE_UNSIGNED (t1))
460 return build_type_attribute_variant (t1, attributes);
462 return build_type_attribute_variant (t2, attributes);
466 /* For two pointers, do this recursively on the target type,
467 and combine the qualifiers of the two types' targets. */
468 /* This code was turned off; I don't know why.
469 But ANSI C++ specifies doing this with the qualifiers.
470 So I turned it on again. */
472 tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (t1));
473 tree tt2 = TYPE_MAIN_VARIANT (TREE_TYPE (t2));
474 int type_quals = (CP_TYPE_QUALS (TREE_TYPE (t1))
475 | CP_TYPE_QUALS (TREE_TYPE (t2)));
480 else if (tt1 == void_type_node || tt2 == void_type_node)
481 target = void_type_node;
482 else if (tt1 == unknown_type_node)
484 else if (tt2 == unknown_type_node)
487 target = common_type (tt1, tt2);
489 target = cp_build_qualified_type (target, type_quals);
490 if (code1 == POINTER_TYPE)
491 t1 = build_pointer_type (target);
493 t1 = build_reference_type (target);
494 t1 = build_type_attribute_variant (t1, attributes);
496 if (TREE_CODE (target) == METHOD_TYPE)
497 t1 = build_ptrmemfunc_type (t1);
504 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
505 /* Save space: see if the result is identical to one of the args. */
506 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
507 return build_type_attribute_variant (t1, attributes);
508 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
509 return build_type_attribute_variant (t2, attributes);
510 /* Merge the element types, and have a size if either arg has one. */
511 t1 = build_cplus_array_type
512 (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
513 return build_type_attribute_variant (t1, attributes);
517 /* Function types: prefer the one that specified arg types.
518 If both do, merge the arg types. Also merge the return types. */
520 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
521 tree p1 = TYPE_ARG_TYPES (t1);
522 tree p2 = TYPE_ARG_TYPES (t2);
525 /* Save space: see if the result is identical to one of the args. */
526 if (valtype == TREE_TYPE (t1) && ! p2)
527 return build_type_attribute_variant (t1, attributes);
528 if (valtype == TREE_TYPE (t2) && ! p1)
529 return build_type_attribute_variant (t2, attributes);
531 /* Simple way if one arg fails to specify argument types. */
532 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
534 rval = build_function_type (valtype, p2);
535 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
536 rval = build_exception_variant (rval, raises);
537 return build_type_attribute_variant (rval, attributes);
539 raises = TYPE_RAISES_EXCEPTIONS (t1);
540 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
542 rval = build_function_type (valtype, p1);
544 rval = build_exception_variant (rval, raises);
545 return build_type_attribute_variant (rval, attributes);
548 rval = build_function_type (valtype, commonparms (p1, p2));
549 rval = build_exception_variant (rval, raises);
550 return build_type_attribute_variant (rval, attributes);
555 t1 = TYPE_MAIN_VARIANT (t1);
556 t2 = TYPE_MAIN_VARIANT (t2);
558 if (DERIVED_FROM_P (t1, t2) && binfo_or_else (t1, t2))
559 return build_type_attribute_variant (t1, attributes);
560 else if (binfo_or_else (t2, t1))
561 return build_type_attribute_variant (t2, attributes);
564 compiler_error ("common_type called with uncommon aggregate types");
565 return error_mark_node;
569 if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2)))
571 /* Get this value the long way, since TYPE_METHOD_BASETYPE
572 is just the main variant of this. */
576 tree b1 = TYPE_OFFSET_BASETYPE (t1);
577 tree b2 = TYPE_OFFSET_BASETYPE (t2);
579 if (same_type_p (b1, b2)
580 || (DERIVED_FROM_P (b1, b2) && binfo_or_else (b1, b2)))
581 basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
584 if (binfo_or_else (b2, b1) == NULL_TREE)
585 compiler_error ("common_type called with uncommon method types");
586 basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1)));
589 raises = TYPE_RAISES_EXCEPTIONS (t1);
591 /* If this was a member function type, get back to the
592 original type of type member function (i.e., without
593 the class instance variable up front. */
594 t1 = build_function_type (TREE_TYPE (t1),
595 TREE_CHAIN (TYPE_ARG_TYPES (t1)));
596 t2 = build_function_type (TREE_TYPE (t2),
597 TREE_CHAIN (TYPE_ARG_TYPES (t2)));
598 t3 = common_type (t1, t2);
599 t3 = build_cplus_method_type (basetype, TREE_TYPE (t3),
600 TYPE_ARG_TYPES (t3));
601 t1 = build_exception_variant (t3, raises);
604 compiler_error ("common_type called with uncommon method types");
606 return build_type_attribute_variant (t1, attributes);
609 if (TREE_TYPE (t1) == TREE_TYPE (t2))
611 tree b1 = TYPE_OFFSET_BASETYPE (t1);
612 tree b2 = TYPE_OFFSET_BASETYPE (t2);
614 if (same_type_p (b1, b2)
615 || (DERIVED_FROM_P (b1, b2) && binfo_or_else (b1, b2)))
616 return build_type_attribute_variant (t2, attributes);
617 else if (binfo_or_else (b2, b1))
618 return build_type_attribute_variant (t1, attributes);
620 compiler_error ("common_type called with uncommon member types");
623 return build_type_attribute_variant (t1, attributes);
627 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
630 compexcepttypes (t1, t2)
633 return TYPE_RAISES_EXCEPTIONS (t1) == TYPE_RAISES_EXCEPTIONS (t2);
636 /* Compare the array types T1 and T2, using CMP as the type comparison
637 function for the element types. STRICT is as for comptypes. */
640 comp_array_types (cmp, t1, t2, strict)
641 register int (*cmp) PROTO((tree, tree, int));
651 /* The type of the array elements must be the same. */
652 if (!(TREE_TYPE (t1) == TREE_TYPE (t2)
653 || (*cmp) (TREE_TYPE (t1), TREE_TYPE (t2),
654 strict & ~COMPARE_REDECLARATION)))
657 d1 = TYPE_DOMAIN (t1);
658 d2 = TYPE_DOMAIN (t2);
663 /* If one of the arrays is dimensionless, and the other has a
664 dimension, they are of different types. However, it is legal to
672 declarations for an array object can specify
673 array types that differ by the presence or absence of a major
674 array bound (_dcl.array_). */
676 return strict & COMPARE_REDECLARATION;
678 /* Check that the dimensions are the same. */
679 return (cp_tree_equal (TYPE_MIN_VALUE (d1),
681 && cp_tree_equal (TYPE_MAX_VALUE (d1),
682 TYPE_MAX_VALUE (d2)));
685 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
686 or various other operations. STRICT is a bitwise-or of the
690 comptypes (type1, type2, strict)
694 register tree t1 = type1;
695 register tree t2 = type2;
697 int orig_strict = strict;
699 /* The special exemption for redeclaring array types without an
700 array bound only applies at the top level:
705 is not legal, for example. */
706 strict &= ~COMPARE_REDECLARATION;
708 /* Suppress errors caused by previously reported errors */
712 /* This should never happen. */
713 my_friendly_assert (t1 != error_mark_node, 307);
715 if (t2 == error_mark_node)
718 if (strict & COMPARE_RELAXED)
720 /* Treat an enum type as the unsigned integer type of the same width. */
722 if (TREE_CODE (t1) == ENUMERAL_TYPE)
723 t1 = type_for_size (TYPE_PRECISION (t1), 1);
724 if (TREE_CODE (t2) == ENUMERAL_TYPE)
725 t2 = type_for_size (TYPE_PRECISION (t2), 1);
731 if (TYPE_PTRMEMFUNC_P (t1))
732 t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
733 if (TYPE_PTRMEMFUNC_P (t2))
734 t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
736 /* Different classes of types can't be compatible. */
737 if (TREE_CODE (t1) != TREE_CODE (t2))
740 /* Qualifiers must match. */
741 if (CP_TYPE_QUALS (t1) != CP_TYPE_QUALS (t2))
743 if (strict == COMPARE_STRICT
744 && TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
747 /* Allow for two different type nodes which have essentially the same
748 definition. Note that we already checked for equality of the type
749 qualifiers (just above). */
751 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
754 /* ??? COMP_TYPE_ATTRIBUTES is currently useless for variables as each
755 attribute is its own main variant (`val' will remain 0). */
756 #ifndef COMP_TYPE_ATTRIBUTES
757 #define COMP_TYPE_ATTRIBUTES(t1,t2) 1
760 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
761 if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2)))
764 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
767 switch (TREE_CODE (t1))
769 case TEMPLATE_TEMPLATE_PARM:
770 if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
771 || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
773 if (! comp_template_parms (DECL_TEMPLATE_PARMS (TYPE_NAME (t1)),
774 DECL_TEMPLATE_PARMS (TYPE_NAME (t2))))
776 if (!TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t1)
777 && ! TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2))
779 /* Don't check inheritance. */
780 strict = COMPARE_STRICT;
785 if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
786 && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
787 || TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM))
788 val = comp_template_args (TYPE_TI_ARGS (t1),
791 if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
796 if ((strict & COMPARE_RELAXED) && DERIVED_FROM_P (t2, t1))
804 val = (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1)),
805 build_pointer_type (TYPE_OFFSET_BASETYPE (t2)), strict)
806 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict));
810 if (! compexcepttypes (t1, t2))
813 /* This case is anti-symmetrical!
814 One can pass a base member (or member function)
815 to something expecting a derived member (or member function),
816 but not vice-versa! */
818 val = (comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict)
819 && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)));
826 /* first, check whether the referred types match with the
827 required level of strictness */
828 val = comptypes (t1, t2, strict);
831 if (TREE_CODE (t1) == RECORD_TYPE
832 && TREE_CODE (t2) == RECORD_TYPE)
837 if (! compexcepttypes (t1, t2))
840 val = ((TREE_TYPE (t1) == TREE_TYPE (t2)
841 || comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict))
842 && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)));
846 /* Target types must match incl. qualifiers. We use ORIG_STRICT
847 here since this is the one place where
848 COMPARE_REDECLARATION should be used. */
849 val = comp_array_types (comptypes, t1, t2, orig_strict);
852 case TEMPLATE_TYPE_PARM:
853 return TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
854 && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2);
857 if (TYPE_IDENTIFIER (t1) != TYPE_IDENTIFIER (t2))
859 return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
864 return attrval == 2 && val == 1 ? 2 : val;
867 /* Subroutine of comp_target-types. Make sure that the cv-quals change
868 only in the same direction as the target type. */
871 comp_cv_target_types (ttl, ttr, nptrs)
877 if (!at_least_as_qualified_p (ttl, ttr)
878 && !at_least_as_qualified_p (ttr, ttl))
879 /* The qualifications are incomparable. */
882 if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr))
883 return more_qualified_p (ttr, ttl) ? -1 : 1;
885 t = comp_target_types (ttl, ttr, nptrs);
886 if ((t == 1 && at_least_as_qualified_p (ttl, ttr))
887 || (t == -1 && at_least_as_qualified_p (ttr, ttl)))
893 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
894 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
895 converted to TTL. Return -1 means that TTL can be converted to TTR but
898 NPTRS is the number of pointers we can strip off and keep cool.
899 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
900 but to not permit B** to convert to A**.
902 This should go away. Callers should use can_convert or something
903 similar instead. (jason 17 Apr 1997) */
906 comp_target_types (ttl, ttr, nptrs)
910 ttl = TYPE_MAIN_VARIANT (ttl);
911 ttr = TYPE_MAIN_VARIANT (ttr);
915 if (TREE_CODE (ttr) != TREE_CODE (ttl))
918 if ((TREE_CODE (ttr) == POINTER_TYPE
919 || TREE_CODE (ttr) == REFERENCE_TYPE)
920 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
921 of the type pointed to. This is necessary for reference init
922 semantics. We won't get here from a previous call with nptrs == 1;
923 for multi-level pointers we end up in comp_ptr_ttypes. */
926 int is_ptr = TREE_CODE (ttr) == POINTER_TYPE;
928 ttl = TREE_TYPE (ttl);
929 ttr = TREE_TYPE (ttr);
933 if (TREE_CODE (ttl) == UNKNOWN_TYPE
934 || TREE_CODE (ttr) == UNKNOWN_TYPE)
936 else if (TREE_CODE (ttl) == VOID_TYPE
937 && TREE_CODE (ttr) != FUNCTION_TYPE
938 && TREE_CODE (ttr) != METHOD_TYPE
939 && TREE_CODE (ttr) != OFFSET_TYPE)
941 else if (TREE_CODE (ttr) == VOID_TYPE
942 && TREE_CODE (ttl) != FUNCTION_TYPE
943 && TREE_CODE (ttl) != METHOD_TYPE
944 && TREE_CODE (ttl) != OFFSET_TYPE)
946 else if (TREE_CODE (ttl) == POINTER_TYPE
947 || TREE_CODE (ttl) == ARRAY_TYPE)
949 if (comp_ptr_ttypes (ttl, ttr))
951 else if (comp_ptr_ttypes (ttr, ttl))
957 /* Const and volatile mean something different for function types,
958 so the usual checks are not appropriate. */
959 if (TREE_CODE (ttl) == FUNCTION_TYPE || TREE_CODE (ttl) == METHOD_TYPE)
960 return comp_target_types (ttl, ttr, nptrs - 1);
962 return comp_cv_target_types (ttl, ttr, nptrs - 1);
965 if (TREE_CODE (ttr) == ARRAY_TYPE)
966 return comp_array_types (comp_target_types, ttl, ttr, COMPARE_STRICT);
967 else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
974 if (!same_type_p (TREE_TYPE (ttl), TREE_TYPE (ttr)))
979 switch (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
988 argsl = TYPE_ARG_TYPES (ttl);
989 argsr = TYPE_ARG_TYPES (ttr);
991 /* Compare 'this' here, not in comp_target_parms. */
992 if (TREE_CODE (ttr) == METHOD_TYPE)
994 tree tl = TYPE_METHOD_BASETYPE (ttl);
995 tree tr = TYPE_METHOD_BASETYPE (ttr);
997 if (!same_or_base_type_p (tr, tl))
999 if (same_or_base_type_p (tl, tr))
1005 argsl = TREE_CHAIN (argsl);
1006 argsr = TREE_CHAIN (argsr);
1009 switch (comp_target_parms (argsl, argsr, 1))
1017 return saw_contra ? -1 : 1;
1020 else if (TREE_CODE (ttr) == OFFSET_TYPE)
1024 /* Contravariance: we can assign a pointer to base member to a pointer
1025 to derived member. Note difference from simple pointer case, where
1026 we can pass a pointer to derived to a pointer to base. */
1027 if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr),
1028 TYPE_OFFSET_BASETYPE (ttl)))
1030 else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl),
1031 TYPE_OFFSET_BASETYPE (ttr)))
1041 ttl = TREE_TYPE (ttl);
1042 ttr = TREE_TYPE (ttr);
1044 if (TREE_CODE (ttl) == POINTER_TYPE
1045 || TREE_CODE (ttl) == ARRAY_TYPE)
1047 if (comp_ptr_ttypes (ttl, ttr))
1053 if (comp_cv_target_types (ttl, ttr, nptrs) == 1)
1058 else if (IS_AGGR_TYPE (ttl))
1062 if (same_or_base_type_p (build_pointer_type (ttl),
1063 build_pointer_type (ttr)))
1065 if (same_or_base_type_p (build_pointer_type (ttr),
1066 build_pointer_type (ttl)))
1074 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1077 at_least_as_qualified_p (type1, type2)
1081 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1082 return ((CP_TYPE_QUALS (type1) & CP_TYPE_QUALS (type2))
1083 == CP_TYPE_QUALS (type2));
1086 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1089 more_qualified_p (type1, type2)
1093 return (CP_TYPE_QUALS (type1) != CP_TYPE_QUALS (type2)
1094 && at_least_as_qualified_p (type1, type2));
1097 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1098 more cv-qualified that TYPE1, and 0 otherwise. */
1101 comp_cv_qualification (type1, type2)
1105 if (CP_TYPE_QUALS (type1) == CP_TYPE_QUALS (type2))
1108 if (at_least_as_qualified_p (type1, type2))
1111 else if (at_least_as_qualified_p (type2, type1))
1117 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1118 subset of the cv-qualification signature of TYPE2, and the types
1119 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1122 comp_cv_qual_signature (type1, type2)
1126 if (comp_ptr_ttypes_real (type2, type1, -1))
1128 else if (comp_ptr_ttypes_real (type1, type2, -1))
1134 /* If two types share a common base type, return that basetype.
1135 If there is not a unique most-derived base type, this function
1136 returns ERROR_MARK_NODE. */
1139 common_base_type (tt1, tt2)
1142 tree best = NULL_TREE;
1145 /* If one is a baseclass of another, that's good enough. */
1146 if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1148 if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1151 /* Otherwise, try to find a unique baseclass of TT1
1152 that is shared by TT2, and follow that down. */
1153 for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
1155 tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
1156 tree trial = common_base_type (basetype, tt2);
1159 if (trial == error_mark_node)
1161 if (best == NULL_TREE)
1163 else if (best != trial)
1164 return error_mark_node;
1169 for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
1171 tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
1172 tree trial = common_base_type (tt1, basetype);
1175 if (trial == error_mark_node)
1177 if (best == NULL_TREE)
1179 else if (best != trial)
1180 return error_mark_node;
1186 /* Subroutines of `comptypes'. */
1188 /* Return 1 if two parameter type lists PARMS1 and PARMS2
1189 are equivalent in the sense that functions with those parameter types
1190 can have equivalent types.
1191 If either list is empty, we win.
1192 Otherwise, the two lists must be equivalent, element by element.
1194 C++: See comment above about TYPE1, TYPE2.
1196 STRICT is no longer used. */
1199 compparms (parms1, parms2)
1200 tree parms1, parms2;
1202 register tree t1 = parms1, t2 = parms2;
1204 /* An unspecified parmlist matches any specified parmlist
1205 whose argument types don't need default promotions. */
1209 if (t1 == 0 && t2 == 0)
1211 /* If one parmlist is shorter than the other,
1212 they fail to match. */
1213 if (t1 == 0 || t2 == 0)
1215 if (!same_type_p (TREE_VALUE (t2), TREE_VALUE (t1)))
1218 t1 = TREE_CHAIN (t1);
1219 t2 = TREE_CHAIN (t2);
1223 /* This really wants return whether or not parameter type lists
1224 would make their owning functions assignment compatible or not.
1226 The return value is like for comp_target_types.
1228 This should go away, possibly with the exception of the empty parmlist
1229 conversion; there are no conversions between function types in C++.
1230 (jason 17 Apr 1997) */
1233 comp_target_parms (parms1, parms2, strict)
1234 tree parms1, parms2;
1237 register tree t1 = parms1, t2 = parms2;
1238 int warn_contravariance = 0;
1240 /* In C, an unspecified parmlist matches any specified parmlist
1241 whose argument types don't need default promotions. This is not
1242 true for C++, but let's do it anyway for unfixed headers. */
1244 if (t1 == 0 && t2 != 0)
1246 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
1248 return self_promoting_args_p (t2);
1251 return self_promoting_args_p (t1);
1253 for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1257 /* If one parmlist is shorter than the other,
1258 they fail to match, unless STRICT is <= 0. */
1259 if (t1 == 0 || t2 == 0)
1264 return 1 + warn_contravariance;
1265 return ((t1 && TREE_PURPOSE (t1)) + warn_contravariance);
1267 p1 = TREE_VALUE (t1);
1268 p2 = TREE_VALUE (t2);
1269 if (same_type_p (p1, p2))
1275 if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
1276 || (TREE_CODE (p1) == REFERENCE_TYPE
1277 && TREE_CODE (p2) == REFERENCE_TYPE))
1280 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1))
1281 == TYPE_MAIN_VARIANT (TREE_TYPE (p2))))
1284 /* The following is wrong for contravariance,
1285 but many programs depend on it. */
1286 if (TREE_TYPE (p1) == void_type_node)
1288 if (TREE_TYPE (p2) == void_type_node)
1290 warn_contravariance = 1;
1293 if (IS_AGGR_TYPE (TREE_TYPE (p1))
1294 && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (p1)),
1295 TYPE_MAIN_VARIANT (TREE_TYPE (p2))))
1298 /* Note backwards order due to contravariance. */
1299 if (comp_target_types (p2, p1, 1) <= 0)
1301 if (comp_target_types (p1, p2, 1) > 0)
1303 warn_contravariance = 1;
1310 return warn_contravariance ? -1 : 1;
1313 /* Return 1 if PARMS specifies a fixed number of parameters
1314 and none of their types is affected by default promotions. */
1317 self_promoting_args_p (parms)
1321 for (t = parms; t; t = TREE_CHAIN (t))
1323 register tree type = TREE_VALUE (t);
1325 if (TREE_CHAIN (t) == 0 && type != void_type_node)
1331 if (TYPE_MAIN_VARIANT (type) == float_type_node)
1334 if (C_PROMOTING_INTEGER_TYPE_P (type))
1340 /* Return an unsigned type the same as TYPE in other respects.
1342 C++: must make these work for type variants as well. */
1345 unsigned_type (type)
1348 tree type1 = TYPE_MAIN_VARIANT (type);
1349 if (type1 == signed_char_type_node || type1 == char_type_node)
1350 return unsigned_char_type_node;
1351 if (type1 == integer_type_node)
1352 return unsigned_type_node;
1353 if (type1 == short_integer_type_node)
1354 return short_unsigned_type_node;
1355 if (type1 == long_integer_type_node)
1356 return long_unsigned_type_node;
1357 if (type1 == long_long_integer_type_node)
1358 return long_long_unsigned_type_node;
1359 #if HOST_BITS_PER_WIDE_INT >= 64
1360 if (type1 == intTI_type_node)
1361 return unsigned_intTI_type_node;
1363 if (type1 == intDI_type_node)
1364 return unsigned_intDI_type_node;
1365 if (type1 == intSI_type_node)
1366 return unsigned_intSI_type_node;
1367 if (type1 == intHI_type_node)
1368 return unsigned_intHI_type_node;
1369 if (type1 == intQI_type_node)
1370 return unsigned_intQI_type_node;
1372 return signed_or_unsigned_type (1, type);
1375 /* Return a signed type the same as TYPE in other respects. */
1381 tree type1 = TYPE_MAIN_VARIANT (type);
1382 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1383 return signed_char_type_node;
1384 if (type1 == unsigned_type_node)
1385 return integer_type_node;
1386 if (type1 == short_unsigned_type_node)
1387 return short_integer_type_node;
1388 if (type1 == long_unsigned_type_node)
1389 return long_integer_type_node;
1390 if (type1 == long_long_unsigned_type_node)
1391 return long_long_integer_type_node;
1392 #if HOST_BITS_PER_WIDE_INT >= 64
1393 if (type1 == unsigned_intTI_type_node)
1394 return intTI_type_node;
1396 if (type1 == unsigned_intDI_type_node)
1397 return intDI_type_node;
1398 if (type1 == unsigned_intSI_type_node)
1399 return intSI_type_node;
1400 if (type1 == unsigned_intHI_type_node)
1401 return intHI_type_node;
1402 if (type1 == unsigned_intQI_type_node)
1403 return intQI_type_node;
1405 return signed_or_unsigned_type (0, type);
1408 /* Return a type the same as TYPE except unsigned or
1409 signed according to UNSIGNEDP. */
1412 signed_or_unsigned_type (unsignedp, type)
1416 if (! INTEGRAL_TYPE_P (type)
1417 || TREE_UNSIGNED (type) == unsignedp)
1420 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1421 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1422 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1423 return unsignedp ? unsigned_type_node : integer_type_node;
1424 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1425 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1426 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1427 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1428 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1429 return (unsignedp ? long_long_unsigned_type_node
1430 : long_long_integer_type_node);
1434 /* Compute the value of the `sizeof' operator. */
1440 enum tree_code code = TREE_CODE (type);
1443 if (processing_template_decl)
1444 return build_min (SIZEOF_EXPR, sizetype, type);
1446 if (code == FUNCTION_TYPE)
1448 if (pedantic || warn_pointer_arith)
1449 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1450 return size_int (1);
1452 if (code == METHOD_TYPE)
1454 if (pedantic || warn_pointer_arith)
1455 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1456 return size_int (1);
1458 if (code == VOID_TYPE)
1460 if (pedantic || warn_pointer_arith)
1461 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1462 return size_int (1);
1464 if (code == ERROR_MARK)
1465 return size_int (1);
1467 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1468 referenced object.'' */
1469 if (code == REFERENCE_TYPE)
1470 type = TREE_TYPE (type);
1472 /* We couldn't find anything in the ARM or the draft standard that says,
1473 one way or the other, if doing sizeof on something that doesn't have
1474 an object associated with it is correct or incorrect. For example, if
1475 you declare `struct S { char str[16]; };', and in your program do
1476 a `sizeof (S::str)', should we flag that as an error or should we give
1477 the size of it? Since it seems like a reasonable thing to do, we'll go
1478 with giving the value. */
1479 if (code == OFFSET_TYPE)
1480 type = TREE_TYPE (type);
1482 /* @@ This also produces an error for a signature ref.
1483 In that case we should be able to do better. */
1484 if (IS_SIGNATURE (type))
1486 error ("`sizeof' applied to a signature type");
1487 return size_int (0);
1490 if (TYPE_SIZE (complete_type (type)) == 0)
1492 cp_error ("`sizeof' applied to incomplete type `%T'", type);
1493 return size_int (0);
1496 /* Convert in case a char is more than one unit. */
1497 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
1498 size_int (TYPE_PRECISION (char_type_node)));
1499 t = convert (sizetype, t);
1500 /* size_binop does not put the constant in range, so do it now. */
1501 if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
1502 TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
1510 if (processing_template_decl)
1511 return build_min (SIZEOF_EXPR, sizetype, e);
1513 if (TREE_CODE (e) == COMPONENT_REF
1514 && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1515 error ("sizeof applied to a bit-field");
1516 /* ANSI says arrays and functions are converted inside comma.
1517 But we can't really convert them in build_compound_expr
1518 because that would break commas in lvalues.
1519 So do the conversion here if operand was a comma. */
1520 if (TREE_CODE (e) == COMPOUND_EXPR
1521 && (TREE_CODE (TREE_TYPE (e)) == ARRAY_TYPE
1522 || TREE_CODE (TREE_TYPE (e)) == FUNCTION_TYPE))
1523 e = default_conversion (e);
1524 else if (is_overloaded_fn (e))
1526 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1527 return size_int (1);
1530 return c_sizeof (TREE_TYPE (e));
1534 c_sizeof_nowarn (type)
1537 enum tree_code code = TREE_CODE (type);
1540 if (code == FUNCTION_TYPE
1541 || code == METHOD_TYPE
1542 || code == VOID_TYPE
1543 || code == ERROR_MARK)
1544 return size_int (1);
1545 if (code == REFERENCE_TYPE)
1546 type = TREE_TYPE (type);
1548 if (TYPE_SIZE (type) == 0)
1549 return size_int (0);
1551 /* Convert in case a char is more than one unit. */
1552 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
1553 size_int (TYPE_PRECISION (char_type_node)));
1554 t = convert (sizetype, t);
1555 force_fit_type (t, 0);
1559 /* Implement the __alignof keyword: Return the minimum required
1560 alignment of TYPE, measured in bytes. */
1566 enum tree_code code = TREE_CODE (type);
1569 if (processing_template_decl)
1570 return build_min (ALIGNOF_EXPR, sizetype, type);
1572 if (code == FUNCTION_TYPE || code == METHOD_TYPE)
1573 return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1575 if (code == VOID_TYPE || code == ERROR_MARK)
1576 return size_int (1);
1578 /* C++: this is really correct! */
1579 if (code == REFERENCE_TYPE)
1580 type = TREE_TYPE (type);
1582 /* @@ This also produces an error for a signature ref.
1583 In that case we should be able to do better. */
1584 if (IS_SIGNATURE (type))
1586 error ("`__alignof' applied to a signature type");
1587 return size_int (1);
1590 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
1591 force_fit_type (t, 0);
1595 /* Perform default promotions for C data used in expressions.
1596 Arrays and functions are converted to pointers;
1597 enumeral types or short or char, to int.
1598 In addition, manifest constants symbols are replaced by their values.
1600 C++: this will automatically bash references to their target type. */
1603 decay_conversion (exp)
1606 register tree type = TREE_TYPE (exp);
1607 register enum tree_code code = TREE_CODE (type);
1609 if (code == OFFSET_TYPE)
1611 if (TREE_CODE (exp) == OFFSET_REF)
1612 return decay_conversion (resolve_offset_ref (exp));
1614 type = TREE_TYPE (type);
1615 code = TREE_CODE (type);
1617 if (type == unknown_type_node)
1619 cp_pedwarn ("assuming & on overloaded member function");
1620 return build_unary_op (ADDR_EXPR, exp, 0);
1624 if (code == REFERENCE_TYPE)
1626 exp = convert_from_reference (exp);
1627 type = TREE_TYPE (exp);
1628 code = TREE_CODE (type);
1631 /* Constants can be used directly unless they're not loadable. */
1632 if (TREE_CODE (exp) == CONST_DECL)
1633 exp = DECL_INITIAL (exp);
1634 /* Replace a nonvolatile const static variable with its value. */
1635 else if (TREE_READONLY_DECL_P (exp))
1637 exp = decl_constant_value (exp);
1638 type = TREE_TYPE (exp);
1641 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1642 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1644 if (code == VOID_TYPE)
1646 error ("void value not ignored as it ought to be");
1647 return error_mark_node;
1649 if (code == METHOD_TYPE)
1651 cp_pedwarn ("assuming & on `%E'", exp);
1652 return build_unary_op (ADDR_EXPR, exp, 0);
1654 if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1656 return build_unary_op (ADDR_EXPR, exp, 0);
1658 if (code == ARRAY_TYPE)
1663 if (TREE_CODE (exp) == INDIRECT_REF)
1665 /* Stripping away the INDIRECT_REF is not the right
1666 thing to do for references... */
1667 tree inner = TREE_OPERAND (exp, 0);
1668 if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
1670 inner = build1 (CONVERT_EXPR,
1671 build_pointer_type (TREE_TYPE
1672 (TREE_TYPE (inner))),
1674 TREE_CONSTANT (inner) = TREE_CONSTANT (TREE_OPERAND (inner, 0));
1676 return cp_convert (build_pointer_type (TREE_TYPE (type)), inner);
1679 if (TREE_CODE (exp) == COMPOUND_EXPR)
1681 tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1682 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1683 TREE_OPERAND (exp, 0), op1);
1687 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1689 error ("invalid use of non-lvalue array");
1690 return error_mark_node;
1693 ptrtype = build_pointer_type (TREE_TYPE (type));
1695 if (TREE_CODE (exp) == VAR_DECL)
1697 /* ??? This is not really quite correct
1698 in that the type of the operand of ADDR_EXPR
1699 is not the target type of the type of the ADDR_EXPR itself.
1700 Question is, can this lossage be avoided? */
1701 adr = build1 (ADDR_EXPR, ptrtype, exp);
1702 if (mark_addressable (exp) == 0)
1703 return error_mark_node;
1704 TREE_CONSTANT (adr) = staticp (exp);
1705 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1708 /* This way is better for a COMPONENT_REF since it can
1709 simplify the offset for a component. */
1710 adr = build_unary_op (ADDR_EXPR, exp, 1);
1711 return cp_convert (ptrtype, adr);
1718 default_conversion (exp)
1722 enum tree_code code;
1724 exp = decay_conversion (exp);
1726 type = TREE_TYPE (exp);
1727 code = TREE_CODE (type);
1729 if (INTEGRAL_CODE_P (code))
1731 tree t = type_promotes_to (type);
1733 return cp_convert (t, exp);
1739 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1743 inline_conversion (exp)
1746 if (TREE_CODE (exp) == FUNCTION_DECL)
1747 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1752 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1753 decay_conversion to one. */
1756 string_conv_p (totype, exp, warn)
1762 if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1765 t = TREE_TYPE (totype);
1766 if (!same_type_p (t, char_type_node)
1767 && !same_type_p (t, wchar_type_node))
1770 if (TREE_CODE (exp) == STRING_CST)
1772 /* Make sure that we don't try to convert between char and wchar_t. */
1773 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))) != t)
1778 /* Is this a string constant which has decayed to 'const char *'? */
1779 t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1780 if (!same_type_p (TREE_TYPE (exp), t))
1783 if (TREE_CODE (exp) != ADDR_EXPR
1784 || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1788 /* This warning is not very useful, as it complains about printf. */
1789 if (warn && warn_write_strings)
1790 cp_warning ("deprecated conversion from string constant to `%T'", totype);
1796 build_object_ref (datum, basetype, field)
1797 tree datum, basetype, field;
1800 if (datum == error_mark_node)
1801 return error_mark_node;
1803 dtype = TREE_TYPE (datum);
1804 if (TREE_CODE (dtype) == REFERENCE_TYPE)
1805 dtype = TREE_TYPE (dtype);
1806 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype)))
1808 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1809 basetype, field, dtype);
1810 return error_mark_node;
1812 else if (IS_SIGNATURE (basetype))
1814 warning ("signature name in scope resolution ignored");
1815 return build_component_ref (datum, field, NULL_TREE, 1);
1817 else if (is_aggr_type (basetype, 1))
1819 tree binfo = binfo_or_else (basetype, dtype);
1821 return build_x_component_ref (build_scoped_ref (datum, basetype),
1824 return error_mark_node;
1827 /* Like `build_component_ref, but uses an already found field, and converts
1828 from a reference. Must compute access for current_class_ref.
1832 build_component_ref_1 (datum, field, protect)
1836 return convert_from_reference
1837 (build_component_ref (datum, field, NULL_TREE, protect));
1840 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1841 can, for example, use as an lvalue. This code used to be in
1842 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1843 expressions, where we're dealing with aggregates. But now it's again only
1844 called from unary_complex_lvalue. The case (in particular) that led to
1845 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1849 rationalize_conditional_expr (code, t)
1850 enum tree_code code;
1853 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1854 the first operand is always the one to be used if both operands
1855 are equal, so we know what conditional expression this used to be. */
1856 if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1859 build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1860 ? LE_EXPR : GE_EXPR),
1861 TREE_OPERAND (t, 0),
1862 TREE_OPERAND (t, 1)),
1863 build_unary_op (code, TREE_OPERAND (t, 0), 0),
1864 build_unary_op (code, TREE_OPERAND (t, 1), 0));
1868 build_conditional_expr (TREE_OPERAND (t, 0),
1869 build_unary_op (code, TREE_OPERAND (t, 1), 0),
1870 build_unary_op (code, TREE_OPERAND (t, 2), 0));
1873 /* Given the TYPE of an anonymous union field inside T, return the
1874 FIELD_DECL for the field. If not found return NULL_TREE. Because
1875 anonymous unions can nest, we must also search all anonymous unions
1876 that are directly reachable. */
1879 lookup_anon_field (t, type)
1884 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1886 if (TREE_STATIC (field))
1888 if (TREE_CODE (field) != FIELD_DECL)
1891 /* If we find it directly, return the field. */
1892 if (DECL_NAME (field) == NULL_TREE
1893 && type == TREE_TYPE (field))
1898 /* Otherwise, it could be nested, search harder. */
1899 if (DECL_NAME (field) == NULL_TREE
1900 && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1902 tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1910 /* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT.
1911 COMPONENT can be an IDENTIFIER_NODE that is the name of the member
1912 that we are interested in, or it can be a FIELD_DECL. */
1915 build_component_ref (datum, component, basetype_path, protect)
1916 tree datum, component, basetype_path;
1919 register tree basetype;
1920 register enum tree_code code;
1921 register tree field = NULL;
1926 if (processing_template_decl)
1927 return build_min_nt (COMPONENT_REF, datum, component);
1929 if (datum == error_mark_node
1930 || TREE_TYPE (datum) == error_mark_node)
1931 return error_mark_node;
1933 /* BASETYPE holds the type of the class containing the COMPONENT. */
1934 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1936 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
1938 switch (TREE_CODE (datum))
1942 tree value = build_component_ref (TREE_OPERAND (datum, 1), component,
1943 basetype_path, protect);
1944 return build (COMPOUND_EXPR, TREE_TYPE (value),
1945 TREE_OPERAND (datum, 0), value);
1948 return build_conditional_expr
1949 (TREE_OPERAND (datum, 0),
1950 build_component_ref (TREE_OPERAND (datum, 1), component,
1951 basetype_path, protect),
1952 build_component_ref (TREE_OPERAND (datum, 2), component,
1953 basetype_path, protect));
1956 cp_error ("invalid use of %D", datum);
1957 datum = error_mark_node;
1964 code = TREE_CODE (basetype);
1966 if (code == REFERENCE_TYPE)
1968 datum = convert_from_reference (datum);
1969 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1970 code = TREE_CODE (basetype);
1972 if (TREE_CODE (datum) == OFFSET_REF)
1974 datum = resolve_offset_ref (datum);
1975 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1976 code = TREE_CODE (basetype);
1979 /* First, see if there is a field or component with name COMPONENT. */
1980 if (TREE_CODE (component) == TREE_LIST)
1982 /* I could not trigger this code. MvL */
1983 my_friendly_abort (980326);
1985 my_friendly_assert (!(TREE_CHAIN (component) == NULL_TREE
1986 && DECL_CHAIN (TREE_VALUE (component)) == NULL_TREE), 309);
1988 return build (COMPONENT_REF, TREE_TYPE (component), datum, component);
1991 if (! IS_AGGR_TYPE_CODE (code))
1993 if (code != ERROR_MARK)
1994 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1995 component, datum, basetype);
1996 return error_mark_node;
1999 if (!complete_type_or_else (basetype))
2000 return error_mark_node;
2002 if (TREE_CODE (component) == BIT_NOT_EXPR)
2004 if (TYPE_IDENTIFIER (basetype) != TREE_OPERAND (component, 0))
2006 cp_error ("destructor specifier `%T::~%T' must have matching names",
2007 basetype, TREE_OPERAND (component, 0));
2008 return error_mark_node;
2010 if (! TYPE_HAS_DESTRUCTOR (basetype))
2012 cp_error ("type `%T' has no destructor", basetype);
2013 return error_mark_node;
2015 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 1);
2018 /* Look up component name in the structure type definition. */
2019 if (CLASSTYPE_VFIELD (basetype)
2020 && DECL_NAME (CLASSTYPE_VFIELD (basetype)) == component)
2021 /* Special-case this because if we use normal lookups in an ambiguous
2022 hierarchy, the compiler will abort (because vptr lookups are
2023 not supposed to be ambiguous. */
2024 field = CLASSTYPE_VFIELD (basetype);
2025 else if (TREE_CODE (component) == FIELD_DECL)
2027 else if (TREE_CODE (component) == TYPE_DECL)
2029 cp_error ("invalid use of type decl `%#D' as expression", component);
2030 return error_mark_node;
2034 tree name = component;
2035 if (TREE_CODE (component) == VAR_DECL)
2036 name = DECL_NAME (component);
2037 if (basetype_path == NULL_TREE)
2038 basetype_path = TYPE_BINFO (basetype);
2039 field = lookup_field (basetype_path, name,
2040 protect && !VFIELD_NAME_P (name), 0);
2041 if (field == error_mark_node)
2042 return error_mark_node;
2044 if (field == NULL_TREE)
2046 /* Not found as a data field, look for it as a method. If found,
2047 then if this is the only possible one, return it, else
2048 report ambiguity error. */
2049 tree fndecls = lookup_fnfields (basetype_path, name, 1);
2050 if (fndecls == error_mark_node)
2051 return error_mark_node;
2054 /* If the function is unique and static, we can resolve it
2055 now. Otherwise, we have to wait and see what context it is
2056 used in; a component_ref involving a non-static member
2057 function can only be used in a call (expr.ref). */
2059 if (TREE_CHAIN (fndecls) == NULL_TREE
2060 && TREE_CODE (TREE_VALUE (fndecls)) == FUNCTION_DECL)
2062 if (DECL_STATIC_FUNCTION_P (TREE_VALUE (fndecls)))
2064 tree fndecl = TREE_VALUE (fndecls);
2065 enforce_access (TREE_PURPOSE (fndecls), fndecl);
2071 /* A unique non-static member function. Other parts
2072 of the compiler expect something with
2073 unknown_type_node to be really overloaded, so
2075 TREE_VALUE (fndecls)
2076 = scratch_ovl_cons (TREE_VALUE (fndecls), NULL_TREE);
2080 ref = build (COMPONENT_REF, unknown_type_node,
2085 cp_error ("`%#T' has no member named `%D'", basetype, name);
2086 return error_mark_node;
2088 else if (TREE_TYPE (field) == error_mark_node)
2089 return error_mark_node;
2091 if (TREE_CODE (field) != FIELD_DECL)
2093 if (TREE_CODE (field) == TYPE_DECL)
2094 cp_pedwarn ("invalid use of type decl `%#D' as expression", field);
2095 else if (DECL_RTL (field) != 0)
2098 TREE_USED (field) = 1;
2103 /* See if we have to do any conversions so that we pick up the field from the
2105 if (DECL_FIELD_CONTEXT (field) != basetype)
2107 tree context = DECL_FIELD_CONTEXT (field);
2108 tree base = context;
2109 while (!same_type_p (base, basetype) && TYPE_NAME (base)
2110 && ANON_UNION_TYPE_P (base))
2112 base = TYPE_CONTEXT (base);
2115 /* Handle base classes here... */
2116 if (base != basetype && TYPE_USES_COMPLEX_INHERITANCE (basetype))
2118 tree addr = build_unary_op (ADDR_EXPR, datum, 0);
2119 if (integer_zerop (addr))
2121 error ("invalid reference to NULL ptr, use ptr-to-member instead");
2122 return error_mark_node;
2124 if (VBASE_NAME_P (DECL_NAME (field)))
2126 /* It doesn't matter which vbase pointer we grab, just
2127 find one of them. */
2128 tree binfo = get_binfo (base,
2129 TREE_TYPE (TREE_TYPE (addr)), 0);
2130 addr = convert_pointer_to_real (binfo, addr);
2133 addr = convert_pointer_to (base, addr);
2134 datum = build_indirect_ref (addr, NULL_PTR);
2135 my_friendly_assert (datum != error_mark_node, 311);
2139 /* Handle things from anon unions here... */
2140 if (TYPE_NAME (context) && ANON_UNION_TYPE_P (context))
2142 tree subfield = lookup_anon_field (basetype, context);
2143 tree subdatum = build_component_ref (datum, subfield,
2144 basetype_path, protect);
2145 return build_component_ref (subdatum, field, basetype_path, protect);
2149 /* Compute the type of the field, as described in [expr.ref]. */
2150 type_quals = TYPE_UNQUALIFIED;
2151 field_type = TREE_TYPE (field);
2152 if (TREE_CODE (field_type) == REFERENCE_TYPE)
2153 /* The standard says that the type of the result should be the
2154 type referred to by the reference. But for now, at least, we
2155 do the conversion from reference type later. */
2159 type_quals = (CP_TYPE_QUALS (field_type)
2160 | CP_TYPE_QUALS (TREE_TYPE (datum)));
2162 /* A field is const (volatile) if the enclosing object, or the
2163 field itself, is const (volatile). But, a mutable field is
2164 not const, even within a const object. */
2165 if (DECL_LANG_SPECIFIC (field) && DECL_MUTABLE_P (field))
2166 type_quals &= ~TYPE_QUAL_CONST;
2167 if (!IS_SIGNATURE (field_type))
2168 field_type = cp_build_qualified_type (field_type, type_quals);
2171 ref = fold (build (COMPONENT_REF, field_type,
2172 break_out_cleanups (datum), field));
2174 /* Mark the expression const or volatile, as appropriate. Even
2175 though we've dealt with the type above, we still have to mark the
2176 expression itself. */
2177 if (type_quals & TYPE_QUAL_CONST)
2178 TREE_READONLY (ref) = 1;
2179 else if (type_quals & TYPE_QUAL_VOLATILE)
2180 TREE_THIS_VOLATILE (ref) = 1;
2185 /* Variant of build_component_ref for use in expressions, which should
2186 never have REFERENCE_TYPE. */
2189 build_x_component_ref (datum, component, basetype_path, protect)
2190 tree datum, component, basetype_path;
2193 tree t = build_component_ref (datum, component, basetype_path, protect);
2195 if (! processing_template_decl)
2196 t = convert_from_reference (t);
2201 /* Given an expression PTR for a pointer, return an expression
2202 for the value pointed to.
2203 ERRORSTRING is the name of the operator to appear in error messages.
2205 This function may need to overload OPERATOR_FNNAME.
2206 Must also handle REFERENCE_TYPEs for C++. */
2209 build_x_indirect_ref (ptr, errorstring)
2215 if (processing_template_decl)
2216 return build_min_nt (INDIRECT_REF, ptr);
2218 rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE,
2222 return build_indirect_ref (ptr, errorstring);
2226 build_indirect_ref (ptr, errorstring)
2230 register tree pointer, type;
2232 if (ptr == error_mark_node)
2233 return error_mark_node;
2235 pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2236 ? ptr : default_conversion (ptr));
2237 type = TREE_TYPE (pointer);
2239 if (ptr == current_class_ptr)
2240 return current_class_ref;
2242 if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
2246 If the type of the expression is "pointer to T," the type
2247 of the result is "T."
2249 We must use the canonical variant because certain parts of
2250 the back end, like fold, do pointer comparisons between
2252 tree t = canonical_type_variant (TREE_TYPE (type));
2254 if (TREE_CODE (pointer) == ADDR_EXPR
2256 && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2257 /* The POINTER was something like `&x'. We simplify `*&x' to
2259 return TREE_OPERAND (pointer, 0);
2262 tree ref = build1 (INDIRECT_REF, t, pointer);
2264 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2265 so that we get the proper error message if the result is used
2266 to assign to. Also, &* is supposed to be a no-op. */
2267 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2268 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2269 TREE_SIDE_EFFECTS (ref)
2270 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer)
2275 /* `pointer' won't be an error_mark_node if we were given a
2276 pointer to member, so it's cool to check for this here. */
2277 else if (TYPE_PTRMEM_P (type) || TYPE_PTRMEMFUNC_P (type))
2278 error ("invalid use of `%s' on pointer to member", errorstring);
2279 else if (TREE_CODE (type) == RECORD_TYPE
2280 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
2281 error ("cannot dereference signature pointer/reference");
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 (array, idx)
2311 error ("subscript missing in array reference");
2312 return error_mark_node;
2315 if (TREE_TYPE (array) == error_mark_node
2316 || TREE_TYPE (idx) == error_mark_node)
2317 return error_mark_node;
2319 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
2320 && TREE_CODE (array) != INDIRECT_REF)
2324 /* Subscripting with type char is likely to lose
2325 on a machine where chars are signed.
2326 So warn on any machine, but optionally.
2327 Don't warn for unsigned char since that type is safe.
2328 Don't warn for signed char because anyone who uses that
2329 must have done so deliberately. */
2330 if (warn_char_subscripts
2331 && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2332 warning ("array subscript has type `char'");
2334 /* Apply default promotions *after* noticing character types. */
2335 idx = default_conversion (idx);
2337 if (TREE_CODE (TREE_TYPE (idx)) != INTEGER_TYPE)
2339 error ("array subscript is not an integer");
2340 return error_mark_node;
2343 /* An array that is indexed by a non-constant
2344 cannot be stored in a register; we must be able to do
2345 address arithmetic on its address.
2346 Likewise an array of elements of variable size. */
2347 if (TREE_CODE (idx) != INTEGER_CST
2348 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
2349 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2352 if (mark_addressable (array) == 0)
2353 return error_mark_node;
2355 /* An array that is indexed by a constant value which is not within
2356 the array bounds cannot be stored in a register either; because we
2357 would get a crash in store_bit_field/extract_bit_field when trying
2358 to access a non-existent part of the register. */
2359 if (TREE_CODE (idx) == INTEGER_CST
2360 && TYPE_VALUES (TREE_TYPE (array))
2361 && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
2363 if (mark_addressable (array) == 0)
2364 return error_mark_node;
2367 if (pedantic && !lvalue_p (array))
2368 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
2370 /* Note in C++ it is valid to subscript a `register' array, since
2371 it is valid to take the address of something with that
2372 storage specification. */
2376 while (TREE_CODE (foo) == COMPONENT_REF)
2377 foo = TREE_OPERAND (foo, 0);
2378 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2379 warning ("subscripting array declared `register'");
2382 type = TREE_TYPE (TREE_TYPE (array));
2383 rval = build (ARRAY_REF, type, array, idx);
2384 /* Array ref is const/volatile if the array elements are
2385 or if the array is.. */
2386 TREE_READONLY (rval)
2387 |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2388 TREE_SIDE_EFFECTS (rval)
2389 |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2390 TREE_THIS_VOLATILE (rval)
2391 |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2392 return require_complete_type (fold (rval));
2396 tree ar = default_conversion (array);
2397 tree ind = default_conversion (idx);
2399 /* Put the integer in IND to simplify error checking. */
2400 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2407 if (ar == error_mark_node)
2410 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2412 error ("subscripted value is neither array nor pointer");
2413 return error_mark_node;
2415 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2417 error ("array subscript is not an integer");
2418 return error_mark_node;
2421 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar,
2427 /* Build a function call to function FUNCTION with parameters PARAMS.
2428 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2429 TREE_VALUE of each node is a parameter-expression. The PARAMS do
2430 not include any object pointer that may be required. FUNCTION's
2431 data type may be a function type or a pointer-to-function.
2433 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2434 is the list of possible methods that FUNCTION could conceivably
2435 be. If the list of methods comes from a class, then it will be
2436 a list of lists (where each element is associated with the class
2437 that produced it), otherwise it will be a simple list (for
2438 functions overloaded in global scope).
2440 In the first case, TREE_VALUE (function) is the head of one of those
2441 lists, and TREE_PURPOSE is the name of the function.
2443 In the second case, TREE_PURPOSE (function) is the function's
2446 DECL is the class instance variable, usually CURRENT_CLASS_REF.
2448 When calling a TEMPLATE_DECL, we don't require a complete return
2452 build_x_function_call (function, params, decl)
2453 tree function, params, decl;
2456 tree template_id = NULL_TREE;
2459 if (function == error_mark_node)
2460 return error_mark_node;
2462 if (processing_template_decl)
2463 return build_min_nt (CALL_EXPR, function, params, NULL_TREE);
2465 /* Save explicit template arguments if found */
2466 if (TREE_CODE (function) == TEMPLATE_ID_EXPR)
2468 template_id = function;
2469 function = TREE_OPERAND (function, 0);
2472 type = TREE_TYPE (function);
2474 if (TREE_CODE (type) == OFFSET_TYPE
2475 && TREE_TYPE (type) == unknown_type_node
2476 && TREE_CODE (function) == TREE_LIST
2477 && TREE_CHAIN (function) == NULL_TREE)
2479 /* Undo (Foo:bar)()... */
2480 type = TYPE_OFFSET_BASETYPE (type);
2481 function = TREE_VALUE (function);
2482 my_friendly_assert (TREE_CODE (function) == TREE_LIST, 999);
2483 my_friendly_assert (TREE_CHAIN (function) == NULL_TREE, 999);
2484 function = TREE_VALUE (function);
2485 if (TREE_CODE (function) == OVERLOAD)
2486 function = OVL_FUNCTION (function);
2487 my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 999);
2488 function = DECL_NAME (function);
2489 return build_method_call (decl, function, params,
2490 TYPE_BINFO (type), LOOKUP_NORMAL);
2493 is_method = ((TREE_CODE (function) == TREE_LIST
2494 && current_class_type != NULL_TREE
2495 && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function))
2497 || TREE_CODE (function) == IDENTIFIER_NODE
2498 || TREE_CODE (type) == METHOD_TYPE
2499 || TYPE_PTRMEMFUNC_P (type));
2501 if ((TREE_CODE (function) == FUNCTION_DECL
2502 && DECL_STATIC_FUNCTION_P (function))
2503 || (TREE_CODE (function) == TEMPLATE_DECL
2504 && DECL_STATIC_FUNCTION_P (DECL_RESULT (function))))
2505 return build_member_call
2506 (DECL_CONTEXT (function), DECL_NAME (function), params);
2508 /* A friend template. Make it look like a toplevel declaration. */
2509 if (! is_method && TREE_CODE (function) == TEMPLATE_DECL)
2510 function = scratch_ovl_cons (function, NULL_TREE);
2512 /* Handle methods, friends, and overloaded functions, respectively. */
2515 tree basetype = NULL_TREE;
2517 if (TREE_CODE (function) == FUNCTION_DECL
2518 || DECL_FUNCTION_TEMPLATE_P (function))
2520 basetype = DECL_CLASS_CONTEXT (function);
2522 if (DECL_NAME (function))
2523 function = DECL_NAME (function);
2525 function = TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function));
2527 else if (TREE_CODE (function) == TREE_LIST)
2529 my_friendly_assert (TREE_CODE (TREE_VALUE (function))
2530 == FUNCTION_DECL, 312);
2531 basetype = DECL_CLASS_CONTEXT (TREE_VALUE (function));
2532 function = TREE_PURPOSE (function);
2534 else if (TREE_CODE (function) != IDENTIFIER_NODE)
2536 if (TREE_CODE (function) == OFFSET_REF)
2538 if (TREE_OPERAND (function, 0))
2539 decl = TREE_OPERAND (function, 0);
2541 /* Call via a pointer to member function. */
2542 if (decl == NULL_TREE)
2544 error ("pointer to member function called, but not in class scope");
2545 return error_mark_node;
2547 /* What other type of POINTER_TYPE could this be? */
2548 if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE
2549 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function))
2550 && TREE_CODE (function) != OFFSET_REF)
2551 function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE,
2556 /* this is an abbreviated method call.
2557 must go through here in case it is a virtual function.
2558 @@ Perhaps this could be optimized. */
2560 if (basetype && (! current_class_type
2561 || ! DERIVED_FROM_P (basetype, current_class_type)))
2562 return build_member_call (basetype, function, params);
2564 if (decl == NULL_TREE)
2566 if (current_class_type == NULL_TREE)
2568 error ("object missing in call to method `%s'",
2569 IDENTIFIER_POINTER (function));
2570 return error_mark_node;
2572 /* Yow: call from a static member function. */
2573 decl = build_dummy_object (current_class_type);
2576 /* Put back explicit template arguments, if any. */
2578 function = template_id;
2579 return build_method_call (decl, function, params,
2580 NULL_TREE, LOOKUP_NORMAL);
2582 else if (TREE_CODE (function) == COMPONENT_REF
2583 && type == unknown_type_node)
2585 /* Undo what we did in build_component_ref. */
2586 decl = TREE_OPERAND (function, 0);
2587 function = TREE_OPERAND (function, 1);
2588 function = DECL_NAME (OVL_CURRENT (TREE_VALUE (function)));
2589 return build_method_call (decl, function, params,
2590 NULL_TREE, LOOKUP_NORMAL);
2592 else if (really_overloaded_fn (function))
2594 if (OVL_FUNCTION (function) == NULL_TREE)
2596 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2597 TREE_PURPOSE (function));
2598 return error_mark_node;
2602 /* Put back explicit template arguments, if any. */
2604 function = template_id;
2605 return build_new_function_call (function, params);
2609 /* Remove a potential OVERLOAD around it */
2610 function = OVL_CURRENT (function);
2613 if (TREE_CODE (function) == OFFSET_REF)
2615 /* If the component is a data element (or a virtual function), we play
2616 games here to make things work. */
2619 if (TREE_OPERAND (function, 0))
2620 decl = TREE_OPERAND (function, 0);
2622 decl = current_class_ref;
2624 decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
2626 /* Sigh. OFFSET_REFs are being used for too many things.
2627 They're being used both for -> and ->*, and we want to resolve
2628 the -> cases here, but leave the ->*. We could use
2629 resolve_offset_ref for those, too, but it would call
2630 get_member_function_from_ptrfunc and decl_addr wouldn't get
2631 updated properly. Nasty. */
2632 if (TREE_CODE (TREE_OPERAND (function, 1)) == FIELD_DECL)
2633 function = resolve_offset_ref (function);
2635 function = TREE_OPERAND (function, 1);
2637 function = get_member_function_from_ptrfunc (&decl_addr, function);
2638 params = expr_tree_cons (NULL_TREE, decl_addr, params);
2639 return build_function_call (function, params);
2642 type = TREE_TYPE (function);
2643 if (type != error_mark_node)
2645 if (TREE_CODE (type) == REFERENCE_TYPE)
2646 type = TREE_TYPE (type);
2648 if (IS_AGGR_TYPE (type))
2649 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, function, params, NULL_TREE);
2654 tree fntype = TREE_TYPE (function);
2655 tree ctypeptr = NULL_TREE;
2657 /* Explicitly named method? */
2658 if (TREE_CODE (function) == FUNCTION_DECL)
2659 ctypeptr = build_pointer_type (DECL_CLASS_CONTEXT (function));
2660 /* Expression with ptr-to-method type? It could either be a plain
2661 usage, or it might be a case where the ptr-to-method is being
2662 passed in as an argument. */
2663 else if (TYPE_PTRMEMFUNC_P (fntype))
2665 tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE
2666 (TYPE_PTRMEMFUNC_FN_TYPE (fntype)));
2667 ctypeptr = build_pointer_type (rec);
2669 /* Unexpected node type? */
2671 my_friendly_abort (116);
2672 if (decl == NULL_TREE)
2674 if (current_function_decl
2675 && DECL_STATIC_FUNCTION_P (current_function_decl))
2676 error ("invalid call to member function needing `this' in static member function scope");
2678 error ("pointer to member function called, but not in class scope");
2679 return error_mark_node;
2681 if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE
2682 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
2684 decl = build_unary_op (ADDR_EXPR, decl, 0);
2685 decl = convert_pointer_to (TREE_TYPE (ctypeptr), decl);
2688 decl = build_c_cast (ctypeptr, decl);
2689 params = expr_tree_cons (NULL_TREE, decl, params);
2692 return build_function_call (function, params);
2695 /* Resolve a pointer to member function. INSTANCE is the object
2696 instance to use, if the member points to a virtual member. */
2699 get_member_function_from_ptrfunc (instance_ptrptr, function)
2700 tree *instance_ptrptr;
2703 if (TREE_CODE (function) == OFFSET_REF)
2705 function = TREE_OPERAND (function, 1);
2708 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2710 tree fntype, idx, e1, delta, delta2, e2, e3, aref, vtbl;
2711 tree instance, basetype;
2713 tree instance_ptr = *instance_ptrptr;
2715 if (TREE_SIDE_EFFECTS (instance_ptr))
2716 instance_ptr = save_expr (instance_ptr);
2718 if (TREE_SIDE_EFFECTS (function))
2719 function = save_expr (function);
2721 fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2722 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2724 delta = cp_convert (ptrdiff_type_node,
2725 build_component_ref (function, delta_identifier,
2727 e3 = PFN_FROM_PTRMEMFUNC (function);
2729 if (TYPE_SIZE (basetype) != NULL_TREE
2730 && ! TYPE_VIRTUAL_P (basetype))
2731 /* If basetype doesn't have virtual functions, don't emit code to
2732 handle that case. */
2736 /* Promoting idx before saving it improves performance on RISC
2737 targets. Without promoting, the first compare used
2738 load-with-sign-extend, while the second used normal load then
2739 shift to sign-extend. An optimizer flaw, perhaps, but it's
2740 easier to make this change. */
2741 idx = save_expr (default_conversion
2742 (build_component_ref (function,
2745 e1 = build_binary_op (GT_EXPR, idx, integer_zero_node, 1);
2747 /* Convert down to the right base, before using the instance. */
2748 instance = convert_pointer_to_real (basetype, instance_ptr);
2749 if (instance == error_mark_node && instance_ptr != error_mark_node)
2752 vtbl = convert_pointer_to (ptr_type_node, instance);
2753 delta2 = DELTA2_FROM_PTRMEMFUNC (function);
2756 build_pointer_type (build_pointer_type (vtable_entry_type)),
2757 vtbl, cp_convert (ptrdiff_type_node, delta2));
2758 vtbl = build_indirect_ref (vtbl, NULL_PTR);
2759 aref = build_array_ref (vtbl, build_binary_op (MINUS_EXPR,
2761 integer_one_node, 1));
2762 if (! flag_vtable_thunks)
2764 aref = save_expr (aref);
2766 delta = build_binary_op
2768 build_conditional_expr (e1,
2769 build_component_ref (aref,
2776 if (flag_vtable_thunks)
2779 e2 = build_component_ref (aref, pfn_identifier, NULL_TREE, 0);
2780 TREE_TYPE (e2) = TREE_TYPE (e3);
2781 e1 = build_conditional_expr (e1, e2, e3);
2783 /* Make sure this doesn't get evaluated first inside one of the
2784 branches of the COND_EXPR. */
2785 if (TREE_CODE (instance_ptr) == SAVE_EXPR)
2786 e1 = build (COMPOUND_EXPR, TREE_TYPE (e1),
2790 *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
2791 instance_ptr, delta);
2793 if (instance_ptr == error_mark_node
2794 && TREE_CODE (e1) != ADDR_EXPR
2795 && TREE_CODE (TREE_OPERAND (e1, 0)) != FUNCTION_DECL)
2796 cp_error ("object missing in `%E'", function);
2804 build_function_call_real (function, params, require_complete, flags)
2805 tree function, params;
2806 int require_complete, flags;
2808 register tree fntype, fndecl;
2809 register tree value_type;
2810 register tree coerced_params;
2811 tree name = NULL_TREE, assembler_name = NULL_TREE;
2814 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2815 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2816 if (TREE_CODE (function) == NOP_EXPR
2817 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2818 function = TREE_OPERAND (function, 0);
2820 if (TREE_CODE (function) == FUNCTION_DECL)
2822 name = DECL_NAME (function);
2823 assembler_name = DECL_ASSEMBLER_NAME (function);
2825 GNU_xref_call (current_function_decl,
2826 IDENTIFIER_POINTER (name ? name
2827 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
2829 mark_used (function);
2832 /* Convert anything with function type to a pointer-to-function. */
2833 if (pedantic && DECL_MAIN_P (function))
2834 pedwarn ("ANSI C++ forbids calling `main' from within program");
2836 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2837 (because calling an inline function does not mean the function
2838 needs to be separately compiled). */
2840 if (DECL_INLINE (function))
2841 function = inline_conversion (function);
2843 function = build_addr_func (function);
2849 function = build_addr_func (function);
2852 if (function == error_mark_node)
2853 return error_mark_node;
2855 fntype = TREE_TYPE (function);
2857 if (TYPE_PTRMEMFUNC_P (fntype))
2859 cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2861 return error_mark_node;
2864 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2865 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2867 if (!((TREE_CODE (fntype) == POINTER_TYPE
2868 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2870 || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2872 cp_error ("`%E' cannot be used as a function", function);
2873 return error_mark_node;
2876 /* fntype now gets the type of function pointed to. */
2877 fntype = TREE_TYPE (fntype);
2879 /* Convert the parameters to the types declared in the
2880 function prototype, or apply default promotions. */
2882 if (flags & LOOKUP_COMPLAIN)
2883 coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2884 params, fndecl, LOOKUP_NORMAL);
2886 coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2889 if (coerced_params == error_mark_node)
2891 if (flags & LOOKUP_SPECULATIVELY)
2894 return error_mark_node;
2897 /* Check for errors in format strings. */
2899 if (warn_format && (name || assembler_name))
2900 check_function_format (name, assembler_name, coerced_params);
2902 /* Recognize certain built-in functions so we can make tree-codes
2903 other than CALL_EXPR. We do this when it enables fold-const.c
2904 to do something useful. */
2906 if (TREE_CODE (function) == ADDR_EXPR
2907 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2908 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2909 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
2914 if (coerced_params == 0)
2915 return integer_zero_node;
2916 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2923 value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
2925 register tree result
2926 = build_call (function, value_type, coerced_params);
2928 if (require_complete)
2930 if (value_type == void_type_node)
2932 result = require_complete_type (result);
2934 if (IS_AGGR_TYPE (value_type))
2935 result = build_cplus_new (value_type, result);
2936 return convert_from_reference (result);
2941 build_function_call (function, params)
2942 tree function, params;
2944 return build_function_call_real (function, params, 1, LOOKUP_NORMAL);
2947 /* Convert the actual parameter expressions in the list VALUES
2948 to the types in the list TYPELIST.
2949 If parmdecls is exhausted, or when an element has NULL as its type,
2950 perform the default conversions.
2952 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2954 This is also where warnings about wrong number of args are generated.
2956 Return a list of expressions for the parameters as converted.
2958 Both VALUES and the returned value are chains of TREE_LIST nodes
2959 with the elements of the list in the TREE_VALUE slots of those nodes.
2961 In C++, unspecified trailing parameters can be filled in with their
2962 default arguments, if such were specified. Do so here. */
2965 convert_arguments (typelist, values, fndecl, flags)
2966 tree typelist, values, fndecl;
2969 register tree typetail, valtail;
2970 register tree result = NULL_TREE;
2971 char *called_thing = 0;
2974 /* Argument passing is always copy-initialization. */
2975 flags |= LOOKUP_ONLYCONVERTING;
2979 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2981 if (DECL_NAME (fndecl) == NULL_TREE
2982 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2983 called_thing = "constructor";
2985 called_thing = "member function";
2988 called_thing = "function";
2991 for (valtail = values, typetail = typelist;
2993 valtail = TREE_CHAIN (valtail), i++)
2995 register tree type = typetail ? TREE_VALUE (typetail) : 0;
2996 register tree val = TREE_VALUE (valtail);
2998 if (val == error_mark_node)
2999 return error_mark_node;
3001 if (type == void_type_node)
3005 cp_error_at ("too many arguments to %s `%+D'", called_thing,
3007 error ("at this point in file");
3010 error ("too many arguments to function");
3011 /* In case anybody wants to know if this argument
3014 TREE_TYPE (tree_last (result)) = error_mark_node;
3018 if (TREE_CODE (val) == OFFSET_REF)
3019 val = resolve_offset_ref (val);
3021 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3022 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3023 if (TREE_CODE (val) == NOP_EXPR
3024 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3025 && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3026 val = TREE_OPERAND (val, 0);
3028 if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3030 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3031 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3032 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3033 val = default_conversion (val);
3035 val = require_complete_type (val);
3038 if (val == error_mark_node)
3039 return error_mark_node;
3043 /* Formal parm type is specified by a function prototype. */
3046 if (TYPE_SIZE (complete_type (type)) == 0)
3048 error ("parameter type of called function is incomplete");
3053 parmval = convert_for_initialization
3054 (NULL_TREE, type, val, flags,
3055 "argument passing", fndecl, i);
3056 #ifdef PROMOTE_PROTOTYPES
3057 if ((TREE_CODE (type) == INTEGER_TYPE
3058 || TREE_CODE (type) == ENUMERAL_TYPE)
3059 && (TYPE_PRECISION (type)
3060 < TYPE_PRECISION (integer_type_node)))
3061 parmval = default_conversion (parmval);
3065 if (parmval == error_mark_node)
3066 return error_mark_node;
3068 result = expr_tree_cons (NULL_TREE, parmval, result);
3072 if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
3073 val = convert_from_reference (val);
3075 result = expr_tree_cons (NULL_TREE,
3076 convert_arg_to_ellipsis (val),
3081 typetail = TREE_CHAIN (typetail);
3084 if (typetail != 0 && typetail != void_list_node)
3086 /* See if there are default arguments that can be used */
3087 if (TREE_PURPOSE (typetail))
3089 for (; typetail != void_list_node; ++i)
3092 = convert_default_arg (TREE_VALUE (typetail),
3093 TREE_PURPOSE (typetail),
3096 if (parmval == error_mark_node)
3097 return error_mark_node;
3099 result = expr_tree_cons (0, parmval, result);
3100 typetail = TREE_CHAIN (typetail);
3101 /* ends with `...'. */
3102 if (typetail == NULL_TREE)
3110 char *buf = (char *)alloca (32 + strlen (called_thing));
3111 sprintf (buf, "too few arguments to %s `%%#D'", called_thing);
3112 cp_error_at (buf, fndecl);
3113 error ("at this point in file");
3116 error ("too few arguments to function");
3117 return error_mark_list;
3121 return nreverse (result);
3124 /* Build a binary-operation expression, after performing default
3125 conversions on the operands. CODE is the kind of expression to build. */
3128 build_x_binary_op (code, arg1, arg2)
3129 enum tree_code code;
3132 if (processing_template_decl)
3133 return build_min_nt (code, arg1, arg2);
3135 return build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
3139 build_binary_op (code, arg1, arg2, convert_p)
3140 enum tree_code code;
3142 int convert_p ATTRIBUTE_UNUSED;
3144 return build_binary_op_nodefault (code, arg1, arg2, code);
3147 /* Build a binary-operation expression without default conversions.
3148 CODE is the kind of expression to build.
3149 This function differs from `build' in several ways:
3150 the data type of the result is computed and recorded in it,
3151 warnings are generated if arg data types are invalid,
3152 special handling for addition and subtraction of pointers is known,
3153 and some optimization is done (operations on narrow ints
3154 are done in the narrower type when that gives the same result).
3155 Constant folding is also done before the result is returned.
3157 ERROR_CODE is the code that determines what to say in error messages.
3158 It is usually, but not always, the same as CODE.
3160 Note that the operands will never have enumeral types
3161 because either they have just had the default conversions performed
3162 or they have both just been converted to some other type in which
3163 the arithmetic is to be done.
3165 C++: must do special pointer arithmetic when implementing
3166 multiple inheritance, and deal with pointer to member functions. */
3169 build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
3170 enum tree_code code;
3171 tree orig_op0, orig_op1;
3172 enum tree_code error_code;
3175 register enum tree_code code0, code1;
3178 /* Expression code to give to the expression when it is built.
3179 Normally this is CODE, which is what the caller asked for,
3180 but in some special cases we change it. */
3181 register enum tree_code resultcode = code;
3183 /* Data type in which the computation is to be performed.
3184 In the simplest cases this is the common type of the arguments. */
3185 register tree result_type = NULL;
3187 /* Nonzero means operands have already been type-converted
3188 in whatever way is necessary.
3189 Zero means they need to be converted to RESULT_TYPE. */
3192 /* Nonzero means create the expression with this type, rather than
3194 tree build_type = 0;
3196 /* Nonzero means after finally constructing the expression
3197 convert it to this type. */
3198 tree final_type = 0;
3200 /* Nonzero if this is an operation like MIN or MAX which can
3201 safely be computed in short if both args are promoted shorts.
3202 Also implies COMMON.
3203 -1 indicates a bitwise operation; this makes a difference
3204 in the exact conditions for when it is safe to do the operation
3205 in a narrower mode. */
3208 /* Nonzero if this is a comparison operation;
3209 if both args are promoted shorts, compare the original shorts.
3210 Also implies COMMON. */
3211 int short_compare = 0;
3213 /* Nonzero if this is a right-shift operation, which can be computed on the
3214 original short and then promoted if the operand is a promoted short. */
3215 int short_shift = 0;
3217 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3220 /* Apply default conversions. */
3221 if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3222 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3223 || code == TRUTH_XOR_EXPR)
3225 op0 = decay_conversion (orig_op0);
3226 op1 = decay_conversion (orig_op1);
3230 op0 = default_conversion (orig_op0);
3231 op1 = default_conversion (orig_op1);
3234 type0 = TREE_TYPE (op0);
3235 type1 = TREE_TYPE (op1);
3237 /* The expression codes of the data types of the arguments tell us
3238 whether the arguments are integers, floating, pointers, etc. */
3239 code0 = TREE_CODE (type0);
3240 code1 = TREE_CODE (type1);
3242 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3243 STRIP_TYPE_NOPS (op0);
3244 STRIP_TYPE_NOPS (op1);
3246 /* If an error was already reported for one of the arguments,
3247 avoid reporting another error. */
3249 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3250 return error_mark_node;
3255 /* Handle the pointer + int case. */
3256 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3257 return pointer_int_sum (PLUS_EXPR, op0, op1);
3258 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
3259 return pointer_int_sum (PLUS_EXPR, op1, op0);
3265 /* Subtraction of two similar pointers.
3266 We must subtract them as integers, then divide by object size. */
3267 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3268 && comp_target_types (type0, type1, 1))
3269 return pointer_diff (op0, op1, common_type (type0, type1));
3270 /* Handle pointer minus int. Just like pointer plus int. */
3271 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3272 return pointer_int_sum (MINUS_EXPR, op0, op1);
3281 case TRUNC_DIV_EXPR:
3283 case FLOOR_DIV_EXPR:
3284 case ROUND_DIV_EXPR:
3285 case EXACT_DIV_EXPR:
3286 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3287 || code0 == COMPLEX_TYPE)
3288 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3289 || code1 == COMPLEX_TYPE))
3291 if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
3292 cp_warning ("division by zero in `%E / 0'", op0);
3293 else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
3294 cp_warning ("division by zero in `%E / 0.'", op0);
3296 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
3297 resultcode = RDIV_EXPR;
3299 /* When dividing two signed integers, we have to promote to int.
3300 unless we divide by a constant != -1. Note that default
3301 conversion will have been performed on the operands at this
3302 point, so we have to dig out the original type to find out if
3304 shorten = ((TREE_CODE (op0) == NOP_EXPR
3305 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3306 || (TREE_CODE (op1) == INTEGER_CST
3307 && (TREE_INT_CST_LOW (op1) != -1
3308 || TREE_INT_CST_HIGH (op1) != -1)));
3314 case BIT_ANDTC_EXPR:
3317 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3319 /* If one operand is a constant, and the other is a short type
3320 that has been converted to an int,
3321 really do the work in the short type and then convert the
3322 result to int. If we are lucky, the constant will be 0 or 1
3323 in the short type, making the entire operation go away. */
3324 if (TREE_CODE (op0) == INTEGER_CST
3325 && TREE_CODE (op1) == NOP_EXPR
3326 && (TYPE_PRECISION (type1)
3327 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))
3328 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
3330 final_type = result_type;
3331 op1 = TREE_OPERAND (op1, 0);
3332 result_type = TREE_TYPE (op1);
3334 if (TREE_CODE (op1) == INTEGER_CST
3335 && TREE_CODE (op0) == NOP_EXPR
3336 && (TYPE_PRECISION (type0)
3337 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))
3338 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3340 final_type = result_type;
3341 op0 = TREE_OPERAND (op0, 0);
3342 result_type = TREE_TYPE (op0);
3346 case TRUNC_MOD_EXPR:
3347 case FLOOR_MOD_EXPR:
3348 if (code1 == INTEGER_TYPE && integer_zerop (op1))
3349 cp_warning ("division by zero in `%E %% 0'", op0);
3350 else if (code1 == REAL_TYPE && real_zerop (op1))
3351 cp_warning ("division by zero in `%E %% 0.'", op0);
3353 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3355 /* Although it would be tempting to shorten always here, that loses
3356 on some targets, since the modulo instruction is undefined if the
3357 quotient can't be represented in the computation mode. We shorten
3358 only if unsigned or if dividing by something we know != -1. */
3359 shorten = ((TREE_CODE (op0) == NOP_EXPR
3360 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3361 || (TREE_CODE (op1) == INTEGER_CST
3362 && (TREE_INT_CST_LOW (op1) != -1
3363 || TREE_INT_CST_HIGH (op1) != -1)));
3368 case TRUTH_ANDIF_EXPR:
3369 case TRUTH_ORIF_EXPR:
3370 case TRUTH_AND_EXPR:
3372 result_type = boolean_type_node;
3375 /* Shift operations: result has same type as first operand;
3376 always convert second operand to int.
3377 Also set SHORT_SHIFT if shifting rightward. */
3380 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3382 result_type = type0;
3383 if (TREE_CODE (op1) == INTEGER_CST)
3385 if (tree_int_cst_lt (op1, integer_zero_node))
3386 warning ("right shift count is negative");
3389 if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
3391 if (TREE_INT_CST_HIGH (op1) != 0
3392 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
3393 >= TYPE_PRECISION (type0)))
3394 warning ("right shift count >= width of type");
3397 /* Convert the shift-count to an integer, regardless of
3398 size of value being shifted. */
3399 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3400 op1 = cp_convert (integer_type_node, op1);
3401 /* Avoid converting op1 to result_type later. */
3407 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3409 result_type = type0;
3410 if (TREE_CODE (op1) == INTEGER_CST)
3412 if (tree_int_cst_lt (op1, integer_zero_node))
3413 warning ("left shift count is negative");
3414 else if (TREE_INT_CST_HIGH (op1) != 0
3415 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
3416 >= TYPE_PRECISION (type0)))
3417 warning ("left shift count >= width of type");
3419 /* Convert the shift-count to an integer, regardless of
3420 size of value being shifted. */
3421 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3422 op1 = cp_convert (integer_type_node, op1);
3423 /* Avoid converting op1 to result_type later. */
3430 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3432 result_type = type0;
3433 if (TREE_CODE (op1) == INTEGER_CST)
3435 if (tree_int_cst_lt (op1, integer_zero_node))
3436 warning ("%s rotate count is negative",
3437 (code == LROTATE_EXPR) ? "left" : "right");
3438 else if (TREE_INT_CST_HIGH (op1) != 0
3439 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
3440 >= TYPE_PRECISION (type0)))
3441 warning ("%s rotate count >= width of type",
3442 (code == LROTATE_EXPR) ? "left" : "right");
3444 /* Convert the shift-count to an integer, regardless of
3445 size of value being shifted. */
3446 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3447 op1 = cp_convert (integer_type_node, op1);
3453 build_type = boolean_type_node;
3454 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3455 || code0 == COMPLEX_TYPE)
3456 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3457 || code1 == COMPLEX_TYPE))
3459 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3461 register tree tt0 = TYPE_MAIN_VARIANT (TREE_TYPE (type0));
3462 register tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (type1));
3464 if (comp_target_types (type0, type1, 1))
3465 result_type = common_type (type0, type1);
3466 else if (tt0 == void_type_node)
3468 if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE
3469 && tree_int_cst_lt (TYPE_SIZE (type0), TYPE_SIZE (type1)))
3470 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3471 else if (TREE_CODE (tt1) == OFFSET_TYPE)
3472 pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
3474 else if (tt1 == void_type_node)
3476 if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE
3477 && tree_int_cst_lt (TYPE_SIZE (type1), TYPE_SIZE (type0)))
3478 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3481 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3484 if (result_type == NULL_TREE)
3485 result_type = ptr_type_node;
3487 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3488 && integer_zerop (op1))
3489 result_type = type0;
3490 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3491 && integer_zerop (op0))
3492 result_type = type1;
3493 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3495 result_type = type0;
3496 error ("ANSI C++ forbids comparison between pointer and integer");
3498 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3500 result_type = type1;
3501 error ("ANSI C++ forbids comparison between pointer and integer");
3503 else if (TYPE_PTRMEMFUNC_P (type0) && TREE_CODE (op1) == INTEGER_CST
3504 && integer_zerop (op1))
3506 op0 = build_component_ref (op0, index_identifier, NULL_TREE, 0);
3507 op1 = integer_zero_node;
3508 result_type = TREE_TYPE (op0);
3510 else if (TYPE_PTRMEMFUNC_P (type1) && TREE_CODE (op0) == INTEGER_CST
3511 && integer_zerop (op0))
3513 op0 = build_component_ref (op1, index_identifier, NULL_TREE, 0);
3514 op1 = integer_zero_node;
3515 result_type = TREE_TYPE (op0);
3517 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3518 && (TYPE_PTRMEMFUNC_FN_TYPE (type0)
3519 == TYPE_PTRMEMFUNC_FN_TYPE (type1)))
3521 /* The code we generate for the test is:
3523 (op0.index == op1.index
3524 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3525 || op0.pfn == op1.pfn)) */
3527 tree index0 = build_component_ref (op0, index_identifier,
3529 tree index1 = save_expr (build_component_ref (op1, index_identifier,
3531 tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
3532 tree pfn1 = PFN_FROM_PTRMEMFUNC (op1);
3533 tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
3534 tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1);
3536 tree integer_neg_one_node
3537 = build_binary_op (MINUS_EXPR, integer_zero_node,
3538 integer_one_node, 1);
3539 e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
3540 e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
3541 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
3542 build_binary_op (EQ_EXPR, delta20, delta21, 1),
3544 e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1);
3545 e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
3546 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
3547 if (code == EQ_EXPR)
3549 return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
3551 else if (TYPE_PTRMEMFUNC_P (type0)
3552 && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1)
3554 tree index0 = build_component_ref (op0, index_identifier,
3557 tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
3558 tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
3559 tree delta21 = integer_zero_node;
3561 tree integer_neg_one_node
3562 = build_binary_op (MINUS_EXPR, integer_zero_node, integer_one_node, 1);
3563 if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL
3564 && DECL_VINDEX (TREE_OPERAND (op1, 0)))
3566 /* Map everything down one to make room for
3567 the null pointer to member. */
3568 index1 = size_binop (PLUS_EXPR,
3569 DECL_VINDEX (TREE_OPERAND (op1, 0)),
3571 op1 = integer_zero_node;
3572 delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE
3573 (TREE_TYPE (type1)));
3574 delta21 = DECL_FIELD_BITPOS (delta21);
3575 delta21 = size_binop (FLOOR_DIV_EXPR, delta21,
3576 size_int (BITS_PER_UNIT));
3577 delta21 = convert (sizetype, delta21);
3580 index1 = integer_neg_one_node;
3582 tree nop1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0),
3584 TREE_CONSTANT (nop1) = TREE_CONSTANT (op1);
3587 e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
3588 e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
3589 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
3590 build_binary_op (EQ_EXPR, delta20, delta21, 1),
3592 e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1);
3593 e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
3594 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
3595 if (code == EQ_EXPR)
3597 return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
3599 else if (TYPE_PTRMEMFUNC_P (type1)
3600 && TYPE_PTRMEMFUNC_FN_TYPE (type1) == type0)
3602 return build_binary_op (code, op1, op0, 1);
3608 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3609 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3611 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3613 if (comp_target_types (type0, type1, 1))
3614 result_type = common_type (type0, type1);
3617 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3619 result_type = ptr_type_node;
3628 build_type = boolean_type_node;
3629 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3630 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3632 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3634 if (comp_target_types (type0, type1, 1))
3635 result_type = common_type (type0, type1);
3638 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3640 result_type = ptr_type_node;
3643 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3644 && integer_zerop (op1))
3645 result_type = type0;
3646 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3647 && integer_zerop (op0))
3648 result_type = type1;
3649 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3651 result_type = type0;
3652 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3654 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3656 result_type = type1;
3657 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3665 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3667 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
3669 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3671 if (shorten || common || short_compare)
3672 result_type = common_type (type0, type1);
3674 /* For certain operations (which identify themselves by shorten != 0)
3675 if both args were extended from the same smaller type,
3676 do the arithmetic in that type and then extend.
3678 shorten !=0 and !=1 indicates a bitwise operation.
3679 For them, this optimization is safe only if
3680 both args are zero-extended or both are sign-extended.
3681 Otherwise, we might change the result.
3682 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3683 but calculated in (unsigned short) it would be (unsigned short)-1. */
3685 if (shorten && none_complex)
3687 int unsigned0, unsigned1;
3688 tree arg0 = get_narrower (op0, &unsigned0);
3689 tree arg1 = get_narrower (op1, &unsigned1);
3690 /* UNS is 1 if the operation to be done is an unsigned one. */
3691 int uns = TREE_UNSIGNED (result_type);
3694 final_type = result_type;
3696 /* Handle the case that OP0 does not *contain* a conversion
3697 but it *requires* conversion to FINAL_TYPE. */
3699 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3700 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3701 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3702 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3704 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3706 /* For bitwise operations, signedness of nominal type
3707 does not matter. Consider only how operands were extended. */
3711 /* Note that in all three cases below we refrain from optimizing
3712 an unsigned operation on sign-extended args.
3713 That would not be valid. */
3715 /* Both args variable: if both extended in same way
3716 from same width, do it in that width.
3717 Do it unsigned if args were zero-extended. */
3718 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3719 < TYPE_PRECISION (result_type))
3720 && (TYPE_PRECISION (TREE_TYPE (arg1))
3721 == TYPE_PRECISION (TREE_TYPE (arg0)))
3722 && unsigned0 == unsigned1
3723 && (unsigned0 || !uns))
3725 = signed_or_unsigned_type (unsigned0,
3726 common_type (TREE_TYPE (arg0),
3728 else if (TREE_CODE (arg0) == INTEGER_CST
3729 && (unsigned1 || !uns)
3730 && (TYPE_PRECISION (TREE_TYPE (arg1))
3731 < TYPE_PRECISION (result_type))
3732 && (type = signed_or_unsigned_type (unsigned1,
3734 int_fits_type_p (arg0, type)))
3736 else if (TREE_CODE (arg1) == INTEGER_CST
3737 && (unsigned0 || !uns)
3738 && (TYPE_PRECISION (TREE_TYPE (arg0))
3739 < TYPE_PRECISION (result_type))
3740 && (type = signed_or_unsigned_type (unsigned0,
3742 int_fits_type_p (arg1, type)))
3746 /* Shifts can be shortened if shifting right. */
3751 tree arg0 = get_narrower (op0, &unsigned_arg);
3753 final_type = result_type;
3755 if (arg0 == op0 && final_type == TREE_TYPE (op0))
3756 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3758 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3759 /* We can shorten only if the shift count is less than the
3760 number of bits in the smaller type size. */
3761 && TREE_INT_CST_HIGH (op1) == 0
3762 && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
3763 /* If arg is sign-extended and then unsigned-shifted,
3764 we can simulate this with a signed shift in arg's type
3765 only if the extended result is at least twice as wide
3766 as the arg. Otherwise, the shift could use up all the
3767 ones made by sign-extension and bring in zeros.
3768 We can't optimize that case at all, but in most machines
3769 it never happens because available widths are 2**N. */
3770 && (!TREE_UNSIGNED (final_type)
3772 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3773 <= TYPE_PRECISION (result_type))))
3775 /* Do an unsigned shift if the operand was zero-extended. */
3777 = signed_or_unsigned_type (unsigned_arg,
3779 /* Convert value-to-be-shifted to that type. */
3780 if (TREE_TYPE (op0) != result_type)
3781 op0 = cp_convert (result_type, op0);
3786 /* Comparison operations are shortened too but differently.
3787 They identify themselves by setting short_compare = 1. */
3791 /* Don't write &op0, etc., because that would prevent op0
3792 from being kept in a register.
3793 Instead, make copies of the our local variables and
3794 pass the copies by reference, then copy them back afterward. */
3795 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3796 enum tree_code xresultcode = resultcode;
3798 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3800 return cp_convert (boolean_type_node, val);
3801 op0 = xop0, op1 = xop1;
3803 resultcode = xresultcode;
3806 if (short_compare && warn_sign_compare)
3808 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
3809 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
3811 int unsignedp0, unsignedp1;
3812 tree primop0 = get_narrower (op0, &unsignedp0);
3813 tree primop1 = get_narrower (op1, &unsignedp1);
3815 /* Check for comparison of different enum types. */
3816 if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3817 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3818 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3819 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3821 cp_warning ("comparison between `%#T' and `%#T'",
3822 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3825 /* Give warnings for comparisons between signed and unsigned
3826 quantities that may fail. */
3827 /* Do the checking based on the original operand trees, so that
3828 casts will be considered, but default promotions won't be. */
3830 /* Do not warn if the comparison is being done in a signed type,
3831 since the signed type will only be chosen if it can represent
3832 all the values of the unsigned type. */
3833 if (! TREE_UNSIGNED (result_type))
3835 /* Do not warn if both operands are unsigned. */
3836 else if (op0_signed == op1_signed)
3838 /* Do not warn if the signed quantity is an unsuffixed
3839 integer literal (or some static constant expression
3840 involving such literals) and it is non-negative. */
3841 else if ((op0_signed && TREE_CODE (orig_op0) == INTEGER_CST
3842 && tree_int_cst_sgn (orig_op0) >= 0)
3843 || (op1_signed && TREE_CODE (orig_op1) == INTEGER_CST
3844 && tree_int_cst_sgn (orig_op1) >= 0))
3846 /* Do not warn if the comparison is an equality operation,
3847 the unsigned quantity is an integral constant and it does
3848 not use the most significant bit of result_type. */
3849 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3850 && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3851 && int_fits_type_p (orig_op1,
3852 signed_type (result_type)))
3853 || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3854 && int_fits_type_p (orig_op0,
3855 signed_type (result_type)))))
3858 warning ("comparison between signed and unsigned");
3860 /* Warn if two unsigned values are being compared in a size
3861 larger than their original size, and one (and only one) is the
3862 result of a `~' operator. This comparison will always fail.
3864 Also warn if one operand is a constant, and the constant does not
3865 have all bits set that are set in the ~ operand when it is
3868 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3869 ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3871 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3872 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3873 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3874 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3876 if (TREE_CODE (primop0) == INTEGER_CST
3877 || TREE_CODE (primop1) == INTEGER_CST)
3880 HOST_WIDE_INT constant, mask;
3884 if (TREE_CODE (primop0) == INTEGER_CST)
3887 unsignedp = unsignedp1;
3888 constant = TREE_INT_CST_LOW (primop0);
3893 unsignedp = unsignedp0;
3894 constant = TREE_INT_CST_LOW (primop1);
3897 bits = TYPE_PRECISION (TREE_TYPE (primop));
3898 if (bits < TYPE_PRECISION (result_type)
3899 && bits < HOST_BITS_PER_LONG && unsignedp)
3901 mask = (~ (HOST_WIDE_INT) 0) << bits;
3902 if ((mask & constant) != mask)
3903 warning ("comparison of promoted ~unsigned with constant");
3906 else if (unsignedp0 && unsignedp1
3907 && (TYPE_PRECISION (TREE_TYPE (primop0))
3908 < TYPE_PRECISION (result_type))
3909 && (TYPE_PRECISION (TREE_TYPE (primop1))
3910 < TYPE_PRECISION (result_type)))
3911 warning ("comparison of promoted ~unsigned with unsigned");
3916 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3917 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3918 Then the expression will be built.
3919 It will be given type FINAL_TYPE if that is nonzero;
3920 otherwise, it will be given type RESULT_TYPE. */
3924 cp_error ("invalid operands `%T' and `%T' to binary `%O'",
3925 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), error_code);
3926 return error_mark_node;
3929 /* Issue warnings about peculiar, but legal, uses of NULL. */
3930 if (/* It's reasonable to use pointer values as operands of &&
3931 and ||, so NULL is no exception. */
3932 !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3933 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3934 (orig_op0 == null_node
3935 && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3936 /* Or vice versa. */
3937 || (orig_op1 == null_node
3938 && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3939 /* Or, both are NULL and the operation was not a comparison. */
3940 || (orig_op0 == null_node && orig_op1 == null_node
3941 && code != EQ_EXPR && code != NE_EXPR)))
3942 /* Some sort of arithmetic operation involving NULL was
3943 performed. Note that pointer-difference and pointer-addition
3944 have already been handled above, and so we don't end up here in
3946 cp_warning ("NULL used in arithmetic");
3950 if (TREE_TYPE (op0) != result_type)
3951 op0 = cp_convert (result_type, op0);
3952 if (TREE_TYPE (op1) != result_type)
3953 op1 = cp_convert (result_type, op1);
3955 if (op0 == error_mark_node || op1 == error_mark_node)
3956 return error_mark_node;
3959 if (build_type == NULL_TREE)
3960 build_type = result_type;
3963 register tree result = build (resultcode, build_type, op0, op1);
3964 register tree folded;
3966 folded = fold (result);
3967 if (folded == result)
3968 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3969 if (final_type != 0)
3970 return cp_convert (final_type, folded);
3975 /* Return a tree for the sum or difference (RESULTCODE says which)
3976 of pointer PTROP and integer INTOP. */
3979 pointer_int_sum (resultcode, ptrop, intop)
3980 enum tree_code resultcode;
3981 register tree ptrop, intop;
3985 register tree result;
3986 register tree folded = fold (intop);
3988 /* The result is a pointer of the same type that is being added. */
3990 register tree result_type = TREE_TYPE (ptrop);
3992 if (!complete_type_or_else (result_type))
3993 return error_mark_node;
3995 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3997 if (pedantic || warn_pointer_arith)
3998 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3999 size_exp = integer_one_node;
4001 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
4003 if (pedantic || warn_pointer_arith)
4004 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
4005 size_exp = integer_one_node;
4007 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
4009 if (pedantic || warn_pointer_arith)
4010 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
4011 size_exp = integer_one_node;
4013 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
4015 if (pedantic || warn_pointer_arith)
4016 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
4017 size_exp = integer_one_node;
4020 size_exp = size_in_bytes (complete_type (TREE_TYPE (result_type)));
4022 /* Needed to make OOPS V2R3 work. */
4024 if (TREE_CODE (intop) == INTEGER_CST
4025 && TREE_INT_CST_LOW (intop) == 0
4026 && TREE_INT_CST_HIGH (intop) == 0)
4029 /* If what we are about to multiply by the size of the elements
4030 contains a constant term, apply distributive law
4031 and multiply that constant term separately.
4032 This helps produce common subexpressions. */
4034 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
4035 && ! TREE_CONSTANT (intop)
4036 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
4037 && TREE_CONSTANT (size_exp))
4039 enum tree_code subcode = resultcode;
4040 if (TREE_CODE (intop) == MINUS_EXPR)
4041 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
4042 ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1), 1);
4043 intop = TREE_OPERAND (intop, 0);
4046 /* Convert the integer argument to a type the same size as sizetype
4047 so the multiply won't overflow spuriously. */
4049 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype))
4050 intop = cp_convert (type_for_size (TYPE_PRECISION (sizetype), 0), intop);
4052 /* Replace the integer argument with a suitable product by the object size.
4053 Do this multiplication as signed, then convert to the appropriate
4054 pointer type (actually unsigned integral). */
4056 intop = cp_convert (result_type,
4057 build_binary_op (MULT_EXPR, intop,
4058 cp_convert (TREE_TYPE (intop),
4062 /* Create the sum or difference. */
4064 result = build (resultcode, result_type, ptrop, intop);
4066 folded = fold (result);
4067 if (folded == result)
4068 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
4072 /* Return a tree for the difference of pointers OP0 and OP1.
4073 The resulting tree has type int. */
4076 pointer_diff (op0, op1, ptrtype)
4077 register tree op0, op1;
4078 register tree ptrtype;
4080 register tree result, folded;
4081 tree restype = ptrdiff_type_node;
4082 tree target_type = TREE_TYPE (ptrtype);
4084 if (!complete_type_or_else (target_type))
4085 return error_mark_node;
4087 if (pedantic || warn_pointer_arith)
4089 if (TREE_CODE (target_type) == VOID_TYPE)
4090 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
4091 if (TREE_CODE (target_type) == FUNCTION_TYPE)
4092 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
4093 if (TREE_CODE (target_type) == METHOD_TYPE)
4094 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
4095 if (TREE_CODE (target_type) == OFFSET_TYPE)
4096 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
4099 /* First do the subtraction as integers;
4100 then drop through to build the divide operator. */
4102 op0 = build_binary_op (MINUS_EXPR, cp_convert (restype, op0),
4103 cp_convert (restype, op1), 1);
4105 /* This generates an error if op1 is a pointer to an incomplete type. */
4106 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
4107 error ("arithmetic on pointer to an incomplete type");
4109 op1 = ((TREE_CODE (target_type) == VOID_TYPE
4110 || TREE_CODE (target_type) == FUNCTION_TYPE
4111 || TREE_CODE (target_type) == METHOD_TYPE
4112 || TREE_CODE (target_type) == OFFSET_TYPE)
4114 : size_in_bytes (target_type));
4116 /* Do the division. */
4118 result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4120 folded = fold (result);
4121 if (folded == result)
4122 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
4126 /* Handle the case of taking the address of a COMPONENT_REF.
4127 Called by `build_unary_op' and `build_up_reference'.
4129 ARG is the COMPONENT_REF whose address we want.
4130 ARGTYPE is the pointer type that this address should have.
4131 MSG is an error message to print if this COMPONENT_REF is not
4132 addressable (such as a bitfield). */
4135 build_component_addr (arg, argtype, msg)
4139 tree field = TREE_OPERAND (arg, 1);
4140 tree basetype = decl_type_context (field);
4141 tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4143 my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 981018);
4145 if (DECL_C_BIT_FIELD (field))
4147 error (msg, IDENTIFIER_POINTER (DECL_NAME (field)));
4148 return error_mark_node;
4151 if (TREE_CODE (field) == FIELD_DECL
4152 && TYPE_USES_COMPLEX_INHERITANCE (basetype))
4154 /* Can't convert directly to ARGTYPE, since that
4155 may have the same pointer type as one of our
4157 rval = build1 (NOP_EXPR, argtype,
4158 convert_pointer_to (basetype, rval));
4159 TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
4162 /* This conversion is harmless. */
4163 rval = convert_force (argtype, rval, 0);
4165 if (! integer_zerop (DECL_FIELD_BITPOS (field)))
4167 tree offset = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
4168 size_int (BITS_PER_UNIT));
4169 int flag = TREE_CONSTANT (rval);
4170 offset = convert (sizetype, offset);
4171 rval = fold (build (PLUS_EXPR, argtype,
4172 rval, cp_convert (argtype, offset)));
4173 TREE_CONSTANT (rval) = flag;
4178 /* Construct and perhaps optimize a tree representation
4179 for a unary operation. CODE, a tree_code, specifies the operation
4180 and XARG is the operand. */
4183 build_x_unary_op (code, xarg)
4184 enum tree_code code;
4187 if (processing_template_decl)
4188 return build_min_nt (code, xarg, NULL_TREE);
4190 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
4192 if (code == ADDR_EXPR
4193 && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4194 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg)))
4195 && TYPE_SIZE (TREE_TYPE (xarg)) == NULL_TREE)
4196 || (TREE_CODE (xarg) == OFFSET_REF)))
4197 /* don't look for a function */;
4202 rval = build_new_op (code, LOOKUP_NORMAL, xarg,
4203 NULL_TREE, NULL_TREE);
4204 if (rval || code != ADDR_EXPR)
4208 if (code == ADDR_EXPR)
4210 if (TREE_CODE (xarg) == TARGET_EXPR)
4211 warning ("taking address of temporary");
4214 return build_unary_op (code, xarg, 0);
4217 /* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4220 condition_conversion (expr)
4224 if (processing_template_decl)
4226 t = cp_convert (boolean_type_node, expr);
4227 t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
4231 /* C++: Must handle pointers to members.
4233 Perhaps type instantiation should be extended to handle conversion
4234 from aggregates to types we don't yet know we want? (Or are those
4235 cases typically errors which should be reported?)
4237 NOCONVERT nonzero suppresses the default promotions
4238 (such as from short to int). */
4241 build_unary_op (code, xarg, noconvert)
4242 enum tree_code code;
4246 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4247 register tree arg = xarg;
4248 register tree argtype = 0;
4249 char *errstring = NULL;
4252 if (arg == error_mark_node)
4253 return error_mark_node;
4258 /* This is used for unary plus, because a CONVERT_EXPR
4259 is enough to prevent anybody from looking inside for
4260 associativity, but won't generate any code. */
4261 if (!(arg = build_expr_type_conversion
4262 (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, 1)))
4263 errstring = "wrong type argument to unary plus";
4267 arg = default_conversion (arg);
4268 arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
4269 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4274 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1)))
4275 errstring = "wrong type argument to unary minus";
4276 else if (!noconvert)
4277 arg = default_conversion (arg);
4281 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4285 arg = default_conversion (arg);
4287 else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
4289 errstring = "wrong type argument to bit-complement";
4290 else if (!noconvert)
4291 arg = default_conversion (arg);
4295 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1)))
4296 errstring = "wrong type argument to abs";
4297 else if (!noconvert)
4298 arg = default_conversion (arg);
4302 /* Conjugating a real value is a no-op, but allow it anyway. */
4303 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1)))
4304 errstring = "wrong type argument to conjugation";
4305 else if (!noconvert)
4306 arg = default_conversion (arg);
4309 case TRUTH_NOT_EXPR:
4310 arg = cp_convert (boolean_type_node, arg);
4311 val = invert_truthvalue (arg);
4312 if (arg != error_mark_node)
4314 errstring = "in argument to unary !";
4321 if (TREE_CODE (arg) == COMPLEX_CST)
4322 return TREE_REALPART (arg);
4323 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4324 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
4329 if (TREE_CODE (arg) == COMPLEX_CST)
4330 return TREE_IMAGPART (arg);
4331 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4332 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
4334 return cp_convert (TREE_TYPE (arg), integer_zero_node);
4336 case PREINCREMENT_EXPR:
4337 case POSTINCREMENT_EXPR:
4338 case PREDECREMENT_EXPR:
4339 case POSTDECREMENT_EXPR:
4340 /* Handle complex lvalues (when permitted)
4341 by reduction to simpler cases. */
4343 val = unary_complex_lvalue (code, arg);
4347 /* Increment or decrement the real part of the value,
4348 and don't change the imaginary part. */
4349 if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4353 arg = stabilize_reference (arg);
4354 real = build_unary_op (REALPART_EXPR, arg, 1);
4355 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
4356 return build (COMPLEX_EXPR, TREE_TYPE (arg),
4357 build_unary_op (code, real, 1), imag);
4360 /* Report invalid types. */
4362 if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4365 if (code == PREINCREMENT_EXPR)
4366 errstring ="no pre-increment operator for type";
4367 else if (code == POSTINCREMENT_EXPR)
4368 errstring ="no post-increment operator for type";
4369 else if (code == PREDECREMENT_EXPR)
4370 errstring ="no pre-decrement operator for type";
4372 errstring ="no post-decrement operator for type";
4376 /* Report something read-only. */
4378 if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4379 || TREE_READONLY (arg))
4380 readonly_error (arg, ((code == PREINCREMENT_EXPR
4381 || code == POSTINCREMENT_EXPR)
4382 ? "increment" : "decrement"),
4387 tree result_type = TREE_TYPE (arg);
4389 arg = get_unwidened (arg, 0);
4390 argtype = TREE_TYPE (arg);
4392 /* ARM $5.2.5 last annotation says this should be forbidden. */
4393 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4394 pedwarn ("ANSI C++ forbids %sing an enum",
4395 (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4396 ? "increment" : "decrement");
4398 /* Compute the increment. */
4400 if (TREE_CODE (argtype) == POINTER_TYPE)
4402 enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
4403 if (TYPE_SIZE (complete_type (TREE_TYPE (argtype))) == 0)
4404 cp_error ("cannot %s a pointer to incomplete type `%T'",
4405 ((code == PREINCREMENT_EXPR
4406 || code == POSTINCREMENT_EXPR)
4407 ? "increment" : "decrement"), TREE_TYPE (argtype));
4408 else if ((pedantic || warn_pointer_arith)
4409 && (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
4410 || tmp == VOID_TYPE || tmp == OFFSET_TYPE))
4411 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
4412 ((code == PREINCREMENT_EXPR
4413 || code == POSTINCREMENT_EXPR)
4414 ? "increment" : "decrement"), argtype);
4415 inc = c_sizeof_nowarn (TREE_TYPE (argtype));
4418 inc = integer_one_node;
4420 inc = cp_convert (argtype, inc);
4422 /* Handle incrementing a cast-expression. */
4424 switch (TREE_CODE (arg))
4429 case FIX_TRUNC_EXPR:
4430 case FIX_FLOOR_EXPR:
4431 case FIX_ROUND_EXPR:
4434 tree incremented, modify, value, compound;
4435 if (! lvalue_p (arg) && pedantic)
4436 pedwarn ("cast to non-reference type used as lvalue");
4437 arg = stabilize_reference (arg);
4438 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
4441 value = save_expr (arg);
4442 incremented = build (((code == PREINCREMENT_EXPR
4443 || code == POSTINCREMENT_EXPR)
4444 ? PLUS_EXPR : MINUS_EXPR),
4445 argtype, value, inc);
4446 TREE_SIDE_EFFECTS (incremented) = 1;
4448 modify = build_modify_expr (arg, NOP_EXPR, incremented);
4449 compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
4451 /* Eliminate warning about unused result of + or -. */
4452 TREE_NO_UNUSED_WARNING (compound) = 1;
4460 /* Complain about anything else that is not a true lvalue. */
4461 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4462 || code == POSTINCREMENT_EXPR)
4463 ? "increment" : "decrement")))
4464 return error_mark_node;
4466 /* Forbid using -- on `bool'. */
4467 if (TREE_TYPE (arg) == boolean_type_node)
4469 if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4471 cp_error ("invalid use of `--' on bool variable `%D'", arg);
4472 return error_mark_node;
4475 /* This will only work if someone can convince Kenner to accept
4476 my patch to expand_increment. (jason) */
4477 val = build (code, TREE_TYPE (arg), arg, inc);
4479 if (code == POSTINCREMENT_EXPR)
4481 arg = stabilize_reference (arg);
4482 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg,
4484 TREE_SIDE_EFFECTS (val) = 1;
4485 arg = save_expr (arg);
4486 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4487 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4490 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg,
4495 val = build (code, TREE_TYPE (arg), arg, inc);
4497 TREE_SIDE_EFFECTS (val) = 1;
4498 return cp_convert (result_type, val);
4502 /* Note that this operation never does default_conversion
4503 regardless of NOCONVERT. */
4505 argtype = lvalue_type (arg);
4506 if (TREE_CODE (argtype) == REFERENCE_TYPE)
4510 build_pointer_type (TREE_TYPE (argtype)), arg);
4511 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4514 else if (pedantic && DECL_MAIN_P (arg))
4516 pedwarn ("taking address of function `main'");
4518 /* Let &* cancel out to simplify resulting code. */
4519 if (TREE_CODE (arg) == INDIRECT_REF)
4521 /* We don't need to have `current_class_ptr' wrapped in a
4522 NON_LVALUE_EXPR node. */
4523 if (arg == current_class_ref)
4524 return current_class_ptr;
4526 arg = TREE_OPERAND (arg, 0);
4527 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4531 build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
4532 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4534 else if (lvalue_p (arg))
4535 /* Don't let this be an lvalue. */
4536 return non_lvalue (arg);
4540 /* For &x[y], return x+y */
4541 if (TREE_CODE (arg) == ARRAY_REF)
4543 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
4544 return error_mark_node;
4545 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4546 TREE_OPERAND (arg, 1), 1);
4549 /* Uninstantiated types are all functions. Taking the
4550 address of a function is a no-op, so just return the
4553 if (TREE_CODE (arg) == IDENTIFIER_NODE
4554 && IDENTIFIER_OPNAME_P (arg))
4556 my_friendly_abort (117);
4557 /* We don't know the type yet, so just work around the problem.
4558 We know that this will resolve to an lvalue. */
4559 return build1 (ADDR_EXPR, unknown_type_node, arg);
4562 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
4567 /* We don't require a match here; it's possible that the
4568 context (like a cast to a particular type) will resolve
4569 the particular choice of template. */
4570 fn = determine_specialization (arg,
4578 fn = instantiate_template (fn, targs);
4579 mark_addressable (fn);
4580 return build_unary_op (ADDR_EXPR, fn, 0);
4583 return build1 (ADDR_EXPR, unknown_type_node, arg);
4585 else if (type_unknown_p (arg))
4586 return build1 (ADDR_EXPR, unknown_type_node, arg);
4588 /* Handle complex lvalues (when permitted)
4589 by reduction to simpler cases. */
4590 val = unary_complex_lvalue (code, arg);
4594 switch (TREE_CODE (arg))
4599 case FIX_TRUNC_EXPR:
4600 case FIX_FLOOR_EXPR:
4601 case FIX_ROUND_EXPR:
4603 if (! lvalue_p (arg) && pedantic)
4604 pedwarn ("taking the address of a cast to non-reference type");
4611 /* Allow the address of a constructor if all the elements
4613 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4614 && TREE_CONSTANT (arg))
4616 /* Anything not already handled and not a true memory reference
4618 else if (TREE_CODE (argtype) != FUNCTION_TYPE
4619 && TREE_CODE (argtype) != METHOD_TYPE
4620 && !lvalue_or_else (arg, "unary `&'"))
4621 return error_mark_node;
4623 if (argtype != error_mark_node)
4624 argtype = build_pointer_type (argtype);
4626 if (mark_addressable (arg) == 0)
4627 return error_mark_node;
4632 if (TREE_CODE (arg) == COMPONENT_REF)
4633 addr = build_component_addr
4635 "attempt to take address of bit-field structure member `%s'");
4637 addr = build1 (code, argtype, arg);
4639 /* Address of a static or external variable or
4640 function counts as a constant */
4642 TREE_CONSTANT (addr) = 1;
4644 if (TREE_CODE (argtype) == POINTER_TYPE
4645 && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4647 build_ptrmemfunc_type (argtype);
4648 addr = build_ptrmemfunc (argtype, addr, 0);
4661 argtype = TREE_TYPE (arg);
4662 return fold (build1 (code, argtype, arg));
4666 return error_mark_node;
4670 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4671 convert ARG with the same conversions in the same order
4672 and return the result. */
4675 convert_sequence (conversions, arg)
4679 switch (TREE_CODE (conversions))
4684 case FIX_TRUNC_EXPR:
4685 case FIX_FLOOR_EXPR:
4686 case FIX_ROUND_EXPR:
4688 return cp_convert (TREE_TYPE (conversions),
4689 convert_sequence (TREE_OPERAND (conversions, 0),
4698 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4699 for certain kinds of expressions which are not really lvalues
4700 but which we can accept as lvalues.
4702 If ARG is not a kind of expression we can handle, return zero. */
4705 unary_complex_lvalue (code, arg)
4706 enum tree_code code;
4709 /* Handle (a, b) used as an "lvalue". */
4710 if (TREE_CODE (arg) == COMPOUND_EXPR)
4712 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4713 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4714 TREE_OPERAND (arg, 0), real_result);
4717 /* Handle (a ? b : c) used as an "lvalue". */
4718 if (TREE_CODE (arg) == COND_EXPR
4719 || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4720 return rationalize_conditional_expr (code, arg);
4722 if (TREE_CODE (arg) == MODIFY_EXPR
4723 || TREE_CODE (arg) == PREINCREMENT_EXPR
4724 || TREE_CODE (arg) == PREDECREMENT_EXPR)
4725 return unary_complex_lvalue
4726 (code, build (COMPOUND_EXPR, TREE_TYPE (TREE_OPERAND (arg, 0)),
4727 arg, TREE_OPERAND (arg, 0)));
4729 if (code != ADDR_EXPR)
4732 /* Handle (a = b) used as an "lvalue" for `&'. */
4733 if (TREE_CODE (arg) == MODIFY_EXPR
4734 || TREE_CODE (arg) == INIT_EXPR)
4736 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4737 arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4738 TREE_NO_UNUSED_WARNING (arg) = 1;
4742 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4743 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4744 || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
4746 /* The representation of something of type OFFSET_TYPE
4747 is really the representation of a pointer to it.
4748 Here give the representation its true type. */
4751 my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4753 if (TREE_CODE (arg) != OFFSET_REF)
4756 t = TREE_OPERAND (arg, 1);
4758 /* Check all this code for right semantics. */
4759 if (TREE_CODE (t) == FUNCTION_DECL)
4761 if (DECL_DESTRUCTOR_P (t))
4762 cp_error ("taking address of destructor");
4763 return build_unary_op (ADDR_EXPR, t, 0);
4765 if (TREE_CODE (t) == VAR_DECL)
4766 return build_unary_op (ADDR_EXPR, t, 0);
4771 if (TREE_OPERAND (arg, 0)
4772 && ! is_dummy_object (TREE_OPERAND (arg, 0))
4773 && TREE_CODE (t) != FIELD_DECL)
4775 cp_error ("taking address of bound pointer-to-member expression");
4776 return error_mark_node;
4779 type = build_offset_type (DECL_FIELD_CONTEXT (t), TREE_TYPE (t));
4780 type = build_pointer_type (type);
4782 t = make_node (PTRMEM_CST);
4783 TREE_TYPE (t) = type;
4784 PTRMEM_CST_MEMBER (t) = TREE_OPERAND (arg, 1);
4790 /* We permit compiler to make function calls returning
4791 objects of aggregate type look like lvalues. */
4795 if (TREE_CODE (targ) == SAVE_EXPR)
4796 targ = TREE_OPERAND (targ, 0);
4798 if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4800 if (TREE_CODE (arg) == SAVE_EXPR)
4803 targ = build_cplus_new (TREE_TYPE (arg), arg);
4804 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4807 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4808 return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4809 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4812 /* Don't let anything else be handled specially. */
4816 /* Mark EXP saying that we need to be able to take the
4817 address of it; it should not be allocated in a register.
4818 Value is 1 if successful.
4820 C++: we do not allow `current_class_ptr' to be addressable. */
4823 mark_addressable (exp)
4826 register tree x = exp;
4828 if (TREE_ADDRESSABLE (x) == 1)
4832 switch (TREE_CODE (x))
4839 x = TREE_OPERAND (x, 0);
4843 if (x == current_class_ptr)
4845 if (! flag_this_is_variable)
4846 error ("address of `this' not available");
4847 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */
4848 put_var_into_stack (x);
4852 if (TREE_STATIC (x) && TREE_READONLY (x)
4853 && DECL_RTL (x) != 0
4854 && ! DECL_IN_MEMORY_P (x))
4856 /* We thought this would make a good constant variable,
4857 but we were wrong. */
4858 push_obstacks_nochange ();
4859 end_temporary_allocation ();
4861 TREE_ASM_WRITTEN (x) = 0;
4863 rest_of_decl_compilation (x, 0,
4864 !DECL_FUNCTION_SCOPE_P (x),
4866 TREE_ADDRESSABLE (x) = 1;
4872 /* Caller should not be trying to mark initialized
4873 constant fields addressable. */
4874 my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4875 || DECL_IN_AGGR_P (x) == 0
4877 || DECL_EXTERNAL (x), 314);
4881 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4882 && !DECL_ARTIFICIAL (x) && extra_warnings)
4883 cp_warning ("address requested for `%D', which is declared `register'",
4885 put_var_into_stack (x);
4886 TREE_ADDRESSABLE (x) = 1;
4890 if (DECL_LANG_SPECIFIC (x) != 0)
4892 x = DECL_MAIN_VARIANT (x);
4893 /* We have to test both conditions here. The first may be
4894 non-zero in the case of processing a default function. The
4895 second may be non-zero in the case of a template function. */
4896 if (DECL_TEMPLATE_INFO (x) && !DECL_TEMPLATE_SPECIALIZATION (x))
4899 TREE_ADDRESSABLE (x) = 1;
4901 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4905 TREE_ADDRESSABLE (x) = 1;
4909 TREE_ADDRESSABLE (x) = 1;
4910 mark_addressable (TREE_OPERAND (x, 0));
4918 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4921 build_x_conditional_expr (ifexp, op1, op2)
4922 tree ifexp, op1, op2;
4924 if (processing_template_decl)
4925 return build_min_nt (COND_EXPR, ifexp, op1, op2);
4927 return build_new_op (COND_EXPR, LOOKUP_NORMAL, ifexp, op1, op2);
4931 build_conditional_expr (ifexp, op1, op2)
4932 tree ifexp, op1, op2;
4934 register tree type1;
4935 register tree type2;
4936 register enum tree_code code1;
4937 register enum tree_code code2;
4938 register tree result_type = NULL_TREE;
4940 /* If second operand is omitted, it is the same as the first one;
4941 make sure it is calculated only once. */
4945 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4946 ifexp = op1 = save_expr (ifexp);
4949 ifexp = cp_convert (boolean_type_node, ifexp);
4951 if (TREE_CODE (ifexp) == ERROR_MARK)
4952 return error_mark_node;
4954 /* C++: REFERENCE_TYPES must be dereferenced. */
4955 type1 = TREE_TYPE (op1);
4956 code1 = TREE_CODE (type1);
4957 type2 = TREE_TYPE (op2);
4958 code2 = TREE_CODE (type2);
4960 if (code1 == REFERENCE_TYPE)
4962 op1 = convert_from_reference (op1);
4963 type1 = TREE_TYPE (op1);
4964 code1 = TREE_CODE (type1);
4966 if (code2 == REFERENCE_TYPE)
4968 op2 = convert_from_reference (op2);
4969 type2 = TREE_TYPE (op2);
4970 code2 = TREE_CODE (type2);
4973 /* Don't promote the operands separately if they promote
4974 the same way. Return the unpromoted type and let the combined
4975 value get promoted if necessary. */
4977 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)
4978 && code2 != ARRAY_TYPE
4979 && code2 != FUNCTION_TYPE
4980 && code2 != METHOD_TYPE)
4984 if (TREE_CONSTANT (ifexp)
4985 && (TREE_CODE (ifexp) == INTEGER_CST
4986 || TREE_CODE (ifexp) == ADDR_EXPR))
4987 return (integer_zerop (ifexp) ? op2 : op1);
4989 if (TREE_CODE (op1) == CONST_DECL)
4990 op1 = DECL_INITIAL (op1);
4991 else if (TREE_READONLY_DECL_P (op1))
4992 op1 = decl_constant_value (op1);
4993 if (TREE_CODE (op2) == CONST_DECL)
4994 op2 = DECL_INITIAL (op2);
4995 else if (TREE_READONLY_DECL_P (op2))
4996 op2 = decl_constant_value (op2);
4998 type1 = cp_build_qualified_type
4999 (type1, (CP_TYPE_QUALS (TREE_TYPE (op1))
5000 | CP_TYPE_QUALS (TREE_TYPE (op2))));
5001 /* ??? This is a kludge to deal with the fact that
5002 we don't sort out integers and enums properly, yet. */
5003 result = fold (build (COND_EXPR, type1, ifexp, op1, op2));
5004 if (TREE_TYPE (result) != type1)
5005 result = build1 (NOP_EXPR, type1, result);
5006 /* Expand both sides into the same slot,
5007 hopefully the target of the ?: expression. */
5008 if (TREE_CODE (op1) == TARGET_EXPR && TREE_CODE (op2) == TARGET_EXPR)
5010 tree slot = build (VAR_DECL, TREE_TYPE (result));
5011 layout_decl (slot, 0);
5012 result = build (TARGET_EXPR, TREE_TYPE (result),
5013 slot, result, NULL_TREE, NULL_TREE);
5018 /* They don't match; promote them both and then try to reconcile them.
5019 But don't permit mismatching enum types. */
5020 if (code1 == ENUMERAL_TYPE)
5022 if (code2 == ENUMERAL_TYPE)
5024 cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'",
5026 return error_mark_node;
5028 else if (extra_warnings && ! IS_AGGR_TYPE_CODE (code2)
5029 && type2 != type_promotes_to (type1))
5030 warning ("enumeral and non-enumeral type in conditional expression");
5032 else if (extra_warnings
5033 && code2 == ENUMERAL_TYPE && ! IS_AGGR_TYPE_CODE (code1)
5034 && type1 != type_promotes_to (type2))
5035 warning ("enumeral and non-enumeral type in conditional expression");
5037 if (code1 != VOID_TYPE)
5039 op1 = default_conversion (op1);
5040 type1 = TREE_TYPE (op1);
5041 if (TYPE_PTRMEMFUNC_P (type1))
5042 type1 = TYPE_PTRMEMFUNC_FN_TYPE (type1);
5043 code1 = TREE_CODE (type1);
5045 if (code2 != VOID_TYPE)
5047 op2 = default_conversion (op2);
5048 type2 = TREE_TYPE (op2);
5049 if (TYPE_PTRMEMFUNC_P (type2))
5050 type2 = TYPE_PTRMEMFUNC_FN_TYPE (type2);
5051 code2 = TREE_CODE (type2);
5054 if (code1 == RECORD_TYPE && code2 == RECORD_TYPE
5055 && real_lvalue_p (op1) && real_lvalue_p (op2)
5056 && comptypes (type1, type2, COMPARE_BASE | COMPARE_RELAXED))
5058 type1 = build_reference_type (type1);
5059 type2 = build_reference_type (type2);
5060 result_type = common_type (type1, type2);
5061 op1 = convert_to_reference (result_type, op1, CONV_IMPLICIT,
5062 LOOKUP_NORMAL, NULL_TREE);
5063 op2 = convert_to_reference (result_type, op2, CONV_IMPLICIT,
5064 LOOKUP_NORMAL, NULL_TREE);
5066 /* Quickly detect the usual case where op1 and op2 have the same type
5068 else if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
5071 result_type = type1;
5074 cp_build_qualified_type (type1,
5075 CP_TYPE_QUALS (TREE_TYPE (op1))
5076 | CP_TYPE_QUALS (TREE_TYPE (op2)));
5078 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
5079 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
5081 result_type = common_type (type1, type2);
5083 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
5085 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
5086 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
5087 result_type = void_type_node;
5089 else if (code1 == POINTER_TYPE && null_ptr_cst_p (op2))
5090 result_type = qualify_type (type1, type2);
5091 else if (code2 == POINTER_TYPE && null_ptr_cst_p (op1))
5092 result_type = qualify_type (type2, type1);
5093 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
5095 if (comp_target_types (type1, type2, 1))
5096 result_type = common_type (type1, type2);
5097 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
5099 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
5100 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5101 result_type = qualify_type (type1, type2);
5103 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
5105 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
5106 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5107 result_type = qualify_type (type2, type1);
5110 else if (same_or_base_type_p (type2, type1))
5111 result_type = type2;
5112 else if (IS_AGGR_TYPE (TREE_TYPE (type1))
5113 && IS_AGGR_TYPE (TREE_TYPE (type2))
5114 && (result_type = common_base_type (TREE_TYPE (type1),
5115 TREE_TYPE (type2))))
5117 if (result_type == error_mark_node)
5119 cp_error ("common base type of types `%T' and `%T' is ambiguous",
5120 TREE_TYPE (type1), TREE_TYPE (type2));
5121 result_type = ptr_type_node;
5126 && result_type != TREE_TYPE (type1)
5127 && result_type != TREE_TYPE (type2))
5128 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
5129 type1, type2, result_type);
5131 result_type = build_pointer_type (result_type);
5136 pedwarn ("pointer type mismatch in conditional expression");
5137 result_type = ptr_type_node;
5140 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
5142 pedwarn ("pointer/integer type mismatch in conditional expression");
5143 result_type = type1;
5145 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
5147 pedwarn ("pointer/integer type mismatch in conditional expression");
5148 result_type = type2;
5150 if (type2 == unknown_type_node)
5151 result_type = type1;
5152 else if (type1 == unknown_type_node)
5153 result_type = type2;
5157 /* The match does not look good. If either is
5158 an aggregate value, try converting to a scalar type. */
5159 if (code1 == RECORD_TYPE && code2 == RECORD_TYPE)
5161 cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'",
5163 return error_mark_node;
5165 /* Warning: this code assumes that conversion between cv-variants of
5166 a type is done using NOP_EXPRs. */
5167 if (code1 == RECORD_TYPE && TYPE_HAS_CONVERSION (type1))
5169 /* There are other types besides pointers and records. */
5171 if (code2 == POINTER_TYPE)
5172 tmp = build_pointer_type
5173 (cp_build_qualified_type (TREE_TYPE (type2),
5175 | TYPE_QUAL_VOLATILE
5176 | TYPE_QUAL_RESTRICT));
5179 tmp = build_type_conversion (CONVERT_EXPR, tmp, op1, 0);
5180 if (tmp == NULL_TREE)
5182 cp_error ("incompatible types `%T' and `%T' in `?:'",
5184 return error_mark_node;
5186 if (tmp == error_mark_node)
5187 error ("ambiguous pointer conversion");
5190 result_type = common_type (type2, TREE_TYPE (tmp));
5193 else if (code2 == RECORD_TYPE && TYPE_HAS_CONVERSION (type2))
5196 if (code1 == POINTER_TYPE)
5197 tmp = build_pointer_type
5198 (cp_build_qualified_type (TREE_TYPE (type1),
5200 | TYPE_QUAL_VOLATILE
5201 | TYPE_QUAL_RESTRICT));
5205 tmp = build_type_conversion (CONVERT_EXPR, tmp, op2, 0);
5206 if (tmp == NULL_TREE)
5208 cp_error ("incompatible types `%T' and `%T' in `?:'",
5210 return error_mark_node;
5212 if (tmp == error_mark_node)
5213 error ("ambiguous pointer conversion");
5216 result_type = common_type (type1, TREE_TYPE (tmp));
5219 else if (flag_cond_mismatch)
5220 result_type = void_type_node;
5223 error ("type mismatch in conditional expression");
5224 return error_mark_node;
5228 if (TREE_CODE (result_type) == POINTER_TYPE
5229 && TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
5230 result_type = build_ptrmemfunc_type (result_type);
5232 if (result_type != TREE_TYPE (op1))
5233 op1 = convert_for_initialization
5234 (NULL_TREE, result_type, op1, LOOKUP_NORMAL, "converting", NULL_TREE, 0);
5235 if (result_type != TREE_TYPE (op2))
5236 op2 = convert_for_initialization
5237 (NULL_TREE, result_type, op2, LOOKUP_NORMAL, "converting", NULL_TREE, 0);
5239 if (TREE_CODE (ifexp) == INTEGER_CST)
5240 return integer_zerop (ifexp) ? op2 : op1;
5242 return convert_from_reference
5243 (fold (build (COND_EXPR, result_type, ifexp, op1, op2)));
5246 /* Handle overloading of the ',' operator when needed. Otherwise,
5247 this function just builds an expression list. */
5250 build_x_compound_expr (list)
5253 tree rest = TREE_CHAIN (list);
5256 if (processing_template_decl)
5257 return build_min_nt (COMPOUND_EXPR, list, NULL_TREE);
5259 if (rest == NULL_TREE)
5260 return build_compound_expr (list);
5262 result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
5263 TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
5265 return build_x_compound_expr (expr_tree_cons (NULL_TREE, result,
5266 TREE_CHAIN (rest)));
5268 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
5270 /* the left-hand operand of a comma expression is like an expression
5271 statement: we should warn if it doesn't have any side-effects,
5272 unless it was explicitly cast to (void). */
5273 if ((extra_warnings || warn_unused)
5274 && !(TREE_CODE (TREE_VALUE(list)) == CONVERT_EXPR
5275 && TREE_TYPE (TREE_VALUE(list)) == void_type_node))
5276 warning("left-hand operand of comma expression has no effect");
5278 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
5279 else if (warn_unused)
5280 warn_if_unused_value (TREE_VALUE(list));
5283 return build_compound_expr
5284 (expr_tree_cons (NULL_TREE, TREE_VALUE (list),
5285 build_expr_list (NULL_TREE,
5286 build_x_compound_expr (rest))));
5289 /* Given a list of expressions, return a compound expression
5290 that performs them all and returns the value of the last of them. */
5293 build_compound_expr (list)
5298 if (TREE_READONLY_DECL_P (TREE_VALUE (list)))
5299 TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list));
5301 if (TREE_CHAIN (list) == 0)
5303 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5304 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
5305 if (TREE_CODE (list) == NOP_EXPR
5306 && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0)))
5307 list = TREE_OPERAND (list, 0);
5309 /* Convert arrays to pointers. */
5310 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
5311 return default_conversion (TREE_VALUE (list));
5313 return TREE_VALUE (list);
5316 rest = build_compound_expr (TREE_CHAIN (list));
5318 /* When pedantic, a compound expression cannot be a constant expression. */
5319 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
5322 return build (COMPOUND_EXPR, TREE_TYPE (rest),
5323 break_out_cleanups (TREE_VALUE (list)), rest);
5327 build_static_cast (type, expr)
5333 if (type == error_mark_node || expr == error_mark_node)
5334 return error_mark_node;
5336 if (TREE_CODE (expr) == OFFSET_REF)
5337 expr = resolve_offset_ref (expr);
5339 if (processing_template_decl)
5341 tree t = build_min (STATIC_CAST_EXPR, copy_to_permanent (type),
5346 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5347 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5348 if (TREE_CODE (type) != REFERENCE_TYPE
5349 && TREE_CODE (expr) == NOP_EXPR
5350 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5351 expr = TREE_OPERAND (expr, 0);
5353 if (TREE_CODE (type) == VOID_TYPE)
5354 return build1 (CONVERT_EXPR, type, expr);
5356 if (TREE_CODE (type) == REFERENCE_TYPE)
5357 return (convert_from_reference
5358 (convert_to_reference (type, expr, CONV_STATIC|CONV_IMPLICIT,
5359 LOOKUP_COMPLAIN, NULL_TREE)));
5361 if (IS_AGGR_TYPE (type))
5362 return build_cplus_new
5363 (type, (build_method_call
5364 (NULL_TREE, ctor_identifier, build_expr_list (NULL_TREE, expr),
5365 TYPE_BINFO (type), LOOKUP_NORMAL)));
5367 expr = decay_conversion (expr);
5368 intype = TREE_TYPE (expr);
5370 /* FIXME handle casting to array type. */
5373 if (can_convert_arg (type, intype, expr))
5375 else if (TYPE_PTROB_P (type) && TYPE_PTROB_P (intype))
5378 if (IS_AGGR_TYPE (TREE_TYPE (type)) && IS_AGGR_TYPE (TREE_TYPE (intype))
5379 && at_least_as_qualified_p (TREE_TYPE (type),
5381 && (binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 0))
5382 && ! TREE_VIA_VIRTUAL (binfo))
5385 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5387 if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))),
5388 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (intype))))
5389 && at_least_as_qualified_p (TREE_TYPE (TREE_TYPE (type)),
5390 TREE_TYPE (TREE_TYPE (intype)))
5391 && (binfo = get_binfo (TYPE_OFFSET_BASETYPE (TREE_TYPE (type)),
5392 TYPE_OFFSET_BASETYPE (TREE_TYPE (intype)), 0))
5393 && ! TREE_VIA_VIRTUAL (binfo))
5396 else if (TREE_CODE (intype) != BOOLEAN_TYPE
5397 && TREE_CODE (type) != ARRAY_TYPE
5398 && TREE_CODE (type) != FUNCTION_TYPE
5399 && can_convert (intype, type))
5403 return build_c_cast (type, expr);
5405 cp_error ("static_cast from `%T' to `%T'", intype, type);
5406 return error_mark_node;
5410 build_reinterpret_cast (type, expr)
5415 if (type == error_mark_node || expr == error_mark_node)
5416 return error_mark_node;
5418 if (TREE_CODE (expr) == OFFSET_REF)
5419 expr = resolve_offset_ref (expr);
5421 if (processing_template_decl)
5423 tree t = build_min (REINTERPRET_CAST_EXPR,
5424 copy_to_permanent (type), expr);
5428 if (TREE_CODE (type) != REFERENCE_TYPE)
5430 expr = decay_conversion (expr);
5432 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5433 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5434 if (TREE_CODE (expr) == NOP_EXPR
5435 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5436 expr = TREE_OPERAND (expr, 0);
5439 intype = TREE_TYPE (expr);
5441 if (TREE_CODE (type) == REFERENCE_TYPE)
5443 if (! real_lvalue_p (expr))
5445 cp_error ("reinterpret_cast from `%T' rvalue to `%T'", intype, type);
5446 return error_mark_node;
5448 expr = build_unary_op (ADDR_EXPR, expr, 0);
5449 if (expr != error_mark_node)
5450 expr = build_reinterpret_cast
5451 (build_pointer_type (TREE_TYPE (type)), expr);
5452 if (expr != error_mark_node)
5453 expr = build_indirect_ref (expr, 0);
5456 else if (same_type_p (TYPE_MAIN_VARIANT (intype),
5457 TYPE_MAIN_VARIANT (type)))
5458 return build_static_cast (type, expr);
5460 if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE
5461 || TREE_CODE (intype) == ENUMERAL_TYPE))
5463 else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
5465 if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5466 cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5469 else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5470 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5472 if (TREE_READONLY_DECL_P (expr))
5473 expr = decl_constant_value (expr);
5474 return fold (build1 (NOP_EXPR, type, expr));
5476 else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5477 || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5479 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type), TREE_TYPE (intype)))
5480 cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5483 if (TREE_READONLY_DECL_P (expr))
5484 expr = decl_constant_value (expr);
5485 return fold (build1 (NOP_EXPR, type, expr));
5487 else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5488 || (TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype)))
5490 pedwarn ("ANSI C++ forbids casting between pointers to functions and objects");
5491 if (TREE_READONLY_DECL_P (expr))
5492 expr = decl_constant_value (expr);
5493 return fold (build1 (NOP_EXPR, type, expr));
5497 cp_error ("reinterpret_cast from `%T' to `%T'", intype, type);
5498 return error_mark_node;
5501 return cp_convert (type, expr);
5505 build_const_cast (type, expr)
5510 if (type == error_mark_node || expr == error_mark_node)
5511 return error_mark_node;
5513 if (TREE_CODE (expr) == OFFSET_REF)
5514 expr = resolve_offset_ref (expr);
5516 if (processing_template_decl)
5518 tree t = build_min (CONST_CAST_EXPR, copy_to_permanent (type),
5523 if (TREE_CODE (type) != REFERENCE_TYPE)
5525 expr = decay_conversion (expr);
5527 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5528 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5529 if (TREE_CODE (expr) == NOP_EXPR
5530 && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5531 expr = TREE_OPERAND (expr, 0);
5534 intype = TREE_TYPE (expr);
5536 if (same_type_p (TYPE_MAIN_VARIANT (intype), TYPE_MAIN_VARIANT (type)))
5537 return build_static_cast (type, expr);
5538 else if (TREE_CODE (type) == REFERENCE_TYPE)
5540 if (! real_lvalue_p (expr))
5542 cp_error ("const_cast from `%T' rvalue to `%T'", intype, type);
5543 return error_mark_node;
5546 if (comp_ptr_ttypes_const (TREE_TYPE (type), intype))
5548 expr = build_unary_op (ADDR_EXPR, expr, 0);
5549 expr = build1 (NOP_EXPR, type, expr);
5550 return convert_from_reference (expr);
5553 else if (TREE_CODE (type) == POINTER_TYPE
5554 && TREE_CODE (intype) == POINTER_TYPE
5555 && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
5556 return cp_convert (type, expr);
5558 cp_error ("const_cast from `%T' to `%T'", intype, type);
5559 return error_mark_node;
5562 /* Build an expression representing a cast to type TYPE of expression EXPR.
5564 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5565 when doing the cast. */
5568 build_c_cast (type, expr)
5571 register tree value = expr;
5574 if (type == error_mark_node || expr == error_mark_node)
5575 return error_mark_node;
5577 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5578 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5579 if (TREE_CODE (type) != REFERENCE_TYPE
5580 && TREE_CODE (value) == NOP_EXPR
5581 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5582 value = TREE_OPERAND (value, 0);
5584 if (TREE_TYPE (expr)
5585 && TREE_CODE (TREE_TYPE (expr)) == OFFSET_TYPE
5586 && TREE_CODE (type) != OFFSET_TYPE)
5587 value = resolve_offset_ref (value);
5589 if (TREE_CODE (type) == ARRAY_TYPE)
5591 /* Allow casting from T1* to T2[] because Cfront allows it.
5592 NIHCL uses it. It is not valid ANSI C however, and hence, not
5594 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5597 pedwarn ("ANSI C++ forbids casting to an array type");
5598 type = build_pointer_type (TREE_TYPE (type));
5602 error ("ANSI C++ forbids casting to an array type");
5603 return error_mark_node;
5607 if (TREE_CODE (type) == FUNCTION_TYPE
5608 || TREE_CODE (type) == METHOD_TYPE)
5610 cp_error ("casting to function type `%T'", type);
5611 return error_mark_node;
5614 if (IS_SIGNATURE (type))
5616 error ("cast specifies signature type");
5617 return error_mark_node;
5620 if (processing_template_decl)
5622 tree t = build_min (CAST_EXPR, type,
5623 min_tree_cons (NULL_TREE, value, NULL_TREE));
5627 /* Convert functions and arrays to pointers and
5628 convert references to their expanded types,
5629 but don't convert any other types. If, however, we are
5630 casting to a class type, there's no reason to do this: the
5631 cast will only succeed if there is a converting constructor,
5632 and the default conversions will be done at that point. In
5633 fact, doing the default conversion here is actually harmful
5637 struct S { S(const A&); };
5639 since we don't want the array-to-pointer conversion done. */
5640 if (!IS_AGGR_TYPE (type))
5642 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5643 || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
5644 /* Don't do the default conversion on a ->* expression. */
5645 && ! (TREE_CODE (type) == POINTER_TYPE
5646 && bound_pmf_p (value)))
5647 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5648 || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5649 value = default_conversion (value);
5651 else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5652 /* However, even for class types, we still need to strip away
5653 the reference type, since the call to convert_force below
5654 does not expect the input expression to be of reference
5656 value = convert_from_reference (value);
5658 otype = TREE_TYPE (value);
5660 /* Optionally warn about potentially worrisome casts. */
5663 && TREE_CODE (type) == POINTER_TYPE
5664 && TREE_CODE (otype) == POINTER_TYPE
5665 && !at_least_as_qualified_p (TREE_TYPE (type),
5667 cp_warning ("cast discards qualifiers from pointer target type");
5669 /* Warn about possible alignment problems. */
5670 if (STRICT_ALIGNMENT && warn_cast_align
5671 && TREE_CODE (type) == POINTER_TYPE
5672 && TREE_CODE (otype) == POINTER_TYPE
5673 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5674 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5675 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
5676 warning ("cast increases required alignment of target type");
5679 /* We should see about re-enabling these, they seem useful to
5681 if (TREE_CODE (type) == INTEGER_TYPE
5682 && TREE_CODE (otype) == POINTER_TYPE
5683 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
5684 warning ("cast from pointer to integer of different size");
5686 if (TREE_CODE (type) == POINTER_TYPE
5687 && TREE_CODE (otype) == INTEGER_TYPE
5688 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
5689 /* Don't warn about converting 0 to pointer,
5690 provided the 0 was explicit--not cast or made by folding. */
5691 && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value)))
5692 warning ("cast to pointer from integer of different size");
5695 if (TREE_CODE (type) == REFERENCE_TYPE)
5696 value = (convert_from_reference
5697 (convert_to_reference (type, value, CONV_C_CAST,
5698 LOOKUP_COMPLAIN, NULL_TREE)));
5703 if (TREE_READONLY_DECL_P (value))
5704 value = decl_constant_value (value);
5707 value = convert_force (type, value, CONV_C_CAST);
5709 /* Ignore any integer overflow caused by the cast. */
5710 if (TREE_CODE (value) == INTEGER_CST)
5712 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
5713 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
5717 /* Always produce some operator for an explicit cast,
5718 so we can tell (for -pedantic) that the cast is no lvalue. */
5719 if (TREE_CODE (type) != REFERENCE_TYPE && value == expr
5720 && real_lvalue_p (value))
5721 value = non_lvalue (value);
5726 /* Build an assignment expression of lvalue LHS from value RHS.
5727 MODIFYCODE is the code for a binary operator that we use
5728 to combine the old value of LHS with RHS to get the new value.
5729 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5731 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5734 build_modify_expr (lhs, modifycode, rhs)
5736 enum tree_code modifycode;
5739 register tree result;
5741 tree lhstype = TREE_TYPE (lhs);
5742 tree olhstype = lhstype;
5745 /* Avoid duplicate error messages from operands that had errors. */
5746 if (lhs == error_mark_node || rhs == error_mark_node)
5747 return error_mark_node;
5749 /* Types that aren't fully specified cannot be used in assignments. */
5750 lhs = require_complete_type (lhs);
5754 /* Handle assignment to signature pointers/refs. */
5756 if (TYPE_LANG_SPECIFIC (lhstype)
5757 && (IS_SIGNATURE_POINTER (lhstype) || IS_SIGNATURE_REFERENCE (lhstype)))
5759 return build_signature_pointer_constructor (lhs, rhs);
5762 /* Handle control structure constructs used as "lvalues". */
5764 switch (TREE_CODE (lhs))
5766 /* Handle --foo = 5; as these are valid constructs in C++ */
5767 case PREDECREMENT_EXPR:
5768 case PREINCREMENT_EXPR:
5769 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5770 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5771 stabilize_reference (TREE_OPERAND (lhs, 0)),
5772 TREE_OPERAND (lhs, 1));
5773 return build (COMPOUND_EXPR, lhstype,
5775 build_modify_expr (TREE_OPERAND (lhs, 0),
5778 /* Handle (a, b) used as an "lvalue". */
5780 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5782 if (newrhs == error_mark_node)
5783 return error_mark_node;
5784 return build (COMPOUND_EXPR, lhstype,
5785 TREE_OPERAND (lhs, 0), newrhs);
5788 newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5789 if (newrhs == error_mark_node)
5790 return error_mark_node;
5791 return build (COMPOUND_EXPR, lhstype, lhs, newrhs);
5793 /* Handle (a ? b : c) used as an "lvalue". */
5795 rhs = save_expr (rhs);
5797 /* Produce (a ? (b = rhs) : (c = rhs))
5798 except that the RHS goes through a save-expr
5799 so the code to compute it is only emitted once. */
5801 = build_conditional_expr (TREE_OPERAND (lhs, 0),
5802 build_modify_expr (cp_convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 1)),
5804 build_modify_expr (cp_convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 2)),
5806 if (cond == error_mark_node)
5808 /* Make sure the code to compute the rhs comes out
5809 before the split. */
5810 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
5811 /* Case to void to suppress warning
5812 from warn_if_unused_value. */
5813 cp_convert (void_type_node, rhs), cond);
5820 if (TREE_CODE (lhs) == OFFSET_REF)
5822 if (TREE_OPERAND (lhs, 0) == NULL_TREE)
5824 /* Static class member? */
5825 tree member = TREE_OPERAND (lhs, 1);
5826 if (TREE_CODE (member) == VAR_DECL)
5830 compiler_error ("invalid static class member");
5831 return error_mark_node;
5835 lhs = resolve_offset_ref (lhs);
5837 olhstype = lhstype = TREE_TYPE (lhs);
5840 if (TREE_CODE (lhstype) == REFERENCE_TYPE
5841 && modifycode != INIT_EXPR)
5843 lhs = convert_from_reference (lhs);
5844 olhstype = lhstype = TREE_TYPE (lhs);
5847 /* If a binary op has been requested, combine the old LHS value with the RHS
5848 producing the value we should actually store into the LHS. */
5850 if (modifycode == INIT_EXPR)
5852 if (! IS_AGGR_TYPE (lhstype))
5853 /* Do the default thing */;
5856 result = build_method_call (lhs, ctor_identifier,
5857 build_expr_list (NULL_TREE, rhs),
5858 TYPE_BINFO (lhstype), LOOKUP_NORMAL);
5859 if (result == NULL_TREE)
5860 return error_mark_node;
5864 else if (modifycode == NOP_EXPR)
5866 /* `operator=' is not an inheritable operator. */
5867 if (! IS_AGGR_TYPE (lhstype))
5868 /* Do the default thing */;
5871 result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
5872 lhs, rhs, make_node (NOP_EXPR));
5873 if (result == NULL_TREE)
5874 return error_mark_node;
5879 else if (PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE))
5881 my_friendly_abort (978652);
5885 lhs = stabilize_reference (lhs);
5886 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
5887 if (newrhs == error_mark_node)
5889 cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode,
5890 TREE_TYPE (lhs), TREE_TYPE (rhs));
5891 return error_mark_node;
5895 /* Handle a cast used as an "lvalue".
5896 We have already performed any binary operator using the value as cast.
5897 Now convert the result to the cast type of the lhs,
5898 and then true type of the lhs and store it there;
5899 then convert result back to the cast type to be the value
5900 of the assignment. */
5902 switch (TREE_CODE (lhs))
5907 case FIX_TRUNC_EXPR:
5908 case FIX_FLOOR_EXPR:
5909 case FIX_ROUND_EXPR:
5911 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5912 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5913 || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5914 || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5915 newrhs = default_conversion (newrhs);
5917 tree inner_lhs = TREE_OPERAND (lhs, 0);
5920 /* WP 5.4.1: The result is an lvalue if T is a reference type,
5921 otherwise the result is an rvalue. */
5922 if (! lvalue_p (lhs))
5923 pedwarn ("ANSI C++ forbids cast to non-reference type used as lvalue");
5925 result = build_modify_expr (inner_lhs, NOP_EXPR,
5926 cp_convert (TREE_TYPE (inner_lhs),
5927 cp_convert (lhstype, newrhs)));
5928 if (result == error_mark_node)
5930 return cp_convert (TREE_TYPE (lhs), result);
5937 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5938 Reject anything strange now. */
5940 if (!lvalue_or_else (lhs, "assignment"))
5941 return error_mark_node;
5943 GNU_xref_assign (lhs);
5945 /* Warn about storing in something that is `const'. */
5946 /* For C++, don't warn if this is initialization. */
5947 if (modifycode != INIT_EXPR
5948 /* For assignment to `const' signature pointer/reference fields,
5949 don't warn either, we already printed a better message before. */
5950 && ! (TREE_CODE (lhs) == COMPONENT_REF
5951 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs, 0)))
5952 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
5953 && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5954 /* Functions are not modifiable, even though they are
5956 || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5957 || ((TREE_CODE (lhstype) == RECORD_TYPE
5958 || TREE_CODE (lhstype) == UNION_TYPE)
5959 && C_TYPE_FIELDS_READONLY (lhstype))
5960 || (TREE_CODE (lhstype) == REFERENCE_TYPE
5961 && CP_TYPE_CONST_P (TREE_TYPE (lhstype)))))
5962 readonly_error (lhs, "assignment", 0);
5964 /* If storing into a structure or union member,
5965 it has probably been given type `int'.
5966 Compute the type that would go with
5967 the actual amount of storage the member occupies. */
5969 if (TREE_CODE (lhs) == COMPONENT_REF
5970 && (TREE_CODE (lhstype) == INTEGER_TYPE
5971 || TREE_CODE (lhstype) == REAL_TYPE
5972 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5974 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5976 /* If storing in a field that is in actuality a short or narrower
5977 than one, we must store in the field in its actual type. */
5979 if (lhstype != TREE_TYPE (lhs))
5981 lhs = copy_node (lhs);
5982 TREE_TYPE (lhs) = lhstype;
5986 /* check to see if there is an assignment to `this' */
5987 if (lhs == current_class_ptr)
5989 if (flag_this_is_variable > 0
5990 && DECL_NAME (current_function_decl) != NULL_TREE
5991 && (DECL_NAME (current_function_decl)
5992 != constructor_name (current_class_type)))
5993 warning ("assignment to `this' not in constructor or destructor");
5994 current_function_just_assigned_this = 1;
5997 if (modifycode != INIT_EXPR)
5999 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
6000 modifycode = NOP_EXPR;
6001 /* Reference-bashing */
6002 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
6004 tree tmp = convert_from_reference (lhs);
6005 lhstype = TREE_TYPE (tmp);
6006 if (TYPE_SIZE (lhstype) == 0)
6008 incomplete_type_error (lhs, lhstype);
6009 return error_mark_node;
6014 if (TREE_CODE (TREE_TYPE (newrhs)) == REFERENCE_TYPE)
6016 tree tmp = convert_from_reference (newrhs);
6017 if (TYPE_SIZE (TREE_TYPE (tmp)) == 0)
6019 incomplete_type_error (newrhs, TREE_TYPE (tmp));
6020 return error_mark_node;
6026 if (TREE_SIDE_EFFECTS (lhs))
6027 lhs = stabilize_reference (lhs);
6028 if (TREE_SIDE_EFFECTS (newrhs))
6029 newrhs = stabilize_reference (newrhs);
6031 /* Convert new value to destination type. */
6033 if (TREE_CODE (lhstype) == ARRAY_TYPE)
6037 if (!same_or_base_type_p (lhstype, TREE_TYPE (rhs)))
6039 cp_error ("incompatible types in assignment of `%T' to `%T'",
6040 TREE_TYPE (rhs), lhstype);
6041 return error_mark_node;
6044 /* Allow array assignment in compiler-generated code. */
6045 if (pedantic && ! DECL_ARTIFICIAL (current_function_decl))
6046 pedwarn ("ANSI C++ forbids assignment of arrays");
6048 /* Have to wrap this in RTL_EXPR for two cases:
6049 in base or member initialization and if we
6050 are a branch of a ?: operator. Since we
6051 can't easily know the latter, just do it always. */
6053 result = make_node (RTL_EXPR);
6055 TREE_TYPE (result) = void_type_node;
6056 do_pending_stack_adjust ();
6057 start_sequence_for_rtl_expr (result);
6059 /* As a matter of principle, `start_sequence' should do this. */
6062 from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6063 ? 1 + (modifycode != INIT_EXPR): 0;
6064 expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs,
6067 do_pending_stack_adjust ();
6069 TREE_SIDE_EFFECTS (result) = 1;
6070 RTL_EXPR_SEQUENCE (result) = get_insns ();
6071 RTL_EXPR_RTL (result) = const0_rtx;
6076 if (modifycode == INIT_EXPR)
6078 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
6079 "assignment", NULL_TREE, 0);
6080 if (lhs == DECL_RESULT (current_function_decl))
6082 if (DECL_INITIAL (lhs))
6083 warning ("return value from function receives multiple initializations");
6084 DECL_INITIAL (lhs) = newrhs;
6089 /* Avoid warnings on enum bit fields. */
6090 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
6091 && TREE_CODE (lhstype) == INTEGER_TYPE)
6093 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6095 newrhs = convert_force (lhstype, newrhs, 0);
6098 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
6100 if (TREE_CODE (newrhs) == CALL_EXPR
6101 && TYPE_NEEDS_CONSTRUCTING (lhstype))
6102 newrhs = build_cplus_new (lhstype, newrhs);
6104 /* Can't initialize directly from a TARGET_EXPR, since that would
6105 cause the lhs to be constructed twice, and possibly result in
6106 accidental self-initialization. So we force the TARGET_EXPR to be
6107 expanded without a target. */
6108 if (TREE_CODE (newrhs) == TARGET_EXPR)
6109 newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6110 TREE_OPERAND (newrhs, 0));
6113 if (newrhs == error_mark_node)
6114 return error_mark_node;
6116 if (TREE_CODE (newrhs) == COND_EXPR)
6119 tree cond = TREE_OPERAND (newrhs, 0);
6121 if (TREE_SIDE_EFFECTS (lhs))
6122 cond = build_compound_expr (tree_cons
6124 build_expr_list (NULL_TREE, cond)));
6126 /* Cannot have two identical lhs on this one tree (result) as preexpand
6127 calls will rip them out and fill in RTL for them, but when the
6128 rtl is generated, the calls will only be in the first side of the
6129 condition, not on both, or before the conditional jump! (mrs) */
6130 lhs1 = break_out_calls (lhs);
6133 /* If there's no change, the COND_EXPR behaves like any other rhs. */
6134 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6135 lhstype, lhs, newrhs);
6138 tree result_type = TREE_TYPE (newrhs);
6139 /* We have to convert each arm to the proper type because the
6140 types may have been munged by constant folding. */
6142 = build (COND_EXPR, result_type, cond,
6143 build_modify_expr (lhs, modifycode,
6144 cp_convert (result_type,
6145 TREE_OPERAND (newrhs, 1))),
6146 build_modify_expr (lhs1, modifycode,
6147 cp_convert (result_type,
6148 TREE_OPERAND (newrhs, 2))));
6152 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6153 lhstype, lhs, newrhs);
6155 TREE_SIDE_EFFECTS (result) = 1;
6157 /* If we got the LHS in a different type for storing in,
6158 convert the result back to the nominal type of LHS
6159 so that the value we return always has the same type
6160 as the LHS argument. */
6162 if (olhstype == TREE_TYPE (result))
6164 /* Avoid warnings converting integral types back into enums
6165 for enum bit fields. */
6166 if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
6167 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
6169 result = build (COMPOUND_EXPR, olhstype, result, olhs);
6170 TREE_NO_UNUSED_WARNING (result) = 1;
6173 return convert_for_assignment (olhstype, result, "assignment",
6178 build_x_modify_expr (lhs, modifycode, rhs)
6180 enum tree_code modifycode;
6183 if (processing_template_decl)
6184 return build_min_nt (MODOP_EXPR, lhs,
6185 build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6187 if (modifycode != NOP_EXPR)
6189 tree rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6190 make_node (modifycode));
6194 return build_modify_expr (lhs, modifycode, rhs);
6198 /* Get difference in deltas for different pointer to member function
6199 types. Return integer_zero_node, if FROM cannot be converted to a
6200 TO type. If FORCE is true, then allow reverse conversions as well. */
6203 get_delta_difference (from, to, force)
6207 tree delta = integer_zero_node;
6213 /* Should get_base_distance here, so we can check if any thing along the
6214 path is virtual, and we need to make sure we stay
6215 inside the real binfos when going through virtual bases.
6216 Maybe we should replace virtual bases with
6217 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6218 binfo = get_binfo (from, to, 1);
6219 if (binfo == error_mark_node)
6221 error (" in pointer to member function conversion");
6228 error_not_base_type (from, to);
6229 error (" in pointer to member conversion");
6232 binfo = get_binfo (to, from, 1);
6233 if (binfo == 0 || binfo == error_mark_node)
6235 if (TREE_VIA_VIRTUAL (binfo))
6237 binfo = binfo_member (BINFO_TYPE (binfo),
6238 CLASSTYPE_VBASECLASSES (from));
6239 cp_warning ("pointer to member cast to virtual base `%T'",
6240 BINFO_TYPE (binfo));
6241 warning (" will only work if you are very careful");
6243 delta = BINFO_OFFSET (binfo);
6244 delta = cp_convert (ptrdiff_type_node, delta);
6246 return build_binary_op (MINUS_EXPR,
6251 if (TREE_VIA_VIRTUAL (binfo))
6255 cp_warning ("pointer to member cast from virtual base `%T'",
6256 BINFO_TYPE (binfo));
6257 warning (" will only work if you are very careful");
6260 cp_error ("pointer to member conversion from virtual base `%T'",
6261 BINFO_TYPE (binfo));
6264 return BINFO_OFFSET (binfo);
6268 build_ptrmemfunc1 (type, delta, idx, pfn, delta2)
6269 tree type, delta, idx, pfn, delta2;
6274 /* This is the old way we did it. We want to avoid calling
6275 digest_init, so that it can give an error if we use { } when
6276 initializing a pointer to member function. */
6280 u = build_nt (CONSTRUCTOR, NULL_TREE,
6281 expr_tree_cons (pfn_identifier, pfn, NULL_TREE));
6285 u = build_nt (CONSTRUCTOR, NULL_TREE,
6286 expr_tree_cons (delta2_identifier, delta2, NULL_TREE));
6289 u = build_nt (CONSTRUCTOR, NULL_TREE,
6290 expr_tree_cons (NULL_TREE, delta,
6291 expr_tree_cons (NULL_TREE, idx,
6292 expr_tree_cons (NULL_TREE, u, NULL_TREE))));
6294 return digest_init (type, u, (tree*)0);
6296 tree delta_field, idx_field, pfn_or_delta2_field, pfn_field, delta2_field;
6298 int allconstant, allsimple;
6300 delta_field = TYPE_FIELDS (type);
6301 idx_field = TREE_CHAIN (delta_field);
6302 pfn_or_delta2_field = TREE_CHAIN (idx_field);
6303 subtype = TREE_TYPE (pfn_or_delta2_field);
6304 pfn_field = TYPE_FIELDS (subtype);
6305 delta2_field = TREE_CHAIN (pfn_field);
6309 allconstant = TREE_CONSTANT (pfn);
6310 allsimple = !! initializer_constant_valid_p (pfn, TREE_TYPE (pfn));
6311 u = expr_tree_cons (pfn_field, pfn, NULL_TREE);
6315 delta2 = convert_and_check (delta_type_node, delta2);
6316 allconstant = TREE_CONSTANT (delta2);
6317 allsimple = !! initializer_constant_valid_p (delta2, TREE_TYPE (delta2));
6318 u = expr_tree_cons (delta2_field, delta2, NULL_TREE);
6321 delta = convert_and_check (delta_type_node, delta);
6322 idx = convert_and_check (delta_type_node, idx);
6324 allconstant = allconstant && TREE_CONSTANT (delta) && TREE_CONSTANT (idx);
6325 allsimple = allsimple
6326 && initializer_constant_valid_p (delta, TREE_TYPE (delta))
6327 && initializer_constant_valid_p (idx, TREE_TYPE (idx));
6329 u = build (CONSTRUCTOR, subtype, NULL_TREE, u);
6330 u = expr_tree_cons (delta_field, delta,
6331 expr_tree_cons (idx_field, idx,
6332 expr_tree_cons (pfn_or_delta2_field, u, NULL_TREE)));
6333 u = build (CONSTRUCTOR, type, NULL_TREE, u);
6334 TREE_CONSTANT (u) = allconstant;
6335 TREE_STATIC (u) = allconstant && allsimple;
6340 /* Build a constructor for a pointer to member function. It can be
6341 used to initialize global variables, local variable, or used
6342 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6345 If FORCE is non-zero, then force this conversion, even if
6346 we would rather not do it. Usually set when using an explicit
6349 Return error_mark_node, if something goes wrong. */
6352 build_ptrmemfunc (type, pfn, force)
6356 tree idx = integer_zero_node;
6357 tree delta = integer_zero_node;
6358 tree delta2 = integer_zero_node;
6360 tree npfn = NULL_TREE;
6362 /* Handle multiple conversions of pointer to member functions. */
6363 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn)))
6365 tree ndelta, ndelta2;
6369 /* Is is already the right type? */
6370 if (type == TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)))
6373 pfn_type = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn));
6375 && comp_target_types (type, pfn_type, 1) != 1)
6376 cp_error ("conversion to `%T' from `%T'", type, pfn_type);
6378 ndelta = cp_convert (ptrdiff_type_node, build_component_ref (pfn, delta_identifier, NULL_TREE, 0));
6379 ndelta2 = cp_convert (ptrdiff_type_node, DELTA2_FROM_PTRMEMFUNC (pfn));
6380 idx = build_component_ref (pfn, index_identifier, NULL_TREE, 0);
6382 n = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (pfn_type)),
6383 TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
6386 delta = build_binary_op (PLUS_EXPR, ndelta, n, 1);
6387 delta2 = build_binary_op (PLUS_EXPR, ndelta2, n, 1);
6388 e1 = fold (build (GT_EXPR, boolean_type_node, idx, integer_zero_node));
6390 e2 = build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx,
6393 pfn = PFN_FROM_PTRMEMFUNC (pfn);
6394 npfn = build1 (NOP_EXPR, type, pfn);
6395 TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
6397 e3 = build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx, npfn,
6399 return build_conditional_expr (e1, e2, e3);
6402 /* Handle null pointer to member function conversions. */
6403 if (integer_zerop (pfn))
6405 pfn = build_c_cast (type, integer_zero_node);
6406 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type),
6407 integer_zero_node, integer_zero_node,
6411 if (type_unknown_p (pfn))
6412 return instantiate_type (type, pfn, 1);
6415 && comp_target_types (type, TREE_TYPE (pfn), 0) != 1)
6416 cp_error ("conversion to `%T' from `%T'", type, TREE_TYPE (pfn));
6418 /* Allow pointer to member conversions here. */
6419 delta = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn))),
6420 TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
6422 delta2 = build_binary_op (PLUS_EXPR, delta2, delta, 1);
6424 if (TREE_CODE (TREE_OPERAND (pfn, 0)) != FUNCTION_DECL)
6425 warning ("assuming pointer to member function is non-virtual");
6427 if (TREE_CODE (TREE_OPERAND (pfn, 0)) == FUNCTION_DECL
6428 && DECL_VINDEX (TREE_OPERAND (pfn, 0)))
6430 /* Find the offset to the vfield pointer in the object. */
6431 vfield_offset = get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn, 0)),
6432 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn, 0)),
6434 vfield_offset = get_vfield_offset (vfield_offset);
6435 delta2 = size_binop (PLUS_EXPR, vfield_offset, delta2);
6437 /* Map everything down one to make room for the null pointer to member. */
6438 idx = size_binop (PLUS_EXPR,
6439 DECL_VINDEX (TREE_OPERAND (pfn, 0)),
6444 idx = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
6446 if (type == TREE_TYPE (pfn))
6452 npfn = build1 (NOP_EXPR, type, pfn);
6453 TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
6457 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx, npfn, delta2);
6460 /* Convert value RHS to type TYPE as preparation for an assignment
6461 to an lvalue of type TYPE.
6462 The real work of conversion is done by `convert'.
6463 The purpose of this function is to generate error messages
6464 for assignments that are not allowed in C.
6465 ERRTYPE is a string to use in error messages:
6466 "assignment", "return", etc.
6468 C++: attempts to allow `convert' to find conversions involving
6469 implicit type conversion between aggregate and scalar types
6470 as per 8.5.6 of C++ manual. Does not randomly dereference
6471 pointers to aggregates! */
6474 convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
6480 register enum tree_code codel = TREE_CODE (type);
6481 register tree rhstype;
6482 register enum tree_code coder = TREE_CODE (TREE_TYPE (rhs));
6484 /* Issue warnings about peculiar, but legal, uses of NULL. */
6485 if (ARITHMETIC_TYPE_P (type) && rhs == null_node)
6486 cp_warning ("converting NULL to non-pointer type");
6488 if (coder == ERROR_MARK)
6489 return error_mark_node;
6491 if (codel == OFFSET_TYPE)
6493 type = TREE_TYPE (type);
6494 codel = TREE_CODE (type);
6497 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6498 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6499 rhs = TREE_OPERAND (rhs, 0);
6501 if (rhs == error_mark_node)
6502 return error_mark_node;
6504 if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6505 return error_mark_node;
6507 if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
6509 rhs = resolve_offset_ref (rhs);
6510 if (rhs == error_mark_node)
6511 return error_mark_node;
6512 rhstype = TREE_TYPE (rhs);
6513 coder = TREE_CODE (rhstype);
6516 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6517 || is_overloaded_fn (rhs))
6518 rhs = default_conversion (rhs);
6519 else if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
6520 rhs = convert_from_reference (rhs);
6522 /* If rhs is some sort of overloaded function, ocp_convert will either
6523 do the right thing or complain; we don't need to check anything else.
6524 So just hand off. */
6525 if (type_unknown_p (rhs))
6526 return ocp_convert (type, rhs, CONV_IMPLICIT, LOOKUP_NORMAL);
6528 rhstype = TREE_TYPE (rhs);
6529 coder = TREE_CODE (rhstype);
6531 /* This should no longer change types on us. */
6532 if (TREE_CODE (rhs) == CONST_DECL)
6533 rhs = DECL_INITIAL (rhs);
6534 else if (TREE_READONLY_DECL_P (rhs))
6535 rhs = decl_constant_value (rhs);
6537 if (same_type_p (type, rhstype))
6539 overflow_warning (rhs);
6543 if (coder == VOID_TYPE)
6545 error ("void value not ignored as it ought to be");
6546 return error_mark_node;
6548 /* Arithmetic types all interconvert. */
6549 if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == BOOLEAN_TYPE
6550 || codel == COMPLEX_TYPE)
6551 && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == BOOLEAN_TYPE
6552 || coder == COMPLEX_TYPE))
6554 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6555 if (coder == REAL_TYPE && codel == INTEGER_TYPE)
6558 cp_warning ("`%T' used for argument %P of `%D'",
6559 rhstype, parmnum, fndecl);
6561 cp_warning ("%s to `%T' from `%T'", errtype, type, rhstype);
6563 /* And we should warn if assigning a negative value to
6564 an unsigned variable. */
6565 else if (TREE_UNSIGNED (type) && codel != BOOLEAN_TYPE)
6567 if (TREE_CODE (rhs) == INTEGER_CST
6568 && TREE_NEGATED_INT (rhs))
6571 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6572 rhs, parmnum, fndecl);
6574 cp_warning ("%s of negative value `%E' to `%T'",
6575 errtype, rhs, type);
6577 overflow_warning (rhs);
6578 if (TREE_CONSTANT (rhs))
6582 return convert_and_check (type, rhs);
6584 /* Conversions involving enums. */
6585 else if ((codel == ENUMERAL_TYPE
6586 && (INTEGRAL_CODE_P (coder) || coder == REAL_TYPE))
6587 || (coder == ENUMERAL_TYPE
6588 && (INTEGRAL_CODE_P (codel) || codel == REAL_TYPE)))
6590 return ocp_convert (type, rhs, CONV_IMPLICIT, LOOKUP_NORMAL);
6592 /* Conversions among pointers */
6593 else if (codel == POINTER_TYPE
6594 && (coder == POINTER_TYPE
6595 || (coder == RECORD_TYPE
6596 && (IS_SIGNATURE_POINTER (rhstype)
6597 || IS_SIGNATURE_REFERENCE (rhstype)))))
6599 register tree ttl = TREE_TYPE (type);
6603 if (coder == RECORD_TYPE)
6605 rhs = build_optr_ref (rhs);
6606 rhstype = TREE_TYPE (rhs);
6608 ttr = TREE_TYPE (rhstype);
6610 /* If both pointers are of aggregate type, then we
6611 can give better error messages, and save some work
6613 if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
6617 if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)
6618 || type == class_star_type_node
6619 || rhstype == class_star_type_node)
6620 binfo = TYPE_BINFO (ttl);
6622 binfo = get_binfo (ttl, ttr, 1);
6624 if (binfo == error_mark_node)
6625 return error_mark_node;
6627 return error_not_base_type (ttl, ttr);
6629 if (!at_least_as_qualified_p (ttl, ttr))
6632 cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers",
6633 rhstype, parmnum, fndecl);
6635 cp_pedwarn ("%s to `%T' from `%T' discards qualifiers",
6636 errtype, type, rhstype);
6640 /* Any non-function converts to a [const][volatile] void *
6641 and vice versa; otherwise, targets must be the same.
6642 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6643 else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
6644 || TYPE_MAIN_VARIANT (ttr) == void_type_node
6645 || (ctt = comp_target_types (type, rhstype, 1))
6646 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
6647 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
6649 /* ARM $4.8, commentary on p39. */
6650 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
6651 && TREE_CODE (ttr) == OFFSET_TYPE)
6653 cp_error ("no standard conversion from `%T' to `void *'", ttr);
6654 return error_mark_node;
6657 if (ctt < 0 && TYPE_MAIN_VARIANT (ttl) != TYPE_MAIN_VARIANT (ttr))
6658 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6661 if (TYPE_MAIN_VARIANT (ttl) != void_type_node
6662 && TYPE_MAIN_VARIANT (ttr) == void_type_node
6663 && ! null_ptr_cst_p (rhs))
6665 if (coder == RECORD_TYPE)
6666 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6669 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6672 /* Const and volatile mean something different for function types,
6673 so the usual warnings are not appropriate. */
6674 else if ((TREE_CODE (ttr) != FUNCTION_TYPE && TREE_CODE (ttr) != METHOD_TYPE)
6675 || (TREE_CODE (ttl) != FUNCTION_TYPE && TREE_CODE (ttl) != METHOD_TYPE))
6677 if (TREE_CODE (ttl) == OFFSET_TYPE
6678 && binfo_member (TYPE_OFFSET_BASETYPE (ttr),
6679 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl))))
6681 error ("%s between pointer to members converting across virtual baseclasses", errtype);
6682 return error_mark_node;
6684 else if (!at_least_as_qualified_p (ttl, ttr))
6686 if (string_conv_p (type, rhs, 1))
6687 /* converting from string constant to char *, OK. */;
6689 cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers",
6690 rhstype, parmnum, fndecl);
6692 cp_pedwarn ("%s to `%T' from `%T' discards qualifiers",
6693 errtype, type, rhstype);
6695 else if (TREE_CODE (ttl) == TREE_CODE (ttr)
6696 && ! comp_target_types (type, rhstype, 1))
6699 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6700 rhstype, parmnum, fndecl);
6702 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6703 errtype, type, rhstype);
6710 int drops_quals = 0;
6712 int unsigned_parity;
6715 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6716 for (; ; ttl = TREE_TYPE (ttl), ttr = TREE_TYPE (ttr))
6719 drops_quals |= !at_least_as_qualified_p (ttl, ttr);
6722 && !at_least_as_qualified_p (ttr, ttl))
6724 left_const &= TYPE_READONLY (ttl);
6726 if (TREE_CODE (ttl) != POINTER_TYPE
6727 || TREE_CODE (ttr) != POINTER_TYPE)
6730 unsigned_parity = TREE_UNSIGNED (ttl) - TREE_UNSIGNED (ttr);
6731 if (unsigned_parity)
6733 if (TREE_UNSIGNED (ttl))
6734 ttr = unsigned_type (ttr);
6736 ttl = unsigned_type (ttl);
6739 if (comp_target_types (ttl, ttr, nptrs) > 0)
6744 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6745 rhstype, parmnum, fndecl);
6747 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6748 errtype, type, rhstype);
6753 cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers",
6754 rhstype, parmnum, fndecl);
6756 cp_pedwarn ("%s to `%T' from `%T' discards qualifiers",
6757 errtype, type, rhstype);
6759 if (unsigned_parity > 0)
6762 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6763 rhstype, parmnum, fndecl);
6765 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6766 errtype, type, rhstype);
6768 else if (unsigned_parity < 0)
6771 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6772 rhstype, parmnum, fndecl);
6774 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6775 errtype, type, rhstype);
6778 /* C++ is not so friendly about converting function and
6779 member function pointers as C. Emit warnings here. */
6780 if (TREE_CODE (ttl) == FUNCTION_TYPE
6781 || TREE_CODE (ttl) == METHOD_TYPE)
6782 if (!same_or_base_type_p (ttl, ttr))
6784 warning ("conflicting function types in %s:", errtype);
6785 cp_warning ("\t`%T' != `%T'", type, rhstype);
6791 cp_error ("passing `%T' as argument %P of `%D'",
6792 rhstype, parmnum, fndecl);
6794 cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
6795 return error_mark_node;
6798 return cp_convert (type, rhs);
6800 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
6802 /* An explicit constant 0 can convert to a pointer,
6803 but not a 0 that results from casting or folding. */
6804 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs)))
6807 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6808 rhstype, parmnum, fndecl);
6810 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6811 errtype, type, rhstype);
6813 return cp_convert (type, rhs);
6815 else if (codel == INTEGER_TYPE
6816 && (coder == POINTER_TYPE
6817 || (coder == RECORD_TYPE
6818 && (IS_SIGNATURE_POINTER (rhstype)
6819 || TYPE_PTRMEMFUNC_FLAG (rhstype)
6820 || IS_SIGNATURE_REFERENCE (rhstype)))))
6823 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6824 rhstype, parmnum, fndecl);
6826 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6827 errtype, type, rhstype);
6828 return cp_convert (type, rhs);
6830 else if (codel == BOOLEAN_TYPE
6831 && (coder == POINTER_TYPE
6832 || (coder == RECORD_TYPE
6833 && (IS_SIGNATURE_POINTER (rhstype)
6834 || TYPE_PTRMEMFUNC_FLAG (rhstype)
6835 || IS_SIGNATURE_REFERENCE (rhstype)))))
6836 return cp_convert (type, rhs);
6839 else if (((coder == POINTER_TYPE
6840 && TREE_CODE (TREE_TYPE (rhstype)) == METHOD_TYPE)
6841 || integer_zerop (rhs)
6842 || TYPE_PTRMEMFUNC_P (rhstype))
6843 && TYPE_PTRMEMFUNC_P (type))
6845 tree ttl = TYPE_PTRMEMFUNC_FN_TYPE (type);
6846 tree ttr = (TYPE_PTRMEMFUNC_P (rhstype)
6847 ? TYPE_PTRMEMFUNC_FN_TYPE (rhstype)
6849 int ctt = (TREE_CODE (rhstype) == INTEGER_TYPE ? 1
6850 : comp_target_types (ttl, ttr, 1));
6853 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6856 cp_error ("%s to `%T' from `%T'", errtype, ttl, ttr);
6858 /* compatible pointer to member functions. */
6859 return build_ptrmemfunc (ttl, rhs, 0);
6861 else if (codel == ERROR_MARK || coder == ERROR_MARK)
6862 return error_mark_node;
6864 /* This should no longer happen. References are initialized via
6865 `convert_for_initialization'. They should otherwise be
6866 bashed before coming here. */
6867 else if (codel == REFERENCE_TYPE)
6868 my_friendly_abort (317);
6869 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))
6871 tree nrhs = build1 (NOP_EXPR, type, rhs);
6872 TREE_CONSTANT (nrhs) = TREE_CONSTANT (rhs);
6875 else if (TYPE_HAS_CONSTRUCTOR (type) || IS_AGGR_TYPE (TREE_TYPE (rhs)))
6876 return cp_convert (type, rhs);
6877 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
6878 else if (TREE_CODE (type) == POINTER_TYPE
6879 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
6880 || TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
6882 && TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6883 return cp_convert (type, rhs);
6885 cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
6886 return error_mark_node;
6889 /* Convert RHS to be of type TYPE.
6890 If EXP is non-zero, it is the target of the initialization.
6891 ERRTYPE is a string to use in error messages.
6893 Two major differences between the behavior of
6894 `convert_for_assignment' and `convert_for_initialization'
6895 are that references are bashed in the former, while
6896 copied in the latter, and aggregates are assigned in
6897 the former (operator=) while initialized in the
6900 If using constructor make sure no conversion operator exists, if one does
6901 exist, an ambiguity exists.
6903 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6906 convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
6907 tree exp, type, rhs;
6913 register enum tree_code codel = TREE_CODE (type);
6914 register tree rhstype;
6915 register enum tree_code coder;
6917 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6918 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6919 if (TREE_CODE (rhs) == NOP_EXPR
6920 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6921 && codel != REFERENCE_TYPE)
6922 rhs = TREE_OPERAND (rhs, 0);
6924 if (rhs == error_mark_node
6925 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6926 return error_mark_node;
6928 if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
6930 rhs = resolve_offset_ref (rhs);
6931 if (rhs == error_mark_node)
6932 return error_mark_node;
6935 if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
6936 rhs = convert_from_reference (rhs);
6938 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6939 && TREE_CODE (type) != ARRAY_TYPE
6940 && (TREE_CODE (type) != REFERENCE_TYPE
6941 || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6942 || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6943 && (TREE_CODE (type) != REFERENCE_TYPE
6944 || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6945 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6946 rhs = default_conversion (rhs);
6948 rhstype = TREE_TYPE (rhs);
6949 coder = TREE_CODE (rhstype);
6951 if (coder == ERROR_MARK)
6952 return error_mark_node;
6954 /* We accept references to incomplete types, so we can
6955 return here before checking if RHS is of complete type. */
6957 if (codel == REFERENCE_TYPE)
6959 /* This should eventually happen in convert_arguments. */
6960 extern int warningcount, errorcount;
6961 int savew = 0, savee = 0;
6964 savew = warningcount, savee = errorcount;
6965 rhs = convert_to_reference (type, rhs, CONV_IMPLICIT, flags,
6966 exp ? exp : error_mark_node);
6969 if (warningcount > savew)
6970 cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
6971 else if (errorcount > savee)
6972 cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
6977 rhs = require_complete_type (rhs);
6978 if (rhs == error_mark_node)
6979 return error_mark_node;
6981 if (exp != 0) exp = require_complete_type (exp);
6982 if (exp == error_mark_node)
6983 return error_mark_node;
6985 if (TREE_CODE (rhstype) == REFERENCE_TYPE)
6986 rhstype = TREE_TYPE (rhstype);
6988 type = complete_type (type);
6990 if (TYPE_LANG_SPECIFIC (type)
6991 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
6992 return build_signature_pointer_constructor (type, rhs);
6994 if (IS_AGGR_TYPE (type))
6995 return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6997 if (type == TREE_TYPE (rhs))
6999 /* Issue warnings about peculiar, but legal, uses of NULL. We
7000 do this *before* the call to decl_constant_value so as to
7001 avoid duplicate warnings on code like `const int I = NULL;
7003 if (ARITHMETIC_TYPE_P (type) && rhs == null_node)
7004 cp_warning ("converting NULL to non-pointer type");
7006 if (TREE_READONLY_DECL_P (rhs))
7007 rhs = decl_constant_value (rhs);
7012 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
7015 /* Expand an ASM statement with operands, handling output operands
7016 that are not variables or INDIRECT_REFS by transforming such
7017 cases into cases that expand_asm_operands can handle.
7019 Arguments are same as for expand_asm_operands.
7021 We don't do default conversions on all inputs, because it can screw
7022 up operands that are expected to be in memory. */
7025 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
7026 tree string, outputs, inputs, clobbers;
7031 int noutputs = list_length (outputs);
7033 /* o[I] is the place that output number I should be written. */
7034 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
7037 /* Record the contents of OUTPUTS before it is modified. */
7038 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
7039 o[i] = TREE_VALUE (tail);
7041 /* Generate the ASM_OPERANDS insn;
7042 store into the TREE_VALUEs of OUTPUTS some trees for
7043 where the values were actually stored. */
7044 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
7046 /* Copy all the intermediate outputs into the specified outputs. */
7047 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
7049 if (o[i] != TREE_VALUE (tail))
7051 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
7052 const0_rtx, VOIDmode, EXPAND_NORMAL);
7055 /* Detect modification of read-only values.
7056 (Otherwise done by build_modify_expr.) */
7059 tree type = TREE_TYPE (o[i]);
7060 if (CP_TYPE_CONST_P (type)
7061 || ((TREE_CODE (type) == RECORD_TYPE
7062 || TREE_CODE (type) == UNION_TYPE)
7063 && C_TYPE_FIELDS_READONLY (type)))
7064 readonly_error (o[i], "modification by `asm'", 1);
7068 /* Those MODIFY_EXPRs could do autoincrements. */
7072 /* Expand a C `return' statement.
7073 RETVAL is the expression for what to return,
7074 or a null pointer for `return;' with no value.
7076 C++: upon seeing a `return', we must call destructors on all
7077 variables in scope which had constructors called on them.
7078 This means that if in a destructor, the base class destructors
7079 must be called before returning.
7081 The RETURN statement in C++ has initialization semantics. */
7084 c_expand_return (retval)
7087 extern struct nesting *cond_stack, *loop_stack, *case_stack;
7088 extern tree dtor_label, ctor_label;
7089 tree result = DECL_RESULT (current_function_decl);
7090 tree valtype = TREE_TYPE (result);
7092 if (TREE_THIS_VOLATILE (current_function_decl))
7093 warning ("function declared `noreturn' has a `return' statement");
7095 if (retval == error_mark_node)
7097 current_function_returns_null = 1;
7101 if (processing_template_decl)
7103 add_tree (build_min_nt (RETURN_STMT, retval));
7110 error ("returning a value from a destructor");
7112 /* Can't just return from a destructor. */
7113 expand_goto (dtor_label);
7117 if (retval == NULL_TREE)
7119 /* A non-named return value does not count. */
7121 if (DECL_CONSTRUCTOR_P (current_function_decl))
7122 retval = current_class_ptr;
7123 else if (DECL_NAME (result) != NULL_TREE
7124 && TREE_CODE (valtype) != VOID_TYPE)
7128 current_function_returns_null = 1;
7130 if (valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE)
7132 if (DECL_NAME (DECL_RESULT (current_function_decl)) == NULL_TREE)
7134 pedwarn ("`return' with no value, in function returning non-void");
7135 /* Clear this, so finish_function won't say that we
7136 reach the end of a non-void function (which we don't,
7137 we gave a return!). */
7138 current_function_returns_null = 0;
7142 expand_null_return ();
7146 else if (DECL_CONSTRUCTOR_P (current_function_decl))
7148 if (flag_this_is_variable)
7149 error ("return from a constructor: use `this = ...' instead");
7151 error ("returning a value from a constructor");
7152 retval = current_class_ptr;
7155 /* Effective C++ rule 15. See also start_function. */
7157 && DECL_NAME (current_function_decl) == ansi_opname[(int) MODIFY_EXPR]
7158 && retval != current_class_ref)
7159 cp_warning ("`operator=' should return a reference to `*this'");
7161 if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
7163 current_function_returns_null = 1;
7164 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7165 pedwarn ("`return' with a value, in function returning void");
7166 expand_return (retval);
7170 /* Now deal with possible C++ hair:
7171 (1) Compute the return value.
7172 (2) If there are aggregate values with destructors which
7173 must be cleaned up, clean them (taking care
7174 not to clobber the return value).
7175 (3) If an X(X&) constructor is defined, the return
7176 value must be returned via that. */
7178 if (retval == result
7179 || DECL_CONSTRUCTOR_P (current_function_decl))
7180 /* It's already done for us. */;
7181 else if (TREE_TYPE (retval) == void_type_node)
7183 pedwarn ("return of void value in function returning non-void");
7184 expand_expr_stmt (retval);
7189 tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
7191 /* First convert the value to the function's return type, then
7192 to the type of return value's location to handle the
7193 case that functype is thiner than the valtype. */
7195 retval = convert_for_initialization
7196 (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
7197 "return", NULL_TREE, 0);
7199 retval = convert (valtype, retval);
7201 if (retval == error_mark_node)
7203 /* Avoid warning about control reaching end of function. */
7204 expand_null_return ();
7208 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7209 else if (! current_function_returns_struct
7210 && TREE_CODE (retval) == TARGET_EXPR
7211 && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
7212 retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval,
7213 TREE_OPERAND (retval, 0));
7215 /* Add some useful error checking for C++. */
7216 else if (TREE_CODE (valtype) == REFERENCE_TYPE)
7218 tree whats_returned;
7220 /* Sort through common things to see what it is
7221 we are returning. */
7222 whats_returned = retval;
7223 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
7225 whats_returned = TREE_OPERAND (whats_returned, 1);
7226 if (TREE_CODE (whats_returned) == ADDR_EXPR)
7227 whats_returned = TREE_OPERAND (whats_returned, 0);
7229 while (TREE_CODE (whats_returned) == CONVERT_EXPR
7230 || TREE_CODE (whats_returned) == NOP_EXPR)
7231 whats_returned = TREE_OPERAND (whats_returned, 0);
7232 if (TREE_CODE (whats_returned) == ADDR_EXPR)
7234 whats_returned = TREE_OPERAND (whats_returned, 0);
7235 while (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
7236 || TREE_CODE (whats_returned) == TARGET_EXPR)
7238 /* Get the target. */
7239 whats_returned = TREE_OPERAND (whats_returned, 0);
7240 warning ("returning reference to temporary");
7244 if (TREE_CODE (whats_returned) == VAR_DECL && DECL_NAME (whats_returned))
7246 if (TEMP_NAME_P (DECL_NAME (whats_returned)))
7247 warning ("reference to non-lvalue returned");
7248 else if (TREE_CODE (TREE_TYPE (whats_returned)) != REFERENCE_TYPE
7249 && DECL_FUNCTION_SCOPE_P (whats_returned)
7250 && !(TREE_STATIC (whats_returned)
7251 || TREE_PUBLIC (whats_returned)))
7252 cp_warning_at ("reference to local variable `%D' returned", whats_returned);
7255 else if (TREE_CODE (retval) == ADDR_EXPR)
7257 tree whats_returned = TREE_OPERAND (retval, 0);
7259 if (TREE_CODE (whats_returned) == VAR_DECL
7260 && DECL_NAME (whats_returned)
7261 && DECL_FUNCTION_SCOPE_P (whats_returned)
7262 && !(TREE_STATIC (whats_returned)
7263 || TREE_PUBLIC (whats_returned)))
7264 cp_warning_at ("address of local variable `%D' returned", whats_returned);
7268 if (retval != NULL_TREE
7269 && TREE_CODE_CLASS (TREE_CODE (retval)) == 'd'
7270 && cond_stack == 0 && loop_stack == 0 && case_stack == 0)
7271 current_function_return_value = retval;
7273 if (ctor_label && TREE_CODE (ctor_label) != ERROR_MARK)
7275 /* Here RETVAL is CURRENT_CLASS_PTR, so there's nothing to do. */
7276 expand_goto (ctor_label);
7279 if (retval && retval != result)
7281 result = build (INIT_EXPR, TREE_TYPE (result), result, retval);
7282 TREE_SIDE_EFFECTS (result) = 1;
7285 expand_start_target_temps ();
7287 expand_return (result);
7289 expand_end_target_temps ();
7291 current_function_returns_value = 1;
7294 /* Start a C switch statement, testing expression EXP.
7295 Return EXP if it is valid, an error node otherwise. */
7298 c_expand_start_case (exp)
7303 exp = build_expr_type_conversion (WANT_INT | WANT_ENUM, exp, 1);
7304 if (exp == NULL_TREE)
7306 error ("switch quantity not an integer");
7307 exp = error_mark_node;
7309 if (exp == error_mark_node)
7310 return error_mark_node;
7312 exp = default_conversion (exp);
7313 type = TREE_TYPE (exp);
7314 idx = get_unwidened (exp, 0);
7315 /* We can't strip a conversion from a signed type to an unsigned,
7316 because if we did, int_fits_type_p would do the wrong thing
7317 when checking case values for being in range,
7318 and it's too hard to do the right thing. */
7319 if (TREE_UNSIGNED (TREE_TYPE (exp)) == TREE_UNSIGNED (TREE_TYPE (idx)))
7323 (1, fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp)),
7324 type, "switch statement");
7329 /* Returns non-zero if the pointer-type FROM can be converted to the
7330 pointer-type TO via a qualification conversion. If CONSTP is -1,
7331 then we return non-zero if the pointers are similar, and the
7332 cv-qualification signature of FROM is a proper subset of that of TO.
7334 If CONSTP is positive, then all outer pointers have been
7338 comp_ptr_ttypes_real (to, from, constp)
7342 int to_more_cv_qualified = 0;
7344 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7346 if (TREE_CODE (to) != TREE_CODE (from))
7349 if (TREE_CODE (from) == OFFSET_TYPE
7350 && same_type_p (TYPE_OFFSET_BASETYPE (from),
7351 TYPE_OFFSET_BASETYPE (to)))
7354 /* Const and volatile mean something different for function types,
7355 so the usual checks are not appropriate. */
7356 if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7358 if (!at_least_as_qualified_p (to, from))
7361 if (!at_least_as_qualified_p (from, to))
7366 ++to_more_cv_qualified;
7370 constp &= TYPE_READONLY (to);
7373 if (TREE_CODE (to) != POINTER_TYPE)
7375 same_type_p (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from))
7376 && (constp >= 0 || to_more_cv_qualified);
7380 /* When comparing, say, char ** to char const **, this function takes the
7381 'char *' and 'char const *'. Do not pass non-pointer types to this
7385 comp_ptr_ttypes (to, from)
7388 return comp_ptr_ttypes_real (to, from, 1);
7391 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7392 type or inheritance-related types, regardless of cv-quals. */
7395 ptr_reasonably_similar (to, from)
7398 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7400 if (TREE_CODE (to) != TREE_CODE (from))
7403 if (TREE_CODE (from) == OFFSET_TYPE
7404 && comptypes (TYPE_OFFSET_BASETYPE (to),
7405 TYPE_OFFSET_BASETYPE (from),
7406 COMPARE_BASE | COMPARE_RELAXED))
7409 if (TREE_CODE (to) != POINTER_TYPE)
7411 (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7412 COMPARE_BASE | COMPARE_RELAXED);
7416 /* Like comp_ptr_ttypes, for const_cast. */
7419 comp_ptr_ttypes_const (to, from)
7422 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7424 if (TREE_CODE (to) != TREE_CODE (from))
7427 if (TREE_CODE (from) == OFFSET_TYPE
7428 && same_type_p (TYPE_OFFSET_BASETYPE (from),
7429 TYPE_OFFSET_BASETYPE (to)))
7432 if (TREE_CODE (to) != POINTER_TYPE)
7433 return same_type_p (TYPE_MAIN_VARIANT (to),
7434 TYPE_MAIN_VARIANT (from));
7438 /* Like comp_ptr_ttypes, for reinterpret_cast. */
7441 comp_ptr_ttypes_reinterpret (to, from)
7446 for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7448 if (TREE_CODE (from) == OFFSET_TYPE)
7449 from = TREE_TYPE (from);
7450 if (TREE_CODE (to) == OFFSET_TYPE)
7451 to = TREE_TYPE (to);
7453 /* Const and volatile mean something different for function types,
7454 so the usual checks are not appropriate. */
7455 if (TREE_CODE (from) != FUNCTION_TYPE && TREE_CODE (from) != METHOD_TYPE
7456 && TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7458 if (!at_least_as_qualified_p (to, from))
7462 && !at_least_as_qualified_p (from, to))
7464 constp &= TYPE_READONLY (to);
7467 if (TREE_CODE (from) != POINTER_TYPE
7468 || TREE_CODE (to) != POINTER_TYPE)
7473 /* Returns the type-qualifier set corresponding to TYPE. */
7476 cp_type_quals (type)
7479 while (TREE_CODE (type) == ARRAY_TYPE)
7480 type = TREE_TYPE (type);
7482 return TYPE_QUALS (type);
7485 /* Returns non-zero if the TYPE contains a mutable member */
7488 cp_has_mutable_p (type)
7491 while (TREE_CODE (type) == ARRAY_TYPE)
7492 type = TREE_TYPE (type);
7494 return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);