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 c_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
= c_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
);
737 if (TREE_CODE (ttr
) == TEMPLATE_TYPE_PARM
)
740 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
743 if (TREE_CODE (ttr
) == POINTER_TYPE
)
745 if (TREE_CODE (TREE_TYPE (ttl
)) == POINTER_TYPE
746 || TREE_CODE (TREE_TYPE (ttl
)) == ARRAY_TYPE
)
747 return comp_ptr_ttypes (TREE_TYPE (ttl
), TREE_TYPE (ttr
));
749 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
- 1);
752 if (TREE_CODE (ttr
) == REFERENCE_TYPE
)
753 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
754 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
755 return comp_array_types (comp_target_types
, ttl
, ttr
, 0);
756 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
757 if (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
758 switch (comp_target_parms (TYPE_ARG_TYPES (ttl
), TYPE_ARG_TYPES (ttr
), 1))
765 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
769 my_friendly_abort (112);
775 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
777 /* Contravariance: we can assign a pointer to base member to a pointer
778 to derived member. Note difference from simple pointer case, where
779 we can pass a pointer to derived to a pointer to base. */
780 if (comptypes (TYPE_OFFSET_BASETYPE (ttr
), TYPE_OFFSET_BASETYPE (ttl
), 0))
781 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
782 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl
), TYPE_OFFSET_BASETYPE (ttr
), 0)
783 && comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
785 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
790 else if (IS_AGGR_TYPE (ttl
))
794 return comptypes (TYPE_POINTER_TO (ttl
), TYPE_POINTER_TO (ttr
), 0);
800 /* If two types share a common base type, return that basetype.
801 If there is not a unique most-derived base type, this function
802 returns ERROR_MARK_NODE. */
804 common_base_type (tt1
, tt2
)
807 tree best
= NULL_TREE
, tmp
;
810 /* If one is a baseclass of another, that's good enough. */
811 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
813 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
816 /* If they share a virtual baseclass, that's good enough. */
817 for (tmp
= CLASSTYPE_VBASECLASSES (tt1
); tmp
; tmp
= TREE_CHAIN (tmp
))
819 if (binfo_member (BINFO_TYPE (tmp
), CLASSTYPE_VBASECLASSES (tt2
)))
820 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
);
907 if (strict
!= 3 && TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
909 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
911 my_friendly_abort (113);
916 t1
= TREE_CHAIN (t1
);
917 t2
= TREE_CHAIN (t2
);
921 /* This really wants return whether or not parameter type lists
922 would make their owning functions assignment compatible or not. */
924 comp_target_parms (parms1
, parms2
, strict
)
928 register tree t1
= parms1
, t2
= parms2
;
929 int warn_contravariance
= 0;
931 /* An unspecified parmlist matches any specified parmlist
932 whose argument types don't need default promotions.
933 @@@ see 13.3.3 for a counterexample... */
935 if (t1
== 0 && t2
!= 0)
937 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
939 return self_promoting_args_p (t2
);
942 return self_promoting_args_p (t1
);
944 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
948 /* If one parmlist is shorter than the other,
949 they fail to match, unless STRICT is <= 0. */
950 if (t1
== 0 || t2
== 0)
955 return 1 + warn_contravariance
;
956 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
958 p1
= TREE_VALUE (t1
);
959 p2
= TREE_VALUE (t2
);
962 if (TREE_CODE (p2
) == TEMPLATE_TYPE_PARM
)
965 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
966 || (TREE_CODE (p1
) == REFERENCE_TYPE
&& TREE_CODE (p2
) == REFERENCE_TYPE
))
969 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
970 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
973 if (TREE_CODE (TREE_TYPE (p2
)) == TEMPLATE_TYPE_PARM
)
976 /* The following is wrong for contravariance,
977 but many programs depend on it. */
978 if (TREE_TYPE (p1
) == void_type_node
)
980 if (TREE_TYPE (p2
) == void_type_node
)
982 warn_contravariance
= 1;
985 if (IS_AGGR_TYPE (TREE_TYPE (p1
)))
987 if (comptypes (p2
, p1
, 0) == 0)
989 if (comptypes (p1
, p2
, 0) != 0)
990 warn_contravariance
= 1;
997 /* Note backwards order due to contravariance. */
998 if (comp_target_types (p2
, p1
, 1) == 0)
1000 if (comp_target_types (p1
, p2
, 1))
1002 warn_contravariance
= 1;
1008 /* What good do these cases do? */
1010 return p2
== void_type_node
&& TREE_PURPOSE (t1
);
1011 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
1014 /* Target types are compatible--just make sure that if
1015 we use parameter lists, that they are ok as well. */
1016 if (TREE_CODE (p1
) == FUNCTION_TYPE
|| TREE_CODE (p1
) == METHOD_TYPE
)
1017 switch (comp_target_parms (TYPE_ARG_TYPES (p1
),
1018 TYPE_ARG_TYPES (p2
),
1026 warn_contravariance
= 1;
1029 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1031 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1033 my_friendly_abort (114);
1038 return 1 + warn_contravariance
;
1041 /* Return 1 if PARMS specifies a fixed number of parameters
1042 and none of their types is affected by default promotions. */
1045 self_promoting_args_p (parms
)
1049 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1051 register tree type
= TREE_VALUE (t
);
1053 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1056 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1062 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1068 /* Return an unsigned type the same as TYPE in other respects.
1070 C++: must make these work for type variants as well. */
1073 unsigned_type (type
)
1076 tree type1
= TYPE_MAIN_VARIANT (type
);
1077 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1078 return unsigned_char_type_node
;
1079 if (type1
== integer_type_node
)
1080 return unsigned_type_node
;
1081 if (type1
== short_integer_type_node
)
1082 return short_unsigned_type_node
;
1083 if (type1
== long_integer_type_node
)
1084 return long_unsigned_type_node
;
1085 if (type1
== long_long_integer_type_node
)
1086 return long_long_unsigned_type_node
;
1090 /* Return a signed type the same as TYPE in other respects. */
1096 tree type1
= TYPE_MAIN_VARIANT (type
);
1097 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1098 return signed_char_type_node
;
1099 if (type1
== unsigned_type_node
)
1100 return integer_type_node
;
1101 if (type1
== short_unsigned_type_node
)
1102 return short_integer_type_node
;
1103 if (type1
== long_unsigned_type_node
)
1104 return long_integer_type_node
;
1105 if (type1
== long_long_unsigned_type_node
)
1106 return long_long_integer_type_node
;
1110 /* Return a type the same as TYPE except unsigned or
1111 signed according to UNSIGNEDP. */
1114 signed_or_unsigned_type (unsignedp
, type
)
1118 if (! INTEGRAL_TYPE_P (type
))
1120 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1121 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1122 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1123 return unsignedp
? unsigned_type_node
: integer_type_node
;
1124 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1125 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1126 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1127 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1128 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1129 return (unsignedp
? long_long_unsigned_type_node
1130 : long_long_integer_type_node
);
1138 enum tree_code code
= TREE_CODE (type
);
1141 if (code
== FUNCTION_TYPE
)
1143 if (pedantic
|| warn_pointer_arith
)
1144 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1145 return size_int (1);
1147 if (code
== METHOD_TYPE
)
1149 if (pedantic
|| warn_pointer_arith
)
1150 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1151 return size_int (1);
1153 if (code
== VOID_TYPE
)
1155 if (pedantic
|| warn_pointer_arith
)
1156 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1157 return size_int (1);
1159 if (code
== ERROR_MARK
)
1160 return size_int (1);
1162 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1163 referenced object.'' */
1164 if (code
== REFERENCE_TYPE
)
1165 type
= TREE_TYPE (type
);
1167 /* We couldn't find anything in the ARM or the draft standard that says,
1168 one way or the other, if doing sizeof on something that doesn't have
1169 an object associated with it is correct or incorrect. For example, if
1170 you declare `struct S { char str[16]; };', and in your program do
1171 a `sizeof (S::str)', should we flag that as an error or should we give
1172 the size of it? Since it seems like a reasonable thing to do, we'll go
1173 with giving the value. */
1174 if (code
== OFFSET_TYPE
)
1175 type
= TREE_TYPE (type
);
1177 /* @@ This also produces an error for a signature ref.
1178 In that case we should be able to do better. */
1179 if (IS_SIGNATURE (type
))
1181 error ("`sizeof' applied to a signature type");
1182 return size_int (0);
1185 if (TYPE_SIZE (type
) == 0)
1187 error ("`sizeof' applied to an incomplete type");
1188 return size_int (0);
1191 /* Convert in case a char is more than one unit. */
1192 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1193 size_int (TYPE_PRECISION (char_type_node
)));
1194 /* size_binop does not put the constant in range, so do it now. */
1195 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1196 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1201 c_sizeof_nowarn (type
)
1204 enum tree_code code
= TREE_CODE (type
);
1207 if (code
== FUNCTION_TYPE
1208 || code
== METHOD_TYPE
1209 || code
== VOID_TYPE
1210 || code
== ERROR_MARK
)
1211 return size_int (1);
1212 if (code
== REFERENCE_TYPE
)
1213 type
= TREE_TYPE (type
);
1215 if (TYPE_SIZE (type
) == 0)
1218 /* ??? Tiemann, why have any diagnostic here?
1219 There is none in the corresponding function for C. */
1220 warning ("sizeof applied to an incomplete type");
1222 return size_int (0);
1225 /* Convert in case a char is more than one unit. */
1226 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1227 size_int (TYPE_PRECISION (char_type_node
)));
1228 force_fit_type (t
, 0);
1232 /* Implement the __alignof keyword: Return the minimum required
1233 alignment of TYPE, measured in bytes. */
1239 enum tree_code code
= TREE_CODE (type
);
1242 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1243 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1245 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1246 return size_int (1);
1248 /* C++: this is really correct! */
1249 if (code
== REFERENCE_TYPE
)
1250 type
= TREE_TYPE (type
);
1252 /* @@ This also produces an error for a signature ref.
1253 In that case we should be able to do better. */
1254 if (IS_SIGNATURE (type
))
1256 error ("`__alignof' applied to a signature type");
1257 return size_int (1);
1260 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1261 force_fit_type (t
, 0);
1265 /* Perform default promotions for C data used in expressions.
1266 Arrays and functions are converted to pointers;
1267 enumeral types or short or char, to int.
1268 In addition, manifest constants symbols are replaced by their values.
1270 C++: this will automatically bash references to their target type. */
1273 default_conversion (exp
)
1276 register tree type
= TREE_TYPE (exp
);
1277 register enum tree_code code
= TREE_CODE (type
);
1279 if (code
== OFFSET_TYPE
/* || TREE_CODE (exp) == OFFSET_REF */ )
1281 if (TREE_CODE (exp
) == OFFSET_REF
)
1282 return default_conversion (resolve_offset_ref (exp
));
1284 type
= TREE_TYPE (type
);
1285 code
= TREE_CODE (type
);
1288 if (code
== REFERENCE_TYPE
)
1290 exp
= convert_from_reference (exp
);
1291 type
= TREE_TYPE (exp
);
1292 code
= TREE_CODE (type
);
1295 /* Constants can be used directly unless they're not loadable. */
1296 if (TREE_CODE (exp
) == CONST_DECL
)
1297 exp
= DECL_INITIAL (exp
);
1298 /* Replace a nonvolatile const static variable with its value. */
1299 else if (TREE_READONLY_DECL_P (exp
) && DECL_MODE (exp
) != BLKmode
)
1301 exp
= decl_constant_value (exp
);
1302 type
= TREE_TYPE (exp
);
1305 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1306 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1308 if (INTEGRAL_CODE_P (code
))
1310 tree t
= type_promotes_to (type
);
1311 if (t
!= TYPE_MAIN_VARIANT (type
))
1312 return convert (t
, exp
);
1314 if (flag_traditional
1315 && TYPE_MAIN_VARIANT (type
) == float_type_node
)
1316 return convert (double_type_node
, exp
);
1317 if (code
== VOID_TYPE
)
1319 error ("void value not ignored as it ought to be");
1320 return error_mark_node
;
1322 if (code
== FUNCTION_TYPE
)
1324 return build_unary_op (ADDR_EXPR
, exp
, 0);
1326 if (code
== METHOD_TYPE
)
1328 if (TREE_CODE (exp
) == OFFSET_REF
)
1330 my_friendly_assert (TREE_CODE (TREE_OPERAND (exp
, 1)) == FUNCTION_DECL
,
1332 return build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 1), 0);
1334 return build_unary_op (ADDR_EXPR
, exp
, 0);
1336 if (code
== ARRAY_TYPE
)
1341 int constp
, volatilep
;
1343 if (TREE_CODE (exp
) == INDIRECT_REF
)
1345 /* Stripping away the INDIRECT_REF is not the right
1346 thing to do for references... */
1347 tree inner
= TREE_OPERAND (exp
, 0);
1348 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1350 inner
= build1 (CONVERT_EXPR
,
1351 build_pointer_type (TREE_TYPE (TREE_TYPE (inner
))),
1353 TREE_REFERENCE_EXPR (inner
) = 1;
1355 return convert (TYPE_POINTER_TO (TREE_TYPE (type
)), inner
);
1358 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1360 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1361 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1362 TREE_OPERAND (exp
, 0), op1
);
1366 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1368 error ("invalid use of non-lvalue array");
1369 return error_mark_node
;
1372 constp
= volatilep
= 0;
1373 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r'
1374 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
1376 constp
= TREE_READONLY (exp
);
1377 volatilep
= TREE_THIS_VOLATILE (exp
);
1380 restype
= TREE_TYPE (type
);
1381 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)
1382 || constp
|| volatilep
)
1383 restype
= c_build_type_variant (restype
,
1384 TYPE_READONLY (type
) || constp
,
1385 TYPE_VOLATILE (type
) || volatilep
);
1386 ptrtype
= build_pointer_type (restype
);
1388 if (TREE_CODE (exp
) == VAR_DECL
)
1390 /* ??? This is not really quite correct
1391 in that the type of the operand of ADDR_EXPR
1392 is not the target type of the type of the ADDR_EXPR itself.
1393 Question is, can this lossage be avoided? */
1394 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1395 if (mark_addressable (exp
) == 0)
1396 return error_mark_node
;
1397 TREE_CONSTANT (adr
) = staticp (exp
);
1398 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1401 /* This way is better for a COMPONENT_REF since it can
1402 simplify the offset for a component. */
1403 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1404 return convert (ptrtype
, adr
);
1410 build_object_ref (datum
, basetype
, field
)
1411 tree datum
, basetype
, field
;
1413 if (datum
== error_mark_node
)
1414 return error_mark_node
;
1415 else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype
)))
1417 warning ("signature name in scope resolution ignored");
1418 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1420 else if (is_aggr_typedef (basetype
, 1))
1422 tree real_basetype
= IDENTIFIER_TYPE_VALUE (basetype
);
1423 tree binfo
= binfo_or_else (real_basetype
, TREE_TYPE (datum
));
1425 return build_component_ref (build_scoped_ref (datum
, basetype
),
1428 return error_mark_node
;
1431 /* Like `build_component_ref, but uses an already found field.
1432 Must compute access for C_C_D. Otherwise, ok. */
1434 build_component_ref_1 (datum
, field
, protect
)
1438 register tree basetype
= TREE_TYPE (datum
);
1439 register enum tree_code code
= TREE_CODE (basetype
);
1442 if (code
== REFERENCE_TYPE
)
1444 datum
= convert_from_reference (datum
);
1445 basetype
= TREE_TYPE (datum
);
1446 code
= TREE_CODE (basetype
);
1449 if (! IS_AGGR_TYPE_CODE (code
))
1451 if (code
!= ERROR_MARK
)
1452 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1453 field
, datum
, basetype
);
1454 return error_mark_node
;
1457 if (TYPE_SIZE (basetype
) == 0)
1459 incomplete_type_error (0, basetype
);
1460 return error_mark_node
;
1463 /* Look up component name in the structure type definition. */
1465 if (field
== error_mark_node
)
1466 my_friendly_abort (115);
1468 if (TREE_STATIC (field
))
1473 enum access_type access
1474 = compute_access (TYPE_BINFO (current_class_type
), field
);
1476 if (access
== access_private
)
1478 cp_error ("field `%D' is private", field
);
1479 return error_mark_node
;
1481 else if (access
== access_protected
)
1483 cp_error ("field `%D' is protected", field
);
1484 return error_mark_node
;
1488 ref
= build (COMPONENT_REF
, TREE_TYPE (field
), datum
, field
);
1490 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1491 TREE_READONLY (ref
) = 1;
1492 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1493 TREE_THIS_VOLATILE (ref
) = 1;
1494 if (DECL_MUTABLE_P (field
))
1495 TREE_READONLY (ref
) = 0;
1500 /* Given a COND_EXPR in T, return it in a form that we can, for
1501 example, use as an lvalue. This code used to be in unary_complex_lvalue,
1502 but we needed it to deal with `a = (d == c) ? b : c' expressions, where
1503 we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
1504 and in build_modify_expr. The case (in particular) that led to this was
1505 with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
1507 rationalize_conditional_expr (code
, t
)
1508 enum tree_code code
;
1512 build_conditional_expr (TREE_OPERAND (t
, 0),
1513 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1514 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1518 build_component_ref (datum
, component
, basetype_path
, protect
)
1519 tree datum
, component
, basetype_path
;
1522 register tree basetype
= TREE_TYPE (datum
);
1523 register enum tree_code code
= TREE_CODE (basetype
);
1524 register tree field
= NULL
;
1527 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1528 unless we are not to support things not strictly ANSI. */
1529 switch (TREE_CODE (datum
))
1533 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1534 basetype_path
, protect
);
1535 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1536 TREE_OPERAND (datum
, 0), value
);
1539 return build_conditional_expr
1540 (TREE_OPERAND (datum
, 0),
1541 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1542 basetype_path
, protect
),
1543 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1544 basetype_path
, protect
));
1547 if (code
== REFERENCE_TYPE
)
1550 /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
1551 @@ Maybe that is not right. */
1552 if (TREE_REFERENCE_EXPR (datum
))
1553 datum
= build1 (INDIRECT_REF
, TREE_TYPE (basetype
), datum
);
1556 datum
= convert_from_reference (datum
);
1557 basetype
= TREE_TYPE (datum
);
1558 code
= TREE_CODE (basetype
);
1561 /* First, see if there is a field or component with name COMPONENT. */
1562 if (TREE_CODE (component
) == TREE_LIST
)
1564 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1565 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1566 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1569 if (TREE_CODE (component
) == TYPE_EXPR
)
1570 return build_component_type_expr (datum
, component
, NULL_TREE
, protect
);
1573 if (! IS_AGGR_TYPE_CODE (code
))
1575 if (code
!= ERROR_MARK
)
1576 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1577 component
, datum
, basetype
);
1578 return error_mark_node
;
1581 if (TYPE_SIZE (basetype
) == 0)
1583 incomplete_type_error (0, basetype
);
1584 return error_mark_node
;
1587 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
1589 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
1591 cp_error ("destructor specifier `%T::~%T' must have matching names",
1592 basetype
, TREE_OPERAND (component
, 0));
1593 return error_mark_node
;
1595 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1597 cp_error ("type `%T' has no destructor", basetype
);
1598 return error_mark_node
;
1600 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
1603 /* Look up component name in the structure type definition. */
1604 if (CLASSTYPE_VFIELD (basetype
)
1605 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
1606 /* Special-case this because if we use normal lookups in an ambiguous
1607 hierarchy, the compiler will abort (because vptr lookups are
1608 not supposed to be ambiguous. */
1609 field
= CLASSTYPE_VFIELD (basetype
);
1612 if (basetype_path
== NULL_TREE
)
1613 basetype_path
= TYPE_BINFO (basetype
);
1614 field
= lookup_field (basetype_path
, component
,
1615 protect
&& ! VFIELD_NAME_P (component
), 0);
1616 if (field
== error_mark_node
)
1617 return error_mark_node
;
1619 if (field
== NULL_TREE
)
1621 /* Not found as a data field, look for it as a method. If found,
1622 then if this is the only possible one, return it, else
1623 report ambiguity error. */
1624 tree fndecls
= lookup_fnfields (basetype_path
, component
, 1);
1625 if (fndecls
== error_mark_node
)
1626 return error_mark_node
;
1629 if (TREE_CHAIN (fndecls
) == NULL_TREE
1630 && DECL_CHAIN (TREE_VALUE (fndecls
)) == NULL_TREE
)
1632 enum access_type access
;
1635 /* Unique, so use this one now. */
1636 basetype
= TREE_PURPOSE (fndecls
);
1637 fndecl
= TREE_VALUE (fndecls
);
1638 access
= compute_access (TREE_PURPOSE (fndecls
), fndecl
);
1639 if (access
== access_public
)
1641 if (DECL_VINDEX (fndecl
)
1642 && ! resolves_to_fixed_type_p (datum
, 0))
1644 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1645 addr
= convert_pointer_to (DECL_CONTEXT (fndecl
), addr
);
1646 datum
= build_indirect_ref (addr
, NULL_PTR
);
1647 my_friendly_assert (datum
!= error_mark_node
, 310);
1648 fndecl
= build_vfn_ref (&addr
, datum
, DECL_VINDEX (fndecl
));
1652 if (access
== access_protected
)
1653 cp_error ("member function `%D' is protected", fndecl
);
1655 cp_error ("member function `%D' is private", fndecl
);
1656 return error_mark_node
;
1659 return build (COMPONENT_REF
, unknown_type_node
, datum
, fndecls
);
1663 if (component
== ansi_opname
[(int) TYPE_EXPR
])
1664 cp_error ("`%#T' has no such type conversion operator", basetype
);
1667 cp_error ("`%#T' has no member named `%D'", basetype
, component
);
1668 return error_mark_node
;
1670 else if (TREE_TYPE (field
) == error_mark_node
)
1671 return error_mark_node
;
1673 if (TREE_CODE (field
) != FIELD_DECL
)
1675 if (TREE_CODE (field
) == TYPE_DECL
)
1677 cp_error ("invalid use of type decl `%#D' as expression", field
);
1678 return error_mark_node
;
1680 if (DECL_RTL (field
) != 0)
1681 assemble_external (field
);
1682 TREE_USED (field
) = 1;
1687 if (DECL_FIELD_CONTEXT (field
) != basetype
1688 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
1690 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1691 if (integer_zerop (addr
))
1693 error ("invalid reference to NULL ptr, use ptr-to-member instead");
1694 return error_mark_node
;
1696 addr
= convert_pointer_to (DECL_FIELD_CONTEXT (field
), addr
);
1697 datum
= build_indirect_ref (addr
, NULL_PTR
);
1698 my_friendly_assert (datum
!= error_mark_node
, 311);
1700 ref
= build (COMPONENT_REF
, TREE_TYPE (field
), break_out_cleanups (datum
), field
);
1702 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1703 TREE_READONLY (ref
) = 1;
1704 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1705 TREE_THIS_VOLATILE (ref
) = 1;
1706 if (DECL_MUTABLE_P (field
))
1707 TREE_READONLY (ref
) = 0;
1712 /* Given an expression PTR for a pointer, return an expression
1713 for the value pointed to.
1714 ERRORSTRING is the name of the operator to appear in error messages.
1716 This function may need to overload OPERATOR_FNNAME.
1717 Must also handle REFERENCE_TYPEs for C++. */
1720 build_x_indirect_ref (ptr
, errorstring
)
1724 tree rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
, NULL_TREE
);
1727 return build_indirect_ref (ptr
, errorstring
);
1731 build_indirect_ref (ptr
, errorstring
)
1735 register tree pointer
= default_conversion (ptr
);
1736 register tree type
= TREE_TYPE (pointer
);
1738 if (ptr
== current_class_decl
)
1741 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
1743 if (TREE_CODE (pointer
) == ADDR_EXPR
1744 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1745 == TREE_TYPE (type
)))
1746 return TREE_OPERAND (pointer
, 0);
1749 tree t
= TREE_TYPE (type
);
1750 register tree ref
= build1 (INDIRECT_REF
,
1751 TYPE_MAIN_VARIANT (t
), pointer
);
1753 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1754 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1755 TREE_SIDE_EFFECTS (ref
)
1756 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1760 /* `pointer' won't be an error_mark_node if we were given a
1761 pointer to member, so it's cool to check for this here. */
1762 else if (TYPE_PTRMEMFUNC_P (type
))
1763 error ("invalid use of `%s' on pointer to member function", errorstring
);
1764 else if (TREE_CODE (type
) == RECORD_TYPE
1765 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1766 error ("cannot dereference signature pointer/reference");
1767 else if (pointer
!= error_mark_node
)
1770 error ("invalid type argument of `%s'", errorstring
);
1772 error ("invalid type argument");
1774 return error_mark_node
;
1777 /* This handles expressions of the form "a[i]", which denotes
1780 This is logically equivalent in C to *(a+i), but we may do it differently.
1781 If A is a variable or a member, we generate a primitive ARRAY_REF.
1782 This avoids forcing the array out of registers, and can work on
1783 arrays that are not lvalues (for example, members of structures returned
1786 If INDEX is of some user-defined type, it must be converted to
1787 integer type. Otherwise, to make a compatible PLUS_EXPR, it
1788 will inherit the type of the array, which will be some pointer type. */
1791 build_x_array_ref (array
, index
)
1794 tree rval
= build_opfncall (ARRAY_REF
, LOOKUP_NORMAL
, array
, index
, NULL_TREE
);
1797 return build_array_ref (array
, index
);
1801 build_array_ref (array
, idx
)
1808 error ("subscript missing in array reference");
1809 return error_mark_node
;
1812 if (TREE_TYPE (array
) == error_mark_node
1813 || TREE_TYPE (idx
) == error_mark_node
)
1814 return error_mark_node
;
1816 itype
= TREE_TYPE (idx
);
1817 /* We must check here for the reference, so we can do the possible
1818 conversions immediately afterwards. */
1819 if (TREE_CODE (itype
) == REFERENCE_TYPE
)
1821 idx
= convert_from_reference (idx
);
1822 itype
= TREE_TYPE (idx
);
1825 if (IS_AGGR_TYPE (itype
))
1827 if (TYPE_HAS_INT_CONVERSION (itype
))
1828 idx
= build_type_conversion (CONVERT_EXPR
,
1829 integer_type_node
, idx
, 1);
1832 error_with_aggr_type (itype
,
1833 "type `%s' requires integer conversion for array indexing");
1834 return error_mark_node
;
1838 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
1839 && TREE_CODE (array
) != INDIRECT_REF
)
1843 /* Subscripting with type char is likely to lose
1844 on a machine where chars are signed.
1845 So warn on any machine, but optionally.
1846 Don't warn for unsigned char since that type is safe.
1847 Don't warn for signed char because anyone who uses that
1848 must have done so deliberately. */
1849 if (warn_char_subscripts
1850 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
1851 warning ("array subscript has type `char'");
1853 /* Apply default promotions *after* noticing character types. */
1854 idx
= default_conversion (idx
);
1856 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
1858 error ("array subscript is not an integer");
1859 return error_mark_node
;
1862 /* An array that is indexed by a non-constant
1863 cannot be stored in a register; we must be able to do
1864 address arithmetic on its address.
1865 Likewise an array of elements of variable size. */
1866 if (TREE_CODE (idx
) != INTEGER_CST
1867 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
1868 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1870 if (mark_addressable (array
) == 0)
1871 return error_mark_node
;
1873 /* An array that is indexed by a constant value which is not within
1874 the array bounds cannot be stored in a register either; because we
1875 would get a crash in store_bit_field/extract_bit_field when trying
1876 to access a non-existent part of the register. */
1877 if (TREE_CODE (idx
) == INTEGER_CST
1878 && TYPE_VALUES (TREE_TYPE (array
))
1879 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
1881 if (mark_addressable (array
) == 0)
1882 return error_mark_node
;
1885 /* Note in C++ we don't bother warning about subscripting a
1886 `register' array, since it's legal in C++ to take the address
1887 of something with that storage specification. */
1888 if (pedantic
&& !lvalue_p (array
))
1889 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1894 while (TREE_CODE (foo
) == COMPONENT_REF
)
1895 foo
= TREE_OPERAND (foo
, 0);
1896 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
1897 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1900 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1901 rval
= build (ARRAY_REF
, type
, array
, idx
);
1902 /* Array ref is const/volatile if the array elements are
1903 or if the array is.. */
1904 TREE_READONLY (rval
)
1905 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1906 | TREE_READONLY (array
));
1907 TREE_SIDE_EFFECTS (rval
)
1908 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1909 | TREE_SIDE_EFFECTS (array
));
1910 TREE_THIS_VOLATILE (rval
)
1911 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1912 /* This was added by rms on 16 Nov 91.
1913 It fixes vol struct foo *a; a->elts[1]
1914 in an inline function.
1915 Hope it doesn't break something else. */
1916 | TREE_THIS_VOLATILE (array
));
1917 return require_complete_type (fold (rval
));
1921 tree ar
= default_conversion (array
);
1922 tree ind
= default_conversion (idx
);
1924 /* Put the integer in IND to simplify error checking. */
1925 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
1932 if (ar
== error_mark_node
)
1935 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
1937 error ("subscripted value is neither array nor pointer");
1938 return error_mark_node
;
1940 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
1942 error ("array subscript is not an integer");
1943 return error_mark_node
;
1946 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
, ind
, PLUS_EXPR
),
1951 /* Build a function call to function FUNCTION with parameters PARAMS.
1952 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1953 TREE_VALUE of each node is a parameter-expression.
1954 FUNCTION's data type may be a function type or a pointer-to-function.
1956 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
1957 is the list of possible methods that FUNCTION could conceivably
1958 be. If the list of methods comes from a class, then it will be
1959 a list of lists (where each element is associated with the class
1960 that produced it), otherwise it will be a simple list (for
1961 functions overloaded in global scope).
1963 In the first case, TREE_VALUE (function) is the head of one of those
1964 lists, and TREE_PURPOSE is the name of the function.
1966 In the second case, TREE_PURPOSE (function) is the function's
1969 DECL is the class instance variable, usually CURRENT_CLASS_DECL. */
1972 * [eichin:19911015.1726EST] actually return a possibly incomplete
1976 build_x_function_call (function
, params
, decl
)
1977 tree function
, params
, decl
;
1982 if (function
== error_mark_node
)
1983 return error_mark_node
;
1985 type
= TREE_TYPE (function
);
1986 is_method
= ((TREE_CODE (function
) == TREE_LIST
1987 && current_class_type
!= NULL_TREE
1988 && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
)) == function
)
1989 || TREE_CODE (function
) == IDENTIFIER_NODE
1990 || TREE_CODE (type
) == METHOD_TYPE
1991 || TYPE_PTRMEMFUNC_P (type
));
1993 /* Handle methods, friends, and overloaded functions, respectively. */
1996 if (TREE_CODE (function
) == FUNCTION_DECL
)
1998 if (DECL_NAME (function
))
1999 function
= DECL_NAME (function
);
2001 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2003 else if (TREE_CODE (function
) == TREE_LIST
)
2006 if (TREE_CODE (TREE_VALUE (function
)) == TREE_LIST
)
2007 function
= TREE_PURPOSE (TREE_VALUE (function
));
2009 function
= TREE_PURPOSE (function
);
2011 my_friendly_assert (TREE_CODE (TREE_VALUE (function
)) == FUNCTION_DECL
, 312);
2012 function
= TREE_PURPOSE (function
);
2015 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2017 if (TREE_CODE (function
) == OFFSET_REF
)
2019 if (TREE_OPERAND (function
, 0))
2020 decl
= TREE_OPERAND (function
, 0);
2022 /* Call via a pointer to member function. */
2023 if (decl
== NULL_TREE
)
2025 error ("pointer to member function called, but not in class scope");
2026 return error_mark_node
;
2028 /* What other type of POINTER_TYPE could this be? */
2029 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2030 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2031 && TREE_CODE (function
) != OFFSET_REF
)
2032 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
, function
);
2036 /* this is an abbreviated method call.
2037 must go through here in case it is a virtual function.
2038 @@ Perhaps this could be optimized. */
2040 if (decl
== NULL_TREE
)
2042 if (current_class_type
== NULL_TREE
)
2044 error ("object missing in call to method `%s'",
2045 IDENTIFIER_POINTER (function
));
2046 return error_mark_node
;
2048 /* Yow: call from a static member function. */
2049 decl
= build1 (NOP_EXPR
, TYPE_POINTER_TO (current_class_type
),
2051 decl
= build_indirect_ref (decl
, NULL_PTR
);
2054 return build_method_call (decl
, function
, params
,
2055 NULL_TREE
, LOOKUP_NORMAL
);
2057 else if (TREE_CODE (function
) == COMPONENT_REF
2058 && type
== unknown_type_node
)
2060 /* Should we undo what was done in build_component_ref? */
2061 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function
, 1))) == TREE_VEC
)
2062 /* Get the name that build_component_ref hid. */
2063 function
= DECL_NAME (TREE_VALUE (TREE_OPERAND (function
, 1)));
2065 function
= TREE_PURPOSE (TREE_OPERAND (function
, 1));
2066 return build_method_call (decl
, function
, params
,
2067 NULL_TREE
, LOOKUP_NORMAL
);
2069 else if (TREE_CODE (function
) == TREE_LIST
)
2071 if (TREE_VALUE (function
) == NULL_TREE
)
2073 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2074 TREE_PURPOSE (function
));
2075 return error_mark_node
;
2079 tree id
= TREE_PURPOSE (function
);
2080 function
= TREE_VALUE (function
);
2082 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2083 return build_overload_call_maybe
2084 (id
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2085 else if (DECL_CHAIN (function
) != NULL_TREE
)
2086 return build_overload_call
2087 (id
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2093 if (TREE_CODE (function
) == OFFSET_REF
)
2095 /* If the component is a data element (or a virtual function), we play
2096 games here to make things work. */
2099 if (TREE_OPERAND (function
, 0))
2100 decl
= TREE_OPERAND (function
, 0);
2104 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2105 function
= get_member_function_from_ptrfunc (&decl_addr
, decl
,
2106 TREE_OPERAND (function
, 1));
2107 params
= tree_cons (NULL_TREE
, decl_addr
, params
);
2108 return build_function_call (function
, params
);
2111 type
= TREE_TYPE (function
);
2112 if (type
!= error_mark_node
)
2114 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2115 type
= TREE_TYPE (type
);
2117 if (TYPE_LANG_SPECIFIC (type
) && TYPE_OVERLOADS_CALL_EXPR (type
))
2118 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2123 tree fntype
= TREE_TYPE (function
);
2126 /* Explicitly named method? */
2127 if (TREE_CODE (function
) == FUNCTION_DECL
)
2128 ctypeptr
= TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function
));
2129 /* Expression with ptr-to-method type? It could either be a plain
2130 usage, or it might be a case where the ptr-to-method is being
2131 passed in as an argument. */
2132 else if (TYPE_PTRMEMFUNC_P (fntype
))
2134 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2135 ctypeptr
= TYPE_POINTER_TO (rec
);
2137 /* Unexpected node type? */
2139 my_friendly_abort (116);
2140 if (decl
== NULL_TREE
)
2142 if (current_function_decl
2143 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2144 error ("invalid call to member function needing `this' in static member function scope");
2146 error ("pointer to member function called, but not in class scope");
2147 return error_mark_node
;
2149 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2150 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2152 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2153 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2156 decl
= build_c_cast (ctypeptr
, decl
);
2157 params
= tree_cons (NULL_TREE
, decl
, params
);
2160 return build_function_call (function
, params
);
2163 /* Resolve a pointer to member function. INSTANCE is the object
2164 instance to use, if the member points to a virtual member. */
2167 get_member_function_from_ptrfunc (instance_ptrptr
, instance
, function
)
2168 tree
*instance_ptrptr
;
2172 if (TREE_CODE (function
) == OFFSET_REF
)
2174 function
= TREE_OPERAND (function
, 1);
2177 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2179 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2180 tree index
= save_expr (convert (integer_type_node
,
2181 build_component_ref (function
,
2184 tree e1
= build (GT_EXPR
, integer_type_node
, index
, integer_zero_node
);
2185 tree delta
= build_component_ref (function
, delta_identifier
, 0, 0);
2186 tree delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2191 /* convert down to the right base, before using the instance. */
2192 instance
= convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
)),
2193 build_unary_op (ADDR_EXPR
, instance
, 0));
2194 if (instance
== error_mark_node
)
2197 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2200 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2201 vtbl
, convert (sizetype
, delta2
));
2202 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2203 aref
= build_array_ref (vtbl
, size_binop (MINUS_EXPR
,
2206 if (! flag_vtable_thunks
)
2208 aref
= save_expr (aref
);
2210 /* Save the intermediate result in a SAVE_EXPR so we don't have to
2211 compute each component of the virtual function pointer twice. */
2212 if (/* !building_cleanup && */ TREE_CODE (aref
) == INDIRECT_REF
)
2213 TREE_OPERAND (aref
, 0) = save_expr (TREE_OPERAND (aref
, 0));
2215 delta
= build (PLUS_EXPR
, integer_type_node
,
2216 build_conditional_expr (e1
, build_component_ref (aref
, delta_identifier
, 0, 0), integer_zero_node
),
2220 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (*instance_ptrptr
),
2222 convert (integer_type_node
, delta
));
2223 if (flag_vtable_thunks
)
2226 e2
= build_component_ref (aref
, pfn_identifier
, 0, 0);
2228 e3
= PFN_FROM_PTRMEMFUNC (function
);
2229 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2230 function
= build_conditional_expr (e1
, e2
, e3
);
2236 build_function_call_real (function
, params
, require_complete
, flags
)
2237 tree function
, params
;
2238 int require_complete
, flags
;
2240 register tree fntype
, fndecl
;
2241 register tree value_type
;
2242 register tree coerced_params
;
2243 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2246 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2247 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2248 if (TREE_CODE (function
) == NOP_EXPR
2249 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2250 function
= TREE_OPERAND (function
, 0);
2252 if (TREE_CODE (function
) == FUNCTION_DECL
)
2254 name
= DECL_NAME (function
);
2255 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2257 GNU_xref_call (current_function_decl
,
2258 IDENTIFIER_POINTER (name
? name
2259 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
))));
2260 assemble_external (function
);
2263 /* Convert anything with function type to a pointer-to-function. */
2266 && IDENTIFIER_LENGTH (name
) == 4
2267 && ! strcmp (IDENTIFIER_POINTER (name
), "main")
2268 && DECL_CONTEXT (function
) == NULL_TREE
)
2270 pedwarn ("ANSI C++ forbids calling `main' from within program");
2273 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2274 (because calling an inline function does not mean the function
2275 needs to be separately compiled). */
2277 if (DECL_INLINE (function
))
2279 fntype
= build_type_variant (TREE_TYPE (function
),
2280 TREE_READONLY (function
),
2281 TREE_THIS_VOLATILE (function
));
2282 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2286 assemble_external (function
);
2287 TREE_USED (function
) = 1;
2288 function
= default_conversion (function
);
2295 /* Convert anything with function type to a pointer-to-function. */
2296 if (function
== error_mark_node
)
2297 return error_mark_node
;
2298 function
= default_conversion (function
);
2301 fntype
= TREE_TYPE (function
);
2303 if (TYPE_PTRMEMFUNC_P (fntype
))
2305 tree instance_ptr
= build_unary_op (ADDR_EXPR
, C_C_D
, 0);
2306 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (fntype
);
2307 function
= get_member_function_from_ptrfunc (&instance_ptr
, C_C_D
, function
);
2310 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2311 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2313 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2314 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2317 error ("called object is not a function");
2318 return error_mark_node
;
2321 /* fntype now gets the type of function pointed to. */
2322 fntype
= TREE_TYPE (fntype
);
2324 /* Convert the parameters to the types declared in the
2325 function prototype, or apply default promotions. */
2327 if (flags
& LOOKUP_COMPLAIN
)
2328 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2329 params
, fndecl
, LOOKUP_NORMAL
);
2331 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2334 /* Check for errors in format strings. */
2336 if (warn_format
&& (name
|| assembler_name
))
2337 check_function_format (name
, assembler_name
, coerced_params
);
2339 /* Recognize certain built-in functions so we can make tree-codes
2340 other than CALL_EXPR. We do this when it enables fold-const.c
2341 to do something useful. */
2343 if (TREE_CODE (function
) == ADDR_EXPR
2344 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2345 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2346 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2351 if (coerced_params
== 0)
2352 return integer_zero_node
;
2353 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2357 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2359 register tree result
=
2360 build (CALL_EXPR
, value_type
,
2361 function
, coerced_params
, NULL_TREE
);
2363 TREE_SIDE_EFFECTS (result
) = 1;
2364 /* Remove this sometime. */
2365 TREE_RAISES (result
) |= !! TYPE_RAISES_EXCEPTIONS (fntype
);
2366 if (! require_complete
)
2368 if (value_type
== void_type_node
)
2370 return require_complete_type (result
);
2375 build_function_call (function
, params
)
2376 tree function
, params
;
2378 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2382 build_function_call_maybe (function
, params
)
2383 tree function
, params
;
2385 return build_function_call_real (function
, params
, 0, 0);
2389 /* Convert the actual parameter expressions in the list VALUES
2390 to the types in the list TYPELIST.
2391 If parmdecls is exhausted, or when an element has NULL as its type,
2392 perform the default conversions.
2394 RETURN_LOC is the location of the return value, if known, NULL_TREE
2395 otherwise. This is useful in the case where we can avoid creating
2396 a temporary variable in the case where we can initialize the return
2397 value directly. If we are not eliding constructors, then we set this
2398 to NULL_TREE to avoid this avoidance.
2400 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2402 This is also where warnings about wrong number of args are generated.
2404 Return a list of expressions for the parameters as converted.
2406 Both VALUES and the returned value are chains of TREE_LIST nodes
2407 with the elements of the list in the TREE_VALUE slots of those nodes.
2409 In C++, unspecified trailing parameters can be filled in with their
2410 default arguments, if such were specified. Do so here. */
2413 convert_arguments (return_loc
, typelist
, values
, fndecl
, flags
)
2414 tree return_loc
, typelist
, values
, fndecl
;
2417 extern tree gc_protect_fndecl
;
2418 register tree typetail
, valtail
;
2419 register tree result
= NULL_TREE
;
2421 int maybe_raises
= 0;
2424 if (! flag_elide_constructors
)
2429 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2431 if (DECL_NAME (fndecl
) == NULL_TREE
2432 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2433 called_thing
= "constructor";
2435 called_thing
= "member function";
2438 called_thing
= "function";
2441 for (valtail
= values
, typetail
= typelist
;
2443 valtail
= TREE_CHAIN (valtail
), i
++)
2445 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2446 register tree val
= TREE_VALUE (valtail
);
2448 if (type
== void_type_node
)
2452 char *buf
= (char *)alloca (40 + strlen (called_thing
));
2453 sprintf (buf
, "too many arguments to %s `%%s'", called_thing
);
2454 error_with_decl (fndecl
, buf
);
2455 error ("at this point in file");
2458 error ("too many arguments to function");
2459 /* In case anybody wants to know if this argument
2462 TREE_TYPE (tree_last (result
)) = error_mark_node
;
2466 /* The tree type of the parameter being passed may not yet be
2467 known. In this case, its type is TYPE_UNKNOWN, and will
2468 be instantiated by the type given by TYPE. If TYPE
2469 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
2470 if (type
&& type_unknown_p (val
))
2471 val
= require_instantiated_type (type
, val
, integer_zero_node
);
2472 else if (type_unknown_p (val
))
2474 /* Strip the `&' from an overloaded FUNCTION_DECL. */
2475 if (TREE_CODE (val
) == ADDR_EXPR
)
2476 val
= TREE_OPERAND (val
, 0);
2477 if (TREE_CODE (val
) == TREE_LIST
2478 && TREE_CHAIN (val
) == NULL_TREE
2479 && TREE_TYPE (TREE_VALUE (val
)) != NULL_TREE
2480 && (TREE_TYPE (val
) == unknown_type_node
2481 || DECL_CHAIN (TREE_VALUE (val
)) == NULL_TREE
))
2482 /* Instantiates automatically. */
2483 val
= TREE_VALUE (val
);
2486 error ("insufficient type information in parameter list");
2487 val
= integer_zero_node
;
2490 else if (TREE_CODE (val
) == OFFSET_REF
2491 && TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2493 /* This is unclean. Should be handled elsewhere. */
2494 val
= build_unary_op (ADDR_EXPR
, val
, 0);
2496 else if (TREE_CODE (val
) == OFFSET_REF
)
2497 val
= resolve_offset_ref (val
);
2501 /* This code forces the assumption that if we have a ptr-to-func
2502 type in an arglist, that every routine that wants to check
2503 its validity has done so, and thus we need not do any
2504 more conversion. I don't remember why this is necessary. */
2505 else if (TREE_CODE (ttype
) == FUNCTION_TYPE
2507 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
2508 || TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
))
2510 type
= build_pointer_type (ttype
);
2515 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2516 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2517 if (TREE_CODE (val
) == NOP_EXPR
2518 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
2519 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
2520 val
= TREE_OPERAND (val
, 0);
2522 if ((type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
2523 && (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
2524 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
2525 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
))
2526 val
= default_conversion (val
);
2528 val
= require_complete_type (val
);
2530 if (val
== error_mark_node
)
2533 maybe_raises
|= TREE_RAISES (val
);
2537 /* Formal parm type is specified by a function prototype. */
2540 if (TYPE_SIZE (type
) == 0)
2542 error ("parameter type of called function is incomplete");
2547 #ifdef PROMOTE_PROTOTYPES
2548 /* Rather than truncating and then reextending,
2549 convert directly to int, if that's the type we will want. */
2550 if (! flag_traditional
2551 && (TREE_CODE (type
) == INTEGER_TYPE
2552 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2553 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2554 type
= integer_type_node
;
2556 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2557 "argument passing", fndecl
, i
);
2558 #ifdef PROMOTE_PROTOTYPES
2559 if ((TREE_CODE (type
) == INTEGER_TYPE
2560 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2561 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2562 parmval
= default_conversion (parmval
);
2565 result
= tree_cons (NULL_TREE
, parmval
, result
);
2569 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
2570 val
= convert_from_reference (val
);
2572 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2573 && (TYPE_PRECISION (TREE_TYPE (val
))
2574 < TYPE_PRECISION (double_type_node
)))
2575 /* Convert `float' to `double'. */
2576 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2577 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
2578 && (TYPE_HAS_INIT_REF (TREE_TYPE (val
))
2579 || TYPE_HAS_ASSIGN_REF (TREE_TYPE (val
))))
2581 cp_warning ("cannot pass objects of type `%T' through `...'",
2583 result
= tree_cons (NULL_TREE
, val
, result
);
2586 /* Convert `short' and `char' to full-size `int'. */
2587 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2591 /* There are certain functions for which we don't need
2592 to protect our arguments. GC_PROTECT_FNDECL is one. */
2593 && fndecl
!= gc_protect_fndecl
2594 && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result
)))
2595 && ! value_safe_from_gc (NULL_TREE
, TREE_VALUE (result
)))
2596 /* This will build a temporary variable whose cleanup is
2597 to clear the obstack entry. */
2598 TREE_VALUE (result
) = protect_value_from_gc (NULL_TREE
,
2599 TREE_VALUE (result
));
2602 typetail
= TREE_CHAIN (typetail
);
2605 if (typetail
!= 0 && typetail
!= void_list_node
)
2607 /* See if there are default arguments that can be used */
2608 if (TREE_PURPOSE (typetail
))
2610 while (typetail
!= void_list_node
)
2612 tree type
= TREE_VALUE (typetail
);
2613 tree val
= TREE_PURPOSE (typetail
);
2616 if (val
== NULL_TREE
)
2617 parmval
= error_mark_node
;
2618 else if (TREE_CODE (val
) == CONSTRUCTOR
)
2620 parmval
= digest_init (type
, val
, (tree
*)0);
2621 parmval
= convert_for_initialization (return_loc
, type
, parmval
, flags
,
2622 "default constructor", fndecl
, i
);
2626 /* This could get clobbered by the following call. */
2627 if (TREE_HAS_CONSTRUCTOR (val
))
2628 val
= copy_node (val
);
2630 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2631 "default argument", fndecl
, i
);
2632 #ifdef PROMOTE_PROTOTYPES
2633 if ((TREE_CODE (type
) == INTEGER_TYPE
2634 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2635 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2636 parmval
= default_conversion (parmval
);
2639 maybe_raises
|= TREE_RAISES (parmval
);
2642 && type_needs_gc_entry (TREE_TYPE (parmval
))
2643 && ! value_safe_from_gc (NULL_TREE
, parmval
))
2644 parmval
= protect_value_from_gc (NULL_TREE
, parmval
);
2646 result
= tree_cons (0, parmval
, result
);
2647 typetail
= TREE_CHAIN (typetail
);
2648 /* ends with `...'. */
2649 if (typetail
== NULL_TREE
)
2657 char *buf
= (char *)alloca (32 + strlen (called_thing
));
2658 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
2659 cp_error_at (buf
, fndecl
);
2660 error ("at this point in file");
2663 error ("too few arguments to function");
2664 return error_mark_list
;
2668 TREE_RAISES (result
) = maybe_raises
;
2670 return nreverse (result
);
2673 /* Build a binary-operation expression, after performing default
2674 conversions on the operands. CODE is the kind of expression to build. */
2677 build_x_binary_op (code
, arg1
, arg2
)
2678 enum tree_code code
;
2681 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
,
2682 arg1
, arg2
, NULL_TREE
);
2684 return build_opfncall (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
2685 if (code
== MEMBER_REF
)
2686 return build_m_component_ref (build_indirect_ref (arg1
, NULL_PTR
),
2688 return build_binary_op (code
, arg1
, arg2
, 1);
2692 build_binary_op (code
, arg1
, arg2
, convert_p
)
2693 enum tree_code code
;
2705 args
[0] = default_conversion (args
[0]);
2706 args
[1] = default_conversion (args
[1]);
2708 if (type_unknown_p (args
[0]))
2710 args
[0] = instantiate_type (TREE_TYPE (args
[1]), args
[0], 1);
2711 args
[0] = default_conversion (args
[0]);
2713 else if (type_unknown_p (args
[1]))
2715 args
[1] = require_instantiated_type (TREE_TYPE (args
[0]),
2718 args
[1] = default_conversion (args
[1]);
2721 type1
= TREE_TYPE (args
[0]);
2722 type2
= TREE_TYPE (args
[1]);
2724 if (IS_AGGR_TYPE_2 (type1
, type2
) && ! TYPE_PTRMEMFUNC_P (type1
))
2726 /* Try to convert this to something reasonable. */
2727 if (! build_default_binary_type_conversion(code
, &args
[0], &args
[1]))
2728 return error_mark_node
;
2730 else if ((IS_AGGR_TYPE (type1
) && ! TYPE_PTRMEMFUNC_P (type1
))
2731 || (IS_AGGR_TYPE (type2
) && ! TYPE_PTRMEMFUNC_P (type2
)))
2733 int convert_index
= IS_AGGR_TYPE (type2
);
2734 /* Avoid being tripped up by things like (ARG1 != 0). */
2737 types
[0] = type1
; types
[1] = type2
;
2738 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
2739 try = build_type_conversion (code
, bool_type_node
,
2740 args
[convert_index
], 1);
2743 try = build_type_conversion (code
, types
[convert_index
^ 1],
2744 args
[convert_index
], 1);
2747 && args
[1] == integer_zero_node
2748 && (code
== NE_EXPR
|| code
== EQ_EXPR
))
2749 try = build_type_conversion (code
, ptr_type_node
,
2750 args
[convert_index
], 1);
2755 cp_error ("no match for `%O(%#T, %#T)'", code
,
2756 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
2757 return error_mark_node
;
2759 if (try == error_mark_node
)
2760 error ("ambiguous pointer conversion");
2761 args
[convert_index
] = try;
2764 return build_binary_op_nodefault (code
, args
[0], args
[1], code
);
2767 /* Build a binary-operation expression without default conversions.
2768 CODE is the kind of expression to build.
2769 This function differs from `build' in several ways:
2770 the data type of the result is computed and recorded in it,
2771 warnings are generated if arg data types are invalid,
2772 special handling for addition and subtraction of pointers is known,
2773 and some optimization is done (operations on narrow ints
2774 are done in the narrower type when that gives the same result).
2775 Constant folding is also done before the result is returned.
2777 ERROR_CODE is the code that determines what to say in error messages.
2778 It is usually, but not always, the same as CODE.
2780 Note that the operands will never have enumeral types
2781 because either they have just had the default conversions performed
2782 or they have both just been converted to some other type in which
2783 the arithmetic is to be done.
2785 C++: must do special pointer arithmetic when implementing
2786 multiple inheritance, and deal with pointer to member functions. */
2789 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
2790 enum tree_code code
;
2791 tree orig_op0
, orig_op1
;
2792 enum tree_code error_code
;
2795 register enum tree_code code0
, code1
;
2798 /* Expression code to give to the expression when it is built.
2799 Normally this is CODE, which is what the caller asked for,
2800 but in some special cases we change it. */
2801 register enum tree_code resultcode
= code
;
2803 /* Data type in which the computation is to be performed.
2804 In the simplest cases this is the common type of the arguments. */
2805 register tree result_type
= NULL
;
2807 /* Nonzero means operands have already been type-converted
2808 in whatever way is necessary.
2809 Zero means they need to be converted to RESULT_TYPE. */
2812 /* Nonzero means after finally constructing the expression
2813 give it this type. Otherwise, give it type RESULT_TYPE. */
2814 tree final_type
= 0;
2816 /* Nonzero if this is an operation like MIN or MAX which can
2817 safely be computed in short if both args are promoted shorts.
2818 Also implies COMMON.
2819 -1 indicates a bitwise operation; this makes a difference
2820 in the exact conditions for when it is safe to do the operation
2821 in a narrower mode. */
2824 /* Nonzero if this is a comparison operation;
2825 if both args are promoted shorts, compare the original shorts.
2826 Also implies COMMON. */
2827 int short_compare
= 0;
2829 /* Nonzero if this is a right-shift operation, which can be computed on the
2830 original short and then promoted if the operand is a promoted short. */
2831 int short_shift
= 0;
2833 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2836 /* Apply default conversions. */
2837 op0
= default_conversion (orig_op0
);
2838 op1
= default_conversion (orig_op1
);
2840 type0
= TREE_TYPE (op0
);
2841 type1
= TREE_TYPE (op1
);
2843 /* The expression codes of the data types of the arguments tell us
2844 whether the arguments are integers, floating, pointers, etc. */
2845 code0
= TREE_CODE (type0
);
2846 code1
= TREE_CODE (type1
);
2848 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2849 STRIP_TYPE_NOPS (op0
);
2850 STRIP_TYPE_NOPS (op1
);
2852 /* If an error was already reported for one of the arguments,
2853 avoid reporting another error. */
2855 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
2856 return error_mark_node
;
2861 /* Handle the pointer + int case. */
2862 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2863 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
2864 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
2865 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
2871 /* Subtraction of two similar pointers.
2872 We must subtract them as integers, then divide by object size. */
2873 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
2874 && comp_target_types (type0
, type1
, 1))
2875 return pointer_diff (op0
, op1
);
2876 /* Handle pointer minus int. Just like pointer plus int. */
2877 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2878 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
2887 case TRUNC_DIV_EXPR
:
2889 case FLOOR_DIV_EXPR
:
2890 case ROUND_DIV_EXPR
:
2891 case EXACT_DIV_EXPR
:
2892 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2893 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2895 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
2897 error ("division by zero");
2898 op1
= integer_one_node
;
2900 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
2902 error ("division by zero");
2903 op1
= build_real (TREE_TYPE (op1
), dconst1
);
2906 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
2907 resultcode
= RDIV_EXPR
;
2909 /* When dividing two signed integers, we have to promote to int.
2910 unless we divide by a conatant != -1. Note that default
2911 conversion will have been performed on the operands at this
2912 point, so we have to dig out the original type to find out if
2914 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2915 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2916 || (TREE_CODE (op1
) == INTEGER_CST
2917 && (TREE_INT_CST_LOW (op1
) != -1
2918 || TREE_INT_CST_HIGH (op1
) != -1)));
2924 case BIT_ANDTC_EXPR
:
2927 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2929 /* If one operand is a constant, and the other is a short type
2930 that has been converted to an int,
2931 really do the work in the short type and then convert the
2932 result to int. If we are lucky, the constant will be 0 or 1
2933 in the short type, making the entire operation go away. */
2934 if (TREE_CODE (op0
) == INTEGER_CST
2935 && TREE_CODE (op1
) == NOP_EXPR
2936 && TYPE_PRECISION (type1
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))
2937 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
2939 final_type
= result_type
;
2940 op1
= TREE_OPERAND (op1
, 0);
2941 result_type
= TREE_TYPE (op1
);
2943 if (TREE_CODE (op1
) == INTEGER_CST
2944 && TREE_CODE (op0
) == NOP_EXPR
2945 && TYPE_PRECISION (type0
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2946 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2948 final_type
= result_type
;
2949 op0
= TREE_OPERAND (op0
, 0);
2950 result_type
= TREE_TYPE (op0
);
2954 case TRUNC_MOD_EXPR
:
2955 case FLOOR_MOD_EXPR
:
2956 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
2958 error ("division by zero");
2959 op1
= integer_one_node
;
2961 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
2963 error ("division by zero");
2964 op1
= build_real (TREE_TYPE (op1
), dconst1
);
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 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3263 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3265 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3267 if (! comp_target_types (type0
, type1
, 1))
3268 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3270 else if ((TYPE_SIZE (TREE_TYPE (type0
)) != 0)
3271 != (TYPE_SIZE (TREE_TYPE (type1
)) != 0))
3272 cp_pedwarn ("comparison of %scomplete and %scomplete pointers",
3273 TYPE_SIZE (TREE_TYPE (type0
)) == 0 ? "in" : "",
3274 TYPE_SIZE (TREE_TYPE (type1
)) == 0 ? "in" : "",
3277 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
3278 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3280 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3281 && integer_zerop (op1
))
3283 op1
= null_pointer_node
;
3285 pedwarn ("ordered comparison of pointer with integer zero");
3287 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3288 && integer_zerop (op0
))
3290 op0
= null_pointer_node
;
3292 pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
3294 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3297 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3298 else if (! flag_traditional
)
3299 warning ("comparison between pointer and integer");
3300 op1
= convert (TREE_TYPE (op0
), op1
);
3302 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3305 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3306 else if (! flag_traditional
)
3307 warning ("comparison between pointer and integer");
3308 op0
= convert (TREE_TYPE (op1
), op0
);
3310 result_type
= bool_type_node
;
3315 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3316 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3318 if (shorten
|| common
|| short_compare
)
3319 result_type
= common_type (type0
, type1
);
3321 /* For certain operations (which identify themselves by shorten != 0)
3322 if both args were extended from the same smaller type,
3323 do the arithmetic in that type and then extend.
3325 shorten !=0 and !=1 indicates a bitwise operation.
3326 For them, this optimization is safe only if
3327 both args are zero-extended or both are sign-extended.
3328 Otherwise, we might change the result.
3329 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3330 but calculated in (unsigned short) it would be (unsigned short)-1. */
3334 int unsigned0
, unsigned1
;
3335 tree arg0
= get_narrower (op0
, &unsigned0
);
3336 tree arg1
= get_narrower (op1
, &unsigned1
);
3337 /* UNS is 1 if the operation to be done is an unsigned one. */
3338 int uns
= TREE_UNSIGNED (result_type
);
3341 final_type
= result_type
;
3343 /* Handle the case that OP0 does not *contain* a conversion
3344 but it *requires* conversion to FINAL_TYPE. */
3346 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3347 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3348 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3349 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3351 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3353 /* For bitwise operations, signedness of nominal type
3354 does not matter. Consider only how operands were extended. */
3358 /* Note that in all three cases below we refrain from optimizing
3359 an unsigned operation on sign-extended args.
3360 That would not be valid. */
3362 /* Both args variable: if both extended in same way
3363 from same width, do it in that width.
3364 Do it unsigned if args were zero-extended. */
3365 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3366 < TYPE_PRECISION (result_type
))
3367 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3368 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3369 && unsigned0
== unsigned1
3370 && (unsigned0
|| !uns
))
3372 = signed_or_unsigned_type (unsigned0
,
3373 common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
3374 else if (TREE_CODE (arg0
) == INTEGER_CST
3375 && (unsigned1
|| !uns
)
3376 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3377 < TYPE_PRECISION (result_type
))
3378 && (type
= signed_or_unsigned_type (unsigned1
,
3380 int_fits_type_p (arg0
, type
)))
3382 else if (TREE_CODE (arg1
) == INTEGER_CST
3383 && (unsigned0
|| !uns
)
3384 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3385 < TYPE_PRECISION (result_type
))
3386 && (type
= signed_or_unsigned_type (unsigned0
,
3388 int_fits_type_p (arg1
, type
)))
3392 /* Shifts can be shortened if shifting right. */
3397 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3399 final_type
= result_type
;
3401 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3402 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3404 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3405 /* If arg is sign-extended and then unsigned-shifted,
3406 we can simulate this with a signed shift in arg's type
3407 only if the extended result is at least twice as wide
3408 as the arg. Otherwise, the shift could use up all the
3409 ones made by sign-extension and bring in zeros.
3410 We can't optimize that case at all, but in most machines
3411 it never happens because available widths are 2**N. */
3412 && (!TREE_UNSIGNED (final_type
)
3414 || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
))
3415 <= TYPE_PRECISION (result_type
))))
3417 /* Do an unsigned shift if the operand was zero-extended. */
3419 = signed_or_unsigned_type (unsigned_arg
,
3421 /* Convert value-to-be-shifted to that type. */
3422 if (TREE_TYPE (op0
) != result_type
)
3423 op0
= convert (result_type
, op0
);
3428 /* Comparison operations are shortened too but differently.
3429 They identify themselves by setting short_compare = 1. */
3433 /* Don't write &op0, etc., because that would prevent op0
3434 from being kept in a register.
3435 Instead, make copies of the our local variables and
3436 pass the copies by reference, then copy them back afterward. */
3437 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3438 enum tree_code xresultcode
= resultcode
;
3440 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3442 return convert (bool_type_node
, val
);
3443 op0
= xop0
, op1
= xop1
, result_type
= bool_type_node
;
3444 resultcode
= xresultcode
;
3447 if (short_compare
&& extra_warnings
)
3449 int unsignedp0
, unsignedp1
;
3450 tree primop0
= get_narrower (op0
, &unsignedp0
);
3451 tree primop1
= get_narrower (op1
, &unsignedp1
);
3453 /* Warn if signed and unsigned are being compared in a size larger
3454 than their original size, as this will always fail. */
3456 if (unsignedp0
!= unsignedp1
3457 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3458 < TYPE_PRECISION (result_type
))
3459 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3460 < TYPE_PRECISION (result_type
)))
3461 warning ("comparison between promoted unsigned and signed");
3463 /* Warn if two unsigned values are being compared in a size
3464 larger than their original size, and one (and only one) is the
3465 result of a `~' operator. This comparison will always fail.
3467 Also warn if one operand is a constant, and the constant does not
3468 have all bits set that are set in the ~ operand when it is
3471 else if (TREE_CODE (primop0
) == BIT_NOT_EXPR
3472 ^ TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3474 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3475 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3476 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3477 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3479 if (TREE_CODE (primop0
) == INTEGER_CST
3480 || TREE_CODE (primop1
) == INTEGER_CST
)
3483 HOST_WIDE_INT constant
, mask
;
3487 if (TREE_CODE (primop0
) == INTEGER_CST
)
3490 unsignedp
= unsignedp1
;
3491 constant
= TREE_INT_CST_LOW (primop0
);
3496 unsignedp
= unsignedp0
;
3497 constant
= TREE_INT_CST_LOW (primop1
);
3500 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3501 if (bits
< TYPE_PRECISION (result_type
)
3502 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3504 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3505 if ((mask
& constant
) != mask
)
3506 warning ("comparison of promoted ~unsigned with constant");
3509 else if (unsignedp0
&& unsignedp1
3510 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3511 < TYPE_PRECISION (result_type
))
3512 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3513 < TYPE_PRECISION (result_type
)))
3514 warning ("comparison of promoted ~unsigned with unsigned");
3519 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3520 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3521 Then the expression will be built.
3522 It will be given type FINAL_TYPE if that is nonzero;
3523 otherwise, it will be given type RESULT_TYPE. */
3527 binary_op_error (error_code
);
3528 return error_mark_node
;
3533 if (TREE_TYPE (op0
) != result_type
)
3534 op0
= convert (result_type
, op0
);
3535 if (TREE_TYPE (op1
) != result_type
)
3536 op1
= convert (result_type
, op1
);
3540 register tree result
= build (resultcode
, result_type
, op0
, op1
);
3541 register tree folded
;
3543 folded
= fold (result
);
3544 if (folded
== result
)
3545 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3546 if (final_type
!= 0)
3547 return convert (final_type
, folded
);
3552 /* Return a tree for the sum or difference (RESULTCODE says which)
3553 of pointer PTROP and integer INTOP. */
3556 pointer_int_sum (resultcode
, ptrop
, intop
)
3557 enum tree_code resultcode
;
3558 register tree ptrop
, intop
;
3562 register tree result
;
3563 register tree folded
= fold (intop
);
3565 /* The result is a pointer of the same type that is being added. */
3567 register tree result_type
= TREE_TYPE (ptrop
);
3569 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3571 if (pedantic
|| warn_pointer_arith
)
3572 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3573 size_exp
= integer_one_node
;
3575 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3577 if (pedantic
|| warn_pointer_arith
)
3578 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3579 size_exp
= integer_one_node
;
3581 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3583 if (pedantic
|| warn_pointer_arith
)
3584 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
3585 size_exp
= integer_one_node
;
3587 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
3590 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
3591 size_exp
= integer_one_node
;
3594 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3596 /* Needed to make OOPS V2R3 work. */
3598 if (TREE_CODE (intop
) == INTEGER_CST
3599 && TREE_INT_CST_LOW (intop
) == 0
3600 && TREE_INT_CST_HIGH (intop
) == 0)
3603 /* If what we are about to multiply by the size of the elements
3604 contains a constant term, apply distributive law
3605 and multiply that constant term separately.
3606 This helps produce common subexpressions. */
3608 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3609 && ! TREE_CONSTANT (intop
)
3610 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3611 && TREE_CONSTANT (size_exp
))
3613 enum tree_code subcode
= resultcode
;
3614 if (TREE_CODE (intop
) == MINUS_EXPR
)
3615 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3616 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
3617 intop
= TREE_OPERAND (intop
, 0);
3620 /* Convert the integer argument to a type the same size as a pointer
3621 so the multiply won't overflow spuriously. */
3623 if (TYPE_PRECISION (TREE_TYPE (intop
)) != POINTER_SIZE
)
3624 intop
= convert (type_for_size (POINTER_SIZE
, 0), intop
);
3626 /* Replace the integer argument with a suitable product by the object size.
3627 Do this multiplication as signed, then convert to the appropriate
3628 pointer type (actually unsigned integral). */
3630 intop
= convert (result_type
,
3631 build_binary_op (MULT_EXPR
, intop
,
3632 convert (TREE_TYPE (intop
), size_exp
), 1));
3634 /* Create the sum or difference. */
3636 result
= build (resultcode
, result_type
, ptrop
, intop
);
3638 folded
= fold (result
);
3639 if (folded
== result
)
3640 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
3644 /* Return a tree for the difference of pointers OP0 and OP1.
3645 The resulting tree has type int. */
3648 pointer_diff (op0
, op1
)
3649 register tree op0
, op1
;
3651 register tree result
, folded
;
3652 tree restype
= ptrdiff_type_node
;
3653 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3657 if (TREE_CODE (target_type
) == VOID_TYPE
)
3658 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
3659 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3660 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
3661 if (TREE_CODE (target_type
) == METHOD_TYPE
)
3662 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
3663 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
3664 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
3667 /* First do the subtraction as integers;
3668 then drop through to build the divide operator. */
3670 op0
= build_binary_op (MINUS_EXPR
,
3671 convert (restype
, op0
), convert (restype
, op1
), 1);
3673 /* This generates an error if op1 is a pointer to an incomplete type. */
3674 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
3675 error ("arithmetic on pointer to an incomplete type");
3677 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
3678 || TREE_CODE (target_type
) == FUNCTION_TYPE
3679 || TREE_CODE (target_type
) == METHOD_TYPE
3680 || TREE_CODE (target_type
) == OFFSET_TYPE
)
3682 : size_in_bytes (target_type
));
3684 /* Do the division. */
3686 result
= build (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
));
3688 folded
= fold (result
);
3689 if (folded
== result
)
3690 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3694 /* Handle the case of taking the address of a COMPONENT_REF.
3695 Called by `build_unary_op' and `build_up_reference'.
3697 ARG is the COMPONENT_REF whose address we want.
3698 ARGTYPE is the pointer type that this address should have.
3699 MSG is an error message to print if this COMPONENT_REF is not
3700 addressable (such as a bitfield). */
3703 build_component_addr (arg
, argtype
, msg
)
3707 tree field
= TREE_OPERAND (arg
, 1);
3708 tree basetype
= decl_type_context (field
);
3709 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
3711 if (DECL_BIT_FIELD (field
))
3713 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
3714 return error_mark_node
;
3718 cp_warning ("address of `%T::%D' taken", basetype
, field
);
3720 if (TREE_CODE (field
) == FIELD_DECL
3721 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
3723 /* Can't convert directly to ARGTYPE, since that
3724 may have the same pointer type as one of our
3726 rval
= build1 (NOP_EXPR
, argtype
,
3727 convert_pointer_to (basetype
, rval
));
3728 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
3731 /* This conversion is harmless. */
3732 rval
= convert (argtype
, rval
);
3734 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
3736 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
3737 size_int (BITS_PER_UNIT
));
3738 int flag
= TREE_CONSTANT (rval
);
3739 rval
= fold (build (PLUS_EXPR
, argtype
,
3740 rval
, convert (argtype
, offset
)));
3741 TREE_CONSTANT (rval
) = flag
;
3746 /* Construct and perhaps optimize a tree representation
3747 for a unary operation. CODE, a tree_code, specifies the operation
3748 and XARG is the operand. */
3751 build_x_unary_op (code
, xarg
)
3752 enum tree_code code
;
3755 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3757 if (code
!= ADDR_EXPR
|| TREE_CODE (TREE_TYPE (xarg
)) != RECORD_TYPE
3758 || TYPE_SIZE (TREE_TYPE (xarg
)))
3760 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
, xarg
,
3761 NULL_TREE
, NULL_TREE
);
3763 return build_opfncall (code
, LOOKUP_NORMAL
, xarg
,
3764 NULL_TREE
, NULL_TREE
);
3766 return build_unary_op (code
, xarg
, 0);
3769 /* Just like truthvalue_conversion, but we want a BOOLEAN_TYPE */
3771 bool_truthvalue_conversion (expr
)
3774 /* We really want to preform the optimizations in truthvalue_conversion
3775 but, not this way. */
3776 /* expr = truthvalue_conversion (expr); */
3777 return convert (bool_type_node
, expr
);
3780 /* C++: Must handle pointers to members.
3782 Perhaps type instantiation should be extended to handle conversion
3783 from aggregates to types we don't yet know we want? (Or are those
3784 cases typically errors which should be reported?)
3786 NOCONVERT nonzero suppresses the default promotions
3787 (such as from short to int). */
3789 build_unary_op (code
, xarg
, noconvert
)
3790 enum tree_code code
;
3794 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3795 register tree arg
= xarg
;
3796 register tree argtype
= 0;
3797 register enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
3798 char *errstring
= NULL
;
3802 if (typecode
== ERROR_MARK
)
3803 return error_mark_node
;
3805 if (typecode
== REFERENCE_TYPE
&& code
!= ADDR_EXPR
&& ! noconvert
)
3807 arg
= convert_from_reference (arg
);
3808 typecode
= TREE_CODE (TREE_TYPE (arg
));
3811 if (typecode
== ENUMERAL_TYPE
)
3812 typecode
= INTEGER_TYPE
;
3814 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3819 /* This is used for unary plus, because a CONVERT_EXPR
3820 is enough to prevent anybody from looking inside for
3821 associativity, but won't generate any code. */
3822 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3823 errstring
= "wrong type argument to unary plus";
3824 else if (!noconvert
)
3825 arg
= default_conversion (arg
);
3832 arg
= default_conversion (arg
);
3835 cp_error ("type conversion for type `%T' not allowed",
3837 return error_mark_node
;
3839 typecode
= TREE_CODE (TREE_TYPE (arg
));
3843 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3844 errstring
= "wrong type argument to unary minus";
3845 else if (!noconvert
)
3846 arg
= default_conversion (arg
);
3853 arg
= default_conversion (arg
);
3856 cp_error ("type conversion for type `%T' not allowed",
3858 return error_mark_node
;
3860 typecode
= TREE_CODE (TREE_TYPE (arg
));
3864 if (typecode
!= INTEGER_TYPE
)
3865 errstring
= "wrong type argument to bit-complement";
3866 else if (!noconvert
)
3867 arg
= default_conversion (arg
);
3874 arg
= default_conversion (arg
);
3877 cp_error ("type conversion for type `%T' not allowed",
3879 return error_mark_node
;
3881 typecode
= TREE_CODE (TREE_TYPE (arg
));
3885 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3886 errstring
= "wrong type argument to abs";
3887 else if (!noconvert
)
3888 arg
= default_conversion (arg
);
3891 case TRUTH_NOT_EXPR
:
3892 arg
= bool_truthvalue_conversion (arg
);
3893 val
= invert_truthvalue (arg
);
3894 if (arg
!= error_mark_node
)
3896 errstring
= "in argument to unary !";
3902 case PREINCREMENT_EXPR
:
3903 case POSTINCREMENT_EXPR
:
3904 case PREDECREMENT_EXPR
:
3905 case POSTDECREMENT_EXPR
:
3906 /* Handle complex lvalues (when permitted)
3907 by reduction to simpler cases. */
3909 val
= unary_complex_lvalue (code
, arg
);
3913 /* Report invalid types. */
3917 arg
= default_conversion (arg
);
3918 typecode
= TREE_CODE (TREE_TYPE (arg
));
3921 if (typecode
!= POINTER_TYPE
3922 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
3924 if (code
== PREINCREMENT_EXPR
)
3925 errstring
="no pre-increment operator for type";
3926 else if (code
== POSTINCREMENT_EXPR
)
3927 errstring
="no post-increment operator for type";
3928 else if (code
== PREDECREMENT_EXPR
)
3929 errstring
="no pre-decrement operator for type";
3931 errstring
="no post-decrement operator for type";
3935 /* Report something read-only. */
3937 if (TYPE_READONLY (TREE_TYPE (arg
))
3938 || TREE_READONLY (arg
))
3939 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
3940 || code
== POSTINCREMENT_EXPR
)
3941 ? "increment" : "decrement"),
3946 tree result_type
= TREE_TYPE (arg
);
3948 arg
= get_unwidened (arg
, 0);
3949 argtype
= TREE_TYPE (arg
);
3951 /* ARM $5.2.5 last annotation says this should be forbidden. */
3952 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
3953 pedwarn ("ANSI C++ forbids %sing an enum",
3954 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3955 ? "increment" : "decrement");
3957 /* Compute the increment. */
3959 if (typecode
== POINTER_TYPE
)
3961 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
3962 if (TYPE_SIZE (TREE_TYPE (argtype
)) == 0)
3963 cp_error ("cannot %s a pointer to incomplete type `%T'",
3964 ((code
== PREINCREMENT_EXPR
3965 || code
== POSTINCREMENT_EXPR
)
3966 ? "increment" : "decrement"), TREE_TYPE (argtype
));
3967 else if (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
3968 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
)
3969 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
3970 ((code
== PREINCREMENT_EXPR
3971 || code
== POSTINCREMENT_EXPR
)
3972 ? "increment" : "decrement"), argtype
);
3973 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
3976 inc
= integer_one_node
;
3978 inc
= convert (argtype
, inc
);
3980 /* Handle incrementing a cast-expression. */
3982 switch (TREE_CODE (arg
))
3987 case FIX_TRUNC_EXPR
:
3988 case FIX_FLOOR_EXPR
:
3989 case FIX_ROUND_EXPR
:
3992 tree incremented
, modify
, value
;
3993 if (! lvalue_p (arg
) && pedantic
)
3994 pedwarn ("cast to non-reference type used as lvalue");
3995 arg
= stabilize_reference (arg
);
3996 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
3999 value
= save_expr (arg
);
4000 incremented
= build (((code
== PREINCREMENT_EXPR
4001 || code
== POSTINCREMENT_EXPR
)
4002 ? PLUS_EXPR
: MINUS_EXPR
),
4003 argtype
, value
, inc
);
4004 TREE_SIDE_EFFECTS (incremented
) = 1;
4005 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4006 return build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4010 if (TREE_CODE (arg
) == OFFSET_REF
)
4011 arg
= resolve_offset_ref (arg
);
4013 /* Complain about anything else that is not a true lvalue. */
4014 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4015 || code
== POSTINCREMENT_EXPR
)
4016 ? "increment" : "decrement")))
4017 return error_mark_node
;
4019 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4020 TREE_SIDE_EFFECTS (val
) = 1;
4021 return convert (result_type
, val
);
4025 /* Note that this operation never does default_conversion
4026 regardless of NOCONVERT. */
4028 if (typecode
== REFERENCE_TYPE
)
4030 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4031 TREE_REFERENCE_EXPR (arg
) = 1;
4035 && TREE_CODE (arg
) == FUNCTION_DECL
4037 && DECL_CONTEXT (arg
) == NULL_TREE
4038 && IDENTIFIER_LENGTH (DECL_NAME (arg
)) == 4
4039 && IDENTIFIER_POINTER (DECL_NAME (arg
))[0] == 'm'
4040 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg
)), "main"))
4042 pedwarn ("taking address of function `main'");
4044 /* Let &* cancel out to simplify resulting code. */
4045 if (TREE_CODE (arg
) == INDIRECT_REF
)
4047 /* We don't need to have `current_class_decl' wrapped in a
4048 NON_LVALUE_EXPR node. */
4050 return current_class_decl
;
4052 /* Keep `default_conversion' from converting if
4053 ARG is of REFERENCE_TYPE. */
4054 arg
= TREE_OPERAND (arg
, 0);
4055 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4057 if (TREE_CODE (arg
) == VAR_DECL
&& DECL_INITIAL (arg
)
4058 && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg
)))
4059 arg
= DECL_INITIAL (arg
);
4060 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4061 TREE_REFERENCE_EXPR (arg
) = 1;
4062 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4064 else if (lvalue_p (arg
))
4065 /* Don't let this be an lvalue. */
4066 return non_lvalue (arg
);
4070 /* For &x[y], return x+y */
4071 if (TREE_CODE (arg
) == ARRAY_REF
)
4073 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4074 return error_mark_node
;
4075 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4076 TREE_OPERAND (arg
, 1), 1);
4079 /* For &(++foo), we are really taking the address of the variable
4080 being acted upon by the increment/decrement operator. ARM $5.3.1
4081 However, according to ARM $5.2.5, we don't allow postfix ++ and
4082 --, since the prefix operators return lvalues, but the postfix
4083 operators do not. */
4084 if (TREE_CODE (arg
) == PREINCREMENT_EXPR
4085 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4086 arg
= TREE_OPERAND (arg
, 0);
4088 /* Uninstantiated types are all functions. Taking the
4089 address of a function is a no-op, so just return the
4092 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4093 && IDENTIFIER_OPNAME_P (arg
))
4095 my_friendly_abort (117);
4096 /* We don't know the type yet, so just work around the problem.
4097 We know that this will resolve to an lvalue. */
4098 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4101 if (TREE_CODE (arg
) == TREE_LIST
)
4103 /* Look at methods with only this name. */
4104 if (TREE_CODE (TREE_VALUE (arg
)) == FUNCTION_DECL
)
4106 tree targ
= TREE_VALUE (arg
);
4108 /* If this function is unique, or it is a unique
4109 constructor, we can take its address easily. */
4110 if (DECL_CHAIN (targ
) == NULL_TREE
4111 || (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (targ
))
4112 && DECL_CHAIN (DECL_CHAIN (targ
)) == NULL_TREE
))
4114 if (DECL_CHAIN (targ
))
4115 targ
= DECL_CHAIN (targ
);
4116 if (DECL_CLASS_CONTEXT (targ
))
4117 targ
= build (OFFSET_REF
, TREE_TYPE (targ
), C_C_D
, targ
);
4119 val
= unary_complex_lvalue (ADDR_EXPR
, targ
);
4124 /* This possible setting of TREE_CONSTANT is what makes it possible
4125 with an initializer list to emit the entire thing in the data
4126 section, rather than a run-time initialization. */
4127 arg
= build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4129 TREE_CONSTANT (arg
) = 1;
4132 if (TREE_CHAIN (arg
) == NULL_TREE
4133 && TREE_CODE (TREE_VALUE (arg
)) == TREE_LIST
4134 && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg
))) == NULL_TREE
)
4136 /* Unique overloaded member function. */
4137 return build_unary_op (ADDR_EXPR
, TREE_VALUE (TREE_VALUE (arg
)), 0);
4139 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4142 /* Handle complex lvalues (when permitted)
4143 by reduction to simpler cases. */
4144 val
= unary_complex_lvalue (code
, arg
);
4148 switch (TREE_CODE (arg
))
4153 case FIX_TRUNC_EXPR
:
4154 case FIX_FLOOR_EXPR
:
4155 case FIX_ROUND_EXPR
:
4157 if (! lvalue_p (arg
) && pedantic
)
4158 pedwarn ("taking the address of a cast to non-reference type");
4161 /* Allow the address of a constructor if all the elements
4163 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_CONSTANT (arg
))
4165 /* Anything not already handled and not a true memory reference
4167 else if (typecode
!= FUNCTION_TYPE
4168 && typecode
!= METHOD_TYPE
4169 && !lvalue_or_else (arg
, "unary `&'"))
4170 return error_mark_node
;
4172 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4173 argtype
= TREE_TYPE (arg
);
4174 /* If the lvalue is const or volatile,
4175 merge that into the type that the address will point to. */
4176 if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'd'
4177 || TREE_CODE_CLASS (TREE_CODE (arg
)) == 'r')
4179 if (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4180 argtype
= c_build_type_variant (argtype
,
4181 TREE_READONLY (arg
),
4182 TREE_THIS_VOLATILE (arg
));
4185 argtype
= build_pointer_type (argtype
);
4187 if (mark_addressable (arg
) == 0)
4188 return error_mark_node
;
4193 if (TREE_CODE (arg
) == COMPONENT_REF
)
4194 addr
= build_component_addr (arg
, argtype
,
4195 "attempt to take address of bit-field structure member `%s'");
4197 addr
= build1 (code
, argtype
, arg
);
4199 /* Address of a static or external variable or
4200 function counts as a constant */
4202 TREE_CONSTANT (addr
) = 1;
4210 argtype
= TREE_TYPE (arg
);
4211 return fold (build1 (code
, argtype
, arg
));
4215 return error_mark_node
;
4218 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4219 convert ARG with the same conversions in the same order
4220 and return the result. */
4223 convert_sequence (conversions
, arg
)
4227 switch (TREE_CODE (conversions
))
4232 case FIX_TRUNC_EXPR
:
4233 case FIX_FLOOR_EXPR
:
4234 case FIX_ROUND_EXPR
:
4236 return convert (TREE_TYPE (conversions
),
4237 convert_sequence (TREE_OPERAND (conversions
, 0),
4245 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4246 for certain kinds of expressions which are not really lvalues
4247 but which we can accept as lvalues.
4249 If ARG is not a kind of expression we can handle, return zero. */
4252 unary_complex_lvalue (code
, arg
)
4253 enum tree_code code
;
4256 /* Handle (a, b) used as an "lvalue". */
4257 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4259 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4260 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4261 TREE_OPERAND (arg
, 0), real_result
);
4264 /* Handle (a ? b : c) used as an "lvalue". */
4265 if (TREE_CODE (arg
) == COND_EXPR
)
4266 return rationalize_conditional_expr (code
, arg
);
4268 if (TREE_CODE (arg
) == MODIFY_EXPR
)
4269 return unary_complex_lvalue
4270 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4271 arg
, TREE_OPERAND (arg
, 0)));
4273 if (code
!= ADDR_EXPR
)
4276 /* Handle (a = b) used as an "lvalue" for `&'. */
4277 if (TREE_CODE (arg
) == MODIFY_EXPR
4278 || TREE_CODE (arg
) == INIT_EXPR
)
4280 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4281 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4284 if (TREE_CODE (arg
) == WITH_CLEANUP_EXPR
)
4286 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4287 real_result
= build (WITH_CLEANUP_EXPR
, TREE_TYPE (real_result
),
4288 real_result
, 0, TREE_OPERAND (arg
, 2));
4292 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4293 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4294 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4296 /* The representation of something of type OFFSET_TYPE
4297 is really the representation of a pointer to it.
4298 Here give the representation its true type. */
4302 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4304 if (TREE_CODE (arg
) != OFFSET_REF
)
4307 t
= TREE_OPERAND (arg
, 1);
4309 if (TREE_CODE (t
) == FUNCTION_DECL
) /* Check all this code for right semantics. */
4310 return build_unary_op (ADDR_EXPR
, t
, 0);
4311 if (TREE_CODE (t
) == VAR_DECL
)
4312 return build_unary_op (ADDR_EXPR
, t
, 0);
4315 /* Can't build a pointer to member if the member must
4316 go through virtual base classes. */
4317 if (virtual_member (DECL_FIELD_CONTEXT (t
),
4318 CLASSTYPE_VBASECLASSES (TREE_TYPE (TREE_OPERAND (arg
, 0)))))
4320 sorry ("pointer to member via virtual baseclass");
4321 return error_mark_node
;
4324 if (TREE_OPERAND (arg
, 0)
4325 && (TREE_CODE (TREE_OPERAND (arg
, 0)) != NOP_EXPR
4326 || TREE_OPERAND (TREE_OPERAND (arg
, 0), 0) != error_mark_node
))
4328 /* Don't know if this should return address to just
4329 _DECL, or actual address resolved in this expression. */
4330 sorry ("address of bound pointer-to-member expression");
4331 return error_mark_node
;
4334 return convert (build_pointer_type (TREE_TYPE (arg
)),
4335 size_binop (EASY_DIV_EXPR
,
4336 DECL_FIELD_BITPOS (t
),
4337 size_int (BITS_PER_UNIT
)));
4341 if (TREE_CODE (arg
) == OFFSET_REF
)
4343 tree left
= TREE_OPERAND (arg
, 0), left_addr
;
4344 tree right_addr
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 1), 0);
4347 if (current_class_decl
)
4348 left_addr
= current_class_decl
;
4351 error ("no `this' for pointer to member");
4352 return error_mark_node
;
4355 left_addr
= build_unary_op (ADDR_EXPR
, left
, 0);
4357 return build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4358 build1 (NOP_EXPR
, integer_type_node
, left_addr
),
4359 build1 (NOP_EXPR
, integer_type_node
, right_addr
));
4362 /* We permit compiler to make function calls returning
4363 objects of aggregate type look like lvalues. */
4367 if (TREE_CODE (targ
) == SAVE_EXPR
)
4368 targ
= TREE_OPERAND (targ
, 0);
4370 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4372 if (TREE_CODE (arg
) == SAVE_EXPR
)
4375 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, 1);
4376 return build1 (ADDR_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)), targ
);
4379 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4380 return build (SAVE_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)),
4381 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4383 /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
4384 we do, here's how to handle it. */
4385 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == WITH_CLEANUP_EXPR
)
4388 /* Not really a bug, but something to turn on when testing. */
4389 compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
4391 return unary_complex_lvalue (ADDR_EXPR
, targ
);
4395 /* Don't let anything else be handled specially. */
4399 /* Mark EXP saying that we need to be able to take the
4400 address of it; it should not be allocated in a register.
4401 Value is 1 if successful.
4403 C++: we do not allow `current_class_decl' to be addressable. */
4406 mark_addressable (exp
)
4409 register tree x
= exp
;
4411 if (TREE_ADDRESSABLE (x
) == 1)
4415 switch (TREE_CODE (x
))
4420 x
= TREE_OPERAND (x
, 0);
4424 if (x
== current_class_decl
)
4426 error ("address of `this' not available");
4427 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4428 put_var_into_stack (x
);
4433 && TREE_READONLY (x
)
4434 && DECL_RTL (x
) != 0
4435 && ! decl_in_memory_p (x
))
4437 /* We thought this would make a good constant variable,
4438 but we were wrong. */
4439 push_obstacks_nochange ();
4440 end_temporary_allocation ();
4442 TREE_ASM_WRITTEN (x
) = 0;
4444 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0, 0);
4445 TREE_ADDRESSABLE (x
) = 1;
4451 /* Caller should not be trying to mark initialized
4452 constant fields addressable. */
4453 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4454 || DECL_IN_AGGR_P (x
) == 0
4456 || DECL_EXTERNAL (x
), 314);
4460 /* For C++, we don't warn about taking the address of a register
4461 variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
4462 put_var_into_stack (x
);
4463 TREE_ADDRESSABLE (x
) = 1;
4467 /* We have to test both conditions here. The first may
4468 be non-zero in the case of processing a default function.
4469 The second may be non-zero in the case of a template function. */
4470 x
= DECL_MAIN_VARIANT (x
);
4471 if ((DECL_INLINE (x
) || DECL_PENDING_INLINE_INFO (x
))
4472 && (DECL_CONTEXT (x
) == NULL_TREE
4473 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x
))) != 't'
4474 || ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x
))))
4476 mark_inline_for_output (x
);
4477 if (x
== current_function_decl
)
4478 DECL_EXTERNAL (x
) = 0;
4480 TREE_ADDRESSABLE (x
) = 1;
4482 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4490 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4493 build_x_conditional_expr (ifexp
, op1
, op2
)
4494 tree ifexp
, op1
, op2
;
4496 tree rval
= NULL_TREE
;
4498 /* See comments in `build_x_binary_op'. */
4500 rval
= build_opfncall (COND_EXPR
, LOOKUP_SPECULATIVELY
, ifexp
, op1
, op2
);
4502 return build_opfncall (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4504 return build_conditional_expr (ifexp
, op1
, op2
);
4508 build_conditional_expr (ifexp
, op1
, op2
)
4509 tree ifexp
, op1
, op2
;
4511 register tree type1
;
4512 register tree type2
;
4513 register enum tree_code code1
;
4514 register enum tree_code code2
;
4515 register tree result_type
= NULL_TREE
;
4516 tree orig_op1
= op1
, orig_op2
= op2
;
4518 /* If second operand is omitted, it is the same as the first one;
4519 make sure it is calculated only once. */
4523 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4524 ifexp
= op1
= save_expr (ifexp
);
4527 ifexp
= bool_truthvalue_conversion (default_conversion (ifexp
));
4529 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4530 return error_mark_node
;
4532 op1
= require_instantiated_type (TREE_TYPE (op2
), op1
, error_mark_node
);
4533 if (op1
== error_mark_node
)
4534 return error_mark_node
;
4535 op2
= require_instantiated_type (TREE_TYPE (op1
), op2
, error_mark_node
);
4536 if (op2
== error_mark_node
)
4537 return error_mark_node
;
4539 /* C++: REFERENCE_TYPES must be dereferenced. */
4540 type1
= TREE_TYPE (op1
);
4541 code1
= TREE_CODE (type1
);
4542 type2
= TREE_TYPE (op2
);
4543 code2
= TREE_CODE (type2
);
4545 if (code1
== REFERENCE_TYPE
)
4547 op1
= convert_from_reference (op1
);
4548 type1
= TREE_TYPE (op1
);
4549 code1
= TREE_CODE (type1
);
4551 if (code2
== REFERENCE_TYPE
)
4553 op2
= convert_from_reference (op2
);
4554 type2
= TREE_TYPE (op2
);
4555 code2
= TREE_CODE (type2
);
4558 #if 1 /* Produces wrong result if within sizeof. Sorry. */
4559 /* Don't promote the operands separately if they promote
4560 the same way. Return the unpromoted type and let the combined
4561 value get promoted if necessary. */
4563 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4564 && code2
!= ARRAY_TYPE
4566 /* For C++, let the enumeral type come through. */
4567 && code2
!= ENUMERAL_TYPE
4569 && code2
!= FUNCTION_TYPE
4570 && code2
!= METHOD_TYPE
)
4574 if (TREE_CONSTANT (ifexp
)
4575 && (TREE_CODE (ifexp
) == INTEGER_CST
4576 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4577 return (integer_zerop (ifexp
) ? op2
: op1
);
4579 if (TREE_CODE (op1
) == CONST_DECL
)
4580 op1
= DECL_INITIAL (op1
);
4581 else if (TREE_READONLY_DECL_P (op1
))
4582 op1
= decl_constant_value (op1
);
4583 if (TREE_CODE (op2
) == CONST_DECL
)
4584 op2
= DECL_INITIAL (op2
);
4585 else if (TREE_READONLY_DECL_P (op2
))
4586 op2
= decl_constant_value (op2
);
4588 type1
= c_build_type_variant
4590 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4591 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4592 /* ??? This is a kludge to deal with the fact that
4593 we don't sort out integers and enums properly, yet. */
4594 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4595 if (TREE_TYPE (result
) != type1
)
4596 result
= build1 (NOP_EXPR
, type1
, result
);
4601 /* They don't match; promote them both and then try to reconcile them.
4602 But don't permit mismatching enum types. */
4603 if (code1
== ENUMERAL_TYPE
)
4605 if (code2
== ENUMERAL_TYPE
)
4607 message_2_types (error
, "enumeral mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4608 return error_mark_node
;
4610 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
))
4611 warning ("enumeral and non-enumeral type in conditional expression");
4613 else if (extra_warnings
4614 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
))
4615 warning ("enumeral and non-enumeral type in conditional expression");
4617 if (code1
!= VOID_TYPE
)
4619 op1
= default_conversion (op1
);
4620 type1
= TREE_TYPE (op1
);
4621 code1
= TREE_CODE (type1
);
4623 if (code2
!= VOID_TYPE
)
4625 op2
= default_conversion (op2
);
4626 type2
= TREE_TYPE (op2
);
4627 code2
= TREE_CODE (type2
);
4630 /* Quickly detect the usual case where op1 and op2 have the same type
4632 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4635 result_type
= type1
;
4637 result_type
= c_build_type_variant
4639 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4640 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4642 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
4643 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
4645 result_type
= common_type (type1
, type2
);
4647 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4649 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
4650 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
4651 result_type
= void_type_node
;
4653 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4655 if (comp_target_types (type1
, type2
, 1))
4656 result_type
= common_type (type1
, type2
);
4657 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
4658 && TREE_CODE (orig_op1
) != NOP_EXPR
)
4659 result_type
= qualify_type (type2
, type1
);
4660 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
4661 && TREE_CODE (orig_op2
) != NOP_EXPR
)
4662 result_type
= qualify_type (type1
, type2
);
4663 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
4665 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4666 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4667 result_type
= qualify_type (type1
, type2
);
4669 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
4671 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4672 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4673 result_type
= qualify_type (type2
, type1
);
4676 else if (comptypes (type2
, type1
, 0))
4677 result_type
= type2
;
4678 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
4679 && IS_AGGR_TYPE (TREE_TYPE (type2
))
4680 && (result_type
= common_base_type (TREE_TYPE (type1
), TREE_TYPE (type2
))))
4682 if (result_type
== error_mark_node
)
4684 message_2_types (error
, "common base type of types `%s' and `%s' is ambiguous",
4685 TREE_TYPE (type1
), TREE_TYPE (type2
));
4686 result_type
= ptr_type_node
;
4688 else result_type
= TYPE_POINTER_TO (result_type
);
4692 pedwarn ("pointer type mismatch in conditional expression");
4693 result_type
= ptr_type_node
;
4696 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4698 if (!integer_zerop (op2
))
4699 pedwarn ("pointer/integer type mismatch in conditional expression");
4702 op2
= null_pointer_node
;
4703 #if 0 /* Sez who? */
4704 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4705 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4708 result_type
= type1
;
4710 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4712 if (!integer_zerop (op1
))
4713 pedwarn ("pointer/integer type mismatch in conditional expression");
4716 op1
= null_pointer_node
;
4717 #if 0 /* Sez who? */
4718 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4719 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4722 result_type
= type2
;
4727 /* The match does not look good. If either is
4728 an aggregate value, try converting to a scalar type. */
4729 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
4731 message_2_types (error
, "aggregate mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4732 return error_mark_node
;
4734 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
4736 tree tmp
= build_type_conversion (CONVERT_EXPR
, type2
, op1
, 0);
4737 if (tmp
== NULL_TREE
)
4739 cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1
);
4740 return error_mark_node
;
4742 if (tmp
== error_mark_node
)
4743 error ("ambiguous pointer conversion");
4744 result_type
= type2
;
4747 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
4749 tree tmp
= build_type_conversion (CONVERT_EXPR
, type1
, op2
, 0);
4750 if (tmp
== NULL_TREE
)
4752 cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2
);
4753 return error_mark_node
;
4755 if (tmp
== error_mark_node
)
4756 error ("ambiguous pointer conversion");
4757 result_type
= type1
;
4760 else if (flag_cond_mismatch
)
4761 result_type
= void_type_node
;
4764 error ("type mismatch in conditional expression");
4765 return error_mark_node
;
4769 if (result_type
!= TREE_TYPE (op1
))
4770 op1
= convert_and_check (result_type
, op1
);
4771 if (result_type
!= TREE_TYPE (op2
))
4772 op2
= convert_and_check (result_type
, op2
);
4775 /* XXX delete me, I've been here for years. */
4776 if (IS_AGGR_TYPE_CODE (code1
))
4778 result_type
= TREE_TYPE (op1
);
4779 if (TREE_CONSTANT (ifexp
))
4780 return (integer_zerop (ifexp
) ? op2
: op1
);
4782 if (TYPE_MODE (result_type
) == BLKmode
)
4784 register tree tempvar
4785 = build_decl (VAR_DECL
, NULL_TREE
, result_type
);
4786 register tree xop1
= build_modify_expr (tempvar
, NOP_EXPR
, op1
);
4787 register tree xop2
= build_modify_expr (tempvar
, NOP_EXPR
, op2
);
4788 register tree result
= fold (build (COND_EXPR
, result_type
,
4789 ifexp
, xop1
, xop2
));
4791 layout_decl (tempvar
, 0);
4792 /* No way to handle variable-sized objects here.
4793 I fear that the entire handling of BLKmode conditional exprs
4794 needs to be redone. */
4795 my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar
)), 315);
4797 = assign_stack_local (DECL_MODE (tempvar
),
4798 (TREE_INT_CST_LOW (DECL_SIZE (tempvar
))
4799 + BITS_PER_UNIT
- 1)
4803 TREE_SIDE_EFFECTS (result
)
4804 = TREE_SIDE_EFFECTS (ifexp
) | TREE_SIDE_EFFECTS (op1
)
4805 | TREE_SIDE_EFFECTS (op2
);
4806 return build (COMPOUND_EXPR
, result_type
, result
, tempvar
);
4811 if (TREE_CONSTANT (ifexp
))
4812 return integer_zerop (ifexp
) ? op2
: op1
;
4814 return fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
4817 /* Handle overloading of the ',' operator when needed. Otherwise,
4818 this function just builds an expression list. */
4820 build_x_compound_expr (list
)
4823 tree rest
= TREE_CHAIN (list
);
4826 if (rest
== NULL_TREE
)
4827 return build_compound_expr (list
);
4829 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
4830 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
4832 return build_x_compound_expr (tree_cons (NULL_TREE
, result
, TREE_CHAIN (rest
)));
4833 return build_compound_expr (tree_cons (NULL_TREE
, TREE_VALUE (list
),
4834 build_tree_list (NULL_TREE
, build_x_compound_expr (rest
))));
4837 /* Given a list of expressions, return a compound expression
4838 that performs them all and returns the value of the last of them. */
4841 build_compound_expr (list
)
4846 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
4847 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
4849 if (TREE_CHAIN (list
) == 0)
4851 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4852 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4853 if (TREE_CODE (list
) == NOP_EXPR
4854 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
4855 list
= TREE_OPERAND (list
, 0);
4857 /* Convert arrays to pointers. */
4858 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
4859 return default_conversion (TREE_VALUE (list
));
4861 return TREE_VALUE (list
);
4864 rest
= build_compound_expr (TREE_CHAIN (list
));
4866 /* When pedantic, a compound expression can be neither an lvalue
4867 nor an integer constant expression. */
4868 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
4871 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
4872 break_out_cleanups (TREE_VALUE (list
)), rest
);
4875 tree
build_static_cast (type
, expr
)
4878 return build_c_cast (type
, expr
);
4881 tree
build_reinterpret_cast (type
, expr
)
4884 return build_c_cast (type
, expr
);
4887 tree
build_const_cast (type
, expr
)
4890 return build_c_cast (type
, expr
);
4893 /* Build an expression representing a cast to type TYPE of expression EXPR. */
4896 build_c_cast (type
, expr
)
4900 register tree value
= expr
;
4902 if (type
== error_mark_node
|| expr
== error_mark_node
)
4903 return error_mark_node
;
4905 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4906 Strip such NOP_EXPRs, since VALUE is being used in non-lvalue context. */
4907 if (TREE_CODE (value
) == NOP_EXPR
4908 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
4909 value
= TREE_OPERAND (value
, 0);
4911 if (TREE_TYPE (expr
)
4912 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
4913 && TREE_CODE (type
) != OFFSET_TYPE
)
4914 value
= resolve_offset_ref (value
);
4916 if (TREE_CODE (type
) == ARRAY_TYPE
)
4918 /* Allow casting from T1* to T2[] because Cfront allows it.
4919 NIHCL uses it. It is not valid ANSI C however, and hence, not
4921 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
4924 pedwarn ("ANSI C++ forbids casting to an array type");
4925 type
= build_pointer_type (TREE_TYPE (type
));
4929 error ("ANSI C++ forbids casting to an array type");
4930 return error_mark_node
;
4934 if (TREE_CODE (type
) == FUNCTION_TYPE
4935 || TREE_CODE (type
) == METHOD_TYPE
)
4937 cp_error ("casting to function type `%T'", type
);
4938 return error_mark_node
;
4941 if (IS_SIGNATURE (type
))
4943 error ("cast specifies signature type");
4944 return error_mark_node
;
4947 /* If there's only one function in the overloaded space,
4949 if (TREE_CODE (value
) == TREE_LIST
4950 && TREE_CHAIN (value
) == NULL_TREE
)
4951 value
= TREE_VALUE (value
);
4953 if (TREE_CODE (type
) == VOID_TYPE
)
4954 value
= build1 (NOP_EXPR
, type
, value
);
4955 else if (TREE_TYPE (value
) == NULL_TREE
4956 || type_unknown_p (value
))
4958 value
= instantiate_type (type
, value
, 1);
4960 if (value
== error_mark_node
)
4961 return error_mark_node
;
4967 /* Convert functions and arrays to pointers and
4968 convert references to their expanded types,
4969 but don't convert any other types. */
4970 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
4971 || TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
4972 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
4973 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
4974 value
= default_conversion (value
);
4975 otype
= TREE_TYPE (value
);
4977 /* Optionally warn about potentially worrisome casts. */
4980 && TREE_CODE (type
) == POINTER_TYPE
4981 && TREE_CODE (otype
) == POINTER_TYPE
)
4983 /* For C++ we make these regular warnings, rather than
4984 softening them into pedwarns. */
4985 if (TYPE_VOLATILE (TREE_TYPE (otype
))
4986 && ! TYPE_VOLATILE (TREE_TYPE (type
)))
4987 warning ("cast discards `volatile' from pointer target type");
4988 if (TYPE_READONLY (TREE_TYPE (otype
))
4989 && ! TYPE_READONLY (TREE_TYPE (type
)))
4990 warning ("cast discards `const' from pointer target type");
4993 /* Warn about possible alignment problems. */
4994 if (STRICT_ALIGNMENT
&& warn_cast_align
4995 && TREE_CODE (type
) == POINTER_TYPE
4996 && TREE_CODE (otype
) == POINTER_TYPE
4997 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
4998 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4999 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5000 warning ("cast increases required alignment of target type");
5003 if (TREE_CODE (type
) == INTEGER_TYPE
5004 && TREE_CODE (otype
) == POINTER_TYPE
5005 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5006 warning ("cast from pointer to integer of different size");
5008 if (TREE_CODE (type
) == POINTER_TYPE
5009 && TREE_CODE (otype
) == INTEGER_TYPE
5010 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5011 /* Don't warn about converting 0 to pointer,
5012 provided the 0 was explicit--not cast or made by folding. */
5013 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5014 warning ("cast to pointer from integer of different size");
5018 value
= convert_force (type
, value
);
5020 /* Ignore any integer overflow caused by the cast. */
5021 if (TREE_CODE (value
) == INTEGER_CST
)
5023 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5024 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5028 /* Always produce some operator for an explicit cast,
5029 so we can tell (for -pedantic) that the cast is no lvalue.
5030 Also, pedantically, don't let (void *) (FOO *) 0 be a null
5031 pointer constant. */
5034 && TREE_CODE (value
) == INTEGER_CST
5035 && TREE_CODE (expr
) == INTEGER_CST
5036 && TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
))
5038 tree nvalue
= build1 (NOP_EXPR
, type
, value
);
5039 TREE_CONSTANT (nvalue
) = TREE_CONSTANT (value
);
5047 /* Build an assignment expression of lvalue LHS from value RHS.
5049 In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
5050 that reference becomes deferenced down to it base type. */
5052 /* Return a reference to the BASE_INDEX part of EXPR. TYPE is
5053 the type to which BASE_INDEX applies. */
5055 get_base_ref (type
, base_index
, expr
)
5060 tree binfos
= TYPE_BINFO_BASETYPES (type
);
5061 tree base_binfo
= TREE_VEC_ELT (binfos
, base_index
);
5064 if (TREE_CODE (expr
) == ARRAY_REF
5065 || ! BINFO_OFFSET_ZEROP (base_binfo
)
5066 || TREE_VIA_VIRTUAL (base_binfo
)
5067 || TYPE_MODE (type
) != TYPE_MODE (BINFO_TYPE (base_binfo
)))
5069 tree addr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5070 ref
= build_indirect_ref (convert_pointer_to (base_binfo
, addr
),
5075 ref
= copy_node (expr
);
5076 TREE_TYPE (ref
) = BINFO_TYPE (base_binfo
);
5081 /* Build an assignment expression of lvalue LHS from value RHS.
5082 MODIFYCODE is the code for a binary operator that we use
5083 to combine the old value of LHS with RHS to get the new value.
5084 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5086 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5088 `build_modify_expr_1' implements recursive part of memberwise
5089 assignment operation. */
5091 build_modify_expr_1 (lhs
, modifycode
, rhs
, basetype_path
)
5093 enum tree_code modifycode
;
5096 register tree result
;
5098 tree lhstype
= TREE_TYPE (lhs
);
5099 tree olhstype
= lhstype
;
5101 /* Avoid duplicate error messages from operands that had errors. */
5102 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5103 return error_mark_node
;
5105 /* If a binary op has been requested, combine the old LHS value with the RHS
5106 producing the value we should actually store into the LHS. */
5108 if (modifycode
== INIT_EXPR
)
5110 else if (modifycode
== NOP_EXPR
)
5112 /* must deal with overloading of `operator=' here. */
5113 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5114 lhstype
= TREE_TYPE (lhstype
);
5120 lhs
= stabilize_reference (lhs
);
5121 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5122 modifycode
= NOP_EXPR
;
5125 /* If storing into a structure or union member,
5126 it has probably been given type `int'.
5127 Compute the type that would go with
5128 the actual amount of storage the member occupies. */
5130 if (TREE_CODE (lhs
) == COMPONENT_REF
5131 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5132 || TREE_CODE (lhstype
) == REAL_TYPE
5133 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5134 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5136 /* C++: The semantics of C++ differ from those of C when an
5137 assignment of an aggregate is desired. Assignment in C++ is
5138 now defined as memberwise assignment of non-static members
5139 and base class objects. This rule applies recursively
5140 until a member of a built-in type is found.
5142 Also, we cannot do a bit-wise copy of aggregates which
5143 contain virtual function table pointers. Those
5144 pointer values must be preserved through the copy.
5145 However, this is handled in expand_expr, and not here.
5146 This is because much better code can be generated at
5147 that stage than this one. */
5148 if (TREE_CODE (lhstype
) == RECORD_TYPE
5149 && TYPE_LANG_SPECIFIC (lhstype
)
5150 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5155 /* Perform operation on object. */
5156 if (modifycode
== INIT_EXPR
&& TYPE_HAS_INIT_REF (lhstype
))
5158 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5159 build_tree_list (NULL_TREE
, rhs
),
5160 basetype_path
, LOOKUP_NORMAL
);
5161 return build_indirect_ref (result
, NULL_PTR
);
5163 else if (modifycode
== NOP_EXPR
)
5165 /* `operator=' is not an inheritable operator; see 13.4.3. */
5166 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5168 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5169 lhs
, rhs
, make_node (NOP_EXPR
));
5170 if (result
== NULL_TREE
)
5171 return error_mark_node
;
5176 if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype
)
5177 || (modifycode
== NOP_EXPR
&& TYPE_GETS_ASSIGNMENT (lhstype
))
5178 || (modifycode
== INIT_EXPR
&& TYPE_GETS_INIT_REF (lhstype
)))
5180 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (lhstype
));
5183 if (binfos
!= NULL_TREE
)
5184 /* Perform operation on each member, depth-first, left-right. */
5185 for (i
= 0; i
<= TREE_VEC_LENGTH (binfos
)-1; i
++)
5187 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
5188 tree base_lhs
, base_rhs
;
5191 /* Assignments from virtual baseclasses handled elsewhere. */
5192 if (TREE_VIA_VIRTUAL (base_binfo
))
5195 base_lhs
= get_base_ref (lhstype
, i
, lhs
);
5196 base_rhs
= get_base_ref (lhstype
, i
, newrhs
);
5198 BINFO_INHERITANCE_CHAIN (base_binfo
) = basetype_path
;
5200 = build_modify_expr_1 (base_lhs
, modifycode
, base_rhs
,
5203 /* We either get back a compound stmt, or a simple one. */
5204 if (new_result
&& TREE_CODE (new_result
) == TREE_LIST
)
5205 new_result
= build_compound_expr (new_result
);
5206 result
= tree_cons (NULL_TREE
, new_result
, result
);
5209 for (elt
= TYPE_FIELDS (lhstype
); elt
; elt
= TREE_CHAIN (elt
))
5211 tree vbases
= NULL_TREE
;
5212 tree elt_lhs
, elt_rhs
;
5214 if (TREE_CODE (elt
) != FIELD_DECL
)
5217 && (VFIELD_NAME_P (DECL_NAME (elt
))
5218 || VBASE_NAME_P (DECL_NAME (elt
))))
5221 if (TREE_READONLY (elt
)
5222 || TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5224 cp_error ("cannot generate default `%T::operator ='",
5226 if (TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5227 cp_error_at ("because member `%#D' is a reference", elt
);
5229 cp_error_at ("because member `%#D' is const", elt
);
5231 return error_mark_node
;
5234 if (IS_AGGR_TYPE (TREE_TYPE (elt
))
5235 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5236 vbases
= CLASSTYPE_VBASECLASSES (TREE_TYPE (elt
));
5238 elt_lhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), lhs
, elt
);
5239 elt_rhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), newrhs
, elt
);
5240 /* It is not always safe to go through `build_modify_expr_1'
5241 when performing element-wise copying. This is because
5242 an element may be of ARRAY_TYPE, which will not
5243 be properly copied as a naked element. */
5244 if (TREE_CODE (TREE_TYPE (elt
)) == RECORD_TYPE
5245 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5246 basetype_path
= TYPE_BINFO (TREE_TYPE (elt
));
5250 tree elt_lhs_addr
= build_unary_op (ADDR_EXPR
, elt_lhs
, 0);
5251 tree elt_rhs_addr
= build_unary_op (ADDR_EXPR
, elt_rhs
, 0);
5253 elt_lhs_addr
= convert_pointer_to (vbases
, elt_lhs_addr
);
5254 elt_rhs_addr
= convert_pointer_to (vbases
, elt_rhs_addr
);
5256 = tree_cons (NULL_TREE
,
5258 (build_indirect_ref (elt_lhs_addr
, NULL_PTR
),
5260 build_indirect_ref (elt_rhs_addr
, NULL_PTR
),
5263 if (TREE_VALUE (result
) == error_mark_node
)
5264 return error_mark_node
;
5265 vbases
= TREE_CHAIN (vbases
);
5267 elt_lhs
= build_modify_expr_1 (elt_lhs
, modifycode
, elt_rhs
,
5269 result
= tree_cons (NULL_TREE
, elt_lhs
, result
);
5273 return build_compound_expr (result
);
5274 /* No fields to move. */
5275 return integer_zero_node
;
5279 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5280 void_type_node
, lhs
, rhs
);
5281 TREE_SIDE_EFFECTS (result
) = 1;
5286 result
= build_modify_expr (lhs
, modifycode
, newrhs
);
5287 /* ARRAY_TYPEs cannot be converted to anything meaningful,
5288 and leaving it there screws up `build_compound_expr' when
5289 it tries to defaultly convert everything. */
5290 if (TREE_CODE (TREE_TYPE (result
)) == ARRAY_TYPE
)
5291 TREE_TYPE (result
) = void_type_node
;
5296 /* Taken from expr.c:
5297 Subroutine of expand_expr:
5298 record the non-copied parts (LIST) of an expr (LHS), and return a list
5299 which specifies the initial values of these parts. */
5302 init_noncopied_parts (lhs
, list
)
5309 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5310 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5311 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5314 tree part
= TREE_VALUE (tail
);
5315 tree part_type
= TREE_TYPE (part
);
5316 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5317 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
5322 /* Build an assignment expression of lvalue LHS from value RHS.
5323 MODIFYCODE is the code for a binary operator that we use
5324 to combine the old value of LHS with RHS to get the new value.
5325 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5327 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5330 build_modify_expr (lhs
, modifycode
, rhs
)
5332 enum tree_code modifycode
;
5335 register tree result
;
5337 tree lhstype
= TREE_TYPE (lhs
);
5338 tree olhstype
= lhstype
;
5341 /* Types that aren't fully specified cannot be used in assignments. */
5342 lhs
= require_complete_type (lhs
);
5344 /* Avoid duplicate error messages from operands that had errors. */
5345 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5346 return error_mark_node
;
5348 /* Decide early if we are going to protect RHS from GC
5349 before assigning it to LHS. */
5350 if (type_needs_gc_entry (TREE_TYPE (rhs
))
5351 && ! value_safe_from_gc (lhs
, rhs
))
5352 rhs
= protect_value_from_gc (lhs
, rhs
);
5356 /* Handle assignment to signature pointers/refs. */
5358 if (TYPE_LANG_SPECIFIC (lhstype
) &&
5359 (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5361 return build_signature_pointer_constructor (lhs
, rhs
);
5364 /* Handle control structure constructs used as "lvalues". */
5366 switch (TREE_CODE (lhs
))
5368 /* Handle --foo = 5; as these are valid constructs in C++ */
5369 case PREDECREMENT_EXPR
:
5370 case PREINCREMENT_EXPR
:
5371 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5372 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5373 stabilize_reference (TREE_OPERAND (lhs
, 0)));
5374 return build (COMPOUND_EXPR
, lhstype
,
5376 build_modify_expr (TREE_OPERAND (lhs
, 0),
5379 /* Handle (a, b) used as an "lvalue". */
5381 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5383 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5384 return error_mark_node
;
5385 return build (COMPOUND_EXPR
, lhstype
,
5386 TREE_OPERAND (lhs
, 0), newrhs
);
5389 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5390 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5391 return error_mark_node
;
5392 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5394 /* Handle (a ? b : c) used as an "lvalue". */
5396 rhs
= save_expr (rhs
);
5398 /* Produce (a ? (b = rhs) : (c = rhs))
5399 except that the RHS goes through a save-expr
5400 so the code to compute it is only emitted once. */
5402 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5403 build_modify_expr (TREE_OPERAND (lhs
, 1),
5405 build_modify_expr (TREE_OPERAND (lhs
, 2),
5407 if (TREE_CODE (cond
) == ERROR_MARK
)
5409 /* Make sure the code to compute the rhs comes out
5410 before the split. */
5411 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5412 /* Case to void to suppress warning
5413 from warn_if_unused_value. */
5414 convert (void_type_node
, rhs
), cond
);
5418 if (TREE_CODE (lhs
) == OFFSET_REF
)
5420 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5422 /* Static class member? */
5423 tree member
= TREE_OPERAND (lhs
, 1);
5424 if (TREE_CODE (member
) == VAR_DECL
)
5428 compiler_error ("invalid static class member");
5429 return error_mark_node
;
5433 lhs
= resolve_offset_ref (lhs
);
5435 olhstype
= lhstype
= TREE_TYPE (lhs
);
5438 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5439 && modifycode
!= INIT_EXPR
)
5441 lhs
= convert_from_reference (lhs
);
5442 olhstype
= lhstype
= TREE_TYPE (lhs
);
5445 /* If a binary op has been requested, combine the old LHS value with the RHS
5446 producing the value we should actually store into the LHS. */
5448 if (modifycode
== INIT_EXPR
)
5450 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_CONSTRUCTOR (lhstype
))
5452 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5453 build_tree_list (NULL_TREE
, rhs
),
5454 NULL_TREE
, LOOKUP_NORMAL
);
5455 if (result
== NULL_TREE
)
5456 return error_mark_node
;
5460 else if (modifycode
== NOP_EXPR
)
5463 /* `operator=' is not an inheritable operator. */
5464 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5466 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5467 lhs
, rhs
, make_node (NOP_EXPR
));
5468 if (result
== NULL_TREE
)
5469 return error_mark_node
;
5473 /* Treat `operator=' as an inheritable operator. */
5474 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_GETS_ASSIGNMENT (lhstype
))
5476 tree orig_lhstype
= lhstype
;
5477 while (! TYPE_HAS_ASSIGNMENT (lhstype
))
5479 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (lhstype
);
5480 tree basetype
= NULL_TREE
;
5481 for (i
= 0; i
< n_baseclasses
; i
++)
5482 if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype
, i
)))
5484 if (basetype
!= NULL_TREE
)
5486 message_2_types (error
, "base classes `%s' and `%s' both have operator ='",
5488 TYPE_BINFO_BASETYPE (lhstype
, i
));
5489 return error_mark_node
;
5491 basetype
= TYPE_BINFO_BASETYPE (lhstype
, i
);
5495 if (orig_lhstype
!= lhstype
)
5497 lhs
= build_indirect_ref (convert_pointer_to (lhstype
,
5498 build_unary_op (ADDR_EXPR
, lhs
, 0)), NULL_PTR
);
5499 if (lhs
== error_mark_node
)
5501 cp_error ("conversion to private basetype `%T'", lhstype
);
5502 return error_mark_node
;
5505 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5506 lhs
, rhs
, make_node (NOP_EXPR
));
5507 if (result
== NULL_TREE
)
5508 return error_mark_node
;
5514 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5516 /* This case must convert to some sort of lvalue that
5517 can participate in an op= operation. */
5520 if (build_default_binary_type_conversion (modifycode
, &lhs_tmp
, &rhs_tmp
))
5522 lhs
= stabilize_reference (lhs_tmp
);
5523 /* Forget is was ever anything else. */
5524 olhstype
= lhstype
= TREE_TYPE (lhs
);
5525 newrhs
= build_binary_op (modifycode
, lhs
, rhs_tmp
, 1);
5528 return error_mark_node
;
5532 lhs
= stabilize_reference (lhs
);
5533 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5536 /* Handle a cast used as an "lvalue".
5537 We have already performed any binary operator using the value as cast.
5538 Now convert the result to the cast type of the lhs,
5539 and then true type of the lhs and store it there;
5540 then convert result back to the cast type to be the value
5541 of the assignment. */
5543 switch (TREE_CODE (lhs
))
5548 case FIX_TRUNC_EXPR
:
5549 case FIX_FLOOR_EXPR
:
5550 case FIX_ROUND_EXPR
:
5552 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5553 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5554 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5555 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5556 newrhs
= default_conversion (newrhs
);
5558 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5560 if (! lvalue_p (lhs
) && pedantic
)
5561 pedwarn ("cast to non-reference type used as lvalue");
5563 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5564 convert (TREE_TYPE (inner_lhs
),
5565 convert (lhstype
, newrhs
)));
5566 if (TREE_CODE (result
) == ERROR_MARK
)
5568 return convert (TREE_TYPE (lhs
), result
);
5572 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5573 Reject anything strange now. */
5575 if (!lvalue_or_else (lhs
, "assignment"))
5576 return error_mark_node
;
5578 GNU_xref_assign (lhs
);
5580 /* Warn about storing in something that is `const'. */
5581 /* For C++, don't warn if this is initialization. */
5582 if (modifycode
!= INIT_EXPR
5583 /* For assignment to `const' signature pointer/reference fields,
5584 don't warn either, we already printed a better message before. */
5585 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5586 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5587 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5588 && (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
5589 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5590 || TREE_CODE (lhstype
) == UNION_TYPE
)
5591 && C_TYPE_FIELDS_READONLY (lhstype
))
5592 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5593 && TYPE_READONLY (TREE_TYPE (lhstype
)))))
5594 readonly_error (lhs
, "assignment", 0);
5596 /* If storing into a structure or union member,
5597 it has probably been given type `int'.
5598 Compute the type that would go with
5599 the actual amount of storage the member occupies. */
5601 if (TREE_CODE (lhs
) == COMPONENT_REF
5602 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5603 || TREE_CODE (lhstype
) == REAL_TYPE
5604 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5606 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5608 /* If storing in a field that is in actuality a short or narrower
5609 than one, we must store in the field in its actual type. */
5611 if (lhstype
!= TREE_TYPE (lhs
))
5613 lhs
= copy_node (lhs
);
5614 TREE_TYPE (lhs
) = lhstype
;
5618 /* check to see if there is an assignment to `this' */
5619 if (lhs
== current_class_decl
)
5621 if (flag_this_is_variable
> 0
5622 && DECL_NAME (current_function_decl
) != NULL_TREE
5623 && current_class_name
!= DECL_NAME (current_function_decl
))
5624 warning ("assignment to `this' not in constructor or destructor");
5625 current_function_just_assigned_this
= 1;
5628 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
5629 when the type of RHS is not yet known, i.e. its type
5630 is inherited from LHS. */
5631 rhs
= require_instantiated_type (lhstype
, newrhs
, error_mark_node
);
5632 if (rhs
== error_mark_node
)
5633 return error_mark_node
;
5636 if (modifycode
!= INIT_EXPR
)
5638 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5639 modifycode
= NOP_EXPR
;
5640 /* Reference-bashing */
5641 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5643 tree tmp
= convert_from_reference (lhs
);
5644 lhstype
= TREE_TYPE (tmp
);
5645 if (TYPE_SIZE (lhstype
) == 0)
5647 incomplete_type_error (lhs
, lhstype
);
5648 return error_mark_node
;
5653 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
5655 tree tmp
= convert_from_reference (newrhs
);
5656 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
5658 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
5659 return error_mark_node
;
5665 if (TREE_SIDE_EFFECTS (lhs
))
5666 lhs
= stabilize_reference (lhs
);
5667 if (TREE_SIDE_EFFECTS (newrhs
))
5668 newrhs
= stabilize_reference (newrhs
);
5670 /* C++: The semantics of C++ differ from those of C when an
5671 assignment of an aggregate is desired. Assignment in C++ is
5672 now defined as memberwise assignment of non-static members
5673 and base class objects. This rule applies recursively
5674 until a member of a built-in type is found.
5676 Also, we cannot do a bit-wise copy of aggregates which
5677 contain virtual function table pointers. Those
5678 pointer values must be preserved through the copy.
5679 However, this is handled in expand_expr, and not here.
5680 This is because much better code can be generated at
5681 that stage than this one. */
5682 if (TREE_CODE (lhstype
) == RECORD_TYPE
5683 && ! TYPE_PTRMEMFUNC_P (lhstype
)
5684 && (TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))
5685 || (TREE_CODE (TREE_TYPE (newrhs
)) == RECORD_TYPE
5686 && UNIQUELY_DERIVED_FROM_P (lhstype
, TREE_TYPE (newrhs
)))))
5688 /* This was decided in finish_struct. */
5689 if (modifycode
== INIT_EXPR
)
5690 cp_error ("can't generate default copy constructor for `%T'", lhstype
);
5692 cp_error ("can't generate default assignment operator for `%T'",
5695 /* This is now done by generating X(X&) and operator=(X&). */
5696 tree vbases
= CLASSTYPE_VBASECLASSES (lhstype
);
5697 tree lhs_addr
= build_unary_op (ADDR_EXPR
, lhs
, 0);
5700 /* Memberwise assignment would cause NEWRHS to be
5701 evaluated for every member that gets assigned.
5702 By wrapping side-effecting exprs in a SAVE_EXPR,
5703 NEWRHS will only be evaluated once. */
5704 if (IS_AGGR_TYPE (TREE_TYPE (newrhs
))
5705 && TREE_SIDE_EFFECTS (newrhs
)
5706 /* This are things we don't have to save. */
5707 && TREE_CODE (newrhs
) != COND_EXPR
5708 && TREE_CODE (newrhs
) != TARGET_EXPR
5709 && TREE_CODE (newrhs
) != WITH_CLEANUP_EXPR
)
5710 /* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
5711 If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
5712 will result in expand_expr expanding the call without knowing
5713 that it should run the cleanup. */
5714 newrhs
= save_expr (break_out_cleanups (newrhs
));
5716 if (TREE_CODE (newrhs
) == COND_EXPR
)
5717 rhs_addr
= rationalize_conditional_expr (ADDR_EXPR
, newrhs
);
5719 rhs_addr
= build_unary_op (ADDR_EXPR
, newrhs
, 0);
5721 result
= tree_cons (NULL_TREE
,
5722 convert (build_reference_type (lhstype
), lhs
),
5725 if (! comptypes (TREE_TYPE (lhs_addr
), TREE_TYPE (rhs_addr
), 1))
5726 rhs_addr
= convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr
)), rhs_addr
);
5728 tree noncopied_parts
= NULL_TREE
;
5730 if (TYPE_NONCOPIED_PARTS (lhstype
) != 0)
5731 noncopied_parts
= init_noncopied_parts (lhs
,
5732 TYPE_NONCOPIED_PARTS (lhstype
));
5733 while (noncopied_parts
!= 0)
5735 result
= tree_cons (NULL_TREE
,
5736 build_modify_expr (convert (ptr_type_node
, TREE_VALUE (noncopied_parts
)),
5738 TREE_PURPOSE (noncopied_parts
)),
5740 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
5743 /* Once we have our hands on an address, we must change NEWRHS
5744 to work from there. Otherwise we can get multiple evaluations
5746 if (TREE_CODE (newrhs
) != SAVE_EXPR
)
5747 newrhs
= build_indirect_ref (rhs_addr
, NULL_PTR
);
5751 tree elt_lhs
= convert_pointer_to (vbases
, lhs_addr
);
5752 tree elt_rhs
= convert_pointer_to (vbases
, rhs_addr
);
5754 = tree_cons (NULL_TREE
,
5755 build_modify_expr_1 (build_indirect_ref (elt_lhs
, NULL_PTR
),
5757 build_indirect_ref (elt_rhs
, NULL_PTR
),
5758 TYPE_BINFO (lhstype
)),
5760 if (TREE_VALUE (result
) == error_mark_node
)
5761 return error_mark_node
;
5762 vbases
= TREE_CHAIN (vbases
);
5764 result
= tree_cons (NULL_TREE
,
5765 build_modify_expr_1 (lhs
,
5768 TYPE_BINFO (lhstype
)),
5770 return build_compound_expr (result
);
5774 /* Convert new value to destination type. */
5776 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5778 /* Allow array assignment in compiler-generated code. */
5779 if ((pedantic
|| flag_ansi
)
5780 && ! DECL_ARTIFICIAL (current_function_decl
))
5781 pedwarn ("ANSI C++ forbids assignment between arrays");
5783 /* Have to wrap this in RTL_EXPR for two cases:
5784 in base or member initialization and if we
5785 are a branch of a ?: operator. Since we
5786 can't easily know the latter, just do it always. */
5788 result
= make_node (RTL_EXPR
);
5790 TREE_TYPE (result
) = void_type_node
;
5791 do_pending_stack_adjust ();
5792 start_sequence_for_rtl_expr (result
);
5794 /* As a matter of principle, `start_sequence' should do this. */
5797 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
5798 1 + (modifycode
!= INIT_EXPR
));
5800 do_pending_stack_adjust ();
5802 TREE_SIDE_EFFECTS (result
) = 1;
5803 RTL_EXPR_SEQUENCE (result
) = get_insns ();
5804 RTL_EXPR_RTL (result
) = const0_rtx
;
5809 if (modifycode
== INIT_EXPR
)
5811 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
5812 "assignment", NULL_TREE
, 0);
5813 if (lhs
== DECL_RESULT (current_function_decl
))
5815 if (DECL_INITIAL (lhs
))
5816 warning ("return value from function receives multiple initializations");
5817 DECL_INITIAL (lhs
) = newrhs
;
5822 if (IS_AGGR_TYPE (lhstype
))
5824 if (result
= build_opfncall (MODIFY_EXPR
,
5825 LOOKUP_NORMAL
, lhs
, newrhs
,
5826 make_node (NOP_EXPR
)))
5829 /* Avoid warnings on enum bit fields. */
5830 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
5831 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
5833 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
5835 newrhs
= convert_force (lhstype
, newrhs
);
5838 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
5840 if (flag_elide_constructors
== 0
5841 && TREE_CODE (newrhs
) == CALL_EXPR
5842 && TREE_ADDRESSABLE (lhstype
))
5844 /* Can't initialized directly from a CALL_EXPR, since
5845 we don't know about what doesn't alias what. */
5847 tree temp
= get_temp_name (lhstype
, 0);
5848 newrhs
= build (COMPOUND_EXPR
, lhstype
,
5849 build_modify_expr (temp
, INIT_EXPR
, newrhs
),
5854 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5855 return error_mark_node
;
5857 if (TREE_CODE (newrhs
) == COND_EXPR
)
5860 tree cond
= TREE_OPERAND (newrhs
, 0);
5862 if (TREE_SIDE_EFFECTS (lhs
))
5863 cond
= build_compound_expr (tree_cons
5865 build_tree_list (NULL_TREE
, cond
)));
5867 /* Cannot have two identical lhs on this one tree (result) as preexpand
5868 calls will rip them out and fill in RTL for them, but when the
5869 rtl is generated, the calls will only be in the first side of the
5870 condition, not on both, or before the conditional jump! (mrs) */
5871 lhs1
= break_out_calls (lhs
);
5874 /* If there's no change, the COND_EXPR behaves like any other rhs. */
5875 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5876 lhstype
, lhs
, newrhs
);
5879 tree result_type
= TREE_TYPE (newrhs
);
5880 /* We have to convert each arm to the proper type because the
5881 types may have been munged by constant folding. */
5883 = build (COND_EXPR
, result_type
, cond
,
5884 build_modify_expr (lhs
, modifycode
,
5885 convert (result_type
,
5886 TREE_OPERAND (newrhs
, 1))),
5887 build_modify_expr (lhs1
, modifycode
,
5888 convert (result_type
,
5889 TREE_OPERAND (newrhs
, 2))));
5892 else if (modifycode
!= INIT_EXPR
&& TREE_CODE (newrhs
) == WITH_CLEANUP_EXPR
)
5894 tree cleanup
= TREE_OPERAND (newrhs
, 2);
5897 /* Finish up by running cleanups and having the "value" of the lhs. */
5898 tree exprlist
= tree_cons (NULL_TREE
, cleanup
,
5899 build_tree_list (NULL_TREE
, lhs
));
5900 newrhs
= TREE_OPERAND (newrhs
, 0);
5901 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
5902 slot
= TREE_OPERAND (newrhs
, 0);
5903 else if (TREE_CODE (newrhs
) == ADDR_EXPR
)
5905 /* Bad but legal. */
5907 warning ("address taken of temporary object");
5910 my_friendly_abort (118);
5912 /* Copy the value computed in SLOT into LHS. */
5913 exprlist
= tree_cons (NULL_TREE
,
5914 build_modify_expr (lhs
, modifycode
, slot
),
5916 /* Evaluate the expression that needs CLEANUP. This will
5917 compute the value into SLOT. */
5918 exprlist
= tree_cons (NULL_TREE
, newrhs
, exprlist
);
5919 result
= convert (lhstype
, build_compound_expr (exprlist
));
5922 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5923 lhstype
, lhs
, newrhs
);
5924 TREE_SIDE_EFFECTS (result
) = 1;
5926 /* If we got the LHS in a different type for storing in,
5927 convert the result back to the nominal type of LHS
5928 so that the value we return always has the same type
5929 as the LHS argument. */
5931 if (olhstype
== TREE_TYPE (result
))
5933 /* Avoid warnings converting integral types back into enums
5934 for enum bit fields. */
5935 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
5936 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
5938 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
5939 TREE_NO_UNUSED_WARNING (result
) = 1;
5942 return convert_for_assignment (olhstype
, result
, "assignment",
5947 /* Return 0 if EXP is not a valid lvalue in this language
5948 even though `lvalue_or_else' would accept it. */
5951 language_lvalue_valid (exp
)
5957 /* Get differnce in deltas for different pointer to member function
5958 types. Return inetger_zero_node, if FROM cannot be converted to a
5959 TO type. If FORCE is true, then allow reverse conversions as well. */
5961 get_delta_difference (from
, to
, force
)
5965 tree delta
= integer_zero_node
;
5971 /* Should get_base_distance here, so we can check if any thing along the
5972 path is virtual, and we need to make sure we stay
5973 inside the real binfos when going through virtual bases.
5974 Maybe we should replace virtual bases with
5975 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
5976 binfo
= get_binfo (from
, to
, 1);
5977 if (binfo
== error_mark_node
)
5979 error (" in pointer to member function conversion");
5986 error_not_base_type (from
, to
);
5987 error (" in pointer to member function conversion");
5990 binfo
= get_binfo (to
, from
, 1);
5991 if (binfo
== error_mark_node
)
5993 error (" in pointer to member function conversion");
5998 error ("cannot convert pointer to member of type %T to unrelated pointer to member of type %T", from
, to
);
6001 if (TREE_VIA_VIRTUAL (binfo
))
6003 warning ("pointer to member conversion to virtual base class will only work if your very careful");
6005 return fold (size_binop (MINUS_EXPR
,
6007 BINFO_OFFSET (binfo
)));
6009 if (TREE_VIA_VIRTUAL (binfo
))
6011 warning ("pointer to member conversion from virtual base class will only work if your very careful");
6013 return BINFO_OFFSET (binfo
);
6016 /* Build a constructor for a pointer to member function. It can be
6017 used to initialize global variables, local variable, or used
6018 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6021 If FORCE is non-zero, then force this conversion, even if
6022 we would rather not do it. Usually set when using an explicit
6025 Return error_mark_node, if something goes wrong. */
6028 build_ptrmemfunc (type
, pfn
, force
)
6032 tree index
= integer_zero_node
;
6033 tree delta
= integer_zero_node
;
6034 tree delta2
= integer_zero_node
;
6039 /* Handle multiple conversions of pointer to member fucntions. */
6040 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6042 tree ndelta
, ndelta2
, nindex
;
6043 /* Is is already the right type? */
6045 /* Sorry, can't do this, the backend is too stupid. */
6046 if (TYPE_METHOD_BASETYPE (TREE_TYPE (type
))
6047 == TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))))
6049 if (type
!= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6051 npfn
= build1 (NOP_EXPR
, TYPE_GET_PTRMEMFUNC_TYPE (type
), pfn
);
6052 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6057 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6061 if (TREE_CODE (pfn
) != CONSTRUCTOR
)
6064 ndelta
= convert (sizetype
, build_component_ref (pfn
, delta_identifier
, 0, 0));
6065 ndelta2
= convert (sizetype
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6066 index
= build_component_ref (pfn
, index_identifier
, 0, 0);
6067 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))),
6068 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6070 delta
= fold (size_binop (PLUS_EXPR
, delta
, ndelta
));
6071 delta2
= fold (size_binop (PLUS_EXPR
, ndelta2
, delta2
));
6072 e1
= fold (build (GT_EXPR
, integer_type_node
, index
, integer_zero_node
));
6074 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6075 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6076 tree_cons (NULL_TREE
, index
,
6077 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6078 e2
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6080 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6081 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6082 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6084 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6085 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6086 tree_cons (NULL_TREE
, index
,
6087 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6088 e3
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6089 return build_conditional_expr (e1
, e2
, e3
);
6092 ndelta
= TREE_VALUE (CONSTRUCTOR_ELTS (pfn
));
6093 nindex
= TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
)));
6094 npfn
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
))));
6095 npfn
= TREE_VALUE (CONSTRUCTOR_ELTS (npfn
));
6096 if (integer_zerop (nindex
))
6097 pfn
= integer_zero_node
;
6100 sorry ("value casting of varible nonnull pointer to member functions not supported");
6101 return error_mark_node
;
6105 /* Handle null pointer to member function conversions. */
6106 if (integer_zerop (pfn
))
6108 pfn
= build_c_cast (type
, integer_zero_node
);
6109 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6110 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, integer_zero_node
,
6111 tree_cons (NULL_TREE
, integer_zero_node
,
6112 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6113 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6116 if (TREE_CODE (pfn
) == TREE_LIST
)
6118 pfn
= instantiate_type (type
, pfn
, 1);
6119 if (pfn
== error_mark_node
)
6120 return error_mark_node
;
6121 pfn
= build_unary_op (ADDR_EXPR
, pfn
, 0);
6124 /* Allow pointer to member conversions here. */
6125 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6126 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6128 delta2
= fold (size_binop (PLUS_EXPR
, delta2
, delta
));
6130 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6131 warning ("assuming pointer to member function is non-virtual");
6133 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6134 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6136 /* Find the offset to the vfield pointer in the object. */
6137 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6138 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6140 vfield_offset
= get_vfield_offset (vfield_offset
);
6141 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6143 /* Map everything down one to make room for the null pointer to member. */
6144 index
= size_binop (PLUS_EXPR
,
6145 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6147 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6151 index
= fold (size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
));
6153 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6154 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6156 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6159 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6160 tree_cons (NULL_TREE
, index
,
6161 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6162 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6165 /* Convert value RHS to type TYPE as preparation for an assignment
6166 to an lvalue of type TYPE.
6167 The real work of conversion is done by `convert'.
6168 The purpose of this function is to generate error messages
6169 for assignments that are not allowed in C.
6170 ERRTYPE is a string to use in error messages:
6171 "assignment", "return", etc.
6173 C++: attempts to allow `convert' to find conversions involving
6174 implicit type conversion between aggregate and scalar types
6175 as per 8.5.6 of C++ manual. Does not randomly dereference
6176 pointers to aggregates! */
6179 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6185 register enum tree_code codel
= TREE_CODE (type
);
6186 register tree rhstype
;
6187 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6189 if (coder
== UNKNOWN_TYPE
)
6190 rhs
= instantiate_type (type
, rhs
, 1);
6192 if (coder
== ERROR_MARK
)
6193 return error_mark_node
;
6195 if (codel
== OFFSET_TYPE
)
6197 type
= TREE_TYPE (type
);
6198 codel
= TREE_CODE (type
);
6201 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6202 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6203 rhs
= TREE_OPERAND (rhs
, 0);
6205 if (rhs
== error_mark_node
)
6206 return error_mark_node
;
6208 if (TREE_VALUE (rhs
) == error_mark_node
)
6209 return error_mark_node
;
6211 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6213 rhs
= resolve_offset_ref (rhs
);
6214 if (rhs
== error_mark_node
)
6215 return error_mark_node
;
6216 rhstype
= TREE_TYPE (rhs
);
6217 coder
= TREE_CODE (rhstype
);
6220 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6221 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6222 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6223 rhs
= default_conversion (rhs
);
6224 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6225 rhs
= convert_from_reference (rhs
);
6227 rhstype
= TREE_TYPE (rhs
);
6228 coder
= TREE_CODE (rhstype
);
6230 /* This should no longer change types on us. */
6231 if (TREE_CODE (rhs
) == CONST_DECL
)
6232 rhs
= DECL_INITIAL (rhs
);
6233 else if (TREE_READONLY_DECL_P (rhs
))
6234 rhs
= decl_constant_value (rhs
);
6236 if (type
== rhstype
)
6238 overflow_warning (rhs
);
6242 if (coder
== VOID_TYPE
)
6244 error ("void value not ignored as it ought to be");
6245 return error_mark_node
;
6247 /* Arithmetic types all interconvert. */
6248 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
)
6249 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
))
6251 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6252 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6255 cp_warning ("`%T' used for argument %P of `%D'",
6256 rhstype
, parmnum
, fndecl
);
6258 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6260 /* And we should warn if assigning a negative value to
6261 an unsigned variable. */
6262 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6264 if (TREE_CODE (rhs
) == INTEGER_CST
6265 && TREE_NEGATED_INT (rhs
))
6268 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6269 rhs
, parmnum
, fndecl
);
6271 cp_warning ("%s of negative value `%E' to `%T'",
6272 errtype
, rhs
, type
);
6274 overflow_warning (rhs
);
6275 if (TREE_CONSTANT (rhs
))
6279 return convert_and_check (type
, rhs
);
6281 /* Conversions involving enums. */
6282 else if ((codel
== ENUMERAL_TYPE
6283 && (coder
== ENUMERAL_TYPE
|| coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
))
6284 || (coder
== ENUMERAL_TYPE
6285 && (codel
== ENUMERAL_TYPE
|| codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
)))
6287 return convert (type
, rhs
);
6289 /* Conversions among pointers */
6290 else if (codel
== POINTER_TYPE
6291 && (coder
== POINTER_TYPE
6292 || (coder
== RECORD_TYPE
6293 && (IS_SIGNATURE_POINTER (rhstype
)
6294 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6296 register tree ttl
= TREE_TYPE (type
);
6299 if (coder
== RECORD_TYPE
)
6301 rhs
= build_optr_ref (rhs
);
6302 rhstype
= TREE_TYPE (rhs
);
6304 ttr
= TREE_TYPE (rhstype
);
6306 /* If both pointers are of aggregate type, then we
6307 can give better error messages, and save some work
6309 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6313 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6314 || type
== class_star_type_node
6315 || rhstype
== class_star_type_node
)
6316 binfo
= TYPE_BINFO (ttl
);
6318 binfo
= get_binfo (ttl
, ttr
, 1);
6320 if (binfo
== error_mark_node
)
6321 return error_mark_node
;
6323 return error_not_base_type (ttl
, ttr
);
6325 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6328 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6329 rhstype
, parmnum
, fndecl
);
6331 cp_pedwarn ("%s to `%T' from `%T' discards const",
6332 errtype
, type
, rhstype
);
6334 if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6337 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6338 rhstype
, parmnum
, fndecl
);
6340 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6341 errtype
, type
, rhstype
);
6345 /* Any non-function converts to a [const][volatile] void *
6346 and vice versa; otherwise, targets must be the same.
6347 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6348 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6349 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6350 || comp_target_types (type
, rhstype
, 1)
6351 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6352 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6354 /* ARM $4.8, commentary on p39. */
6355 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6356 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6358 error ("no standard conversion from pointer to member to `void *'");
6359 return error_mark_node
;
6362 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6363 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6364 && rhs
!= null_pointer_node
)
6366 if (coder
== RECORD_TYPE
)
6367 pedwarn ("implicit conversion of signature pointer to type `%s'",
6368 type_as_string (type
, 0));
6370 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6373 /* Const and volatile mean something different for function types,
6374 so the usual warnings are not appropriate. */
6375 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6376 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6378 if (TREE_CODE (ttl
) == OFFSET_TYPE
6379 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6380 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6382 sorry ("%s between pointer to members converting across virtual baseclasses", errtype
);
6383 return error_mark_node
;
6385 else if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6388 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6389 rhstype
, parmnum
, fndecl
);
6391 cp_pedwarn ("%s to `%T' from `%T' discards const",
6392 errtype
, type
, rhstype
);
6394 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6397 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6398 rhstype
, parmnum
, fndecl
);
6400 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6401 errtype
, type
, rhstype
);
6403 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6404 && ! comp_target_types (type
, rhstype
, 1))
6407 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6408 rhstype
, parmnum
, fndecl
);
6410 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6411 errtype
, type
, rhstype
);
6415 else if (TREE_CODE (ttr
) == OFFSET_TYPE
6416 && TREE_CODE (ttl
) != OFFSET_TYPE
)
6418 /* Normally, pointers to different type codes (other
6419 than void) are not compatible, but we perform
6420 some type instantiation if that resolves the
6421 ambiguity of (X Y::*) and (X *). */
6423 if (current_class_decl
)
6425 if (TREE_CODE (rhs
) == INTEGER_CST
)
6427 rhs
= build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (ttr
)),
6428 current_class_decl
, rhs
);
6429 return convert_for_assignment (type
, rhs
,
6430 errtype
, fndecl
, parmnum
);
6433 if (TREE_CODE (ttl
) == METHOD_TYPE
)
6434 error ("%s between pointer-to-method and pointer-to-member types",
6437 error ("%s between pointer and pointer-to-member types", errtype
);
6438 return error_mark_node
;
6442 int add_quals
= 0, const_parity
= 0, volatile_parity
= 0;
6444 int unsigned_parity
;
6447 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6448 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6451 const_parity
|= TYPE_READONLY (ttl
) < TYPE_READONLY (ttr
);
6452 volatile_parity
|= TYPE_VOLATILE (ttl
) < TYPE_VOLATILE (ttr
);
6455 && (TYPE_READONLY (ttl
) > TYPE_READONLY (ttr
)
6456 || TYPE_VOLATILE (ttl
) > TYPE_VOLATILE (ttr
)))
6458 left_const
&= TYPE_READONLY (ttl
);
6460 if (TREE_CODE (ttl
) != POINTER_TYPE
)
6463 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6464 if (unsigned_parity
)
6466 if (TREE_UNSIGNED (ttl
))
6467 ttr
= unsigned_type (ttr
);
6469 ttl
= unsigned_type (ttl
);
6472 if (comp_target_types (ttl
, ttr
, nptrs
))
6477 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6478 rhstype
, parmnum
, fndecl
);
6480 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6481 errtype
, type
, rhstype
);
6486 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6487 rhstype
, parmnum
, fndecl
);
6489 cp_pedwarn ("%s to `%T' from `%T' discards const",
6490 errtype
, type
, rhstype
);
6492 if (volatile_parity
)
6495 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6496 rhstype
, parmnum
, fndecl
);
6498 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6499 errtype
, type
, rhstype
);
6501 if (unsigned_parity
> 0)
6504 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6505 rhstype
, parmnum
, fndecl
);
6507 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6508 errtype
, type
, rhstype
);
6510 else if (unsigned_parity
< 0)
6513 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6514 rhstype
, parmnum
, fndecl
);
6516 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6517 errtype
, type
, rhstype
);
6520 /* C++ is not so friendly about converting function and
6521 member function pointers as C. Emit warnings here. */
6522 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6523 || TREE_CODE (ttl
) == METHOD_TYPE
)
6524 if (! comptypes (ttl
, ttr
, 0))
6526 warning ("conflicting function types in %s:", errtype
);
6527 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6530 else if (TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6532 /* When does this happen? */
6533 my_friendly_abort (119);
6534 /* Conversion of a pointer-to-member type to void *. */
6535 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6536 TREE_TYPE (rhs
) = type
;
6539 else if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6541 /* When does this happen? */
6542 my_friendly_abort (120);
6543 /* Conversion of a pointer-to-member type to void *. */
6544 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6545 TREE_TYPE (rhs
) = type
;
6551 cp_error ("passing `%T' as argument %P of `%D'",
6552 rhstype
, parmnum
, fndecl
);
6554 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6555 return error_mark_node
;
6558 return convert (type
, rhs
);
6560 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6562 /* An explicit constant 0 can convert to a pointer,
6563 but not a 0 that results from casting or folding. */
6564 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6567 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6568 rhstype
, parmnum
, fndecl
);
6570 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6571 errtype
, type
, rhstype
);
6572 return convert (type
, rhs
);
6574 return null_pointer_node
;
6576 else if (codel
== INTEGER_TYPE
6577 && (coder
== POINTER_TYPE
6578 || (coder
== RECORD_TYPE
6579 && (IS_SIGNATURE_POINTER (rhstype
)
6580 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6583 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6584 rhstype
, parmnum
, fndecl
);
6586 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6587 errtype
, type
, rhstype
);
6588 return convert (type
, rhs
);
6592 else if (((coder
== POINTER_TYPE
&& TREE_CODE (rhs
) == ADDR_EXPR
6593 && TREE_CODE (rhstype
) == POINTER_TYPE
6594 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6595 || integer_zerop (rhs
)
6596 || TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6597 && TYPE_PTRMEMFUNC_P (type
))
6599 /* compatible pointer to member functions. */
6600 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), rhs
, 0);
6602 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6603 return error_mark_node
;
6605 /* This should no longer happen. References are initialized via
6606 `convert_for_initialization'. They should otherwise be
6607 bashed before coming here. */
6608 else if (codel
== REFERENCE_TYPE
)
6609 /* Force an abort. */
6610 my_friendly_assert (codel
!= REFERENCE_TYPE
, 317);
6611 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6613 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6614 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6617 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6618 return convert (type
, rhs
);
6620 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6621 return error_mark_node
;
6624 /* Convert RHS to be of type TYPE. If EXP is non-zero,
6625 it is the target of the initialization.
6626 ERRTYPE is a string to use in error messages.
6628 Two major differences between the behavior of
6629 `convert_for_assignment' and `convert_for_initialization'
6630 are that references are bashed in the former, while
6631 copied in the latter, and aggregates are assigned in
6632 the former (operator=) while initialized in the
6635 If using constructor make sure no conversion operator exists, if one does
6636 exist, an ambiguity exists. */
6638 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6639 tree exp
, type
, rhs
;
6645 register enum tree_code codel
= TREE_CODE (type
);
6646 register tree rhstype
;
6647 register enum tree_code coder
;
6649 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6650 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6651 if (TREE_CODE (rhs
) == NOP_EXPR
6652 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6653 && codel
!= REFERENCE_TYPE
)
6654 rhs
= TREE_OPERAND (rhs
, 0);
6656 if (rhs
== error_mark_node
6657 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6658 return error_mark_node
;
6660 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6662 rhs
= resolve_offset_ref (rhs
);
6663 if (rhs
== error_mark_node
)
6664 return error_mark_node
;
6665 rhstype
= TREE_TYPE (rhs
);
6666 coder
= TREE_CODE (rhstype
);
6669 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6670 && TREE_CODE (type
) != ARRAY_TYPE
&& TREE_CODE (type
) != REFERENCE_TYPE
)
6671 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6672 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6673 rhs
= default_conversion (rhs
);
6675 rhstype
= TREE_TYPE (rhs
);
6676 coder
= TREE_CODE (rhstype
);
6678 if (coder
== UNKNOWN_TYPE
)
6680 rhs
= instantiate_type (type
, rhs
, 1);
6681 rhstype
= TREE_TYPE (rhs
);
6682 coder
= TREE_CODE (rhstype
);
6685 if (coder
== ERROR_MARK
)
6686 return error_mark_node
;
6689 /* This is *not* the quick way out! It is the way to disaster. */
6690 if (type
== rhstype
)
6694 /* We accept references to incomplete types, so we can
6695 return here before checking if RHS is of complete type. */
6697 if (codel
== REFERENCE_TYPE
)
6699 /* This should eventually happen in convert_arguments. */
6700 extern int warningcount
, errorcount
;
6704 savew
= warningcount
, savee
= errorcount
;
6705 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6706 exp
? exp
: error_mark_node
);
6709 if (warningcount
> savew
)
6710 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6711 else if (errorcount
> savee
)
6712 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6717 rhs
= require_complete_type (rhs
);
6718 if (rhs
== error_mark_node
)
6719 return error_mark_node
;
6721 if (exp
!= 0) exp
= require_complete_type (exp
);
6722 if (exp
== error_mark_node
)
6723 return error_mark_node
;
6725 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6726 rhstype
= TREE_TYPE (rhstype
);
6728 if (TYPE_LANG_SPECIFIC (type
)
6729 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6730 return build_signature_pointer_constructor (type
, rhs
);
6732 if (IS_AGGR_TYPE (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
6734 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
6736 /* This is sufficient to perform initialization. No need,
6737 apparently, to go through X(X&) to do first-cut
6738 initialization. Return through a TARGET_EXPR so that we get
6739 cleanups if it is used. */
6740 if (TREE_CODE (rhs
) == CALL_EXPR
)
6742 rhs
= build_cplus_new (type
, rhs
, 0);
6745 /* Handle the case of default parameter initialization and
6746 initialization of static variables. */
6747 else if (TREE_CODE (rhs
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (rhs
))
6749 my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs
, 0)) == CALL_EXPR
, 318);
6752 my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1)) == NULL_TREE
, 316);
6753 TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1))
6754 = build_unary_op (ADDR_EXPR
, exp
, 0);
6757 rhs
= build_cplus_new (type
, TREE_OPERAND (rhs
, 0), 0);
6761 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
)
6762 || (IS_AGGR_TYPE (rhstype
) && UNIQUELY_DERIVED_FROM_P (type
, rhstype
)))
6764 if (TYPE_HAS_INIT_REF (type
))
6766 tree init
= build_method_call (exp
, constructor_name_full (type
),
6767 build_tree_list (NULL_TREE
, rhs
),
6768 TYPE_BINFO (type
), LOOKUP_NORMAL
);
6770 if (init
== error_mark_node
)
6771 return error_mark_node
;
6775 exp
= build_cplus_new (type
, init
, 0);
6779 return build (COMPOUND_EXPR
, type
, init
, exp
);
6782 /* ??? The following warnings are turned off because
6783 this is another place where the default X(X&) constructor
6785 if (TYPE_HAS_ASSIGNMENT (type
))
6786 cp_warning ("bitwise copy: `%T' defines operator=", type
);
6788 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6789 rhs
= convert_from_reference (rhs
);
6790 if (type
!= rhstype
)
6792 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6793 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6799 return convert (type
, rhs
);
6802 if (type
== TREE_TYPE (rhs
))
6804 if (TREE_READONLY_DECL_P (rhs
))
6805 rhs
= decl_constant_value (rhs
);
6809 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
6812 /* Expand an ASM statement with operands, handling output operands
6813 that are not variables or INDIRECT_REFS by transforming such
6814 cases into cases that expand_asm_operands can handle.
6816 Arguments are same as for expand_asm_operands.
6818 We don't do default conversions on all inputs, because it can screw
6819 up operands that are expected to be in memory. */
6822 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
6823 tree string
, outputs
, inputs
, clobbers
;
6828 int noutputs
= list_length (outputs
);
6830 /* o[I] is the place that output number I should be written. */
6831 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
6834 /* Record the contents of OUTPUTS before it is modified. */
6835 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6836 o
[i
] = TREE_VALUE (tail
);
6838 /* Generate the ASM_OPERANDS insn;
6839 store into the TREE_VALUEs of OUTPUTS some trees for
6840 where the values were actually stored. */
6841 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
6843 /* Copy all the intermediate outputs into the specified outputs. */
6844 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6846 if (o
[i
] != TREE_VALUE (tail
))
6848 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
6849 const0_rtx
, VOIDmode
, 0);
6852 /* Detect modification of read-only values.
6853 (Otherwise done by build_modify_expr.) */
6856 tree type
= TREE_TYPE (o
[i
]);
6857 if (TYPE_READONLY (type
)
6858 || ((TREE_CODE (type
) == RECORD_TYPE
6859 || TREE_CODE (type
) == UNION_TYPE
)
6860 && C_TYPE_FIELDS_READONLY (type
)))
6861 readonly_error (o
[i
], "modification by `asm'", 1);
6865 /* Those MODIFY_EXPRs could do autoincrements. */
6869 /* Expand a C `return' statement.
6870 RETVAL is the expression for what to return,
6871 or a null pointer for `return;' with no value.
6873 C++: upon seeing a `return', we must call destructors on all
6874 variables in scope which had constructors called on them.
6875 This means that if in a destructor, the base class destructors
6876 must be called before returning.
6878 The RETURN statement in C++ has initialization semantics. */
6881 c_expand_return (retval
)
6884 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
6885 extern tree dtor_label
, ctor_label
;
6886 tree result
= DECL_RESULT (current_function_decl
);
6887 tree valtype
= TREE_TYPE (result
);
6888 register int use_temp
= 0;
6889 int returns_value
= 1;
6891 if (TREE_THIS_VOLATILE (current_function_decl
))
6892 warning ("function declared `noreturn' has a `return' statement");
6894 if (retval
== error_mark_node
)
6896 current_function_returns_null
= 1;
6900 if (retval
== NULL_TREE
)
6902 /* A non-named return value does not count. */
6904 /* Can't just return from a destructor. */
6907 expand_goto (dtor_label
);
6911 if (DECL_CONSTRUCTOR_P (current_function_decl
))
6912 retval
= current_class_decl
;
6913 else if (DECL_NAME (result
) != NULL_TREE
6914 && TREE_CODE (valtype
) != VOID_TYPE
)
6918 current_function_returns_null
= 1;
6920 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
6922 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
6924 pedwarn ("`return' with no value, in function returning non-void");
6925 /* Clear this, so finish_function won't say that we
6926 reach the end of a non-void function (which we don't,
6927 we gave a return!). */
6928 current_function_returns_null
= 0;
6932 expand_null_return ();
6936 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
6937 && retval
!= current_class_decl
)
6939 error ("return from a constructor: use `this = ...' instead");
6940 retval
= current_class_decl
;
6943 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
6945 current_function_returns_null
= 1;
6946 /* We do this here so we'll avoid a warning about how the function
6947 "may or may not return a value" in finish_function. */
6951 pedwarn ("`return' with a value, in function returning void");
6952 expand_return (retval
);
6954 /* Add some useful error checking for C++. */
6955 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6957 tree whats_returned
;
6958 tree tmp_result
= result
;
6960 /* Don't initialize directly into a non-BLKmode retval, since that
6961 could lose when being inlined by another caller. (GCC can't
6962 read the function return register in an inline function when
6963 the return value is being ignored). */
6964 if (result
&& TYPE_MODE (TREE_TYPE (tmp_result
)) != BLKmode
)
6967 /* convert to reference now, so we can give error if we
6968 return an reference to a non-lvalue. */
6969 retval
= convert_for_initialization (tmp_result
, valtype
, retval
,
6970 LOOKUP_NORMAL
, "return",
6973 /* Sort through common things to see what it is
6974 we are returning. */
6975 whats_returned
= retval
;
6976 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
6978 whats_returned
= TREE_OPERAND (whats_returned
, 1);
6979 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
6980 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6982 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
6984 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6985 while (TREE_CODE (whats_returned
) == NEW_EXPR
6986 || TREE_CODE (whats_returned
) == TARGET_EXPR
6987 || TREE_CODE (whats_returned
) == WITH_CLEANUP_EXPR
)
6988 /* Get the target. */
6989 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6992 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
6994 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
6995 warning ("reference to non-lvalue returned");
6996 else if (! TREE_STATIC (whats_returned
)
6997 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
)))
6998 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7001 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7003 tree whats_returned
= TREE_OPERAND (retval
, 0);
7005 if (TREE_CODE (whats_returned
) == VAR_DECL
7006 && DECL_NAME (whats_returned
)
7007 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7008 && !TREE_STATIC (whats_returned
))
7009 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7012 /* Now deal with possible C++ hair:
7013 (1) Compute the return value.
7014 (2) If there are aggregate values with destructors which
7015 must be cleaned up, clean them (taking care
7016 not to clobber the return value).
7017 (3) If an X(X&) constructor is defined, the return
7018 value must be returned via that. */
7020 if (retval
== result
7021 /* Watch out for constructors, which "return" aggregates
7022 via initialization, but which otherwise "return" a pointer. */
7023 || DECL_CONSTRUCTOR_P (current_function_decl
))
7025 /* This is just an error--it's already been reported. */
7026 if (TYPE_SIZE (valtype
) == NULL_TREE
)
7029 if (TYPE_MODE (valtype
) != BLKmode
7030 && any_pending_cleanups (1))
7032 retval
= get_temp_regvar (valtype
, retval
);
7033 use_temp
= obey_regdecls
;
7036 else if (IS_AGGR_TYPE (valtype
) && TYPE_NEEDS_CONSTRUCTING (valtype
))
7038 /* Throw away the cleanup that `build_functional_cast' gave us. */
7039 if (TREE_CODE (retval
) == WITH_CLEANUP_EXPR
7040 && TREE_CODE (TREE_OPERAND (retval
, 0)) == TARGET_EXPR
)
7041 retval
= TREE_OPERAND (retval
, 0);
7042 expand_aggr_init (result
, retval
, 0);
7043 DECL_INITIAL (result
) = NULL_TREE
;
7048 if (TYPE_MODE (valtype
) == VOIDmode
)
7050 if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
7051 && warn_return_type
)
7052 warning ("return of void value in function returning non-void");
7053 expand_expr_stmt (retval
);
7057 else if (TYPE_MODE (valtype
) != BLKmode
7058 && any_pending_cleanups (1))
7060 retval
= get_temp_regvar (valtype
, retval
);
7061 use_temp
= obey_regdecls
;
7066 retval
= convert_for_initialization (result
, valtype
, retval
,
7068 "return", NULL_TREE
, 0);
7069 DECL_INITIAL (result
) = NULL_TREE
;
7071 if (retval
== error_mark_node
)
7077 if (retval
!= NULL_TREE
7078 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7079 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7080 current_function_return_value
= retval
;
7084 /* Everything's great--RETVAL is in RESULT. */
7085 if (original_result_rtx
)
7086 store_expr (result
, original_result_rtx
, 0);
7087 else if (retval
&& retval
!= result
)
7089 /* Clear this out so the later call to decl_function_context
7090 won't end up bombing on us. */
7091 if (DECL_CONTEXT (result
) == error_mark_node
)
7092 DECL_CONTEXT (result
) = NULL_TREE
;
7093 /* Here is where we finally get RETVAL into RESULT.
7094 `expand_return' does the magic of protecting
7095 RESULT from cleanups. */
7096 retval
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7097 TREE_SIDE_EFFECTS (retval
) = 1;
7098 expand_return (retval
);
7101 expand_return (result
);
7103 use_variable (DECL_RTL (result
));
7104 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7105 expand_goto (ctor_label
);
7107 expand_null_return ();
7111 /* We may still need to put RETVAL into RESULT. */
7112 result
= DECL_RESULT (current_function_decl
);
7113 if (original_result_rtx
)
7115 /* Here we have a named return value that went
7116 into memory. We can compute RETVAL into that. */
7118 expand_assignment (result
, retval
, 0, 0);
7120 store_expr (result
, original_result_rtx
, 0);
7121 result
= make_tree (TREE_TYPE (result
), original_result_rtx
);
7123 else if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7125 /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do. */
7126 expand_goto (ctor_label
);
7130 /* Here is where we finally get RETVAL into RESULT.
7131 `expand_return' does the magic of protecting
7132 RESULT from cleanups. */
7133 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7134 TREE_SIDE_EFFECTS (result
) = 1;
7135 expand_return (result
);
7137 else if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
)
7138 expand_return (result
);
7141 current_function_returns_value
= returns_value
;
7143 /* These wind up after the BARRIER, which causes problems for
7144 expand_end_binding. What purpose were they supposed to serve? */
7145 if (original_result_rtx
)
7146 use_variable (original_result_rtx
);
7148 use_variable (DECL_RTL (DECL_RESULT (current_function_decl
)));
7151 /* One way to clear out cleanups that EXPR might
7152 generate. Note that this code will really be
7153 dead code, but that is ok--cleanups that were
7154 needed were handled by the magic of `return'. */
7155 expand_cleanups_to (NULL_TREE
);
7158 /* Start a C switch statement, testing expression EXP.
7159 Return EXP if it is valid, an error node otherwise. */
7162 c_expand_start_case (exp
)
7166 register enum tree_code code
;
7168 /* Convert from references, etc. */
7169 exp
= default_conversion (exp
);
7170 type
= TREE_TYPE (exp
);
7171 code
= TREE_CODE (type
);
7173 if (IS_AGGR_TYPE_CODE (code
))
7174 exp
= build_type_conversion (CONVERT_EXPR
, integer_type_node
, exp
, 1);
7176 if (exp
== NULL_TREE
)
7178 error ("switch quantity not an integer");
7179 exp
= error_mark_node
;
7181 type
= TREE_TYPE (exp
);
7182 code
= TREE_CODE (type
);
7184 if (code
!= INTEGER_TYPE
&& code
!= ENUMERAL_TYPE
&& code
!= ERROR_MARK
)
7186 error ("switch quantity not an integer");
7187 exp
= error_mark_node
;
7193 exp
= default_conversion (exp
);
7194 type
= TREE_TYPE (exp
);
7195 index
= get_unwidened (exp
, 0);
7196 /* We can't strip a conversion from a signed type to an unsigned,
7197 because if we did, int_fits_type_p would do the wrong thing
7198 when checking case values for being in range,
7199 and it's too hard to do the right thing. */
7200 if (TREE_UNSIGNED (TREE_TYPE (exp
))
7201 == TREE_UNSIGNED (TREE_TYPE (index
)))
7205 expand_start_case (1, exp
, type
, "switch statement");
7210 /* CONSTP remembers whether or not all the intervening pointers in the `to'
7211 type have been const. */
7213 comp_ptr_ttypes_real (to
, from
, constp
)
7217 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7219 if (TREE_CODE (to
) != TREE_CODE (from
))
7222 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7223 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7227 && (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7228 || TYPE_VOLATILE (to
) > TYPE_READONLY (from
)))
7230 constp
&= TYPE_READONLY (to
);
7232 if (TREE_CODE (to
) != POINTER_TYPE
)
7233 return comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1);
7237 /* When comparing, say, char ** to char const **, this function takes the
7238 'char *' and 'char const *'. Do not pass non-pointer types to this
7241 comp_ptr_ttypes (to
, from
)
7244 return comp_ptr_ttypes_real (to
, from
, 1);