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 ();
51 extern rtx original_result_rtx
;
53 /* Return the target type of TYPE, which meas return T for:
54 T*, T&, T[], T (...), and otherwise, just T. */
60 if (TREE_CODE (type
) == REFERENCE_TYPE
)
61 type
= TREE_TYPE (type
);
62 while (TREE_CODE (type
) == POINTER_TYPE
63 || TREE_CODE (type
) == ARRAY_TYPE
64 || TREE_CODE (type
) == FUNCTION_TYPE
65 || TREE_CODE (type
) == METHOD_TYPE
66 || TREE_CODE (type
) == OFFSET_TYPE
)
67 type
= TREE_TYPE (type
);
71 /* Do `exp = require_complete_type (exp);' to make sure exp
72 does not have an incomplete type. (That includes void types.) */
75 require_complete_type (value
)
78 tree type
= TREE_TYPE (value
);
80 /* First, detect a valid value with a complete type. */
81 if (TYPE_SIZE (type
) != 0
82 && type
!= void_type_node
83 && ! (TYPE_LANG_SPECIFIC (type
)
84 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
85 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
88 /* If we see X::Y, we build an OFFSET_TYPE which has
89 not been laid out. Try to avoid an error by interpreting
90 it as this->X::Y, if reasonable. */
91 if (TREE_CODE (value
) == OFFSET_REF
93 && TREE_OPERAND (value
, 0) == C_C_D
)
95 tree base
, member
= TREE_OPERAND (value
, 1);
96 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
97 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
98 base
= convert_pointer_to (basetype
, current_class_decl
);
99 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
100 build_indirect_ref (base
, NULL_PTR
), member
);
101 return require_complete_type (value
);
104 incomplete_type_error (value
, type
);
105 return error_mark_node
;
108 /* Return truthvalue of whether type of EXP is instantiated. */
113 return (TREE_CODE (exp
) == TREE_LIST
114 || TREE_TYPE (exp
) == unknown_type_node
115 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
116 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
119 /* Return truthvalue of whether T is function (or pfn) type. */
124 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
125 || (TREE_CODE (t
) == POINTER_TYPE
126 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
127 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
130 /* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
131 does not have an uninstantiated type.
132 TYPE is type to instantiate with, if uninstantiated. */
134 require_instantiated_type (type
, exp
, errval
)
135 tree type
, exp
, errval
;
137 if (TREE_TYPE (exp
) == NULL_TREE
)
139 error ("argument list may not have an initializer list");
143 if (TREE_TYPE (exp
) == unknown_type_node
144 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
145 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
))
147 exp
= instantiate_type (type
, exp
, 1);
148 if (TREE_TYPE (exp
) == error_mark_node
)
154 /* Return a variant of TYPE which has all the type qualifiers of LIKE
155 as well as those of TYPE. */
158 qualify_type (type
, like
)
161 int constflag
= TYPE_READONLY (type
) || TYPE_READONLY (like
);
162 int volflag
= TYPE_VOLATILE (type
) || TYPE_VOLATILE (like
);
163 /* @@ Must do member pointers here. */
164 return cp_build_type_variant (type
, constflag
, volflag
);
167 /* Return the common type of two parameter lists.
168 We assume that comptypes has already been done and returned 1;
169 if that isn't so, this may crash.
171 As an optimization, free the space we allocate if the parameter
172 lists are already common. */
178 tree oldargs
= p1
, newargs
, n
;
181 char *first_obj
= (char *) oballoc (0);
183 len
= list_length (p1
);
184 newargs
= tree_last (p1
);
186 if (newargs
== void_list_node
)
195 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
200 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
202 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
204 /* We used to give a warning here that advised about a default
205 argument being given in the prototype but not in the function's
206 declaration. It's best not to bother. */
207 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
210 else if (! TREE_PURPOSE (p1
))
212 if (TREE_PURPOSE (p2
))
214 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
220 int cmp
= simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
));
222 my_friendly_abort (111);
225 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
227 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
230 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
233 TREE_VALUE (n
) = TREE_VALUE (p1
);
244 /* Return the common type of two types.
245 We assume that comptypes has already been done and returned 1;
246 if that isn't so, this may crash.
248 This is the type for the result of most arithmetic operations
249 if the operands have the given two types.
251 We do not deal with enumeral types here because they have already been
252 converted to integer types. */
258 register enum tree_code code1
;
259 register enum tree_code code2
;
262 /* Save time if the two types are the same. */
264 if (t1
== t2
) return t1
;
266 /* If one type is nonsense, use the other. */
267 if (t1
== error_mark_node
)
269 if (t2
== error_mark_node
)
272 /* Merge the attributes */
274 { register tree a1
, a2
;
275 a1
= TYPE_ATTRIBUTES (t1
);
276 a2
= TYPE_ATTRIBUTES (t2
);
278 /* Either one unset? Take the set one. */
280 if (!(attributes
= a1
))
283 /* One that completely contains the other? Take it. */
285 else if (a2
&& !attribute_list_contained (a1
, a2
))
286 if (attribute_list_contained (a2
, a1
))
290 /* Pick the longest list, and hang on the other
293 if (list_length (a1
) < list_length (a2
))
294 attributes
= a2
, a2
= a1
;
296 for (; a2
; a2
= TREE_CHAIN (a2
))
297 if (!value_member (attributes
, a2
))
300 TREE_CHAIN (a1
) = attributes
;
306 /* Treat an enum type as the unsigned integer type of the same width. */
308 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
309 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
310 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
311 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
313 code1
= TREE_CODE (t1
);
314 code2
= TREE_CODE (t2
);
320 /* If only one is real, use it as the result. */
322 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
323 return build_type_attribute_variant (t1
, attributes
);
325 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
326 return build_type_attribute_variant (t2
, attributes
);
328 /* Both real or both integers; use the one with greater precision. */
330 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
331 return build_type_attribute_variant (t1
, attributes
);
332 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
333 return build_type_attribute_variant (t2
, attributes
);
335 /* Same precision. Prefer longs to ints even when same size. */
337 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
338 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
339 return build_type_attribute_variant (long_unsigned_type_node
,
342 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
343 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
345 /* But preserve unsignedness from the other type,
346 since long cannot hold all the values of an unsigned int. */
347 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
348 t1
= long_unsigned_type_node
;
350 t1
= long_integer_type_node
;
351 return build_type_attribute_variant (t1
, attributes
);
354 /* Otherwise prefer the unsigned one. */
356 if (TREE_UNSIGNED (t1
))
357 return build_type_attribute_variant (t1
, attributes
);
359 return build_type_attribute_variant (t2
, attributes
);
363 /* For two pointers, do this recursively on the target type,
364 and combine the qualifiers of the two types' targets. */
365 /* This code was turned off; I don't know why.
366 But ANSI C++ specifies doing this with the qualifiers.
367 So I turned it on again. */
369 tree target
= common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1
)),
370 TYPE_MAIN_VARIANT (TREE_TYPE (t2
)));
372 = TYPE_READONLY (TREE_TYPE (t1
)) || TYPE_READONLY (TREE_TYPE (t2
));
374 = TYPE_VOLATILE (TREE_TYPE (t1
)) || TYPE_VOLATILE (TREE_TYPE (t2
));
375 target
= cp_build_type_variant (target
, constp
, volatilep
);
376 if (code1
== POINTER_TYPE
)
377 t1
= build_pointer_type (target
);
379 t1
= build_reference_type (target
);
380 return build_type_attribute_variant (t1
, attributes
);
384 t1
= build_pointer_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
385 return build_type_attribute_variant (t1
, attributes
);
388 t1
= build_reference_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
389 return build_type_attribute_variant (t1
, attributes
);
394 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
395 /* Save space: see if the result is identical to one of the args. */
396 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
397 return build_type_attribute_variant (t1
, attributes
);
398 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
399 return build_type_attribute_variant (t2
, attributes
);
400 /* Merge the element types, and have a size if either arg has one. */
401 t1
= build_array_type (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
402 return build_type_attribute_variant (t1
, attributes
);
406 /* Function types: prefer the one that specified arg types.
407 If both do, merge the arg types. Also merge the return types. */
409 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
410 tree p1
= TYPE_ARG_TYPES (t1
);
411 tree p2
= TYPE_ARG_TYPES (t2
);
414 /* Save space: see if the result is identical to one of the args. */
415 if (valtype
== TREE_TYPE (t1
) && ! p2
)
416 return build_type_attribute_variant (t1
, attributes
);
417 if (valtype
== TREE_TYPE (t2
) && ! p1
)
418 return build_type_attribute_variant (t2
, attributes
);
420 /* Simple way if one arg fails to specify argument types. */
421 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
423 rval
= build_function_type (valtype
, p2
);
424 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
425 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
426 return build_type_attribute_variant (rval
, attributes
);
428 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
429 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
431 rval
= build_function_type (valtype
, p1
);
433 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
434 return build_type_attribute_variant (rval
, attributes
);
437 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
438 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
439 return build_type_attribute_variant (rval
, attributes
);
444 my_friendly_assert (TYPE_MAIN_VARIANT (t1
) == t1
445 && TYPE_MAIN_VARIANT (t2
) == t2
, 306);
447 if (! binfo_or_else (t1
, t2
))
448 compiler_error ("common_type called with uncommon aggregate types");
449 return build_type_attribute_variant (t1
, attributes
);
452 if (comptypes (TYPE_METHOD_BASETYPE (t1
), TYPE_METHOD_BASETYPE (t2
), 1)
453 && TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
455 /* Get this value the long way, since TYPE_METHOD_BASETYPE
456 is just the main variant of this. */
457 tree basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
460 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
462 /* If this was a member function type, get back to the
463 original type of type member function (i.e., without
464 the class instance variable up front. */
465 t1
= build_function_type (TREE_TYPE (t1
), TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
466 t2
= build_function_type (TREE_TYPE (t2
), TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
467 t3
= common_type (t1
, t2
);
468 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
), TYPE_ARG_TYPES (t3
));
469 t1
= build_exception_variant (basetype
, t3
, raises
);
472 compiler_error ("common_type called with uncommon method types");
474 return build_type_attribute_variant (t1
, attributes
);
477 if (TYPE_OFFSET_BASETYPE (t1
) == TYPE_OFFSET_BASETYPE (t2
)
478 && TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
480 tree basetype
= TYPE_OFFSET_BASETYPE (t1
);
481 t1
= build_offset_type (basetype
,
482 common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
485 compiler_error ("common_type called with uncommon member types");
487 /* ... falls through ... */
490 return build_type_attribute_variant (t1
, attributes
);
494 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
496 compexcepttypes (t1
, t2
, strict
)
500 return TYPE_RAISES_EXCEPTIONS (t1
) == TYPE_RAISES_EXCEPTIONS (t2
);
504 comp_array_types (cmp
, t1
, t2
, strict
)
505 register int (*cmp
)();
509 tree d1
= TYPE_DOMAIN (t1
);
510 tree d2
= TYPE_DOMAIN (t2
);
512 /* Target types must match incl. qualifiers. */
513 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
514 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)))
517 /* Sizes must match unless one is missing or variable. */
518 if (d1
== 0 || d2
== 0 || d1
== d2
519 || TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
520 || TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
521 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
522 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
)
525 return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1
))
526 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2
)))
527 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1
))
528 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2
)))
529 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1
))
530 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2
)))
531 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1
))
532 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2
))));
535 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
536 or various other operations. This is what ANSI C++ speaks of as
539 For C++: argument STRICT says we should be strict about this
542 2 : strict, except that if one type is a reference and
543 the other is not, compare the target type of the
544 reference to the type that's not a reference (ARM, p308).
545 This is used for checking for illegal overloading.
546 1 : strict (compared according to ANSI C)
547 This is used for checking whether two function decls match.
548 0 : <= (compared according to C++)
549 -1: <= or >= (relaxed)
551 Otherwise, pointers involving base classes and derived classes
552 can be mixed as legal: i.e. a pointer to a base class may be assigned
553 to a pointer to one of its derived classes, as per C++. A pointer to
554 a derived class may be passed as a parameter to a function expecting a
555 pointer to a base classes. These allowances do not commute. In this
556 case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
557 be the derived class. */
559 comptypes (type1
, type2
, strict
)
563 register tree t1
= type1
;
564 register tree t2
= type2
;
567 /* Suppress errors caused by previously reported errors */
572 /* This should never happen. */
573 my_friendly_assert (t1
!= error_mark_node
, 307);
575 if (t2
== error_mark_node
)
580 /* Treat an enum type as the unsigned integer type of the same width. */
582 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
583 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
584 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
585 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
591 /* Different classes of types can't be compatible. */
593 if (TREE_CODE (t1
) != TREE_CODE (t2
))
596 && ((TREE_CODE (t1
) == REFERENCE_TYPE
)
597 ^ (TREE_CODE (t2
) == REFERENCE_TYPE
)))
599 if (TREE_CODE (t1
) == REFERENCE_TYPE
)
600 return comptypes (TREE_TYPE (t1
), t2
, 1);
601 return comptypes (t1
, TREE_TYPE (t2
), 1);
609 /* Qualifiers must match. */
611 if (TYPE_READONLY (t1
) != TYPE_READONLY (t2
))
613 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
616 /* Allow for two different type nodes which have essentially the same
617 definition. Note that we already checked for equality of the type
618 type qualifiers (just above). */
620 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
623 #ifdef COMP_TYPE_ATTRIBUTES
624 if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
627 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
631 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
634 switch (TREE_CODE (t1
))
643 val
= (comptypes (TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t1
)),
644 TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t2
)), strict
)
645 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
649 if (! compexcepttypes (t1
, t2
, strict
))
652 /* This case is anti-symmetrical!
653 One can pass a base member (or member function)
654 to something expecting a derived member (or member function),
655 but not vice-versa! */
657 val
= (comptypes (TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t2
)),
658 TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t1
)), strict
)
659 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
660 && compparms (TREE_CHAIN (TYPE_ARG_TYPES (t1
)),
661 TREE_CHAIN (TYPE_ARG_TYPES (t2
)), strict
));
675 if (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
)
679 rval
= t1
== t2
|| UNIQUELY_DERIVED_FROM_P (t1
, t2
);
688 val
= UNIQUELY_DERIVED_FROM_P (t2
, t1
);
695 val
= comptypes (t1
, t2
, strict
);
699 if (! compexcepttypes (t1
, t2
, strict
))
702 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
703 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
704 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
), strict
));
708 /* Target types must match incl. qualifiers. */
709 val
= comp_array_types (comptypes
, t1
, t2
, strict
);
712 case TEMPLATE_TYPE_PARM
:
715 case UNINSTANTIATED_P_TYPE
:
716 return UPT_TEMPLATE (t1
) == UPT_TEMPLATE (t2
);
718 return attrval
== 2 && val
== 1 ? 2 : val
;
721 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
722 ignoring their qualifiers.
724 NPTRS is the number of pointers we can strip off and keep cool.
725 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
726 but to not permit B** to convert to A**. */
729 comp_target_types (ttl
, ttr
, nptrs
)
733 ttl
= TYPE_MAIN_VARIANT (ttl
);
734 ttr
= TYPE_MAIN_VARIANT (ttr
);
738 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
741 if (TREE_CODE (ttr
) == POINTER_TYPE
)
743 if (TREE_CODE (TREE_TYPE (ttl
)) == POINTER_TYPE
744 || TREE_CODE (TREE_TYPE (ttl
)) == ARRAY_TYPE
)
745 return comp_ptr_ttypes (TREE_TYPE (ttl
), TREE_TYPE (ttr
));
747 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
- 1);
750 if (TREE_CODE (ttr
) == REFERENCE_TYPE
)
751 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
752 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
753 return comp_array_types (comp_target_types
, ttl
, ttr
, 0);
754 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
755 if (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
756 switch (comp_target_parms (TYPE_ARG_TYPES (ttl
), TYPE_ARG_TYPES (ttr
), 1))
763 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
767 my_friendly_abort (112);
773 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
775 /* Contravariance: we can assign a pointer to base member to a pointer
776 to derived member. Note difference from simple pointer case, where
777 we can pass a pointer to derived to a pointer to base. */
778 if (comptypes (TYPE_OFFSET_BASETYPE (ttr
), TYPE_OFFSET_BASETYPE (ttl
), 0))
779 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
780 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl
), TYPE_OFFSET_BASETYPE (ttr
), 0)
781 && comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
783 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
788 else if (IS_AGGR_TYPE (ttl
))
792 return comptypes (TYPE_POINTER_TO (ttl
), TYPE_POINTER_TO (ttr
), 0);
798 /* If two types share a common base type, return that basetype.
799 If there is not a unique most-derived base type, this function
800 returns ERROR_MARK_NODE. */
802 common_base_type (tt1
, tt2
)
805 tree best
= NULL_TREE
, tmp
;
808 /* If one is a baseclass of another, that's good enough. */
809 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
811 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
815 /* If they share a virtual baseclass, that's good enough. */
816 for (tmp
= CLASSTYPE_VBASECLASSES (tt1
); tmp
; tmp
= TREE_CHAIN (tmp
))
818 if (binfo_member (BINFO_TYPE (tmp
), CLASSTYPE_VBASECLASSES (tt2
)))
819 return BINFO_TYPE (tmp
);
823 /* Otherwise, try to find a unique baseclass of TT1
824 that is shared by TT2, and follow that down. */
825 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
827 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
828 tree trial
= common_base_type (basetype
, tt2
);
831 if (trial
== error_mark_node
)
833 if (best
== NULL_TREE
)
835 else if (best
!= trial
)
836 return error_mark_node
;
841 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
843 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
844 tree trial
= common_base_type (tt1
, basetype
);
847 if (trial
== error_mark_node
)
849 if (best
== NULL_TREE
)
851 else if (best
!= trial
)
852 return error_mark_node
;
858 /* Subroutines of `comptypes'. */
860 /* Return 1 if two parameter type lists PARMS1 and PARMS2
861 are equivalent in the sense that functions with those parameter types
862 can have equivalent types.
863 If either list is empty, we win.
864 Otherwise, the two lists must be equivalent, element by element.
866 C++: See comment above about TYPE1, TYPE2, STRICT.
867 If STRICT == 3, it means checking is strict, but do not compare
868 default parameter values. */
870 compparms (parms1
, parms2
, strict
)
874 register tree t1
= parms1
, t2
= parms2
;
876 /* An unspecified parmlist matches any specified parmlist
877 whose argument types don't need default promotions. */
879 if (strict
<= 0 && t1
== 0)
880 return self_promoting_args_p (t2
);
881 if (strict
< 0 && t2
== 0)
882 return self_promoting_args_p (t1
);
886 if (t1
== 0 && t2
== 0)
888 /* If one parmlist is shorter than the other,
889 they fail to match, unless STRICT is <= 0. */
890 if (t1
== 0 || t2
== 0)
897 return t1
&& TREE_PURPOSE (t1
);
899 if (! comptypes (TREE_VALUE (t2
), TREE_VALUE (t1
), strict
))
904 return t2
== void_list_node
&& TREE_PURPOSE (t1
);
905 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
908 /* Default parms are not part of the type of a function. */
909 if (strict
!= 3 && TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
911 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
913 my_friendly_abort (113);
919 t1
= TREE_CHAIN (t1
);
920 t2
= TREE_CHAIN (t2
);
924 /* This really wants return whether or not parameter type lists
925 would make their owning functions assignment compatible or not. */
927 comp_target_parms (parms1
, parms2
, strict
)
931 register tree t1
= parms1
, t2
= parms2
;
932 int warn_contravariance
= 0;
934 /* An unspecified parmlist matches any specified parmlist
935 whose argument types don't need default promotions.
936 @@@ see 13.3.3 for a counterexample... */
938 if (t1
== 0 && t2
!= 0)
940 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
942 return self_promoting_args_p (t2
);
945 return self_promoting_args_p (t1
);
947 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
951 /* If one parmlist is shorter than the other,
952 they fail to match, unless STRICT is <= 0. */
953 if (t1
== 0 || t2
== 0)
958 return 1 + warn_contravariance
;
959 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
961 p1
= TREE_VALUE (t1
);
962 p2
= TREE_VALUE (t2
);
966 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
967 || (TREE_CODE (p1
) == REFERENCE_TYPE
&& TREE_CODE (p2
) == REFERENCE_TYPE
))
970 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
971 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
974 /* The following is wrong for contravariance,
975 but many programs depend on it. */
976 if (TREE_TYPE (p1
) == void_type_node
)
978 if (TREE_TYPE (p2
) == void_type_node
)
980 warn_contravariance
= 1;
983 if (IS_AGGR_TYPE (TREE_TYPE (p1
)))
985 if (comptypes (p2
, p1
, 0) == 0)
987 if (comptypes (p1
, p2
, 0) != 0)
988 warn_contravariance
= 1;
995 /* Note backwards order due to contravariance. */
996 if (comp_target_types (p2
, p1
, 1) == 0)
998 if (comp_target_types (p1
, p2
, 1))
1000 warn_contravariance
= 1;
1006 /* What good do these cases do? */
1008 return p2
== void_type_node
&& TREE_PURPOSE (t1
);
1009 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
1012 /* Target types are compatible--just make sure that if
1013 we use parameter lists, that they are ok as well. */
1014 if (TREE_CODE (p1
) == FUNCTION_TYPE
|| TREE_CODE (p1
) == METHOD_TYPE
)
1015 switch (comp_target_parms (TYPE_ARG_TYPES (p1
),
1016 TYPE_ARG_TYPES (p2
),
1024 warn_contravariance
= 1;
1027 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1029 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1031 my_friendly_abort (114);
1036 return 1 + warn_contravariance
;
1039 /* Return 1 if PARMS specifies a fixed number of parameters
1040 and none of their types is affected by default promotions. */
1043 self_promoting_args_p (parms
)
1047 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1049 register tree type
= TREE_VALUE (t
);
1051 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1054 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1060 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1066 /* Return an unsigned type the same as TYPE in other respects.
1068 C++: must make these work for type variants as well. */
1071 unsigned_type (type
)
1074 tree type1
= TYPE_MAIN_VARIANT (type
);
1075 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1076 return unsigned_char_type_node
;
1077 if (type1
== integer_type_node
)
1078 return unsigned_type_node
;
1079 if (type1
== short_integer_type_node
)
1080 return short_unsigned_type_node
;
1081 if (type1
== long_integer_type_node
)
1082 return long_unsigned_type_node
;
1083 if (type1
== long_long_integer_type_node
)
1084 return long_long_unsigned_type_node
;
1088 /* Return a signed type the same as TYPE in other respects. */
1094 tree type1
= TYPE_MAIN_VARIANT (type
);
1095 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1096 return signed_char_type_node
;
1097 if (type1
== unsigned_type_node
)
1098 return integer_type_node
;
1099 if (type1
== short_unsigned_type_node
)
1100 return short_integer_type_node
;
1101 if (type1
== long_unsigned_type_node
)
1102 return long_integer_type_node
;
1103 if (type1
== long_long_unsigned_type_node
)
1104 return long_long_integer_type_node
;
1108 /* Return a type the same as TYPE except unsigned or
1109 signed according to UNSIGNEDP. */
1112 signed_or_unsigned_type (unsignedp
, type
)
1116 if (! INTEGRAL_TYPE_P (type
))
1118 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1119 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1120 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1121 return unsignedp
? unsigned_type_node
: integer_type_node
;
1122 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1123 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1124 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1125 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1126 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1127 return (unsignedp
? long_long_unsigned_type_node
1128 : long_long_integer_type_node
);
1136 enum tree_code code
= TREE_CODE (type
);
1139 if (code
== FUNCTION_TYPE
)
1141 if (pedantic
|| warn_pointer_arith
)
1142 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1143 return size_int (1);
1145 if (code
== METHOD_TYPE
)
1147 if (pedantic
|| warn_pointer_arith
)
1148 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1149 return size_int (1);
1151 if (code
== VOID_TYPE
)
1153 if (pedantic
|| warn_pointer_arith
)
1154 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1155 return size_int (1);
1157 if (code
== ERROR_MARK
)
1158 return size_int (1);
1160 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1161 referenced object.'' */
1162 if (code
== REFERENCE_TYPE
)
1163 type
= TREE_TYPE (type
);
1165 /* We couldn't find anything in the ARM or the draft standard that says,
1166 one way or the other, if doing sizeof on something that doesn't have
1167 an object associated with it is correct or incorrect. For example, if
1168 you declare `struct S { char str[16]; };', and in your program do
1169 a `sizeof (S::str)', should we flag that as an error or should we give
1170 the size of it? Since it seems like a reasonable thing to do, we'll go
1171 with giving the value. */
1172 if (code
== OFFSET_TYPE
)
1173 type
= TREE_TYPE (type
);
1175 /* @@ This also produces an error for a signature ref.
1176 In that case we should be able to do better. */
1177 if (IS_SIGNATURE (type
))
1179 error ("`sizeof' applied to a signature type");
1180 return size_int (0);
1183 if (TYPE_SIZE (type
) == 0)
1185 error ("`sizeof' applied to an incomplete type");
1186 return size_int (0);
1189 /* Convert in case a char is more than one unit. */
1190 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1191 size_int (TYPE_PRECISION (char_type_node
)));
1192 /* size_binop does not put the constant in range, so do it now. */
1193 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1194 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1199 c_sizeof_nowarn (type
)
1202 enum tree_code code
= TREE_CODE (type
);
1205 if (code
== FUNCTION_TYPE
1206 || code
== METHOD_TYPE
1207 || code
== VOID_TYPE
1208 || code
== ERROR_MARK
)
1209 return size_int (1);
1210 if (code
== REFERENCE_TYPE
)
1211 type
= TREE_TYPE (type
);
1213 if (TYPE_SIZE (type
) == 0)
1216 /* ??? Tiemann, why have any diagnostic here?
1217 There is none in the corresponding function for C. */
1218 warning ("sizeof applied to an incomplete type");
1220 return size_int (0);
1223 /* Convert in case a char is more than one unit. */
1224 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1225 size_int (TYPE_PRECISION (char_type_node
)));
1226 force_fit_type (t
, 0);
1230 /* Implement the __alignof keyword: Return the minimum required
1231 alignment of TYPE, measured in bytes. */
1237 enum tree_code code
= TREE_CODE (type
);
1240 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1241 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1243 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1244 return size_int (1);
1246 /* C++: this is really correct! */
1247 if (code
== REFERENCE_TYPE
)
1248 type
= TREE_TYPE (type
);
1250 /* @@ This also produces an error for a signature ref.
1251 In that case we should be able to do better. */
1252 if (IS_SIGNATURE (type
))
1254 error ("`__alignof' applied to a signature type");
1255 return size_int (1);
1258 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1259 force_fit_type (t
, 0);
1263 /* Perform default promotions for C data used in expressions.
1264 Arrays and functions are converted to pointers;
1265 enumeral types or short or char, to int.
1266 In addition, manifest constants symbols are replaced by their values.
1268 C++: this will automatically bash references to their target type. */
1271 default_conversion (exp
)
1274 register tree type
= TREE_TYPE (exp
);
1275 register enum tree_code code
= TREE_CODE (type
);
1277 if (code
== OFFSET_TYPE
/* || TREE_CODE (exp) == OFFSET_REF */ )
1279 if (TREE_CODE (exp
) == OFFSET_REF
)
1280 return default_conversion (resolve_offset_ref (exp
));
1282 type
= TREE_TYPE (type
);
1283 code
= TREE_CODE (type
);
1286 if (code
== REFERENCE_TYPE
)
1288 exp
= convert_from_reference (exp
);
1289 type
= TREE_TYPE (exp
);
1290 code
= TREE_CODE (type
);
1293 /* Constants can be used directly unless they're not loadable. */
1294 if (TREE_CODE (exp
) == CONST_DECL
)
1295 exp
= DECL_INITIAL (exp
);
1296 /* Replace a nonvolatile const static variable with its value. */
1297 else if (TREE_READONLY_DECL_P (exp
) && DECL_MODE (exp
) != BLKmode
)
1299 exp
= decl_constant_value (exp
);
1300 type
= TREE_TYPE (exp
);
1303 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1304 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1306 if (INTEGRAL_CODE_P (code
))
1308 tree t
= type_promotes_to (type
);
1309 if (t
!= TYPE_MAIN_VARIANT (type
))
1310 return convert (t
, exp
);
1312 if (flag_traditional
1313 && TYPE_MAIN_VARIANT (type
) == float_type_node
)
1314 return convert (double_type_node
, exp
);
1315 if (code
== VOID_TYPE
)
1317 error ("void value not ignored as it ought to be");
1318 return error_mark_node
;
1320 if (code
== FUNCTION_TYPE
)
1322 return build_unary_op (ADDR_EXPR
, exp
, 0);
1324 if (code
== METHOD_TYPE
)
1326 if (TREE_CODE (exp
) == OFFSET_REF
)
1328 my_friendly_assert (TREE_CODE (TREE_OPERAND (exp
, 1)) == FUNCTION_DECL
,
1330 return build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 1), 0);
1332 return build_unary_op (ADDR_EXPR
, exp
, 0);
1334 if (code
== ARRAY_TYPE
)
1339 int constp
, volatilep
;
1341 if (TREE_CODE (exp
) == INDIRECT_REF
)
1343 /* Stripping away the INDIRECT_REF is not the right
1344 thing to do for references... */
1345 tree inner
= TREE_OPERAND (exp
, 0);
1346 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1348 inner
= build1 (CONVERT_EXPR
,
1349 build_pointer_type (TREE_TYPE (TREE_TYPE (inner
))),
1351 TREE_REFERENCE_EXPR (inner
) = 1;
1353 return convert (TYPE_POINTER_TO (TREE_TYPE (type
)), inner
);
1356 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1358 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1359 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1360 TREE_OPERAND (exp
, 0), op1
);
1364 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1366 error ("invalid use of non-lvalue array");
1367 return error_mark_node
;
1370 constp
= volatilep
= 0;
1371 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r'
1372 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
1374 constp
= TREE_READONLY (exp
);
1375 volatilep
= TREE_THIS_VOLATILE (exp
);
1378 restype
= TREE_TYPE (type
);
1379 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)
1380 || constp
|| volatilep
)
1381 restype
= cp_build_type_variant (restype
,
1382 TYPE_READONLY (type
) || constp
,
1383 TYPE_VOLATILE (type
) || volatilep
);
1384 ptrtype
= build_pointer_type (restype
);
1386 if (TREE_CODE (exp
) == VAR_DECL
)
1388 /* ??? This is not really quite correct
1389 in that the type of the operand of ADDR_EXPR
1390 is not the target type of the type of the ADDR_EXPR itself.
1391 Question is, can this lossage be avoided? */
1392 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1393 if (mark_addressable (exp
) == 0)
1394 return error_mark_node
;
1395 TREE_CONSTANT (adr
) = staticp (exp
);
1396 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1399 /* This way is better for a COMPONENT_REF since it can
1400 simplify the offset for a component. */
1401 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1402 return convert (ptrtype
, adr
);
1408 build_object_ref (datum
, basetype
, field
)
1409 tree datum
, basetype
, field
;
1412 if (datum
== error_mark_node
)
1413 return error_mark_node
;
1415 dtype
= TREE_TYPE (datum
);
1416 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1417 dtype
= TREE_TYPE (dtype
);
1418 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1420 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1421 basetype
, field
, dtype
);
1422 return error_mark_node
;
1424 else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype
)))
1426 warning ("signature name in scope resolution ignored");
1427 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1429 else if (is_aggr_typedef (basetype
, 1))
1431 tree real_basetype
= IDENTIFIER_TYPE_VALUE (basetype
);
1432 tree binfo
= binfo_or_else (real_basetype
, TREE_TYPE (datum
));
1434 return build_component_ref (build_scoped_ref (datum
, basetype
),
1437 return error_mark_node
;
1440 /* Like `build_component_ref, but uses an already found field.
1441 Must compute access for C_C_D. Otherwise, ok. */
1443 build_component_ref_1 (datum
, field
, protect
)
1447 register tree basetype
= TREE_TYPE (datum
);
1448 register enum tree_code code
= TREE_CODE (basetype
);
1451 if (code
== REFERENCE_TYPE
)
1453 datum
= convert_from_reference (datum
);
1454 basetype
= TREE_TYPE (datum
);
1455 code
= TREE_CODE (basetype
);
1458 if (! IS_AGGR_TYPE_CODE (code
))
1460 if (code
!= ERROR_MARK
)
1461 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1462 field
, datum
, basetype
);
1463 return error_mark_node
;
1466 if (TYPE_SIZE (basetype
) == 0)
1468 incomplete_type_error (0, basetype
);
1469 return error_mark_node
;
1472 /* Look up component name in the structure type definition. */
1474 if (field
== error_mark_node
)
1475 my_friendly_abort (115);
1477 if (TREE_STATIC (field
))
1482 enum access_type access
1483 = compute_access (TYPE_BINFO (current_class_type
), field
);
1485 if (access
== access_private
)
1487 cp_error ("field `%D' is private", field
);
1488 return error_mark_node
;
1490 else if (access
== access_protected
)
1492 cp_error ("field `%D' is protected", field
);
1493 return error_mark_node
;
1497 ref
= build (COMPONENT_REF
, TREE_TYPE (field
), datum
, field
);
1499 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1500 TREE_READONLY (ref
) = 1;
1501 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1502 TREE_THIS_VOLATILE (ref
) = 1;
1503 if (DECL_MUTABLE_P (field
))
1504 TREE_READONLY (ref
) = 0;
1509 /* Given a COND_EXPR in T, return it in a form that we can, for
1510 example, use as an lvalue. This code used to be in unary_complex_lvalue,
1511 but we needed it to deal with `a = (d == c) ? b : c' expressions, where
1512 we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
1513 and in build_modify_expr. The case (in particular) that led to this was
1514 with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
1516 rationalize_conditional_expr (code
, t
)
1517 enum tree_code code
;
1521 build_conditional_expr (TREE_OPERAND (t
, 0),
1522 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1523 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1527 build_component_ref (datum
, component
, basetype_path
, protect
)
1528 tree datum
, component
, basetype_path
;
1531 register tree basetype
= TREE_TYPE (datum
);
1532 register enum tree_code code
= TREE_CODE (basetype
);
1533 register tree field
= NULL
;
1536 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it. */
1537 switch (TREE_CODE (datum
))
1541 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1542 basetype_path
, protect
);
1543 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1544 TREE_OPERAND (datum
, 0), value
);
1547 return build_conditional_expr
1548 (TREE_OPERAND (datum
, 0),
1549 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1550 basetype_path
, protect
),
1551 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1552 basetype_path
, protect
));
1555 if (code
== REFERENCE_TYPE
)
1558 /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
1559 @@ Maybe that is not right. */
1560 if (TREE_REFERENCE_EXPR (datum
))
1561 datum
= build1 (INDIRECT_REF
, TREE_TYPE (basetype
), datum
);
1564 datum
= convert_from_reference (datum
);
1565 basetype
= TREE_TYPE (datum
);
1566 code
= TREE_CODE (basetype
);
1569 /* First, see if there is a field or component with name COMPONENT. */
1570 if (TREE_CODE (component
) == TREE_LIST
)
1572 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1573 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1574 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1577 if (TREE_CODE (component
) == TYPE_EXPR
)
1578 return build_component_type_expr (datum
, component
, NULL_TREE
, protect
);
1581 if (! IS_AGGR_TYPE_CODE (code
))
1583 if (code
!= ERROR_MARK
)
1584 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1585 component
, datum
, basetype
);
1586 return error_mark_node
;
1589 if (TYPE_SIZE (basetype
) == 0)
1591 incomplete_type_error (0, basetype
);
1592 return error_mark_node
;
1595 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
1597 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
1599 cp_error ("destructor specifier `%T::~%T' must have matching names",
1600 basetype
, TREE_OPERAND (component
, 0));
1601 return error_mark_node
;
1603 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1605 cp_error ("type `%T' has no destructor", basetype
);
1606 return error_mark_node
;
1608 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
1611 /* Look up component name in the structure type definition. */
1612 if (CLASSTYPE_VFIELD (basetype
)
1613 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
1614 /* Special-case this because if we use normal lookups in an ambiguous
1615 hierarchy, the compiler will abort (because vptr lookups are
1616 not supposed to be ambiguous. */
1617 field
= CLASSTYPE_VFIELD (basetype
);
1620 if (basetype_path
== NULL_TREE
)
1621 basetype_path
= TYPE_BINFO (basetype
);
1622 field
= lookup_field (basetype_path
, component
,
1623 protect
&& ! VFIELD_NAME_P (component
), 0);
1624 if (field
== error_mark_node
)
1625 return error_mark_node
;
1627 if (field
== NULL_TREE
)
1629 /* Not found as a data field, look for it as a method. If found,
1630 then if this is the only possible one, return it, else
1631 report ambiguity error. */
1632 tree fndecls
= lookup_fnfields (basetype_path
, component
, 1);
1633 if (fndecls
== error_mark_node
)
1634 return error_mark_node
;
1637 if (TREE_CHAIN (fndecls
) == NULL_TREE
1638 && DECL_CHAIN (TREE_VALUE (fndecls
)) == NULL_TREE
)
1640 enum access_type access
;
1643 /* Unique, so use this one now. */
1644 basetype
= TREE_PURPOSE (fndecls
);
1645 fndecl
= TREE_VALUE (fndecls
);
1646 access
= compute_access (TREE_PURPOSE (fndecls
), fndecl
);
1647 if (access
== access_public
)
1649 if (DECL_VINDEX (fndecl
)
1650 && ! resolves_to_fixed_type_p (datum
, 0))
1652 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1653 addr
= convert_pointer_to (DECL_CONTEXT (fndecl
), addr
);
1654 datum
= build_indirect_ref (addr
, NULL_PTR
);
1655 my_friendly_assert (datum
!= error_mark_node
, 310);
1656 fndecl
= build_vfn_ref (&addr
, datum
, DECL_VINDEX (fndecl
));
1660 if (access
== access_protected
)
1661 cp_error ("member function `%D' is protected", fndecl
);
1663 cp_error ("member function `%D' is private", fndecl
);
1664 return error_mark_node
;
1667 return build (COMPONENT_REF
, unknown_type_node
, datum
, fndecls
);
1671 if (component
== ansi_opname
[(int) TYPE_EXPR
])
1672 cp_error ("`%#T' has no such type conversion operator", basetype
);
1675 cp_error ("`%#T' has no member named `%D'", basetype
, component
);
1676 return error_mark_node
;
1678 else if (TREE_TYPE (field
) == error_mark_node
)
1679 return error_mark_node
;
1681 if (TREE_CODE (field
) != FIELD_DECL
)
1683 if (TREE_CODE (field
) == TYPE_DECL
)
1685 cp_error ("invalid use of type decl `%#D' as expression", field
);
1686 return error_mark_node
;
1688 if (DECL_RTL (field
) != 0)
1689 assemble_external (field
);
1690 TREE_USED (field
) = 1;
1695 if (DECL_FIELD_CONTEXT (field
) != basetype
1696 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
1698 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1699 if (integer_zerop (addr
))
1701 error ("invalid reference to NULL ptr, use ptr-to-member instead");
1702 return error_mark_node
;
1704 addr
= convert_pointer_to (DECL_FIELD_CONTEXT (field
), addr
);
1705 datum
= build_indirect_ref (addr
, NULL_PTR
);
1706 my_friendly_assert (datum
!= error_mark_node
, 311);
1708 ref
= fold (build (COMPONENT_REF
, TREE_TYPE (field
),
1709 break_out_cleanups (datum
), field
));
1711 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1712 TREE_READONLY (ref
) = 1;
1713 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1714 TREE_THIS_VOLATILE (ref
) = 1;
1715 if (DECL_MUTABLE_P (field
))
1716 TREE_READONLY (ref
) = 0;
1721 /* Given an expression PTR for a pointer, return an expression
1722 for the value pointed to.
1723 ERRORSTRING is the name of the operator to appear in error messages.
1725 This function may need to overload OPERATOR_FNNAME.
1726 Must also handle REFERENCE_TYPEs for C++. */
1729 build_x_indirect_ref (ptr
, errorstring
)
1733 tree rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
, NULL_TREE
);
1736 return build_indirect_ref (ptr
, errorstring
);
1740 build_indirect_ref (ptr
, errorstring
)
1744 register tree pointer
= default_conversion (ptr
);
1745 register tree type
= TREE_TYPE (pointer
);
1747 if (ptr
== current_class_decl
)
1750 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
1752 if (TREE_CODE (pointer
) == ADDR_EXPR
1753 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1754 == TREE_TYPE (type
)))
1755 return TREE_OPERAND (pointer
, 0);
1758 tree t
= TREE_TYPE (type
);
1759 register tree ref
= build1 (INDIRECT_REF
,
1760 TYPE_MAIN_VARIANT (t
), pointer
);
1762 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1763 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1764 TREE_SIDE_EFFECTS (ref
)
1765 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1769 /* `pointer' won't be an error_mark_node if we were given a
1770 pointer to member, so it's cool to check for this here. */
1771 else if (TYPE_PTRMEMFUNC_P (type
))
1772 error ("invalid use of `%s' on pointer to member function", errorstring
);
1773 else if (TREE_CODE (type
) == RECORD_TYPE
1774 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1775 error ("cannot dereference signature pointer/reference");
1776 else if (pointer
!= error_mark_node
)
1779 error ("invalid type argument of `%s'", errorstring
);
1781 error ("invalid type argument");
1783 return error_mark_node
;
1786 /* This handles expressions of the form "a[i]", which denotes
1789 This is logically equivalent in C to *(a+i), but we may do it differently.
1790 If A is a variable or a member, we generate a primitive ARRAY_REF.
1791 This avoids forcing the array out of registers, and can work on
1792 arrays that are not lvalues (for example, members of structures returned
1795 If INDEX is of some user-defined type, it must be converted to
1796 integer type. Otherwise, to make a compatible PLUS_EXPR, it
1797 will inherit the type of the array, which will be some pointer type. */
1800 build_x_array_ref (array
, index
)
1803 tree rval
= build_opfncall (ARRAY_REF
, LOOKUP_NORMAL
, array
, index
, NULL_TREE
);
1806 return build_array_ref (array
, index
);
1810 build_array_ref (array
, idx
)
1817 error ("subscript missing in array reference");
1818 return error_mark_node
;
1821 if (TREE_TYPE (array
) == error_mark_node
1822 || TREE_TYPE (idx
) == error_mark_node
)
1823 return error_mark_node
;
1825 itype
= TREE_TYPE (idx
);
1826 /* We must check here for the reference, so we can do the possible
1827 conversions immediately afterwards. */
1828 if (TREE_CODE (itype
) == REFERENCE_TYPE
)
1830 idx
= convert_from_reference (idx
);
1831 itype
= TREE_TYPE (idx
);
1834 if (IS_AGGR_TYPE (itype
))
1836 if (TYPE_HAS_INT_CONVERSION (itype
))
1837 idx
= build_type_conversion (CONVERT_EXPR
,
1838 integer_type_node
, idx
, 1);
1841 error_with_aggr_type (itype
,
1842 "type `%s' requires integer conversion for array indexing");
1843 return error_mark_node
;
1847 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
1848 && TREE_CODE (array
) != INDIRECT_REF
)
1852 /* Subscripting with type char is likely to lose
1853 on a machine where chars are signed.
1854 So warn on any machine, but optionally.
1855 Don't warn for unsigned char since that type is safe.
1856 Don't warn for signed char because anyone who uses that
1857 must have done so deliberately. */
1858 if (warn_char_subscripts
1859 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
1860 warning ("array subscript has type `char'");
1862 /* Apply default promotions *after* noticing character types. */
1863 idx
= default_conversion (idx
);
1865 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
1867 error ("array subscript is not an integer");
1868 return error_mark_node
;
1871 /* An array that is indexed by a non-constant
1872 cannot be stored in a register; we must be able to do
1873 address arithmetic on its address.
1874 Likewise an array of elements of variable size. */
1875 if (TREE_CODE (idx
) != INTEGER_CST
1876 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
1877 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1879 if (mark_addressable (array
) == 0)
1880 return error_mark_node
;
1882 /* An array that is indexed by a constant value which is not within
1883 the array bounds cannot be stored in a register either; because we
1884 would get a crash in store_bit_field/extract_bit_field when trying
1885 to access a non-existent part of the register. */
1886 if (TREE_CODE (idx
) == INTEGER_CST
1887 && TYPE_VALUES (TREE_TYPE (array
))
1888 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
1890 if (mark_addressable (array
) == 0)
1891 return error_mark_node
;
1894 /* Note in C++ we don't bother warning about subscripting a
1895 `register' array, since it's legal in C++ to take the address
1896 of something with that storage specification. */
1897 if (pedantic
&& !lvalue_p (array
))
1898 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1903 while (TREE_CODE (foo
) == COMPONENT_REF
)
1904 foo
= TREE_OPERAND (foo
, 0);
1905 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
1906 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1909 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1910 rval
= build (ARRAY_REF
, type
, array
, idx
);
1911 /* Array ref is const/volatile if the array elements are
1912 or if the array is.. */
1913 TREE_READONLY (rval
)
1914 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1915 | TREE_READONLY (array
));
1916 TREE_SIDE_EFFECTS (rval
)
1917 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1918 | TREE_SIDE_EFFECTS (array
));
1919 TREE_THIS_VOLATILE (rval
)
1920 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1921 /* This was added by rms on 16 Nov 91.
1922 It fixes vol struct foo *a; a->elts[1]
1923 in an inline function.
1924 Hope it doesn't break something else. */
1925 | TREE_THIS_VOLATILE (array
));
1926 return require_complete_type (fold (rval
));
1930 tree ar
= default_conversion (array
);
1931 tree ind
= default_conversion (idx
);
1933 /* Put the integer in IND to simplify error checking. */
1934 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
1941 if (ar
== error_mark_node
)
1944 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
1946 error ("subscripted value is neither array nor pointer");
1947 return error_mark_node
;
1949 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
1951 error ("array subscript is not an integer");
1952 return error_mark_node
;
1955 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
, ind
, PLUS_EXPR
),
1960 /* Build a function call to function FUNCTION with parameters PARAMS.
1961 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1962 TREE_VALUE of each node is a parameter-expression.
1963 FUNCTION's data type may be a function type or a pointer-to-function.
1965 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
1966 is the list of possible methods that FUNCTION could conceivably
1967 be. If the list of methods comes from a class, then it will be
1968 a list of lists (where each element is associated with the class
1969 that produced it), otherwise it will be a simple list (for
1970 functions overloaded in global scope).
1972 In the first case, TREE_VALUE (function) is the head of one of those
1973 lists, and TREE_PURPOSE is the name of the function.
1975 In the second case, TREE_PURPOSE (function) is the function's
1978 DECL is the class instance variable, usually CURRENT_CLASS_DECL. */
1981 * [eichin:19911015.1726EST] actually return a possibly incomplete
1985 build_x_function_call (function
, params
, decl
)
1986 tree function
, params
, decl
;
1991 if (function
== error_mark_node
)
1992 return error_mark_node
;
1994 type
= TREE_TYPE (function
);
1995 is_method
= ((TREE_CODE (function
) == TREE_LIST
1996 && current_class_type
!= NULL_TREE
1997 && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
)) == function
)
1998 || TREE_CODE (function
) == IDENTIFIER_NODE
1999 || TREE_CODE (type
) == METHOD_TYPE
2000 || TYPE_PTRMEMFUNC_P (type
));
2002 /* Handle methods, friends, and overloaded functions, respectively. */
2005 if (TREE_CODE (function
) == FUNCTION_DECL
)
2007 if (DECL_NAME (function
))
2008 function
= DECL_NAME (function
);
2010 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2012 else if (TREE_CODE (function
) == TREE_LIST
)
2015 if (TREE_CODE (TREE_VALUE (function
)) == TREE_LIST
)
2016 function
= TREE_PURPOSE (TREE_VALUE (function
));
2018 function
= TREE_PURPOSE (function
);
2020 my_friendly_assert (TREE_CODE (TREE_VALUE (function
)) == FUNCTION_DECL
, 312);
2021 function
= TREE_PURPOSE (function
);
2024 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2026 if (TREE_CODE (function
) == OFFSET_REF
)
2028 if (TREE_OPERAND (function
, 0))
2029 decl
= TREE_OPERAND (function
, 0);
2031 /* Call via a pointer to member function. */
2032 if (decl
== NULL_TREE
)
2034 error ("pointer to member function called, but not in class scope");
2035 return error_mark_node
;
2037 /* What other type of POINTER_TYPE could this be? */
2038 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2039 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2040 && TREE_CODE (function
) != OFFSET_REF
)
2041 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
, function
);
2045 /* this is an abbreviated method call.
2046 must go through here in case it is a virtual function.
2047 @@ Perhaps this could be optimized. */
2049 if (decl
== NULL_TREE
)
2051 if (current_class_type
== NULL_TREE
)
2053 error ("object missing in call to method `%s'",
2054 IDENTIFIER_POINTER (function
));
2055 return error_mark_node
;
2057 /* Yow: call from a static member function. */
2058 decl
= build1 (NOP_EXPR
, TYPE_POINTER_TO (current_class_type
),
2060 decl
= build_indirect_ref (decl
, NULL_PTR
);
2063 return build_method_call (decl
, function
, params
,
2064 NULL_TREE
, LOOKUP_NORMAL
);
2066 else if (TREE_CODE (function
) == COMPONENT_REF
2067 && type
== unknown_type_node
)
2069 /* Should we undo what was done in build_component_ref? */
2070 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function
, 1))) == TREE_VEC
)
2071 /* Get the name that build_component_ref hid. */
2072 function
= DECL_NAME (TREE_VALUE (TREE_OPERAND (function
, 1)));
2074 function
= TREE_PURPOSE (TREE_OPERAND (function
, 1));
2075 return build_method_call (decl
, function
, params
,
2076 NULL_TREE
, LOOKUP_NORMAL
);
2078 else if (TREE_CODE (function
) == TREE_LIST
)
2080 if (TREE_VALUE (function
) == NULL_TREE
)
2082 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2083 TREE_PURPOSE (function
));
2084 return error_mark_node
;
2088 tree val
= TREE_VALUE (function
);
2090 if (TREE_CODE (val
) == TEMPLATE_DECL
)
2091 return build_overload_call_maybe
2092 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2093 else if (DECL_CHAIN (val
) != NULL_TREE
)
2094 return build_overload_call
2095 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2097 my_friendly_abort (360);
2102 if (TREE_CODE (function
) == OFFSET_REF
)
2104 /* If the component is a data element (or a virtual function), we play
2105 games here to make things work. */
2108 if (TREE_OPERAND (function
, 0))
2109 decl
= TREE_OPERAND (function
, 0);
2113 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2114 function
= get_member_function_from_ptrfunc (&decl_addr
, decl
,
2115 TREE_OPERAND (function
, 1));
2116 params
= tree_cons (NULL_TREE
, decl_addr
, params
);
2117 return build_function_call (function
, params
);
2120 type
= TREE_TYPE (function
);
2121 if (type
!= error_mark_node
)
2123 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2124 type
= TREE_TYPE (type
);
2126 if (TYPE_LANG_SPECIFIC (type
) && TYPE_OVERLOADS_CALL_EXPR (type
))
2127 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2132 tree fntype
= TREE_TYPE (function
);
2135 /* Explicitly named method? */
2136 if (TREE_CODE (function
) == FUNCTION_DECL
)
2137 ctypeptr
= TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function
));
2138 /* Expression with ptr-to-method type? It could either be a plain
2139 usage, or it might be a case where the ptr-to-method is being
2140 passed in as an argument. */
2141 else if (TYPE_PTRMEMFUNC_P (fntype
))
2143 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2144 ctypeptr
= TYPE_POINTER_TO (rec
);
2146 /* Unexpected node type? */
2148 my_friendly_abort (116);
2149 if (decl
== NULL_TREE
)
2151 if (current_function_decl
2152 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2153 error ("invalid call to member function needing `this' in static member function scope");
2155 error ("pointer to member function called, but not in class scope");
2156 return error_mark_node
;
2158 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2159 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2161 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2162 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2165 decl
= build_c_cast (ctypeptr
, decl
);
2166 params
= tree_cons (NULL_TREE
, decl
, params
);
2169 return build_function_call (function
, params
);
2172 /* Resolve a pointer to member function. INSTANCE is the object
2173 instance to use, if the member points to a virtual member. */
2176 get_member_function_from_ptrfunc (instance_ptrptr
, instance
, function
)
2177 tree
*instance_ptrptr
;
2181 if (TREE_CODE (function
) == OFFSET_REF
)
2183 function
= TREE_OPERAND (function
, 1);
2186 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2188 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2189 tree index
= save_expr (convert (integer_type_node
,
2190 build_component_ref (function
,
2193 tree e1
= build (GT_EXPR
, integer_type_node
, index
, integer_zero_node
);
2194 tree delta
= build_component_ref (function
, delta_identifier
, 0, 0);
2195 tree delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2200 /* convert down to the right base, before using the instance. */
2201 instance
= convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
)),
2202 build_unary_op (ADDR_EXPR
, instance
, 0));
2203 if (instance
== error_mark_node
)
2206 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2209 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2210 vtbl
, convert (sizetype
, delta2
));
2211 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2212 aref
= build_array_ref (vtbl
, size_binop (MINUS_EXPR
,
2215 if (! flag_vtable_thunks
)
2217 aref
= save_expr (aref
);
2219 /* Save the intermediate result in a SAVE_EXPR so we don't have to
2220 compute each component of the virtual function pointer twice. */
2221 if (/* !building_cleanup && */ TREE_CODE (aref
) == INDIRECT_REF
)
2222 TREE_OPERAND (aref
, 0) = save_expr (TREE_OPERAND (aref
, 0));
2224 delta
= build (PLUS_EXPR
, integer_type_node
,
2225 build_conditional_expr (e1
, build_component_ref (aref
, delta_identifier
, 0, 0), integer_zero_node
),
2229 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (*instance_ptrptr
),
2231 convert (integer_type_node
, delta
));
2232 if (flag_vtable_thunks
)
2235 e2
= build_component_ref (aref
, pfn_identifier
, 0, 0);
2237 e3
= PFN_FROM_PTRMEMFUNC (function
);
2238 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2239 function
= build_conditional_expr (e1
, e2
, e3
);
2245 build_function_call_real (function
, params
, require_complete
, flags
)
2246 tree function
, params
;
2247 int require_complete
, flags
;
2249 register tree fntype
, fndecl
;
2250 register tree value_type
;
2251 register tree coerced_params
;
2252 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2255 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2256 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2257 if (TREE_CODE (function
) == NOP_EXPR
2258 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2259 function
= TREE_OPERAND (function
, 0);
2261 if (TREE_CODE (function
) == FUNCTION_DECL
)
2263 name
= DECL_NAME (function
);
2264 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2266 GNU_xref_call (current_function_decl
,
2267 IDENTIFIER_POINTER (name
? name
2268 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
))));
2269 assemble_external (function
);
2272 /* Convert anything with function type to a pointer-to-function. */
2275 && IDENTIFIER_LENGTH (name
) == 4
2276 && ! strcmp (IDENTIFIER_POINTER (name
), "main")
2277 && DECL_CONTEXT (function
) == NULL_TREE
)
2279 pedwarn ("ANSI C++ forbids calling `main' from within program");
2282 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2283 (because calling an inline function does not mean the function
2284 needs to be separately compiled). */
2286 if (DECL_INLINE (function
))
2288 fntype
= build_type_variant (TREE_TYPE (function
),
2289 TREE_READONLY (function
),
2290 TREE_THIS_VOLATILE (function
));
2291 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2295 assemble_external (function
);
2296 TREE_USED (function
) = 1;
2297 function
= default_conversion (function
);
2304 /* Convert anything with function type to a pointer-to-function. */
2305 if (function
== error_mark_node
)
2306 return error_mark_node
;
2307 function
= default_conversion (function
);
2310 fntype
= TREE_TYPE (function
);
2312 if (TYPE_PTRMEMFUNC_P (fntype
))
2314 tree instance_ptr
= build_unary_op (ADDR_EXPR
, C_C_D
, 0);
2315 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (fntype
);
2316 function
= get_member_function_from_ptrfunc (&instance_ptr
, C_C_D
, function
);
2319 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2320 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2322 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2323 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2326 error ("called object is not a function");
2327 return error_mark_node
;
2330 /* fntype now gets the type of function pointed to. */
2331 fntype
= TREE_TYPE (fntype
);
2333 /* Convert the parameters to the types declared in the
2334 function prototype, or apply default promotions. */
2336 if (flags
& LOOKUP_COMPLAIN
)
2337 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2338 params
, fndecl
, LOOKUP_NORMAL
);
2340 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2343 /* Check for errors in format strings. */
2345 if (warn_format
&& (name
|| assembler_name
))
2346 check_function_format (name
, assembler_name
, coerced_params
);
2348 /* Recognize certain built-in functions so we can make tree-codes
2349 other than CALL_EXPR. We do this when it enables fold-const.c
2350 to do something useful. */
2352 if (TREE_CODE (function
) == ADDR_EXPR
2353 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2354 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2355 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2360 if (coerced_params
== 0)
2361 return integer_zero_node
;
2362 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2366 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2368 register tree result
=
2369 build (CALL_EXPR
, value_type
,
2370 function
, coerced_params
, NULL_TREE
);
2372 TREE_SIDE_EFFECTS (result
) = 1;
2373 /* Remove this sometime. */
2374 TREE_RAISES (result
) |= !! TYPE_RAISES_EXCEPTIONS (fntype
);
2375 if (! require_complete
)
2377 if (value_type
== void_type_node
)
2379 return require_complete_type (result
);
2384 build_function_call (function
, params
)
2385 tree function
, params
;
2387 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2391 build_function_call_maybe (function
, params
)
2392 tree function
, params
;
2394 return build_function_call_real (function
, params
, 0, 0);
2398 /* Convert the actual parameter expressions in the list VALUES
2399 to the types in the list TYPELIST.
2400 If parmdecls is exhausted, or when an element has NULL as its type,
2401 perform the default conversions.
2403 RETURN_LOC is the location of the return value, if known, NULL_TREE
2404 otherwise. This is useful in the case where we can avoid creating
2405 a temporary variable in the case where we can initialize the return
2406 value directly. If we are not eliding constructors, then we set this
2407 to NULL_TREE to avoid this avoidance.
2409 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2411 This is also where warnings about wrong number of args are generated.
2413 Return a list of expressions for the parameters as converted.
2415 Both VALUES and the returned value are chains of TREE_LIST nodes
2416 with the elements of the list in the TREE_VALUE slots of those nodes.
2418 In C++, unspecified trailing parameters can be filled in with their
2419 default arguments, if such were specified. Do so here. */
2422 convert_arguments (return_loc
, typelist
, values
, fndecl
, flags
)
2423 tree return_loc
, typelist
, values
, fndecl
;
2426 extern tree gc_protect_fndecl
;
2427 register tree typetail
, valtail
;
2428 register tree result
= NULL_TREE
;
2430 int maybe_raises
= 0;
2433 if (! flag_elide_constructors
)
2438 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2440 if (DECL_NAME (fndecl
) == NULL_TREE
2441 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2442 called_thing
= "constructor";
2444 called_thing
= "member function";
2447 called_thing
= "function";
2450 for (valtail
= values
, typetail
= typelist
;
2452 valtail
= TREE_CHAIN (valtail
), i
++)
2454 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2455 register tree val
= TREE_VALUE (valtail
);
2457 if (type
== void_type_node
)
2461 char *buf
= (char *)alloca (40 + strlen (called_thing
));
2462 sprintf (buf
, "too many arguments to %s `%%s'", called_thing
);
2463 error_with_decl (fndecl
, buf
);
2464 error ("at this point in file");
2467 error ("too many arguments to function");
2468 /* In case anybody wants to know if this argument
2471 TREE_TYPE (tree_last (result
)) = error_mark_node
;
2475 /* The tree type of the parameter being passed may not yet be
2476 known. In this case, its type is TYPE_UNKNOWN, and will
2477 be instantiated by the type given by TYPE. If TYPE
2478 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
2479 if (type
&& type_unknown_p (val
))
2480 val
= require_instantiated_type (type
, val
, integer_zero_node
);
2481 else if (type_unknown_p (val
))
2483 /* Strip the `&' from an overloaded FUNCTION_DECL. */
2484 if (TREE_CODE (val
) == ADDR_EXPR
)
2485 val
= TREE_OPERAND (val
, 0);
2486 if (TREE_CODE (val
) == TREE_LIST
2487 && TREE_CHAIN (val
) == NULL_TREE
2488 && TREE_TYPE (TREE_VALUE (val
)) != NULL_TREE
2489 && (TREE_TYPE (val
) == unknown_type_node
2490 || DECL_CHAIN (TREE_VALUE (val
)) == NULL_TREE
))
2491 /* Instantiates automatically. */
2492 val
= TREE_VALUE (val
);
2495 error ("insufficient type information in parameter list");
2496 val
= integer_zero_node
;
2499 else if (TREE_CODE (val
) == OFFSET_REF
2500 && TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2502 /* This is unclean. Should be handled elsewhere. */
2503 val
= build_unary_op (ADDR_EXPR
, val
, 0);
2505 else if (TREE_CODE (val
) == OFFSET_REF
)
2506 val
= resolve_offset_ref (val
);
2510 /* This code forces the assumption that if we have a ptr-to-func
2511 type in an arglist, that every routine that wants to check
2512 its validity has done so, and thus we need not do any
2513 more conversion. I don't remember why this is necessary. */
2514 else if (TREE_CODE (ttype
) == FUNCTION_TYPE
2516 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
2517 || TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
))
2519 type
= build_pointer_type (ttype
);
2524 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2525 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2526 if (TREE_CODE (val
) == NOP_EXPR
2527 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
2528 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
2529 val
= TREE_OPERAND (val
, 0);
2531 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
2533 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
2534 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
2535 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2536 val
= default_conversion (val
);
2538 val
= require_complete_type (val
);
2541 if (val
== error_mark_node
)
2544 maybe_raises
|= TREE_RAISES (val
);
2548 /* Formal parm type is specified by a function prototype. */
2551 if (TYPE_SIZE (type
) == 0)
2553 error ("parameter type of called function is incomplete");
2558 #if 0 && defined (PROMOTE_PROTOTYPES)
2559 /* This breaks user-defined conversions. */
2560 /* Rather than truncating and then reextending,
2561 convert directly to int, if that's the type we will want. */
2562 if (! flag_traditional
2563 && (TREE_CODE (type
) == INTEGER_TYPE
2564 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2565 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2566 type
= integer_type_node
;
2568 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2569 "argument passing", fndecl
, i
);
2570 #ifdef PROMOTE_PROTOTYPES
2571 if ((TREE_CODE (type
) == INTEGER_TYPE
2572 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2573 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2574 parmval
= default_conversion (parmval
);
2577 result
= tree_cons (NULL_TREE
, parmval
, result
);
2581 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
2582 val
= convert_from_reference (val
);
2584 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2585 && (TYPE_PRECISION (TREE_TYPE (val
))
2586 < TYPE_PRECISION (double_type_node
)))
2587 /* Convert `float' to `double'. */
2588 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2589 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
2590 && (TYPE_HAS_INIT_REF (TREE_TYPE (val
))
2591 || TYPE_HAS_ASSIGN_REF (TREE_TYPE (val
))))
2593 cp_warning ("cannot pass objects of type `%T' through `...'",
2595 result
= tree_cons (NULL_TREE
, val
, result
);
2598 /* Convert `short' and `char' to full-size `int'. */
2599 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2603 /* There are certain functions for which we don't need
2604 to protect our arguments. GC_PROTECT_FNDECL is one. */
2605 && fndecl
!= gc_protect_fndecl
2606 && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result
)))
2607 && ! value_safe_from_gc (NULL_TREE
, TREE_VALUE (result
)))
2608 /* This will build a temporary variable whose cleanup is
2609 to clear the obstack entry. */
2610 TREE_VALUE (result
) = protect_value_from_gc (NULL_TREE
,
2611 TREE_VALUE (result
));
2614 typetail
= TREE_CHAIN (typetail
);
2617 if (typetail
!= 0 && typetail
!= void_list_node
)
2619 /* See if there are default arguments that can be used */
2620 if (TREE_PURPOSE (typetail
))
2622 for (; typetail
!= void_list_node
; ++i
)
2624 tree type
= TREE_VALUE (typetail
);
2625 tree val
= TREE_PURPOSE (typetail
);
2628 if (val
== NULL_TREE
)
2629 parmval
= error_mark_node
;
2630 else if (TREE_CODE (val
) == CONSTRUCTOR
)
2632 parmval
= digest_init (type
, val
, (tree
*)0);
2633 parmval
= convert_for_initialization (return_loc
, type
, parmval
, flags
,
2634 "default constructor", fndecl
, i
);
2638 /* This could get clobbered by the following call. */
2639 if (TREE_HAS_CONSTRUCTOR (val
))
2640 val
= copy_node (val
);
2642 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2643 "default argument", fndecl
, i
);
2644 #ifdef PROMOTE_PROTOTYPES
2645 if ((TREE_CODE (type
) == INTEGER_TYPE
2646 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2647 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2648 parmval
= default_conversion (parmval
);
2651 maybe_raises
|= TREE_RAISES (parmval
);
2654 && type_needs_gc_entry (TREE_TYPE (parmval
))
2655 && ! value_safe_from_gc (NULL_TREE
, parmval
))
2656 parmval
= protect_value_from_gc (NULL_TREE
, parmval
);
2658 result
= tree_cons (0, parmval
, result
);
2659 typetail
= TREE_CHAIN (typetail
);
2660 /* ends with `...'. */
2661 if (typetail
== NULL_TREE
)
2669 char *buf
= (char *)alloca (32 + strlen (called_thing
));
2670 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
2671 cp_error_at (buf
, fndecl
);
2672 error ("at this point in file");
2675 error ("too few arguments to function");
2676 return error_mark_list
;
2680 TREE_RAISES (result
) = maybe_raises
;
2682 return nreverse (result
);
2685 /* Build a binary-operation expression, after performing default
2686 conversions on the operands. CODE is the kind of expression to build. */
2689 build_x_binary_op (code
, arg1
, arg2
)
2690 enum tree_code code
;
2693 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
,
2694 arg1
, arg2
, NULL_TREE
);
2696 return build_opfncall (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
2697 if (code
== MEMBER_REF
)
2698 return build_m_component_ref (build_indirect_ref (arg1
, NULL_PTR
),
2700 return build_binary_op (code
, arg1
, arg2
, 1);
2704 build_binary_op (code
, arg1
, arg2
, convert_p
)
2705 enum tree_code code
;
2717 args
[0] = default_conversion (args
[0]);
2718 args
[1] = default_conversion (args
[1]);
2720 if (type_unknown_p (args
[0]))
2722 args
[0] = instantiate_type (TREE_TYPE (args
[1]), args
[0], 1);
2723 args
[0] = default_conversion (args
[0]);
2725 else if (type_unknown_p (args
[1]))
2727 args
[1] = require_instantiated_type (TREE_TYPE (args
[0]),
2730 args
[1] = default_conversion (args
[1]);
2733 type1
= TREE_TYPE (args
[0]);
2734 type2
= TREE_TYPE (args
[1]);
2736 if (IS_AGGR_TYPE_2 (type1
, type2
) && ! TYPE_PTRMEMFUNC_P (type1
))
2738 /* Try to convert this to something reasonable. */
2739 if (! build_default_binary_type_conversion(code
, &args
[0], &args
[1]))
2740 return error_mark_node
;
2742 else if ((IS_AGGR_TYPE (type1
) && ! TYPE_PTRMEMFUNC_P (type1
))
2743 || (IS_AGGR_TYPE (type2
) && ! TYPE_PTRMEMFUNC_P (type2
)))
2745 int convert_index
= IS_AGGR_TYPE (type2
);
2746 /* Avoid being tripped up by things like (ARG1 != 0). */
2749 types
[0] = type1
; types
[1] = type2
;
2750 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
2751 try = build_type_conversion (code
, bool_type_node
,
2752 args
[convert_index
], 1);
2755 try = build_type_conversion (code
, types
[convert_index
^ 1],
2756 args
[convert_index
], 1);
2759 && args
[1] == integer_zero_node
2760 && (code
== NE_EXPR
|| code
== EQ_EXPR
))
2761 try = build_type_conversion (code
, ptr_type_node
,
2762 args
[convert_index
], 1);
2767 cp_error ("no match for `%O(%#T, %#T)'", code
,
2768 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
2769 return error_mark_node
;
2771 if (try == error_mark_node
)
2772 error ("ambiguous pointer conversion");
2773 args
[convert_index
] = try;
2776 return build_binary_op_nodefault (code
, args
[0], args
[1], code
);
2779 /* Build a binary-operation expression without default conversions.
2780 CODE is the kind of expression to build.
2781 This function differs from `build' in several ways:
2782 the data type of the result is computed and recorded in it,
2783 warnings are generated if arg data types are invalid,
2784 special handling for addition and subtraction of pointers is known,
2785 and some optimization is done (operations on narrow ints
2786 are done in the narrower type when that gives the same result).
2787 Constant folding is also done before the result is returned.
2789 ERROR_CODE is the code that determines what to say in error messages.
2790 It is usually, but not always, the same as CODE.
2792 Note that the operands will never have enumeral types
2793 because either they have just had the default conversions performed
2794 or they have both just been converted to some other type in which
2795 the arithmetic is to be done.
2797 C++: must do special pointer arithmetic when implementing
2798 multiple inheritance, and deal with pointer to member functions. */
2801 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
2802 enum tree_code code
;
2803 tree orig_op0
, orig_op1
;
2804 enum tree_code error_code
;
2807 register enum tree_code code0
, code1
;
2810 /* Expression code to give to the expression when it is built.
2811 Normally this is CODE, which is what the caller asked for,
2812 but in some special cases we change it. */
2813 register enum tree_code resultcode
= code
;
2815 /* Data type in which the computation is to be performed.
2816 In the simplest cases this is the common type of the arguments. */
2817 register tree result_type
= NULL
;
2819 /* Nonzero means operands have already been type-converted
2820 in whatever way is necessary.
2821 Zero means they need to be converted to RESULT_TYPE. */
2824 /* Nonzero means after finally constructing the expression
2825 give it this type. Otherwise, give it type RESULT_TYPE. */
2826 tree final_type
= 0;
2828 /* Nonzero if this is an operation like MIN or MAX which can
2829 safely be computed in short if both args are promoted shorts.
2830 Also implies COMMON.
2831 -1 indicates a bitwise operation; this makes a difference
2832 in the exact conditions for when it is safe to do the operation
2833 in a narrower mode. */
2836 /* Nonzero if this is a comparison operation;
2837 if both args are promoted shorts, compare the original shorts.
2838 Also implies COMMON. */
2839 int short_compare
= 0;
2841 /* Nonzero if this is a right-shift operation, which can be computed on the
2842 original short and then promoted if the operand is a promoted short. */
2843 int short_shift
= 0;
2845 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2848 /* Apply default conversions. */
2849 op0
= default_conversion (orig_op0
);
2850 op1
= default_conversion (orig_op1
);
2852 type0
= TREE_TYPE (op0
);
2853 type1
= TREE_TYPE (op1
);
2855 /* The expression codes of the data types of the arguments tell us
2856 whether the arguments are integers, floating, pointers, etc. */
2857 code0
= TREE_CODE (type0
);
2858 code1
= TREE_CODE (type1
);
2860 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2861 STRIP_TYPE_NOPS (op0
);
2862 STRIP_TYPE_NOPS (op1
);
2864 /* If an error was already reported for one of the arguments,
2865 avoid reporting another error. */
2867 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
2868 return error_mark_node
;
2873 /* Handle the pointer + int case. */
2874 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2875 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
2876 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
2877 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
2883 /* Subtraction of two similar pointers.
2884 We must subtract them as integers, then divide by object size. */
2885 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
2886 && comp_target_types (type0
, type1
, 1))
2887 return pointer_diff (op0
, op1
);
2888 /* Handle pointer minus int. Just like pointer plus int. */
2889 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2890 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
2899 case TRUNC_DIV_EXPR
:
2901 case FLOOR_DIV_EXPR
:
2902 case ROUND_DIV_EXPR
:
2903 case EXACT_DIV_EXPR
:
2904 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2905 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2907 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
2908 cp_warning ("division by zero in `%E / 0'", op0
);
2909 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
2910 cp_warning ("division by zero in `%E / 0.'", op0
);
2912 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
2913 resultcode
= RDIV_EXPR
;
2915 /* When dividing two signed integers, we have to promote to int.
2916 unless we divide by a conatant != -1. Note that default
2917 conversion will have been performed on the operands at this
2918 point, so we have to dig out the original type to find out if
2920 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2921 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2922 || (TREE_CODE (op1
) == INTEGER_CST
2923 && (TREE_INT_CST_LOW (op1
) != -1
2924 || TREE_INT_CST_HIGH (op1
) != -1)));
2930 case BIT_ANDTC_EXPR
:
2933 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2935 /* If one operand is a constant, and the other is a short type
2936 that has been converted to an int,
2937 really do the work in the short type and then convert the
2938 result to int. If we are lucky, the constant will be 0 or 1
2939 in the short type, making the entire operation go away. */
2940 if (TREE_CODE (op0
) == INTEGER_CST
2941 && TREE_CODE (op1
) == NOP_EXPR
2942 && TYPE_PRECISION (type1
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))
2943 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
2945 final_type
= result_type
;
2946 op1
= TREE_OPERAND (op1
, 0);
2947 result_type
= TREE_TYPE (op1
);
2949 if (TREE_CODE (op1
) == INTEGER_CST
2950 && TREE_CODE (op0
) == NOP_EXPR
2951 && TYPE_PRECISION (type0
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2952 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2954 final_type
= result_type
;
2955 op0
= TREE_OPERAND (op0
, 0);
2956 result_type
= TREE_TYPE (op0
);
2960 case TRUNC_MOD_EXPR
:
2961 case FLOOR_MOD_EXPR
:
2962 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
2963 cp_warning ("division by zero in `%E % 0'", op0
);
2964 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
2965 cp_warning ("division by zero in `%E % 0.'", op0
);
2967 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2969 /* Although it would be tempting to shorten always here, that loses
2970 on some targets, since the modulo instruction is undefined if the
2971 quotient can't be represented in the computation mode. We shorten
2972 only if unsigned or if dividing by something we know != -1. */
2973 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2974 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2975 || (TREE_CODE (op1
) == INTEGER_CST
2976 && (TREE_INT_CST_LOW (op1
) != -1
2977 || TREE_INT_CST_HIGH (op1
) != -1)));
2982 case TRUTH_ANDIF_EXPR
:
2983 case TRUTH_ORIF_EXPR
:
2984 case TRUTH_AND_EXPR
:
2986 result_type
= bool_type_node
;
2987 op0
= bool_truthvalue_conversion (op0
);
2988 op1
= bool_truthvalue_conversion (op1
);
2992 /* Shift operations: result has same type as first operand;
2993 always convert second operand to int.
2994 Also set SHORT_SHIFT if shifting rightward. */
2997 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2999 result_type
= type0
;
3000 if (TREE_CODE (op1
) == INTEGER_CST
)
3002 if (tree_int_cst_lt (op1
, integer_zero_node
))
3003 warning ("right shift count is negative");
3006 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3008 if (TREE_INT_CST_HIGH (op1
) != 0
3009 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3010 >= TYPE_PRECISION (type0
)))
3011 warning ("right shift count >= width of type");
3014 /* Convert the shift-count to an integer, regardless of
3015 size of value being shifted. */
3016 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3017 op1
= convert (integer_type_node
, op1
);
3018 /* Avoid converting op1 to result_type later. */
3024 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3026 result_type
= type0
;
3027 if (TREE_CODE (op1
) == INTEGER_CST
)
3029 if (tree_int_cst_lt (op1
, integer_zero_node
))
3030 warning ("left shift count is negative");
3031 else if (TREE_INT_CST_HIGH (op1
) != 0
3032 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3033 >= TYPE_PRECISION (type0
)))
3034 warning ("left shift count >= width of type");
3036 /* Convert the shift-count to an integer, regardless of
3037 size of value being shifted. */
3038 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3039 op1
= convert (integer_type_node
, op1
);
3040 /* Avoid converting op1 to result_type later. */
3047 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3049 result_type
= type0
;
3050 if (TREE_CODE (op1
) == INTEGER_CST
)
3052 if (tree_int_cst_lt (op1
, integer_zero_node
))
3053 warning ("%s rotate count is negative",
3054 (code
== LROTATE_EXPR
) ? "left" : "right");
3055 else if (TREE_INT_CST_HIGH (op1
) != 0
3056 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3057 >= TYPE_PRECISION (type0
)))
3058 warning ("%s rotate count >= width of type",
3059 (code
== LROTATE_EXPR
) ? "left" : "right");
3061 /* Convert the shift-count to an integer, regardless of
3062 size of value being shifted. */
3063 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3064 op1
= convert (integer_type_node
, op1
);
3070 result_type
= bool_type_node
;
3072 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3073 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3075 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3077 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3078 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3079 /* Anything compares with void *. void * compares with anything.
3080 Otherwise, the targets must be the same. */
3081 if (tt0
!= tt1
&& TREE_CODE (tt0
) == RECORD_TYPE
3082 && TREE_CODE (tt1
) == RECORD_TYPE
)
3084 tree base
= common_base_type (tt0
, tt1
);
3085 if (base
== NULL_TREE
)
3086 cp_warning ("comparison of distinct object pointer types `%T' and `%T'", type0
, type1
);
3087 else if (base
== error_mark_node
)
3089 cp_error ("comparison of pointer types `%T' and `%T' requires conversion to ambiguous supertype", type0
, type1
);
3090 return error_mark_node
;
3094 if (integer_zerop (op0
))
3095 op0
= null_pointer_node
;
3097 op0
= convert_pointer_to (base
, op0
);
3098 if (integer_zerop (op1
))
3099 op1
= null_pointer_node
;
3101 op1
= convert_pointer_to (base
, op1
);
3104 else if (comp_target_types (type0
, type1
, 1))
3106 else if (tt0
== void_type_node
)
3108 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3109 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3110 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3112 else if (tt1
== void_type_node
)
3114 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3115 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3116 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3118 else if ((TYPE_SIZE (tt0
) != 0) != (TYPE_SIZE (tt1
) != 0))
3119 cp_pedwarn ("comparison of %scomplete and %scomplete pointers `%T' and `%T'",
3120 TYPE_SIZE (tt0
) == 0 ? "in" : "",
3121 TYPE_SIZE (tt1
) == 0 ? "in" : "",
3124 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3127 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3128 && integer_zerop (op1
))
3129 op1
= null_pointer_node
;
3130 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3131 && integer_zerop (op0
))
3132 op0
= null_pointer_node
;
3133 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3135 error ("ANSI C++ forbids comparison between pointer and integer");
3136 op1
= convert (TREE_TYPE (op0
), op1
);
3138 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3140 error ("ANSI C++ forbids comparison between pointer and integer");
3141 op0
= convert (TREE_TYPE (op1
), op0
);
3143 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3144 && integer_zerop (op1
))
3146 op0
= build_component_ref (op0
, index_identifier
, 0, 0);
3147 op1
= integer_zero_node
;
3149 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3150 && integer_zerop (op0
))
3152 op0
= build_component_ref (op1
, index_identifier
, 0, 0);
3153 op1
= integer_zero_node
;
3155 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3156 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3157 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3159 /* The code we generate for the test is:
3161 (op0.index == op1.index
3162 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3163 || op0.pfn == op1.pfn)) */
3165 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3166 tree index1
= save_expr (build_component_ref (op1
, index_identifier
, 0, 0));
3167 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3168 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3169 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3170 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3172 tree integer_neg_one_node
3173 = size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
3174 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3175 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3176 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3177 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3178 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3179 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3180 if (code
== EQ_EXPR
)
3182 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3184 else if (TYPE_PTRMEMFUNC_P (type0
)
3185 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3187 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3189 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3190 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3191 tree delta21
= integer_zero_node
;
3193 tree integer_neg_one_node
3194 = size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
3195 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3196 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3198 /* Map everything down one to make room for the null pointer to member. */
3199 index1
= size_binop (PLUS_EXPR
,
3200 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3202 op1
= integer_zero_node
;
3203 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1
)));
3204 delta21
= DECL_FIELD_BITPOS (delta21
);
3205 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
, size_int (BITS_PER_UNIT
));
3208 index1
= integer_neg_one_node
;
3210 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
), op1
);
3211 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3214 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3215 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3216 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3217 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3218 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3219 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3220 if (code
== EQ_EXPR
)
3222 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3224 else if (TYPE_PTRMEMFUNC_P (type1
)
3225 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3227 return build_binary_op (code
, op1
, op0
, 1);
3230 /* If args are not valid, clear out RESULT_TYPE
3231 to cause an error message later. */
3237 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3238 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3240 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3242 if (! comp_target_types (type0
, type1
, 1))
3243 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3245 else if ((TYPE_SIZE (TREE_TYPE (type0
)) != 0)
3246 != (TYPE_SIZE (TREE_TYPE (type1
)) != 0))
3247 cp_pedwarn ("comparison of %scomplete and %scomplete pointers",
3248 TYPE_SIZE (TREE_TYPE (type0
)) == 0 ? "in" : "",
3249 TYPE_SIZE (TREE_TYPE (type1
)) == 0 ? "in" : "",
3252 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
3253 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3254 result_type
= common_type (type0
, type1
);
3262 result_type
= bool_type_node
;
3263 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3264 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3266 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3268 if (! comp_target_types (type0
, type1
, 1))
3269 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3271 else if ((TYPE_SIZE (TREE_TYPE (type0
)) != 0)
3272 != (TYPE_SIZE (TREE_TYPE (type1
)) != 0))
3273 cp_pedwarn ("comparison of %scomplete and %scomplete pointers",
3274 TYPE_SIZE (TREE_TYPE (type0
)) == 0 ? "in" : "",
3275 TYPE_SIZE (TREE_TYPE (type1
)) == 0 ? "in" : "",
3278 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
3279 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3281 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3282 && integer_zerop (op1
))
3284 op1
= null_pointer_node
;
3286 pedwarn ("ordered comparison of pointer with integer zero");
3288 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3289 && integer_zerop (op0
))
3291 op0
= null_pointer_node
;
3293 pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
3295 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3298 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3299 else if (! flag_traditional
)
3300 warning ("comparison between pointer and integer");
3301 op1
= convert (TREE_TYPE (op0
), op1
);
3303 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3306 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3307 else if (! flag_traditional
)
3308 warning ("comparison between pointer and integer");
3309 op0
= convert (TREE_TYPE (op1
), op0
);
3317 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3318 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3320 if (shorten
|| common
|| short_compare
)
3321 result_type
= common_type (type0
, type1
);
3323 /* For certain operations (which identify themselves by shorten != 0)
3324 if both args were extended from the same smaller type,
3325 do the arithmetic in that type and then extend.
3327 shorten !=0 and !=1 indicates a bitwise operation.
3328 For them, this optimization is safe only if
3329 both args are zero-extended or both are sign-extended.
3330 Otherwise, we might change the result.
3331 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3332 but calculated in (unsigned short) it would be (unsigned short)-1. */
3336 int unsigned0
, unsigned1
;
3337 tree arg0
= get_narrower (op0
, &unsigned0
);
3338 tree arg1
= get_narrower (op1
, &unsigned1
);
3339 /* UNS is 1 if the operation to be done is an unsigned one. */
3340 int uns
= TREE_UNSIGNED (result_type
);
3343 final_type
= result_type
;
3345 /* Handle the case that OP0 does not *contain* a conversion
3346 but it *requires* conversion to FINAL_TYPE. */
3348 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3349 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3350 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3351 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3353 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3355 /* For bitwise operations, signedness of nominal type
3356 does not matter. Consider only how operands were extended. */
3360 /* Note that in all three cases below we refrain from optimizing
3361 an unsigned operation on sign-extended args.
3362 That would not be valid. */
3364 /* Both args variable: if both extended in same way
3365 from same width, do it in that width.
3366 Do it unsigned if args were zero-extended. */
3367 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3368 < TYPE_PRECISION (result_type
))
3369 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3370 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3371 && unsigned0
== unsigned1
3372 && (unsigned0
|| !uns
))
3374 = signed_or_unsigned_type (unsigned0
,
3375 common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
3376 else if (TREE_CODE (arg0
) == INTEGER_CST
3377 && (unsigned1
|| !uns
)
3378 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3379 < TYPE_PRECISION (result_type
))
3380 && (type
= signed_or_unsigned_type (unsigned1
,
3382 int_fits_type_p (arg0
, type
)))
3384 else if (TREE_CODE (arg1
) == INTEGER_CST
3385 && (unsigned0
|| !uns
)
3386 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3387 < TYPE_PRECISION (result_type
))
3388 && (type
= signed_or_unsigned_type (unsigned0
,
3390 int_fits_type_p (arg1
, type
)))
3394 /* Shifts can be shortened if shifting right. */
3399 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3401 final_type
= result_type
;
3403 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3404 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3406 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3407 /* If arg is sign-extended and then unsigned-shifted,
3408 we can simulate this with a signed shift in arg's type
3409 only if the extended result is at least twice as wide
3410 as the arg. Otherwise, the shift could use up all the
3411 ones made by sign-extension and bring in zeros.
3412 We can't optimize that case at all, but in most machines
3413 it never happens because available widths are 2**N. */
3414 && (!TREE_UNSIGNED (final_type
)
3416 || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
))
3417 <= TYPE_PRECISION (result_type
))))
3419 /* Do an unsigned shift if the operand was zero-extended. */
3421 = signed_or_unsigned_type (unsigned_arg
,
3423 /* Convert value-to-be-shifted to that type. */
3424 if (TREE_TYPE (op0
) != result_type
)
3425 op0
= convert (result_type
, op0
);
3430 /* Comparison operations are shortened too but differently.
3431 They identify themselves by setting short_compare = 1. */
3435 /* Don't write &op0, etc., because that would prevent op0
3436 from being kept in a register.
3437 Instead, make copies of the our local variables and
3438 pass the copies by reference, then copy them back afterward. */
3439 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3440 enum tree_code xresultcode
= resultcode
;
3442 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3444 return convert (bool_type_node
, val
);
3445 op0
= xop0
, op1
= xop1
, result_type
= bool_type_node
;
3446 resultcode
= xresultcode
;
3449 if (short_compare
&& extra_warnings
)
3451 int unsignedp0
, unsignedp1
;
3452 tree primop0
= get_narrower (op0
, &unsignedp0
);
3453 tree primop1
= get_narrower (op1
, &unsignedp1
);
3455 /* Warn if signed and unsigned are being compared in a size larger
3456 than their original size, as this will always fail. */
3458 if (unsignedp0
!= unsignedp1
3459 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3460 < TYPE_PRECISION (result_type
))
3461 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3462 < TYPE_PRECISION (result_type
)))
3463 warning ("comparison between promoted unsigned and signed");
3465 /* Warn if two unsigned values are being compared in a size
3466 larger than their original size, and one (and only one) is the
3467 result of a `~' operator. This comparison will always fail.
3469 Also warn if one operand is a constant, and the constant does not
3470 have all bits set that are set in the ~ operand when it is
3473 else if (TREE_CODE (primop0
) == BIT_NOT_EXPR
3474 ^ TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3476 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3477 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3478 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3479 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3481 if (TREE_CODE (primop0
) == INTEGER_CST
3482 || TREE_CODE (primop1
) == INTEGER_CST
)
3485 HOST_WIDE_INT constant
, mask
;
3489 if (TREE_CODE (primop0
) == INTEGER_CST
)
3492 unsignedp
= unsignedp1
;
3493 constant
= TREE_INT_CST_LOW (primop0
);
3498 unsignedp
= unsignedp0
;
3499 constant
= TREE_INT_CST_LOW (primop1
);
3502 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3503 if (bits
< TYPE_PRECISION (result_type
)
3504 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3506 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3507 if ((mask
& constant
) != mask
)
3508 warning ("comparison of promoted ~unsigned with constant");
3511 else if (unsignedp0
&& unsignedp1
3512 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3513 < TYPE_PRECISION (result_type
))
3514 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3515 < TYPE_PRECISION (result_type
)))
3516 warning ("comparison of promoted ~unsigned with unsigned");
3521 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3522 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3523 Then the expression will be built.
3524 It will be given type FINAL_TYPE if that is nonzero;
3525 otherwise, it will be given type RESULT_TYPE. */
3529 binary_op_error (error_code
);
3530 return error_mark_node
;
3535 if (TREE_TYPE (op0
) != result_type
)
3536 op0
= convert (result_type
, op0
);
3537 if (TREE_TYPE (op1
) != result_type
)
3538 op1
= convert (result_type
, op1
);
3542 register tree result
= build (resultcode
, result_type
, op0
, op1
);
3543 register tree folded
;
3545 folded
= fold (result
);
3546 if (folded
== result
)
3547 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3548 if (final_type
!= 0)
3549 return convert (final_type
, folded
);
3554 /* Return a tree for the sum or difference (RESULTCODE says which)
3555 of pointer PTROP and integer INTOP. */
3558 pointer_int_sum (resultcode
, ptrop
, intop
)
3559 enum tree_code resultcode
;
3560 register tree ptrop
, intop
;
3564 register tree result
;
3565 register tree folded
= fold (intop
);
3567 /* The result is a pointer of the same type that is being added. */
3569 register tree result_type
= TREE_TYPE (ptrop
);
3571 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3573 if (pedantic
|| warn_pointer_arith
)
3574 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3575 size_exp
= integer_one_node
;
3577 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3579 if (pedantic
|| warn_pointer_arith
)
3580 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3581 size_exp
= integer_one_node
;
3583 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3585 if (pedantic
|| warn_pointer_arith
)
3586 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
3587 size_exp
= integer_one_node
;
3589 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
3592 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
3593 size_exp
= integer_one_node
;
3596 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3598 /* Needed to make OOPS V2R3 work. */
3600 if (TREE_CODE (intop
) == INTEGER_CST
3601 && TREE_INT_CST_LOW (intop
) == 0
3602 && TREE_INT_CST_HIGH (intop
) == 0)
3605 /* If what we are about to multiply by the size of the elements
3606 contains a constant term, apply distributive law
3607 and multiply that constant term separately.
3608 This helps produce common subexpressions. */
3610 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3611 && ! TREE_CONSTANT (intop
)
3612 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3613 && TREE_CONSTANT (size_exp
))
3615 enum tree_code subcode
= resultcode
;
3616 if (TREE_CODE (intop
) == MINUS_EXPR
)
3617 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3618 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
3619 intop
= TREE_OPERAND (intop
, 0);
3622 /* Convert the integer argument to a type the same size as a pointer
3623 so the multiply won't overflow spuriously. */
3625 if (TYPE_PRECISION (TREE_TYPE (intop
)) != POINTER_SIZE
)
3626 intop
= convert (type_for_size (POINTER_SIZE
, 0), intop
);
3628 /* Replace the integer argument with a suitable product by the object size.
3629 Do this multiplication as signed, then convert to the appropriate
3630 pointer type (actually unsigned integral). */
3632 intop
= convert (result_type
,
3633 build_binary_op (MULT_EXPR
, intop
,
3634 convert (TREE_TYPE (intop
), size_exp
), 1));
3636 /* Create the sum or difference. */
3638 result
= build (resultcode
, result_type
, ptrop
, intop
);
3640 folded
= fold (result
);
3641 if (folded
== result
)
3642 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
3646 /* Return a tree for the difference of pointers OP0 and OP1.
3647 The resulting tree has type int. */
3650 pointer_diff (op0
, op1
)
3651 register tree op0
, op1
;
3653 register tree result
, folded
;
3654 tree restype
= ptrdiff_type_node
;
3655 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3659 if (TREE_CODE (target_type
) == VOID_TYPE
)
3660 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
3661 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3662 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
3663 if (TREE_CODE (target_type
) == METHOD_TYPE
)
3664 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
3665 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
3666 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
3669 /* First do the subtraction as integers;
3670 then drop through to build the divide operator. */
3672 op0
= build_binary_op (MINUS_EXPR
,
3673 convert (restype
, op0
), convert (restype
, op1
), 1);
3675 /* This generates an error if op1 is a pointer to an incomplete type. */
3676 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
3677 error ("arithmetic on pointer to an incomplete type");
3679 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
3680 || TREE_CODE (target_type
) == FUNCTION_TYPE
3681 || TREE_CODE (target_type
) == METHOD_TYPE
3682 || TREE_CODE (target_type
) == OFFSET_TYPE
)
3684 : size_in_bytes (target_type
));
3686 /* Do the division. */
3688 result
= build (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
));
3690 folded
= fold (result
);
3691 if (folded
== result
)
3692 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3696 /* Handle the case of taking the address of a COMPONENT_REF.
3697 Called by `build_unary_op' and `build_up_reference'.
3699 ARG is the COMPONENT_REF whose address we want.
3700 ARGTYPE is the pointer type that this address should have.
3701 MSG is an error message to print if this COMPONENT_REF is not
3702 addressable (such as a bitfield). */
3705 build_component_addr (arg
, argtype
, msg
)
3709 tree field
= TREE_OPERAND (arg
, 1);
3710 tree basetype
= decl_type_context (field
);
3711 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
3713 if (DECL_BIT_FIELD (field
))
3715 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
3716 return error_mark_node
;
3720 cp_warning ("address of `%T::%D' taken", basetype
, field
);
3722 if (TREE_CODE (field
) == FIELD_DECL
3723 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
3725 /* Can't convert directly to ARGTYPE, since that
3726 may have the same pointer type as one of our
3728 rval
= build1 (NOP_EXPR
, argtype
,
3729 convert_pointer_to (basetype
, rval
));
3730 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
3733 /* This conversion is harmless. */
3734 rval
= convert_force (argtype
, rval
);
3736 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
3738 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
3739 size_int (BITS_PER_UNIT
));
3740 int flag
= TREE_CONSTANT (rval
);
3741 rval
= fold (build (PLUS_EXPR
, argtype
,
3742 rval
, convert (argtype
, offset
)));
3743 TREE_CONSTANT (rval
) = flag
;
3748 /* Construct and perhaps optimize a tree representation
3749 for a unary operation. CODE, a tree_code, specifies the operation
3750 and XARG is the operand. */
3753 build_x_unary_op (code
, xarg
)
3754 enum tree_code code
;
3757 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3759 if (code
!= ADDR_EXPR
|| TREE_CODE (TREE_TYPE (xarg
)) != RECORD_TYPE
3760 || TYPE_SIZE (TREE_TYPE (xarg
)))
3762 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
, xarg
,
3763 NULL_TREE
, NULL_TREE
);
3765 return build_opfncall (code
, LOOKUP_NORMAL
, xarg
,
3766 NULL_TREE
, NULL_TREE
);
3768 return build_unary_op (code
, xarg
, 0);
3771 /* Just like truthvalue_conversion, but we want a BOOLEAN_TYPE */
3773 bool_truthvalue_conversion (expr
)
3776 /* We really want to preform the optimizations in truthvalue_conversion
3777 but, not this way. */
3778 /* expr = truthvalue_conversion (expr); */
3779 return convert (bool_type_node
, expr
);
3782 /* C++: Must handle pointers to members.
3784 Perhaps type instantiation should be extended to handle conversion
3785 from aggregates to types we don't yet know we want? (Or are those
3786 cases typically errors which should be reported?)
3788 NOCONVERT nonzero suppresses the default promotions
3789 (such as from short to int). */
3791 build_unary_op (code
, xarg
, noconvert
)
3792 enum tree_code code
;
3796 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3797 register tree arg
= xarg
;
3798 register tree argtype
= 0;
3799 register enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
3800 char *errstring
= NULL
;
3804 if (typecode
== ERROR_MARK
)
3805 return error_mark_node
;
3807 if (typecode
== REFERENCE_TYPE
&& code
!= ADDR_EXPR
&& ! noconvert
)
3809 arg
= convert_from_reference (arg
);
3810 typecode
= TREE_CODE (TREE_TYPE (arg
));
3813 if (typecode
== ENUMERAL_TYPE
)
3814 typecode
= INTEGER_TYPE
;
3816 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3821 /* This is used for unary plus, because a CONVERT_EXPR
3822 is enough to prevent anybody from looking inside for
3823 associativity, but won't generate any code. */
3824 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3825 errstring
= "wrong type argument to unary plus";
3826 else if (!noconvert
)
3827 arg
= default_conversion (arg
);
3834 arg
= default_conversion (arg
);
3837 cp_error ("type conversion for type `%T' not allowed",
3839 return error_mark_node
;
3841 typecode
= TREE_CODE (TREE_TYPE (arg
));
3845 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3846 errstring
= "wrong type argument to unary minus";
3847 else if (!noconvert
)
3848 arg
= default_conversion (arg
);
3855 arg
= default_conversion (arg
);
3858 cp_error ("type conversion for type `%T' not allowed",
3860 return error_mark_node
;
3862 typecode
= TREE_CODE (TREE_TYPE (arg
));
3866 if (typecode
!= INTEGER_TYPE
)
3867 errstring
= "wrong type argument to bit-complement";
3868 else if (!noconvert
)
3869 arg
= default_conversion (arg
);
3876 arg
= default_conversion (arg
);
3879 cp_error ("type conversion for type `%T' not allowed",
3881 return error_mark_node
;
3883 typecode
= TREE_CODE (TREE_TYPE (arg
));
3887 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3888 errstring
= "wrong type argument to abs";
3889 else if (!noconvert
)
3890 arg
= default_conversion (arg
);
3893 case TRUTH_NOT_EXPR
:
3894 arg
= bool_truthvalue_conversion (arg
);
3895 val
= invert_truthvalue (arg
);
3896 if (arg
!= error_mark_node
)
3898 errstring
= "in argument to unary !";
3904 case PREINCREMENT_EXPR
:
3905 case POSTINCREMENT_EXPR
:
3906 case PREDECREMENT_EXPR
:
3907 case POSTDECREMENT_EXPR
:
3908 /* Handle complex lvalues (when permitted)
3909 by reduction to simpler cases. */
3911 val
= unary_complex_lvalue (code
, arg
);
3915 /* Report invalid types. */
3919 arg
= default_conversion (arg
);
3920 typecode
= TREE_CODE (TREE_TYPE (arg
));
3923 if (typecode
!= POINTER_TYPE
3924 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
3926 if (code
== PREINCREMENT_EXPR
)
3927 errstring
="no pre-increment operator for type";
3928 else if (code
== POSTINCREMENT_EXPR
)
3929 errstring
="no post-increment operator for type";
3930 else if (code
== PREDECREMENT_EXPR
)
3931 errstring
="no pre-decrement operator for type";
3933 errstring
="no post-decrement operator for type";
3937 /* Report something read-only. */
3939 if (TYPE_READONLY (TREE_TYPE (arg
))
3940 || TREE_READONLY (arg
))
3941 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
3942 || code
== POSTINCREMENT_EXPR
)
3943 ? "increment" : "decrement"),
3948 tree result_type
= TREE_TYPE (arg
);
3950 arg
= get_unwidened (arg
, 0);
3951 argtype
= TREE_TYPE (arg
);
3953 /* ARM $5.2.5 last annotation says this should be forbidden. */
3954 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
3955 pedwarn ("ANSI C++ forbids %sing an enum",
3956 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3957 ? "increment" : "decrement");
3959 /* Compute the increment. */
3961 if (typecode
== POINTER_TYPE
)
3963 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
3964 if (TYPE_SIZE (TREE_TYPE (argtype
)) == 0)
3965 cp_error ("cannot %s a pointer to incomplete type `%T'",
3966 ((code
== PREINCREMENT_EXPR
3967 || code
== POSTINCREMENT_EXPR
)
3968 ? "increment" : "decrement"), TREE_TYPE (argtype
));
3969 else if (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
3970 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
)
3971 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
3972 ((code
== PREINCREMENT_EXPR
3973 || code
== POSTINCREMENT_EXPR
)
3974 ? "increment" : "decrement"), argtype
);
3975 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
3978 inc
= integer_one_node
;
3980 inc
= convert (argtype
, inc
);
3982 /* Handle incrementing a cast-expression. */
3984 switch (TREE_CODE (arg
))
3989 case FIX_TRUNC_EXPR
:
3990 case FIX_FLOOR_EXPR
:
3991 case FIX_ROUND_EXPR
:
3994 tree incremented
, modify
, value
;
3995 if (! lvalue_p (arg
) && pedantic
)
3996 pedwarn ("cast to non-reference type used as lvalue");
3997 arg
= stabilize_reference (arg
);
3998 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4001 value
= save_expr (arg
);
4002 incremented
= build (((code
== PREINCREMENT_EXPR
4003 || code
== POSTINCREMENT_EXPR
)
4004 ? PLUS_EXPR
: MINUS_EXPR
),
4005 argtype
, value
, inc
);
4006 TREE_SIDE_EFFECTS (incremented
) = 1;
4007 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4008 return build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4012 if (TREE_CODE (arg
) == OFFSET_REF
)
4013 arg
= resolve_offset_ref (arg
);
4015 /* Complain about anything else that is not a true lvalue. */
4016 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4017 || code
== POSTINCREMENT_EXPR
)
4018 ? "increment" : "decrement")))
4019 return error_mark_node
;
4021 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4022 TREE_SIDE_EFFECTS (val
) = 1;
4023 return convert (result_type
, val
);
4027 /* Note that this operation never does default_conversion
4028 regardless of NOCONVERT. */
4030 if (typecode
== REFERENCE_TYPE
)
4032 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4033 TREE_REFERENCE_EXPR (arg
) = 1;
4037 && TREE_CODE (arg
) == FUNCTION_DECL
4039 && DECL_CONTEXT (arg
) == NULL_TREE
4040 && IDENTIFIER_LENGTH (DECL_NAME (arg
)) == 4
4041 && IDENTIFIER_POINTER (DECL_NAME (arg
))[0] == 'm'
4042 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg
)), "main"))
4044 pedwarn ("taking address of function `main'");
4046 /* Let &* cancel out to simplify resulting code. */
4047 if (TREE_CODE (arg
) == INDIRECT_REF
)
4049 /* We don't need to have `current_class_decl' wrapped in a
4050 NON_LVALUE_EXPR node. */
4052 return current_class_decl
;
4054 /* Keep `default_conversion' from converting if
4055 ARG is of REFERENCE_TYPE. */
4056 arg
= TREE_OPERAND (arg
, 0);
4057 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4059 if (TREE_CODE (arg
) == VAR_DECL
&& DECL_INITIAL (arg
)
4060 && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg
)))
4061 arg
= DECL_INITIAL (arg
);
4062 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4063 TREE_REFERENCE_EXPR (arg
) = 1;
4064 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4066 else if (lvalue_p (arg
))
4067 /* Don't let this be an lvalue. */
4068 return non_lvalue (arg
);
4072 /* For &x[y], return x+y */
4073 if (TREE_CODE (arg
) == ARRAY_REF
)
4075 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4076 return error_mark_node
;
4077 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4078 TREE_OPERAND (arg
, 1), 1);
4081 /* For &(++foo), we are really taking the address of the variable
4082 being acted upon by the increment/decrement operator. ARM $5.3.1
4083 However, according to ARM $5.2.5, we don't allow postfix ++ and
4084 --, since the prefix operators return lvalues, but the postfix
4085 operators do not. */
4086 if (TREE_CODE (arg
) == PREINCREMENT_EXPR
4087 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4088 arg
= TREE_OPERAND (arg
, 0);
4090 /* Uninstantiated types are all functions. Taking the
4091 address of a function is a no-op, so just return the
4094 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4095 && IDENTIFIER_OPNAME_P (arg
))
4097 my_friendly_abort (117);
4098 /* We don't know the type yet, so just work around the problem.
4099 We know that this will resolve to an lvalue. */
4100 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4103 if (TREE_CODE (arg
) == TREE_LIST
)
4105 if (TREE_CODE (TREE_VALUE (arg
)) == FUNCTION_DECL
4106 && DECL_CHAIN (TREE_VALUE (arg
)) == NULL_TREE
)
4107 /* Unique overloaded non-member function. */
4108 return build_unary_op (ADDR_EXPR
, TREE_VALUE (arg
), 0);
4109 if (TREE_CHAIN (arg
) == NULL_TREE
4110 && TREE_CODE (TREE_VALUE (arg
)) == TREE_LIST
4111 && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg
))) == NULL_TREE
)
4112 /* Unique overloaded member function. */
4113 return build_unary_op (ADDR_EXPR
, TREE_VALUE (TREE_VALUE (arg
)),
4115 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4118 /* Handle complex lvalues (when permitted)
4119 by reduction to simpler cases. */
4120 val
= unary_complex_lvalue (code
, arg
);
4124 switch (TREE_CODE (arg
))
4129 case FIX_TRUNC_EXPR
:
4130 case FIX_FLOOR_EXPR
:
4131 case FIX_ROUND_EXPR
:
4133 if (! lvalue_p (arg
) && pedantic
)
4134 pedwarn ("taking the address of a cast to non-reference type");
4137 /* Allow the address of a constructor if all the elements
4139 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_CONSTANT (arg
))
4141 /* Anything not already handled and not a true memory reference
4143 else if (typecode
!= FUNCTION_TYPE
4144 && typecode
!= METHOD_TYPE
4145 && !lvalue_or_else (arg
, "unary `&'"))
4146 return error_mark_node
;
4148 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4149 argtype
= TREE_TYPE (arg
);
4150 /* If the lvalue is const or volatile,
4151 merge that into the type that the address will point to. */
4152 if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'd'
4153 || TREE_CODE_CLASS (TREE_CODE (arg
)) == 'r')
4155 if (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4156 argtype
= cp_build_type_variant (argtype
,
4157 TREE_READONLY (arg
),
4158 TREE_THIS_VOLATILE (arg
));
4161 argtype
= build_pointer_type (argtype
);
4163 if (mark_addressable (arg
) == 0)
4164 return error_mark_node
;
4169 if (TREE_CODE (arg
) == COMPONENT_REF
)
4170 addr
= build_component_addr (arg
, argtype
,
4171 "attempt to take address of bit-field structure member `%s'");
4173 addr
= build1 (code
, argtype
, arg
);
4175 /* Address of a static or external variable or
4176 function counts as a constant */
4178 TREE_CONSTANT (addr
) = 1;
4186 argtype
= TREE_TYPE (arg
);
4187 return fold (build1 (code
, argtype
, arg
));
4191 return error_mark_node
;
4194 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4195 convert ARG with the same conversions in the same order
4196 and return the result. */
4199 convert_sequence (conversions
, arg
)
4203 switch (TREE_CODE (conversions
))
4208 case FIX_TRUNC_EXPR
:
4209 case FIX_FLOOR_EXPR
:
4210 case FIX_ROUND_EXPR
:
4212 return convert (TREE_TYPE (conversions
),
4213 convert_sequence (TREE_OPERAND (conversions
, 0),
4221 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4222 for certain kinds of expressions which are not really lvalues
4223 but which we can accept as lvalues.
4225 If ARG is not a kind of expression we can handle, return zero. */
4228 unary_complex_lvalue (code
, arg
)
4229 enum tree_code code
;
4232 /* Handle (a, b) used as an "lvalue". */
4233 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4235 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4236 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4237 TREE_OPERAND (arg
, 0), real_result
);
4240 /* Handle (a ? b : c) used as an "lvalue". */
4241 if (TREE_CODE (arg
) == COND_EXPR
)
4242 return rationalize_conditional_expr (code
, arg
);
4244 if (TREE_CODE (arg
) == MODIFY_EXPR
)
4245 return unary_complex_lvalue
4246 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4247 arg
, TREE_OPERAND (arg
, 0)));
4249 if (code
!= ADDR_EXPR
)
4252 /* Handle (a = b) used as an "lvalue" for `&'. */
4253 if (TREE_CODE (arg
) == MODIFY_EXPR
4254 || TREE_CODE (arg
) == INIT_EXPR
)
4256 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4257 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4260 if (TREE_CODE (arg
) == WITH_CLEANUP_EXPR
)
4262 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4263 real_result
= build (WITH_CLEANUP_EXPR
, TREE_TYPE (real_result
),
4264 real_result
, 0, TREE_OPERAND (arg
, 2));
4268 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4269 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4270 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4272 /* The representation of something of type OFFSET_TYPE
4273 is really the representation of a pointer to it.
4274 Here give the representation its true type. */
4278 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4280 if (TREE_CODE (arg
) != OFFSET_REF
)
4283 t
= TREE_OPERAND (arg
, 1);
4285 if (TREE_CODE (t
) == FUNCTION_DECL
) /* Check all this code for right semantics. */
4286 return build_unary_op (ADDR_EXPR
, t
, 0);
4287 if (TREE_CODE (t
) == VAR_DECL
)
4288 return build_unary_op (ADDR_EXPR
, t
, 0);
4291 /* Can't build a pointer to member if the member must
4292 go through virtual base classes. */
4293 if (virtual_member (DECL_FIELD_CONTEXT (t
),
4294 CLASSTYPE_VBASECLASSES (TREE_TYPE (TREE_OPERAND (arg
, 0)))))
4296 sorry ("pointer to member via virtual baseclass");
4297 return error_mark_node
;
4300 if (TREE_OPERAND (arg
, 0)
4301 && (TREE_CODE (TREE_OPERAND (arg
, 0)) != NOP_EXPR
4302 || TREE_OPERAND (TREE_OPERAND (arg
, 0), 0) != error_mark_node
))
4304 /* Don't know if this should return address to just
4305 _DECL, or actual address resolved in this expression. */
4306 sorry ("address of bound pointer-to-member expression");
4307 return error_mark_node
;
4310 return convert (build_pointer_type (TREE_TYPE (arg
)),
4311 size_binop (EASY_DIV_EXPR
,
4312 DECL_FIELD_BITPOS (t
),
4313 size_int (BITS_PER_UNIT
)));
4317 if (TREE_CODE (arg
) == OFFSET_REF
)
4319 tree left
= TREE_OPERAND (arg
, 0), left_addr
;
4320 tree right_addr
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 1), 0);
4323 if (current_class_decl
)
4324 left_addr
= current_class_decl
;
4327 error ("no `this' for pointer to member");
4328 return error_mark_node
;
4331 left_addr
= build_unary_op (ADDR_EXPR
, left
, 0);
4333 return build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4334 build1 (NOP_EXPR
, integer_type_node
, left_addr
),
4335 build1 (NOP_EXPR
, integer_type_node
, right_addr
));
4338 /* We permit compiler to make function calls returning
4339 objects of aggregate type look like lvalues. */
4343 if (TREE_CODE (targ
) == SAVE_EXPR
)
4344 targ
= TREE_OPERAND (targ
, 0);
4346 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4348 if (TREE_CODE (arg
) == SAVE_EXPR
)
4351 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, 1);
4352 return build1 (ADDR_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)), targ
);
4355 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4356 return build (SAVE_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)),
4357 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4359 /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
4360 we do, here's how to handle it. */
4361 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == WITH_CLEANUP_EXPR
)
4364 /* Not really a bug, but something to turn on when testing. */
4365 compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
4367 return unary_complex_lvalue (ADDR_EXPR
, targ
);
4371 /* Don't let anything else be handled specially. */
4375 /* Mark EXP saying that we need to be able to take the
4376 address of it; it should not be allocated in a register.
4377 Value is 1 if successful.
4379 C++: we do not allow `current_class_decl' to be addressable. */
4382 mark_addressable (exp
)
4385 register tree x
= exp
;
4387 if (TREE_ADDRESSABLE (x
) == 1)
4391 switch (TREE_CODE (x
))
4396 x
= TREE_OPERAND (x
, 0);
4400 if (x
== current_class_decl
)
4402 error ("address of `this' not available");
4403 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4404 put_var_into_stack (x
);
4409 && TREE_READONLY (x
)
4410 && DECL_RTL (x
) != 0
4411 && ! decl_in_memory_p (x
))
4413 /* We thought this would make a good constant variable,
4414 but we were wrong. */
4415 push_obstacks_nochange ();
4416 end_temporary_allocation ();
4418 TREE_ASM_WRITTEN (x
) = 0;
4420 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0, 0);
4421 TREE_ADDRESSABLE (x
) = 1;
4427 /* Caller should not be trying to mark initialized
4428 constant fields addressable. */
4429 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4430 || DECL_IN_AGGR_P (x
) == 0
4432 || DECL_EXTERNAL (x
), 314);
4436 /* For C++, we don't warn about taking the address of a register
4437 variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
4438 put_var_into_stack (x
);
4439 TREE_ADDRESSABLE (x
) = 1;
4443 /* We have to test both conditions here. The first may
4444 be non-zero in the case of processing a default function.
4445 The second may be non-zero in the case of a template function. */
4446 x
= DECL_MAIN_VARIANT (x
);
4447 if ((DECL_INLINE (x
) || DECL_PENDING_INLINE_INFO (x
))
4448 && (DECL_CONTEXT (x
) == NULL_TREE
4449 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x
))) != 't'
4450 || ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x
))))
4452 mark_inline_for_output (x
);
4453 if (x
== current_function_decl
)
4454 DECL_EXTERNAL (x
) = 0;
4456 TREE_ADDRESSABLE (x
) = 1;
4458 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4466 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4469 build_x_conditional_expr (ifexp
, op1
, op2
)
4470 tree ifexp
, op1
, op2
;
4472 tree rval
= NULL_TREE
;
4474 /* See comments in `build_x_binary_op'. */
4476 rval
= build_opfncall (COND_EXPR
, LOOKUP_SPECULATIVELY
, ifexp
, op1
, op2
);
4478 return build_opfncall (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4480 return build_conditional_expr (ifexp
, op1
, op2
);
4484 build_conditional_expr (ifexp
, op1
, op2
)
4485 tree ifexp
, op1
, op2
;
4487 register tree type1
;
4488 register tree type2
;
4489 register enum tree_code code1
;
4490 register enum tree_code code2
;
4491 register tree result_type
= NULL_TREE
;
4492 tree orig_op1
= op1
, orig_op2
= op2
;
4494 /* If second operand is omitted, it is the same as the first one;
4495 make sure it is calculated only once. */
4499 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4500 ifexp
= op1
= save_expr (ifexp
);
4503 ifexp
= bool_truthvalue_conversion (default_conversion (ifexp
));
4505 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4506 return error_mark_node
;
4508 op1
= require_instantiated_type (TREE_TYPE (op2
), op1
, error_mark_node
);
4509 if (op1
== error_mark_node
)
4510 return error_mark_node
;
4511 op2
= require_instantiated_type (TREE_TYPE (op1
), op2
, error_mark_node
);
4512 if (op2
== error_mark_node
)
4513 return error_mark_node
;
4515 /* C++: REFERENCE_TYPES must be dereferenced. */
4516 type1
= TREE_TYPE (op1
);
4517 code1
= TREE_CODE (type1
);
4518 type2
= TREE_TYPE (op2
);
4519 code2
= TREE_CODE (type2
);
4521 if (code1
== REFERENCE_TYPE
)
4523 op1
= convert_from_reference (op1
);
4524 type1
= TREE_TYPE (op1
);
4525 code1
= TREE_CODE (type1
);
4527 if (code2
== REFERENCE_TYPE
)
4529 op2
= convert_from_reference (op2
);
4530 type2
= TREE_TYPE (op2
);
4531 code2
= TREE_CODE (type2
);
4534 #if 1 /* Produces wrong result if within sizeof. Sorry. */
4535 /* Don't promote the operands separately if they promote
4536 the same way. Return the unpromoted type and let the combined
4537 value get promoted if necessary. */
4539 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4540 && code2
!= ARRAY_TYPE
4542 /* For C++, let the enumeral type come through. */
4543 && code2
!= ENUMERAL_TYPE
4545 && code2
!= FUNCTION_TYPE
4546 && code2
!= METHOD_TYPE
)
4550 if (TREE_CONSTANT (ifexp
)
4551 && (TREE_CODE (ifexp
) == INTEGER_CST
4552 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4553 return (integer_zerop (ifexp
) ? op2
: op1
);
4555 if (TREE_CODE (op1
) == CONST_DECL
)
4556 op1
= DECL_INITIAL (op1
);
4557 else if (TREE_READONLY_DECL_P (op1
))
4558 op1
= decl_constant_value (op1
);
4559 if (TREE_CODE (op2
) == CONST_DECL
)
4560 op2
= DECL_INITIAL (op2
);
4561 else if (TREE_READONLY_DECL_P (op2
))
4562 op2
= decl_constant_value (op2
);
4564 type1
= cp_build_type_variant
4566 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4567 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4568 /* ??? This is a kludge to deal with the fact that
4569 we don't sort out integers and enums properly, yet. */
4570 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4571 if (TREE_TYPE (result
) != type1
)
4572 result
= build1 (NOP_EXPR
, type1
, result
);
4577 /* They don't match; promote them both and then try to reconcile them.
4578 But don't permit mismatching enum types. */
4579 if (code1
== ENUMERAL_TYPE
)
4581 if (code2
== ENUMERAL_TYPE
)
4583 message_2_types (error
, "enumeral mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4584 return error_mark_node
;
4586 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
))
4587 warning ("enumeral and non-enumeral type in conditional expression");
4589 else if (extra_warnings
4590 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
))
4591 warning ("enumeral and non-enumeral type in conditional expression");
4593 if (code1
!= VOID_TYPE
)
4595 op1
= default_conversion (op1
);
4596 type1
= TREE_TYPE (op1
);
4597 code1
= TREE_CODE (type1
);
4599 if (code2
!= VOID_TYPE
)
4601 op2
= default_conversion (op2
);
4602 type2
= TREE_TYPE (op2
);
4603 code2
= TREE_CODE (type2
);
4606 /* Quickly detect the usual case where op1 and op2 have the same type
4608 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4611 result_type
= type1
;
4613 result_type
= cp_build_type_variant
4615 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4616 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4618 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
4619 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
4621 result_type
= common_type (type1
, type2
);
4623 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4625 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
4626 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
4627 result_type
= void_type_node
;
4629 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4631 if (comp_target_types (type1
, type2
, 1))
4632 result_type
= common_type (type1
, type2
);
4633 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
4634 && TREE_CODE (orig_op1
) != NOP_EXPR
)
4635 result_type
= qualify_type (type2
, type1
);
4636 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
4637 && TREE_CODE (orig_op2
) != NOP_EXPR
)
4638 result_type
= qualify_type (type1
, type2
);
4639 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
4641 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4642 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4643 result_type
= qualify_type (type1
, type2
);
4645 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
4647 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4648 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4649 result_type
= qualify_type (type2
, type1
);
4652 else if (comptypes (type2
, type1
, 0))
4653 result_type
= type2
;
4654 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
4655 && IS_AGGR_TYPE (TREE_TYPE (type2
))
4656 && (result_type
= common_base_type (TREE_TYPE (type1
), TREE_TYPE (type2
))))
4658 if (result_type
== error_mark_node
)
4660 cp_error ("common base type of types `%T' and `%T' is ambiguous",
4661 TREE_TYPE (type1
), TREE_TYPE (type2
));
4662 result_type
= ptr_type_node
;
4667 && result_type
!= TREE_TYPE (type1
)
4668 && result_type
!= TREE_TYPE (type2
))
4669 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
4670 type1
, type2
, result_type
);
4672 result_type
= TYPE_POINTER_TO (result_type
);
4677 pedwarn ("pointer type mismatch in conditional expression");
4678 result_type
= ptr_type_node
;
4681 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4683 if (!integer_zerop (op2
))
4684 pedwarn ("pointer/integer type mismatch in conditional expression");
4687 op2
= null_pointer_node
;
4688 #if 0 /* Sez who? */
4689 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4690 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4693 result_type
= type1
;
4695 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4697 if (!integer_zerop (op1
))
4698 pedwarn ("pointer/integer type mismatch in conditional expression");
4701 op1
= null_pointer_node
;
4702 #if 0 /* Sez who? */
4703 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4704 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4707 result_type
= type2
;
4712 /* The match does not look good. If either is
4713 an aggregate value, try converting to a scalar type. */
4714 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
4716 message_2_types (error
, "aggregate mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4717 return error_mark_node
;
4719 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
4721 tree tmp
= build_type_conversion (CONVERT_EXPR
, type2
, op1
, 0);
4722 if (tmp
== NULL_TREE
)
4724 cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1
);
4725 return error_mark_node
;
4727 if (tmp
== error_mark_node
)
4728 error ("ambiguous pointer conversion");
4729 result_type
= type2
;
4732 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
4734 tree tmp
= build_type_conversion (CONVERT_EXPR
, type1
, op2
, 0);
4735 if (tmp
== NULL_TREE
)
4737 cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2
);
4738 return error_mark_node
;
4740 if (tmp
== error_mark_node
)
4741 error ("ambiguous pointer conversion");
4742 result_type
= type1
;
4745 else if (flag_cond_mismatch
)
4746 result_type
= void_type_node
;
4749 error ("type mismatch in conditional expression");
4750 return error_mark_node
;
4754 if (result_type
!= TREE_TYPE (op1
))
4755 op1
= convert_and_check (result_type
, op1
);
4756 if (result_type
!= TREE_TYPE (op2
))
4757 op2
= convert_and_check (result_type
, op2
);
4760 /* XXX delete me, I've been here for years. */
4761 if (IS_AGGR_TYPE_CODE (code1
))
4763 result_type
= TREE_TYPE (op1
);
4764 if (TREE_CONSTANT (ifexp
))
4765 return (integer_zerop (ifexp
) ? op2
: op1
);
4767 if (TYPE_MODE (result_type
) == BLKmode
)
4769 register tree tempvar
4770 = build_decl (VAR_DECL
, NULL_TREE
, result_type
);
4771 register tree xop1
= build_modify_expr (tempvar
, NOP_EXPR
, op1
);
4772 register tree xop2
= build_modify_expr (tempvar
, NOP_EXPR
, op2
);
4773 register tree result
= fold (build (COND_EXPR
, result_type
,
4774 ifexp
, xop1
, xop2
));
4776 layout_decl (tempvar
, 0);
4777 /* No way to handle variable-sized objects here.
4778 I fear that the entire handling of BLKmode conditional exprs
4779 needs to be redone. */
4780 my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar
)), 315);
4782 = assign_stack_local (DECL_MODE (tempvar
),
4783 (TREE_INT_CST_LOW (DECL_SIZE (tempvar
))
4784 + BITS_PER_UNIT
- 1)
4788 TREE_SIDE_EFFECTS (result
)
4789 = TREE_SIDE_EFFECTS (ifexp
) | TREE_SIDE_EFFECTS (op1
)
4790 | TREE_SIDE_EFFECTS (op2
);
4791 return build (COMPOUND_EXPR
, result_type
, result
, tempvar
);
4796 if (TREE_CONSTANT (ifexp
))
4797 return integer_zerop (ifexp
) ? op2
: op1
;
4799 return fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
4802 /* Handle overloading of the ',' operator when needed. Otherwise,
4803 this function just builds an expression list. */
4805 build_x_compound_expr (list
)
4808 tree rest
= TREE_CHAIN (list
);
4811 if (rest
== NULL_TREE
)
4812 return build_compound_expr (list
);
4814 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
4815 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
4817 return build_x_compound_expr (tree_cons (NULL_TREE
, result
, TREE_CHAIN (rest
)));
4818 return build_compound_expr (tree_cons (NULL_TREE
, TREE_VALUE (list
),
4819 build_tree_list (NULL_TREE
, build_x_compound_expr (rest
))));
4822 /* Given a list of expressions, return a compound expression
4823 that performs them all and returns the value of the last of them. */
4826 build_compound_expr (list
)
4831 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
4832 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
4834 if (TREE_CHAIN (list
) == 0)
4836 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4837 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4838 if (TREE_CODE (list
) == NOP_EXPR
4839 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
4840 list
= TREE_OPERAND (list
, 0);
4842 /* Convert arrays to pointers. */
4843 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
4844 return default_conversion (TREE_VALUE (list
));
4846 return TREE_VALUE (list
);
4849 rest
= build_compound_expr (TREE_CHAIN (list
));
4851 /* When pedantic, a compound expression can be neither an lvalue
4852 nor an integer constant expression. */
4853 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
4856 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
4857 break_out_cleanups (TREE_VALUE (list
)), rest
);
4860 tree
build_static_cast (type
, expr
)
4863 return build_c_cast (type
, expr
);
4866 tree
build_reinterpret_cast (type
, expr
)
4869 return build_c_cast (type
, expr
);
4872 tree
build_const_cast (type
, expr
)
4875 return build_c_cast (type
, expr
);
4878 /* Build an expression representing a cast to type TYPE of expression EXPR. */
4881 build_c_cast (type
, expr
)
4885 register tree value
= expr
;
4887 if (type
== error_mark_node
|| expr
== error_mark_node
)
4888 return error_mark_node
;
4890 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4891 Strip such NOP_EXPRs, since VALUE is being used in non-lvalue context. */
4892 if (TREE_CODE (value
) == NOP_EXPR
4893 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
4894 value
= TREE_OPERAND (value
, 0);
4896 if (TREE_TYPE (expr
)
4897 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
4898 && TREE_CODE (type
) != OFFSET_TYPE
)
4899 value
= resolve_offset_ref (value
);
4901 if (TREE_CODE (type
) == ARRAY_TYPE
)
4903 /* Allow casting from T1* to T2[] because Cfront allows it.
4904 NIHCL uses it. It is not valid ANSI C however, and hence, not
4906 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
4909 pedwarn ("ANSI C++ forbids casting to an array type");
4910 type
= build_pointer_type (TREE_TYPE (type
));
4914 error ("ANSI C++ forbids casting to an array type");
4915 return error_mark_node
;
4919 if (TREE_CODE (type
) == FUNCTION_TYPE
4920 || TREE_CODE (type
) == METHOD_TYPE
)
4922 cp_error ("casting to function type `%T'", type
);
4923 return error_mark_node
;
4926 if (IS_SIGNATURE (type
))
4928 error ("cast specifies signature type");
4929 return error_mark_node
;
4932 /* If there's only one function in the overloaded space,
4934 if (TREE_CODE (value
) == TREE_LIST
4935 && TREE_CHAIN (value
) == NULL_TREE
)
4936 value
= TREE_VALUE (value
);
4938 if (TREE_CODE (type
) == VOID_TYPE
)
4939 value
= build1 (CONVERT_EXPR
, type
, value
);
4940 else if (TREE_TYPE (value
) == NULL_TREE
4941 || type_unknown_p (value
))
4943 value
= instantiate_type (type
, value
, 1);
4945 if (value
== error_mark_node
)
4946 return error_mark_node
;
4952 /* Convert functions and arrays to pointers and
4953 convert references to their expanded types,
4954 but don't convert any other types. */
4955 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
4956 || TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
4957 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
4958 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
4959 value
= default_conversion (value
);
4960 otype
= TREE_TYPE (value
);
4962 /* Optionally warn about potentially worrisome casts. */
4965 && TREE_CODE (type
) == POINTER_TYPE
4966 && TREE_CODE (otype
) == POINTER_TYPE
)
4968 /* For C++ we make these regular warnings, rather than
4969 softening them into pedwarns. */
4970 if (TYPE_VOLATILE (TREE_TYPE (otype
))
4971 && ! TYPE_VOLATILE (TREE_TYPE (type
)))
4972 warning ("cast discards `volatile' from pointer target type");
4973 if (TYPE_READONLY (TREE_TYPE (otype
))
4974 && ! TYPE_READONLY (TREE_TYPE (type
)))
4975 warning ("cast discards `const' from pointer target type");
4978 /* Warn about possible alignment problems. */
4979 if (STRICT_ALIGNMENT
&& warn_cast_align
4980 && TREE_CODE (type
) == POINTER_TYPE
4981 && TREE_CODE (otype
) == POINTER_TYPE
4982 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
4983 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4984 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
4985 warning ("cast increases required alignment of target type");
4988 if (TREE_CODE (type
) == INTEGER_TYPE
4989 && TREE_CODE (otype
) == POINTER_TYPE
4990 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
4991 warning ("cast from pointer to integer of different size");
4993 if (TREE_CODE (type
) == POINTER_TYPE
4994 && TREE_CODE (otype
) == INTEGER_TYPE
4995 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
4996 /* Don't warn about converting 0 to pointer,
4997 provided the 0 was explicit--not cast or made by folding. */
4998 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
4999 warning ("cast to pointer from integer of different size");
5002 if (TREE_READONLY_DECL_P (value
))
5003 value
= decl_constant_value (value
);
5006 value
= convert_force (type
, value
);
5008 /* Ignore any integer overflow caused by the cast. */
5009 if (TREE_CODE (value
) == INTEGER_CST
)
5011 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5012 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5016 /* Always produce some operator for an explicit cast,
5017 so we can tell (for -pedantic) that the cast is no lvalue.
5018 Also, pedantically, don't let (void *) (FOO *) 0 be a null
5019 pointer constant. */
5022 && TREE_CODE (value
) == INTEGER_CST
5023 && TREE_CODE (expr
) == INTEGER_CST
5024 && TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
))
5026 tree nvalue
= build1 (NOP_EXPR
, type
, value
);
5027 TREE_CONSTANT (nvalue
) = TREE_CONSTANT (value
);
5035 /* Build an assignment expression of lvalue LHS from value RHS.
5037 In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
5038 that reference becomes deferenced down to it base type. */
5040 /* Return a reference to the BASE_INDEX part of EXPR. TYPE is
5041 the type to which BASE_INDEX applies. */
5043 get_base_ref (type
, base_index
, expr
)
5048 tree binfos
= TYPE_BINFO_BASETYPES (type
);
5049 tree base_binfo
= TREE_VEC_ELT (binfos
, base_index
);
5052 if (TREE_CODE (expr
) == ARRAY_REF
5053 || ! BINFO_OFFSET_ZEROP (base_binfo
)
5054 || TREE_VIA_VIRTUAL (base_binfo
)
5055 || TYPE_MODE (type
) != TYPE_MODE (BINFO_TYPE (base_binfo
)))
5057 tree addr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5058 ref
= build_indirect_ref (convert_pointer_to (base_binfo
, addr
),
5063 ref
= copy_node (expr
);
5064 TREE_TYPE (ref
) = BINFO_TYPE (base_binfo
);
5069 /* Build an assignment expression of lvalue LHS from value RHS.
5070 MODIFYCODE is the code for a binary operator that we use
5071 to combine the old value of LHS with RHS to get the new value.
5072 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5074 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5076 `build_modify_expr_1' implements recursive part of memberwise
5077 assignment operation. */
5079 build_modify_expr_1 (lhs
, modifycode
, rhs
, basetype_path
)
5081 enum tree_code modifycode
;
5084 register tree result
;
5086 tree lhstype
= TREE_TYPE (lhs
);
5087 tree olhstype
= lhstype
;
5089 /* Avoid duplicate error messages from operands that had errors. */
5090 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5091 return error_mark_node
;
5093 /* If a binary op has been requested, combine the old LHS value with the RHS
5094 producing the value we should actually store into the LHS. */
5096 if (modifycode
== INIT_EXPR
)
5098 else if (modifycode
== NOP_EXPR
)
5100 /* must deal with overloading of `operator=' here. */
5101 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5102 lhstype
= TREE_TYPE (lhstype
);
5108 lhs
= stabilize_reference (lhs
);
5109 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5110 modifycode
= NOP_EXPR
;
5113 /* If storing into a structure or union member,
5114 it has probably been given type `int'.
5115 Compute the type that would go with
5116 the actual amount of storage the member occupies. */
5118 if (TREE_CODE (lhs
) == COMPONENT_REF
5119 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5120 || TREE_CODE (lhstype
) == REAL_TYPE
5121 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5122 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5124 /* C++: The semantics of C++ differ from those of C when an
5125 assignment of an aggregate is desired. Assignment in C++ is
5126 now defined as memberwise assignment of non-static members
5127 and base class objects. This rule applies recursively
5128 until a member of a built-in type is found.
5130 Also, we cannot do a bit-wise copy of aggregates which
5131 contain virtual function table pointers. Those
5132 pointer values must be preserved through the copy.
5133 However, this is handled in expand_expr, and not here.
5134 This is because much better code can be generated at
5135 that stage than this one. */
5136 if (TREE_CODE (lhstype
) == RECORD_TYPE
5137 && TYPE_LANG_SPECIFIC (lhstype
)
5138 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5143 /* Perform operation on object. */
5144 if (modifycode
== INIT_EXPR
&& TYPE_HAS_INIT_REF (lhstype
))
5146 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5147 build_tree_list (NULL_TREE
, rhs
),
5148 basetype_path
, LOOKUP_NORMAL
);
5149 return build_indirect_ref (result
, NULL_PTR
);
5151 else if (modifycode
== NOP_EXPR
)
5153 /* `operator=' is not an inheritable operator; see 13.4.3. */
5154 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5156 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5157 lhs
, rhs
, make_node (NOP_EXPR
));
5158 if (result
== NULL_TREE
)
5159 return error_mark_node
;
5164 if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype
)
5165 || (modifycode
== NOP_EXPR
&& TYPE_GETS_ASSIGNMENT (lhstype
))
5166 || (modifycode
== INIT_EXPR
&& TYPE_GETS_INIT_REF (lhstype
)))
5168 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (lhstype
));
5171 if (binfos
!= NULL_TREE
)
5172 /* Perform operation on each member, depth-first, left-right. */
5173 for (i
= 0; i
<= TREE_VEC_LENGTH (binfos
)-1; i
++)
5175 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
5176 tree base_lhs
, base_rhs
;
5179 /* Assignments from virtual baseclasses handled elsewhere. */
5180 if (TREE_VIA_VIRTUAL (base_binfo
))
5183 base_lhs
= get_base_ref (lhstype
, i
, lhs
);
5184 base_rhs
= get_base_ref (lhstype
, i
, newrhs
);
5186 BINFO_INHERITANCE_CHAIN (base_binfo
) = basetype_path
;
5188 = build_modify_expr_1 (base_lhs
, modifycode
, base_rhs
,
5191 /* We either get back a compound stmt, or a simple one. */
5192 if (new_result
&& TREE_CODE (new_result
) == TREE_LIST
)
5193 new_result
= build_compound_expr (new_result
);
5194 result
= tree_cons (NULL_TREE
, new_result
, result
);
5197 for (elt
= TYPE_FIELDS (lhstype
); elt
; elt
= TREE_CHAIN (elt
))
5199 tree vbases
= NULL_TREE
;
5200 tree elt_lhs
, elt_rhs
;
5202 if (TREE_CODE (elt
) != FIELD_DECL
)
5205 && (VFIELD_NAME_P (DECL_NAME (elt
))
5206 || VBASE_NAME_P (DECL_NAME (elt
))))
5209 if (TREE_READONLY (elt
)
5210 || TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5212 cp_error ("cannot generate default `%T::operator ='",
5214 if (TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5215 cp_error_at ("because member `%#D' is a reference", elt
);
5217 cp_error_at ("because member `%#D' is const", elt
);
5219 return error_mark_node
;
5222 if (IS_AGGR_TYPE (TREE_TYPE (elt
))
5223 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5224 vbases
= CLASSTYPE_VBASECLASSES (TREE_TYPE (elt
));
5226 elt_lhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), lhs
, elt
);
5227 elt_rhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), newrhs
, elt
);
5228 /* It is not always safe to go through `build_modify_expr_1'
5229 when performing element-wise copying. This is because
5230 an element may be of ARRAY_TYPE, which will not
5231 be properly copied as a naked element. */
5232 if (TREE_CODE (TREE_TYPE (elt
)) == RECORD_TYPE
5233 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5234 basetype_path
= TYPE_BINFO (TREE_TYPE (elt
));
5238 tree elt_lhs_addr
= build_unary_op (ADDR_EXPR
, elt_lhs
, 0);
5239 tree elt_rhs_addr
= build_unary_op (ADDR_EXPR
, elt_rhs
, 0);
5241 elt_lhs_addr
= convert_pointer_to (vbases
, elt_lhs_addr
);
5242 elt_rhs_addr
= convert_pointer_to (vbases
, elt_rhs_addr
);
5244 = tree_cons (NULL_TREE
,
5246 (build_indirect_ref (elt_lhs_addr
, NULL_PTR
),
5248 build_indirect_ref (elt_rhs_addr
, NULL_PTR
),
5251 if (TREE_VALUE (result
) == error_mark_node
)
5252 return error_mark_node
;
5253 vbases
= TREE_CHAIN (vbases
);
5255 elt_lhs
= build_modify_expr_1 (elt_lhs
, modifycode
, elt_rhs
,
5257 result
= tree_cons (NULL_TREE
, elt_lhs
, result
);
5261 return build_compound_expr (result
);
5262 /* No fields to move. */
5263 return integer_zero_node
;
5267 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5268 void_type_node
, lhs
, rhs
);
5269 TREE_SIDE_EFFECTS (result
) = 1;
5274 result
= build_modify_expr (lhs
, modifycode
, newrhs
);
5275 /* ARRAY_TYPEs cannot be converted to anything meaningful,
5276 and leaving it there screws up `build_compound_expr' when
5277 it tries to defaultly convert everything. */
5278 if (TREE_CODE (TREE_TYPE (result
)) == ARRAY_TYPE
)
5279 TREE_TYPE (result
) = void_type_node
;
5284 /* Taken from expr.c:
5285 Subroutine of expand_expr:
5286 record the non-copied parts (LIST) of an expr (LHS), and return a list
5287 which specifies the initial values of these parts. */
5290 init_noncopied_parts (lhs
, list
)
5297 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5298 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5299 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5302 tree part
= TREE_VALUE (tail
);
5303 tree part_type
= TREE_TYPE (part
);
5304 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5305 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
5310 /* Build an assignment expression of lvalue LHS from value RHS.
5311 MODIFYCODE is the code for a binary operator that we use
5312 to combine the old value of LHS with RHS to get the new value.
5313 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5315 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5318 build_modify_expr (lhs
, modifycode
, rhs
)
5320 enum tree_code modifycode
;
5323 register tree result
;
5325 tree lhstype
= TREE_TYPE (lhs
);
5326 tree olhstype
= lhstype
;
5329 /* Avoid duplicate error messages from operands that had errors. */
5330 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5331 return error_mark_node
;
5333 /* Types that aren't fully specified cannot be used in assignments. */
5334 lhs
= require_complete_type (lhs
);
5336 /* Decide early if we are going to protect RHS from GC
5337 before assigning it to LHS. */
5338 if (type_needs_gc_entry (TREE_TYPE (rhs
))
5339 && ! value_safe_from_gc (lhs
, rhs
))
5340 rhs
= protect_value_from_gc (lhs
, rhs
);
5344 /* Handle assignment to signature pointers/refs. */
5346 if (TYPE_LANG_SPECIFIC (lhstype
) &&
5347 (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5349 return build_signature_pointer_constructor (lhs
, rhs
);
5352 /* Handle control structure constructs used as "lvalues". */
5354 switch (TREE_CODE (lhs
))
5356 /* Handle --foo = 5; as these are valid constructs in C++ */
5357 case PREDECREMENT_EXPR
:
5358 case PREINCREMENT_EXPR
:
5359 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5360 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5361 stabilize_reference (TREE_OPERAND (lhs
, 0)));
5362 return build (COMPOUND_EXPR
, lhstype
,
5364 build_modify_expr (TREE_OPERAND (lhs
, 0),
5367 /* Handle (a, b) used as an "lvalue". */
5369 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5371 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5372 return error_mark_node
;
5373 return build (COMPOUND_EXPR
, lhstype
,
5374 TREE_OPERAND (lhs
, 0), newrhs
);
5377 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5378 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5379 return error_mark_node
;
5380 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5382 /* Handle (a ? b : c) used as an "lvalue". */
5384 rhs
= save_expr (rhs
);
5386 /* Produce (a ? (b = rhs) : (c = rhs))
5387 except that the RHS goes through a save-expr
5388 so the code to compute it is only emitted once. */
5390 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5391 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5393 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5395 if (TREE_CODE (cond
) == ERROR_MARK
)
5397 /* Make sure the code to compute the rhs comes out
5398 before the split. */
5399 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5400 /* Case to void to suppress warning
5401 from warn_if_unused_value. */
5402 convert (void_type_node
, rhs
), cond
);
5406 if (TREE_CODE (lhs
) == OFFSET_REF
)
5408 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5410 /* Static class member? */
5411 tree member
= TREE_OPERAND (lhs
, 1);
5412 if (TREE_CODE (member
) == VAR_DECL
)
5416 compiler_error ("invalid static class member");
5417 return error_mark_node
;
5421 lhs
= resolve_offset_ref (lhs
);
5423 olhstype
= lhstype
= TREE_TYPE (lhs
);
5426 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5427 && modifycode
!= INIT_EXPR
)
5429 lhs
= convert_from_reference (lhs
);
5430 olhstype
= lhstype
= TREE_TYPE (lhs
);
5433 /* If a binary op has been requested, combine the old LHS value with the RHS
5434 producing the value we should actually store into the LHS. */
5436 if (modifycode
== INIT_EXPR
)
5438 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_CONSTRUCTOR (lhstype
))
5440 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5441 build_tree_list (NULL_TREE
, rhs
),
5442 NULL_TREE
, LOOKUP_NORMAL
);
5443 if (result
== NULL_TREE
)
5444 return error_mark_node
;
5448 else if (modifycode
== NOP_EXPR
)
5451 /* `operator=' is not an inheritable operator. */
5452 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5454 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5455 lhs
, rhs
, make_node (NOP_EXPR
));
5456 if (result
== NULL_TREE
)
5457 return error_mark_node
;
5461 /* Treat `operator=' as an inheritable operator. */
5462 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_GETS_ASSIGNMENT (lhstype
))
5464 tree orig_lhstype
= lhstype
;
5465 while (! TYPE_HAS_ASSIGNMENT (lhstype
))
5467 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (lhstype
);
5468 tree basetype
= NULL_TREE
;
5469 for (i
= 0; i
< n_baseclasses
; i
++)
5470 if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype
, i
)))
5472 if (basetype
!= NULL_TREE
)
5474 message_2_types (error
, "base classes `%s' and `%s' both have operator ='",
5476 TYPE_BINFO_BASETYPE (lhstype
, i
));
5477 return error_mark_node
;
5479 basetype
= TYPE_BINFO_BASETYPE (lhstype
, i
);
5483 if (orig_lhstype
!= lhstype
)
5485 lhs
= build_indirect_ref (convert_pointer_to (lhstype
,
5486 build_unary_op (ADDR_EXPR
, lhs
, 0)), NULL_PTR
);
5487 if (lhs
== error_mark_node
)
5489 cp_error ("conversion to private basetype `%T'", lhstype
);
5490 return error_mark_node
;
5493 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5494 lhs
, rhs
, make_node (NOP_EXPR
));
5495 if (result
== NULL_TREE
)
5496 return error_mark_node
;
5502 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5504 /* This case must convert to some sort of lvalue that
5505 can participate in an op= operation. */
5508 if (build_default_binary_type_conversion (modifycode
, &lhs_tmp
, &rhs_tmp
))
5510 lhs
= stabilize_reference (lhs_tmp
);
5511 /* Forget is was ever anything else. */
5512 olhstype
= lhstype
= TREE_TYPE (lhs
);
5513 newrhs
= build_binary_op (modifycode
, lhs
, rhs_tmp
, 1);
5516 return error_mark_node
;
5520 lhs
= stabilize_reference (lhs
);
5521 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5524 /* Handle a cast used as an "lvalue".
5525 We have already performed any binary operator using the value as cast.
5526 Now convert the result to the cast type of the lhs,
5527 and then true type of the lhs and store it there;
5528 then convert result back to the cast type to be the value
5529 of the assignment. */
5531 switch (TREE_CODE (lhs
))
5536 case FIX_TRUNC_EXPR
:
5537 case FIX_FLOOR_EXPR
:
5538 case FIX_ROUND_EXPR
:
5540 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5541 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5542 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5543 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5544 newrhs
= default_conversion (newrhs
);
5546 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5548 if (! lvalue_p (lhs
) && pedantic
)
5549 pedwarn ("cast to non-reference type used as lvalue");
5551 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5552 convert (TREE_TYPE (inner_lhs
),
5553 convert (lhstype
, newrhs
)));
5554 if (TREE_CODE (result
) == ERROR_MARK
)
5556 return convert (TREE_TYPE (lhs
), result
);
5560 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5561 Reject anything strange now. */
5563 if (!lvalue_or_else (lhs
, "assignment"))
5564 return error_mark_node
;
5566 GNU_xref_assign (lhs
);
5568 /* Warn about storing in something that is `const'. */
5569 /* For C++, don't warn if this is initialization. */
5570 if (modifycode
!= INIT_EXPR
5571 /* For assignment to `const' signature pointer/reference fields,
5572 don't warn either, we already printed a better message before. */
5573 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5574 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5575 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5576 && (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
5577 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5578 || TREE_CODE (lhstype
) == UNION_TYPE
)
5579 && C_TYPE_FIELDS_READONLY (lhstype
))
5580 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5581 && TYPE_READONLY (TREE_TYPE (lhstype
)))))
5582 readonly_error (lhs
, "assignment", 0);
5584 /* If storing into a structure or union member,
5585 it has probably been given type `int'.
5586 Compute the type that would go with
5587 the actual amount of storage the member occupies. */
5589 if (TREE_CODE (lhs
) == COMPONENT_REF
5590 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5591 || TREE_CODE (lhstype
) == REAL_TYPE
5592 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5594 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5596 /* If storing in a field that is in actuality a short or narrower
5597 than one, we must store in the field in its actual type. */
5599 if (lhstype
!= TREE_TYPE (lhs
))
5601 lhs
= copy_node (lhs
);
5602 TREE_TYPE (lhs
) = lhstype
;
5606 /* check to see if there is an assignment to `this' */
5607 if (lhs
== current_class_decl
)
5609 if (flag_this_is_variable
> 0
5610 && DECL_NAME (current_function_decl
) != NULL_TREE
5611 && current_class_name
!= DECL_NAME (current_function_decl
))
5612 warning ("assignment to `this' not in constructor or destructor");
5613 current_function_just_assigned_this
= 1;
5616 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
5617 when the type of RHS is not yet known, i.e. its type
5618 is inherited from LHS. */
5619 rhs
= require_instantiated_type (lhstype
, newrhs
, error_mark_node
);
5620 if (rhs
== error_mark_node
)
5621 return error_mark_node
;
5624 if (modifycode
!= INIT_EXPR
)
5626 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5627 modifycode
= NOP_EXPR
;
5628 /* Reference-bashing */
5629 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5631 tree tmp
= convert_from_reference (lhs
);
5632 lhstype
= TREE_TYPE (tmp
);
5633 if (TYPE_SIZE (lhstype
) == 0)
5635 incomplete_type_error (lhs
, lhstype
);
5636 return error_mark_node
;
5641 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
5643 tree tmp
= convert_from_reference (newrhs
);
5644 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
5646 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
5647 return error_mark_node
;
5653 if (TREE_SIDE_EFFECTS (lhs
))
5654 lhs
= stabilize_reference (lhs
);
5655 if (TREE_SIDE_EFFECTS (newrhs
))
5656 newrhs
= stabilize_reference (newrhs
);
5658 /* C++: The semantics of C++ differ from those of C when an
5659 assignment of an aggregate is desired. Assignment in C++ is
5660 now defined as memberwise assignment of non-static members
5661 and base class objects. This rule applies recursively
5662 until a member of a built-in type is found.
5664 Also, we cannot do a bit-wise copy of aggregates which
5665 contain virtual function table pointers. Those
5666 pointer values must be preserved through the copy.
5667 However, this is handled in expand_expr, and not here.
5668 This is because much better code can be generated at
5669 that stage than this one. */
5670 if (TREE_CODE (lhstype
) == RECORD_TYPE
5671 && ! TYPE_PTRMEMFUNC_P (lhstype
)
5672 && (TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))
5673 || (TREE_CODE (TREE_TYPE (newrhs
)) == RECORD_TYPE
5674 && UNIQUELY_DERIVED_FROM_P (lhstype
, TREE_TYPE (newrhs
)))))
5676 /* This was decided in finish_struct. */
5677 if (modifycode
== INIT_EXPR
)
5678 cp_error ("can't generate default copy constructor for `%T'", lhstype
);
5680 cp_error ("can't generate default assignment operator for `%T'",
5683 /* This is now done by generating X(X&) and operator=(X&). */
5684 tree vbases
= CLASSTYPE_VBASECLASSES (lhstype
);
5685 tree lhs_addr
= build_unary_op (ADDR_EXPR
, lhs
, 0);
5688 /* Memberwise assignment would cause NEWRHS to be
5689 evaluated for every member that gets assigned.
5690 By wrapping side-effecting exprs in a SAVE_EXPR,
5691 NEWRHS will only be evaluated once. */
5692 if (IS_AGGR_TYPE (TREE_TYPE (newrhs
))
5693 && TREE_SIDE_EFFECTS (newrhs
)
5694 /* This are things we don't have to save. */
5695 && TREE_CODE (newrhs
) != COND_EXPR
5696 && TREE_CODE (newrhs
) != TARGET_EXPR
5697 && TREE_CODE (newrhs
) != WITH_CLEANUP_EXPR
)
5698 /* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
5699 If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
5700 will result in expand_expr expanding the call without knowing
5701 that it should run the cleanup. */
5702 newrhs
= save_expr (break_out_cleanups (newrhs
));
5704 if (TREE_CODE (newrhs
) == COND_EXPR
)
5705 rhs_addr
= rationalize_conditional_expr (ADDR_EXPR
, newrhs
);
5707 rhs_addr
= build_unary_op (ADDR_EXPR
, newrhs
, 0);
5709 result
= tree_cons (NULL_TREE
,
5710 convert (build_reference_type (lhstype
), lhs
),
5713 if (! comptypes (TREE_TYPE (lhs_addr
), TREE_TYPE (rhs_addr
), 1))
5714 rhs_addr
= convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr
)), rhs_addr
);
5716 tree noncopied_parts
= NULL_TREE
;
5718 if (TYPE_NONCOPIED_PARTS (lhstype
) != 0)
5719 noncopied_parts
= init_noncopied_parts (lhs
,
5720 TYPE_NONCOPIED_PARTS (lhstype
));
5721 while (noncopied_parts
!= 0)
5723 result
= tree_cons (NULL_TREE
,
5724 build_modify_expr (convert (ptr_type_node
, TREE_VALUE (noncopied_parts
)),
5726 TREE_PURPOSE (noncopied_parts
)),
5728 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
5731 /* Once we have our hands on an address, we must change NEWRHS
5732 to work from there. Otherwise we can get multiple evaluations
5734 if (TREE_CODE (newrhs
) != SAVE_EXPR
)
5735 newrhs
= build_indirect_ref (rhs_addr
, NULL_PTR
);
5739 tree elt_lhs
= convert_pointer_to (vbases
, lhs_addr
);
5740 tree elt_rhs
= convert_pointer_to (vbases
, rhs_addr
);
5742 = tree_cons (NULL_TREE
,
5743 build_modify_expr_1 (build_indirect_ref (elt_lhs
, NULL_PTR
),
5745 build_indirect_ref (elt_rhs
, NULL_PTR
),
5746 TYPE_BINFO (lhstype
)),
5748 if (TREE_VALUE (result
) == error_mark_node
)
5749 return error_mark_node
;
5750 vbases
= TREE_CHAIN (vbases
);
5752 result
= tree_cons (NULL_TREE
,
5753 build_modify_expr_1 (lhs
,
5756 TYPE_BINFO (lhstype
)),
5758 return build_compound_expr (result
);
5762 /* Convert new value to destination type. */
5764 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5768 /* Allow array assignment in compiler-generated code. */
5769 if ((pedantic
|| flag_ansi
)
5770 && ! DECL_ARTIFICIAL (current_function_decl
))
5771 pedwarn ("ANSI C++ forbids assignment of arrays");
5773 /* Have to wrap this in RTL_EXPR for two cases:
5774 in base or member initialization and if we
5775 are a branch of a ?: operator. Since we
5776 can't easily know the latter, just do it always. */
5778 result
= make_node (RTL_EXPR
);
5780 TREE_TYPE (result
) = void_type_node
;
5781 do_pending_stack_adjust ();
5782 start_sequence_for_rtl_expr (result
);
5784 /* As a matter of principle, `start_sequence' should do this. */
5787 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5788 ? 1 + (modifycode
!= INIT_EXPR
): 0;
5789 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
5792 do_pending_stack_adjust ();
5794 TREE_SIDE_EFFECTS (result
) = 1;
5795 RTL_EXPR_SEQUENCE (result
) = get_insns ();
5796 RTL_EXPR_RTL (result
) = const0_rtx
;
5801 if (modifycode
== INIT_EXPR
)
5803 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
5804 "assignment", NULL_TREE
, 0);
5805 if (lhs
== DECL_RESULT (current_function_decl
))
5807 if (DECL_INITIAL (lhs
))
5808 warning ("return value from function receives multiple initializations");
5809 DECL_INITIAL (lhs
) = newrhs
;
5814 if (IS_AGGR_TYPE (lhstype
))
5816 if (result
= build_opfncall (MODIFY_EXPR
,
5817 LOOKUP_NORMAL
, lhs
, newrhs
,
5818 make_node (NOP_EXPR
)))
5821 /* Avoid warnings on enum bit fields. */
5822 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
5823 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
5825 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
5827 newrhs
= convert_force (lhstype
, newrhs
);
5830 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
5832 if (flag_elide_constructors
== 0
5833 && TREE_CODE (newrhs
) == CALL_EXPR
5834 && TREE_ADDRESSABLE (lhstype
))
5836 /* Can't initialized directly from a CALL_EXPR, since
5837 we don't know about what doesn't alias what. */
5839 tree temp
= get_temp_name (lhstype
, 0);
5840 newrhs
= build (COMPOUND_EXPR
, lhstype
,
5841 build_modify_expr (temp
, INIT_EXPR
, newrhs
),
5846 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5847 return error_mark_node
;
5849 if (TREE_CODE (newrhs
) == COND_EXPR
)
5852 tree cond
= TREE_OPERAND (newrhs
, 0);
5854 if (TREE_SIDE_EFFECTS (lhs
))
5855 cond
= build_compound_expr (tree_cons
5857 build_tree_list (NULL_TREE
, cond
)));
5859 /* Cannot have two identical lhs on this one tree (result) as preexpand
5860 calls will rip them out and fill in RTL for them, but when the
5861 rtl is generated, the calls will only be in the first side of the
5862 condition, not on both, or before the conditional jump! (mrs) */
5863 lhs1
= break_out_calls (lhs
);
5866 /* If there's no change, the COND_EXPR behaves like any other rhs. */
5867 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5868 lhstype
, lhs
, newrhs
);
5871 tree result_type
= TREE_TYPE (newrhs
);
5872 /* We have to convert each arm to the proper type because the
5873 types may have been munged by constant folding. */
5875 = build (COND_EXPR
, result_type
, cond
,
5876 build_modify_expr (lhs
, modifycode
,
5877 convert (result_type
,
5878 TREE_OPERAND (newrhs
, 1))),
5879 build_modify_expr (lhs1
, modifycode
,
5880 convert (result_type
,
5881 TREE_OPERAND (newrhs
, 2))));
5884 else if (modifycode
!= INIT_EXPR
&& TREE_CODE (newrhs
) == WITH_CLEANUP_EXPR
)
5886 tree cleanup
= TREE_OPERAND (newrhs
, 2);
5889 /* Finish up by running cleanups and having the "value" of the lhs. */
5890 tree exprlist
= tree_cons (NULL_TREE
, cleanup
,
5891 build_tree_list (NULL_TREE
, lhs
));
5892 newrhs
= TREE_OPERAND (newrhs
, 0);
5893 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
5894 slot
= TREE_OPERAND (newrhs
, 0);
5895 else if (TREE_CODE (newrhs
) == ADDR_EXPR
)
5897 /* Bad but legal. */
5899 warning ("address taken of temporary object");
5902 my_friendly_abort (118);
5904 /* Copy the value computed in SLOT into LHS. */
5905 exprlist
= tree_cons (NULL_TREE
,
5906 build_modify_expr (lhs
, modifycode
, slot
),
5908 /* Evaluate the expression that needs CLEANUP. This will
5909 compute the value into SLOT. */
5910 exprlist
= tree_cons (NULL_TREE
, newrhs
, exprlist
);
5911 result
= convert (lhstype
, build_compound_expr (exprlist
));
5914 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5915 lhstype
, lhs
, newrhs
);
5916 TREE_SIDE_EFFECTS (result
) = 1;
5918 /* If we got the LHS in a different type for storing in,
5919 convert the result back to the nominal type of LHS
5920 so that the value we return always has the same type
5921 as the LHS argument. */
5923 if (olhstype
== TREE_TYPE (result
))
5925 /* Avoid warnings converting integral types back into enums
5926 for enum bit fields. */
5927 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
5928 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
5930 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
5931 TREE_NO_UNUSED_WARNING (result
) = 1;
5934 return convert_for_assignment (olhstype
, result
, "assignment",
5939 /* Return 0 if EXP is not a valid lvalue in this language
5940 even though `lvalue_or_else' would accept it. */
5943 language_lvalue_valid (exp
)
5949 /* Get differnce in deltas for different pointer to member function
5950 types. Return inetger_zero_node, if FROM cannot be converted to a
5951 TO type. If FORCE is true, then allow reverse conversions as well. */
5953 get_delta_difference (from
, to
, force
)
5957 tree delta
= integer_zero_node
;
5963 /* Should get_base_distance here, so we can check if any thing along the
5964 path is virtual, and we need to make sure we stay
5965 inside the real binfos when going through virtual bases.
5966 Maybe we should replace virtual bases with
5967 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
5968 binfo
= get_binfo (from
, to
, 1);
5969 if (binfo
== error_mark_node
)
5971 error (" in pointer to member function conversion");
5978 error_not_base_type (from
, to
);
5979 error (" in pointer to member function conversion");
5982 binfo
= get_binfo (to
, from
, 1);
5983 if (binfo
== error_mark_node
)
5985 error (" in pointer to member function conversion");
5990 error ("cannot convert pointer to member of type %T to unrelated pointer to member of type %T", from
, to
);
5993 if (TREE_VIA_VIRTUAL (binfo
))
5995 warning ("pointer to member conversion to virtual base class will only work if your very careful");
5997 return fold (size_binop (MINUS_EXPR
,
5999 BINFO_OFFSET (binfo
)));
6001 if (TREE_VIA_VIRTUAL (binfo
))
6003 warning ("pointer to member conversion from virtual base class will only work if your very careful");
6005 return BINFO_OFFSET (binfo
);
6008 /* Build a constructor for a pointer to member function. It can be
6009 used to initialize global variables, local variable, or used
6010 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6013 If FORCE is non-zero, then force this conversion, even if
6014 we would rather not do it. Usually set when using an explicit
6017 Return error_mark_node, if something goes wrong. */
6020 build_ptrmemfunc (type
, pfn
, force
)
6024 tree index
= integer_zero_node
;
6025 tree delta
= integer_zero_node
;
6026 tree delta2
= integer_zero_node
;
6031 /* Handle multiple conversions of pointer to member fucntions. */
6032 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6034 tree ndelta
, ndelta2
, nindex
;
6035 /* Is is already the right type? */
6037 /* Sorry, can't do this, the backend is too stupid. */
6038 if (TYPE_METHOD_BASETYPE (TREE_TYPE (type
))
6039 == TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))))
6041 if (type
!= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6043 npfn
= build1 (NOP_EXPR
, TYPE_GET_PTRMEMFUNC_TYPE (type
), pfn
);
6044 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6049 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6053 if (TREE_CODE (pfn
) != CONSTRUCTOR
)
6056 ndelta
= convert (sizetype
, build_component_ref (pfn
, delta_identifier
, 0, 0));
6057 ndelta2
= convert (sizetype
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6058 index
= build_component_ref (pfn
, index_identifier
, 0, 0);
6059 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))),
6060 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6062 delta
= fold (size_binop (PLUS_EXPR
, delta
, ndelta
));
6063 delta2
= fold (size_binop (PLUS_EXPR
, ndelta2
, delta2
));
6064 e1
= fold (build (GT_EXPR
, integer_type_node
, index
, integer_zero_node
));
6066 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6067 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6068 tree_cons (NULL_TREE
, index
,
6069 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6070 e2
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6072 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6073 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6074 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6076 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6077 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6078 tree_cons (NULL_TREE
, index
,
6079 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6080 e3
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6081 return build_conditional_expr (e1
, e2
, e3
);
6084 ndelta
= TREE_VALUE (CONSTRUCTOR_ELTS (pfn
));
6085 nindex
= TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
)));
6086 npfn
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
))));
6087 npfn
= TREE_VALUE (CONSTRUCTOR_ELTS (npfn
));
6088 if (integer_zerop (nindex
))
6089 pfn
= integer_zero_node
;
6092 sorry ("value casting of varible nonnull pointer to member functions not supported");
6093 return error_mark_node
;
6097 /* Handle null pointer to member function conversions. */
6098 if (integer_zerop (pfn
))
6100 pfn
= build_c_cast (type
, integer_zero_node
);
6101 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6102 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, integer_zero_node
,
6103 tree_cons (NULL_TREE
, integer_zero_node
,
6104 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6105 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6108 if (TREE_CODE (pfn
) == TREE_LIST
6109 || (TREE_CODE (pfn
) == ADDR_EXPR
6110 && TREE_CODE (TREE_OPERAND (pfn
, 0)) == TREE_LIST
))
6112 pfn
= instantiate_type (type
, pfn
, 1);
6113 if (pfn
== error_mark_node
)
6114 return error_mark_node
;
6115 if (TREE_CODE (pfn
) != ADDR_EXPR
)
6116 pfn
= build_unary_op (ADDR_EXPR
, pfn
, 0);
6119 /* Allow pointer to member conversions here. */
6120 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6121 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6123 delta2
= fold (size_binop (PLUS_EXPR
, delta2
, delta
));
6125 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6126 warning ("assuming pointer to member function is non-virtual");
6128 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6129 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6131 /* Find the offset to the vfield pointer in the object. */
6132 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6133 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6135 vfield_offset
= get_vfield_offset (vfield_offset
);
6136 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6138 /* Map everything down one to make room for the null pointer to member. */
6139 index
= size_binop (PLUS_EXPR
,
6140 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6142 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6146 index
= fold (size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
));
6148 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6149 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6151 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6154 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6155 tree_cons (NULL_TREE
, index
,
6156 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6157 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6160 /* Convert value RHS to type TYPE as preparation for an assignment
6161 to an lvalue of type TYPE.
6162 The real work of conversion is done by `convert'.
6163 The purpose of this function is to generate error messages
6164 for assignments that are not allowed in C.
6165 ERRTYPE is a string to use in error messages:
6166 "assignment", "return", etc.
6168 C++: attempts to allow `convert' to find conversions involving
6169 implicit type conversion between aggregate and scalar types
6170 as per 8.5.6 of C++ manual. Does not randomly dereference
6171 pointers to aggregates! */
6174 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6180 register enum tree_code codel
= TREE_CODE (type
);
6181 register tree rhstype
;
6182 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6184 if (coder
== UNKNOWN_TYPE
)
6185 rhs
= instantiate_type (type
, rhs
, 1);
6187 if (coder
== ERROR_MARK
)
6188 return error_mark_node
;
6190 if (codel
== OFFSET_TYPE
)
6192 type
= TREE_TYPE (type
);
6193 codel
= TREE_CODE (type
);
6196 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6197 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6198 rhs
= TREE_OPERAND (rhs
, 0);
6200 if (rhs
== error_mark_node
)
6201 return error_mark_node
;
6203 if (TREE_VALUE (rhs
) == error_mark_node
)
6204 return error_mark_node
;
6206 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6208 rhs
= resolve_offset_ref (rhs
);
6209 if (rhs
== error_mark_node
)
6210 return error_mark_node
;
6211 rhstype
= TREE_TYPE (rhs
);
6212 coder
= TREE_CODE (rhstype
);
6215 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6216 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6217 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6218 rhs
= default_conversion (rhs
);
6219 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6220 rhs
= convert_from_reference (rhs
);
6222 rhstype
= TREE_TYPE (rhs
);
6223 coder
= TREE_CODE (rhstype
);
6225 /* This should no longer change types on us. */
6226 if (TREE_CODE (rhs
) == CONST_DECL
)
6227 rhs
= DECL_INITIAL (rhs
);
6228 else if (TREE_READONLY_DECL_P (rhs
))
6229 rhs
= decl_constant_value (rhs
);
6231 if (type
== rhstype
)
6233 overflow_warning (rhs
);
6237 if (coder
== VOID_TYPE
)
6239 error ("void value not ignored as it ought to be");
6240 return error_mark_node
;
6242 /* Arithmetic types all interconvert. */
6243 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
)
6244 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
))
6246 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6247 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6250 cp_warning ("`%T' used for argument %P of `%D'",
6251 rhstype
, parmnum
, fndecl
);
6253 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6255 /* And we should warn if assigning a negative value to
6256 an unsigned variable. */
6257 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6259 if (TREE_CODE (rhs
) == INTEGER_CST
6260 && TREE_NEGATED_INT (rhs
))
6263 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6264 rhs
, parmnum
, fndecl
);
6266 cp_warning ("%s of negative value `%E' to `%T'",
6267 errtype
, rhs
, type
);
6269 overflow_warning (rhs
);
6270 if (TREE_CONSTANT (rhs
))
6274 return convert_and_check (type
, rhs
);
6276 /* Conversions involving enums. */
6277 else if ((codel
== ENUMERAL_TYPE
6278 && (coder
== ENUMERAL_TYPE
|| coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
))
6279 || (coder
== ENUMERAL_TYPE
6280 && (codel
== ENUMERAL_TYPE
|| codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
)))
6282 return convert (type
, rhs
);
6284 /* Conversions among pointers */
6285 else if (codel
== POINTER_TYPE
6286 && (coder
== POINTER_TYPE
6287 || (coder
== RECORD_TYPE
6288 && (IS_SIGNATURE_POINTER (rhstype
)
6289 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6291 register tree ttl
= TREE_TYPE (type
);
6294 if (coder
== RECORD_TYPE
)
6296 rhs
= build_optr_ref (rhs
);
6297 rhstype
= TREE_TYPE (rhs
);
6299 ttr
= TREE_TYPE (rhstype
);
6301 /* If both pointers are of aggregate type, then we
6302 can give better error messages, and save some work
6304 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6308 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6309 || type
== class_star_type_node
6310 || rhstype
== class_star_type_node
)
6311 binfo
= TYPE_BINFO (ttl
);
6313 binfo
= get_binfo (ttl
, ttr
, 1);
6315 if (binfo
== error_mark_node
)
6316 return error_mark_node
;
6318 return error_not_base_type (ttl
, ttr
);
6320 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6323 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6324 rhstype
, parmnum
, fndecl
);
6326 cp_pedwarn ("%s to `%T' from `%T' discards const",
6327 errtype
, type
, rhstype
);
6329 if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6332 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6333 rhstype
, parmnum
, fndecl
);
6335 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6336 errtype
, type
, rhstype
);
6340 /* Any non-function converts to a [const][volatile] void *
6341 and vice versa; otherwise, targets must be the same.
6342 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6343 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6344 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6345 || comp_target_types (type
, rhstype
, 1)
6346 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6347 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6349 /* ARM $4.8, commentary on p39. */
6350 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6351 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6353 error ("no standard conversion from pointer to member to `void *'");
6354 return error_mark_node
;
6357 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6358 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6359 && rhs
!= null_pointer_node
)
6361 if (coder
== RECORD_TYPE
)
6362 pedwarn ("implicit conversion of signature pointer to type `%s'",
6363 type_as_string (type
, 0));
6365 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6368 /* Const and volatile mean something different for function types,
6369 so the usual warnings are not appropriate. */
6370 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6371 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6373 if (TREE_CODE (ttl
) == OFFSET_TYPE
6374 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6375 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6377 sorry ("%s between pointer to members converting across virtual baseclasses", errtype
);
6378 return error_mark_node
;
6380 else if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6383 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6384 rhstype
, parmnum
, fndecl
);
6386 cp_pedwarn ("%s to `%T' from `%T' discards const",
6387 errtype
, type
, rhstype
);
6389 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6392 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6393 rhstype
, parmnum
, fndecl
);
6395 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6396 errtype
, type
, rhstype
);
6398 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6399 && ! comp_target_types (type
, rhstype
, 1))
6402 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6403 rhstype
, parmnum
, fndecl
);
6405 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6406 errtype
, type
, rhstype
);
6410 else if (TREE_CODE (ttr
) == OFFSET_TYPE
6411 && TREE_CODE (ttl
) != OFFSET_TYPE
)
6413 /* Normally, pointers to different type codes (other
6414 than void) are not compatible, but we perform
6415 some type instantiation if that resolves the
6416 ambiguity of (X Y::*) and (X *). */
6418 if (current_class_decl
)
6420 if (TREE_CODE (rhs
) == INTEGER_CST
)
6422 rhs
= build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (ttr
)),
6423 current_class_decl
, rhs
);
6424 return convert_for_assignment (type
, rhs
,
6425 errtype
, fndecl
, parmnum
);
6428 if (TREE_CODE (ttl
) == METHOD_TYPE
)
6429 error ("%s between pointer-to-method and pointer-to-member types",
6432 error ("%s between pointer and pointer-to-member types", errtype
);
6433 return error_mark_node
;
6437 int add_quals
= 0, const_parity
= 0, volatile_parity
= 0;
6439 int unsigned_parity
;
6442 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6443 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6446 const_parity
|= TYPE_READONLY (ttl
) < TYPE_READONLY (ttr
);
6447 volatile_parity
|= TYPE_VOLATILE (ttl
) < TYPE_VOLATILE (ttr
);
6450 && (TYPE_READONLY (ttl
) > TYPE_READONLY (ttr
)
6451 || TYPE_VOLATILE (ttl
) > TYPE_VOLATILE (ttr
)))
6453 left_const
&= TYPE_READONLY (ttl
);
6455 if (TREE_CODE (ttl
) != POINTER_TYPE
6456 || TREE_CODE (ttr
) != POINTER_TYPE
)
6459 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6460 if (unsigned_parity
)
6462 if (TREE_UNSIGNED (ttl
))
6463 ttr
= unsigned_type (ttr
);
6465 ttl
= unsigned_type (ttl
);
6468 if (comp_target_types (ttl
, ttr
, nptrs
))
6473 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6474 rhstype
, parmnum
, fndecl
);
6476 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6477 errtype
, type
, rhstype
);
6482 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6483 rhstype
, parmnum
, fndecl
);
6485 cp_pedwarn ("%s to `%T' from `%T' discards const",
6486 errtype
, type
, rhstype
);
6488 if (volatile_parity
)
6491 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6492 rhstype
, parmnum
, fndecl
);
6494 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6495 errtype
, type
, rhstype
);
6497 if (unsigned_parity
> 0)
6500 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6501 rhstype
, parmnum
, fndecl
);
6503 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6504 errtype
, type
, rhstype
);
6506 else if (unsigned_parity
< 0)
6509 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6510 rhstype
, parmnum
, fndecl
);
6512 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6513 errtype
, type
, rhstype
);
6516 /* C++ is not so friendly about converting function and
6517 member function pointers as C. Emit warnings here. */
6518 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6519 || TREE_CODE (ttl
) == METHOD_TYPE
)
6520 if (! comptypes (ttl
, ttr
, 0))
6522 warning ("conflicting function types in %s:", errtype
);
6523 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6526 else if (TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6528 /* When does this happen? */
6529 my_friendly_abort (119);
6530 /* Conversion of a pointer-to-member type to void *. */
6531 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6532 TREE_TYPE (rhs
) = type
;
6535 else if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6537 /* When does this happen? */
6538 my_friendly_abort (120);
6539 /* Conversion of a pointer-to-member type to void *. */
6540 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6541 TREE_TYPE (rhs
) = type
;
6547 cp_error ("passing `%T' as argument %P of `%D'",
6548 rhstype
, parmnum
, fndecl
);
6550 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6551 return error_mark_node
;
6554 return convert (type
, rhs
);
6556 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6558 /* An explicit constant 0 can convert to a pointer,
6559 but not a 0 that results from casting or folding. */
6560 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6563 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6564 rhstype
, parmnum
, fndecl
);
6566 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6567 errtype
, type
, rhstype
);
6568 return convert (type
, rhs
);
6570 return null_pointer_node
;
6572 else if ((codel
== INTEGER_TYPE
|| codel
== BOOLEAN_TYPE
)
6573 && (coder
== POINTER_TYPE
6574 || (coder
== RECORD_TYPE
6575 && (IS_SIGNATURE_POINTER (rhstype
)
6576 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6577 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6580 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6581 rhstype
, parmnum
, fndecl
);
6583 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6584 errtype
, type
, rhstype
);
6585 return convert (type
, rhs
);
6589 else if (((coder
== POINTER_TYPE
&& TREE_CODE (rhs
) == ADDR_EXPR
6590 && TREE_CODE (rhstype
) == POINTER_TYPE
6591 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6592 || integer_zerop (rhs
)
6593 || TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6594 && TYPE_PTRMEMFUNC_P (type
))
6596 /* compatible pointer to member functions. */
6597 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), rhs
, 0);
6599 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6600 return error_mark_node
;
6602 /* This should no longer happen. References are initialized via
6603 `convert_for_initialization'. They should otherwise be
6604 bashed before coming here. */
6605 else if (codel
== REFERENCE_TYPE
)
6606 /* Force an abort. */
6607 my_friendly_assert (codel
!= REFERENCE_TYPE
, 317);
6608 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6610 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6611 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6614 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6615 return convert (type
, rhs
);
6617 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6618 return error_mark_node
;
6621 /* Convert RHS to be of type TYPE. If EXP is non-zero,
6622 it is the target of the initialization.
6623 ERRTYPE is a string to use in error messages.
6625 Two major differences between the behavior of
6626 `convert_for_assignment' and `convert_for_initialization'
6627 are that references are bashed in the former, while
6628 copied in the latter, and aggregates are assigned in
6629 the former (operator=) while initialized in the
6632 If using constructor make sure no conversion operator exists, if one does
6633 exist, an ambiguity exists. */
6635 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6636 tree exp
, type
, rhs
;
6642 register enum tree_code codel
= TREE_CODE (type
);
6643 register tree rhstype
;
6644 register enum tree_code coder
;
6646 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6647 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6648 if (TREE_CODE (rhs
) == NOP_EXPR
6649 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6650 && codel
!= REFERENCE_TYPE
)
6651 rhs
= TREE_OPERAND (rhs
, 0);
6653 if (rhs
== error_mark_node
6654 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6655 return error_mark_node
;
6657 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6659 rhs
= resolve_offset_ref (rhs
);
6660 if (rhs
== error_mark_node
)
6661 return error_mark_node
;
6662 rhstype
= TREE_TYPE (rhs
);
6663 coder
= TREE_CODE (rhstype
);
6666 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6667 && TREE_CODE (type
) != ARRAY_TYPE
&& TREE_CODE (type
) != REFERENCE_TYPE
)
6668 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6669 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6670 rhs
= default_conversion (rhs
);
6672 rhstype
= TREE_TYPE (rhs
);
6673 coder
= TREE_CODE (rhstype
);
6675 if (coder
== UNKNOWN_TYPE
)
6677 rhs
= instantiate_type (type
, rhs
, 1);
6678 rhstype
= TREE_TYPE (rhs
);
6679 coder
= TREE_CODE (rhstype
);
6682 if (coder
== ERROR_MARK
)
6683 return error_mark_node
;
6686 /* This is *not* the quick way out! It is the way to disaster. */
6687 if (type
== rhstype
)
6691 /* We accept references to incomplete types, so we can
6692 return here before checking if RHS is of complete type. */
6694 if (codel
== REFERENCE_TYPE
)
6696 /* This should eventually happen in convert_arguments. */
6697 extern int warningcount
, errorcount
;
6701 savew
= warningcount
, savee
= errorcount
;
6702 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6703 exp
? exp
: error_mark_node
);
6706 if (warningcount
> savew
)
6707 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6708 else if (errorcount
> savee
)
6709 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6714 rhs
= require_complete_type (rhs
);
6715 if (rhs
== error_mark_node
)
6716 return error_mark_node
;
6718 if (exp
!= 0) exp
= require_complete_type (exp
);
6719 if (exp
== error_mark_node
)
6720 return error_mark_node
;
6722 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6723 rhstype
= TREE_TYPE (rhstype
);
6725 if (TYPE_LANG_SPECIFIC (type
)
6726 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6727 return build_signature_pointer_constructor (type
, rhs
);
6729 if (IS_AGGR_TYPE (type
)
6730 && (TYPE_NEEDS_CONSTRUCTING (type
) || TREE_HAS_CONSTRUCTOR (rhs
)))
6732 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
6734 /* This is sufficient to perform initialization. No need,
6735 apparently, to go through X(X&) to do first-cut
6736 initialization. Return through a TARGET_EXPR so that we get
6737 cleanups if it is used. */
6738 if (TREE_CODE (rhs
) == CALL_EXPR
)
6740 rhs
= build_cplus_new (type
, rhs
, 0);
6743 /* Handle the case of default parameter initialization and
6744 initialization of static variables. */
6745 else if (TREE_CODE (rhs
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (rhs
))
6747 my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs
, 0)) == CALL_EXPR
, 318);
6750 my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1)) == NULL_TREE
, 316);
6751 TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1))
6752 = build_unary_op (ADDR_EXPR
, exp
, 0);
6755 rhs
= build_cplus_new (type
, TREE_OPERAND (rhs
, 0), 0);
6759 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
)
6760 || (IS_AGGR_TYPE (rhstype
) && UNIQUELY_DERIVED_FROM_P (type
, rhstype
)))
6762 if (TYPE_HAS_INIT_REF (type
))
6764 tree init
= build_method_call (exp
, constructor_name_full (type
),
6765 build_tree_list (NULL_TREE
, rhs
),
6766 TYPE_BINFO (type
), LOOKUP_NORMAL
);
6768 if (init
== error_mark_node
)
6769 return error_mark_node
;
6773 exp
= build_cplus_new (type
, init
, 0);
6777 return build (COMPOUND_EXPR
, type
, init
, exp
);
6780 /* ??? The following warnings are turned off because
6781 this is another place where the default X(X&) constructor
6783 if (TYPE_HAS_ASSIGNMENT (type
))
6784 cp_warning ("bitwise copy: `%T' defines operator=", type
);
6786 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6787 rhs
= convert_from_reference (rhs
);
6788 if (type
!= rhstype
)
6790 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6791 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6797 return convert (type
, rhs
);
6800 if (type
== TREE_TYPE (rhs
))
6802 if (TREE_READONLY_DECL_P (rhs
))
6803 rhs
= decl_constant_value (rhs
);
6807 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
6810 /* Expand an ASM statement with operands, handling output operands
6811 that are not variables or INDIRECT_REFS by transforming such
6812 cases into cases that expand_asm_operands can handle.
6814 Arguments are same as for expand_asm_operands.
6816 We don't do default conversions on all inputs, because it can screw
6817 up operands that are expected to be in memory. */
6820 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
6821 tree string
, outputs
, inputs
, clobbers
;
6826 int noutputs
= list_length (outputs
);
6828 /* o[I] is the place that output number I should be written. */
6829 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
6832 /* Record the contents of OUTPUTS before it is modified. */
6833 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6834 o
[i
] = TREE_VALUE (tail
);
6836 /* Generate the ASM_OPERANDS insn;
6837 store into the TREE_VALUEs of OUTPUTS some trees for
6838 where the values were actually stored. */
6839 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
6841 /* Copy all the intermediate outputs into the specified outputs. */
6842 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6844 if (o
[i
] != TREE_VALUE (tail
))
6846 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
6847 const0_rtx
, VOIDmode
, 0);
6850 /* Detect modification of read-only values.
6851 (Otherwise done by build_modify_expr.) */
6854 tree type
= TREE_TYPE (o
[i
]);
6855 if (TYPE_READONLY (type
)
6856 || ((TREE_CODE (type
) == RECORD_TYPE
6857 || TREE_CODE (type
) == UNION_TYPE
)
6858 && C_TYPE_FIELDS_READONLY (type
)))
6859 readonly_error (o
[i
], "modification by `asm'", 1);
6863 /* Those MODIFY_EXPRs could do autoincrements. */
6867 /* Expand a C `return' statement.
6868 RETVAL is the expression for what to return,
6869 or a null pointer for `return;' with no value.
6871 C++: upon seeing a `return', we must call destructors on all
6872 variables in scope which had constructors called on them.
6873 This means that if in a destructor, the base class destructors
6874 must be called before returning.
6876 The RETURN statement in C++ has initialization semantics. */
6879 c_expand_return (retval
)
6882 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
6883 extern tree dtor_label
, ctor_label
;
6884 tree result
= DECL_RESULT (current_function_decl
);
6885 tree valtype
= TREE_TYPE (result
);
6886 register int use_temp
= 0;
6887 int returns_value
= 1;
6889 if (TREE_THIS_VOLATILE (current_function_decl
))
6890 warning ("function declared `noreturn' has a `return' statement");
6892 if (retval
== error_mark_node
)
6894 current_function_returns_null
= 1;
6898 if (retval
== NULL_TREE
)
6900 /* A non-named return value does not count. */
6902 /* Can't just return from a destructor. */
6905 expand_goto (dtor_label
);
6909 if (DECL_CONSTRUCTOR_P (current_function_decl
))
6910 retval
= current_class_decl
;
6911 else if (DECL_NAME (result
) != NULL_TREE
6912 && TREE_CODE (valtype
) != VOID_TYPE
)
6916 current_function_returns_null
= 1;
6918 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
6920 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
6922 pedwarn ("`return' with no value, in function returning non-void");
6923 /* Clear this, so finish_function won't say that we
6924 reach the end of a non-void function (which we don't,
6925 we gave a return!). */
6926 current_function_returns_null
= 0;
6930 expand_null_return ();
6934 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
6935 && retval
!= current_class_decl
)
6937 error ("return from a constructor: use `this = ...' instead");
6938 retval
= current_class_decl
;
6941 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
6943 current_function_returns_null
= 1;
6944 /* We do this here so we'll avoid a warning about how the function
6945 "may or may not return a value" in finish_function. */
6949 pedwarn ("`return' with a value, in function returning void");
6950 expand_return (retval
);
6952 /* Add some useful error checking for C++. */
6953 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6955 tree whats_returned
;
6956 tree tmp_result
= result
;
6958 /* Don't initialize directly into a non-BLKmode retval, since that
6959 could lose when being inlined by another caller. (GCC can't
6960 read the function return register in an inline function when
6961 the return value is being ignored). */
6962 if (result
&& TYPE_MODE (TREE_TYPE (tmp_result
)) != BLKmode
)
6965 /* convert to reference now, so we can give error if we
6966 return an reference to a non-lvalue. */
6967 retval
= convert_for_initialization (tmp_result
, valtype
, retval
,
6968 LOOKUP_NORMAL
, "return",
6971 /* Sort through common things to see what it is
6972 we are returning. */
6973 whats_returned
= retval
;
6974 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
6976 whats_returned
= TREE_OPERAND (whats_returned
, 1);
6977 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
6978 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6980 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
6982 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6983 while (TREE_CODE (whats_returned
) == NEW_EXPR
6984 || TREE_CODE (whats_returned
) == TARGET_EXPR
6985 || TREE_CODE (whats_returned
) == WITH_CLEANUP_EXPR
)
6987 /* Get the target. */
6988 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6989 warning ("returning reference to temporary");
6993 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
6995 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
6996 warning ("reference to non-lvalue returned");
6997 else if (! TREE_STATIC (whats_returned
)
6998 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
)))
6999 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7002 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7004 tree whats_returned
= TREE_OPERAND (retval
, 0);
7006 if (TREE_CODE (whats_returned
) == VAR_DECL
7007 && DECL_NAME (whats_returned
)
7008 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7009 && !TREE_STATIC (whats_returned
))
7010 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7013 /* Now deal with possible C++ hair:
7014 (1) Compute the return value.
7015 (2) If there are aggregate values with destructors which
7016 must be cleaned up, clean them (taking care
7017 not to clobber the return value).
7018 (3) If an X(X&) constructor is defined, the return
7019 value must be returned via that. */
7021 if (retval
== result
7022 /* Watch out for constructors, which "return" aggregates
7023 via initialization, but which otherwise "return" a pointer. */
7024 || DECL_CONSTRUCTOR_P (current_function_decl
))
7026 /* This is just an error--it's already been reported. */
7027 if (TYPE_SIZE (valtype
) == NULL_TREE
)
7030 if (TYPE_MODE (valtype
) != BLKmode
7031 && any_pending_cleanups (1))
7033 retval
= get_temp_regvar (valtype
, retval
);
7034 use_temp
= obey_regdecls
;
7037 else if (IS_AGGR_TYPE (valtype
) && TYPE_NEEDS_CONSTRUCTING (valtype
))
7039 /* Throw away the cleanup that `build_functional_cast' gave us. */
7040 if (TREE_CODE (retval
) == WITH_CLEANUP_EXPR
7041 && TREE_CODE (TREE_OPERAND (retval
, 0)) == TARGET_EXPR
)
7042 retval
= TREE_OPERAND (retval
, 0);
7043 expand_aggr_init (result
, retval
, 0);
7044 expand_cleanups_to (NULL_TREE
);
7045 DECL_INITIAL (result
) = NULL_TREE
;
7050 if (TYPE_MODE (valtype
) == VOIDmode
)
7052 if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
7053 && warn_return_type
)
7054 warning ("return of void value in function returning non-void");
7055 expand_expr_stmt (retval
);
7059 else if (TYPE_MODE (valtype
) != BLKmode
7060 && any_pending_cleanups (1))
7062 retval
= get_temp_regvar (valtype
, retval
);
7063 expand_cleanups_to (NULL_TREE
);
7064 use_temp
= obey_regdecls
;
7069 retval
= convert_for_initialization (result
, valtype
, retval
,
7071 "return", NULL_TREE
, 0);
7072 DECL_INITIAL (result
) = NULL_TREE
;
7074 if (retval
== error_mark_node
)
7080 if (retval
!= NULL_TREE
7081 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7082 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7083 current_function_return_value
= retval
;
7087 /* Everything's great--RETVAL is in RESULT. */
7088 if (original_result_rtx
)
7090 store_expr (result
, original_result_rtx
, 0);
7091 expand_cleanups_to (NULL_TREE
);
7093 else if (retval
&& retval
!= result
)
7095 /* Clear this out so the later call to decl_function_context
7096 won't end up bombing on us. */
7097 if (DECL_CONTEXT (result
) == error_mark_node
)
7098 DECL_CONTEXT (result
) = NULL_TREE
;
7099 /* Here is where we finally get RETVAL into RESULT.
7100 `expand_return' does the magic of protecting
7101 RESULT from cleanups. */
7102 retval
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (result
), retval
);
7103 /* This part _must_ come second, because expand_return looks for
7104 the INIT_EXPR as the toplevel node only. :-( */
7105 retval
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7106 TREE_SIDE_EFFECTS (retval
) = 1;
7107 expand_return (retval
);
7110 expand_return (result
);
7112 use_variable (DECL_RTL (result
));
7113 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7114 expand_goto (ctor_label
);
7116 expand_null_return ();
7120 /* We may still need to put RETVAL into RESULT. */
7121 result
= DECL_RESULT (current_function_decl
);
7122 if (original_result_rtx
)
7124 /* Here we have a named return value that went
7125 into memory. We can compute RETVAL into that. */
7127 expand_assignment (result
, retval
, 0, 0);
7129 store_expr (result
, original_result_rtx
, 0);
7130 result
= make_tree (TREE_TYPE (result
), original_result_rtx
);
7132 else if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7134 /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do. */
7135 expand_goto (ctor_label
);
7139 /* Here is where we finally get RETVAL into RESULT.
7140 `expand_return' does the magic of protecting
7141 RESULT from cleanups. */
7142 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7143 TREE_SIDE_EFFECTS (result
) = 1;
7144 expand_return (result
);
7146 else if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
)
7147 expand_return (result
);
7150 current_function_returns_value
= returns_value
;
7152 /* These wind up after the BARRIER, which causes problems for
7153 expand_end_binding. What purpose were they supposed to serve? */
7154 if (original_result_rtx
)
7155 use_variable (original_result_rtx
);
7157 use_variable (DECL_RTL (DECL_RESULT (current_function_decl
)));
7160 /* One way to clear out cleanups that EXPR might
7161 generate. Note that this code will really be
7162 dead code, but that is ok--cleanups that were
7163 needed were handled by the magic of `return'. */
7164 expand_cleanups_to (NULL_TREE
);
7167 /* Start a C switch statement, testing expression EXP.
7168 Return EXP if it is valid, an error node otherwise. */
7171 c_expand_start_case (exp
)
7175 register enum tree_code code
;
7177 /* Convert from references, etc. */
7178 exp
= default_conversion (exp
);
7179 type
= TREE_TYPE (exp
);
7180 code
= TREE_CODE (type
);
7182 if (IS_AGGR_TYPE_CODE (code
))
7183 exp
= build_type_conversion (CONVERT_EXPR
, integer_type_node
, exp
, 1);
7185 if (exp
== NULL_TREE
)
7187 error ("switch quantity not an integer");
7188 exp
= error_mark_node
;
7190 type
= TREE_TYPE (exp
);
7191 code
= TREE_CODE (type
);
7193 if (code
!= INTEGER_TYPE
&& code
!= ENUMERAL_TYPE
&& code
!= ERROR_MARK
)
7195 error ("switch quantity not an integer");
7196 exp
= error_mark_node
;
7202 exp
= default_conversion (exp
);
7203 type
= TREE_TYPE (exp
);
7204 index
= get_unwidened (exp
, 0);
7205 /* We can't strip a conversion from a signed type to an unsigned,
7206 because if we did, int_fits_type_p would do the wrong thing
7207 when checking case values for being in range,
7208 and it's too hard to do the right thing. */
7209 if (TREE_UNSIGNED (TREE_TYPE (exp
))
7210 == TREE_UNSIGNED (TREE_TYPE (index
)))
7214 expand_start_case (1, build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
),
7215 type
, "switch statement");
7220 /* CONSTP remembers whether or not all the intervening pointers in the `to'
7221 type have been const. */
7223 comp_ptr_ttypes_real (to
, from
, constp
)
7227 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7229 if (TREE_CODE (to
) != TREE_CODE (from
))
7232 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7233 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7237 && (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7238 || TYPE_VOLATILE (to
) > TYPE_READONLY (from
)))
7240 constp
&= TYPE_READONLY (to
);
7242 if (TREE_CODE (to
) != POINTER_TYPE
)
7243 return comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1);
7247 /* When comparing, say, char ** to char const **, this function takes the
7248 'char *' and 'char const *'. Do not pass non-pointer types to this
7251 comp_ptr_ttypes (to
, from
)
7254 return comp_ptr_ttypes_real (to
, from
, 1);