1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92, 93, 1994 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This file is part of the C++ front end.
23 It contains routines to build C++ expressions given their operands,
24 including computing the types of the result, C and C++ specific error
25 checks, and some optimization.
27 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
28 and to process initializations in declarations (since they work
29 like a strange sort of assignment). */
32 extern void warning ();
41 int mark_addressable ();
42 static tree convert_for_assignment ();
43 /* static */ tree convert_for_initialization ();
44 extern tree shorten_compare ();
45 extern void binary_op_error ();
46 static tree pointer_int_sum ();
47 static tree pointer_diff ();
48 static tree convert_sequence ();
49 /* static */ tree unary_complex_lvalue ();
50 static void pedantic_lvalue_warning ();
51 tree truthvalue_conversion ();
53 extern rtx original_result_rtx;
55 /* Return the target type of TYPE, which meas return T for:
56 T*, T&, T[], T (...), and otherwise, just T. */
62 if (TREE_CODE (type) == REFERENCE_TYPE)
63 type = TREE_TYPE (type);
64 while (TREE_CODE (type) == POINTER_TYPE
65 || TREE_CODE (type) == ARRAY_TYPE
66 || TREE_CODE (type) == FUNCTION_TYPE
67 || TREE_CODE (type) == METHOD_TYPE
68 || TREE_CODE (type) == OFFSET_TYPE)
69 type = TREE_TYPE (type);
73 /* Do `exp = require_complete_type (exp);' to make sure exp
74 does not have an incomplete type. (That includes void types.) */
77 require_complete_type (value)
80 tree type = TREE_TYPE (value);
82 /* First, detect a valid value with a complete type. */
83 if (TYPE_SIZE (type) != 0
84 && type != void_type_node
85 && ! (TYPE_LANG_SPECIFIC (type)
86 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))
87 && TYPE_SIZE (SIGNATURE_TYPE (type)) == 0))
90 /* If we see X::Y, we build an OFFSET_TYPE which has
91 not been laid out. Try to avoid an error by interpreting
92 it as this->X::Y, if reasonable. */
93 if (TREE_CODE (value) == OFFSET_REF
95 && TREE_OPERAND (value, 0) == C_C_D)
97 tree base, member = TREE_OPERAND (value, 1);
98 tree basetype = TYPE_OFFSET_BASETYPE (type);
99 my_friendly_assert (TREE_CODE (member) == FIELD_DECL, 305);
100 base = convert_pointer_to (basetype, current_class_decl);
101 value = build (COMPONENT_REF, TREE_TYPE (member),
102 build_indirect_ref (base, NULL_PTR), member);
103 return require_complete_type (value);
106 incomplete_type_error (value, type);
107 return error_mark_node;
110 /* Return truthvalue of whether type of EXP is instantiated. */
115 return (TREE_CODE (exp) == TREE_LIST
116 || TREE_TYPE (exp) == unknown_type_node
117 || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
118 && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node));
121 /* Return truthvalue of whether T is function (or pfn) type. */
126 return (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE
127 || (TREE_CODE (t) == POINTER_TYPE
128 && (TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE
129 || TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE)));
132 /* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
133 does not have an uninstantiated type.
134 TYPE is type to instantiate with, if uninstantiated. */
136 require_instantiated_type (type, exp, errval)
137 tree type, exp, errval;
139 if (TREE_TYPE (exp) == NULL_TREE)
141 error ("argument list may not have an initializer list");
145 if (TREE_TYPE (exp) == unknown_type_node
146 || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
147 && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node))
149 exp = instantiate_type (type, exp, 1);
150 if (TREE_TYPE (exp) == error_mark_node)
156 /* Return a variant of TYPE which has all the type qualifiers of LIKE
157 as well as those of TYPE. */
160 qualify_type (type, like)
163 int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
164 int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
165 /* @@ Must do member pointers here. */
166 return build_type_variant (type, constflag, volflag);
169 /* Return the common type of two parameter lists.
170 We assume that comptypes has already been done and returned 1;
171 if that isn't so, this may crash.
173 As an optimization, free the space we allocate if the parameter
174 lists are already common. */
180 tree oldargs = p1, newargs, n;
183 char *first_obj = (char *) oballoc (0);
185 len = list_length (p1);
186 newargs = tree_last (p1);
188 if (newargs == void_list_node)
197 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
202 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
204 if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
206 /* We used to give a warning here that advised about a default
207 argument being given in the prototype but not in the function's
208 declaration. It's best not to bother. */
209 TREE_PURPOSE (n) = TREE_PURPOSE (p1);
212 else if (! TREE_PURPOSE (p1))
214 if (TREE_PURPOSE (p2))
216 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
222 int cmp = simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2));
224 my_friendly_abort (111);
227 error ("redeclaration of default argument %d", i+1);
230 TREE_PURPOSE (n) = TREE_PURPOSE (p2);
232 if (TREE_VALUE (p1) != TREE_VALUE (p2))
235 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
238 TREE_VALUE (n) = TREE_VALUE (p1);
249 /* Return the common type of two types.
250 We assume that comptypes has already been done and returned 1;
251 if that isn't so, this may crash.
253 This is the type for the result of most arithmetic operations
254 if the operands have the given two types.
256 We do not deal with enumeral types here because they have already been
257 converted to integer types. */
263 register enum tree_code code1;
264 register enum tree_code code2;
266 /* Save time if the two types are the same. */
268 if (t1 == t2) return t1;
270 /* If one type is nonsense, use the other. */
271 if (t1 == error_mark_node)
273 if (t2 == error_mark_node)
276 /* Treat an enum type as the unsigned integer type of the same width. */
278 if (TREE_CODE (t1) == ENUMERAL_TYPE)
279 t1 = type_for_size (TYPE_PRECISION (t1), 1);
280 if (TREE_CODE (t2) == ENUMERAL_TYPE)
281 t2 = type_for_size (TYPE_PRECISION (t2), 1);
283 code1 = TREE_CODE (t1);
284 code2 = TREE_CODE (t2);
290 /* If only one is real, use it as the result. */
292 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
295 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
298 /* Both real or both integers; use the one with greater precision. */
300 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
302 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
305 /* Same precision. Prefer longs to ints even when same size. */
307 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
308 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
309 return long_unsigned_type_node;
311 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
312 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
314 /* But preserve unsignedness from the other type,
315 since long cannot hold all the values of an unsigned int. */
316 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
317 return long_unsigned_type_node;
318 return long_integer_type_node;
321 /* Otherwise prefer the unsigned one. */
323 if (TREE_UNSIGNED (t1))
329 /* For two pointers, do this recursively on the target type,
330 and combine the qualifiers of the two types' targets. */
331 /* This code was turned off; I don't know why.
332 But ANSI C++ specifies doing this with the qualifiers.
333 So I turned it on again. */
335 tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
336 TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
338 = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
340 = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
341 target = build_type_variant (target, constp, volatilep);
342 if (code1 == POINTER_TYPE)
343 return build_pointer_type (target);
345 return build_reference_type (target);
349 return build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
352 return build_reference_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
357 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
358 /* Save space: see if the result is identical to one of the args. */
359 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
361 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
363 /* Merge the element types, and have a size if either arg has one. */
364 return build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
368 /* Function types: prefer the one that specified arg types.
369 If both do, merge the arg types. Also merge the return types. */
371 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
372 tree p1 = TYPE_ARG_TYPES (t1);
373 tree p2 = TYPE_ARG_TYPES (t2);
376 /* Save space: see if the result is identical to one of the args. */
377 if (valtype == TREE_TYPE (t1) && ! p2)
379 if (valtype == TREE_TYPE (t2) && ! p1)
382 /* Simple way if one arg fails to specify argument types. */
383 if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
385 rval = build_function_type (valtype, p2);
386 if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
387 rval = build_exception_variant (NULL_TREE, rval, raises);
390 raises = TYPE_RAISES_EXCEPTIONS (t1);
391 if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
393 rval = build_function_type (valtype, p1);
395 rval = build_exception_variant (NULL_TREE, rval, raises);
399 rval = build_function_type (valtype, commonparms (p1, p2));
400 return build_exception_variant (NULL_TREE, rval, raises);
405 my_friendly_assert (TYPE_MAIN_VARIANT (t1) == t1
406 && TYPE_MAIN_VARIANT (t2) == t2, 306);
408 if (binfo_or_else (t1, t2))
410 compiler_error ("common_type called with uncommon aggregate types");
414 if (TYPE_METHOD_BASETYPE (t1) == TYPE_METHOD_BASETYPE (t2)
415 && TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2)))
417 /* Get this value the long way, since TYPE_METHOD_BASETYPE
418 is just the main variant of this. */
419 tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1)));
422 raises = TYPE_RAISES_EXCEPTIONS (t1);
424 /* If this was a member function type, get back to the
425 original type of type member function (i.e., without
426 the class instance variable up front. */
427 t1 = build_function_type (TREE_TYPE (t1), TREE_CHAIN (TYPE_ARG_TYPES (t1)));
428 t2 = build_function_type (TREE_TYPE (t2), TREE_CHAIN (TYPE_ARG_TYPES (t2)));
429 t3 = common_type (t1, t2);
430 t3 = build_cplus_method_type (basetype, TREE_TYPE (t3), TYPE_ARG_TYPES (t3));
431 return build_exception_variant (basetype, t3, raises);
433 compiler_error ("common_type called with uncommon method types");
437 if (TYPE_OFFSET_BASETYPE (t1) == TYPE_OFFSET_BASETYPE (t2)
438 && TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2)))
440 tree basetype = TYPE_OFFSET_BASETYPE (t1);
441 return build_offset_type (basetype,
442 common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
444 compiler_error ("common_type called with uncommon member types");
452 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
454 compexcepttypes (t1, t2, strict)
458 return TYPE_RAISES_EXCEPTIONS (t1) == TYPE_RAISES_EXCEPTIONS (t2);
462 comp_array_types (cmp, t1, t2, strict)
463 register int (*cmp)();
467 tree d1 = TYPE_DOMAIN (t1);
468 tree d2 = TYPE_DOMAIN (t2);
470 /* Target types must match incl. qualifiers. */
471 if (!(TREE_TYPE (t1) == TREE_TYPE (t2)
472 || (*cmp) (TREE_TYPE (t1), TREE_TYPE (t2), strict)))
475 /* Sizes must match unless one is missing or variable. */
476 if (d1 == 0 || d2 == 0 || d1 == d2
477 || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
478 || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
479 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
480 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
483 return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
484 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
485 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
486 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
487 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
488 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
489 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
490 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2))));
493 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
494 or various other operations. This is what ANSI C++ speaks of as
497 For C++: argument STRICT says we should be strict about this
500 2 : strict, except that if one type is a reference and
501 the other is not, compare the target type of the
502 reference to the type that's not a reference (ARM, p308).
503 1 : strict (compared according to ANSI C)
504 0 : <= (compared according to C++)
505 -1: <= or >= (relaxed)
507 Otherwise, pointers involving base classes and derived classes
508 can be mixed as legal: i.e. a pointer to a base class may be assigned
509 to a pointer to one of its derived classes, as per C++. A pointer to
510 a derived class may be passed as a parameter to a function expecting a
511 pointer to a base classes. These allowances do not commute. In this
512 case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
513 be the derived class. */
515 comptypes (type1, type2, strict)
519 register tree t1 = type1;
520 register tree t2 = type2;
522 /* Suppress errors caused by previously reported errors */
527 /* This should never happen. */
528 my_friendly_assert (t1 != error_mark_node, 307);
530 if (t2 == error_mark_node)
535 /* Treat an enum type as the unsigned integer type of the same width. */
537 if (TREE_CODE (t1) == ENUMERAL_TYPE)
538 t1 = type_for_size (TYPE_PRECISION (t1), 1);
539 if (TREE_CODE (t2) == ENUMERAL_TYPE)
540 t2 = type_for_size (TYPE_PRECISION (t2), 1);
546 /* Different classes of types can't be compatible. */
548 if (TREE_CODE (t1) != TREE_CODE (t2))
551 && ((TREE_CODE (t1) == REFERENCE_TYPE)
552 ^ (TREE_CODE (t2) == REFERENCE_TYPE)))
554 if (TREE_CODE (t1) == REFERENCE_TYPE)
555 return comptypes (TREE_TYPE (t1), t2, 1);
556 return comptypes (t1, TREE_TYPE (t2), 1);
564 /* Qualifiers must match. */
566 if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
568 if (TREE_THIS_VOLATILE (t1) != TREE_THIS_VOLATILE (t2))
571 /* Allow for two different type nodes which have essentially the same
572 definition. Note that we already checked for equality of the type
573 type qualifiers (just above). */
575 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
578 switch (TREE_CODE (t1))
589 return (comptypes (TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t1)),
590 TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t2)), strict)
591 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict));
594 if (! compexcepttypes (t1, t2, strict))
597 /* This case is anti-symmetrical!
598 One can pass a base member (or member function)
599 to something expecting a derived member (or member function),
600 but not vice-versa! */
602 return (comptypes (TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t2)),
603 TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t1)), strict)
604 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict)
605 && compparms (TREE_CHAIN (TYPE_ARG_TYPES (t1)),
606 TREE_CHAIN (TYPE_ARG_TYPES (t2)), strict));
615 if (TREE_CODE (t1) == RECORD_TYPE && TREE_CODE (t2) == RECORD_TYPE)
619 rval = t1 == t2 || UNIQUELY_DERIVED_FROM_P (t1, t2);
624 return UNIQUELY_DERIVED_FROM_P (t2, t1);
629 return comptypes (t1, t2, strict);
632 if (! compexcepttypes (t1, t2, strict))
635 return ((TREE_TYPE (t1) == TREE_TYPE (t2)
636 || comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict))
637 && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2), strict));
640 /* Target types must match incl. qualifiers. */
641 return comp_array_types (comptypes, t1, t2, strict);
643 case TEMPLATE_TYPE_PARM:
649 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
650 ignoring their qualifiers.
652 NPTRS is the number of pointers we can strip off and keep cool.
653 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
654 but to not permit B** to convert to A**. */
657 comp_target_types (ttl, ttr, nptrs)
661 ttl = TYPE_MAIN_VARIANT (ttl);
662 ttr = TYPE_MAIN_VARIANT (ttr);
665 if (TREE_CODE (ttr) == TEMPLATE_TYPE_PARM)
668 if (TREE_CODE (ttr) != TREE_CODE (ttl))
671 if (TREE_CODE (ttr) == POINTER_TYPE)
672 return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs - 1);
674 if (TREE_CODE (ttr) == REFERENCE_TYPE)
675 return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs);
676 if (TREE_CODE (ttr) == ARRAY_TYPE)
677 return comp_array_types (comp_target_types, ttl, ttr, 0);
678 else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
679 if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs))
680 switch (comp_target_parms (TYPE_ARG_TYPES (ttl), TYPE_ARG_TYPES (ttr), 1))
687 warning ("contravariance violation for method types ignored");
690 my_friendly_abort (112);
696 else if (TREE_CODE (ttr) == OFFSET_TYPE)
698 /* Contravariance: we can assign a pointer to base member to a pointer
699 to derived member. Note difference from simple pointer case, where
700 we can pass a pointer to derived to a pointer to base. */
701 if (comptypes (TYPE_OFFSET_BASETYPE (ttr), TYPE_OFFSET_BASETYPE (ttl), 0))
702 return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs);
703 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl), TYPE_OFFSET_BASETYPE (ttr), 0)
704 && comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs))
706 warning ("contravariance violation for member types ignored");
710 else if (IS_AGGR_TYPE (ttl))
714 return comptypes (TYPE_POINTER_TO (ttl), TYPE_POINTER_TO (ttr), 0);
720 /* If two types share a common base type, return that basetype.
721 If there is not a unique most-derived base type, this function
722 returns ERROR_MARK_NODE. */
724 common_base_type (tt1, tt2)
727 tree best = NULL_TREE, tmp;
730 /* If one is a baseclass of another, that's good enough. */
731 if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
733 if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
736 /* If they share a virtual baseclass, that's good enough. */
737 for (tmp = CLASSTYPE_VBASECLASSES (tt1); tmp; tmp = TREE_CHAIN (tmp))
739 if (binfo_member (BINFO_TYPE (tmp), CLASSTYPE_VBASECLASSES (tt2)))
740 return BINFO_TYPE (tmp);
743 /* Otherwise, try to find a unique baseclass of TT1
744 that is shared by TT2, and follow that down. */
745 for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
747 tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
748 tree trial = common_base_type (basetype, tt2);
751 if (trial == error_mark_node)
753 if (best == NULL_TREE)
755 else if (best != trial)
756 return error_mark_node;
761 for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
763 tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
764 tree trial = common_base_type (tt1, basetype);
767 if (trial == error_mark_node)
769 if (best == NULL_TREE)
771 else if (best != trial)
772 return error_mark_node;
778 /* Subroutines of `comptypes'. */
780 /* Return 1 if two parameter type lists PARMS1 and PARMS2
781 are equivalent in the sense that functions with those parameter types
782 can have equivalent types.
783 If either list is empty, we win.
784 Otherwise, the two lists must be equivalent, element by element.
786 C++: See comment above about TYPE1, TYPE2, STRICT.
787 If STRICT == 3, it means checking is strict, but do not compare
788 default parameter values. */
790 compparms (parms1, parms2, strict)
794 register tree t1 = parms1, t2 = parms2;
796 /* An unspecified parmlist matches any specified parmlist
797 whose argument types don't need default promotions. */
799 if (strict <= 0 && t1 == 0)
800 return self_promoting_args_p (t2);
801 if (strict < 0 && t2 == 0)
802 return self_promoting_args_p (t1);
806 if (t1 == 0 && t2 == 0)
808 /* If one parmlist is shorter than the other,
809 they fail to match, unless STRICT is <= 0. */
810 if (t1 == 0 || t2 == 0)
817 return t1 && TREE_PURPOSE (t1);
819 if (! comptypes (TREE_VALUE (t2), TREE_VALUE (t1), strict))
824 return t2 == void_list_node && TREE_PURPOSE (t1);
825 return TREE_PURPOSE (t1) || TREE_PURPOSE (t2);
827 if (strict != 3 && TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
829 int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
831 my_friendly_abort (113);
836 t1 = TREE_CHAIN (t1);
837 t2 = TREE_CHAIN (t2);
841 /* This really wants return whether or not parameter type lists
842 would make their owning functions assignment compatible or not. */
844 comp_target_parms (parms1, parms2, strict)
848 register tree t1 = parms1, t2 = parms2;
849 int warn_contravariance = 0;
851 /* An unspecified parmlist matches any specified parmlist
852 whose argument types don't need default promotions.
853 @@@ see 13.3.3 for a counterexample... */
855 if (t1 == 0 && t2 != 0)
857 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
859 return self_promoting_args_p (t2);
862 return self_promoting_args_p (t1);
864 for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
868 /* If one parmlist is shorter than the other,
869 they fail to match, unless STRICT is <= 0. */
870 if (t1 == 0 || t2 == 0)
875 return 1 + warn_contravariance;
876 return ((t1 && TREE_PURPOSE (t1)) + warn_contravariance);
878 p1 = TREE_VALUE (t1);
879 p2 = TREE_VALUE (t2);
882 if (TREE_CODE (p2) == TEMPLATE_TYPE_PARM)
885 if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
886 || (TREE_CODE (p1) == REFERENCE_TYPE && TREE_CODE (p2) == REFERENCE_TYPE))
889 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1))
890 == TYPE_MAIN_VARIANT (TREE_TYPE (p2))))
893 if (TREE_CODE (TREE_TYPE (p2)) == TEMPLATE_TYPE_PARM)
896 /* The following is wrong for contravariance,
897 but many programs depend on it. */
898 if (TREE_TYPE (p1) == void_type_node)
900 if (TREE_TYPE (p2) == void_type_node)
902 warn_contravariance = 1;
905 if (IS_AGGR_TYPE (TREE_TYPE (p1)))
907 if (comptypes (p2, p1, 0) == 0)
909 if (comptypes (p1, p2, 0) != 0)
910 warn_contravariance = 1;
917 /* Note backwards order due to contravariance. */
918 if (comp_target_types (p2, p1, 1) == 0)
920 if (comp_target_types (p1, p2, 1))
922 warn_contravariance = 1;
928 /* What good do these cases do? */
930 return p2 == void_type_node && TREE_PURPOSE (t1);
931 return TREE_PURPOSE (t1) || TREE_PURPOSE (t2);
934 /* Target types are compatible--just make sure that if
935 we use parameter lists, that they are ok as well. */
936 if (TREE_CODE (p1) == FUNCTION_TYPE || TREE_CODE (p1) == METHOD_TYPE)
937 switch (comp_target_parms (TYPE_ARG_TYPES (p1),
946 warn_contravariance = 1;
949 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
951 int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
953 my_friendly_abort (114);
958 return 1 + warn_contravariance;
961 /* Return 1 if PARMS specifies a fixed number of parameters
962 and none of their types is affected by default promotions. */
965 self_promoting_args_p (parms)
969 for (t = parms; t; t = TREE_CHAIN (t))
971 register tree type = TREE_VALUE (t);
973 if (TREE_CHAIN (t) == 0 && type != void_type_node)
976 if (TYPE_MAIN_VARIANT (type) == float_type_node)
982 if (C_PROMOTING_INTEGER_TYPE_P (type))
988 /* Return an unsigned type the same as TYPE in other respects.
990 C++: must make these work for type variants as well. */
996 tree type1 = TYPE_MAIN_VARIANT (type);
997 if (type1 == signed_char_type_node || type1 == char_type_node)
998 return unsigned_char_type_node;
999 if (type1 == integer_type_node)
1000 return unsigned_type_node;
1001 if (type1 == short_integer_type_node)
1002 return short_unsigned_type_node;
1003 if (type1 == long_integer_type_node)
1004 return long_unsigned_type_node;
1005 if (type1 == long_long_integer_type_node)
1006 return long_long_unsigned_type_node;
1010 /* Return a signed type the same as TYPE in other respects. */
1016 tree type1 = TYPE_MAIN_VARIANT (type);
1017 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1018 return signed_char_type_node;
1019 if (type1 == unsigned_type_node)
1020 return integer_type_node;
1021 if (type1 == short_unsigned_type_node)
1022 return short_integer_type_node;
1023 if (type1 == long_unsigned_type_node)
1024 return long_integer_type_node;
1025 if (type1 == long_long_unsigned_type_node)
1026 return long_long_integer_type_node;
1030 /* Return a type the same as TYPE except unsigned or
1031 signed according to UNSIGNEDP. */
1034 signed_or_unsigned_type (unsignedp, type)
1038 if (! INTEGRAL_TYPE_P (type))
1040 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1041 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1042 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1043 return unsignedp ? unsigned_type_node : integer_type_node;
1044 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1045 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1046 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1047 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1048 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1049 return (unsignedp ? long_long_unsigned_type_node
1050 : long_long_integer_type_node);
1058 enum tree_code code = TREE_CODE (type);
1061 if (code == FUNCTION_TYPE)
1063 if (pedantic || warn_pointer_arith)
1064 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1065 return size_int (1);
1067 if (code == METHOD_TYPE)
1069 if (pedantic || warn_pointer_arith)
1070 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1071 return size_int (1);
1073 if (code == VOID_TYPE)
1075 if (pedantic || warn_pointer_arith)
1076 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1077 return size_int (1);
1079 if (code == ERROR_MARK)
1080 return size_int (1);
1082 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1083 referenced object.'' */
1084 if (code == REFERENCE_TYPE)
1085 type = TREE_TYPE (type);
1087 /* We couldn't find anything in the ARM or the draft standard that says,
1088 one way or the other, if doing sizeof on something that doesn't have
1089 an object associated with it is correct or incorrect. For example, if
1090 you declare `struct S { char str[16]; };', and in your program do
1091 a `sizeof (S::str)', should we flag that as an error or should we give
1092 the size of it? Since it seems like a reasonable thing to do, we'll go
1093 with giving the value. */
1094 if (code == OFFSET_TYPE)
1095 type = TREE_TYPE (type);
1097 /* @@ This also produces an error for a signature ref.
1098 In that case we should be able to do better. */
1099 if (IS_SIGNATURE (type))
1101 error ("`sizeof' applied to a signature type");
1102 return size_int (0);
1105 if (TYPE_SIZE (type) == 0)
1107 error ("`sizeof' applied to an incomplete type");
1108 return size_int (0);
1111 /* Convert in case a char is more than one unit. */
1112 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
1113 size_int (TYPE_PRECISION (char_type_node)));
1114 /* size_binop does not put the constant in range, so do it now. */
1115 if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
1116 TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
1121 c_sizeof_nowarn (type)
1124 enum tree_code code = TREE_CODE (type);
1127 if (code == FUNCTION_TYPE
1128 || code == METHOD_TYPE
1129 || code == VOID_TYPE
1130 || code == ERROR_MARK)
1131 return size_int (1);
1132 if (code == REFERENCE_TYPE)
1133 type = TREE_TYPE (type);
1135 if (TYPE_SIZE (type) == 0)
1138 /* ??? Tiemann, why have any diagnostic here?
1139 There is none in the corresponding function for C. */
1140 warning ("sizeof applied to an incomplete type");
1142 return size_int (0);
1145 /* Convert in case a char is more than one unit. */
1146 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
1147 size_int (TYPE_PRECISION (char_type_node)));
1148 force_fit_type (t, 0);
1152 /* Implement the __alignof keyword: Return the minimum required
1153 alignment of TYPE, measured in bytes. */
1159 enum tree_code code = TREE_CODE (type);
1162 if (code == FUNCTION_TYPE || code == METHOD_TYPE)
1163 return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1165 if (code == VOID_TYPE || code == ERROR_MARK)
1166 return size_int (1);
1168 /* C++: this is really correct! */
1169 if (code == REFERENCE_TYPE)
1170 type = TREE_TYPE (type);
1172 /* @@ This also produces an error for a signature ref.
1173 In that case we should be able to do better. */
1174 if (IS_SIGNATURE (type))
1176 error ("`__alignof' applied to a signature type");
1177 return size_int (1);
1180 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
1181 force_fit_type (t, 0);
1185 /* Perform default promotions for C data used in expressions.
1186 Arrays and functions are converted to pointers;
1187 enumeral types or short or char, to int.
1188 In addition, manifest constants symbols are replaced by their values.
1190 C++: this will automatically bash references to their target type. */
1193 default_conversion (exp)
1196 register tree type = TREE_TYPE (exp);
1197 register enum tree_code code = TREE_CODE (type);
1199 if (code == OFFSET_TYPE /* || TREE_CODE (exp) == OFFSET_REF */ )
1201 if (TREE_CODE (exp) == OFFSET_REF)
1202 return default_conversion (resolve_offset_ref (exp));
1204 type = TREE_TYPE (type);
1205 code = TREE_CODE (type);
1208 if (code == REFERENCE_TYPE)
1210 exp = convert_from_reference (exp);
1211 type = TREE_TYPE (exp);
1212 code = TREE_CODE (type);
1215 /* Constants can be used directly unless they're not loadable. */
1216 if (TREE_CODE (exp) == CONST_DECL)
1217 exp = DECL_INITIAL (exp);
1218 /* Replace a nonvolatile const static variable with its value. */
1219 else if (TREE_READONLY_DECL_P (exp) && DECL_MODE (exp) != BLKmode)
1221 exp = decl_constant_value (exp);
1222 type = TREE_TYPE (exp);
1225 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1226 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1228 if (code == ENUMERAL_TYPE || code == INTEGER_TYPE)
1230 tree t = type_promotes_to (type);
1231 if (t != TYPE_MAIN_VARIANT (type))
1232 return convert (t, exp);
1234 if (flag_traditional
1235 && TYPE_MAIN_VARIANT (type) == float_type_node)
1236 return convert (double_type_node, exp);
1237 if (code == VOID_TYPE)
1239 error ("void value not ignored as it ought to be");
1240 return error_mark_node;
1242 if (code == FUNCTION_TYPE)
1244 return build_unary_op (ADDR_EXPR, exp, 0);
1246 if (code == METHOD_TYPE)
1248 if (TREE_CODE (exp) == OFFSET_REF)
1250 my_friendly_assert (TREE_CODE (TREE_OPERAND (exp, 1)) == FUNCTION_DECL,
1252 return build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
1254 return build_unary_op (ADDR_EXPR, exp, 0);
1256 if (code == ARRAY_TYPE)
1261 int constp, volatilep;
1263 if (TREE_CODE (exp) == INDIRECT_REF)
1265 /* Stripping away the INDIRECT_REF is not the right
1266 thing to do for references... */
1267 tree inner = TREE_OPERAND (exp, 0);
1268 if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
1270 inner = build1 (CONVERT_EXPR,
1271 build_pointer_type (TREE_TYPE (TREE_TYPE (inner))),
1273 TREE_REFERENCE_EXPR (inner) = 1;
1275 return convert (TYPE_POINTER_TO (TREE_TYPE (type)), inner);
1278 if (TREE_CODE (exp) == COMPOUND_EXPR)
1280 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1281 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1282 TREE_OPERAND (exp, 0), op1);
1286 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1288 error ("invalid use of non-lvalue array");
1289 return error_mark_node;
1292 constp = volatilep = 0;
1293 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
1294 || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1296 constp = TREE_READONLY (exp);
1297 volatilep = TREE_THIS_VOLATILE (exp);
1300 restype = TREE_TYPE (type);
1301 if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
1302 || constp || volatilep)
1303 restype = build_type_variant (restype,
1304 TYPE_READONLY (type) || constp,
1305 TYPE_VOLATILE (type) || volatilep);
1306 ptrtype = build_pointer_type (restype);
1308 if (TREE_CODE (exp) == VAR_DECL)
1310 /* ??? This is not really quite correct
1311 in that the type of the operand of ADDR_EXPR
1312 is not the target type of the type of the ADDR_EXPR itself.
1313 Question is, can this lossage be avoided? */
1314 adr = build1 (ADDR_EXPR, ptrtype, exp);
1315 if (mark_addressable (exp) == 0)
1316 return error_mark_node;
1317 TREE_CONSTANT (adr) = staticp (exp);
1318 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1321 /* This way is better for a COMPONENT_REF since it can
1322 simplify the offset for a component. */
1323 adr = build_unary_op (ADDR_EXPR, exp, 1);
1324 return convert (ptrtype, adr);
1330 build_object_ref (datum, basetype, field)
1331 tree datum, basetype, field;
1333 if (datum == error_mark_node)
1334 return error_mark_node;
1335 else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype)))
1337 warning ("signature name in scope resolution ignored");
1338 return build_component_ref (datum, field, NULL_TREE, 1);
1340 else if (is_aggr_typedef (basetype, 1))
1342 tree real_basetype = IDENTIFIER_TYPE_VALUE (basetype);
1343 if (binfo_or_else (real_basetype, TREE_TYPE (datum)))
1344 return build_component_ref (build_scoped_ref (datum, basetype),
1345 field, NULL_TREE, 1);
1347 return error_mark_node;
1350 /* Like `build_component_ref, but uses an already found field.
1351 Must compute access for C_C_D. Otherwise, ok. */
1353 build_component_ref_1 (datum, field, protect)
1357 register tree basetype = TREE_TYPE (datum);
1358 register enum tree_code code = TREE_CODE (basetype);
1361 if (code == REFERENCE_TYPE)
1363 datum = convert_from_reference (datum);
1364 basetype = TREE_TYPE (datum);
1365 code = TREE_CODE (basetype);
1368 if (! IS_AGGR_TYPE_CODE (code))
1370 if (code != ERROR_MARK)
1371 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1372 field, datum, basetype);
1373 return error_mark_node;
1376 if (TYPE_SIZE (basetype) == 0)
1378 incomplete_type_error (0, basetype);
1379 return error_mark_node;
1382 /* Look up component name in the structure type definition. */
1384 if (field == error_mark_node)
1385 my_friendly_abort (115);
1387 if (TREE_STATIC (field))
1392 enum access_type access
1393 = compute_access (TYPE_BINFO (current_class_type), field);
1395 if (access == access_private)
1397 cp_error ("field `%D' is private", field);
1398 return error_mark_node;
1400 else if (access == access_protected)
1402 cp_error ("field `%D' is protected", field);
1403 return error_mark_node;
1407 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1409 if (TREE_READONLY (datum) || TREE_READONLY (field))
1410 TREE_READONLY (ref) = 1;
1411 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1412 TREE_THIS_VOLATILE (ref) = 1;
1413 if (DECL_MUTABLE_P (field))
1414 TREE_READONLY (ref) = 0;
1419 /* Given a COND_EXPR in T, return it in a form that we can, for
1420 example, use as an lvalue. This code used to be in unary_complex_lvalue,
1421 but we needed it to deal with `a = (d == c) ? b : c' expressions, where
1422 we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
1423 and in build_modify_expr. The case (in particular) that led to this was
1424 with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
1426 rationalize_conditional_expr (code, t)
1427 enum tree_code code;
1431 build_conditional_expr (TREE_OPERAND (t, 0),
1432 build_unary_op (code, TREE_OPERAND (t, 1), 0),
1433 build_unary_op (code, TREE_OPERAND (t, 2), 0));
1437 build_component_ref (datum, component, basetype_path, protect)
1438 tree datum, component, basetype_path;
1441 register tree basetype = TREE_TYPE (datum);
1442 register enum tree_code code = TREE_CODE (basetype);
1443 register tree field = NULL;
1446 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1447 unless we are not to support things not strictly ANSI. */
1448 switch (TREE_CODE (datum))
1452 tree value = build_component_ref (TREE_OPERAND (datum, 1), component,
1453 basetype_path, protect);
1454 return build (COMPOUND_EXPR, TREE_TYPE (value),
1455 TREE_OPERAND (datum, 0), value);
1458 return build_conditional_expr
1459 (TREE_OPERAND (datum, 0),
1460 build_component_ref (TREE_OPERAND (datum, 1), component,
1461 basetype_path, protect),
1462 build_component_ref (TREE_OPERAND (datum, 2), component,
1463 basetype_path, protect));
1466 if (code == REFERENCE_TYPE)
1469 /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
1470 @@ Maybe that is not right. */
1471 if (TREE_REFERENCE_EXPR (datum))
1472 datum = build1 (INDIRECT_REF, TREE_TYPE (basetype), datum);
1475 datum = convert_from_reference (datum);
1476 basetype = TREE_TYPE (datum);
1477 code = TREE_CODE (basetype);
1480 /* First, see if there is a field or component with name COMPONENT. */
1481 if (TREE_CODE (component) == TREE_LIST)
1483 my_friendly_assert (!(TREE_CHAIN (component) == NULL_TREE
1484 && DECL_CHAIN (TREE_VALUE (component)) == NULL_TREE), 309);
1485 return build (COMPONENT_REF, TREE_TYPE (component), datum, component);
1488 if (TREE_CODE (component) == TYPE_EXPR)
1489 return build_component_type_expr (datum, component, NULL_TREE, protect);
1492 if (! IS_AGGR_TYPE_CODE (code))
1494 if (code != ERROR_MARK)
1495 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1496 component, datum, basetype);
1497 return error_mark_node;
1500 if (TYPE_SIZE (basetype) == 0)
1502 incomplete_type_error (0, basetype);
1503 return error_mark_node;
1506 if (TREE_CODE (component) == BIT_NOT_EXPR)
1508 if (TYPE_IDENTIFIER (basetype) != TREE_OPERAND (component, 0))
1510 cp_error ("destructor specifier `%T::~%T' must have matching names",
1511 basetype, TREE_OPERAND (component, 0));
1512 return error_mark_node;
1514 if (! TYPE_HAS_DESTRUCTOR (basetype))
1516 cp_error ("type `%T' has no destructor", basetype);
1517 return error_mark_node;
1519 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
1522 /* Look up component name in the structure type definition. */
1523 if (CLASSTYPE_VFIELD (basetype)
1524 && DECL_NAME (CLASSTYPE_VFIELD (basetype)) == component)
1525 /* Special-case this because if we use normal lookups in an ambiguous
1526 hierarchy, the compiler will abort (because vptr lookups are
1527 not supposed to be ambiguous. */
1528 field = CLASSTYPE_VFIELD (basetype);
1531 if (basetype_path == NULL_TREE)
1532 basetype_path = TYPE_BINFO (basetype);
1533 field = lookup_field (basetype_path, component,
1534 protect && ! VFIELD_NAME_P (component), 0);
1535 if (field == error_mark_node)
1536 return error_mark_node;
1538 if (field == NULL_TREE)
1540 /* Not found as a data field, look for it as a method. If found,
1541 then if this is the only possible one, return it, else
1542 report ambiguity error. */
1543 tree fndecls = lookup_fnfields (basetype_path, component, 1);
1544 if (fndecls == error_mark_node)
1545 return error_mark_node;
1548 if (TREE_CHAIN (fndecls) == NULL_TREE
1549 && DECL_CHAIN (TREE_VALUE (fndecls)) == NULL_TREE)
1551 enum access_type access;
1554 /* Unique, so use this one now. */
1555 basetype = TREE_PURPOSE (fndecls);
1556 fndecl = TREE_VALUE (fndecls);
1557 access = compute_access (TREE_PURPOSE (fndecls), fndecl);
1558 if (access == access_public)
1560 if (DECL_VINDEX (fndecl)
1561 && ! resolves_to_fixed_type_p (datum, 0))
1563 tree addr = build_unary_op (ADDR_EXPR, datum, 0);
1564 addr = convert_pointer_to (DECL_CONTEXT (fndecl), addr);
1565 datum = build_indirect_ref (addr, NULL_PTR);
1566 my_friendly_assert (datum != error_mark_node, 310);
1567 fndecl = build_vfn_ref (&addr, datum, DECL_VINDEX (fndecl));
1571 if (access == access_protected)
1572 cp_error ("member function `%D' is protected", fndecl);
1574 cp_error ("member function `%D' is private", fndecl);
1575 return error_mark_node;
1578 return build (COMPONENT_REF, unknown_type_node, datum, fndecls);
1582 if (component == ansi_opname[(int) TYPE_EXPR])
1583 cp_error ("`%#T' has no such type conversion operator", basetype);
1586 cp_error ("`%#T' has no member named `%D'", basetype, component);
1587 return error_mark_node;
1589 else if (TREE_TYPE (field) == error_mark_node)
1590 return error_mark_node;
1592 if (TREE_CODE (field) != FIELD_DECL)
1594 if (TREE_CODE (field) == TYPE_DECL)
1596 cp_error ("invalid use of type decl `%#D' as expression", field);
1597 return error_mark_node;
1599 if (DECL_RTL (field) != 0)
1600 assemble_external (field);
1601 TREE_USED (field) = 1;
1606 if (DECL_FIELD_CONTEXT (field) != basetype
1607 && TYPE_USES_COMPLEX_INHERITANCE (basetype))
1609 tree addr = build_unary_op (ADDR_EXPR, datum, 0);
1610 if (integer_zerop (addr))
1612 error ("invalid reference to NULL ptr, use ptr-to-member instead");
1613 return error_mark_node;
1615 addr = convert_pointer_to (DECL_FIELD_CONTEXT (field), addr);
1616 datum = build_indirect_ref (addr, NULL_PTR);
1617 my_friendly_assert (datum != error_mark_node, 311);
1619 ref = build (COMPONENT_REF, TREE_TYPE (field), break_out_cleanups (datum), field);
1621 if (TREE_READONLY (datum) || TREE_READONLY (field))
1622 TREE_READONLY (ref) = 1;
1623 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1624 TREE_THIS_VOLATILE (ref) = 1;
1625 if (DECL_MUTABLE_P (field))
1626 TREE_READONLY (ref) = 0;
1631 /* Given an expression PTR for a pointer, return an expression
1632 for the value pointed to.
1633 ERRORSTRING is the name of the operator to appear in error messages.
1635 This function may need to overload OPERATOR_FNNAME.
1636 Must also handle REFERENCE_TYPEs for C++. */
1639 build_x_indirect_ref (ptr, errorstring)
1643 tree rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE, NULL_TREE);
1646 return build_indirect_ref (ptr, errorstring);
1650 build_indirect_ref (ptr, errorstring)
1654 register tree pointer = default_conversion (ptr);
1655 register tree type = TREE_TYPE (pointer);
1657 if (ptr == current_class_decl)
1660 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
1662 if (TREE_CODE (pointer) == ADDR_EXPR
1663 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1664 == TREE_TYPE (type)))
1665 return TREE_OPERAND (pointer, 0);
1668 tree t = TREE_TYPE (type);
1669 register tree ref = build1 (INDIRECT_REF,
1670 TYPE_MAIN_VARIANT (t), pointer);
1672 TREE_READONLY (ref) = TYPE_READONLY (t);
1673 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1674 TREE_SIDE_EFFECTS (ref)
1675 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1679 /* `pointer' won't be an error_mark_node if we were given a
1680 pointer to member, so it's cool to check for this here. */
1681 else if (TYPE_PTRMEMFUNC_P (type))
1682 error ("invalid use of `%s' on pointer to member function", errorstring);
1683 else if (TREE_CODE (type) == RECORD_TYPE
1684 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
1685 error ("cannot dereference signature pointer/reference");
1686 else if (pointer != error_mark_node)
1689 error ("invalid type argument of `%s'", errorstring);
1691 error ("invalid type argument");
1693 return error_mark_node;
1696 /* This handles expressions of the form "a[i]", which denotes
1699 This is logically equivalent in C to *(a+i), but we may do it differently.
1700 If A is a variable or a member, we generate a primitive ARRAY_REF.
1701 This avoids forcing the array out of registers, and can work on
1702 arrays that are not lvalues (for example, members of structures returned
1705 If INDEX is of some user-defined type, it must be converted to
1706 integer type. Otherwise, to make a compatible PLUS_EXPR, it
1707 will inherit the type of the array, which will be some pointer type. */
1710 build_x_array_ref (array, index)
1713 tree rval = build_opfncall (ARRAY_REF, LOOKUP_NORMAL, array, index, NULL_TREE);
1716 return build_array_ref (array, index);
1720 build_array_ref (array, idx)
1727 error ("subscript missing in array reference");
1728 return error_mark_node;
1731 if (TREE_TYPE (array) == error_mark_node
1732 || TREE_TYPE (idx) == error_mark_node)
1733 return error_mark_node;
1735 itype = TREE_TYPE (idx);
1736 /* We must check here for the reference, so we can do the possible
1737 conversions immediately afterwards. */
1738 if (TREE_CODE (itype) == REFERENCE_TYPE)
1740 idx = convert_from_reference (idx);
1741 itype = TREE_TYPE (idx);
1744 if (IS_AGGR_TYPE (itype))
1746 if (TYPE_HAS_INT_CONVERSION (itype))
1747 idx = build_type_conversion (CONVERT_EXPR,
1748 integer_type_node, idx, 1);
1751 error_with_aggr_type (itype,
1752 "type `%s' requires integer conversion for array indexing");
1753 return error_mark_node;
1757 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1758 && TREE_CODE (array) != INDIRECT_REF)
1762 /* Subscripting with type char is likely to lose
1763 on a machine where chars are signed.
1764 So warn on any machine, but optionally.
1765 Don't warn for unsigned char since that type is safe.
1766 Don't warn for signed char because anyone who uses that
1767 must have done so deliberately. */
1768 if (warn_char_subscripts
1769 && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
1770 warning ("array subscript has type `char'");
1772 /* Apply default promotions *after* noticing character types. */
1773 idx = default_conversion (idx);
1775 if (TREE_CODE (TREE_TYPE (idx)) != INTEGER_TYPE)
1777 error ("array subscript is not an integer");
1778 return error_mark_node;
1781 /* An array that is indexed by a non-constant
1782 cannot be stored in a register; we must be able to do
1783 address arithmetic on its address.
1784 Likewise an array of elements of variable size. */
1785 if (TREE_CODE (idx) != INTEGER_CST
1786 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
1787 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1789 if (mark_addressable (array) == 0)
1790 return error_mark_node;
1792 /* An array that is indexed by a constant value which is not within
1793 the array bounds cannot be stored in a register either; because we
1794 would get a crash in store_bit_field/extract_bit_field when trying
1795 to access a non-existent part of the register. */
1796 if (TREE_CODE (idx) == INTEGER_CST
1797 && TYPE_VALUES (TREE_TYPE (array))
1798 && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
1800 if (mark_addressable (array) == 0)
1801 return error_mark_node;
1804 /* Note in C++ we don't bother warning about subscripting a
1805 `register' array, since it's legal in C++ to take the address
1806 of something with that storage specification. */
1807 if (pedantic && !lvalue_p (array))
1808 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1813 while (TREE_CODE (foo) == COMPONENT_REF)
1814 foo = TREE_OPERAND (foo, 0);
1815 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1816 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1819 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1820 rval = build (ARRAY_REF, type, array, idx);
1821 /* Array ref is const/volatile if the array elements are
1822 or if the array is.. */
1823 TREE_READONLY (rval)
1824 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1825 | TREE_READONLY (array));
1826 TREE_SIDE_EFFECTS (rval)
1827 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1828 | TREE_SIDE_EFFECTS (array));
1829 TREE_THIS_VOLATILE (rval)
1830 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1831 /* This was added by rms on 16 Nov 91.
1832 It fixes vol struct foo *a; a->elts[1]
1833 in an inline function.
1834 Hope it doesn't break something else. */
1835 | TREE_THIS_VOLATILE (array));
1836 return require_complete_type (fold (rval));
1840 tree ar = default_conversion (array);
1841 tree ind = default_conversion (idx);
1843 /* Put the integer in IND to simplify error checking. */
1844 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1851 if (ar == error_mark_node)
1854 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
1856 error ("subscripted value is neither array nor pointer");
1857 return error_mark_node;
1859 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1861 error ("array subscript is not an integer");
1862 return error_mark_node;
1865 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar, ind, PLUS_EXPR),
1870 /* Build a function call to function FUNCTION with parameters PARAMS.
1871 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1872 TREE_VALUE of each node is a parameter-expression.
1873 FUNCTION's data type may be a function type or a pointer-to-function.
1875 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
1876 is the list of possible methods that FUNCTION could conceivably
1877 be. If the list of methods comes from a class, then it will be
1878 a list of lists (where each element is associated with the class
1879 that produced it), otherwise it will be a simple list (for
1880 functions overloaded in global scope).
1882 In the first case, TREE_VALUE (function) is the head of one of those
1883 lists, and TREE_PURPOSE is the name of the function.
1885 In the second case, TREE_PURPOSE (function) is the function's
1888 DECL is the class instance variable, usually CURRENT_CLASS_DECL. */
1891 * [eichin:19911015.1726EST] actually return a possibly incomplete
1895 build_x_function_call (function, params, decl)
1896 tree function, params, decl;
1901 if (function == error_mark_node)
1902 return error_mark_node;
1904 type = TREE_TYPE (function);
1905 is_method = ((TREE_CODE (function) == TREE_LIST
1906 && current_class_type != NULL_TREE
1907 && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function)) == function)
1908 || TREE_CODE (function) == IDENTIFIER_NODE
1909 || TREE_CODE (type) == METHOD_TYPE
1910 || TYPE_PTRMEMFUNC_P (type));
1912 /* Handle methods, friends, and overloaded functions, respectively. */
1915 if (TREE_CODE (function) == FUNCTION_DECL)
1917 if (DECL_NAME (function))
1918 function = DECL_NAME (function);
1920 function = TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function));
1922 else if (TREE_CODE (function) == TREE_LIST)
1925 if (TREE_CODE (TREE_VALUE (function)) == TREE_LIST)
1926 function = TREE_PURPOSE (TREE_VALUE (function));
1928 function = TREE_PURPOSE (function);
1930 my_friendly_assert (TREE_CODE (TREE_VALUE (function)) == FUNCTION_DECL, 312);
1931 function = TREE_PURPOSE (function);
1934 else if (TREE_CODE (function) != IDENTIFIER_NODE)
1936 if (TREE_CODE (function) == OFFSET_REF)
1938 if (TREE_OPERAND (function, 0))
1939 decl = TREE_OPERAND (function, 0);
1941 /* Call via a pointer to member function. */
1942 if (decl == NULL_TREE)
1944 error ("pointer to member function called, but not in class scope");
1945 return error_mark_node;
1947 /* What other type of POINTER_TYPE could this be? */
1948 if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE
1949 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function))
1950 && TREE_CODE (function) != OFFSET_REF)
1951 function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE, function);
1955 /* this is an abbreviated method call.
1956 must go through here in case it is a virtual function.
1957 @@ Perhaps this could be optimized. */
1959 if (decl == NULL_TREE)
1961 if (current_class_type == NULL_TREE)
1963 error ("object missing in call to method `%s'",
1964 IDENTIFIER_POINTER (function));
1965 return error_mark_node;
1967 /* Yow: call from a static member function. */
1968 decl = build1 (NOP_EXPR, TYPE_POINTER_TO (current_class_type),
1970 decl = build_indirect_ref (decl, NULL_PTR);
1973 return build_method_call (decl, function, params,
1974 NULL_TREE, LOOKUP_NORMAL);
1976 else if (TREE_CODE (function) == COMPONENT_REF
1977 && type == unknown_type_node)
1979 /* Should we undo what was done in build_component_ref? */
1980 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function, 1))) == TREE_VEC)
1981 /* Get the name that build_component_ref hid. */
1982 function = DECL_NAME (TREE_VALUE (TREE_OPERAND (function, 1)));
1984 function = TREE_PURPOSE (TREE_OPERAND (function, 1));
1985 return build_method_call (decl, function, params,
1986 NULL_TREE, LOOKUP_NORMAL);
1988 else if (TREE_CODE (function) == TREE_LIST)
1990 if (TREE_VALUE (function) == NULL_TREE)
1992 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
1993 TREE_PURPOSE (function));
1994 return error_mark_node;
1998 tree id = TREE_PURPOSE (function);
1999 function = TREE_VALUE (function);
2001 if (TREE_CODE (function) == TEMPLATE_DECL)
2002 return build_overload_call_maybe
2003 (id, params, LOOKUP_COMPLAIN, (struct candidate *)0);
2004 else if (DECL_CHAIN (function) != NULL_TREE)
2005 return build_overload_call
2006 (id, params, LOOKUP_COMPLAIN, (struct candidate *)0);
2012 if (TREE_CODE (function) == OFFSET_REF)
2014 /* If the component is a data element (or a virtual function), we play
2015 games here to make things work. */
2018 if (TREE_OPERAND (function, 0))
2019 decl = TREE_OPERAND (function, 0);
2023 decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
2024 function = get_member_function_from_ptrfunc (&decl_addr, decl,
2025 TREE_OPERAND (function, 1));
2026 params = tree_cons (NULL_TREE, decl_addr, params);
2027 return build_function_call (function, params);
2030 type = TREE_TYPE (function);
2031 if (type != error_mark_node)
2033 if (TREE_CODE (type) == REFERENCE_TYPE)
2034 type = TREE_TYPE (type);
2036 if (TYPE_LANG_SPECIFIC (type) && TYPE_OVERLOADS_CALL_EXPR (type))
2037 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, function, params, NULL_TREE);
2042 tree fntype = TREE_TYPE (function);
2045 /* Explicitly named method? */
2046 if (TREE_CODE (function) == FUNCTION_DECL)
2047 ctypeptr = TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function));
2048 /* Expression with ptr-to-method type? It could either be a plain
2049 usage, or it might be a case where the ptr-to-method is being
2050 passed in as an argument. */
2051 else if (TYPE_PTRMEMFUNC_P (fntype))
2053 tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype)));
2054 ctypeptr = TYPE_POINTER_TO (rec);
2056 /* Unexpected node type? */
2058 my_friendly_abort (116);
2059 if (decl == NULL_TREE)
2061 if (current_function_decl
2062 && DECL_STATIC_FUNCTION_P (current_function_decl))
2063 error ("invalid call to member function needing `this' in static member function scope");
2065 error ("pointer to member function called, but not in class scope");
2066 return error_mark_node;
2068 if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE
2069 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
2071 decl = build_unary_op (ADDR_EXPR, decl, 0);
2072 decl = convert_pointer_to (TREE_TYPE (ctypeptr), decl);
2075 decl = build_c_cast (ctypeptr, decl);
2076 params = tree_cons (NULL_TREE, decl, params);
2079 return build_function_call (function, params);
2082 /* Resolve a pointer to member function. INSTANCE is the object
2083 instance to use, if the member points to a virtual member. */
2086 get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
2087 tree *instance_ptrptr;
2091 if (TREE_CODE (function) == OFFSET_REF)
2093 function = TREE_OPERAND (function, 1);
2096 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2098 tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2099 tree index = save_expr (convert (integer_type_node,
2100 build_component_ref (function,
2103 tree e1 = build (GT_EXPR, integer_type_node, index, integer_zero_node);
2104 tree delta = build_component_ref (function, delta_identifier, 0, 0);
2105 tree delta2 = DELTA2_FROM_PTRMEMFUNC (function);
2110 /* convert down to the right base, before using the instance. */
2111 instance = convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)),
2112 build_unary_op (ADDR_EXPR, instance, 0));
2113 if (instance == error_mark_node)
2116 vtbl = convert_pointer_to (ptr_type_node, instance);
2119 build_pointer_type (build_pointer_type (vtable_entry_type)),
2120 vtbl, convert (sizetype, delta2));
2121 vtbl = build_indirect_ref (vtbl, NULL_PTR);
2122 aref = build_array_ref (vtbl, size_binop (MINUS_EXPR,
2125 if (! flag_vtable_thunks)
2127 aref = save_expr (aref);
2129 /* Save the intermediate result in a SAVE_EXPR so we don't have to
2130 compute each component of the virtual function pointer twice. */
2131 if (/* !building_cleanup && */ TREE_CODE (aref) == INDIRECT_REF)
2132 TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
2134 delta = build (PLUS_EXPR, integer_type_node,
2135 build_conditional_expr (e1, build_component_ref (aref, delta_identifier, 0, 0), integer_zero_node),
2139 *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (*instance_ptrptr),
2141 convert (integer_type_node, delta));
2142 if (flag_vtable_thunks)
2145 e2 = build_component_ref (aref, pfn_identifier, 0, 0);
2147 e3 = PFN_FROM_PTRMEMFUNC (function);
2148 TREE_TYPE (e2) = TREE_TYPE (e3);
2149 function = build_conditional_expr (e1, e2, e3);
2155 build_function_call_real (function, params, require_complete, flags)
2156 tree function, params;
2157 int require_complete, flags;
2159 register tree fntype, fndecl;
2160 register tree value_type;
2161 register tree coerced_params;
2162 tree name = NULL_TREE, assembler_name = NULL_TREE;
2165 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2166 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2167 if (TREE_CODE (function) == NOP_EXPR
2168 && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2169 function = TREE_OPERAND (function, 0);
2171 if (TREE_CODE (function) == FUNCTION_DECL)
2173 name = DECL_NAME (function);
2174 assembler_name = DECL_ASSEMBLER_NAME (function);
2176 GNU_xref_call (current_function_decl,
2177 IDENTIFIER_POINTER (name ? name
2178 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function))));
2179 assemble_external (function);
2182 /* Convert anything with function type to a pointer-to-function. */
2185 && IDENTIFIER_LENGTH (name) == 4
2186 && ! strcmp (IDENTIFIER_POINTER (name), "main")
2187 && DECL_CONTEXT (function) == NULL_TREE)
2189 pedwarn ("ANSI C++ forbids calling `main' from within program");
2192 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2193 (because calling an inline function does not mean the function
2194 needs to be separately compiled). */
2196 if (DECL_INLINE (function))
2198 fntype = build_type_variant (TREE_TYPE (function),
2199 TREE_READONLY (function),
2200 TREE_THIS_VOLATILE (function));
2201 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
2205 assemble_external (function);
2206 TREE_USED (function) = 1;
2207 function = default_conversion (function);
2214 /* Convert anything with function type to a pointer-to-function. */
2215 if (function == error_mark_node)
2216 return error_mark_node;
2217 function = default_conversion (function);
2220 fntype = TREE_TYPE (function);
2222 if (TYPE_PTRMEMFUNC_P (fntype))
2224 tree instance_ptr = build_unary_op (ADDR_EXPR, C_C_D, 0);
2225 fntype = TYPE_PTRMEMFUNC_FN_TYPE (fntype);
2226 function = get_member_function_from_ptrfunc (&instance_ptr, C_C_D, function);
2229 is_method = (TREE_CODE (fntype) == POINTER_TYPE
2230 && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2232 if (!((TREE_CODE (fntype) == POINTER_TYPE
2233 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2236 error ("called object is not a function");
2237 return error_mark_node;
2240 /* fntype now gets the type of function pointed to. */
2241 fntype = TREE_TYPE (fntype);
2243 /* Convert the parameters to the types declared in the
2244 function prototype, or apply default promotions. */
2246 if (flags & LOOKUP_COMPLAIN)
2247 coerced_params = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
2248 params, fndecl, LOOKUP_NORMAL);
2250 coerced_params = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
2253 /* Check for errors in format strings. */
2255 if (warn_format && (name || assembler_name))
2256 check_function_format (name, assembler_name, coerced_params);
2258 /* Recognize certain built-in functions so we can make tree-codes
2259 other than CALL_EXPR. We do this when it enables fold-const.c
2260 to do something useful. */
2262 if (TREE_CODE (function) == ADDR_EXPR
2263 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2264 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2265 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
2270 if (coerced_params == 0)
2271 return integer_zero_node;
2272 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2276 value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
2278 register tree result =
2279 build (CALL_EXPR, value_type,
2280 function, coerced_params, NULL_TREE);
2282 TREE_SIDE_EFFECTS (result) = 1;
2283 /* Remove this sometime. */
2284 TREE_RAISES (result) |= !! TYPE_RAISES_EXCEPTIONS (fntype);
2285 if (! require_complete)
2287 if (value_type == void_type_node)
2289 return require_complete_type (result);
2294 build_function_call (function, params)
2295 tree function, params;
2297 return build_function_call_real (function, params, 1, LOOKUP_NORMAL);
2301 build_function_call_maybe (function, params)
2302 tree function, params;
2304 return build_function_call_real (function, params, 0, 0);
2308 /* Convert the actual parameter expressions in the list VALUES
2309 to the types in the list TYPELIST.
2310 If parmdecls is exhausted, or when an element has NULL as its type,
2311 perform the default conversions.
2313 RETURN_LOC is the location of the return value, if known, NULL_TREE
2314 otherwise. This is useful in the case where we can avoid creating
2315 a temporary variable in the case where we can initialize the return
2316 value directly. If we are not eliding constructors, then we set this
2317 to NULL_TREE to avoid this avoidance.
2319 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2321 This is also where warnings about wrong number of args are generated.
2323 Return a list of expressions for the parameters as converted.
2325 Both VALUES and the returned value are chains of TREE_LIST nodes
2326 with the elements of the list in the TREE_VALUE slots of those nodes.
2328 In C++, unspecified trailing parameters can be filled in with their
2329 default arguments, if such were specified. Do so here. */
2332 convert_arguments (return_loc, typelist, values, fndecl, flags)
2333 tree return_loc, typelist, values, fndecl;
2336 extern tree gc_protect_fndecl;
2337 register tree typetail, valtail;
2338 register tree result = NULL_TREE;
2340 int maybe_raises = 0;
2343 if (! flag_elide_constructors)
2348 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2350 if (DECL_NAME (fndecl) == NULL_TREE
2351 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2352 called_thing = "constructor";
2354 called_thing = "member function";
2359 called_thing = "function";
2363 for (valtail = values, typetail = typelist;
2365 valtail = TREE_CHAIN (valtail), i++)
2367 register tree type = typetail ? TREE_VALUE (typetail) : 0;
2368 register tree val = TREE_VALUE (valtail);
2370 if (type == void_type_node)
2374 char *buf = (char *)alloca (40 + strlen (called_thing));
2375 sprintf (buf, "too many arguments to %s `%%s'", called_thing);
2376 error_with_decl (fndecl, buf);
2377 error ("at this point in file");
2380 error ("too many arguments to function");
2381 /* In case anybody wants to know if this argument
2384 TREE_TYPE (tree_last (result)) = error_mark_node;
2388 /* The tree type of the parameter being passed may not yet be
2389 known. In this case, its type is TYPE_UNKNOWN, and will
2390 be instantiated by the type given by TYPE. If TYPE
2391 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
2392 if (type && type_unknown_p (val))
2393 val = require_instantiated_type (type, val, integer_zero_node);
2394 else if (type_unknown_p (val))
2396 /* Strip the `&' from an overloaded FUNCTION_DECL. */
2397 if (TREE_CODE (val) == ADDR_EXPR)
2398 val = TREE_OPERAND (val, 0);
2399 if (TREE_CODE (val) == TREE_LIST
2400 && TREE_CHAIN (val) == NULL_TREE
2401 && TREE_TYPE (TREE_VALUE (val)) != NULL_TREE
2402 && (TREE_TYPE (val) == unknown_type_node
2403 || DECL_CHAIN (TREE_VALUE (val)) == NULL_TREE))
2404 /* Instantiates automatically. */
2405 val = TREE_VALUE (val);
2408 error ("insufficient type information in parameter list");
2409 val = integer_zero_node;
2412 else if (TREE_CODE (val) == OFFSET_REF
2413 && TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2415 /* This is unclean. Should be handled elsewhere. */
2416 val = build_unary_op (ADDR_EXPR, val, 0);
2418 else if (TREE_CODE (val) == OFFSET_REF)
2419 val = resolve_offset_ref (val);
2423 /* This code forces the assumption that if we have a ptr-to-func
2424 type in an arglist, that every routine that wants to check
2425 its validity has done so, and thus we need not do any
2426 more conversion. I don't remember why this is necessary. */
2427 else if (TREE_CODE (ttype) == FUNCTION_TYPE
2429 || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
2430 || TREE_CODE (TREE_TYPE (type)) == VOID_TYPE))
2432 type = build_pointer_type (ttype);
2437 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2438 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2439 if (TREE_CODE (val) == NOP_EXPR
2440 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
2441 val = TREE_OPERAND (val, 0);
2443 if ((type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2444 && (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2445 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2446 || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE))
2447 val = default_conversion (val);
2449 val = require_complete_type (val);
2451 if (val == error_mark_node)
2454 maybe_raises |= TREE_RAISES (val);
2458 /* Formal parm type is specified by a function prototype. */
2461 if (TYPE_SIZE (type) == 0)
2463 error ("parameter type of called function is incomplete");
2468 #ifdef PROMOTE_PROTOTYPES
2469 /* Rather than truncating and then reextending,
2470 convert directly to int, if that's the type we will want. */
2471 if (! flag_traditional
2472 && (TREE_CODE (type) == INTEGER_TYPE
2473 || TREE_CODE (type) == ENUMERAL_TYPE)
2474 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2475 type = integer_type_node;
2477 parmval = convert_for_initialization (return_loc, type, val, flags,
2478 "argument passing", fndecl, i);
2479 #ifdef PROMOTE_PROTOTYPES
2480 if ((TREE_CODE (type) == INTEGER_TYPE
2481 || TREE_CODE (type) == ENUMERAL_TYPE)
2482 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2483 parmval = default_conversion (parmval);
2486 result = tree_cons (NULL_TREE, parmval, result);
2490 if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
2491 val = convert_from_reference (val);
2493 if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2494 && (TYPE_PRECISION (TREE_TYPE (val))
2495 < TYPE_PRECISION (double_type_node)))
2496 /* Convert `float' to `double'. */
2497 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2498 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val))
2499 && (TYPE_HAS_INIT_REF (TREE_TYPE (val))
2500 || TYPE_HAS_ASSIGN_REF (TREE_TYPE (val))))
2502 cp_warning ("cannot pass objects of type `%T' through `...'",
2504 result = tree_cons (NULL_TREE, val, result);
2507 /* Convert `short' and `char' to full-size `int'. */
2508 result = tree_cons (NULL_TREE, default_conversion (val), result);
2512 /* There are certain functions for which we don't need
2513 to protect our arguments. GC_PROTECT_FNDECL is one. */
2514 && fndecl != gc_protect_fndecl
2515 && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result)))
2516 && ! value_safe_from_gc (NULL_TREE, TREE_VALUE (result)))
2517 /* This will build a temporary variable whose cleanup is
2518 to clear the obstack entry. */
2519 TREE_VALUE (result) = protect_value_from_gc (NULL_TREE,
2520 TREE_VALUE (result));
2523 typetail = TREE_CHAIN (typetail);
2526 if (typetail != 0 && typetail != void_list_node)
2528 /* See if there are default arguments that can be used */
2529 if (TREE_PURPOSE (typetail))
2531 while (typetail != void_list_node)
2533 tree type = TREE_VALUE (typetail);
2534 tree val = TREE_PURPOSE (typetail);
2537 if (val == NULL_TREE)
2538 parmval = error_mark_node;
2539 else if (TREE_CODE (val) == CONSTRUCTOR)
2541 parmval = digest_init (type, val, (tree *)0);
2542 parmval = convert_for_initialization (return_loc, type, parmval, flags,
2543 "default constructor", fndecl, i);
2547 /* This could get clobbered by the following call. */
2548 if (TREE_HAS_CONSTRUCTOR (val))
2549 val = copy_node (val);
2551 parmval = convert_for_initialization (return_loc, type, val, flags,
2552 "default argument", fndecl, i);
2553 #ifdef PROMOTE_PROTOTYPES
2554 if ((TREE_CODE (type) == INTEGER_TYPE
2555 || TREE_CODE (type) == ENUMERAL_TYPE)
2556 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2557 parmval = default_conversion (parmval);
2560 maybe_raises |= TREE_RAISES (parmval);
2563 && type_needs_gc_entry (TREE_TYPE (parmval))
2564 && ! value_safe_from_gc (NULL_TREE, parmval))
2565 parmval = protect_value_from_gc (NULL_TREE, parmval);
2567 result = tree_cons (0, parmval, result);
2568 typetail = TREE_CHAIN (typetail);
2569 /* ends with `...'. */
2570 if (typetail == NULL_TREE)
2578 char *buf = (char *)alloca (32 + strlen (called_thing));
2579 sprintf (buf, "too few arguments to %s `%%#D'", called_thing);
2580 cp_error_at (buf, fndecl);
2581 error ("at this point in file");
2584 error ("too few arguments to function");
2585 return error_mark_list;
2589 TREE_RAISES (result) = maybe_raises;
2591 return nreverse (result);
2594 /* Build a binary-operation expression, after performing default
2595 conversions on the operands. CODE is the kind of expression to build. */
2598 build_x_binary_op (code, arg1, arg2)
2599 enum tree_code code;
2602 tree rval = build_opfncall (code, LOOKUP_SPECULATIVELY,
2603 arg1, arg2, NULL_TREE);
2605 return build_opfncall (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
2606 if (code == MEMBER_REF)
2607 return build_m_component_ref (build_indirect_ref (arg1, NULL_PTR),
2609 return build_binary_op (code, arg1, arg2, 1);
2613 build_binary_op (code, arg1, arg2, convert_p)
2614 enum tree_code code;
2626 args[0] = default_conversion (args[0]);
2627 args[1] = default_conversion (args[1]);
2629 if (type_unknown_p (args[0]))
2631 args[0] = instantiate_type (TREE_TYPE (args[1]), args[0], 1);
2632 args[0] = default_conversion (args[0]);
2634 else if (type_unknown_p (args[1]))
2636 args[1] = require_instantiated_type (TREE_TYPE (args[0]),
2639 args[1] = default_conversion (args[1]);
2642 type1 = TREE_TYPE (args[0]);
2643 type2 = TREE_TYPE (args[1]);
2645 if (IS_AGGR_TYPE_2 (type1, type2) && ! TYPE_PTRMEMFUNC_P (type1))
2647 /* Try to convert this to something reasonable. */
2648 if (! build_default_binary_type_conversion(code, &args[0], &args[1]))
2649 return error_mark_node;
2651 else if ((IS_AGGR_TYPE (type1) && ! TYPE_PTRMEMFUNC_P (type1))
2652 || (IS_AGGR_TYPE (type2) && ! TYPE_PTRMEMFUNC_P (type2)))
2654 int convert_index = IS_AGGR_TYPE (type2);
2655 /* Avoid being tripped up by things like (ARG1 != 0). */
2658 types[0] = type1; types[1] = type2;
2659 try = build_type_conversion (code, types[convert_index ^ 1],
2660 args[convert_index], 1);
2663 && args[1] == integer_zero_node
2664 && (code == NE_EXPR || code == EQ_EXPR))
2665 try = build_type_conversion (code, ptr_type_node,
2666 args[convert_index], 1);
2669 cp_error ("no match for `%O(%#T, %#T)'", code,
2670 types[convert_index], types[convert_index ^ 1]);
2671 return error_mark_node;
2673 if (try == error_mark_node)
2674 error ("ambiguous pointer conversion");
2675 args[convert_index] = try;
2678 return build_binary_op_nodefault (code, args[0], args[1], code);
2681 /* Build a binary-operation expression without default conversions.
2682 CODE is the kind of expression to build.
2683 This function differs from `build' in several ways:
2684 the data type of the result is computed and recorded in it,
2685 warnings are generated if arg data types are invalid,
2686 special handling for addition and subtraction of pointers is known,
2687 and some optimization is done (operations on narrow ints
2688 are done in the narrower type when that gives the same result).
2689 Constant folding is also done before the result is returned.
2691 ERROR_CODE is the code that determines what to say in error messages.
2692 It is usually, but not always, the same as CODE.
2694 Note that the operands will never have enumeral types
2695 because either they have just had the default conversions performed
2696 or they have both just been converted to some other type in which
2697 the arithmetic is to be done.
2699 C++: must do special pointer arithmetic when implementing
2700 multiple inheritance, and deal with pointer to member functions. */
2703 build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
2704 enum tree_code code;
2705 tree orig_op0, orig_op1;
2706 enum tree_code error_code;
2709 register enum tree_code code0, code1;
2712 /* Expression code to give to the expression when it is built.
2713 Normally this is CODE, which is what the caller asked for,
2714 but in some special cases we change it. */
2715 register enum tree_code resultcode = code;
2717 /* Data type in which the computation is to be performed.
2718 In the simplest cases this is the common type of the arguments. */
2719 register tree result_type = NULL;
2721 /* Nonzero means operands have already been type-converted
2722 in whatever way is necessary.
2723 Zero means they need to be converted to RESULT_TYPE. */
2726 /* Nonzero means after finally constructing the expression
2727 give it this type. Otherwise, give it type RESULT_TYPE. */
2728 tree final_type = 0;
2730 /* Nonzero if this is an operation like MIN or MAX which can
2731 safely be computed in short if both args are promoted shorts.
2732 Also implies COMMON.
2733 -1 indicates a bitwise operation; this makes a difference
2734 in the exact conditions for when it is safe to do the operation
2735 in a narrower mode. */
2738 /* Nonzero if this is a comparison operation;
2739 if both args are promoted shorts, compare the original shorts.
2740 Also implies COMMON. */
2741 int short_compare = 0;
2743 /* Nonzero if this is a right-shift operation, which can be computed on the
2744 original short and then promoted if the operand is a promoted short. */
2745 int short_shift = 0;
2747 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2750 /* Apply default conversions. */
2751 op0 = default_conversion (orig_op0);
2752 op1 = default_conversion (orig_op1);
2754 type0 = TREE_TYPE (op0);
2755 type1 = TREE_TYPE (op1);
2757 /* The expression codes of the data types of the arguments tell us
2758 whether the arguments are integers, floating, pointers, etc. */
2759 code0 = TREE_CODE (type0);
2760 code1 = TREE_CODE (type1);
2762 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2763 STRIP_TYPE_NOPS (op0);
2764 STRIP_TYPE_NOPS (op1);
2766 /* If an error was already reported for one of the arguments,
2767 avoid reporting another error. */
2769 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2770 return error_mark_node;
2775 /* Handle the pointer + int case. */
2776 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2777 return pointer_int_sum (PLUS_EXPR, op0, op1);
2778 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2779 return pointer_int_sum (PLUS_EXPR, op1, op0);
2785 /* Subtraction of two similar pointers.
2786 We must subtract them as integers, then divide by object size. */
2787 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2788 && comp_target_types (type0, type1, 1))
2789 return pointer_diff (op0, op1);
2790 /* Handle pointer minus int. Just like pointer plus int. */
2791 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2792 return pointer_int_sum (MINUS_EXPR, op0, op1);
2801 case TRUNC_DIV_EXPR:
2803 case FLOOR_DIV_EXPR:
2804 case ROUND_DIV_EXPR:
2805 case EXACT_DIV_EXPR:
2806 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2807 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2809 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2810 resultcode = RDIV_EXPR;
2812 /* When dividing two signed integers, we have to promote to int.
2813 unless we divide by a conatant != -1. Note that default
2814 conversion will have been performed on the operands at this
2815 point, so we have to dig out the original type to find out if
2817 shorten = ((TREE_CODE (op0) == NOP_EXPR
2818 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2819 || (TREE_CODE (op1) == INTEGER_CST
2820 && (TREE_INT_CST_LOW (op1) != -1
2821 || TREE_INT_CST_HIGH (op1) != -1)));
2827 case BIT_ANDTC_EXPR:
2830 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2832 /* If one operand is a constant, and the other is a short type
2833 that has been converted to an int,
2834 really do the work in the short type and then convert the
2835 result to int. If we are lucky, the constant will be 0 or 1
2836 in the short type, making the entire operation go away. */
2837 if (TREE_CODE (op0) == INTEGER_CST
2838 && TREE_CODE (op1) == NOP_EXPR
2839 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2840 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2842 final_type = result_type;
2843 op1 = TREE_OPERAND (op1, 0);
2844 result_type = TREE_TYPE (op1);
2846 if (TREE_CODE (op1) == INTEGER_CST
2847 && TREE_CODE (op0) == NOP_EXPR
2848 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2849 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2851 final_type = result_type;
2852 op0 = TREE_OPERAND (op0, 0);
2853 result_type = TREE_TYPE (op0);
2857 case TRUNC_MOD_EXPR:
2858 case FLOOR_MOD_EXPR:
2859 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2861 /* Although it would be tempting to shorten always here, that loses
2862 on some targets, since the modulo instruction is undefined if the
2863 quotient can't be represented in the computation mode. We shorten
2864 only if unsigned or if dividing by something we know != -1. */
2865 shorten = ((TREE_CODE (op0) == NOP_EXPR
2866 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2867 || (TREE_CODE (op1) == INTEGER_CST
2868 && (TREE_INT_CST_LOW (op1) != -1
2869 || TREE_INT_CST_HIGH (op1) != -1)));
2874 case TRUTH_ANDIF_EXPR:
2875 case TRUTH_ORIF_EXPR:
2876 case TRUTH_AND_EXPR:
2878 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE || code0 == REAL_TYPE)
2879 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE || code1 == REAL_TYPE))
2881 /* Result of these operations is always an int,
2882 but that does not mean the operands should be
2883 converted to ints! */
2884 result_type = integer_type_node;
2885 op0 = truthvalue_conversion (op0);
2886 op1 = truthvalue_conversion (op1);
2891 /* Shift operations: result has same type as first operand;
2892 always convert second operand to int.
2893 Also set SHORT_SHIFT if shifting rightward. */
2896 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2898 result_type = type0;
2899 if (TREE_CODE (op1) == INTEGER_CST)
2901 if (tree_int_cst_lt (op1, integer_zero_node))
2902 warning ("right shift count is negative");
2905 if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
2907 if (TREE_INT_CST_HIGH (op1) != 0
2908 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2909 >= TYPE_PRECISION (type0)))
2910 warning ("right shift count >= width of type");
2913 /* Convert the shift-count to an integer, regardless of
2914 size of value being shifted. */
2915 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2916 op1 = convert (integer_type_node, op1);
2917 /* Avoid converting op1 to result_type later. */
2923 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2925 result_type = type0;
2926 if (TREE_CODE (op1) == INTEGER_CST)
2928 if (tree_int_cst_lt (op1, integer_zero_node))
2929 warning ("left shift count is negative");
2930 else if (TREE_INT_CST_HIGH (op1) != 0
2931 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2932 >= TYPE_PRECISION (type0)))
2933 warning ("left shift count >= width of type");
2935 /* Convert the shift-count to an integer, regardless of
2936 size of value being shifted. */
2937 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2938 op1 = convert (integer_type_node, op1);
2939 /* Avoid converting op1 to result_type later. */
2946 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2948 result_type = type0;
2949 if (TREE_CODE (op1) == INTEGER_CST)
2951 if (tree_int_cst_lt (op1, integer_zero_node))
2952 warning ("%s rotate count is negative",
2953 (code == LROTATE_EXPR) ? "left" : "right");
2954 else if (TREE_INT_CST_HIGH (op1) != 0
2955 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2956 >= TYPE_PRECISION (type0)))
2957 warning ("%s rotate count >= width of type",
2958 (code == LROTATE_EXPR) ? "left" : "right");
2960 /* Convert the shift-count to an integer, regardless of
2961 size of value being shifted. */
2962 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2963 op1 = convert (integer_type_node, op1);
2969 /* Result of comparison is always int,
2970 but don't convert the args to int! */
2971 result_type = integer_type_node;
2973 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2974 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2976 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2978 register tree tt0 = TYPE_MAIN_VARIANT (TREE_TYPE (type0));
2979 register tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (type1));
2980 /* Anything compares with void *. void * compares with anything.
2981 Otherwise, the targets must be the same. */
2982 if (tt0 != tt1 && TREE_CODE (tt0) == RECORD_TYPE
2983 && TREE_CODE (tt1) == RECORD_TYPE)
2985 tree base = common_base_type (tt0, tt1);
2986 if (base == NULL_TREE)
2987 warning ("comparison of distinct object pointer types");
2988 else if (base == error_mark_node)
2990 message_2_types (error, "comparison of pointer types `%s*' and `%s*' requires conversion to ambiguous supertype", tt0, tt1);
2991 return error_mark_node;
2995 if (integer_zerop (op0))
2996 op0 = null_pointer_node;
2998 op0 = convert_pointer_to (base, op0);
2999 if (integer_zerop (op1))
3000 op1 = null_pointer_node;
3002 op1 = convert_pointer_to (base, op1);
3005 else if (comp_target_types (type0, type1, 1))
3007 else if (tt0 == void_type_node)
3009 if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
3010 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3012 else if (tt1 == void_type_node)
3014 if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
3015 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3017 else if ((TYPE_SIZE (tt0) != 0) != (TYPE_SIZE (tt1) != 0))
3018 pedwarn ("comparison of complete and incomplete pointers");
3020 pedwarn ("comparison of distinct pointer types lacks a cast");
3022 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3023 && integer_zerop (op1))
3024 op1 = null_pointer_node;
3025 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3026 && integer_zerop (op0))
3027 op0 = null_pointer_node;
3028 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3030 error ("ANSI C++ forbids comparison between pointer and integer");
3031 op1 = convert (TREE_TYPE (op0), op1);
3033 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3035 error ("ANSI C++ forbids comparison between pointer and integer");
3036 op0 = convert (TREE_TYPE (op1), op0);
3038 else if (TYPE_PTRMEMFUNC_P (type0) && TREE_CODE (op1) == INTEGER_CST
3039 && integer_zerop (op1))
3041 op0 = build_component_ref (op0, index_identifier, 0, 0);
3042 op1 = integer_zero_node;
3044 else if (TYPE_PTRMEMFUNC_P (type1) && TREE_CODE (op0) == INTEGER_CST
3045 && integer_zerop (op0))
3047 op0 = build_component_ref (op1, index_identifier, 0, 0);
3048 op1 = integer_zero_node;
3050 else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3051 && (TYPE_PTRMEMFUNC_FN_TYPE (type0)
3052 == TYPE_PTRMEMFUNC_FN_TYPE (type1)))
3054 /* The code we generate for the test is:
3056 (op0.index == op1.index
3057 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3058 || op0.pfn == op1.pfn)) */
3060 tree index0 = build_component_ref (op0, index_identifier, 0, 0);
3061 tree index1 = save_expr (build_component_ref (op1, index_identifier, 0, 0));
3062 tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
3063 tree pfn1 = PFN_FROM_PTRMEMFUNC (op1);
3064 tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
3065 tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1);
3067 tree integer_neg_one_node
3068 = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
3069 e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
3070 e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
3071 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
3072 e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1);
3073 e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
3074 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
3075 if (code == EQ_EXPR)
3077 return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
3079 else if (TYPE_PTRMEMFUNC_P (type0)
3080 && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1)
3082 tree index0 = build_component_ref (op0, index_identifier, 0, 0);
3084 tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
3085 tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
3086 tree delta21 = integer_zero_node;
3088 tree integer_neg_one_node
3089 = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
3090 if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL
3091 && DECL_VINDEX (TREE_OPERAND (op1, 0)))
3093 /* Map everything down one to make room for the null pointer to member. */
3094 index1 = size_binop (PLUS_EXPR,
3095 DECL_VINDEX (TREE_OPERAND (op1, 0)),
3097 op1 = integer_zero_node;
3098 delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1)));
3099 delta21 = DECL_FIELD_BITPOS (delta21);
3100 delta21 = size_binop (FLOOR_DIV_EXPR, delta21, size_int (BITS_PER_UNIT));
3103 index1 = integer_neg_one_node;
3105 tree nop1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0), op1);
3106 TREE_CONSTANT (nop1) = TREE_CONSTANT (op1);
3109 e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
3110 e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
3111 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
3112 e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1);
3113 e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
3114 e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
3115 if (code == EQ_EXPR)
3117 return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
3119 else if (TYPE_PTRMEMFUNC_P (type1)
3120 && TYPE_PTRMEMFUNC_FN_TYPE (type1) == type0)
3122 return build_binary_op (code, op1, op0, 1);
3125 /* If args are not valid, clear out RESULT_TYPE
3126 to cause an error message later. */
3132 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3133 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3135 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3137 if (! comp_target_types (type0, type1, 1))
3138 pedwarn ("comparison of distinct pointer types lacks a cast");
3139 else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
3140 != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
3141 pedwarn ("comparison of complete and incomplete pointers");
3143 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
3144 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3145 result_type = common_type (type0, type1);
3153 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3154 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3156 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3158 if (! comp_target_types (type0, type1, 1))
3159 pedwarn ("comparison of distinct pointer types lacks a cast");
3160 else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
3161 != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
3162 pedwarn ("comparison of complete and incomplete pointers");
3164 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
3165 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3166 result_type = integer_type_node;
3168 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3169 && integer_zerop (op1))
3171 result_type = integer_type_node;
3172 op1 = null_pointer_node;
3174 pedwarn ("ordered comparison of pointer with integer zero");
3176 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3177 && integer_zerop (op0))
3179 result_type = integer_type_node;
3180 op0 = null_pointer_node;
3182 pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
3184 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3186 result_type = integer_type_node;
3188 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3189 else if (! flag_traditional)
3190 warning ("comparison between pointer and integer");
3191 op1 = convert (TREE_TYPE (op0), op1);
3193 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3195 result_type = integer_type_node;
3197 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3198 else if (! flag_traditional)
3199 warning ("comparison between pointer and integer");
3200 op0 = convert (TREE_TYPE (op1), op0);
3206 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3207 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3209 if (shorten || common || short_compare)
3210 result_type = common_type (type0, type1);
3212 /* For certain operations (which identify themselves by shorten != 0)
3213 if both args were extended from the same smaller type,
3214 do the arithmetic in that type and then extend.
3216 shorten !=0 and !=1 indicates a bitwise operation.
3217 For them, this optimization is safe only if
3218 both args are zero-extended or both are sign-extended.
3219 Otherwise, we might change the result.
3220 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3221 but calculated in (unsigned short) it would be (unsigned short)-1. */
3225 int unsigned0, unsigned1;
3226 tree arg0 = get_narrower (op0, &unsigned0);
3227 tree arg1 = get_narrower (op1, &unsigned1);
3228 /* UNS is 1 if the operation to be done is an unsigned one. */
3229 int uns = TREE_UNSIGNED (result_type);
3232 final_type = result_type;
3234 /* Handle the case that OP0 does not *contain* a conversion
3235 but it *requires* conversion to FINAL_TYPE. */
3237 if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3238 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3239 if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3240 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3242 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3244 /* For bitwise operations, signedness of nominal type
3245 does not matter. Consider only how operands were extended. */
3249 /* Note that in all three cases below we refrain from optimizing
3250 an unsigned operation on sign-extended args.
3251 That would not be valid. */
3253 /* Both args variable: if both extended in same way
3254 from same width, do it in that width.
3255 Do it unsigned if args were zero-extended. */
3256 if ((TYPE_PRECISION (TREE_TYPE (arg0))
3257 < TYPE_PRECISION (result_type))
3258 && (TYPE_PRECISION (TREE_TYPE (arg1))
3259 == TYPE_PRECISION (TREE_TYPE (arg0)))
3260 && unsigned0 == unsigned1
3261 && (unsigned0 || !uns))
3263 = signed_or_unsigned_type (unsigned0,
3264 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3265 else if (TREE_CODE (arg0) == INTEGER_CST
3266 && (unsigned1 || !uns)
3267 && (TYPE_PRECISION (TREE_TYPE (arg1))
3268 < TYPE_PRECISION (result_type))
3269 && (type = signed_or_unsigned_type (unsigned1,
3271 int_fits_type_p (arg0, type)))
3273 else if (TREE_CODE (arg1) == INTEGER_CST
3274 && (unsigned0 || !uns)
3275 && (TYPE_PRECISION (TREE_TYPE (arg0))
3276 < TYPE_PRECISION (result_type))
3277 && (type = signed_or_unsigned_type (unsigned0,
3279 int_fits_type_p (arg1, type)))
3283 /* Shifts can be shortened if shifting right. */
3288 tree arg0 = get_narrower (op0, &unsigned_arg);
3290 final_type = result_type;
3292 if (arg0 == op0 && final_type == TREE_TYPE (op0))
3293 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3295 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3296 /* If arg is sign-extended and then unsigned-shifted,
3297 we can simulate this with a signed shift in arg's type
3298 only if the extended result is at least twice as wide
3299 as the arg. Otherwise, the shift could use up all the
3300 ones made by sign-extension and bring in zeros.
3301 We can't optimize that case at all, but in most machines
3302 it never happens because available widths are 2**N. */
3303 && (!TREE_UNSIGNED (final_type)
3305 || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0))
3306 <= TYPE_PRECISION (result_type))))
3308 /* Do an unsigned shift if the operand was zero-extended. */
3310 = signed_or_unsigned_type (unsigned_arg,
3312 /* Convert value-to-be-shifted to that type. */
3313 if (TREE_TYPE (op0) != result_type)
3314 op0 = convert (result_type, op0);
3319 /* Comparison operations are shortened too but differently.
3320 They identify themselves by setting short_compare = 1. */
3324 /* Don't write &op0, etc., because that would prevent op0
3325 from being kept in a register.
3326 Instead, make copies of the our local variables and
3327 pass the copies by reference, then copy them back afterward. */
3328 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3329 enum tree_code xresultcode = resultcode;
3331 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3334 op0 = xop0, op1 = xop1, result_type = xresult_type;
3335 resultcode = xresultcode;
3338 if (short_compare && extra_warnings)
3340 int unsignedp0, unsignedp1;
3341 tree primop0 = get_narrower (op0, &unsignedp0);
3342 tree primop1 = get_narrower (op1, &unsignedp1);
3344 /* Warn if signed and unsigned are being compared in a size larger
3345 than their original size, as this will always fail. */
3347 if (unsignedp0 != unsignedp1
3348 && (TYPE_PRECISION (TREE_TYPE (primop0))
3349 < TYPE_PRECISION (result_type))
3350 && (TYPE_PRECISION (TREE_TYPE (primop1))
3351 < TYPE_PRECISION (result_type)))
3352 warning ("comparison between promoted unsigned and signed");
3354 /* Warn if two unsigned values are being compared in a size
3355 larger than their original size, and one (and only one) is the
3356 result of a `~' operator. This comparison will always fail.
3358 Also warn if one operand is a constant, and the constant does not
3359 have all bits set that are set in the ~ operand when it is
3362 else if (TREE_CODE (primop0) == BIT_NOT_EXPR
3363 ^ TREE_CODE (primop1) == BIT_NOT_EXPR)
3365 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3366 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3367 if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3368 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3370 if (TREE_CODE (primop0) == INTEGER_CST
3371 || TREE_CODE (primop1) == INTEGER_CST)
3374 HOST_WIDE_INT constant, mask;
3378 if (TREE_CODE (primop0) == INTEGER_CST)
3381 unsignedp = unsignedp1;
3382 constant = TREE_INT_CST_LOW (primop0);
3387 unsignedp = unsignedp0;
3388 constant = TREE_INT_CST_LOW (primop1);
3391 bits = TYPE_PRECISION (TREE_TYPE (primop));
3392 if (bits < TYPE_PRECISION (result_type)
3393 && bits < HOST_BITS_PER_LONG && unsignedp)
3395 mask = (~ (HOST_WIDE_INT) 0) << bits;
3396 if ((mask & constant) != mask)
3397 warning ("comparison of promoted ~unsigned with constant");
3400 else if (unsignedp0 && unsignedp1
3401 && (TYPE_PRECISION (TREE_TYPE (primop0))
3402 < TYPE_PRECISION (result_type))
3403 && (TYPE_PRECISION (TREE_TYPE (primop1))
3404 < TYPE_PRECISION (result_type)))
3405 warning ("comparison of promoted ~unsigned with unsigned");
3410 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3411 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3412 Then the expression will be built.
3413 It will be given type FINAL_TYPE if that is nonzero;
3414 otherwise, it will be given type RESULT_TYPE. */
3418 binary_op_error (error_code);
3419 return error_mark_node;
3424 if (TREE_TYPE (op0) != result_type)
3425 op0 = convert (result_type, op0);
3426 if (TREE_TYPE (op1) != result_type)
3427 op1 = convert (result_type, op1);
3431 register tree result = build (resultcode, result_type, op0, op1);
3432 register tree folded;
3434 folded = fold (result);
3435 if (folded == result)
3436 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3437 if (final_type != 0)
3438 return convert (final_type, folded);
3443 /* Return a tree for the sum or difference (RESULTCODE says which)
3444 of pointer PTROP and integer INTOP. */
3447 pointer_int_sum (resultcode, ptrop, intop)
3448 enum tree_code resultcode;
3449 register tree ptrop, intop;
3453 register tree result;
3454 register tree folded = fold (intop);
3456 /* The result is a pointer of the same type that is being added. */
3458 register tree result_type = TREE_TYPE (ptrop);
3460 /* Needed to make OOPS V2R3 work. */
3462 if (TREE_CODE (intop) == INTEGER_CST
3463 && TREE_INT_CST_LOW (intop) == 0
3464 && TREE_INT_CST_HIGH (intop) == 0)
3467 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3469 if (pedantic || warn_pointer_arith)
3470 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3471 size_exp = integer_one_node;
3473 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3475 if (pedantic || warn_pointer_arith)
3476 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3477 size_exp = integer_one_node;
3479 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3481 if (pedantic || warn_pointer_arith)
3482 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
3483 size_exp = integer_one_node;
3485 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
3488 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
3489 size_exp = integer_one_node;
3492 size_exp = size_in_bytes (TREE_TYPE (result_type));
3494 /* If what we are about to multiply by the size of the elements
3495 contains a constant term, apply distributive law
3496 and multiply that constant term separately.
3497 This helps produce common subexpressions. */
3499 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3500 && ! TREE_CONSTANT (intop)
3501 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3502 && TREE_CONSTANT (size_exp))
3504 enum tree_code subcode = resultcode;
3505 if (TREE_CODE (intop) == MINUS_EXPR)
3506 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3507 ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1), 1);
3508 intop = TREE_OPERAND (intop, 0);
3511 /* Convert the integer argument to a type the same size as a pointer
3512 so the multiply won't overflow spuriously. */
3514 if (TYPE_PRECISION (TREE_TYPE (intop)) != POINTER_SIZE)
3515 intop = convert (type_for_size (POINTER_SIZE, 0), intop);
3517 /* Replace the integer argument with a suitable product by the object size.
3518 Do this multiplication as signed, then convert to the appropriate
3519 pointer type (actually unsigned integral). */
3521 intop = convert (result_type,
3522 build_binary_op (MULT_EXPR, intop,
3523 convert (TREE_TYPE (intop), size_exp), 1));
3525 /* Create the sum or difference. */
3527 result = build (resultcode, result_type, ptrop, intop);
3529 folded = fold (result);
3530 if (folded == result)
3531 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
3535 /* Return a tree for the difference of pointers OP0 and OP1.
3536 The resulting tree has type int. */
3539 pointer_diff (op0, op1)
3540 register tree op0, op1;
3542 register tree result, folded;
3543 tree restype = ptrdiff_type_node;
3544 tree target_type = TREE_TYPE (TREE_TYPE (op0));
3548 if (TREE_CODE (target_type) == VOID_TYPE)
3549 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
3550 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3551 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
3552 if (TREE_CODE (target_type) == METHOD_TYPE)
3553 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
3554 if (TREE_CODE (target_type) == OFFSET_TYPE)
3555 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
3558 /* First do the subtraction as integers;
3559 then drop through to build the divide operator. */
3561 op0 = build_binary_op (MINUS_EXPR,
3562 convert (restype, op0), convert (restype, op1), 1);
3564 /* This generates an error if op1 is a pointer to an incomplete type. */
3565 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
3566 error ("arithmetic on pointer to an incomplete type");
3568 op1 = ((TREE_CODE (target_type) == VOID_TYPE
3569 || TREE_CODE (target_type) == FUNCTION_TYPE
3570 || TREE_CODE (target_type) == METHOD_TYPE
3571 || TREE_CODE (target_type) == OFFSET_TYPE)
3573 : size_in_bytes (target_type));
3575 /* Do the division. */
3577 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
3579 folded = fold (result);
3580 if (folded == result)
3581 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3585 /* Handle the case of taking the address of a COMPONENT_REF.
3586 Called by `build_unary_op' and `build_up_reference'.
3588 ARG is the COMPONENT_REF whose address we want.
3589 ARGTYPE is the pointer type that this address should have.
3590 MSG is an error message to print if this COMPONENT_REF is not
3591 addressable (such as a bitfield). */
3594 build_component_addr (arg, argtype, msg)
3598 tree field = TREE_OPERAND (arg, 1);
3599 tree basetype = decl_type_context (field);
3600 tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3602 if (DECL_BIT_FIELD (field))
3604 error (msg, IDENTIFIER_POINTER (DECL_NAME (field)));
3605 return error_mark_node;
3609 cp_warning ("address of `%T::%D' taken", basetype, field);
3611 if (TREE_CODE (field) == FIELD_DECL
3612 && TYPE_USES_COMPLEX_INHERITANCE (basetype))
3614 /* Can't convert directly to ARGTYPE, since that
3615 may have the same pointer type as one of our
3617 rval = build1 (NOP_EXPR, argtype,
3618 convert_pointer_to (basetype, rval));
3619 TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
3622 /* This conversion is harmless. */
3623 rval = convert (argtype, rval);
3625 if (! integer_zerop (DECL_FIELD_BITPOS (field)))
3627 tree offset = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
3628 size_int (BITS_PER_UNIT));
3629 int flag = TREE_CONSTANT (rval);
3630 rval = fold (build (PLUS_EXPR, argtype,
3631 rval, convert (argtype, offset)));
3632 TREE_CONSTANT (rval) = flag;
3637 /* Construct and perhaps optimize a tree representation
3638 for a unary operation. CODE, a tree_code, specifies the operation
3639 and XARG is the operand. */
3642 build_x_unary_op (code, xarg)
3643 enum tree_code code;
3646 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3648 if (code != ADDR_EXPR || TREE_CODE (TREE_TYPE (xarg)) != RECORD_TYPE
3649 || TYPE_SIZE (TREE_TYPE (xarg)))
3651 tree rval = build_opfncall (code, LOOKUP_SPECULATIVELY, xarg,
3652 NULL_TREE, NULL_TREE);
3654 return build_opfncall (code, LOOKUP_NORMAL, xarg,
3655 NULL_TREE, NULL_TREE);
3657 return build_unary_op (code, xarg, 0);
3660 /* C++: Must handle pointers to members.
3662 Perhaps type instantiation should be extended to handle conversion
3663 from aggregates to types we don't yet know we want? (Or are those
3664 cases typically errors which should be reported?)
3666 NOCONVERT nonzero suppresses the default promotions
3667 (such as from short to int). */
3669 build_unary_op (code, xarg, noconvert)
3670 enum tree_code code;
3674 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3675 register tree arg = xarg;
3676 register tree argtype = 0;
3677 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
3678 char *errstring = NULL;
3682 if (typecode == ERROR_MARK)
3683 return error_mark_node;
3685 if (typecode == REFERENCE_TYPE && code != ADDR_EXPR && ! noconvert)
3687 arg = convert_from_reference (arg);
3688 typecode = TREE_CODE (TREE_TYPE (arg));
3691 if (typecode == ENUMERAL_TYPE)
3692 typecode = INTEGER_TYPE;
3694 isaggrtype = IS_AGGR_TYPE_CODE (typecode);
3699 /* This is used for unary plus, because a CONVERT_EXPR
3700 is enough to prevent anybody from looking inside for
3701 associativity, but won't generate any code. */
3702 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3703 errstring = "wrong type argument to unary plus";
3704 else if (!noconvert)
3705 arg = default_conversion (arg);
3712 arg = default_conversion (arg);
3715 cp_error ("type conversion for type `%T' not allowed",
3717 return error_mark_node;
3719 typecode = TREE_CODE (TREE_TYPE (arg));
3723 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3724 errstring = "wrong type argument to unary minus";
3725 else if (!noconvert)
3726 arg = default_conversion (arg);
3733 arg = default_conversion (arg);
3736 cp_error ("type conversion for type `%T' not allowed",
3738 return error_mark_node;
3740 typecode = TREE_CODE (TREE_TYPE (arg));
3744 if (typecode != INTEGER_TYPE)
3745 errstring = "wrong type argument to bit-complement";
3746 else if (!noconvert)
3747 arg = default_conversion (arg);
3754 arg = default_conversion (arg);
3757 cp_error ("type conversion for type `%T' not allowed",
3759 return error_mark_node;
3761 typecode = TREE_CODE (TREE_TYPE (arg));
3765 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3766 errstring = "wrong type argument to abs";
3767 else if (!noconvert)
3768 arg = default_conversion (arg);
3771 case TRUTH_NOT_EXPR:
3774 arg = truthvalue_conversion (arg);
3775 typecode = TREE_CODE (TREE_TYPE (arg));
3778 if (typecode != INTEGER_TYPE
3779 && typecode != REAL_TYPE && typecode != POINTER_TYPE
3780 /* These will convert to a pointer. */
3781 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
3783 errstring = "wrong type argument to unary exclamation mark";
3786 arg = truthvalue_conversion (arg);
3787 val = invert_truthvalue (arg);
3788 if (val) return val;
3794 case PREINCREMENT_EXPR:
3795 case POSTINCREMENT_EXPR:
3796 case PREDECREMENT_EXPR:
3797 case POSTDECREMENT_EXPR:
3798 /* Handle complex lvalues (when permitted)
3799 by reduction to simpler cases. */
3801 val = unary_complex_lvalue (code, arg);
3805 /* Report invalid types. */
3809 arg = default_conversion (arg);
3810 typecode = TREE_CODE (TREE_TYPE (arg));
3813 if (typecode != POINTER_TYPE
3814 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
3816 if (code == PREINCREMENT_EXPR)
3817 errstring ="no pre-increment operator for type";
3818 else if (code == POSTINCREMENT_EXPR)
3819 errstring ="no post-increment operator for type";
3820 else if (code == PREDECREMENT_EXPR)
3821 errstring ="no pre-decrement operator for type";
3823 errstring ="no post-decrement operator for type";
3827 /* Report something read-only. */
3829 if (TYPE_READONLY (TREE_TYPE (arg))
3830 || TREE_READONLY (arg))
3831 readonly_error (arg, ((code == PREINCREMENT_EXPR
3832 || code == POSTINCREMENT_EXPR)
3833 ? "increment" : "decrement"),
3838 tree result_type = TREE_TYPE (arg);
3840 arg = get_unwidened (arg, 0);
3841 argtype = TREE_TYPE (arg);
3843 /* ARM $5.2.5 last annotation says this should be forbidden. */
3844 if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3845 pedwarn ("ANSI C++ forbids %sing an enum",
3846 (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3847 ? "increment" : "decrement");
3849 /* Compute the increment. */
3851 if (typecode == POINTER_TYPE)
3853 enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
3854 if (TYPE_SIZE (TREE_TYPE (argtype)) == 0)
3855 cp_error ("cannot %s a pointer to incomplete type `%T'",
3856 ((code == PREINCREMENT_EXPR
3857 || code == POSTINCREMENT_EXPR)
3858 ? "increment" : "decrement"), TREE_TYPE (argtype));
3859 else if (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
3860 || tmp == VOID_TYPE || tmp == OFFSET_TYPE)
3861 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
3862 ((code == PREINCREMENT_EXPR
3863 || code == POSTINCREMENT_EXPR)
3864 ? "increment" : "decrement"), argtype);
3865 inc = c_sizeof_nowarn (TREE_TYPE (argtype));
3868 inc = integer_one_node;
3870 inc = convert (argtype, inc);
3872 /* Handle incrementing a cast-expression. */
3874 switch (TREE_CODE (arg))
3879 case FIX_TRUNC_EXPR:
3880 case FIX_FLOOR_EXPR:
3881 case FIX_ROUND_EXPR:
3884 tree incremented, modify, value;
3885 pedantic_lvalue_warning (CONVERT_EXPR);
3886 arg = stabilize_reference (arg);
3887 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3890 value = save_expr (arg);
3891 incremented = build (((code == PREINCREMENT_EXPR
3892 || code == POSTINCREMENT_EXPR)
3893 ? PLUS_EXPR : MINUS_EXPR),
3894 argtype, value, inc);
3895 TREE_SIDE_EFFECTS (incremented) = 1;
3896 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3897 return build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3901 if (TREE_CODE (arg) == OFFSET_REF)
3902 arg = resolve_offset_ref (arg);
3904 /* Complain about anything else that is not a true lvalue. */
3905 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3906 || code == POSTINCREMENT_EXPR)
3907 ? "increment" : "decrement")))
3908 return error_mark_node;
3910 val = build (code, TREE_TYPE (arg), arg, inc);
3911 TREE_SIDE_EFFECTS (val) = 1;
3912 return convert (result_type, val);
3916 /* Note that this operation never does default_conversion
3917 regardless of NOCONVERT. */
3919 if (typecode == REFERENCE_TYPE)
3921 arg = build1 (CONVERT_EXPR, build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
3922 TREE_REFERENCE_EXPR (arg) = 1;
3925 else if (TREE_CODE (arg) == FUNCTION_DECL
3927 && DECL_CONTEXT (arg) == NULL_TREE
3928 && IDENTIFIER_LENGTH (DECL_NAME (arg)) == 4
3929 && IDENTIFIER_POINTER (DECL_NAME (arg))[0] == 'm'
3930 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg)), "main"))
3933 error ("attempt to take address of function `main'");
3934 return error_mark_node;
3937 /* Let &* cancel out to simplify resulting code. */
3938 if (TREE_CODE (arg) == INDIRECT_REF)
3940 /* We don't need to have `current_class_decl' wrapped in a
3941 NON_LVALUE_EXPR node. */
3943 return current_class_decl;
3945 /* Keep `default_conversion' from converting if
3946 ARG is of REFERENCE_TYPE. */
3947 arg = TREE_OPERAND (arg, 0);
3948 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3950 if (TREE_CODE (arg) == VAR_DECL && DECL_INITIAL (arg)
3951 && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg)))
3952 arg = DECL_INITIAL (arg);
3953 arg = build1 (CONVERT_EXPR, build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
3954 TREE_REFERENCE_EXPR (arg) = 1;
3955 TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3957 else if (lvalue_p (arg))
3958 /* Don't let this be an lvalue. */
3959 return non_lvalue (arg);
3963 /* For &x[y], return x+y */
3964 if (TREE_CODE (arg) == ARRAY_REF)
3966 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3967 return error_mark_node;
3968 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3969 TREE_OPERAND (arg, 1), 1);
3972 /* For &(++foo), we are really taking the address of the variable
3973 being acted upon by the increment/decrement operator. ARM $5.3.1
3974 However, according to ARM $5.2.5, we don't allow postfix ++ and
3975 --, since the prefix operators return lvalues, but the postfix
3976 operators do not. */
3977 if (TREE_CODE (arg) == PREINCREMENT_EXPR
3978 || TREE_CODE (arg) == PREDECREMENT_EXPR)
3979 arg = TREE_OPERAND (arg, 0);
3981 /* Uninstantiated types are all functions. Taking the
3982 address of a function is a no-op, so just return the
3985 if (TREE_CODE (arg) == IDENTIFIER_NODE
3986 && IDENTIFIER_OPNAME_P (arg))
3988 my_friendly_abort (117);
3989 /* We don't know the type yet, so just work around the problem.
3990 We know that this will resolve to an lvalue. */
3991 return build1 (ADDR_EXPR, unknown_type_node, arg);
3994 if (TREE_CODE (arg) == TREE_LIST)
3996 /* Look at methods with only this name. */
3997 if (TREE_CODE (TREE_VALUE (arg)) == FUNCTION_DECL)
3999 tree targ = TREE_VALUE (arg);
4001 /* If this function is unique, or it is a unique
4002 constructor, we can take its address easily. */
4003 if (DECL_CHAIN (targ) == NULL_TREE
4004 || (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (targ))
4005 && DECL_CHAIN (DECL_CHAIN (targ)) == NULL_TREE))
4007 if (DECL_CHAIN (targ))
4008 targ = DECL_CHAIN (targ);
4009 if (DECL_CLASS_CONTEXT (targ))
4010 targ = build (OFFSET_REF, TREE_TYPE (targ), C_C_D, targ);
4012 val = unary_complex_lvalue (ADDR_EXPR, targ);
4017 /* This possible setting of TREE_CONSTANT is what makes it possible
4018 with an initializer list to emit the entire thing in the data
4019 section, rather than a run-time initialization. */
4020 arg = build1 (ADDR_EXPR, unknown_type_node, arg);
4022 TREE_CONSTANT (arg) = 1;
4025 if (TREE_CHAIN (arg) == NULL_TREE
4026 && TREE_CODE (TREE_VALUE (arg)) == TREE_LIST
4027 && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg))) == NULL_TREE)
4029 /* Unique overloaded member function. */
4030 return build_unary_op (ADDR_EXPR, TREE_VALUE (TREE_VALUE (arg)), 0);
4032 return build1 (ADDR_EXPR, unknown_type_node, arg);
4035 /* Handle complex lvalues (when permitted)
4036 by reduction to simpler cases. */
4037 val = unary_complex_lvalue (code, arg);
4041 #if 0 /* Turned off because inconsistent;
4042 float f; *&(int)f = 3.4 stores in int format
4043 whereas (int)f = 3.4 stores in float format. */
4044 /* Address of a cast is just a cast of the address
4045 of the operand of the cast. */
4046 switch (TREE_CODE (arg))
4051 case FIX_TRUNC_EXPR:
4052 case FIX_FLOOR_EXPR:
4053 case FIX_ROUND_EXPR:
4056 pedwarn ("ANSI C++ forbids taking the address of a cast expression");
4057 return convert (build_pointer_type (TREE_TYPE (arg)),
4058 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0));
4062 /* Allow the address of a constructor if all the elements
4064 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
4066 /* Anything not already handled and not a true memory reference
4068 else if (typecode != FUNCTION_TYPE
4069 && typecode != METHOD_TYPE
4070 && !lvalue_or_else (arg, "unary `&'"))
4071 return error_mark_node;
4073 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4074 argtype = TREE_TYPE (arg);
4075 /* If the lvalue is const or volatile,
4076 merge that into the type that the address will point to. */
4077 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
4078 || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
4080 if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
4081 argtype = build_type_variant (argtype,
4082 TREE_READONLY (arg),
4083 TREE_THIS_VOLATILE (arg));
4086 argtype = build_pointer_type (argtype);
4088 if (mark_addressable (arg) == 0)
4089 return error_mark_node;
4094 if (TREE_CODE (arg) == COMPONENT_REF)
4095 addr = build_component_addr (arg, argtype,
4096 "attempt to take address of bit-field structure member `%s'");
4098 addr = build1 (code, argtype, arg);
4100 /* Address of a static or external variable or
4101 function counts as a constant */
4103 TREE_CONSTANT (addr) = 1;
4111 argtype = TREE_TYPE (arg);
4112 return fold (build1 (code, argtype, arg));
4116 return error_mark_node;
4119 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4120 convert ARG with the same conversions in the same order
4121 and return the result. */
4124 convert_sequence (conversions, arg)
4128 switch (TREE_CODE (conversions))
4133 case FIX_TRUNC_EXPR:
4134 case FIX_FLOOR_EXPR:
4135 case FIX_ROUND_EXPR:
4137 return convert (TREE_TYPE (conversions),
4138 convert_sequence (TREE_OPERAND (conversions, 0),
4146 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4147 for certain kinds of expressions which are not really lvalues
4148 but which we can accept as lvalues.
4150 If ARG is not a kind of expression we can handle, return zero. */
4153 unary_complex_lvalue (code, arg)
4154 enum tree_code code;
4157 /* Handle (a, b) used as an "lvalue". */
4158 if (TREE_CODE (arg) == COMPOUND_EXPR)
4160 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4161 pedantic_lvalue_warning (COMPOUND_EXPR);
4162 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4163 TREE_OPERAND (arg, 0), real_result);
4166 /* Handle (a ? b : c) used as an "lvalue". */
4167 if (TREE_CODE (arg) == COND_EXPR)
4169 pedantic_lvalue_warning (COND_EXPR);
4170 return rationalize_conditional_expr (code, arg);
4173 if (code != ADDR_EXPR)
4176 /* Handle (a = b) used as an "lvalue" for `&'. */
4177 if (TREE_CODE (arg) == MODIFY_EXPR
4178 || TREE_CODE (arg) == INIT_EXPR)
4180 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4181 return build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4184 if (TREE_CODE (arg) == WITH_CLEANUP_EXPR)
4186 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4187 real_result = build (WITH_CLEANUP_EXPR, TREE_TYPE (real_result),
4188 real_result, 0, TREE_OPERAND (arg, 2));
4192 if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4193 || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4194 || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
4196 /* The representation of something of type OFFSET_TYPE
4197 is really the representation of a pointer to it.
4198 Here give the representation its true type. */
4202 my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4204 if (TREE_CODE (arg) != OFFSET_REF)
4207 t = TREE_OPERAND (arg, 1);
4209 if (TREE_CODE (t) == FUNCTION_DECL) /* Check all this code for right semantics. */
4210 return build_unary_op (ADDR_EXPR, t, 0);
4211 if (TREE_CODE (t) == VAR_DECL)
4212 return build_unary_op (ADDR_EXPR, t, 0);
4215 /* Can't build a pointer to member if the member must
4216 go through virtual base classes. */
4217 if (virtual_member (DECL_FIELD_CONTEXT (t),
4218 CLASSTYPE_VBASECLASSES (TREE_TYPE (TREE_OPERAND (arg, 0)))))
4220 sorry ("pointer to member via virtual baseclass");
4221 return error_mark_node;
4224 if (TREE_OPERAND (arg, 0)
4225 && (TREE_CODE (TREE_OPERAND (arg, 0)) != NOP_EXPR
4226 || TREE_OPERAND (TREE_OPERAND (arg, 0), 0) != error_mark_node))
4228 /* Don't know if this should return address to just
4229 _DECL, or actual address resolved in this expression. */
4230 sorry ("address of bound pointer-to-member expression");
4231 return error_mark_node;
4234 return convert (build_pointer_type (TREE_TYPE (arg)),
4235 size_binop (EASY_DIV_EXPR,
4236 DECL_FIELD_BITPOS (t),
4237 size_int (BITS_PER_UNIT)));
4241 if (TREE_CODE (arg) == OFFSET_REF)
4243 tree left = TREE_OPERAND (arg, 0), left_addr;
4244 tree right_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 1), 0);
4247 if (current_class_decl)
4248 left_addr = current_class_decl;
4251 error ("no `this' for pointer to member");
4252 return error_mark_node;
4255 left_addr = build_unary_op (ADDR_EXPR, left, 0);
4257 return build (PLUS_EXPR, build_pointer_type (TREE_TYPE (arg)),
4258 build1 (NOP_EXPR, integer_type_node, left_addr),
4259 build1 (NOP_EXPR, integer_type_node, right_addr));
4262 /* We permit compiler to make function calls returning
4263 objects of aggregate type look like lvalues. */
4267 if (TREE_CODE (targ) == SAVE_EXPR)
4268 targ = TREE_OPERAND (targ, 0);
4270 if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4272 if (TREE_CODE (arg) == SAVE_EXPR)
4275 targ = build_cplus_new (TREE_TYPE (arg), arg, 1);
4276 return build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (arg)), targ);
4279 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4280 return build (SAVE_EXPR, TYPE_POINTER_TO (TREE_TYPE (arg)),
4281 TREE_OPERAND (targ, 0), current_function_decl, NULL);
4283 /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
4284 we do, here's how to handle it. */
4285 if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == WITH_CLEANUP_EXPR)
4288 /* Not really a bug, but something to turn on when testing. */
4289 compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
4291 return unary_complex_lvalue (ADDR_EXPR, targ);
4295 /* Don't let anything else be handled specially. */
4299 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
4300 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
4303 pedantic_lvalue_warning (code)
4304 enum tree_code code;
4307 pedwarn ("ANSI C++ forbids use of %s expressions as lvalues",
4308 code == COND_EXPR ? "conditional"
4309 : code == COMPOUND_EXPR ? "compound" : "cast");
4312 /* Mark EXP saying that we need to be able to take the
4313 address of it; it should not be allocated in a register.
4314 Value is 1 if successful.
4316 C++: we do not allow `current_class_decl' to be addressable. */
4319 mark_addressable (exp)
4322 register tree x = exp;
4324 if (TREE_ADDRESSABLE (x) == 1)
4328 switch (TREE_CODE (x))
4333 x = TREE_OPERAND (x, 0);
4337 if (x == current_class_decl)
4339 error ("address of `this' not available");
4340 TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */
4341 put_var_into_stack (x);
4346 && TREE_READONLY (x)
4347 && DECL_RTL (x) != 0
4348 && ! decl_in_memory_p (x))
4350 /* We thought this would make a good constant variable,
4351 but we were wrong. */
4352 push_obstacks_nochange ();
4353 end_temporary_allocation ();
4355 TREE_ASM_WRITTEN (x) = 0;
4357 rest_of_decl_compilation (x, 0, IDENTIFIER_LOCAL_VALUE (x) == 0, 0);
4358 TREE_ADDRESSABLE (x) = 1;
4364 /* Caller should not be trying to mark initialized
4365 constant fields addressable. */
4366 my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4367 || DECL_IN_AGGR_P (x) == 0
4369 || DECL_EXTERNAL (x), 314);
4373 /* For C++, we don't warn about taking the address of a register
4374 variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
4375 put_var_into_stack (x);
4376 TREE_ADDRESSABLE (x) = 1;
4380 /* We have to test both conditions here. The first may
4381 be non-zero in the case of processing a default function.
4382 The second may be non-zero in the case of a template function. */
4383 x = DECL_MAIN_VARIANT (x);
4384 if ((DECL_INLINE (x) || DECL_PENDING_INLINE_INFO (x))
4385 && (DECL_CONTEXT (x) == NULL_TREE
4386 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x))) != 't'
4387 || ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x))))
4389 mark_inline_for_output (x);
4390 if (x == current_function_decl)
4391 DECL_EXTERNAL (x) = 0;
4393 TREE_ADDRESSABLE (x) = 1;
4395 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4403 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4406 build_x_conditional_expr (ifexp, op1, op2)
4407 tree ifexp, op1, op2;
4409 tree rval = NULL_TREE;
4411 /* See comments in `build_x_binary_op'. */
4413 rval = build_opfncall (COND_EXPR, LOOKUP_SPECULATIVELY, ifexp, op1, op2);
4415 return build_opfncall (COND_EXPR, LOOKUP_NORMAL, ifexp, op1, op2);
4417 return build_conditional_expr (ifexp, op1, op2);
4421 build_conditional_expr (ifexp, op1, op2)
4422 tree ifexp, op1, op2;
4424 register tree type1;
4425 register tree type2;
4426 register enum tree_code code1;
4427 register enum tree_code code2;
4428 register tree result_type = NULL_TREE;
4429 tree orig_op1 = op1, orig_op2 = op2;
4431 /* If second operand is omitted, it is the same as the first one;
4432 make sure it is calculated only once. */
4436 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4437 ifexp = op1 = save_expr (ifexp);
4440 ifexp = truthvalue_conversion (default_conversion (ifexp));
4442 if (TREE_CODE (ifexp) == ERROR_MARK)
4443 return error_mark_node;
4445 op1 = require_instantiated_type (TREE_TYPE (op2), op1, error_mark_node);
4446 if (op1 == error_mark_node)
4447 return error_mark_node;
4448 op2 = require_instantiated_type (TREE_TYPE (op1), op2, error_mark_node);
4449 if (op2 == error_mark_node)
4450 return error_mark_node;
4452 /* C++: REFERENCE_TYPES must be dereferenced. */
4453 type1 = TREE_TYPE (op1);
4454 code1 = TREE_CODE (type1);
4455 type2 = TREE_TYPE (op2);
4456 code2 = TREE_CODE (type2);
4458 if (code1 == REFERENCE_TYPE)
4460 op1 = convert_from_reference (op1);
4461 type1 = TREE_TYPE (op1);
4462 code1 = TREE_CODE (type1);
4464 if (code2 == REFERENCE_TYPE)
4466 op2 = convert_from_reference (op2);
4467 type2 = TREE_TYPE (op2);
4468 code2 = TREE_CODE (type2);
4471 #if 1 /* Produces wrong result if within sizeof. Sorry. */
4472 /* Don't promote the operands separately if they promote
4473 the same way. Return the unpromoted type and let the combined
4474 value get promoted if necessary. */
4476 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)
4477 && code2 != ARRAY_TYPE
4479 /* For C++, let the enumeral type come through. */
4480 && code2 != ENUMERAL_TYPE
4482 && code2 != FUNCTION_TYPE
4483 && code2 != METHOD_TYPE)
4487 if (TREE_CONSTANT (ifexp)
4488 && (TREE_CODE (ifexp) == INTEGER_CST
4489 || TREE_CODE (ifexp) == ADDR_EXPR))
4490 return (integer_zerop (ifexp) ? op2 : op1);
4492 if (TREE_CODE (op1) == CONST_DECL)
4493 op1 = DECL_INITIAL (op1);
4494 else if (TREE_READONLY_DECL_P (op1))
4495 op1 = decl_constant_value (op1);
4496 if (TREE_CODE (op2) == CONST_DECL)
4497 op2 = DECL_INITIAL (op2);
4498 else if (TREE_READONLY_DECL_P (op2))
4499 op2 = decl_constant_value (op2);
4501 type1 = build_type_variant
4503 TREE_READONLY (op1) || TREE_READONLY (op2),
4504 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
4505 /* ??? This is a kludge to deal with the fact that
4506 we don't sort out integers and enums properly, yet. */
4507 result = fold (build (COND_EXPR, type1, ifexp, op1, op2));
4508 if (TREE_TYPE (result) != type1)
4509 result = build1 (NOP_EXPR, type1, result);
4514 /* They don't match; promote them both and then try to reconcile them.
4515 But don't permit mismatching enum types. */
4516 if (code1 == ENUMERAL_TYPE)
4518 if (code2 == ENUMERAL_TYPE)
4520 message_2_types (error, "enumeral mismatch in conditional expression: `%s' vs `%s'", type1, type2);
4521 return error_mark_node;
4523 else if (extra_warnings && ! IS_AGGR_TYPE_CODE (code2))
4524 warning ("enumeral and non-enumeral type in conditional expression");
4526 else if (extra_warnings
4527 && code2 == ENUMERAL_TYPE && ! IS_AGGR_TYPE_CODE (code1))
4528 warning ("enumeral and non-enumeral type in conditional expression");
4530 if (code1 != VOID_TYPE)
4532 op1 = default_conversion (op1);
4533 type1 = TREE_TYPE (op1);
4534 code1 = TREE_CODE (type1);
4536 if (code2 != VOID_TYPE)
4538 op2 = default_conversion (op2);
4539 type2 = TREE_TYPE (op2);
4540 code2 = TREE_CODE (type2);
4543 /* Quickly detect the usual case where op1 and op2 have the same type
4545 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4548 result_type = type1;
4550 result_type = build_type_variant
4552 TREE_READONLY (op1) || TREE_READONLY (op2),
4553 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
4555 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
4556 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
4558 result_type = common_type (type1, type2);
4560 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
4562 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
4563 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
4564 result_type = void_type_node;
4566 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
4568 if (comp_target_types (type1, type2, 1))
4569 result_type = common_type (type1, type2);
4570 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
4571 && TREE_CODE (orig_op1) != NOP_EXPR)
4572 result_type = qualify_type (type2, type1);
4573 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
4574 && TREE_CODE (orig_op2) != NOP_EXPR)
4575 result_type = qualify_type (type1, type2);
4576 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
4578 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
4579 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4580 result_type = qualify_type (type1, type2);
4582 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
4584 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
4585 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4586 result_type = qualify_type (type2, type1);
4589 else if (comptypes (type2, type1, 0))
4590 result_type = type2;
4591 else if (IS_AGGR_TYPE (TREE_TYPE (type1))
4592 && IS_AGGR_TYPE (TREE_TYPE (type2))
4593 && (result_type = common_base_type (TREE_TYPE (type1), TREE_TYPE (type2))))
4595 if (result_type == error_mark_node)
4597 message_2_types (error, "common base type of types `%s' and `%s' is ambiguous",
4598 TREE_TYPE (type1), TREE_TYPE (type2));
4599 result_type = ptr_type_node;
4601 else result_type = TYPE_POINTER_TO (result_type);
4605 pedwarn ("pointer type mismatch in conditional expression");
4606 result_type = ptr_type_node;
4609 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
4611 if (!integer_zerop (op2))
4612 pedwarn ("pointer/integer type mismatch in conditional expression");
4615 op2 = null_pointer_node;
4616 #if 0 /* Sez who? */
4617 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
4618 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4621 result_type = type1;
4623 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
4625 if (!integer_zerop (op1))
4626 pedwarn ("pointer/integer type mismatch in conditional expression");
4629 op1 = null_pointer_node;
4630 #if 0 /* Sez who? */
4631 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
4632 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4635 result_type = type2;
4640 /* The match does not look good. If either is
4641 an aggregate value, try converting to a scalar type. */
4642 if (code1 == RECORD_TYPE && code2 == RECORD_TYPE)
4644 message_2_types (error, "aggregate mismatch in conditional expression: `%s' vs `%s'", type1, type2);
4645 return error_mark_node;
4647 if (code1 == RECORD_TYPE && TYPE_HAS_CONVERSION (type1))
4649 tree tmp = build_type_conversion (CONVERT_EXPR, type2, op1, 0);
4650 if (tmp == NULL_TREE)
4652 cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1);
4653 return error_mark_node;
4655 if (tmp == error_mark_node)
4656 error ("ambiguous pointer conversion");
4657 result_type = type2;
4660 else if (code2 == RECORD_TYPE && TYPE_HAS_CONVERSION (type2))
4662 tree tmp = build_type_conversion (CONVERT_EXPR, type1, op2, 0);
4663 if (tmp == NULL_TREE)
4665 cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2);
4666 return error_mark_node;
4668 if (tmp == error_mark_node)
4669 error ("ambiguous pointer conversion");
4670 result_type = type1;
4673 else if (flag_cond_mismatch)
4674 result_type = void_type_node;
4677 error ("type mismatch in conditional expression");
4678 return error_mark_node;
4682 if (result_type != TREE_TYPE (op1))
4683 op1 = convert_and_check (result_type, op1);
4684 if (result_type != TREE_TYPE (op2))
4685 op2 = convert_and_check (result_type, op2);
4688 /* XXX delete me, I've been here for years. */
4689 if (IS_AGGR_TYPE_CODE (code1))
4691 result_type = TREE_TYPE (op1);
4692 if (TREE_CONSTANT (ifexp))
4693 return (integer_zerop (ifexp) ? op2 : op1);
4695 if (TYPE_MODE (result_type) == BLKmode)
4697 register tree tempvar
4698 = build_decl (VAR_DECL, NULL_TREE, result_type);
4699 register tree xop1 = build_modify_expr (tempvar, NOP_EXPR, op1);
4700 register tree xop2 = build_modify_expr (tempvar, NOP_EXPR, op2);
4701 register tree result = fold (build (COND_EXPR, result_type,
4702 ifexp, xop1, xop2));
4704 layout_decl (tempvar, 0);
4705 /* No way to handle variable-sized objects here.
4706 I fear that the entire handling of BLKmode conditional exprs
4707 needs to be redone. */
4708 my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar)), 315);
4710 = assign_stack_local (DECL_MODE (tempvar),
4711 (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
4712 + BITS_PER_UNIT - 1)
4716 TREE_SIDE_EFFECTS (result)
4717 = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
4718 | TREE_SIDE_EFFECTS (op2);
4719 return build (COMPOUND_EXPR, result_type, result, tempvar);
4724 if (TREE_CONSTANT (ifexp))
4725 return integer_zerop (ifexp) ? op2 : op1;
4727 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
4730 /* Handle overloading of the ',' operator when needed. Otherwise,
4731 this function just builds an expression list. */
4733 build_x_compound_expr (list)
4736 tree rest = TREE_CHAIN (list);
4739 if (rest == NULL_TREE)
4740 return build_compound_expr (list);
4742 result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
4743 TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
4745 return build_x_compound_expr (tree_cons (NULL_TREE, result, TREE_CHAIN (rest)));
4746 return build_compound_expr (tree_cons (NULL_TREE, TREE_VALUE (list),
4747 build_tree_list (NULL_TREE, build_x_compound_expr (rest))));
4750 /* Given a list of expressions, return a compound expression
4751 that performs them all and returns the value of the last of them. */
4754 build_compound_expr (list)
4759 if (TREE_READONLY_DECL_P (TREE_VALUE (list)))
4760 TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list));
4762 if (TREE_CHAIN (list) == 0)
4764 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4765 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4766 if (TREE_CODE (list) == NOP_EXPR
4767 && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0)))
4768 list = TREE_OPERAND (list, 0);
4770 /* Convert arrays to pointers. */
4771 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
4772 return default_conversion (TREE_VALUE (list));
4774 return TREE_VALUE (list);
4777 rest = build_compound_expr (TREE_CHAIN (list));
4779 /* When pedantic, a compound expression can be neither an lvalue
4780 nor an integer constant expression. */
4781 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
4784 return build (COMPOUND_EXPR, TREE_TYPE (rest),
4785 break_out_cleanups (TREE_VALUE (list)), rest);
4788 /* Build an expression representing a cast to type TYPE of expression EXPR. */
4791 build_c_cast (type, expr)
4795 register tree value = expr;
4797 if (type == error_mark_node || expr == error_mark_node)
4798 return error_mark_node;
4800 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4801 Strip such NOP_EXPRs, since VALUE is being used in non-lvalue context. */
4802 if (TREE_CODE (value) == NOP_EXPR
4803 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
4804 value = TREE_OPERAND (value, 0);
4806 if (TREE_TYPE (expr)
4807 && TREE_CODE (TREE_TYPE (expr)) == OFFSET_TYPE
4808 && TREE_CODE (type) != OFFSET_TYPE)
4809 value = resolve_offset_ref (value);
4811 if (TREE_CODE (type) == ARRAY_TYPE)
4813 /* Allow casting from T1* to T2[] because Cfront allows it.
4814 NIHCL uses it. It is not valid ANSI C however, and hence, not
4816 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
4819 pedwarn ("ANSI C++ forbids casting to an array type");
4820 type = build_pointer_type (TREE_TYPE (type));
4824 error ("ANSI C++ forbids casting to an array type");
4825 return error_mark_node;
4829 if (IS_SIGNATURE (type))
4831 error ("cast specifies signature type");
4832 return error_mark_node;
4835 if (TREE_TYPE (value)
4836 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
4838 /* For C++, we must copy the constness of TYPE into VALUE. */
4839 if (TREE_READONLY (value) != TYPE_READONLY (type))
4841 value = copy_node (value);
4842 TREE_READONLY (value) = TYPE_READONLY (type);
4846 if (TREE_CODE (type) == RECORD_TYPE
4847 || TREE_CODE (type) == UNION_TYPE)
4848 pedwarn ("ANSI C++ forbids casting nonscalar to the same type");
4853 /* If there's only one function in the overloaded space,
4855 if (TREE_CODE (value) == TREE_LIST
4856 && TREE_CHAIN (value) == NULL_TREE)
4857 value = TREE_VALUE (value);
4859 /* Make up for the fact that we do not always perform
4860 `default_conversion' anymore. */
4861 if (TREE_READONLY_DECL_P (value))
4862 value = decl_constant_value (value);
4864 if (TREE_CODE (type) == VOID_TYPE)
4865 value = build1 (NOP_EXPR, type, value);
4866 else if (TREE_TYPE (value) == NULL_TREE
4867 || type_unknown_p (value))
4869 value = instantiate_type (type, value, 1);
4871 if (value == error_mark_node)
4872 return error_mark_node;
4878 /* Convert functions and arrays to pointers and
4879 convert references to their expanded types,
4880 but don't convert any other types. */
4881 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
4882 || TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
4883 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
4884 || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
4885 value = default_conversion (value);
4886 otype = TREE_TYPE (value);
4888 /* Optionally warn about potentially worrisome casts. */
4891 && TREE_CODE (type) == POINTER_TYPE
4892 && TREE_CODE (otype) == POINTER_TYPE)
4894 /* For C++ we make these regular warnings, rather than
4895 softening them into pedwarns. */
4896 if (TYPE_VOLATILE (TREE_TYPE (otype))
4897 && ! TYPE_VOLATILE (TREE_TYPE (type)))
4898 warning ("cast discards `volatile' from pointer target type");
4899 if (TYPE_READONLY (TREE_TYPE (otype))
4900 && ! TYPE_READONLY (TREE_TYPE (type)))
4901 warning ("cast discards `const' from pointer target type");
4904 /* Warn about possible alignment problems. */
4905 if (STRICT_ALIGNMENT && warn_cast_align
4906 && TREE_CODE (type) == POINTER_TYPE
4907 && TREE_CODE (otype) == POINTER_TYPE
4908 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
4909 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4910 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
4911 warning ("cast increases required alignment of target type");
4914 if (TREE_CODE (type) == INTEGER_TYPE
4915 && TREE_CODE (otype) == POINTER_TYPE
4916 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4917 warning ("cast from pointer to integer of different size");
4919 if (TREE_CODE (type) == POINTER_TYPE
4920 && TREE_CODE (otype) == INTEGER_TYPE
4921 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4922 /* Don't warn about converting 0 to pointer,
4923 provided the 0 was explicit--not cast or made by folding. */
4924 && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value)))
4925 warning ("cast to pointer from integer of different size");
4929 value = convert_force (type, value);
4931 /* Ignore any integer overflow caused by the cast. */
4932 if (TREE_CODE (value) == INTEGER_CST)
4934 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4935 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
4939 /* Always produce some operator for an explicit cast,
4940 so we can tell (for -pedantic) that the cast is no lvalue.
4941 Also, pedantically, don't let (void *) (FOO *) 0 be a null
4942 pointer constant. */
4945 && TREE_CODE (value) == INTEGER_CST
4946 && TREE_CODE (expr) == INTEGER_CST
4947 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE))
4949 tree nvalue = build1 (NOP_EXPR, type, value);
4950 TREE_CONSTANT (nvalue) = TREE_CONSTANT (value);
4958 /* Build an assignment expression of lvalue LHS from value RHS.
4960 In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
4961 that reference becomes deferenced down to it base type. */
4963 /* Return a reference to the BASE_INDEX part of EXPR. TYPE is
4964 the type to which BASE_INDEX applies. */
4966 get_base_ref (type, base_index, expr)
4971 tree binfos = TYPE_BINFO_BASETYPES (type);
4972 tree base_binfo = TREE_VEC_ELT (binfos, base_index);
4975 if (TREE_CODE (expr) == ARRAY_REF
4976 || ! BINFO_OFFSET_ZEROP (base_binfo)
4977 || TREE_VIA_VIRTUAL (base_binfo)
4978 || TYPE_MODE (type) != TYPE_MODE (BINFO_TYPE (base_binfo)))
4980 tree addr = build_unary_op (ADDR_EXPR, expr, 0);
4981 ref = build_indirect_ref (convert_pointer_to (base_binfo, addr),
4986 ref = copy_node (expr);
4987 TREE_TYPE (ref) = BINFO_TYPE (base_binfo);
4992 /* Build an assignment expression of lvalue LHS from value RHS.
4993 MODIFYCODE is the code for a binary operator that we use
4994 to combine the old value of LHS with RHS to get the new value.
4995 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4997 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
4999 `build_modify_expr_1' implements recursive part of memberwise
5000 assignment operation. */
5002 build_modify_expr_1 (lhs, modifycode, rhs, basetype_path)
5004 enum tree_code modifycode;
5007 register tree result;
5009 tree lhstype = TREE_TYPE (lhs);
5010 tree olhstype = lhstype;
5012 /* Avoid duplicate error messages from operands that had errors. */
5013 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
5014 return error_mark_node;
5016 /* If a binary op has been requested, combine the old LHS value with the RHS
5017 producing the value we should actually store into the LHS. */
5019 if (modifycode == INIT_EXPR)
5021 else if (modifycode == NOP_EXPR)
5023 /* must deal with overloading of `operator=' here. */
5024 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5025 lhstype = TREE_TYPE (lhstype);
5031 lhs = stabilize_reference (lhs);
5032 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
5033 modifycode = NOP_EXPR;
5036 /* If storing into a structure or union member,
5037 it has probably been given type `int'.
5038 Compute the type that would go with
5039 the actual amount of storage the member occupies. */
5041 if (TREE_CODE (lhs) == COMPONENT_REF
5042 && (TREE_CODE (lhstype) == INTEGER_TYPE
5043 || TREE_CODE (lhstype) == REAL_TYPE
5044 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5045 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5047 /* C++: The semantics of C++ differ from those of C when an
5048 assignment of an aggregate is desired. Assignment in C++ is
5049 now defined as memberwise assignment of non-static members
5050 and base class objects. This rule applies recursively
5051 until a member of a built-in type is found.
5053 Also, we cannot do a bit-wise copy of aggregates which
5054 contain virtual function table pointers. Those
5055 pointer values must be preserved through the copy.
5056 However, this is handled in expand_expr, and not here.
5057 This is because much better code can be generated at
5058 that stage than this one. */
5059 if (TREE_CODE (lhstype) == RECORD_TYPE
5060 && TYPE_LANG_SPECIFIC (lhstype)
5061 && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
5066 /* Perform operation on object. */
5067 if (modifycode == INIT_EXPR && TYPE_HAS_INIT_REF (lhstype))
5069 result = build_method_call (lhs, constructor_name_full (lhstype),
5070 build_tree_list (NULL_TREE, rhs),
5071 basetype_path, LOOKUP_NORMAL);
5072 return build_indirect_ref (result, NULL_PTR);
5074 else if (modifycode == NOP_EXPR)
5076 /* `operator=' is not an inheritable operator; see 13.4.3. */
5077 if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_ASSIGNMENT (lhstype))
5079 result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
5080 lhs, rhs, make_node (NOP_EXPR));
5081 if (result == NULL_TREE)
5082 return error_mark_node;
5087 if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype)
5088 || (modifycode == NOP_EXPR && TYPE_GETS_ASSIGNMENT (lhstype))
5089 || (modifycode == INIT_EXPR && TYPE_GETS_INIT_REF (lhstype)))
5091 tree binfos = BINFO_BASETYPES (TYPE_BINFO (lhstype));
5094 if (binfos != NULL_TREE)
5095 /* Perform operation on each member, depth-first, left-right. */
5096 for (i = 0; i <= TREE_VEC_LENGTH (binfos)-1; i++)
5098 tree base_binfo = TREE_VEC_ELT (binfos, i);
5099 tree base_lhs, base_rhs;
5102 /* Assignments from virtual baseclasses handled elsewhere. */
5103 if (TREE_VIA_VIRTUAL (base_binfo))
5106 base_lhs = get_base_ref (lhstype, i, lhs);
5107 base_rhs = get_base_ref (lhstype, i, newrhs);
5109 BINFO_INHERITANCE_CHAIN (base_binfo) = basetype_path;
5111 = build_modify_expr_1 (base_lhs, modifycode, base_rhs,
5114 /* We either get back a compound stmt, or a simple one. */
5115 if (new_result && TREE_CODE (new_result) == TREE_LIST)
5116 new_result = build_compound_expr (new_result);
5117 result = tree_cons (NULL_TREE, new_result, result);
5120 for (elt = TYPE_FIELDS (lhstype); elt; elt = TREE_CHAIN (elt))
5122 tree vbases = NULL_TREE;
5123 tree elt_lhs, elt_rhs;
5125 if (TREE_CODE (elt) != FIELD_DECL)
5128 && (VFIELD_NAME_P (DECL_NAME (elt))
5129 || VBASE_NAME_P (DECL_NAME (elt))))
5132 if (TREE_READONLY (elt)
5133 || TREE_CODE (TREE_TYPE (elt)) == REFERENCE_TYPE)
5135 cp_error ("cannot generate default `%T::operator ='",
5137 if (TREE_CODE (TREE_TYPE (elt)) == REFERENCE_TYPE)
5138 cp_error_at ("because member `%#D' is a reference", elt);
5140 cp_error_at ("because member `%#D' is const", elt);
5142 return error_mark_node;
5145 if (IS_AGGR_TYPE (TREE_TYPE (elt))
5146 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt)))
5147 vbases = CLASSTYPE_VBASECLASSES (TREE_TYPE (elt));
5149 elt_lhs = build (COMPONENT_REF, TREE_TYPE (elt), lhs, elt);
5150 elt_rhs = build (COMPONENT_REF, TREE_TYPE (elt), newrhs, elt);
5151 /* It is not always safe to go through `build_modify_expr_1'
5152 when performing element-wise copying. This is because
5153 an element may be of ARRAY_TYPE, which will not
5154 be properly copied as a naked element. */
5155 if (TREE_CODE (TREE_TYPE (elt)) == RECORD_TYPE
5156 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt)))
5157 basetype_path = TYPE_BINFO (TREE_TYPE (elt));
5161 tree elt_lhs_addr = build_unary_op (ADDR_EXPR, elt_lhs, 0);
5162 tree elt_rhs_addr = build_unary_op (ADDR_EXPR, elt_rhs, 0);
5164 elt_lhs_addr = convert_pointer_to (vbases, elt_lhs_addr);
5165 elt_rhs_addr = convert_pointer_to (vbases, elt_rhs_addr);
5167 = tree_cons (NULL_TREE,
5169 (build_indirect_ref (elt_lhs_addr, NULL_PTR),
5171 build_indirect_ref (elt_rhs_addr, NULL_PTR),
5174 if (TREE_VALUE (result) == error_mark_node)
5175 return error_mark_node;
5176 vbases = TREE_CHAIN (vbases);
5178 elt_lhs = build_modify_expr_1 (elt_lhs, modifycode, elt_rhs,
5180 result = tree_cons (NULL_TREE, elt_lhs, result);
5184 return build_compound_expr (result);
5185 /* No fields to move. */
5186 return integer_zero_node;
5190 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5191 void_type_node, lhs, rhs);
5192 TREE_SIDE_EFFECTS (result) = 1;
5197 result = build_modify_expr (lhs, modifycode, newrhs);
5198 /* ARRAY_TYPEs cannot be converted to anything meaningful,
5199 and leaving it there screws up `build_compound_expr' when
5200 it tries to defaultly convert everything. */
5201 if (TREE_CODE (TREE_TYPE (result)) == ARRAY_TYPE)
5202 TREE_TYPE (result) = void_type_node;
5207 /* Taken from expr.c:
5208 Subroutine of expand_expr:
5209 record the non-copied parts (LIST) of an expr (LHS), and return a list
5210 which specifies the initial values of these parts. */
5213 init_noncopied_parts (lhs, list)
5220 for (tail = list; tail; tail = TREE_CHAIN (tail))
5221 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5222 parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
5225 tree part = TREE_VALUE (tail);
5226 tree part_type = TREE_TYPE (part);
5227 tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
5228 parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
5233 /* Build an assignment expression of lvalue LHS from value RHS.
5234 MODIFYCODE is the code for a binary operator that we use
5235 to combine the old value of LHS with RHS to get the new value.
5236 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5238 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5241 build_modify_expr (lhs, modifycode, rhs)
5243 enum tree_code modifycode;
5246 register tree result;
5248 tree lhstype = TREE_TYPE (lhs);
5249 tree olhstype = lhstype;
5251 /* Types that aren't fully specified cannot be used in assignments. */
5252 lhs = require_complete_type (lhs);
5254 /* Avoid duplicate error messages from operands that had errors. */
5255 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
5256 return error_mark_node;
5258 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5259 Strip such NOP_EXPRs, since RHS is being used in non-lvalue context. */
5260 if (TREE_CODE (rhs) == NOP_EXPR
5261 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)))
5262 rhs = TREE_OPERAND (rhs, 0);
5264 /* Decide early if we are going to protect RHS from GC
5265 before assigning it to LHS. */
5266 if (type_needs_gc_entry (TREE_TYPE (rhs))
5267 && ! value_safe_from_gc (lhs, rhs))
5268 rhs = protect_value_from_gc (lhs, rhs);
5272 /* Handle assignment to signature pointers/refs. */
5274 if (TYPE_LANG_SPECIFIC (lhstype) &&
5275 (IS_SIGNATURE_POINTER (lhstype) || IS_SIGNATURE_REFERENCE (lhstype)))
5277 return build_signature_pointer_constructor (lhs, rhs);
5280 /* Handle control structure constructs used as "lvalues". */
5282 switch (TREE_CODE (lhs))
5284 /* Handle --foo = 5; as these are valid constructs in C++ */
5285 case PREDECREMENT_EXPR:
5286 case PREINCREMENT_EXPR:
5287 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5288 lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5289 stabilize_reference (TREE_OPERAND (lhs, 0)));
5290 return build (COMPOUND_EXPR, lhstype,
5292 build_modify_expr (TREE_OPERAND (lhs, 0),
5295 /* Handle (a, b) used as an "lvalue". */
5297 pedantic_lvalue_warning (COMPOUND_EXPR);
5298 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5300 if (TREE_CODE (newrhs) == ERROR_MARK)
5301 return error_mark_node;
5302 return build (COMPOUND_EXPR, lhstype,
5303 TREE_OPERAND (lhs, 0), newrhs);
5305 /* Handle (a ? b : c) used as an "lvalue". */
5307 pedantic_lvalue_warning (COND_EXPR);
5308 rhs = save_expr (rhs);
5310 /* Produce (a ? (b = rhs) : (c = rhs))
5311 except that the RHS goes through a save-expr
5312 so the code to compute it is only emitted once. */
5314 = build_conditional_expr (TREE_OPERAND (lhs, 0),
5315 build_modify_expr (TREE_OPERAND (lhs, 1),
5317 build_modify_expr (TREE_OPERAND (lhs, 2),
5319 if (TREE_CODE (cond) == ERROR_MARK)
5321 /* Make sure the code to compute the rhs comes out
5322 before the split. */
5323 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
5324 /* Case to void to suppress warning
5325 from warn_if_unused_value. */
5326 convert (void_type_node, rhs), cond);
5330 /* If a binary op has been requested, combine the old LHS value with the RHS
5331 producing the value we should actually store into the LHS. */
5333 if (modifycode == INIT_EXPR)
5335 if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_CONSTRUCTOR (lhstype))
5337 result = build_method_call (lhs, constructor_name_full (lhstype),
5338 build_tree_list (NULL_TREE, rhs),
5339 NULL_TREE, LOOKUP_NORMAL);
5340 if (result == NULL_TREE)
5341 return error_mark_node;
5345 else if (modifycode == NOP_EXPR)
5347 /* must deal with overloading of `operator=' here. */
5348 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5349 lhstype = TREE_TYPE (lhstype);
5351 /* `operator=' is not an inheritable operator. */
5352 if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_ASSIGNMENT (lhstype))
5354 result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
5355 lhs, rhs, make_node (NOP_EXPR));
5356 if (result == NULL_TREE)
5357 return error_mark_node;
5361 /* Treat `operator=' as an inheritable operator. */
5362 if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_GETS_ASSIGNMENT (lhstype))
5364 tree orig_lhstype = lhstype;
5365 while (! TYPE_HAS_ASSIGNMENT (lhstype))
5367 int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (lhstype);
5368 tree basetype = NULL_TREE;
5369 for (i = 0; i < n_baseclasses; i++)
5370 if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype, i)))
5372 if (basetype != NULL_TREE)
5374 message_2_types (error, "base classes `%s' and `%s' both have operator ='",
5376 TYPE_BINFO_BASETYPE (lhstype, i));
5377 return error_mark_node;
5379 basetype = TYPE_BINFO_BASETYPE (lhstype, i);
5383 if (orig_lhstype != lhstype)
5385 lhs = build_indirect_ref (convert_pointer_to (lhstype,
5386 build_unary_op (ADDR_EXPR, lhs, 0)), NULL_PTR);
5387 if (lhs == error_mark_node)
5389 cp_error ("conversion to private basetype `%T'", lhstype);
5390 return error_mark_node;
5393 result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
5394 lhs, rhs, make_node (NOP_EXPR));
5395 if (result == NULL_TREE)
5396 return error_mark_node;
5402 else if (PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE))
5404 /* This case must convert to some sort of lvalue that
5405 can participate in an op= operation. */
5408 if (build_default_binary_type_conversion (modifycode, &lhs_tmp, &rhs_tmp))
5410 lhs = stabilize_reference (lhs_tmp);
5411 /* Forget is was ever anything else. */
5412 olhstype = lhstype = TREE_TYPE (lhs);
5413 newrhs = build_binary_op (modifycode, lhs, rhs_tmp, 1);
5416 return error_mark_node;
5420 lhs = stabilize_reference (lhs);
5421 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
5424 /* Handle a cast used as an "lvalue".
5425 We have already performed any binary operator using the value as cast.
5426 Now convert the result to the cast type of the lhs,
5427 and then true type of the lhs and store it there;
5428 then convert result back to the cast type to be the value
5429 of the assignment. */
5431 switch (TREE_CODE (lhs))
5436 case FIX_TRUNC_EXPR:
5437 case FIX_FLOOR_EXPR:
5438 case FIX_ROUND_EXPR:
5440 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5441 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5442 || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5443 || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5444 newrhs = default_conversion (newrhs);
5446 tree inner_lhs = TREE_OPERAND (lhs, 0);
5448 result = build_modify_expr (inner_lhs, NOP_EXPR,
5449 convert (TREE_TYPE (inner_lhs),
5450 convert (lhstype, newrhs)));
5451 if (TREE_CODE (result) == ERROR_MARK)
5453 return convert (TREE_TYPE (lhs), result);
5457 if (TREE_CODE (lhs) == OFFSET_REF)
5459 if (TREE_OPERAND (lhs, 0) == NULL_TREE)
5461 /* Static class member? */
5462 tree member = TREE_OPERAND (lhs, 1);
5463 if (TREE_CODE (member) == VAR_DECL)
5467 compiler_error ("invalid static class member");
5468 return error_mark_node;
5472 lhs = resolve_offset_ref (lhs);
5475 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5476 Reject anything strange now. */
5478 if (!lvalue_or_else (lhs, "assignment"))
5479 return error_mark_node;
5481 GNU_xref_assign (lhs);
5483 /* Warn about storing in something that is `const'. */
5484 /* For C++, don't warn if this is initialization. */
5485 if (modifycode != INIT_EXPR
5486 /* For assignment to `const' signature pointer/reference fields,
5487 don't warn either, we already printed a better message before. */
5488 && ! (TREE_CODE (lhs) == COMPONENT_REF
5489 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs, 0)))
5490 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
5491 && (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
5492 || ((TREE_CODE (lhstype) == RECORD_TYPE
5493 || TREE_CODE (lhstype) == UNION_TYPE)
5494 && C_TYPE_FIELDS_READONLY (lhstype))
5495 || (TREE_CODE (lhstype) == REFERENCE_TYPE
5496 && TYPE_READONLY (TREE_TYPE (lhstype)))))
5497 readonly_error (lhs, "assignment", 0);
5499 /* If storing into a structure or union member,
5500 it has probably been given type `int'.
5501 Compute the type that would go with
5502 the actual amount of storage the member occupies. */
5504 if (TREE_CODE (lhs) == COMPONENT_REF
5505 && (TREE_CODE (lhstype) == INTEGER_TYPE
5506 || TREE_CODE (lhstype) == REAL_TYPE
5507 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5508 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5510 /* check to see if there is an assignment to `this' */
5511 if (lhs == current_class_decl)
5513 if (DECL_NAME (current_function_decl) != NULL_TREE)
5515 /* ARM 18.3.3 and draft standard section C.11 say that assigning
5516 something to this is an anachronism. */
5518 warning ("anachronistic assignment to `this' pointer");
5519 else if (flag_this_is_variable > 0
5520 && current_class_name != DECL_NAME (current_function_decl))
5521 warning ("assignment to `this' not in constructor or destructor");
5523 current_function_just_assigned_this = 1;
5526 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
5527 when the type of RHS is not yet known, i.e. its type
5528 is inherited from LHS. */
5529 rhs = require_instantiated_type (lhstype, newrhs, error_mark_node);
5530 if (rhs == error_mark_node)
5531 return error_mark_node;
5534 if (modifycode != INIT_EXPR)
5536 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5537 modifycode = NOP_EXPR;
5538 /* Reference-bashing */
5539 if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5541 tree tmp = convert_from_reference (lhs);
5542 lhstype = TREE_TYPE (tmp);
5543 if (TYPE_SIZE (lhstype) == 0)
5545 incomplete_type_error (lhs, lhstype);
5546 return error_mark_node;
5551 if (TREE_CODE (TREE_TYPE (newrhs)) == REFERENCE_TYPE)
5553 tree tmp = convert_from_reference (newrhs);
5554 if (TYPE_SIZE (TREE_TYPE (tmp)) == 0)
5556 incomplete_type_error (newrhs, TREE_TYPE (tmp));
5557 return error_mark_node;
5563 if (TREE_SIDE_EFFECTS (lhs))
5564 lhs = stabilize_reference (lhs);
5565 if (TREE_SIDE_EFFECTS (newrhs))
5566 newrhs = stabilize_reference (newrhs);
5568 /* C++: The semantics of C++ differ from those of C when an
5569 assignment of an aggregate is desired. Assignment in C++ is
5570 now defined as memberwise assignment of non-static members
5571 and base class objects. This rule applies recursively
5572 until a member of a built-in type is found.
5574 Also, we cannot do a bit-wise copy of aggregates which
5575 contain virtual function table pointers. Those
5576 pointer values must be preserved through the copy.
5577 However, this is handled in expand_expr, and not here.
5578 This is because much better code can be generated at
5579 that stage than this one. */
5580 if (TREE_CODE (lhstype) == RECORD_TYPE
5581 && ! TYPE_PTRMEMFUNC_P (lhstype)
5582 && (TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))
5583 || (TREE_CODE (TREE_TYPE (newrhs)) == RECORD_TYPE
5584 && UNIQUELY_DERIVED_FROM_P (lhstype, TREE_TYPE (newrhs)))))
5586 /* This was decided in finish_struct. */
5587 if (modifycode == INIT_EXPR)
5588 cp_error ("can't generate default copy constructor for `%T'", lhstype);
5590 cp_error ("can't generate default assignment operator for `%T'",
5593 /* This is now done by generating X(X&) and operator=(X&). */
5594 tree vbases = CLASSTYPE_VBASECLASSES (lhstype);
5595 tree lhs_addr = build_unary_op (ADDR_EXPR, lhs, 0);
5598 /* Memberwise assignment would cause NEWRHS to be
5599 evaluated for every member that gets assigned.
5600 By wrapping side-effecting exprs in a SAVE_EXPR,
5601 NEWRHS will only be evaluated once. */
5602 if (IS_AGGR_TYPE (TREE_TYPE (newrhs))
5603 && TREE_SIDE_EFFECTS (newrhs)
5604 /* This are things we don't have to save. */
5605 && TREE_CODE (newrhs) != COND_EXPR
5606 && TREE_CODE (newrhs) != TARGET_EXPR
5607 && TREE_CODE (newrhs) != WITH_CLEANUP_EXPR)
5608 /* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
5609 If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
5610 will result in expand_expr expanding the call without knowing
5611 that it should run the cleanup. */
5612 newrhs = save_expr (break_out_cleanups (newrhs));
5614 if (TREE_CODE (newrhs) == COND_EXPR)
5615 rhs_addr = rationalize_conditional_expr (ADDR_EXPR, newrhs);
5617 rhs_addr = build_unary_op (ADDR_EXPR, newrhs, 0);
5619 result = tree_cons (NULL_TREE,
5620 convert (build_reference_type (lhstype), lhs),
5623 if (! comptypes (TREE_TYPE (lhs_addr), TREE_TYPE (rhs_addr), 1))
5624 rhs_addr = convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr)), rhs_addr);
5626 tree noncopied_parts = NULL_TREE;
5628 if (TYPE_NONCOPIED_PARTS (lhstype) != 0)
5629 noncopied_parts = init_noncopied_parts (lhs,
5630 TYPE_NONCOPIED_PARTS (lhstype));
5631 while (noncopied_parts != 0)
5633 result = tree_cons (NULL_TREE,
5634 build_modify_expr (convert (ptr_type_node, TREE_VALUE (noncopied_parts)),
5636 TREE_PURPOSE (noncopied_parts)),
5638 noncopied_parts = TREE_CHAIN (noncopied_parts);
5641 /* Once we have our hands on an address, we must change NEWRHS
5642 to work from there. Otherwise we can get multiple evaluations
5644 if (TREE_CODE (newrhs) != SAVE_EXPR)
5645 newrhs = build_indirect_ref (rhs_addr, NULL_PTR);
5649 tree elt_lhs = convert_pointer_to (vbases, lhs_addr);
5650 tree elt_rhs = convert_pointer_to (vbases, rhs_addr);
5652 = tree_cons (NULL_TREE,
5653 build_modify_expr_1 (build_indirect_ref (elt_lhs, NULL_PTR),
5655 build_indirect_ref (elt_rhs, NULL_PTR),
5656 TYPE_BINFO (lhstype)),
5658 if (TREE_VALUE (result) == error_mark_node)
5659 return error_mark_node;
5660 vbases = TREE_CHAIN (vbases);
5662 result = tree_cons (NULL_TREE,
5663 build_modify_expr_1 (lhs,
5666 TYPE_BINFO (lhstype)),
5668 return build_compound_expr (result);
5672 /* If storing in a field that is in actuality a short or narrower than one,
5673 we must store in the field in its actual type. */
5675 if (lhstype != TREE_TYPE (lhs))
5677 lhs = copy_node (lhs);
5678 TREE_TYPE (lhs) = lhstype;
5681 /* Convert new value to destination type. */
5683 if (TREE_CODE (lhstype) == ARRAY_TYPE)
5685 /* Allow array assignment in compiler-generated code. */
5686 if ((pedantic || flag_ansi)
5687 && ! DECL_ARTIFICIAL (current_function_decl))
5688 pedwarn ("ANSI C++ forbids assignment between arrays");
5690 /* Have to wrap this in RTL_EXPR for two cases:
5691 in base or member initialization and if we
5692 are a branch of a ?: operator. Since we
5693 can't easily know the latter, just do it always. */
5695 result = make_node (RTL_EXPR);
5697 TREE_TYPE (result) = void_type_node;
5698 do_pending_stack_adjust ();
5699 start_sequence_for_rtl_expr (result);
5701 /* As a matter of principle, `start_sequence' should do this. */
5704 expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs,
5705 1 + (modifycode != INIT_EXPR));
5707 do_pending_stack_adjust ();
5709 TREE_SIDE_EFFECTS (result) = 1;
5710 RTL_EXPR_SEQUENCE (result) = get_insns ();
5711 RTL_EXPR_RTL (result) = const0_rtx;
5716 if (modifycode == INIT_EXPR)
5718 newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5719 "assignment", NULL_TREE, 0);
5720 if (lhs == DECL_RESULT (current_function_decl))
5722 if (DECL_INITIAL (lhs))
5723 warning ("return value from function receives multiple initializations");
5724 DECL_INITIAL (lhs) = newrhs;
5729 if (IS_AGGR_TYPE (lhstype))
5731 if (result = build_opfncall (MODIFY_EXPR,
5732 LOOKUP_NORMAL, lhs, newrhs,
5733 make_node (NOP_EXPR)))
5736 /* Avoid warnings on enum bit fields. */
5737 if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5738 && TREE_CODE (lhstype) == INTEGER_TYPE)
5740 newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5742 newrhs = convert_force (lhstype, newrhs);
5745 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5747 if (flag_elide_constructors == 0
5748 && TREE_CODE (newrhs) == CALL_EXPR
5749 && TREE_ADDRESSABLE (lhstype))
5751 /* Can't initialized directly from a CALL_EXPR, since
5752 we don't know about what doesn't alias what. */
5754 tree temp = get_temp_name (lhstype, 0);
5755 newrhs = build (COMPOUND_EXPR, lhstype,
5756 build_modify_expr (temp, INIT_EXPR, newrhs),
5761 if (TREE_CODE (newrhs) == ERROR_MARK)
5762 return error_mark_node;
5764 if (TREE_CODE (newrhs) == COND_EXPR)
5767 tree cond = TREE_OPERAND (newrhs, 0);
5769 if (TREE_SIDE_EFFECTS (lhs))
5770 cond = build_compound_expr (tree_cons
5772 build_tree_list (NULL_TREE, cond)));
5774 /* Cannot have two identical lhs on this one tree (result) as preexpand
5775 calls will rip them out and fill in RTL for them, but when the
5776 rtl is generated, the calls will only be in the first side of the
5777 condition, not on both, or before the conditional jump! (mrs) */
5778 lhs1 = break_out_calls (lhs);
5781 /* If there's no change, the COND_EXPR behaves like any other rhs. */
5782 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5783 lhstype, lhs, newrhs);
5786 tree result_type = TREE_TYPE (newrhs);
5787 /* We have to convert each arm to the proper type because the
5788 types may have been munged by constant folding. */
5790 = build (COND_EXPR, result_type, cond,
5791 build_modify_expr (lhs, modifycode,
5792 convert (result_type,
5793 TREE_OPERAND (newrhs, 1))),
5794 build_modify_expr (lhs1, modifycode,
5795 convert (result_type,
5796 TREE_OPERAND (newrhs, 2))));
5799 else if (modifycode != INIT_EXPR && TREE_CODE (newrhs) == WITH_CLEANUP_EXPR)
5801 tree cleanup = TREE_OPERAND (newrhs, 2);
5804 /* Finish up by running cleanups and having the "value" of the lhs. */
5805 tree exprlist = tree_cons (NULL_TREE, cleanup,
5806 build_tree_list (NULL_TREE, lhs));
5807 newrhs = TREE_OPERAND (newrhs, 0);
5808 if (TREE_CODE (newrhs) == TARGET_EXPR)
5809 slot = TREE_OPERAND (newrhs, 0);
5810 else if (TREE_CODE (newrhs) == ADDR_EXPR)
5812 /* Bad but legal. */
5814 warning ("address taken of temporary object");
5817 my_friendly_abort (118);
5819 /* Copy the value computed in SLOT into LHS. */
5820 exprlist = tree_cons (NULL_TREE,
5821 build_modify_expr (lhs, modifycode, slot),
5823 /* Evaluate the expression that needs CLEANUP. This will
5824 compute the value into SLOT. */
5825 exprlist = tree_cons (NULL_TREE, newrhs, exprlist);
5826 result = convert (lhstype, build_compound_expr (exprlist));
5829 result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5830 lhstype, lhs, newrhs);
5831 TREE_SIDE_EFFECTS (result) = 1;
5833 /* If we got the LHS in a different type for storing in,
5834 convert the result back to the nominal type of LHS
5835 so that the value we return always has the same type
5836 as the LHS argument. */
5838 if (olhstype == TREE_TYPE (result))
5840 /* Avoid warnings converting integral types back into enums
5841 for enum bit fields. */
5842 if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
5843 && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5844 return convert_force (olhstype, result);
5845 return convert_for_assignment (olhstype, result, "assignment",
5850 /* Return 0 if EXP is not a valid lvalue in this language
5851 even though `lvalue_or_else' would accept it. */
5854 language_lvalue_valid (exp)
5860 /* Get differnce in deltas for different pointer to member function
5861 types. Return inetger_zero_node, if FROM cannot be converted to a
5862 TO type. If FORCE is true, then allow reverse conversions as well. */
5864 get_delta_difference (from, to, force)
5868 tree delta = integer_zero_node;
5874 /* Should get_base_distance here, so we can check if any thing along the
5875 path is virtual, and we need to make sure we stay
5876 inside the real binfos when going through virtual bases.
5877 Maybe we should replace virtual bases with
5878 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
5879 binfo = get_binfo (from, to, 1);
5880 if (binfo == error_mark_node)
5882 error (" in pointer to member function conversion");
5889 error_not_base_type (from, to);
5890 error (" in pointer to member function conversion");
5893 binfo = get_binfo (to, from, 1);
5894 if (binfo == error_mark_node)
5896 error (" in pointer to member function conversion");
5901 error ("cannot convert pointer to member of type %T to unrelated pointer to member of type %T", from, to);
5904 if (TREE_VIA_VIRTUAL (binfo))
5906 warning ("pointer to member conversion to virtual base class will only work if your very careful");
5908 return fold (size_binop (MINUS_EXPR,
5910 BINFO_OFFSET (binfo)));
5912 if (TREE_VIA_VIRTUAL (binfo))
5914 warning ("pointer to member conversion from virtual base class will only work if your very careful");
5916 return BINFO_OFFSET (binfo);
5919 /* Build a constructor for a pointer to member function. It can be
5920 used to initialize global variables, local variable, or used
5921 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
5924 If FORCE is non-zero, then force this conversion, even if
5925 we would rather not do it. Usually set when using an explicit
5928 Return error_mark_node, if something goes wrong. */
5931 build_ptrmemfunc (type, pfn, force)
5935 tree index = integer_zero_node;
5936 tree delta = integer_zero_node;
5937 tree delta2 = integer_zero_node;
5942 /* Handle multiple conversions of pointer to member fucntions. */
5943 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn)))
5945 tree ndelta, ndelta2, nindex;
5946 /* Is is already the right type? */
5948 /* Sorry, can't do this, the backend is too stupid. */
5949 if (TYPE_METHOD_BASETYPE (TREE_TYPE (type))
5950 == TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)))))
5952 if (type != TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)))
5954 npfn = build1 (NOP_EXPR, TYPE_GET_PTRMEMFUNC_TYPE (type), pfn);
5955 TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
5960 if (type == TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)))
5964 if (TREE_CODE (pfn) != CONSTRUCTOR)
5967 ndelta = convert (sizetype, build_component_ref (pfn, delta_identifier, 0, 0));
5968 ndelta2 = convert (sizetype, DELTA2_FROM_PTRMEMFUNC (pfn));
5969 index = build_component_ref (pfn, index_identifier, 0, 0);
5970 delta = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)))),
5971 TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
5973 delta = fold (size_binop (PLUS_EXPR, delta, ndelta));
5974 delta2 = fold (size_binop (PLUS_EXPR, ndelta2, delta2));
5975 e1 = fold (build (GT_EXPR, integer_type_node, index, integer_zero_node));
5977 u = build_nt (CONSTRUCTOR, 0, tree_cons (delta2_identifier, delta2, NULL_TREE));
5978 u = build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,
5979 tree_cons (NULL_TREE, index,
5980 tree_cons (NULL_TREE, u, NULL_TREE))));
5981 e2 = digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type), u, (tree*)0);
5983 pfn = PFN_FROM_PTRMEMFUNC (pfn);
5984 npfn = build1 (NOP_EXPR, type, pfn);
5985 TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
5987 u = build_nt (CONSTRUCTOR, 0, tree_cons (pfn_identifier, npfn, NULL_TREE));
5988 u = build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,
5989 tree_cons (NULL_TREE, index,
5990 tree_cons (NULL_TREE, u, NULL_TREE))));
5991 e3 = digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type), u, (tree*)0);
5992 return build_conditional_expr (e1, e2, e3);
5995 ndelta = TREE_VALUE (CONSTRUCTOR_ELTS (pfn));
5996 nindex = TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn)));
5997 npfn = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn))));
5998 npfn = TREE_VALUE (CONSTRUCTOR_ELTS (npfn));
5999 if (integer_zerop (nindex))
6000 pfn = integer_zero_node;
6003 sorry ("value casting of varible nonnull pointer to member functions not supported");
6004 return error_mark_node;
6008 /* Handle null pointer to member function conversions. */
6009 if (integer_zerop (pfn))
6011 pfn = build_c_cast (type, integer_zero_node);
6012 u = build_nt (CONSTRUCTOR, 0, tree_cons (pfn_identifier, pfn, NULL_TREE));
6013 u = build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, integer_zero_node,
6014 tree_cons (NULL_TREE, integer_zero_node,
6015 tree_cons (NULL_TREE, u, NULL_TREE))));
6016 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type), u, (tree*)0);
6019 /* Allow pointer to member conversions here. */
6020 delta = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn))),
6021 TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
6023 delta2 = fold (size_binop (PLUS_EXPR, delta2, delta));
6025 if (TREE_CODE (TREE_OPERAND (pfn, 0)) != FUNCTION_DECL)
6026 warning ("assuming pointer to member function is non-virtual");
6028 if (TREE_CODE (TREE_OPERAND (pfn, 0)) == FUNCTION_DECL
6029 && DECL_VINDEX (TREE_OPERAND (pfn, 0)))
6031 /* Find the offset to the vfield pointer in the object. */
6032 vfield_offset = get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn, 0)),
6033 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn, 0)),
6035 vfield_offset = get_vfield_offset (vfield_offset);
6036 delta2 = size_binop (PLUS_EXPR, vfield_offset, delta2);
6038 /* Map everything down one to make room for the null pointer to member. */
6039 index = size_binop (PLUS_EXPR,
6040 DECL_VINDEX (TREE_OPERAND (pfn, 0)),
6042 u = build_nt (CONSTRUCTOR, 0, tree_cons (delta2_identifier, delta2, NULL_TREE));
6046 index = fold (size_binop (MINUS_EXPR, integer_zero_node, integer_one_node));
6048 npfn = build1 (NOP_EXPR, type, pfn);
6049 TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
6051 u = build_nt (CONSTRUCTOR, 0, tree_cons (pfn_identifier, npfn, NULL_TREE));
6054 u = build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,
6055 tree_cons (NULL_TREE, index,
6056 tree_cons (NULL_TREE, u, NULL_TREE))));
6057 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type), u, (tree*)0);
6060 /* Convert value RHS to type TYPE as preparation for an assignment
6061 to an lvalue of type TYPE.
6062 The real work of conversion is done by `convert'.
6063 The purpose of this function is to generate error messages
6064 for assignments that are not allowed in C.
6065 ERRTYPE is a string to use in error messages:
6066 "assignment", "return", etc.
6068 C++: attempts to allow `convert' to find conversions involving
6069 implicit type conversion between aggregate and scalar types
6070 as per 8.5.6 of C++ manual. Does not randomly dereference
6071 pointers to aggregates! */
6074 convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
6080 register enum tree_code codel = TREE_CODE (type);
6081 register tree rhstype;
6082 register enum tree_code coder = TREE_CODE (TREE_TYPE (rhs));
6084 if (coder == UNKNOWN_TYPE)
6085 rhs = instantiate_type (type, rhs, 1);
6087 if (coder == ERROR_MARK)
6088 return error_mark_node;
6090 if (codel == OFFSET_TYPE)
6092 type = TREE_TYPE (type);
6093 codel = TREE_CODE (type);
6096 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6097 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6098 rhs = TREE_OPERAND (rhs, 0);
6100 if (rhs == error_mark_node)
6101 return error_mark_node;
6103 if (TREE_VALUE (rhs) == error_mark_node)
6104 return error_mark_node;
6106 if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
6108 rhs = resolve_offset_ref (rhs);
6109 if (rhs == error_mark_node)
6110 return error_mark_node;
6111 rhstype = TREE_TYPE (rhs);
6112 coder = TREE_CODE (rhstype);
6115 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6116 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6117 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6118 rhs = default_conversion (rhs);
6119 else if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
6120 rhs = convert_from_reference (rhs);
6122 rhstype = TREE_TYPE (rhs);
6123 coder = TREE_CODE (rhstype);
6125 /* This should no longer change types on us. */
6126 if (TREE_CODE (rhs) == CONST_DECL)
6127 rhs = DECL_INITIAL (rhs);
6128 else if (TREE_READONLY_DECL_P (rhs))
6129 rhs = decl_constant_value (rhs);
6131 if (type == rhstype)
6133 overflow_warning (rhs);
6137 if (coder == VOID_TYPE)
6139 error ("void value not ignored as it ought to be");
6140 return error_mark_node;
6142 /* Arithmetic types all interconvert. */
6143 if ((codel == INTEGER_TYPE || codel == REAL_TYPE)
6144 && (coder == INTEGER_TYPE || coder == REAL_TYPE))
6146 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6147 if (coder == REAL_TYPE && codel == INTEGER_TYPE)
6150 cp_warning ("`%T' used for argument %P of `%D'",
6151 rhstype, parmnum, fndecl);
6153 cp_warning ("%s to `%T' from `%T'", errtype, type, rhstype);
6155 /* And we should warn if assigning a negative value to
6156 an unsigned variable. */
6157 else if (TREE_UNSIGNED (type))
6159 if (TREE_CODE (rhs) == INTEGER_CST
6160 && TREE_NEGATED_INT (rhs))
6163 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6164 rhs, parmnum, fndecl);
6166 cp_warning ("%s of negative value `%E' to `%T'",
6167 errtype, rhs, type);
6169 overflow_warning (rhs);
6170 if (TREE_CONSTANT (rhs))
6174 return convert_and_check (type, rhs);
6176 /* Conversions involving enums. */
6177 else if ((codel == ENUMERAL_TYPE
6178 && (coder == ENUMERAL_TYPE || coder == INTEGER_TYPE || coder == REAL_TYPE))
6179 || (coder == ENUMERAL_TYPE
6180 && (codel == ENUMERAL_TYPE || codel == INTEGER_TYPE || codel == REAL_TYPE)))
6182 return convert (type, rhs);
6184 /* Conversions among pointers */
6185 else if (codel == POINTER_TYPE
6186 && (coder == POINTER_TYPE
6187 || (coder == RECORD_TYPE
6188 && (IS_SIGNATURE_POINTER (rhstype)
6189 || IS_SIGNATURE_REFERENCE (rhstype)))))
6191 register tree ttl = TREE_TYPE (type);
6194 if (coder == RECORD_TYPE)
6196 rhs = build_optr_ref (rhs);
6197 rhstype = TREE_TYPE (rhs);
6199 ttr = TREE_TYPE (rhstype);
6201 /* If both pointers are of aggregate type, then we
6202 can give better error messages, and save some work
6204 if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
6208 if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)
6209 || type == class_star_type_node
6210 || rhstype == class_star_type_node)
6211 binfo = TYPE_BINFO (ttl);
6213 binfo = get_binfo (ttl, ttr, 1);
6215 if (binfo == error_mark_node)
6216 return error_mark_node;
6218 return error_not_base_type (ttl, ttr);
6220 if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
6223 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6224 rhstype, parmnum, fndecl);
6226 cp_pedwarn ("%s to `%T' from `%T' discards const",
6227 errtype, type, rhstype);
6229 if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
6232 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6233 rhstype, parmnum, fndecl);
6235 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6236 errtype, type, rhstype);
6240 /* Any non-function converts to a [const][volatile] void *
6241 and vice versa; otherwise, targets must be the same.
6242 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6243 else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
6244 || TYPE_MAIN_VARIANT (ttr) == void_type_node
6245 || comp_target_types (type, rhstype, 1)
6246 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
6247 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
6249 /* ARM $4.8, commentary on p39. */
6250 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
6251 && TREE_CODE (ttr) == OFFSET_TYPE)
6253 error ("no standard conversion from pointer to member to `void *'");
6254 return error_mark_node;
6257 if (TYPE_MAIN_VARIANT (ttl) != void_type_node
6258 && TYPE_MAIN_VARIANT (ttr) == void_type_node
6259 && rhs != null_pointer_node)
6260 if (coder == RECORD_TYPE)
6261 pedwarn ("implicit conversion of signature pointer to type `%s'",
6262 type_as_string (type, 0));
6264 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6266 /* Const and volatile mean something different for function types,
6267 so the usual warnings are not appropriate. */
6268 else if ((TREE_CODE (ttr) != FUNCTION_TYPE && TREE_CODE (ttr) != METHOD_TYPE)
6269 || (TREE_CODE (ttl) != FUNCTION_TYPE && TREE_CODE (ttl) != METHOD_TYPE))
6271 if (TREE_CODE (ttl) == OFFSET_TYPE
6272 && binfo_member (TYPE_OFFSET_BASETYPE (ttr),
6273 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl))))
6275 sorry ("%s between pointer to members converting across virtual baseclasses", errtype);
6276 return error_mark_node;
6278 if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
6281 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6282 rhstype, parmnum, fndecl);
6284 cp_pedwarn ("%s to `%T' from `%T' discards const",
6285 errtype, type, rhstype);
6287 if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
6290 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6291 rhstype, parmnum, fndecl);
6293 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6294 errtype, type, rhstype);
6298 else if (TREE_CODE (ttr) == OFFSET_TYPE
6299 && TREE_CODE (ttl) != OFFSET_TYPE)
6301 /* Normally, pointers to different type codes (other
6302 than void) are not compatible, but we perform
6303 some type instantiation if that resolves the
6304 ambiguity of (X Y::*) and (X *). */
6306 if (current_class_decl)
6308 if (TREE_CODE (rhs) == INTEGER_CST)
6310 rhs = build (PLUS_EXPR, build_pointer_type (TREE_TYPE (ttr)),
6311 current_class_decl, rhs);
6312 return convert_for_assignment (type, rhs,
6313 errtype, fndecl, parmnum);
6316 if (TREE_CODE (ttl) == METHOD_TYPE)
6317 error ("%s between pointer-to-method and pointer-to-member types",
6320 error ("%s between pointer and pointer-to-member types", errtype);
6321 return error_mark_node;
6325 int const_parity = TYPE_READONLY (type) ^ TYPE_READONLY (rhstype);
6326 int volatile_parity = TYPE_VOLATILE (type) ^ TYPE_VOLATILE (rhstype);
6327 int unsigned_parity;
6330 while (TREE_CODE (ttl) == POINTER_TYPE
6331 && TREE_CODE (ttr) == POINTER_TYPE)
6334 const_parity |= TYPE_READONLY (ttl) ^ TYPE_READONLY (ttr);
6335 volatile_parity |= TYPE_VOLATILE (ttl) ^ TYPE_VOLATILE (ttr);
6336 ttl = TREE_TYPE (ttl);
6337 ttr = TREE_TYPE (ttr);
6339 unsigned_parity = TREE_UNSIGNED (ttl) - TREE_UNSIGNED (ttr);
6340 if (unsigned_parity)
6341 if (TREE_UNSIGNED (ttl))
6342 ttr = unsigned_type (ttr);
6344 ttl = unsigned_type (ttl);
6346 if (comp_target_types (ttl, ttr, nptrs))
6351 cp_warning ("passing `%T' as argument %P of `%D' discards const",
6352 rhstype, parmnum, fndecl);
6354 cp_warning ("%s to `%T' from `%T' discards const",
6355 errtype, type, rhstype);
6357 if (volatile_parity)
6360 cp_warning ("passing `%T' as argument %P of `%D' discards volatile",
6361 rhstype, parmnum, fndecl);
6363 cp_warning ("%s to `%T' from `%T' discards volatile",
6364 errtype, type, rhstype);
6366 if (unsigned_parity > 0)
6369 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6370 rhstype, parmnum, fndecl);
6372 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6373 errtype, type, rhstype);
6375 else if (unsigned_parity < 0)
6378 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6379 rhstype, parmnum, fndecl);
6381 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6382 errtype, type, rhstype);
6385 /* C++ is not so friendly about converting function and
6386 member function pointers as C. Emit warnings here. */
6387 if (TREE_CODE (ttl) == FUNCTION_TYPE
6388 || TREE_CODE (ttl) == METHOD_TYPE)
6389 if (! comptypes (ttl, ttr, 0))
6391 warning ("conflicting function types in %s:", errtype);
6392 cp_warning ("\t`%T' != `%T'", type, rhstype);
6395 else if (TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6397 /* When does this happen? */
6398 my_friendly_abort (119);
6399 /* Conversion of a pointer-to-member type to void *. */
6400 rhs = build_unary_op (ADDR_EXPR, rhs, 0);
6401 TREE_TYPE (rhs) = type;
6404 else if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
6406 /* When does this happen? */
6407 my_friendly_abort (120);
6408 /* Conversion of a pointer-to-member type to void *. */
6409 rhs = build_unary_op (ADDR_EXPR, rhs, 0);
6410 TREE_TYPE (rhs) = type;
6416 cp_error ("passing `%T' as argument %P of `%D'",
6417 rhstype, parmnum, fndecl);
6419 cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
6420 return error_mark_node;
6423 return convert (type, rhs);
6425 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
6427 /* An explicit constant 0 can convert to a pointer,
6428 but not a 0 that results from casting or folding. */
6429 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs)))
6432 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6433 rhstype, parmnum, fndecl);
6435 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6436 errtype, type, rhstype);
6437 return convert (type, rhs);
6439 return null_pointer_node;
6441 else if (codel == INTEGER_TYPE
6442 && (coder == POINTER_TYPE
6443 || (coder == RECORD_TYPE
6444 && (IS_SIGNATURE_POINTER (rhstype)
6445 || IS_SIGNATURE_REFERENCE (rhstype)))))
6448 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6449 rhstype, parmnum, fndecl);
6451 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6452 errtype, type, rhstype);
6453 return convert (type, rhs);
6457 else if (((coder == POINTER_TYPE && TREE_CODE (rhs) == ADDR_EXPR
6458 && TREE_CODE (rhstype) == POINTER_TYPE
6459 && TREE_CODE (TREE_TYPE (rhstype)) == METHOD_TYPE)
6460 || integer_zerop (rhs)
6461 || TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6462 && TYPE_PTRMEMFUNC_P (type))
6464 /* compatible pointer to member functions. */
6465 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), rhs, 0);
6467 else if (codel == ERROR_MARK || coder == ERROR_MARK)
6468 return error_mark_node;
6470 /* This should no longer happen. References are initialized via
6471 `convert_for_initialization'. They should otherwise be
6472 bashed before coming here. */
6473 else if (codel == REFERENCE_TYPE)
6474 /* Force an abort. */
6475 my_friendly_assert (codel != REFERENCE_TYPE, 317);
6476 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))
6478 tree nrhs = build1 (NOP_EXPR, type, rhs);
6479 TREE_CONSTANT (nrhs) = TREE_CONSTANT (rhs);
6482 else if (TYPE_HAS_CONSTRUCTOR (type) || IS_AGGR_TYPE (TREE_TYPE (rhs)))
6483 return convert (type, rhs);
6485 cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
6486 return error_mark_node;
6489 /* Convert RHS to be of type TYPE. If EXP is non-zero,
6490 it is the target of the initialization.
6491 ERRTYPE is a string to use in error messages.
6493 Two major differences between the behavior of
6494 `convert_for_assignment' and `convert_for_initialization'
6495 are that references are bashed in the former, while
6496 copied in the latter, and aggregates are assigned in
6497 the former (operator=) while initialized in the
6500 If using constructor make sure no conversion operator exists, if one does
6501 exist, an ambiguity exists. */
6503 convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
6504 tree exp, type, rhs;
6510 register enum tree_code codel = TREE_CODE (type);
6511 register tree rhstype;
6512 register enum tree_code coder;
6514 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6515 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6516 if (TREE_CODE (rhs) == NOP_EXPR
6517 && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)))
6518 rhs = TREE_OPERAND (rhs, 0);
6520 if (rhs == error_mark_node
6521 || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6522 return error_mark_node;
6524 if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
6526 rhs = resolve_offset_ref (rhs);
6527 if (rhs == error_mark_node)
6528 return error_mark_node;
6529 rhstype = TREE_TYPE (rhs);
6530 coder = TREE_CODE (rhstype);
6533 if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6534 && TREE_CODE (type) != ARRAY_TYPE && TREE_CODE (type) != REFERENCE_TYPE)
6535 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6536 || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6537 rhs = default_conversion (rhs);
6539 rhstype = TREE_TYPE (rhs);
6540 coder = TREE_CODE (rhstype);
6542 if (coder == UNKNOWN_TYPE)
6544 rhs = instantiate_type (type, rhs, 1);
6545 rhstype = TREE_TYPE (rhs);
6546 coder = TREE_CODE (rhstype);
6549 if (coder == ERROR_MARK)
6550 return error_mark_node;
6553 /* This is *not* the quick way out! It is the way to disaster. */
6554 if (type == rhstype)
6558 /* We accept references to incomplete types, so we can
6559 return here before checking if RHS is of complete type. */
6561 if (codel == REFERENCE_TYPE)
6562 return convert_to_reference ((exp ? exp : error_mark_node),
6563 type, rhs, fndecl, parmnum, errtype,
6566 rhs = require_complete_type (rhs);
6567 if (rhs == error_mark_node)
6568 return error_mark_node;
6570 if (exp != 0) exp = require_complete_type (exp);
6571 if (exp == error_mark_node)
6572 return error_mark_node;
6574 if (TREE_CODE (rhstype) == REFERENCE_TYPE)
6575 rhstype = TREE_TYPE (rhstype);
6577 if (TYPE_LANG_SPECIFIC (type)
6578 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
6579 return build_signature_pointer_constructor (type, rhs);
6581 if (IS_AGGR_TYPE (type) && TYPE_NEEDS_CONSTRUCTING (type))
6583 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
6585 /* This is sufficient to perform initialization. No need,
6586 apparently, to go through X(X&) to do first-cut
6587 initialization. Return through a TARGET_EXPR so that we get
6588 cleanups if it is used. */
6589 if (TREE_CODE (rhs) == CALL_EXPR)
6591 rhs = build_cplus_new (type, rhs, 0);
6594 /* Handle the case of default parameter initialization and
6595 initialization of static variables. */
6596 else if (TREE_CODE (rhs) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (rhs))
6598 my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs, 0)) == CALL_EXPR, 318);
6601 my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 1)) == NULL_TREE, 316);
6602 TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 1))
6603 = build_unary_op (ADDR_EXPR, exp, 0);
6606 rhs = build_cplus_new (type, TREE_OPERAND (rhs, 0), 0);
6610 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)
6611 || (IS_AGGR_TYPE (rhstype) && UNIQUELY_DERIVED_FROM_P (type, rhstype)))
6613 if (TYPE_HAS_INIT_REF (type))
6615 tree init = build_method_call (exp, constructor_name_full (type),
6616 build_tree_list (NULL_TREE, rhs),
6617 TYPE_BINFO (type), LOOKUP_NORMAL);
6619 if (init == error_mark_node)
6620 return error_mark_node;
6624 exp = build_cplus_new (type, init, 0);
6628 return build (COMPOUND_EXPR, type, init, exp);
6631 /* ??? The following warnings are turned off because
6632 this is another place where the default X(X&) constructor
6634 if (TYPE_HAS_ASSIGNMENT (type))
6635 cp_warning ("bitwise copy: `%T' defines operator=", type);
6637 if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
6638 rhs = convert_from_reference (rhs);
6639 if (type != rhstype)
6641 tree nrhs = build1 (NOP_EXPR, type, rhs);
6642 TREE_CONSTANT (nrhs) = TREE_CONSTANT (rhs);
6648 return convert (type, rhs);
6651 if (type == TREE_TYPE (rhs))
6653 if (TREE_READONLY_DECL_P (rhs))
6654 rhs = decl_constant_value (rhs);
6658 return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
6661 /* Expand an ASM statement with operands, handling output operands
6662 that are not variables or INDIRECT_REFS by transforming such
6663 cases into cases that expand_asm_operands can handle.
6665 Arguments are same as for expand_asm_operands.
6667 We don't do default conversions on all inputs, because it can screw
6668 up operands that are expected to be in memory. */
6671 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6672 tree string, outputs, inputs, clobbers;
6677 int noutputs = list_length (outputs);
6679 /* o[I] is the place that output number I should be written. */
6680 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6683 /* Record the contents of OUTPUTS before it is modified. */
6684 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6685 o[i] = TREE_VALUE (tail);
6687 /* Generate the ASM_OPERANDS insn;
6688 store into the TREE_VALUEs of OUTPUTS some trees for
6689 where the values were actually stored. */
6690 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6692 /* Copy all the intermediate outputs into the specified outputs. */
6693 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6695 if (o[i] != TREE_VALUE (tail))
6697 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6698 const0_rtx, VOIDmode, 0);
6701 /* Detect modification of read-only values.
6702 (Otherwise done by build_modify_expr.) */
6705 tree type = TREE_TYPE (o[i]);
6706 if (TYPE_READONLY (type)
6707 || ((TREE_CODE (type) == RECORD_TYPE
6708 || TREE_CODE (type) == UNION_TYPE)
6709 && C_TYPE_FIELDS_READONLY (type)))
6710 readonly_error (o[i], "modification by `asm'", 1);
6714 /* Those MODIFY_EXPRs could do autoincrements. */
6718 /* Expand a C `return' statement.
6719 RETVAL is the expression for what to return,
6720 or a null pointer for `return;' with no value.
6722 C++: upon seeing a `return', we must call destructors on all
6723 variables in scope which had constructors called on them.
6724 This means that if in a destructor, the base class destructors
6725 must be called before returning.
6727 The RETURN statement in C++ has initialization semantics. */
6730 c_expand_return (retval)
6733 extern struct nesting *cond_stack, *loop_stack, *case_stack;
6734 extern tree dtor_label, ctor_label;
6735 tree result = DECL_RESULT (current_function_decl);
6736 tree valtype = TREE_TYPE (result);
6737 register int use_temp = 0;
6738 int returns_value = 1;
6740 if (TREE_THIS_VOLATILE (current_function_decl))
6741 warning ("function declared `noreturn' has a `return' statement");
6743 if (retval == error_mark_node)
6745 current_function_returns_null = 1;
6749 if (retval == NULL_TREE)
6751 /* A non-named return value does not count. */
6753 /* Can't just return from a destructor. */
6756 expand_goto (dtor_label);
6760 if (DECL_CONSTRUCTOR_P (current_function_decl))
6761 retval = current_class_decl;
6762 else if (DECL_NAME (result) != NULL_TREE
6763 && TREE_CODE (valtype) != VOID_TYPE)
6767 current_function_returns_null = 1;
6769 if (valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE)
6771 if (DECL_NAME (DECL_RESULT (current_function_decl)) == NULL_TREE)
6773 pedwarn ("`return' with no value, in function returning non-void");
6774 /* Clear this, so finish_function won't say that we
6775 reach the end of a non-void function (which we don't,
6776 we gave a return!). */
6777 current_function_returns_null = 0;
6781 expand_null_return ();
6785 else if (DECL_CONSTRUCTOR_P (current_function_decl)
6786 && retval != current_class_decl)
6788 error ("return from a constructor: use `this = ...' instead");
6789 retval = current_class_decl;
6792 if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
6794 current_function_returns_null = 1;
6795 /* We do this here so we'll avoid a warning about how the function
6796 "may or may not return a value" in finish_function. */
6800 pedwarn ("`return' with a value, in function returning void");
6801 expand_return (retval);
6803 /* Add some useful error checking for C++. */
6804 else if (TREE_CODE (valtype) == REFERENCE_TYPE)
6806 tree whats_returned;
6807 tree tmp_result = result;
6809 /* Don't initialize directly into a non-BLKmode retval, since that
6810 could lose when being inlined by another caller. (GCC can't
6811 read the function return register in an inline function when
6812 the return value is being ignored). */
6813 if (result && TYPE_MODE (TREE_TYPE (tmp_result)) != BLKmode)
6816 /* convert to reference now, so we can give error if we
6817 return an reference to a non-lvalue. */
6818 retval = convert_for_initialization (tmp_result, valtype, retval,
6819 LOOKUP_NORMAL, "return",
6822 /* Sort through common things to see what it is
6823 we are returning. */
6824 whats_returned = retval;
6825 if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6827 whats_returned = TREE_OPERAND (whats_returned, 1);
6828 if (TREE_CODE (whats_returned) == ADDR_EXPR)
6829 whats_returned = TREE_OPERAND (whats_returned, 0);
6831 if (TREE_CODE (whats_returned) == ADDR_EXPR)
6833 whats_returned = TREE_OPERAND (whats_returned, 0);
6834 while (TREE_CODE (whats_returned) == NEW_EXPR
6835 || TREE_CODE (whats_returned) == TARGET_EXPR
6836 || TREE_CODE (whats_returned) == WITH_CLEANUP_EXPR)
6837 /* Get the target. */
6838 whats_returned = TREE_OPERAND (whats_returned, 0);
6841 if (TREE_CODE (whats_returned) == VAR_DECL && DECL_NAME (whats_returned))
6843 if (TEMP_NAME_P (DECL_NAME (whats_returned)))
6844 warning ("reference to non-lvalue returned");
6845 else if (! TREE_STATIC (whats_returned)
6846 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned)))
6847 cp_warning_at ("reference to local variable `%D' returned", whats_returned);
6850 else if (TREE_CODE (retval) == ADDR_EXPR)
6852 tree whats_returned = TREE_OPERAND (retval, 0);
6854 if (TREE_CODE (whats_returned) == VAR_DECL
6855 && DECL_NAME (whats_returned)
6856 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned))
6857 && !TREE_STATIC (whats_returned))
6858 cp_warning_at ("address of local variable `%D' returned", whats_returned);
6861 /* Now deal with possible C++ hair:
6862 (1) Compute the return value.
6863 (2) If there are aggregate values with destructors which
6864 must be cleaned up, clean them (taking care
6865 not to clobber the return value).
6866 (3) If an X(X&) constructor is defined, the return
6867 value must be returned via that. */
6869 if (retval == result
6870 /* Watch out for constructors, which "return" aggregates
6871 via initialization, but which otherwise "return" a pointer. */
6872 || DECL_CONSTRUCTOR_P (current_function_decl))
6874 /* This is just an error--it's already been reported. */
6875 if (TYPE_SIZE (valtype) == NULL_TREE)
6878 if (TYPE_MODE (valtype) != BLKmode
6879 && any_pending_cleanups (1))
6881 retval = get_temp_regvar (valtype, retval);
6882 use_temp = obey_regdecls;
6885 else if (IS_AGGR_TYPE (valtype) && TYPE_NEEDS_CONSTRUCTING (valtype))
6887 /* Throw away the cleanup that `build_functional_cast' gave us. */
6888 if (TREE_CODE (retval) == WITH_CLEANUP_EXPR
6889 && TREE_CODE (TREE_OPERAND (retval, 0)) == TARGET_EXPR)
6890 retval = TREE_OPERAND (retval, 0);
6891 expand_aggr_init (result, retval, 0);
6892 DECL_INITIAL (result) = NULL_TREE;
6897 if (TYPE_MODE (valtype) == VOIDmode)
6899 if (TYPE_MODE (TREE_TYPE (result)) != VOIDmode
6900 && warn_return_type)
6901 warning ("return of void value in function returning non-void");
6902 expand_expr_stmt (retval);
6906 else if (TYPE_MODE (valtype) != BLKmode
6907 && any_pending_cleanups (1))
6909 retval = get_temp_regvar (valtype, retval);
6910 use_temp = obey_regdecls;
6915 retval = convert_for_initialization (result, valtype, retval,
6917 "return", NULL_TREE, 0);
6918 DECL_INITIAL (result) = NULL_TREE;
6920 if (retval == error_mark_node)
6926 if (retval != NULL_TREE
6927 && TREE_CODE_CLASS (TREE_CODE (retval)) == 'd'
6928 && cond_stack == 0 && loop_stack == 0 && case_stack == 0)
6929 current_function_return_value = retval;
6933 /* Everything's great--RETVAL is in RESULT. */
6934 if (original_result_rtx)
6935 store_expr (result, original_result_rtx, 0);
6936 else if (retval && retval != result)
6938 /* Clear this out so the later call to decl_function_context
6939 won't end up bombing on us. */
6940 if (DECL_CONTEXT (result) == error_mark_node)
6941 DECL_CONTEXT (result) = NULL_TREE;
6942 /* Here is where we finally get RETVAL into RESULT.
6943 `expand_return' does the magic of protecting
6944 RESULT from cleanups. */
6945 retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6946 TREE_SIDE_EFFECTS (retval) = 1;
6947 expand_return (retval);
6950 expand_return (result);
6952 use_variable (DECL_RTL (result));
6953 if (ctor_label && TREE_CODE (ctor_label) != ERROR_MARK)
6954 expand_goto (ctor_label);
6956 expand_null_return ();
6960 /* We may still need to put RETVAL into RESULT. */
6961 result = DECL_RESULT (current_function_decl);
6962 if (original_result_rtx)
6964 /* Here we have a named return value that went
6965 into memory. We can compute RETVAL into that. */
6967 expand_assignment (result, retval, 0, 0);
6969 store_expr (result, original_result_rtx, 0);
6970 result = make_tree (TREE_TYPE (result), original_result_rtx);
6972 else if (ctor_label && TREE_CODE (ctor_label) != ERROR_MARK)
6974 /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do. */
6975 expand_goto (ctor_label);
6979 /* Here is where we finally get RETVAL into RESULT.
6980 `expand_return' does the magic of protecting
6981 RESULT from cleanups. */
6982 result = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6983 TREE_SIDE_EFFECTS (result) = 1;
6984 expand_return (result);
6986 else if (TYPE_MODE (TREE_TYPE (result)) != VOIDmode)
6987 expand_return (result);
6990 current_function_returns_value = returns_value;
6991 if (original_result_rtx)
6992 use_variable (original_result_rtx);
6994 use_variable (DECL_RTL (DECL_RESULT (current_function_decl)));
6996 /* One way to clear out cleanups that EXPR might
6997 generate. Note that this code will really be
6998 dead code, but that is ok--cleanups that were
6999 needed were handled by the magic of `return'. */
7000 expand_cleanups_to (NULL_TREE);
7003 /* Start a C switch statement, testing expression EXP.
7004 Return EXP if it is valid, an error node otherwise. */
7007 c_expand_start_case (exp)
7011 register enum tree_code code;
7013 /* Convert from references, etc. */
7014 exp = default_conversion (exp);
7015 type = TREE_TYPE (exp);
7016 code = TREE_CODE (type);
7018 if (IS_AGGR_TYPE_CODE (code))
7019 exp = build_type_conversion (CONVERT_EXPR, integer_type_node, exp, 1);
7021 if (exp == NULL_TREE)
7023 error ("switch quantity not an integer");
7024 exp = error_mark_node;
7026 type = TREE_TYPE (exp);
7027 code = TREE_CODE (type);
7029 if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
7031 error ("switch quantity not an integer");
7032 exp = error_mark_node;
7038 exp = default_conversion (exp);
7039 type = TREE_TYPE (exp);
7040 index = get_unwidened (exp, 0);
7041 /* We can't strip a conversion from a signed type to an unsigned,
7042 because if we did, int_fits_type_p would do the wrong thing
7043 when checking case values for being in range,
7044 and it's too hard to do the right thing. */
7045 if (TREE_UNSIGNED (TREE_TYPE (exp))
7046 == TREE_UNSIGNED (TREE_TYPE (index)))
7050 expand_start_case (1, exp, type, "switch statement");