1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This file is part of the C++ front end.
23 It contains routines to build C++ expressions given their operands,
24 including computing the types of the result, C and C++ specific error
25 checks, and some optimization.
27 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
28 and to process initializations in declarations (since they work
29 like a strange sort of assignment). */
32 extern void warning ();
41 int mark_addressable ();
42 static tree
convert_for_assignment ();
43 /* static */ tree
convert_for_initialization ();
44 extern tree
shorten_compare ();
45 extern void binary_op_error ();
46 static tree
pointer_int_sum ();
47 static tree
pointer_diff ();
48 static tree
convert_sequence ();
49 /* static */ tree
unary_complex_lvalue ();
50 static tree get_delta_difference
PROTO((tree
, tree
, int));
52 extern rtx original_result_rtx
;
54 /* Return the target type of TYPE, which meas return T for:
55 T*, T&, T[], T (...), and otherwise, just T. */
61 if (TREE_CODE (type
) == REFERENCE_TYPE
)
62 type
= TREE_TYPE (type
);
63 while (TREE_CODE (type
) == POINTER_TYPE
64 || TREE_CODE (type
) == ARRAY_TYPE
65 || TREE_CODE (type
) == FUNCTION_TYPE
66 || TREE_CODE (type
) == METHOD_TYPE
67 || TREE_CODE (type
) == OFFSET_TYPE
)
68 type
= TREE_TYPE (type
);
72 /* Do `exp = require_complete_type (exp);' to make sure exp
73 does not have an incomplete type. (That includes void types.) */
76 require_complete_type (value
)
79 tree type
= TREE_TYPE (value
);
81 /* First, detect a valid value with a complete type. */
82 if (TYPE_SIZE (type
) != 0
83 && type
!= void_type_node
84 && ! (TYPE_LANG_SPECIFIC (type
)
85 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
86 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
89 /* If we see X::Y, we build an OFFSET_TYPE which has
90 not been laid out. Try to avoid an error by interpreting
91 it as this->X::Y, if reasonable. */
92 if (TREE_CODE (value
) == OFFSET_REF
94 && TREE_OPERAND (value
, 0) == C_C_D
)
96 tree base
, member
= TREE_OPERAND (value
, 1);
97 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
98 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
99 base
= convert_pointer_to (basetype
, current_class_decl
);
100 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
101 build_indirect_ref (base
, NULL_PTR
), member
);
102 return require_complete_type (value
);
105 incomplete_type_error (value
, type
);
106 return error_mark_node
;
109 /* Return truthvalue of whether type of EXP is instantiated. */
114 return (TREE_CODE (exp
) == TREE_LIST
115 || TREE_TYPE (exp
) == unknown_type_node
116 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
117 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
120 /* Return truthvalue of whether T is function (or pfn) type. */
125 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
126 || (TREE_CODE (t
) == POINTER_TYPE
127 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
128 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
131 /* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
132 does not have an uninstantiated type.
133 TYPE is type to instantiate with, if uninstantiated. */
135 require_instantiated_type (type
, exp
, errval
)
136 tree type
, exp
, errval
;
138 if (TREE_TYPE (exp
) == NULL_TREE
)
140 error ("argument list may not have an initializer list");
144 if (TREE_TYPE (exp
) == unknown_type_node
145 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
146 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
))
148 exp
= instantiate_type (type
, exp
, 1);
149 if (TREE_TYPE (exp
) == error_mark_node
)
155 /* Return a variant of TYPE which has all the type qualifiers of LIKE
156 as well as those of TYPE. */
159 qualify_type (type
, like
)
162 int constflag
= TYPE_READONLY (type
) || TYPE_READONLY (like
);
163 int volflag
= TYPE_VOLATILE (type
) || TYPE_VOLATILE (like
);
164 /* @@ Must do member pointers here. */
165 return cp_build_type_variant (type
, constflag
, volflag
);
168 /* Return the common type of two parameter lists.
169 We assume that comptypes has already been done and returned 1;
170 if that isn't so, this may crash.
172 As an optimization, free the space we allocate if the parameter
173 lists are already common. */
179 tree oldargs
= p1
, newargs
, n
;
182 char *first_obj
= (char *) oballoc (0);
184 len
= list_length (p1
);
185 newargs
= tree_last (p1
);
187 if (newargs
== void_list_node
)
196 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
201 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
203 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
205 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
208 else if (! TREE_PURPOSE (p1
))
210 if (TREE_PURPOSE (p2
))
212 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
218 int cmp
= simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
));
220 my_friendly_abort (111);
223 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
225 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
228 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
231 TREE_VALUE (n
) = TREE_VALUE (p1
);
242 /* Return the common type of two types.
243 We assume that comptypes has already been done and returned 1;
244 if that isn't so, this may crash.
246 This is the type for the result of most arithmetic operations
247 if the operands have the given two types.
249 We do not deal with enumeral types here because they have already been
250 converted to integer types. */
256 register enum tree_code code1
;
257 register enum tree_code code2
;
260 /* Save time if the two types are the same. */
262 if (t1
== t2
) return t1
;
264 /* If one type is nonsense, use the other. */
265 if (t1
== error_mark_node
)
267 if (t2
== error_mark_node
)
270 /* Merge the attributes */
272 { register tree a1
, a2
;
273 a1
= TYPE_ATTRIBUTES (t1
);
274 a2
= TYPE_ATTRIBUTES (t2
);
276 /* Either one unset? Take the set one. */
278 if (!(attributes
= a1
))
281 /* One that completely contains the other? Take it. */
283 else if (a2
&& !attribute_list_contained (a1
, a2
))
284 if (attribute_list_contained (a2
, a1
))
288 /* Pick the longest list, and hang on the other
291 if (list_length (a1
) < list_length (a2
))
292 attributes
= a2
, a2
= a1
;
294 for (; a2
; a2
= TREE_CHAIN (a2
))
295 if (!value_member (attributes
, a2
))
298 TREE_CHAIN (a1
) = attributes
;
304 /* Treat an enum type as the unsigned integer type of the same width. */
306 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
307 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
308 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
309 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
311 code1
= TREE_CODE (t1
);
312 code2
= TREE_CODE (t2
);
318 /* If only one is real, use it as the result. */
320 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
321 return build_type_attribute_variant (t1
, attributes
);
323 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
324 return build_type_attribute_variant (t2
, attributes
);
326 /* Both real or both integers; use the one with greater precision. */
328 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
329 return build_type_attribute_variant (t1
, attributes
);
330 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
331 return build_type_attribute_variant (t2
, attributes
);
333 /* Same precision. Prefer longs to ints even when same size. */
335 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
336 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
337 return build_type_attribute_variant (long_unsigned_type_node
,
340 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
341 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
343 /* But preserve unsignedness from the other type,
344 since long cannot hold all the values of an unsigned int. */
345 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
346 t1
= long_unsigned_type_node
;
348 t1
= long_integer_type_node
;
349 return build_type_attribute_variant (t1
, attributes
);
352 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
353 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
354 return build_type_attribute_variant (long_double_type_node
,
357 /* Otherwise prefer the unsigned one. */
359 if (TREE_UNSIGNED (t1
))
360 return build_type_attribute_variant (t1
, attributes
);
362 return build_type_attribute_variant (t2
, attributes
);
366 /* For two pointers, do this recursively on the target type,
367 and combine the qualifiers of the two types' targets. */
368 /* This code was turned off; I don't know why.
369 But ANSI C++ specifies doing this with the qualifiers.
370 So I turned it on again. */
372 tree target
= common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1
)),
373 TYPE_MAIN_VARIANT (TREE_TYPE (t2
)));
375 = TYPE_READONLY (TREE_TYPE (t1
)) || TYPE_READONLY (TREE_TYPE (t2
));
377 = TYPE_VOLATILE (TREE_TYPE (t1
)) || TYPE_VOLATILE (TREE_TYPE (t2
));
378 target
= cp_build_type_variant (target
, constp
, volatilep
);
379 if (code1
== POINTER_TYPE
)
380 t1
= build_pointer_type (target
);
382 t1
= build_reference_type (target
);
383 return build_type_attribute_variant (t1
, attributes
);
387 t1
= build_pointer_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
388 return build_type_attribute_variant (t1
, attributes
);
391 t1
= build_reference_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
392 return build_type_attribute_variant (t1
, attributes
);
397 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
398 /* Save space: see if the result is identical to one of the args. */
399 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
400 return build_type_attribute_variant (t1
, attributes
);
401 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
402 return build_type_attribute_variant (t2
, attributes
);
403 /* Merge the element types, and have a size if either arg has one. */
404 t1
= build_array_type (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
405 return build_type_attribute_variant (t1
, attributes
);
409 /* Function types: prefer the one that specified arg types.
410 If both do, merge the arg types. Also merge the return types. */
412 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
413 tree p1
= TYPE_ARG_TYPES (t1
);
414 tree p2
= TYPE_ARG_TYPES (t2
);
417 /* Save space: see if the result is identical to one of the args. */
418 if (valtype
== TREE_TYPE (t1
) && ! p2
)
419 return build_type_attribute_variant (t1
, attributes
);
420 if (valtype
== TREE_TYPE (t2
) && ! p1
)
421 return build_type_attribute_variant (t2
, attributes
);
423 /* Simple way if one arg fails to specify argument types. */
424 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
426 rval
= build_function_type (valtype
, p2
);
427 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
428 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
429 return build_type_attribute_variant (rval
, attributes
);
431 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
432 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
434 rval
= build_function_type (valtype
, p1
);
436 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
437 return build_type_attribute_variant (rval
, attributes
);
440 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
441 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
442 return build_type_attribute_variant (rval
, attributes
);
447 my_friendly_assert (TYPE_MAIN_VARIANT (t1
) == t1
448 && TYPE_MAIN_VARIANT (t2
) == t2
, 306);
450 if (DERIVED_FROM_P (t1
, t2
) && binfo_or_else (t1
, t2
))
451 return build_type_attribute_variant (t1
, attributes
);
452 else if (binfo_or_else (t2
, t1
))
453 return build_type_attribute_variant (t2
, attributes
);
455 compiler_error ("common_type called with uncommon aggregate types");
458 if (comptypes (TYPE_METHOD_BASETYPE (t1
), TYPE_METHOD_BASETYPE (t2
), 1)
459 && TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
461 /* Get this value the long way, since TYPE_METHOD_BASETYPE
462 is just the main variant of this. */
463 tree basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
466 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
468 /* If this was a member function type, get back to the
469 original type of type member function (i.e., without
470 the class instance variable up front. */
471 t1
= build_function_type (TREE_TYPE (t1
), TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
472 t2
= build_function_type (TREE_TYPE (t2
), TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
473 t3
= common_type (t1
, t2
);
474 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
), TYPE_ARG_TYPES (t3
));
475 t1
= build_exception_variant (basetype
, t3
, raises
);
478 compiler_error ("common_type called with uncommon method types");
480 return build_type_attribute_variant (t1
, attributes
);
483 if (TYPE_OFFSET_BASETYPE (t1
) == TYPE_OFFSET_BASETYPE (t2
)
484 && TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
486 tree basetype
= TYPE_OFFSET_BASETYPE (t1
);
487 t1
= build_offset_type (basetype
,
488 common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
491 compiler_error ("common_type called with uncommon member types");
493 /* ... falls through ... */
496 return build_type_attribute_variant (t1
, attributes
);
500 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
502 compexcepttypes (t1
, t2
, strict
)
506 return TYPE_RAISES_EXCEPTIONS (t1
) == TYPE_RAISES_EXCEPTIONS (t2
);
510 comp_array_types (cmp
, t1
, t2
, strict
)
511 register int (*cmp
)();
515 tree d1
= TYPE_DOMAIN (t1
);
516 tree d2
= TYPE_DOMAIN (t2
);
518 /* Target types must match incl. qualifiers. */
519 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
520 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)))
523 /* Sizes must match unless one is missing or variable. */
524 if (d1
== 0 || d2
== 0 || d1
== d2
525 || TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
526 || TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
527 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
528 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
)
531 return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1
))
532 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2
)))
533 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1
))
534 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2
)))
535 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1
))
536 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2
)))
537 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1
))
538 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2
))));
541 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
542 or various other operations. This is what ANSI C++ speaks of as
545 For C++: argument STRICT says we should be strict about this
548 2 : strict, except that if one type is a reference and
549 the other is not, compare the target type of the
550 reference to the type that's not a reference (ARM, p308).
551 This is used for checking for invalid overloading.
552 1 : strict (compared according to ANSI C)
553 This is used for checking whether two function decls match.
554 0 : <= (compared according to C++)
555 -1: <= or >= (relaxed)
557 Otherwise, pointers involving base classes and derived classes
558 can be mixed as valid: i.e. a pointer to a base class may be assigned
559 to a pointer to one of its derived classes, as per C++. A pointer to
560 a derived class may be passed as a parameter to a function expecting a
561 pointer to a base classes. These allowances do not commute. In this
562 case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
563 be the derived class. */
565 comptypes (type1
, type2
, strict
)
569 register tree t1
= type1
;
570 register tree t2
= type2
;
573 /* Suppress errors caused by previously reported errors */
578 /* This should never happen. */
579 my_friendly_assert (t1
!= error_mark_node
, 307);
581 if (t2
== error_mark_node
)
586 /* Treat an enum type as the unsigned integer type of the same width. */
588 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
589 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
590 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
591 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
597 /* Different classes of types can't be compatible. */
599 if (TREE_CODE (t1
) != TREE_CODE (t2
))
602 && ((TREE_CODE (t1
) == REFERENCE_TYPE
)
603 ^ (TREE_CODE (t2
) == REFERENCE_TYPE
)))
605 if (TREE_CODE (t1
) == REFERENCE_TYPE
)
606 return comptypes (TREE_TYPE (t1
), t2
, 1);
607 return comptypes (t1
, TREE_TYPE (t2
), 1);
615 /* Qualifiers must match. */
617 if (TYPE_READONLY (t1
) != TYPE_READONLY (t2
))
619 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
622 /* Allow for two different type nodes which have essentially the same
623 definition. Note that we already checked for equality of the type
624 type qualifiers (just above). */
626 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
629 #ifdef COMP_TYPE_ATTRIBUTES
630 if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
633 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
637 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
640 switch (TREE_CODE (t1
))
649 val
= (comptypes (TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t1
)),
650 TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t2
)), strict
)
651 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
655 if (! compexcepttypes (t1
, t2
, strict
))
658 /* This case is anti-symmetrical!
659 One can pass a base member (or member function)
660 to something expecting a derived member (or member function),
661 but not vice-versa! */
663 val
= (comptypes (TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t2
)),
664 TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t1
)), strict
)
665 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
666 && compparms (TREE_CHAIN (TYPE_ARG_TYPES (t1
)),
667 TREE_CHAIN (TYPE_ARG_TYPES (t2
)), strict
));
681 if (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
)
685 rval
= t1
== t2
|| UNIQUELY_DERIVED_FROM_P (t1
, t2
);
694 val
= UNIQUELY_DERIVED_FROM_P (t2
, t1
);
701 val
= comptypes (t1
, t2
, strict
);
705 if (! compexcepttypes (t1
, t2
, strict
))
708 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
709 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
710 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
), strict
));
714 /* Target types must match incl. qualifiers. */
715 val
= comp_array_types (comptypes
, t1
, t2
, strict
);
718 case TEMPLATE_TYPE_PARM
:
721 case UNINSTANTIATED_P_TYPE
:
722 return UPT_TEMPLATE (t1
) == UPT_TEMPLATE (t2
);
724 return attrval
== 2 && val
== 1 ? 2 : val
;
727 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
728 ignoring their qualifiers.
730 NPTRS is the number of pointers we can strip off and keep cool.
731 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
732 but to not permit B** to convert to A**. */
735 comp_target_types (ttl
, ttr
, nptrs
)
739 ttl
= TYPE_MAIN_VARIANT (ttl
);
740 ttr
= TYPE_MAIN_VARIANT (ttr
);
744 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
747 if (TREE_CODE (ttr
) == POINTER_TYPE
)
749 if (TREE_CODE (TREE_TYPE (ttl
)) == POINTER_TYPE
750 || TREE_CODE (TREE_TYPE (ttl
)) == ARRAY_TYPE
)
751 return comp_ptr_ttypes (TREE_TYPE (ttl
), TREE_TYPE (ttr
));
753 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
- 1);
756 if (TREE_CODE (ttr
) == REFERENCE_TYPE
)
757 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
758 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
759 return comp_array_types (comp_target_types
, ttl
, ttr
, 0);
760 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
761 if (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
762 switch (comp_target_parms (TYPE_ARG_TYPES (ttl
), TYPE_ARG_TYPES (ttr
), 1))
771 my_friendly_abort (112);
777 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
779 /* Contravariance: we can assign a pointer to base member to a pointer
780 to derived member. Note difference from simple pointer case, where
781 we can pass a pointer to derived to a pointer to base. */
782 if (comptypes (TYPE_OFFSET_BASETYPE (ttr
), TYPE_OFFSET_BASETYPE (ttl
), 0))
783 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
784 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl
), TYPE_OFFSET_BASETYPE (ttr
), 0)
785 && comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
788 else if (IS_AGGR_TYPE (ttl
))
792 if (comptypes (TYPE_POINTER_TO (ttl
), TYPE_POINTER_TO (ttr
), 0))
794 if (comptypes (TYPE_POINTER_TO (ttr
), TYPE_POINTER_TO (ttl
), 0))
802 /* If two types share a common base type, return that basetype.
803 If there is not a unique most-derived base type, this function
804 returns ERROR_MARK_NODE. */
806 common_base_type (tt1
, tt2
)
809 tree best
= NULL_TREE
, tmp
;
812 /* If one is a baseclass of another, that's good enough. */
813 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
815 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
819 /* If they share a virtual baseclass, that's good enough. */
820 for (tmp
= CLASSTYPE_VBASECLASSES (tt1
); tmp
; tmp
= TREE_CHAIN (tmp
))
822 if (binfo_member (BINFO_TYPE (tmp
), CLASSTYPE_VBASECLASSES (tt2
)))
823 return BINFO_TYPE (tmp
);
827 /* Otherwise, try to find a unique baseclass of TT1
828 that is shared by TT2, and follow that down. */
829 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
831 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
832 tree trial
= common_base_type (basetype
, tt2
);
835 if (trial
== error_mark_node
)
837 if (best
== NULL_TREE
)
839 else if (best
!= trial
)
840 return error_mark_node
;
845 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
847 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
848 tree trial
= common_base_type (tt1
, basetype
);
851 if (trial
== error_mark_node
)
853 if (best
== NULL_TREE
)
855 else if (best
!= trial
)
856 return error_mark_node
;
862 /* Subroutines of `comptypes'. */
864 /* Return 1 if two parameter type lists PARMS1 and PARMS2
865 are equivalent in the sense that functions with those parameter types
866 can have equivalent types.
867 If either list is empty, we win.
868 Otherwise, the two lists must be equivalent, element by element.
870 C++: See comment above about TYPE1, TYPE2, STRICT.
871 If STRICT == 3, it means checking is strict, but do not compare
872 default parameter values. */
874 compparms (parms1
, parms2
, strict
)
878 register tree t1
= parms1
, t2
= parms2
;
880 /* An unspecified parmlist matches any specified parmlist
881 whose argument types don't need default promotions. */
883 if (strict
<= 0 && t1
== 0)
884 return self_promoting_args_p (t2
);
885 if (strict
< 0 && t2
== 0)
886 return self_promoting_args_p (t1
);
890 if (t1
== 0 && t2
== 0)
892 /* If one parmlist is shorter than the other,
893 they fail to match, unless STRICT is <= 0. */
894 if (t1
== 0 || t2
== 0)
901 return t1
&& TREE_PURPOSE (t1
);
903 if (! comptypes (TREE_VALUE (t2
), TREE_VALUE (t1
), strict
))
908 return t2
== void_list_node
&& TREE_PURPOSE (t1
);
909 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
912 /* Default parms are not part of the type of a function. */
913 if (strict
!= 3 && TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
915 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
917 my_friendly_abort (113);
923 t1
= TREE_CHAIN (t1
);
924 t2
= TREE_CHAIN (t2
);
928 /* This really wants return whether or not parameter type lists
929 would make their owning functions assignment compatible or not. */
931 comp_target_parms (parms1
, parms2
, strict
)
935 register tree t1
= parms1
, t2
= parms2
;
936 int warn_contravariance
= 0;
938 /* An unspecified parmlist matches any specified parmlist
939 whose argument types don't need default promotions.
940 @@@ see 13.3.3 for a counterexample... */
942 if (t1
== 0 && t2
!= 0)
944 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
946 return self_promoting_args_p (t2
);
949 return self_promoting_args_p (t1
);
951 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
955 /* If one parmlist is shorter than the other,
956 they fail to match, unless STRICT is <= 0. */
957 if (t1
== 0 || t2
== 0)
962 return 1 + warn_contravariance
;
963 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
965 p1
= TREE_VALUE (t1
);
966 p2
= TREE_VALUE (t2
);
970 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
971 || (TREE_CODE (p1
) == REFERENCE_TYPE
&& TREE_CODE (p2
) == REFERENCE_TYPE
))
974 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
975 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
978 /* The following is wrong for contravariance,
979 but many programs depend on it. */
980 if (TREE_TYPE (p1
) == void_type_node
)
982 if (TREE_TYPE (p2
) == void_type_node
)
984 warn_contravariance
= 1;
987 if (IS_AGGR_TYPE (TREE_TYPE (p1
)))
989 if (comptypes (p2
, p1
, 0) == 0)
991 if (comptypes (p1
, p2
, 0) != 0)
992 warn_contravariance
= 1;
999 /* Note backwards order due to contravariance. */
1000 if (comp_target_types (p2
, p1
, 1) == 0)
1002 if (comp_target_types (p1
, p2
, 1))
1004 warn_contravariance
= 1;
1010 /* What good do these cases do? */
1012 return p2
== void_type_node
&& TREE_PURPOSE (t1
);
1013 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
1016 /* Target types are compatible--just make sure that if
1017 we use parameter lists, that they are ok as well. */
1018 if (TREE_CODE (p1
) == FUNCTION_TYPE
|| TREE_CODE (p1
) == METHOD_TYPE
)
1019 switch (comp_target_parms (TYPE_ARG_TYPES (p1
),
1020 TYPE_ARG_TYPES (p2
),
1028 warn_contravariance
= 1;
1031 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1033 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1035 my_friendly_abort (114);
1040 return 1 + warn_contravariance
;
1043 /* Return 1 if PARMS specifies a fixed number of parameters
1044 and none of their types is affected by default promotions. */
1047 self_promoting_args_p (parms
)
1051 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1053 register tree type
= TREE_VALUE (t
);
1055 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1058 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1064 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1070 /* Return an unsigned type the same as TYPE in other respects.
1072 C++: must make these work for type variants as well. */
1075 unsigned_type (type
)
1078 tree type1
= TYPE_MAIN_VARIANT (type
);
1079 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1080 return unsigned_char_type_node
;
1081 if (type1
== integer_type_node
)
1082 return unsigned_type_node
;
1083 if (type1
== short_integer_type_node
)
1084 return short_unsigned_type_node
;
1085 if (type1
== long_integer_type_node
)
1086 return long_unsigned_type_node
;
1087 if (type1
== long_long_integer_type_node
)
1088 return long_long_unsigned_type_node
;
1092 /* Return a signed type the same as TYPE in other respects. */
1098 tree type1
= TYPE_MAIN_VARIANT (type
);
1099 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1100 return signed_char_type_node
;
1101 if (type1
== unsigned_type_node
)
1102 return integer_type_node
;
1103 if (type1
== short_unsigned_type_node
)
1104 return short_integer_type_node
;
1105 if (type1
== long_unsigned_type_node
)
1106 return long_integer_type_node
;
1107 if (type1
== long_long_unsigned_type_node
)
1108 return long_long_integer_type_node
;
1112 /* Return a type the same as TYPE except unsigned or
1113 signed according to UNSIGNEDP. */
1116 signed_or_unsigned_type (unsignedp
, type
)
1120 if (! INTEGRAL_TYPE_P (type
))
1122 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1123 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1124 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1125 return unsignedp
? unsigned_type_node
: integer_type_node
;
1126 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1127 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1128 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1129 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1130 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1131 return (unsignedp
? long_long_unsigned_type_node
1132 : long_long_integer_type_node
);
1140 enum tree_code code
= TREE_CODE (type
);
1143 if (code
== FUNCTION_TYPE
)
1145 if (pedantic
|| warn_pointer_arith
)
1146 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1147 return size_int (1);
1149 if (code
== METHOD_TYPE
)
1151 if (pedantic
|| warn_pointer_arith
)
1152 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1153 return size_int (1);
1155 if (code
== VOID_TYPE
)
1157 if (pedantic
|| warn_pointer_arith
)
1158 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1159 return size_int (1);
1161 if (code
== ERROR_MARK
)
1162 return size_int (1);
1164 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1165 referenced object.'' */
1166 if (code
== REFERENCE_TYPE
)
1167 type
= TREE_TYPE (type
);
1169 /* We couldn't find anything in the ARM or the draft standard that says,
1170 one way or the other, if doing sizeof on something that doesn't have
1171 an object associated with it is correct or incorrect. For example, if
1172 you declare `struct S { char str[16]; };', and in your program do
1173 a `sizeof (S::str)', should we flag that as an error or should we give
1174 the size of it? Since it seems like a reasonable thing to do, we'll go
1175 with giving the value. */
1176 if (code
== OFFSET_TYPE
)
1177 type
= TREE_TYPE (type
);
1179 /* @@ This also produces an error for a signature ref.
1180 In that case we should be able to do better. */
1181 if (IS_SIGNATURE (type
))
1183 error ("`sizeof' applied to a signature type");
1184 return size_int (0);
1187 if (TYPE_SIZE (type
) == 0)
1189 error ("`sizeof' applied to an incomplete type");
1190 return size_int (0);
1193 /* Convert in case a char is more than one unit. */
1194 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1195 size_int (TYPE_PRECISION (char_type_node
)));
1196 /* size_binop does not put the constant in range, so do it now. */
1197 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1198 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1203 c_sizeof_nowarn (type
)
1206 enum tree_code code
= TREE_CODE (type
);
1209 if (code
== FUNCTION_TYPE
1210 || code
== METHOD_TYPE
1211 || code
== VOID_TYPE
1212 || code
== ERROR_MARK
)
1213 return size_int (1);
1214 if (code
== REFERENCE_TYPE
)
1215 type
= TREE_TYPE (type
);
1217 if (TYPE_SIZE (type
) == 0)
1220 /* ??? Tiemann, why have any diagnostic here?
1221 There is none in the corresponding function for C. */
1222 warning ("sizeof applied to an incomplete type");
1224 return size_int (0);
1227 /* Convert in case a char is more than one unit. */
1228 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1229 size_int (TYPE_PRECISION (char_type_node
)));
1230 force_fit_type (t
, 0);
1234 /* Implement the __alignof keyword: Return the minimum required
1235 alignment of TYPE, measured in bytes. */
1241 enum tree_code code
= TREE_CODE (type
);
1244 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1245 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1247 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1248 return size_int (1);
1250 /* C++: this is really correct! */
1251 if (code
== REFERENCE_TYPE
)
1252 type
= TREE_TYPE (type
);
1254 /* @@ This also produces an error for a signature ref.
1255 In that case we should be able to do better. */
1256 if (IS_SIGNATURE (type
))
1258 error ("`__alignof' applied to a signature type");
1259 return size_int (1);
1262 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1263 force_fit_type (t
, 0);
1267 /* Perform default promotions for C data used in expressions.
1268 Arrays and functions are converted to pointers;
1269 enumeral types or short or char, to int.
1270 In addition, manifest constants symbols are replaced by their values.
1272 C++: this will automatically bash references to their target type. */
1275 default_conversion (exp
)
1278 register tree type
= TREE_TYPE (exp
);
1279 register enum tree_code code
= TREE_CODE (type
);
1281 if (code
== OFFSET_TYPE
/* || TREE_CODE (exp) == OFFSET_REF */ )
1283 if (TREE_CODE (exp
) == OFFSET_REF
)
1284 return default_conversion (resolve_offset_ref (exp
));
1286 type
= TREE_TYPE (type
);
1287 code
= TREE_CODE (type
);
1290 if (code
== REFERENCE_TYPE
)
1292 exp
= convert_from_reference (exp
);
1293 type
= TREE_TYPE (exp
);
1294 code
= TREE_CODE (type
);
1297 /* Constants can be used directly unless they're not loadable. */
1298 if (TREE_CODE (exp
) == CONST_DECL
)
1299 exp
= DECL_INITIAL (exp
);
1300 /* Replace a nonvolatile const static variable with its value. */
1301 else if (TREE_READONLY_DECL_P (exp
) && DECL_MODE (exp
) != BLKmode
)
1303 exp
= decl_constant_value (exp
);
1304 type
= TREE_TYPE (exp
);
1307 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1308 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1310 if (INTEGRAL_CODE_P (code
))
1312 tree t
= type_promotes_to (type
);
1314 return convert (t
, exp
);
1316 if (flag_traditional
1317 && TYPE_MAIN_VARIANT (type
) == float_type_node
)
1318 return convert (double_type_node
, exp
);
1319 if (code
== VOID_TYPE
)
1321 error ("void value not ignored as it ought to be");
1322 return error_mark_node
;
1324 if (code
== FUNCTION_TYPE
)
1326 return build_unary_op (ADDR_EXPR
, exp
, 0);
1328 if (code
== METHOD_TYPE
)
1330 if (TREE_CODE (exp
) == OFFSET_REF
)
1332 my_friendly_assert (TREE_CODE (TREE_OPERAND (exp
, 1)) == FUNCTION_DECL
,
1334 return build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 1), 0);
1336 return build_unary_op (ADDR_EXPR
, exp
, 0);
1338 if (code
== ARRAY_TYPE
)
1343 int constp
, volatilep
;
1345 if (TREE_CODE (exp
) == INDIRECT_REF
)
1347 /* Stripping away the INDIRECT_REF is not the right
1348 thing to do for references... */
1349 tree inner
= TREE_OPERAND (exp
, 0);
1350 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1352 inner
= build1 (CONVERT_EXPR
,
1353 build_pointer_type (TREE_TYPE (TREE_TYPE (inner
))),
1355 TREE_REFERENCE_EXPR (inner
) = 1;
1357 return convert (TYPE_POINTER_TO (TREE_TYPE (type
)), inner
);
1360 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1362 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1363 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1364 TREE_OPERAND (exp
, 0), op1
);
1368 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1370 error ("invalid use of non-lvalue array");
1371 return error_mark_node
;
1374 constp
= volatilep
= 0;
1375 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r'
1376 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
1378 constp
= TREE_READONLY (exp
);
1379 volatilep
= TREE_THIS_VOLATILE (exp
);
1382 restype
= TREE_TYPE (type
);
1383 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)
1384 || constp
|| volatilep
)
1385 restype
= cp_build_type_variant (restype
,
1386 TYPE_READONLY (type
) || constp
,
1387 TYPE_VOLATILE (type
) || volatilep
);
1388 ptrtype
= build_pointer_type (restype
);
1390 if (TREE_CODE (exp
) == VAR_DECL
)
1392 /* ??? This is not really quite correct
1393 in that the type of the operand of ADDR_EXPR
1394 is not the target type of the type of the ADDR_EXPR itself.
1395 Question is, can this lossage be avoided? */
1396 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1397 if (mark_addressable (exp
) == 0)
1398 return error_mark_node
;
1399 TREE_CONSTANT (adr
) = staticp (exp
);
1400 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1403 /* This way is better for a COMPONENT_REF since it can
1404 simplify the offset for a component. */
1405 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1406 return convert (ptrtype
, adr
);
1412 build_object_ref (datum
, basetype
, field
)
1413 tree datum
, basetype
, field
;
1416 if (datum
== error_mark_node
)
1417 return error_mark_node
;
1419 dtype
= TREE_TYPE (datum
);
1420 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1421 dtype
= TREE_TYPE (dtype
);
1422 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1424 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1425 basetype
, field
, dtype
);
1426 return error_mark_node
;
1428 else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype
)))
1430 warning ("signature name in scope resolution ignored");
1431 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1433 else if (is_aggr_typedef (basetype
, 1))
1435 tree real_basetype
= IDENTIFIER_TYPE_VALUE (basetype
);
1436 tree binfo
= binfo_or_else (real_basetype
, TREE_TYPE (datum
));
1438 return build_component_ref (build_scoped_ref (datum
, basetype
),
1441 return error_mark_node
;
1444 /* Like `build_component_ref, but uses an already found field.
1445 Must compute access for C_C_D. Otherwise, ok. */
1447 build_component_ref_1 (datum
, field
, protect
)
1451 register tree basetype
= TREE_TYPE (datum
);
1452 register enum tree_code code
= TREE_CODE (basetype
);
1455 if (code
== REFERENCE_TYPE
)
1457 datum
= convert_from_reference (datum
);
1458 basetype
= TREE_TYPE (datum
);
1459 code
= TREE_CODE (basetype
);
1462 if (! IS_AGGR_TYPE_CODE (code
))
1464 if (code
!= ERROR_MARK
)
1465 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1466 field
, datum
, basetype
);
1467 return error_mark_node
;
1470 if (TYPE_SIZE (basetype
) == 0)
1472 incomplete_type_error (0, basetype
);
1473 return error_mark_node
;
1476 /* Look up component name in the structure type definition. */
1478 if (field
== error_mark_node
)
1479 my_friendly_abort (115);
1481 if (TREE_STATIC (field
))
1486 enum access_type access
1487 = compute_access (TYPE_BINFO (current_class_type
), field
);
1489 if (access
== access_private
)
1491 cp_error ("field `%D' is private", field
);
1492 return error_mark_node
;
1494 else if (access
== access_protected
)
1496 cp_error ("field `%D' is protected", field
);
1497 return error_mark_node
;
1501 ref
= build (COMPONENT_REF
, TREE_TYPE (field
), datum
, field
);
1503 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1504 TREE_READONLY (ref
) = 1;
1505 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1506 TREE_THIS_VOLATILE (ref
) = 1;
1507 if (DECL_MUTABLE_P (field
))
1508 TREE_READONLY (ref
) = 0;
1513 /* Given a COND_EXPR in T, return it in a form that we can, for
1514 example, use as an lvalue. This code used to be in unary_complex_lvalue,
1515 but we needed it to deal with `a = (d == c) ? b : c' expressions, where
1516 we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
1517 and in build_modify_expr. The case (in particular) that led to this was
1518 with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
1520 rationalize_conditional_expr (code
, t
)
1521 enum tree_code code
;
1525 build_conditional_expr (TREE_OPERAND (t
, 0),
1526 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1527 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1531 build_component_ref (datum
, component
, basetype_path
, protect
)
1532 tree datum
, component
, basetype_path
;
1535 register tree basetype
= TREE_TYPE (datum
);
1536 register enum tree_code code
= TREE_CODE (basetype
);
1537 register tree field
= NULL
;
1540 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it. */
1541 switch (TREE_CODE (datum
))
1545 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1546 basetype_path
, protect
);
1547 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1548 TREE_OPERAND (datum
, 0), value
);
1551 return build_conditional_expr
1552 (TREE_OPERAND (datum
, 0),
1553 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1554 basetype_path
, protect
),
1555 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1556 basetype_path
, protect
));
1559 if (code
== REFERENCE_TYPE
)
1562 /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
1563 @@ Maybe that is not right. */
1564 if (TREE_REFERENCE_EXPR (datum
))
1565 datum
= build1 (INDIRECT_REF
, TREE_TYPE (basetype
), datum
);
1568 datum
= convert_from_reference (datum
);
1569 basetype
= TREE_TYPE (datum
);
1570 code
= TREE_CODE (basetype
);
1573 /* First, see if there is a field or component with name COMPONENT. */
1574 if (TREE_CODE (component
) == TREE_LIST
)
1576 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1577 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1578 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1581 if (TREE_CODE (component
) == TYPE_EXPR
)
1582 return build_component_type_expr (datum
, component
, NULL_TREE
, protect
);
1585 if (! IS_AGGR_TYPE_CODE (code
))
1587 if (code
!= ERROR_MARK
)
1588 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1589 component
, datum
, basetype
);
1590 return error_mark_node
;
1593 if (TYPE_SIZE (basetype
) == 0)
1595 incomplete_type_error (0, basetype
);
1596 return error_mark_node
;
1599 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
1601 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
1603 cp_error ("destructor specifier `%T::~%T' must have matching names",
1604 basetype
, TREE_OPERAND (component
, 0));
1605 return error_mark_node
;
1607 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1609 cp_error ("type `%T' has no destructor", basetype
);
1610 return error_mark_node
;
1612 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
1615 /* Look up component name in the structure type definition. */
1616 if (CLASSTYPE_VFIELD (basetype
)
1617 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
1618 /* Special-case this because if we use normal lookups in an ambiguous
1619 hierarchy, the compiler will abort (because vptr lookups are
1620 not supposed to be ambiguous. */
1621 field
= CLASSTYPE_VFIELD (basetype
);
1624 if (basetype_path
== NULL_TREE
)
1625 basetype_path
= TYPE_BINFO (basetype
);
1626 field
= lookup_field (basetype_path
, component
,
1627 protect
&& ! VFIELD_NAME_P (component
), 0);
1628 if (field
== error_mark_node
)
1629 return error_mark_node
;
1631 if (field
== NULL_TREE
)
1633 /* Not found as a data field, look for it as a method. If found,
1634 then if this is the only possible one, return it, else
1635 report ambiguity error. */
1636 tree fndecls
= lookup_fnfields (basetype_path
, component
, 1);
1637 if (fndecls
== error_mark_node
)
1638 return error_mark_node
;
1641 if (TREE_CHAIN (fndecls
) == NULL_TREE
1642 && DECL_CHAIN (TREE_VALUE (fndecls
)) == NULL_TREE
)
1644 enum access_type access
;
1647 /* Unique, so use this one now. */
1648 basetype
= TREE_PURPOSE (fndecls
);
1649 fndecl
= TREE_VALUE (fndecls
);
1650 access
= compute_access (TREE_PURPOSE (fndecls
), fndecl
);
1651 if (access
== access_public
)
1653 if (DECL_VINDEX (fndecl
)
1654 && ! resolves_to_fixed_type_p (datum
, 0))
1656 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1657 addr
= convert_pointer_to (DECL_CONTEXT (fndecl
), addr
);
1658 datum
= build_indirect_ref (addr
, NULL_PTR
);
1659 my_friendly_assert (datum
!= error_mark_node
, 310);
1660 fndecl
= build_vfn_ref (&addr
, datum
, DECL_VINDEX (fndecl
));
1664 if (access
== access_protected
)
1665 cp_error ("member function `%D' is protected", fndecl
);
1667 cp_error ("member function `%D' is private", fndecl
);
1668 return error_mark_node
;
1672 /* Just act like build_offset_ref, since the object does
1673 not matter unless we're actually calling the function. */
1674 tree t
= build_tree_list (error_mark_node
, fndecls
);
1675 TREE_TYPE (t
) = build_offset_type (basetype
,
1682 if (component
== ansi_opname
[(int) TYPE_EXPR
])
1683 cp_error ("`%#T' has no such type conversion operator", basetype
);
1686 cp_error ("`%#T' has no member named `%D'", basetype
, component
);
1687 return error_mark_node
;
1689 else if (TREE_TYPE (field
) == error_mark_node
)
1690 return error_mark_node
;
1692 if (TREE_CODE (field
) != FIELD_DECL
)
1694 if (TREE_CODE (field
) == TYPE_DECL
)
1696 cp_error ("invalid use of type decl `%#D' as expression", field
);
1697 return error_mark_node
;
1699 if (DECL_RTL (field
) != 0)
1700 assemble_external (field
);
1701 TREE_USED (field
) = 1;
1706 if (DECL_FIELD_CONTEXT (field
) != basetype
1707 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
1709 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1710 if (integer_zerop (addr
))
1712 error ("invalid reference to NULL ptr, use ptr-to-member instead");
1713 return error_mark_node
;
1715 addr
= convert_pointer_to (DECL_FIELD_CONTEXT (field
), addr
);
1716 datum
= build_indirect_ref (addr
, NULL_PTR
);
1717 my_friendly_assert (datum
!= error_mark_node
, 311);
1719 ref
= fold (build (COMPONENT_REF
, TREE_TYPE (field
),
1720 break_out_cleanups (datum
), field
));
1722 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1723 TREE_READONLY (ref
) = 1;
1724 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1725 TREE_THIS_VOLATILE (ref
) = 1;
1726 if (DECL_MUTABLE_P (field
))
1727 TREE_READONLY (ref
) = 0;
1732 /* Given an expression PTR for a pointer, return an expression
1733 for the value pointed to.
1734 ERRORSTRING is the name of the operator to appear in error messages.
1736 This function may need to overload OPERATOR_FNNAME.
1737 Must also handle REFERENCE_TYPEs for C++. */
1740 build_x_indirect_ref (ptr
, errorstring
)
1744 tree rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
, NULL_TREE
);
1747 return build_indirect_ref (ptr
, errorstring
);
1751 build_indirect_ref (ptr
, errorstring
)
1755 register tree pointer
= default_conversion (ptr
);
1756 register tree type
= TREE_TYPE (pointer
);
1758 if (ptr
== current_class_decl
)
1761 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
1763 if (TREE_CODE (pointer
) == ADDR_EXPR
1764 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1765 == TREE_TYPE (type
)))
1766 return TREE_OPERAND (pointer
, 0);
1769 tree t
= TREE_TYPE (type
);
1770 register tree ref
= build1 (INDIRECT_REF
,
1771 TYPE_MAIN_VARIANT (t
), pointer
);
1773 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1774 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1775 TREE_SIDE_EFFECTS (ref
)
1776 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1780 /* `pointer' won't be an error_mark_node if we were given a
1781 pointer to member, so it's cool to check for this here. */
1782 else if (TYPE_PTRMEMFUNC_P (type
))
1783 error ("invalid use of `%s' on pointer to member function", errorstring
);
1784 else if (TREE_CODE (type
) == RECORD_TYPE
1785 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1786 error ("cannot dereference signature pointer/reference");
1787 else if (pointer
!= error_mark_node
)
1790 error ("invalid type argument of `%s'", errorstring
);
1792 error ("invalid type argument");
1794 return error_mark_node
;
1797 /* This handles expressions of the form "a[i]", which denotes
1800 This is logically equivalent in C to *(a+i), but we may do it differently.
1801 If A is a variable or a member, we generate a primitive ARRAY_REF.
1802 This avoids forcing the array out of registers, and can work on
1803 arrays that are not lvalues (for example, members of structures returned
1806 If INDEX is of some user-defined type, it must be converted to
1807 integer type. Otherwise, to make a compatible PLUS_EXPR, it
1808 will inherit the type of the array, which will be some pointer type. */
1811 build_x_array_ref (array
, index
)
1814 tree rval
= build_opfncall (ARRAY_REF
, LOOKUP_NORMAL
, array
, index
, NULL_TREE
);
1817 return build_array_ref (array
, index
);
1821 build_array_ref (array
, idx
)
1828 error ("subscript missing in array reference");
1829 return error_mark_node
;
1832 if (TREE_TYPE (array
) == error_mark_node
1833 || TREE_TYPE (idx
) == error_mark_node
)
1834 return error_mark_node
;
1836 itype
= TREE_TYPE (idx
);
1837 /* We must check here for the reference, so we can do the possible
1838 conversions immediately afterwards. */
1839 if (TREE_CODE (itype
) == REFERENCE_TYPE
)
1841 idx
= convert_from_reference (idx
);
1842 itype
= TREE_TYPE (idx
);
1845 if (IS_AGGR_TYPE (itype
))
1847 if (TYPE_HAS_INT_CONVERSION (itype
))
1848 idx
= build_type_conversion (CONVERT_EXPR
,
1849 integer_type_node
, idx
, 1);
1852 error_with_aggr_type (itype
,
1853 "type `%s' requires integer conversion for array indexing");
1854 return error_mark_node
;
1858 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
1859 && TREE_CODE (array
) != INDIRECT_REF
)
1863 /* Subscripting with type char is likely to lose
1864 on a machine where chars are signed.
1865 So warn on any machine, but optionally.
1866 Don't warn for unsigned char since that type is safe.
1867 Don't warn for signed char because anyone who uses that
1868 must have done so deliberately. */
1869 if (warn_char_subscripts
1870 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
1871 warning ("array subscript has type `char'");
1873 /* Apply default promotions *after* noticing character types. */
1874 idx
= default_conversion (idx
);
1876 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
1878 error ("array subscript is not an integer");
1879 return error_mark_node
;
1882 /* An array that is indexed by a non-constant
1883 cannot be stored in a register; we must be able to do
1884 address arithmetic on its address.
1885 Likewise an array of elements of variable size. */
1886 if (TREE_CODE (idx
) != INTEGER_CST
1887 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
1888 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1890 if (mark_addressable (array
) == 0)
1891 return error_mark_node
;
1893 /* An array that is indexed by a constant value which is not within
1894 the array bounds cannot be stored in a register either; because we
1895 would get a crash in store_bit_field/extract_bit_field when trying
1896 to access a non-existent part of the register. */
1897 if (TREE_CODE (idx
) == INTEGER_CST
1898 && TYPE_VALUES (TREE_TYPE (array
))
1899 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
1901 if (mark_addressable (array
) == 0)
1902 return error_mark_node
;
1905 /* Note in C++ we don't bother warning about subscripting a
1906 `register' array, since it's valid in C++ to take the address
1907 of something with that storage specification. */
1908 if (pedantic
&& !lvalue_p (array
))
1909 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1914 while (TREE_CODE (foo
) == COMPONENT_REF
)
1915 foo
= TREE_OPERAND (foo
, 0);
1916 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
1917 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1920 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1921 rval
= build (ARRAY_REF
, type
, array
, idx
);
1922 /* Array ref is const/volatile if the array elements are
1923 or if the array is.. */
1924 TREE_READONLY (rval
)
1925 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1926 | TREE_READONLY (array
));
1927 TREE_SIDE_EFFECTS (rval
)
1928 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1929 | TREE_SIDE_EFFECTS (array
));
1930 TREE_THIS_VOLATILE (rval
)
1931 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1932 /* This was added by rms on 16 Nov 91.
1933 It fixes vol struct foo *a; a->elts[1]
1934 in an inline function.
1935 Hope it doesn't break something else. */
1936 | TREE_THIS_VOLATILE (array
));
1937 return require_complete_type (fold (rval
));
1941 tree ar
= default_conversion (array
);
1942 tree ind
= default_conversion (idx
);
1944 /* Put the integer in IND to simplify error checking. */
1945 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
1952 if (ar
== error_mark_node
)
1955 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
1957 error ("subscripted value is neither array nor pointer");
1958 return error_mark_node
;
1960 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
1962 error ("array subscript is not an integer");
1963 return error_mark_node
;
1966 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
, ind
, PLUS_EXPR
),
1971 /* Build a function call to function FUNCTION with parameters PARAMS.
1972 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1973 TREE_VALUE of each node is a parameter-expression.
1974 FUNCTION's data type may be a function type or a pointer-to-function.
1976 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
1977 is the list of possible methods that FUNCTION could conceivably
1978 be. If the list of methods comes from a class, then it will be
1979 a list of lists (where each element is associated with the class
1980 that produced it), otherwise it will be a simple list (for
1981 functions overloaded in global scope).
1983 In the first case, TREE_VALUE (function) is the head of one of those
1984 lists, and TREE_PURPOSE is the name of the function.
1986 In the second case, TREE_PURPOSE (function) is the function's
1989 DECL is the class instance variable, usually CURRENT_CLASS_DECL. */
1992 * [eichin:19911015.1726EST] actually return a possibly incomplete
1996 build_x_function_call (function
, params
, decl
)
1997 tree function
, params
, decl
;
2002 if (function
== error_mark_node
)
2003 return error_mark_node
;
2005 type
= TREE_TYPE (function
);
2006 is_method
= ((TREE_CODE (function
) == TREE_LIST
2007 && current_class_type
!= NULL_TREE
2008 && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
)) == function
)
2009 || TREE_CODE (function
) == IDENTIFIER_NODE
2010 || TREE_CODE (type
) == METHOD_TYPE
2011 || TYPE_PTRMEMFUNC_P (type
));
2013 /* Handle methods, friends, and overloaded functions, respectively. */
2016 if (TREE_CODE (function
) == FUNCTION_DECL
)
2018 if (DECL_NAME (function
))
2019 function
= DECL_NAME (function
);
2021 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2023 else if (TREE_CODE (function
) == TREE_LIST
)
2026 if (TREE_CODE (TREE_VALUE (function
)) == TREE_LIST
)
2027 function
= TREE_PURPOSE (TREE_VALUE (function
));
2029 function
= TREE_PURPOSE (function
);
2031 my_friendly_assert (TREE_CODE (TREE_VALUE (function
)) == FUNCTION_DECL
, 312);
2032 function
= TREE_PURPOSE (function
);
2035 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2037 if (TREE_CODE (function
) == OFFSET_REF
)
2039 if (TREE_OPERAND (function
, 0))
2040 decl
= TREE_OPERAND (function
, 0);
2042 /* Call via a pointer to member function. */
2043 if (decl
== NULL_TREE
)
2045 error ("pointer to member function called, but not in class scope");
2046 return error_mark_node
;
2048 /* What other type of POINTER_TYPE could this be? */
2049 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2050 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2051 && TREE_CODE (function
) != OFFSET_REF
)
2052 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
, function
);
2056 /* this is an abbreviated method call.
2057 must go through here in case it is a virtual function.
2058 @@ Perhaps this could be optimized. */
2060 if (decl
== NULL_TREE
)
2062 if (current_class_type
== NULL_TREE
)
2064 error ("object missing in call to method `%s'",
2065 IDENTIFIER_POINTER (function
));
2066 return error_mark_node
;
2068 /* Yow: call from a static member function. */
2069 decl
= build1 (NOP_EXPR
, TYPE_POINTER_TO (current_class_type
),
2071 decl
= build_indirect_ref (decl
, NULL_PTR
);
2074 return build_method_call (decl
, function
, params
,
2075 NULL_TREE
, LOOKUP_NORMAL
);
2077 else if (TREE_CODE (function
) == COMPONENT_REF
2078 && type
== unknown_type_node
)
2080 /* Should we undo what was done in build_component_ref? */
2081 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function
, 1))) == TREE_VEC
)
2082 /* Get the name that build_component_ref hid. */
2083 function
= DECL_NAME (TREE_VALUE (TREE_OPERAND (function
, 1)));
2085 function
= TREE_PURPOSE (TREE_OPERAND (function
, 1));
2086 return build_method_call (decl
, function
, params
,
2087 NULL_TREE
, LOOKUP_NORMAL
);
2089 else if (TREE_CODE (function
) == TREE_LIST
)
2091 if (TREE_VALUE (function
) == NULL_TREE
)
2093 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2094 TREE_PURPOSE (function
));
2095 return error_mark_node
;
2099 tree val
= TREE_VALUE (function
);
2101 if (TREE_CODE (val
) == TEMPLATE_DECL
)
2102 return build_overload_call_maybe
2103 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2104 else if (DECL_CHAIN (val
) != NULL_TREE
)
2105 return build_overload_call
2106 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2108 my_friendly_abort (360);
2113 if (TREE_CODE (function
) == OFFSET_REF
)
2115 /* If the component is a data element (or a virtual function), we play
2116 games here to make things work. */
2119 if (TREE_OPERAND (function
, 0))
2120 decl
= TREE_OPERAND (function
, 0);
2124 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2125 function
= get_member_function_from_ptrfunc (&decl_addr
, decl
,
2126 TREE_OPERAND (function
, 1));
2127 params
= tree_cons (NULL_TREE
, decl_addr
, params
);
2128 return build_function_call (function
, params
);
2131 type
= TREE_TYPE (function
);
2132 if (type
!= error_mark_node
)
2134 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2135 type
= TREE_TYPE (type
);
2137 if (TYPE_LANG_SPECIFIC (type
) && TYPE_OVERLOADS_CALL_EXPR (type
))
2138 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2143 tree fntype
= TREE_TYPE (function
);
2146 /* Explicitly named method? */
2147 if (TREE_CODE (function
) == FUNCTION_DECL
)
2148 ctypeptr
= TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function
));
2149 /* Expression with ptr-to-method type? It could either be a plain
2150 usage, or it might be a case where the ptr-to-method is being
2151 passed in as an argument. */
2152 else if (TYPE_PTRMEMFUNC_P (fntype
))
2154 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2155 ctypeptr
= TYPE_POINTER_TO (rec
);
2157 /* Unexpected node type? */
2159 my_friendly_abort (116);
2160 if (decl
== NULL_TREE
)
2162 if (current_function_decl
2163 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2164 error ("invalid call to member function needing `this' in static member function scope");
2166 error ("pointer to member function called, but not in class scope");
2167 return error_mark_node
;
2169 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2170 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2172 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2173 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2176 decl
= build_c_cast (ctypeptr
, decl
, 0);
2177 params
= tree_cons (NULL_TREE
, decl
, params
);
2180 return build_function_call (function
, params
);
2183 /* Resolve a pointer to member function. INSTANCE is the object
2184 instance to use, if the member points to a virtual member. */
2187 get_member_function_from_ptrfunc (instance_ptrptr
, instance
, function
)
2188 tree
*instance_ptrptr
;
2192 if (TREE_CODE (function
) == OFFSET_REF
)
2194 function
= TREE_OPERAND (function
, 1);
2197 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2199 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2200 tree index
= save_expr (build_component_ref (function
,
2203 tree e1
= build (GT_EXPR
, delta_type_node
, index
,
2204 convert (delta_type_node
, integer_zero_node
));
2205 tree delta
= convert (ptrdiff_type_node
,
2206 build_component_ref (function
, delta_identifier
, 0, 0));
2207 tree delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2212 /* convert down to the right base, before using the instance. */
2213 instance
= convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
)),
2214 build_unary_op (ADDR_EXPR
, instance
, 0));
2215 if (instance
== error_mark_node
)
2218 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2221 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2222 vtbl
, convert (ptrdiff_type_node
, delta2
));
2223 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2224 aref
= build_array_ref (vtbl
, build_binary_op (MINUS_EXPR
,
2226 integer_one_node
, 1));
2227 if (! flag_vtable_thunks
)
2229 aref
= save_expr (aref
);
2231 /* Save the intermediate result in a SAVE_EXPR so we don't have to
2232 compute each component of the virtual function pointer twice. */
2233 if (/* !building_cleanup && */ TREE_CODE (aref
) == INDIRECT_REF
)
2234 TREE_OPERAND (aref
, 0) = save_expr (TREE_OPERAND (aref
, 0));
2236 delta
= build_binary_op (PLUS_EXPR
,
2237 build_conditional_expr (e1
, build_component_ref (aref
, delta_identifier
, 0, 0), integer_zero_node
),
2241 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (*instance_ptrptr
),
2244 if (flag_vtable_thunks
)
2247 e2
= build_component_ref (aref
, pfn_identifier
, 0, 0);
2249 e3
= PFN_FROM_PTRMEMFUNC (function
);
2250 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2251 function
= build_conditional_expr (e1
, e2
, e3
);
2257 build_function_call_real (function
, params
, require_complete
, flags
)
2258 tree function
, params
;
2259 int require_complete
, flags
;
2261 register tree fntype
, fndecl
;
2262 register tree value_type
;
2263 register tree coerced_params
;
2264 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2267 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2268 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2269 if (TREE_CODE (function
) == NOP_EXPR
2270 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2271 function
= TREE_OPERAND (function
, 0);
2273 if (TREE_CODE (function
) == FUNCTION_DECL
)
2275 name
= DECL_NAME (function
);
2276 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2278 GNU_xref_call (current_function_decl
,
2279 IDENTIFIER_POINTER (name
? name
2280 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
))));
2281 assemble_external (function
);
2284 /* Convert anything with function type to a pointer-to-function. */
2287 && IDENTIFIER_LENGTH (name
) == 4
2288 && ! strcmp (IDENTIFIER_POINTER (name
), "main")
2289 && DECL_CONTEXT (function
) == NULL_TREE
)
2291 pedwarn ("ANSI C++ forbids calling `main' from within program");
2294 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2295 (because calling an inline function does not mean the function
2296 needs to be separately compiled). */
2298 if (DECL_INLINE (function
))
2300 fntype
= build_type_variant (TREE_TYPE (function
),
2301 TREE_READONLY (function
),
2302 TREE_THIS_VOLATILE (function
));
2303 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2307 assemble_external (function
);
2308 TREE_USED (function
) = 1;
2309 function
= default_conversion (function
);
2316 /* Convert anything with function type to a pointer-to-function. */
2317 if (function
== error_mark_node
)
2318 return error_mark_node
;
2319 function
= default_conversion (function
);
2322 fntype
= TREE_TYPE (function
);
2324 if (TYPE_PTRMEMFUNC_P (fntype
))
2326 tree instance_ptr
= build_unary_op (ADDR_EXPR
, C_C_D
, 0);
2327 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (fntype
);
2328 function
= get_member_function_from_ptrfunc (&instance_ptr
, C_C_D
, function
);
2331 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2332 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2334 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2335 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2338 error ("called object is not a function");
2339 return error_mark_node
;
2342 /* fntype now gets the type of function pointed to. */
2343 fntype
= TREE_TYPE (fntype
);
2345 /* Convert the parameters to the types declared in the
2346 function prototype, or apply default promotions. */
2348 if (flags
& LOOKUP_COMPLAIN
)
2349 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2350 params
, fndecl
, LOOKUP_NORMAL
);
2352 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2355 /* Check for errors in format strings. */
2357 if (warn_format
&& (name
|| assembler_name
))
2358 check_function_format (name
, assembler_name
, coerced_params
);
2360 /* Recognize certain built-in functions so we can make tree-codes
2361 other than CALL_EXPR. We do this when it enables fold-const.c
2362 to do something useful. */
2364 if (TREE_CODE (function
) == ADDR_EXPR
2365 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2366 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2367 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2372 if (coerced_params
== 0)
2373 return integer_zero_node
;
2374 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2378 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2380 register tree result
=
2381 build (CALL_EXPR
, value_type
,
2382 function
, coerced_params
, NULL_TREE
);
2384 TREE_SIDE_EFFECTS (result
) = 1;
2385 if (! require_complete
)
2387 if (value_type
== void_type_node
)
2389 return require_complete_type (result
);
2394 build_function_call (function
, params
)
2395 tree function
, params
;
2397 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2401 build_function_call_maybe (function
, params
)
2402 tree function
, params
;
2404 return build_function_call_real (function
, params
, 0, 0);
2408 /* Convert the actual parameter expressions in the list VALUES
2409 to the types in the list TYPELIST.
2410 If parmdecls is exhausted, or when an element has NULL as its type,
2411 perform the default conversions.
2413 RETURN_LOC is the location of the return value, if known, NULL_TREE
2414 otherwise. This is useful in the case where we can avoid creating
2415 a temporary variable in the case where we can initialize the return
2416 value directly. If we are not eliding constructors, then we set this
2417 to NULL_TREE to avoid this avoidance.
2419 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2421 This is also where warnings about wrong number of args are generated.
2423 Return a list of expressions for the parameters as converted.
2425 Both VALUES and the returned value are chains of TREE_LIST nodes
2426 with the elements of the list in the TREE_VALUE slots of those nodes.
2428 In C++, unspecified trailing parameters can be filled in with their
2429 default arguments, if such were specified. Do so here. */
2432 convert_arguments (return_loc
, typelist
, values
, fndecl
, flags
)
2433 tree return_loc
, typelist
, values
, fndecl
;
2436 extern tree gc_protect_fndecl
;
2437 register tree typetail
, valtail
;
2438 register tree result
= NULL_TREE
;
2442 if (! flag_elide_constructors
)
2447 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2449 if (DECL_NAME (fndecl
) == NULL_TREE
2450 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2451 called_thing
= "constructor";
2453 called_thing
= "member function";
2456 called_thing
= "function";
2459 for (valtail
= values
, typetail
= typelist
;
2461 valtail
= TREE_CHAIN (valtail
), i
++)
2463 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2464 register tree val
= TREE_VALUE (valtail
);
2466 if (type
== void_type_node
)
2470 char *buf
= (char *)alloca (40 + strlen (called_thing
));
2471 sprintf (buf
, "too many arguments to %s `%%s'", called_thing
);
2472 error_with_decl (fndecl
, buf
);
2473 error ("at this point in file");
2476 error ("too many arguments to function");
2477 /* In case anybody wants to know if this argument
2480 TREE_TYPE (tree_last (result
)) = error_mark_node
;
2484 /* The tree type of the parameter being passed may not yet be
2485 known. In this case, its type is TYPE_UNKNOWN, and will
2486 be instantiated by the type given by TYPE. If TYPE
2487 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
2488 if (type
&& type_unknown_p (val
))
2489 val
= require_instantiated_type (type
, val
, integer_zero_node
);
2490 else if (type_unknown_p (val
))
2492 /* Strip the `&' from an overloaded FUNCTION_DECL. */
2493 if (TREE_CODE (val
) == ADDR_EXPR
)
2494 val
= TREE_OPERAND (val
, 0);
2495 if (TREE_CODE (val
) == TREE_LIST
2496 && TREE_CHAIN (val
) == NULL_TREE
2497 && TREE_TYPE (TREE_VALUE (val
)) != NULL_TREE
2498 && (TREE_TYPE (val
) == unknown_type_node
2499 || DECL_CHAIN (TREE_VALUE (val
)) == NULL_TREE
))
2500 /* Instantiates automatically. */
2501 val
= TREE_VALUE (val
);
2504 error ("insufficient type information in parameter list");
2505 val
= integer_zero_node
;
2508 else if (TREE_CODE (val
) == OFFSET_REF
2509 && TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2511 /* This is unclean. Should be handled elsewhere. */
2512 val
= build_unary_op (ADDR_EXPR
, val
, 0);
2514 else if (TREE_CODE (val
) == OFFSET_REF
)
2515 val
= resolve_offset_ref (val
);
2519 /* This code forces the assumption that if we have a ptr-to-func
2520 type in an arglist, that every routine that wants to check
2521 its validity has done so, and thus we need not do any
2522 more conversion. I don't remember why this is necessary. */
2523 else if (TREE_CODE (ttype
) == FUNCTION_TYPE
2525 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
2526 || TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
))
2528 type
= build_pointer_type (ttype
);
2533 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2534 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2535 if (TREE_CODE (val
) == NOP_EXPR
2536 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
2537 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
2538 val
= TREE_OPERAND (val
, 0);
2540 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
2542 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
2543 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
2544 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2545 val
= default_conversion (val
);
2547 val
= require_complete_type (val
);
2550 if (val
== error_mark_node
)
2555 /* Formal parm type is specified by a function prototype. */
2558 if (TYPE_SIZE (type
) == 0)
2560 error ("parameter type of called function is incomplete");
2565 #if 0 && defined (PROMOTE_PROTOTYPES)
2566 /* This breaks user-defined conversions. */
2567 /* Rather than truncating and then reextending,
2568 convert directly to int, if that's the type we will want. */
2569 if (! flag_traditional
2570 && (TREE_CODE (type
) == INTEGER_TYPE
2571 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2572 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2573 type
= integer_type_node
;
2575 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2576 "argument passing", fndecl
, i
);
2577 #ifdef PROMOTE_PROTOTYPES
2578 if ((TREE_CODE (type
) == INTEGER_TYPE
2579 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2580 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2581 parmval
= default_conversion (parmval
);
2584 result
= tree_cons (NULL_TREE
, parmval
, result
);
2588 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
2589 val
= convert_from_reference (val
);
2591 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2592 && (TYPE_PRECISION (TREE_TYPE (val
))
2593 < TYPE_PRECISION (double_type_node
)))
2594 /* Convert `float' to `double'. */
2595 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2596 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
2597 && (TYPE_HAS_INIT_REF (TREE_TYPE (val
))
2598 || TYPE_HAS_ASSIGN_REF (TREE_TYPE (val
))))
2600 cp_warning ("cannot pass objects of type `%T' through `...'",
2602 result
= tree_cons (NULL_TREE
, val
, result
);
2605 /* Convert `short' and `char' to full-size `int'. */
2606 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2610 /* There are certain functions for which we don't need
2611 to protect our arguments. GC_PROTECT_FNDECL is one. */
2612 && fndecl
!= gc_protect_fndecl
2613 && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result
)))
2614 && ! value_safe_from_gc (NULL_TREE
, TREE_VALUE (result
)))
2615 /* This will build a temporary variable whose cleanup is
2616 to clear the obstack entry. */
2617 TREE_VALUE (result
) = protect_value_from_gc (NULL_TREE
,
2618 TREE_VALUE (result
));
2621 typetail
= TREE_CHAIN (typetail
);
2624 if (typetail
!= 0 && typetail
!= void_list_node
)
2626 /* See if there are default arguments that can be used */
2627 if (TREE_PURPOSE (typetail
))
2629 for (; typetail
!= void_list_node
; ++i
)
2631 tree type
= TREE_VALUE (typetail
);
2632 tree val
= TREE_PURPOSE (typetail
);
2635 if (val
== NULL_TREE
)
2636 parmval
= error_mark_node
;
2637 else if (TREE_CODE (val
) == CONSTRUCTOR
)
2639 parmval
= digest_init (type
, val
, (tree
*)0);
2640 parmval
= convert_for_initialization (return_loc
, type
, parmval
, flags
,
2641 "default constructor", fndecl
, i
);
2645 /* This could get clobbered by the following call. */
2646 if (TREE_HAS_CONSTRUCTOR (val
))
2647 val
= copy_node (val
);
2649 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2650 "default argument", fndecl
, i
);
2651 #ifdef PROMOTE_PROTOTYPES
2652 if ((TREE_CODE (type
) == INTEGER_TYPE
2653 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2654 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2655 parmval
= default_conversion (parmval
);
2660 && type_needs_gc_entry (TREE_TYPE (parmval
))
2661 && ! value_safe_from_gc (NULL_TREE
, parmval
))
2662 parmval
= protect_value_from_gc (NULL_TREE
, parmval
);
2664 result
= tree_cons (0, parmval
, result
);
2665 typetail
= TREE_CHAIN (typetail
);
2666 /* ends with `...'. */
2667 if (typetail
== NULL_TREE
)
2675 char *buf
= (char *)alloca (32 + strlen (called_thing
));
2676 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
2677 cp_error_at (buf
, fndecl
);
2678 error ("at this point in file");
2681 error ("too few arguments to function");
2682 return error_mark_list
;
2686 return nreverse (result
);
2689 /* Build a binary-operation expression, after performing default
2690 conversions on the operands. CODE is the kind of expression to build. */
2693 build_x_binary_op (code
, arg1
, arg2
)
2694 enum tree_code code
;
2697 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
,
2698 arg1
, arg2
, NULL_TREE
);
2700 return build_opfncall (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
2701 if (code
== MEMBER_REF
)
2702 return build_m_component_ref (build_indirect_ref (arg1
, NULL_PTR
),
2704 return build_binary_op (code
, arg1
, arg2
, 1);
2708 build_binary_op (code
, arg1
, arg2
, convert_p
)
2709 enum tree_code code
;
2721 args
[0] = default_conversion (args
[0]);
2722 args
[1] = default_conversion (args
[1]);
2724 if (type_unknown_p (args
[0]))
2726 args
[0] = instantiate_type (TREE_TYPE (args
[1]), args
[0], 1);
2727 args
[0] = default_conversion (args
[0]);
2729 else if (type_unknown_p (args
[1]))
2731 args
[1] = require_instantiated_type (TREE_TYPE (args
[0]),
2734 args
[1] = default_conversion (args
[1]);
2737 type1
= TREE_TYPE (args
[0]);
2738 type2
= TREE_TYPE (args
[1]);
2740 if (IS_AGGR_TYPE_2 (type1
, type2
))
2742 /* Try to convert this to something reasonable. */
2743 if (! build_default_binary_type_conversion(code
, &args
[0], &args
[1]))
2744 return error_mark_node
;
2746 else if (IS_AGGR_TYPE (type1
) || IS_AGGR_TYPE (type2
))
2748 int convert_index
= IS_AGGR_TYPE (type2
);
2749 /* Avoid being tripped up by things like (ARG1 != 0). */
2752 types
[0] = type1
; types
[1] = type2
;
2753 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
2754 try = build_type_conversion (code
, boolean_type_node
,
2755 args
[convert_index
], 1);
2758 try = build_type_conversion (code
, types
[convert_index
^ 1],
2759 args
[convert_index
], 1);
2762 && args
[1] == integer_zero_node
2763 && (code
== NE_EXPR
|| code
== EQ_EXPR
))
2764 try = build_type_conversion (code
, ptr_type_node
,
2765 args
[convert_index
], 1);
2770 cp_error ("no match for `%O(%#T, %#T)'", code
,
2771 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
2772 return error_mark_node
;
2774 if (try == error_mark_node
)
2775 error ("ambiguous pointer conversion");
2776 args
[convert_index
] = try;
2779 return build_binary_op_nodefault (code
, args
[0], args
[1], code
);
2782 /* Build a binary-operation expression without default conversions.
2783 CODE is the kind of expression to build.
2784 This function differs from `build' in several ways:
2785 the data type of the result is computed and recorded in it,
2786 warnings are generated if arg data types are invalid,
2787 special handling for addition and subtraction of pointers is known,
2788 and some optimization is done (operations on narrow ints
2789 are done in the narrower type when that gives the same result).
2790 Constant folding is also done before the result is returned.
2792 ERROR_CODE is the code that determines what to say in error messages.
2793 It is usually, but not always, the same as CODE.
2795 Note that the operands will never have enumeral types
2796 because either they have just had the default conversions performed
2797 or they have both just been converted to some other type in which
2798 the arithmetic is to be done.
2800 C++: must do special pointer arithmetic when implementing
2801 multiple inheritance, and deal with pointer to member functions. */
2804 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
2805 enum tree_code code
;
2806 tree orig_op0
, orig_op1
;
2807 enum tree_code error_code
;
2810 register enum tree_code code0
, code1
;
2813 /* Expression code to give to the expression when it is built.
2814 Normally this is CODE, which is what the caller asked for,
2815 but in some special cases we change it. */
2816 register enum tree_code resultcode
= code
;
2818 /* Data type in which the computation is to be performed.
2819 In the simplest cases this is the common type of the arguments. */
2820 register tree result_type
= NULL
;
2822 /* Nonzero means operands have already been type-converted
2823 in whatever way is necessary.
2824 Zero means they need to be converted to RESULT_TYPE. */
2827 /* Nonzero means after finally constructing the expression
2828 give it this type. Otherwise, give it type RESULT_TYPE. */
2829 tree final_type
= 0;
2831 /* Nonzero if this is an operation like MIN or MAX which can
2832 safely be computed in short if both args are promoted shorts.
2833 Also implies COMMON.
2834 -1 indicates a bitwise operation; this makes a difference
2835 in the exact conditions for when it is safe to do the operation
2836 in a narrower mode. */
2839 /* Nonzero if this is a comparison operation;
2840 if both args are promoted shorts, compare the original shorts.
2841 Also implies COMMON. */
2842 int short_compare
= 0;
2844 /* Nonzero if this is a right-shift operation, which can be computed on the
2845 original short and then promoted if the operand is a promoted short. */
2846 int short_shift
= 0;
2848 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2851 /* Apply default conversions. */
2852 op0
= default_conversion (orig_op0
);
2853 op1
= default_conversion (orig_op1
);
2855 type0
= TREE_TYPE (op0
);
2856 type1
= TREE_TYPE (op1
);
2858 /* The expression codes of the data types of the arguments tell us
2859 whether the arguments are integers, floating, pointers, etc. */
2860 code0
= TREE_CODE (type0
);
2861 code1
= TREE_CODE (type1
);
2863 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2864 STRIP_TYPE_NOPS (op0
);
2865 STRIP_TYPE_NOPS (op1
);
2867 /* If an error was already reported for one of the arguments,
2868 avoid reporting another error. */
2870 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
2871 return error_mark_node
;
2876 /* Handle the pointer + int case. */
2877 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2878 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
2879 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
2880 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
2886 /* Subtraction of two similar pointers.
2887 We must subtract them as integers, then divide by object size. */
2888 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
2889 && comp_target_types (type0
, type1
, 1))
2890 return pointer_diff (op0
, op1
);
2891 /* Handle pointer minus int. Just like pointer plus int. */
2892 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2893 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
2902 case TRUNC_DIV_EXPR
:
2904 case FLOOR_DIV_EXPR
:
2905 case ROUND_DIV_EXPR
:
2906 case EXACT_DIV_EXPR
:
2907 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2908 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2910 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
2911 cp_warning ("division by zero in `%E / 0'", op0
);
2912 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
2913 cp_warning ("division by zero in `%E / 0.'", op0
);
2915 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
2916 resultcode
= RDIV_EXPR
;
2918 /* When dividing two signed integers, we have to promote to int.
2919 unless we divide by a conatant != -1. Note that default
2920 conversion will have been performed on the operands at this
2921 point, so we have to dig out the original type to find out if
2923 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2924 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2925 || (TREE_CODE (op1
) == INTEGER_CST
2926 && (TREE_INT_CST_LOW (op1
) != -1
2927 || TREE_INT_CST_HIGH (op1
) != -1)));
2933 case BIT_ANDTC_EXPR
:
2936 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2938 /* If one operand is a constant, and the other is a short type
2939 that has been converted to an int,
2940 really do the work in the short type and then convert the
2941 result to int. If we are lucky, the constant will be 0 or 1
2942 in the short type, making the entire operation go away. */
2943 if (TREE_CODE (op0
) == INTEGER_CST
2944 && TREE_CODE (op1
) == NOP_EXPR
2945 && TYPE_PRECISION (type1
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))
2946 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
2948 final_type
= result_type
;
2949 op1
= TREE_OPERAND (op1
, 0);
2950 result_type
= TREE_TYPE (op1
);
2952 if (TREE_CODE (op1
) == INTEGER_CST
2953 && TREE_CODE (op0
) == NOP_EXPR
2954 && TYPE_PRECISION (type0
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))
2955 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2957 final_type
= result_type
;
2958 op0
= TREE_OPERAND (op0
, 0);
2959 result_type
= TREE_TYPE (op0
);
2963 case TRUNC_MOD_EXPR
:
2964 case FLOOR_MOD_EXPR
:
2965 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
2966 cp_warning ("division by zero in `%E % 0'", op0
);
2967 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
2968 cp_warning ("division by zero in `%E % 0.'", op0
);
2970 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2972 /* Although it would be tempting to shorten always here, that loses
2973 on some targets, since the modulo instruction is undefined if the
2974 quotient can't be represented in the computation mode. We shorten
2975 only if unsigned or if dividing by something we know != -1. */
2976 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2977 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2978 || (TREE_CODE (op1
) == INTEGER_CST
2979 && (TREE_INT_CST_LOW (op1
) != -1
2980 || TREE_INT_CST_HIGH (op1
) != -1)));
2985 case TRUTH_ANDIF_EXPR
:
2986 case TRUTH_ORIF_EXPR
:
2987 case TRUTH_AND_EXPR
:
2989 result_type
= boolean_type_node
;
2990 op0
= bool_truthvalue_conversion (op0
);
2991 op1
= bool_truthvalue_conversion (op1
);
2995 /* Shift operations: result has same type as first operand;
2996 always convert second operand to int.
2997 Also set SHORT_SHIFT if shifting rightward. */
3000 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3002 result_type
= type0
;
3003 if (TREE_CODE (op1
) == INTEGER_CST
)
3005 if (tree_int_cst_lt (op1
, integer_zero_node
))
3006 warning ("right shift count is negative");
3009 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3011 if (TREE_INT_CST_HIGH (op1
) != 0
3012 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3013 >= TYPE_PRECISION (type0
)))
3014 warning ("right shift count >= width of type");
3017 /* Convert the shift-count to an integer, regardless of
3018 size of value being shifted. */
3019 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3020 op1
= convert (integer_type_node
, op1
);
3021 /* Avoid converting op1 to result_type later. */
3027 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3029 result_type
= type0
;
3030 if (TREE_CODE (op1
) == INTEGER_CST
)
3032 if (tree_int_cst_lt (op1
, integer_zero_node
))
3033 warning ("left shift count is negative");
3034 else if (TREE_INT_CST_HIGH (op1
) != 0
3035 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3036 >= TYPE_PRECISION (type0
)))
3037 warning ("left shift count >= width of type");
3039 /* Convert the shift-count to an integer, regardless of
3040 size of value being shifted. */
3041 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3042 op1
= convert (integer_type_node
, op1
);
3043 /* Avoid converting op1 to result_type later. */
3050 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3052 result_type
= type0
;
3053 if (TREE_CODE (op1
) == INTEGER_CST
)
3055 if (tree_int_cst_lt (op1
, integer_zero_node
))
3056 warning ("%s rotate count is negative",
3057 (code
== LROTATE_EXPR
) ? "left" : "right");
3058 else if (TREE_INT_CST_HIGH (op1
) != 0
3059 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3060 >= TYPE_PRECISION (type0
)))
3061 warning ("%s rotate count >= width of type",
3062 (code
== LROTATE_EXPR
) ? "left" : "right");
3064 /* Convert the shift-count to an integer, regardless of
3065 size of value being shifted. */
3066 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3067 op1
= convert (integer_type_node
, op1
);
3073 result_type
= boolean_type_node
;
3075 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3076 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3078 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3080 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3081 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3082 /* Anything compares with void *. void * compares with anything.
3083 Otherwise, the targets must be the same. */
3084 if (tt0
!= tt1
&& TREE_CODE (tt0
) == RECORD_TYPE
3085 && TREE_CODE (tt1
) == RECORD_TYPE
)
3087 tree base
= common_base_type (tt0
, tt1
);
3088 if (base
== NULL_TREE
)
3089 cp_warning ("comparison of distinct object pointer types `%T' and `%T'", type0
, type1
);
3090 else if (base
== error_mark_node
)
3092 cp_error ("comparison of pointer types `%T' and `%T' requires conversion to ambiguous supertype", type0
, type1
);
3093 return error_mark_node
;
3097 if (integer_zerop (op0
))
3098 op0
= null_pointer_node
;
3100 op0
= convert_pointer_to (base
, op0
);
3101 if (integer_zerop (op1
))
3102 op1
= null_pointer_node
;
3104 op1
= convert_pointer_to (base
, op1
);
3107 else if (comp_target_types (type0
, type1
, 1))
3109 else if (tt0
== void_type_node
)
3111 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3112 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3113 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3115 else if (tt1
== void_type_node
)
3117 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3118 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3119 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3121 else if ((TYPE_SIZE (tt0
) != 0) != (TYPE_SIZE (tt1
) != 0))
3122 cp_pedwarn ("comparison of %scomplete and %scomplete pointers `%T' and `%T'",
3123 TYPE_SIZE (tt0
) == 0 ? "in" : "",
3124 TYPE_SIZE (tt1
) == 0 ? "in" : "",
3127 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3130 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3131 && integer_zerop (op1
))
3132 op1
= null_pointer_node
;
3133 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3134 && integer_zerop (op0
))
3135 op0
= null_pointer_node
;
3136 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3138 error ("ANSI C++ forbids comparison between pointer and integer");
3139 op1
= convert (TREE_TYPE (op0
), op1
);
3141 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3143 error ("ANSI C++ forbids comparison between pointer and integer");
3144 op0
= convert (TREE_TYPE (op1
), op0
);
3146 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3147 && integer_zerop (op1
))
3149 op0
= build_component_ref (op0
, index_identifier
, 0, 0);
3150 op1
= integer_zero_node
;
3152 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3153 && integer_zerop (op0
))
3155 op0
= build_component_ref (op1
, index_identifier
, 0, 0);
3156 op1
= integer_zero_node
;
3158 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3159 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3160 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3162 /* The code we generate for the test is:
3164 (op0.index == op1.index
3165 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3166 || op0.pfn == op1.pfn)) */
3168 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3169 tree index1
= save_expr (build_component_ref (op1
, index_identifier
, 0, 0));
3170 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3171 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3172 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3173 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3175 tree integer_neg_one_node
3176 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3177 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3178 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3179 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3180 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3181 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3182 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3183 if (code
== EQ_EXPR
)
3185 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3187 else if (TYPE_PTRMEMFUNC_P (type0
)
3188 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3190 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3192 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3193 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3194 tree delta21
= integer_zero_node
;
3196 tree integer_neg_one_node
3197 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3198 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3199 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3201 /* Map everything down one to make room for the null pointer to member. */
3202 index1
= size_binop (PLUS_EXPR
,
3203 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3205 op1
= integer_zero_node
;
3206 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1
)));
3207 delta21
= DECL_FIELD_BITPOS (delta21
);
3208 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
, size_int (BITS_PER_UNIT
));
3211 index1
= integer_neg_one_node
;
3213 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
), op1
);
3214 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3217 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3218 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3219 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3220 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3221 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3222 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3223 if (code
== EQ_EXPR
)
3225 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3227 else if (TYPE_PTRMEMFUNC_P (type1
)
3228 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3230 return build_binary_op (code
, op1
, op0
, 1);
3233 /* If args are not valid, clear out RESULT_TYPE
3234 to cause an error message later. */
3240 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3241 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3243 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3245 if (! comp_target_types (type0
, type1
, 1))
3246 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3248 else if ((TYPE_SIZE (TREE_TYPE (type0
)) != 0)
3249 != (TYPE_SIZE (TREE_TYPE (type1
)) != 0))
3250 cp_pedwarn ("comparison of %scomplete and %scomplete pointers",
3251 TYPE_SIZE (TREE_TYPE (type0
)) == 0 ? "in" : "",
3252 TYPE_SIZE (TREE_TYPE (type1
)) == 0 ? "in" : "",
3255 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
3256 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3257 result_type
= common_type (type0
, type1
);
3265 result_type
= boolean_type_node
;
3266 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3267 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3269 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3271 if (! comp_target_types (type0
, type1
, 1))
3272 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3274 else if ((TYPE_SIZE (TREE_TYPE (type0
)) != 0)
3275 != (TYPE_SIZE (TREE_TYPE (type1
)) != 0))
3276 cp_pedwarn ("comparison of %scomplete and %scomplete pointers",
3277 TYPE_SIZE (TREE_TYPE (type0
)) == 0 ? "in" : "",
3278 TYPE_SIZE (TREE_TYPE (type1
)) == 0 ? "in" : "",
3281 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
3282 pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
3284 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3285 && integer_zerop (op1
))
3287 op1
= null_pointer_node
;
3289 pedwarn ("ordered comparison of pointer with integer zero");
3291 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3292 && integer_zerop (op0
))
3294 op0
= null_pointer_node
;
3296 pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
3298 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3301 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3302 else if (! flag_traditional
)
3303 warning ("comparison between pointer and integer");
3304 op1
= convert (TREE_TYPE (op0
), op1
);
3306 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3309 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3310 else if (! flag_traditional
)
3311 warning ("comparison between pointer and integer");
3312 op0
= convert (TREE_TYPE (op1
), op0
);
3320 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3321 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3323 if (shorten
|| common
|| short_compare
)
3324 result_type
= common_type (type0
, type1
);
3326 /* For certain operations (which identify themselves by shorten != 0)
3327 if both args were extended from the same smaller type,
3328 do the arithmetic in that type and then extend.
3330 shorten !=0 and !=1 indicates a bitwise operation.
3331 For them, this optimization is safe only if
3332 both args are zero-extended or both are sign-extended.
3333 Otherwise, we might change the result.
3334 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3335 but calculated in (unsigned short) it would be (unsigned short)-1. */
3339 int unsigned0
, unsigned1
;
3340 tree arg0
= get_narrower (op0
, &unsigned0
);
3341 tree arg1
= get_narrower (op1
, &unsigned1
);
3342 /* UNS is 1 if the operation to be done is an unsigned one. */
3343 int uns
= TREE_UNSIGNED (result_type
);
3346 final_type
= result_type
;
3348 /* Handle the case that OP0 does not *contain* a conversion
3349 but it *requires* conversion to FINAL_TYPE. */
3351 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3352 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3353 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3354 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3356 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3358 /* For bitwise operations, signedness of nominal type
3359 does not matter. Consider only how operands were extended. */
3363 /* Note that in all three cases below we refrain from optimizing
3364 an unsigned operation on sign-extended args.
3365 That would not be valid. */
3367 /* Both args variable: if both extended in same way
3368 from same width, do it in that width.
3369 Do it unsigned if args were zero-extended. */
3370 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3371 < TYPE_PRECISION (result_type
))
3372 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3373 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3374 && unsigned0
== unsigned1
3375 && (unsigned0
|| !uns
))
3377 = signed_or_unsigned_type (unsigned0
,
3378 common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
3379 else if (TREE_CODE (arg0
) == INTEGER_CST
3380 && (unsigned1
|| !uns
)
3381 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3382 < TYPE_PRECISION (result_type
))
3383 && (type
= signed_or_unsigned_type (unsigned1
,
3385 int_fits_type_p (arg0
, type
)))
3387 else if (TREE_CODE (arg1
) == INTEGER_CST
3388 && (unsigned0
|| !uns
)
3389 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3390 < TYPE_PRECISION (result_type
))
3391 && (type
= signed_or_unsigned_type (unsigned0
,
3393 int_fits_type_p (arg1
, type
)))
3397 /* Shifts can be shortened if shifting right. */
3402 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3404 final_type
= result_type
;
3406 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3407 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3409 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3410 /* We can shorten only if the shift count is less than the
3411 number of bits in the smaller type size. */
3412 && TREE_INT_CST_HIGH (op1
) == 0
3413 && TYPE_PRECISION (TREE_TYPE (arg0
)) > TREE_INT_CST_LOW (op1
)
3414 /* If arg is sign-extended and then unsigned-shifted,
3415 we can simulate this with a signed shift in arg's type
3416 only if the extended result is at least twice as wide
3417 as the arg. Otherwise, the shift could use up all the
3418 ones made by sign-extension and bring in zeros.
3419 We can't optimize that case at all, but in most machines
3420 it never happens because available widths are 2**N. */
3421 && (!TREE_UNSIGNED (final_type
)
3423 || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
))
3424 <= TYPE_PRECISION (result_type
))))
3426 /* Do an unsigned shift if the operand was zero-extended. */
3428 = signed_or_unsigned_type (unsigned_arg
,
3430 /* Convert value-to-be-shifted to that type. */
3431 if (TREE_TYPE (op0
) != result_type
)
3432 op0
= convert (result_type
, op0
);
3437 /* Comparison operations are shortened too but differently.
3438 They identify themselves by setting short_compare = 1. */
3442 /* Don't write &op0, etc., because that would prevent op0
3443 from being kept in a register.
3444 Instead, make copies of the our local variables and
3445 pass the copies by reference, then copy them back afterward. */
3446 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3447 enum tree_code xresultcode
= resultcode
;
3449 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3451 return convert (boolean_type_node
, val
);
3452 op0
= xop0
, op1
= xop1
, result_type
= boolean_type_node
;
3453 resultcode
= xresultcode
;
3456 if (short_compare
&& extra_warnings
)
3458 int unsignedp0
, unsignedp1
;
3459 tree primop0
= get_narrower (op0
, &unsignedp0
);
3460 tree primop1
= get_narrower (op1
, &unsignedp1
);
3462 /* Warn if signed and unsigned are being compared in a size larger
3463 than their original size, as this will always fail. */
3465 if (unsignedp0
!= unsignedp1
3466 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3467 < TYPE_PRECISION (result_type
))
3468 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3469 < TYPE_PRECISION (result_type
)))
3470 warning ("comparison between promoted unsigned and signed");
3472 /* Warn if two unsigned values are being compared in a size
3473 larger than their original size, and one (and only one) is the
3474 result of a `~' operator. This comparison will always fail.
3476 Also warn if one operand is a constant, and the constant does not
3477 have all bits set that are set in the ~ operand when it is
3480 else if (TREE_CODE (primop0
) == BIT_NOT_EXPR
3481 ^ TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3483 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3484 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3485 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3486 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3488 if (TREE_CODE (primop0
) == INTEGER_CST
3489 || TREE_CODE (primop1
) == INTEGER_CST
)
3492 HOST_WIDE_INT constant
, mask
;
3496 if (TREE_CODE (primop0
) == INTEGER_CST
)
3499 unsignedp
= unsignedp1
;
3500 constant
= TREE_INT_CST_LOW (primop0
);
3505 unsignedp
= unsignedp0
;
3506 constant
= TREE_INT_CST_LOW (primop1
);
3509 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3510 if (bits
< TYPE_PRECISION (result_type
)
3511 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3513 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3514 if ((mask
& constant
) != mask
)
3515 warning ("comparison of promoted ~unsigned with constant");
3518 else if (unsignedp0
&& unsignedp1
3519 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3520 < TYPE_PRECISION (result_type
))
3521 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3522 < TYPE_PRECISION (result_type
)))
3523 warning ("comparison of promoted ~unsigned with unsigned");
3528 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3529 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3530 Then the expression will be built.
3531 It will be given type FINAL_TYPE if that is nonzero;
3532 otherwise, it will be given type RESULT_TYPE. */
3536 binary_op_error (error_code
);
3537 return error_mark_node
;
3542 if (TREE_TYPE (op0
) != result_type
)
3543 op0
= convert (result_type
, op0
);
3544 if (TREE_TYPE (op1
) != result_type
)
3545 op1
= convert (result_type
, op1
);
3549 register tree result
= build (resultcode
, result_type
, op0
, op1
);
3550 register tree folded
;
3552 folded
= fold (result
);
3553 if (folded
== result
)
3554 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3555 if (final_type
!= 0)
3556 return convert (final_type
, folded
);
3561 /* Return a tree for the sum or difference (RESULTCODE says which)
3562 of pointer PTROP and integer INTOP. */
3565 pointer_int_sum (resultcode
, ptrop
, intop
)
3566 enum tree_code resultcode
;
3567 register tree ptrop
, intop
;
3571 register tree result
;
3572 register tree folded
= fold (intop
);
3574 /* The result is a pointer of the same type that is being added. */
3576 register tree result_type
= TREE_TYPE (ptrop
);
3578 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3580 if (pedantic
|| warn_pointer_arith
)
3581 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3582 size_exp
= integer_one_node
;
3584 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3586 if (pedantic
|| warn_pointer_arith
)
3587 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3588 size_exp
= integer_one_node
;
3590 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3592 if (pedantic
|| warn_pointer_arith
)
3593 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
3594 size_exp
= integer_one_node
;
3596 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
3599 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
3600 size_exp
= integer_one_node
;
3603 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3605 /* Needed to make OOPS V2R3 work. */
3607 if (TREE_CODE (intop
) == INTEGER_CST
3608 && TREE_INT_CST_LOW (intop
) == 0
3609 && TREE_INT_CST_HIGH (intop
) == 0)
3612 /* If what we are about to multiply by the size of the elements
3613 contains a constant term, apply distributive law
3614 and multiply that constant term separately.
3615 This helps produce common subexpressions. */
3617 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3618 && ! TREE_CONSTANT (intop
)
3619 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3620 && TREE_CONSTANT (size_exp
))
3622 enum tree_code subcode
= resultcode
;
3623 if (TREE_CODE (intop
) == MINUS_EXPR
)
3624 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3625 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
3626 intop
= TREE_OPERAND (intop
, 0);
3629 /* Convert the integer argument to a type the same size as a pointer
3630 so the multiply won't overflow spuriously. */
3632 if (TYPE_PRECISION (TREE_TYPE (intop
)) != POINTER_SIZE
)
3633 intop
= convert (type_for_size (POINTER_SIZE
, 0), intop
);
3635 /* Replace the integer argument with a suitable product by the object size.
3636 Do this multiplication as signed, then convert to the appropriate
3637 pointer type (actually unsigned integral). */
3639 intop
= convert (result_type
,
3640 build_binary_op (MULT_EXPR
, intop
,
3641 convert (TREE_TYPE (intop
), size_exp
), 1));
3643 /* Create the sum or difference. */
3645 result
= build (resultcode
, result_type
, ptrop
, intop
);
3647 folded
= fold (result
);
3648 if (folded
== result
)
3649 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
3653 /* Return a tree for the difference of pointers OP0 and OP1.
3654 The resulting tree has type int. */
3657 pointer_diff (op0
, op1
)
3658 register tree op0
, op1
;
3660 register tree result
, folded
;
3661 tree restype
= ptrdiff_type_node
;
3662 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3666 if (TREE_CODE (target_type
) == VOID_TYPE
)
3667 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
3668 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3669 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
3670 if (TREE_CODE (target_type
) == METHOD_TYPE
)
3671 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
3672 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
3673 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
3676 /* First do the subtraction as integers;
3677 then drop through to build the divide operator. */
3679 op0
= build_binary_op (MINUS_EXPR
,
3680 convert (restype
, op0
), convert (restype
, op1
), 1);
3682 /* This generates an error if op1 is a pointer to an incomplete type. */
3683 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
3684 error ("arithmetic on pointer to an incomplete type");
3686 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
3687 || TREE_CODE (target_type
) == FUNCTION_TYPE
3688 || TREE_CODE (target_type
) == METHOD_TYPE
3689 || TREE_CODE (target_type
) == OFFSET_TYPE
)
3691 : size_in_bytes (target_type
));
3693 /* Do the division. */
3695 result
= build (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
));
3697 folded
= fold (result
);
3698 if (folded
== result
)
3699 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3703 /* Handle the case of taking the address of a COMPONENT_REF.
3704 Called by `build_unary_op' and `build_up_reference'.
3706 ARG is the COMPONENT_REF whose address we want.
3707 ARGTYPE is the pointer type that this address should have.
3708 MSG is an error message to print if this COMPONENT_REF is not
3709 addressable (such as a bitfield). */
3712 build_component_addr (arg
, argtype
, msg
)
3716 tree field
= TREE_OPERAND (arg
, 1);
3717 tree basetype
= decl_type_context (field
);
3718 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
3720 if (DECL_BIT_FIELD (field
))
3722 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
3723 return error_mark_node
;
3727 cp_warning ("address of `%T::%D' taken", basetype
, field
);
3729 if (TREE_CODE (field
) == FIELD_DECL
3730 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
3732 /* Can't convert directly to ARGTYPE, since that
3733 may have the same pointer type as one of our
3735 rval
= build1 (NOP_EXPR
, argtype
,
3736 convert_pointer_to (basetype
, rval
));
3737 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
3740 /* This conversion is harmless. */
3741 rval
= convert_force (argtype
, rval
, 0);
3743 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
3745 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
3746 size_int (BITS_PER_UNIT
));
3747 int flag
= TREE_CONSTANT (rval
);
3748 rval
= fold (build (PLUS_EXPR
, argtype
,
3749 rval
, convert (argtype
, offset
)));
3750 TREE_CONSTANT (rval
) = flag
;
3755 /* Construct and perhaps optimize a tree representation
3756 for a unary operation. CODE, a tree_code, specifies the operation
3757 and XARG is the operand. */
3760 build_x_unary_op (code
, xarg
)
3761 enum tree_code code
;
3764 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3766 if (code
== ADDR_EXPR
3767 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
3768 && TYPE_SIZE (TREE_TYPE (xarg
)) == NULL_TREE
)
3769 || (TREE_CODE (xarg
) == OFFSET_REF
)))
3770 /* don't look for a function */;
3773 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
, xarg
,
3774 NULL_TREE
, NULL_TREE
);
3776 return build_opfncall (code
, LOOKUP_NORMAL
, xarg
,
3777 NULL_TREE
, NULL_TREE
);
3779 return build_unary_op (code
, xarg
, 0);
3782 /* Just like truthvalue_conversion, but we want a BOOLEAN_TYPE */
3784 bool_truthvalue_conversion (expr
)
3787 /* We really want to preform the optimizations in truthvalue_conversion
3788 but, not this way. */
3789 /* expr = truthvalue_conversion (expr); */
3790 return convert (boolean_type_node
, expr
);
3793 /* C++: Must handle pointers to members.
3795 Perhaps type instantiation should be extended to handle conversion
3796 from aggregates to types we don't yet know we want? (Or are those
3797 cases typically errors which should be reported?)
3799 NOCONVERT nonzero suppresses the default promotions
3800 (such as from short to int). */
3802 build_unary_op (code
, xarg
, noconvert
)
3803 enum tree_code code
;
3807 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3808 register tree arg
= xarg
;
3809 register tree argtype
= 0;
3810 register enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
3811 char *errstring
= NULL
;
3815 if (typecode
== ERROR_MARK
)
3816 return error_mark_node
;
3818 if (typecode
== REFERENCE_TYPE
&& code
!= ADDR_EXPR
&& ! noconvert
)
3820 arg
= convert_from_reference (arg
);
3821 typecode
= TREE_CODE (TREE_TYPE (arg
));
3824 if (typecode
== ENUMERAL_TYPE
)
3825 typecode
= INTEGER_TYPE
;
3827 if (typecode
== BOOLEAN_TYPE
&& ! noconvert
)
3828 typecode
= INTEGER_TYPE
;
3830 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3835 /* This is used for unary plus, because a CONVERT_EXPR
3836 is enough to prevent anybody from looking inside for
3837 associativity, but won't generate any code. */
3838 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3839 errstring
= "wrong type argument to unary plus";
3840 else if (!noconvert
)
3841 arg
= default_conversion (arg
);
3842 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
3846 if (typecode
== OFFSET_TYPE
)
3848 arg
= resolve_offset_ref (arg
);
3849 typecode
= TREE_CODE (TREE_TYPE (arg
));
3850 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3856 arg
= default_conversion (arg
);
3859 cp_error ("type conversion for type `%T' not allowed",
3861 return error_mark_node
;
3863 typecode
= TREE_CODE (TREE_TYPE (arg
));
3867 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3868 errstring
= "wrong type argument to unary minus";
3869 else if (!noconvert
)
3870 arg
= default_conversion (arg
);
3874 if (typecode
== OFFSET_TYPE
)
3876 arg
= resolve_offset_ref (arg
);
3877 typecode
= TREE_CODE (TREE_TYPE (arg
));
3878 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3884 arg
= default_conversion (arg
);
3887 cp_error ("type conversion for type `%T' not allowed",
3889 return error_mark_node
;
3891 typecode
= TREE_CODE (TREE_TYPE (arg
));
3895 if (typecode
!= INTEGER_TYPE
)
3896 errstring
= "wrong type argument to bit-complement";
3897 else if (!noconvert
)
3898 arg
= default_conversion (arg
);
3902 if (typecode
== OFFSET_TYPE
)
3904 arg
= resolve_offset_ref (arg
);
3905 typecode
= TREE_CODE (TREE_TYPE (arg
));
3906 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3912 arg
= default_conversion (arg
);
3915 cp_error ("type conversion for type `%T' not allowed",
3917 return error_mark_node
;
3919 typecode
= TREE_CODE (TREE_TYPE (arg
));
3923 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3924 errstring
= "wrong type argument to abs";
3925 else if (!noconvert
)
3926 arg
= default_conversion (arg
);
3929 case TRUTH_NOT_EXPR
:
3930 arg
= bool_truthvalue_conversion (arg
);
3931 val
= invert_truthvalue (arg
);
3932 if (arg
!= error_mark_node
)
3934 errstring
= "in argument to unary !";
3940 case PREINCREMENT_EXPR
:
3941 case POSTINCREMENT_EXPR
:
3942 case PREDECREMENT_EXPR
:
3943 case POSTDECREMENT_EXPR
:
3944 /* Handle complex lvalues (when permitted)
3945 by reduction to simpler cases. */
3947 val
= unary_complex_lvalue (code
, arg
);
3951 /* Report invalid types. */
3953 if (typecode
== OFFSET_TYPE
)
3955 arg
= resolve_offset_ref (arg
);
3956 typecode
= TREE_CODE (TREE_TYPE (arg
));
3957 isaggrtype
= IS_AGGR_TYPE_CODE (typecode
);
3962 arg
= default_conversion (arg
);
3963 typecode
= TREE_CODE (TREE_TYPE (arg
));
3966 if (typecode
!= POINTER_TYPE
3967 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
3969 if (code
== PREINCREMENT_EXPR
)
3970 errstring
="no pre-increment operator for type";
3971 else if (code
== POSTINCREMENT_EXPR
)
3972 errstring
="no post-increment operator for type";
3973 else if (code
== PREDECREMENT_EXPR
)
3974 errstring
="no pre-decrement operator for type";
3976 errstring
="no post-decrement operator for type";
3980 /* Report something read-only. */
3982 if (TYPE_READONLY (TREE_TYPE (arg
))
3983 || TREE_READONLY (arg
))
3984 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
3985 || code
== POSTINCREMENT_EXPR
)
3986 ? "increment" : "decrement"),
3991 tree result_type
= TREE_TYPE (arg
);
3993 arg
= get_unwidened (arg
, 0);
3994 argtype
= TREE_TYPE (arg
);
3996 /* ARM $5.2.5 last annotation says this should be forbidden. */
3997 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
3998 pedwarn ("ANSI C++ forbids %sing an enum",
3999 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4000 ? "increment" : "decrement");
4002 /* Compute the increment. */
4004 if (typecode
== POINTER_TYPE
)
4006 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
4007 if (TYPE_SIZE (TREE_TYPE (argtype
)) == 0)
4008 cp_error ("cannot %s a pointer to incomplete type `%T'",
4009 ((code
== PREINCREMENT_EXPR
4010 || code
== POSTINCREMENT_EXPR
)
4011 ? "increment" : "decrement"), TREE_TYPE (argtype
));
4012 else if (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
4013 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
)
4014 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
4015 ((code
== PREINCREMENT_EXPR
4016 || code
== POSTINCREMENT_EXPR
)
4017 ? "increment" : "decrement"), argtype
);
4018 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
4021 inc
= integer_one_node
;
4023 inc
= convert (argtype
, inc
);
4025 /* Handle incrementing a cast-expression. */
4027 switch (TREE_CODE (arg
))
4032 case FIX_TRUNC_EXPR
:
4033 case FIX_FLOOR_EXPR
:
4034 case FIX_ROUND_EXPR
:
4037 tree incremented
, modify
, value
;
4038 if (! lvalue_p (arg
) && pedantic
)
4039 pedwarn ("cast to non-reference type used as lvalue");
4040 arg
= stabilize_reference (arg
);
4041 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4044 value
= save_expr (arg
);
4045 incremented
= build (((code
== PREINCREMENT_EXPR
4046 || code
== POSTINCREMENT_EXPR
)
4047 ? PLUS_EXPR
: MINUS_EXPR
),
4048 argtype
, value
, inc
);
4049 TREE_SIDE_EFFECTS (incremented
) = 1;
4050 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4051 return build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4055 /* Complain about anything else that is not a true lvalue. */
4056 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4057 || code
== POSTINCREMENT_EXPR
)
4058 ? "increment" : "decrement")))
4059 return error_mark_node
;
4061 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4062 TREE_SIDE_EFFECTS (val
) = 1;
4063 return convert (result_type
, val
);
4067 /* Note that this operation never does default_conversion
4068 regardless of NOCONVERT. */
4070 if (typecode
== REFERENCE_TYPE
)
4072 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4073 TREE_REFERENCE_EXPR (arg
) = 1;
4077 && TREE_CODE (arg
) == FUNCTION_DECL
4079 && DECL_CONTEXT (arg
) == NULL_TREE
4080 && IDENTIFIER_LENGTH (DECL_NAME (arg
)) == 4
4081 && IDENTIFIER_POINTER (DECL_NAME (arg
))[0] == 'm'
4082 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg
)), "main"))
4084 pedwarn ("taking address of function `main'");
4086 /* Let &* cancel out to simplify resulting code. */
4087 if (TREE_CODE (arg
) == INDIRECT_REF
)
4089 /* We don't need to have `current_class_decl' wrapped in a
4090 NON_LVALUE_EXPR node. */
4092 return current_class_decl
;
4094 /* Keep `default_conversion' from converting if
4095 ARG is of REFERENCE_TYPE. */
4096 arg
= TREE_OPERAND (arg
, 0);
4097 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4099 if (TREE_CODE (arg
) == VAR_DECL
&& DECL_INITIAL (arg
)
4100 && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg
)))
4101 arg
= DECL_INITIAL (arg
);
4102 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4103 TREE_REFERENCE_EXPR (arg
) = 1;
4104 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4106 else if (lvalue_p (arg
))
4107 /* Don't let this be an lvalue. */
4108 return non_lvalue (arg
);
4112 /* For &x[y], return x+y */
4113 if (TREE_CODE (arg
) == ARRAY_REF
)
4115 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4116 return error_mark_node
;
4117 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4118 TREE_OPERAND (arg
, 1), 1);
4121 /* For &(++foo), we are really taking the address of the variable
4122 being acted upon by the increment/decrement operator. ARM $5.3.1
4123 However, according to ARM $5.2.5, we don't allow postfix ++ and
4124 --, since the prefix operators return lvalues, but the postfix
4125 operators do not. */
4126 if (TREE_CODE (arg
) == PREINCREMENT_EXPR
4127 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4128 arg
= TREE_OPERAND (arg
, 0);
4130 /* Uninstantiated types are all functions. Taking the
4131 address of a function is a no-op, so just return the
4134 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4135 && IDENTIFIER_OPNAME_P (arg
))
4137 my_friendly_abort (117);
4138 /* We don't know the type yet, so just work around the problem.
4139 We know that this will resolve to an lvalue. */
4140 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4143 if (TREE_CODE (arg
) == TREE_LIST
)
4145 if (TREE_CODE (TREE_VALUE (arg
)) == FUNCTION_DECL
4146 && DECL_CHAIN (TREE_VALUE (arg
)) == NULL_TREE
)
4147 /* Unique overloaded non-member function. */
4148 return build_unary_op (ADDR_EXPR
, TREE_VALUE (arg
), 0);
4149 if (TREE_CHAIN (arg
) == NULL_TREE
4150 && TREE_CODE (TREE_VALUE (arg
)) == TREE_LIST
4151 && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg
))) == NULL_TREE
)
4152 /* Unique overloaded member function. */
4153 return build_unary_op (ADDR_EXPR
, TREE_VALUE (TREE_VALUE (arg
)),
4155 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4158 /* Handle complex lvalues (when permitted)
4159 by reduction to simpler cases. */
4160 val
= unary_complex_lvalue (code
, arg
);
4164 switch (TREE_CODE (arg
))
4169 case FIX_TRUNC_EXPR
:
4170 case FIX_FLOOR_EXPR
:
4171 case FIX_ROUND_EXPR
:
4173 if (! lvalue_p (arg
) && pedantic
)
4174 pedwarn ("taking the address of a cast to non-reference type");
4177 /* Allow the address of a constructor if all the elements
4179 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_CONSTANT (arg
))
4181 /* Anything not already handled and not a true memory reference
4183 else if (typecode
!= FUNCTION_TYPE
4184 && typecode
!= METHOD_TYPE
4185 && !lvalue_or_else (arg
, "unary `&'"))
4186 return error_mark_node
;
4188 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4189 argtype
= TREE_TYPE (arg
);
4190 /* If the lvalue is const or volatile,
4191 merge that into the type that the address will point to. */
4192 if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'd'
4193 || TREE_CODE_CLASS (TREE_CODE (arg
)) == 'r')
4195 if (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4196 argtype
= cp_build_type_variant (argtype
,
4197 TREE_READONLY (arg
),
4198 TREE_THIS_VOLATILE (arg
));
4201 argtype
= build_pointer_type (argtype
);
4203 if (mark_addressable (arg
) == 0)
4204 return error_mark_node
;
4209 if (TREE_CODE (arg
) == COMPONENT_REF
)
4210 addr
= build_component_addr (arg
, argtype
,
4211 "attempt to take address of bit-field structure member `%s'");
4213 addr
= build1 (code
, argtype
, arg
);
4215 /* Address of a static or external variable or
4216 function counts as a constant */
4218 TREE_CONSTANT (addr
) = 1;
4226 argtype
= TREE_TYPE (arg
);
4227 return fold (build1 (code
, argtype
, arg
));
4231 return error_mark_node
;
4234 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4235 convert ARG with the same conversions in the same order
4236 and return the result. */
4239 convert_sequence (conversions
, arg
)
4243 switch (TREE_CODE (conversions
))
4248 case FIX_TRUNC_EXPR
:
4249 case FIX_FLOOR_EXPR
:
4250 case FIX_ROUND_EXPR
:
4252 return convert (TREE_TYPE (conversions
),
4253 convert_sequence (TREE_OPERAND (conversions
, 0),
4261 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4262 for certain kinds of expressions which are not really lvalues
4263 but which we can accept as lvalues.
4265 If ARG is not a kind of expression we can handle, return zero. */
4268 unary_complex_lvalue (code
, arg
)
4269 enum tree_code code
;
4272 /* Handle (a, b) used as an "lvalue". */
4273 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4275 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4276 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4277 TREE_OPERAND (arg
, 0), real_result
);
4280 /* Handle (a ? b : c) used as an "lvalue". */
4281 if (TREE_CODE (arg
) == COND_EXPR
)
4282 return rationalize_conditional_expr (code
, arg
);
4284 if (TREE_CODE (arg
) == MODIFY_EXPR
4285 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4286 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4287 return unary_complex_lvalue
4288 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4289 arg
, TREE_OPERAND (arg
, 0)));
4291 if (code
!= ADDR_EXPR
)
4294 /* Handle (a = b) used as an "lvalue" for `&'. */
4295 if (TREE_CODE (arg
) == MODIFY_EXPR
4296 || TREE_CODE (arg
) == INIT_EXPR
)
4298 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4299 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4302 if (TREE_CODE (arg
) == WITH_CLEANUP_EXPR
)
4304 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4305 real_result
= build (WITH_CLEANUP_EXPR
, TREE_TYPE (real_result
),
4306 real_result
, 0, TREE_OPERAND (arg
, 2));
4310 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4311 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4312 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4314 /* The representation of something of type OFFSET_TYPE
4315 is really the representation of a pointer to it.
4316 Here give the representation its true type. */
4320 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4322 if (TREE_CODE (arg
) != OFFSET_REF
)
4325 t
= TREE_OPERAND (arg
, 1);
4327 if (TREE_CODE (t
) == FUNCTION_DECL
) /* Check all this code for right semantics. */
4328 return build_unary_op (ADDR_EXPR
, t
, 0);
4329 if (TREE_CODE (t
) == VAR_DECL
)
4330 return build_unary_op (ADDR_EXPR
, t
, 0);
4333 if (TREE_OPERAND (arg
, 0)
4334 && (TREE_CODE (TREE_OPERAND (arg
, 0)) != NOP_EXPR
4335 || TREE_OPERAND (TREE_OPERAND (arg
, 0), 0) != error_mark_node
))
4336 if (TREE_CODE (t
) != FIELD_DECL
)
4338 /* Don't know if this should return address to just
4339 _DECL, or actual address resolved in this expression. */
4340 sorry ("address of bound pointer-to-member expression");
4341 return error_mark_node
;
4344 offset
= get_delta_difference (DECL_FIELD_CONTEXT (t
),
4345 TREE_TYPE (TREE_OPERAND (arg
, 0)),
4347 offset
= size_binop (PLUS_EXPR
, offset
,
4348 size_binop (EASY_DIV_EXPR
,
4349 DECL_FIELD_BITPOS (t
),
4350 size_int (BITS_PER_UNIT
)));
4351 return convert (build_pointer_type (TREE_TYPE (arg
)), offset
);
4355 if (TREE_CODE (arg
) == OFFSET_REF
)
4357 tree left
= TREE_OPERAND (arg
, 0), left_addr
;
4358 tree right_addr
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 1), 0);
4361 if (current_class_decl
)
4362 left_addr
= current_class_decl
;
4365 error ("no `this' for pointer to member");
4366 return error_mark_node
;
4369 left_addr
= build_unary_op (ADDR_EXPR
, left
, 0);
4371 return build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4372 build1 (NOP_EXPR
, integer_type_node
, left_addr
),
4373 build1 (NOP_EXPR
, integer_type_node
, right_addr
));
4376 /* We permit compiler to make function calls returning
4377 objects of aggregate type look like lvalues. */
4381 if (TREE_CODE (targ
) == SAVE_EXPR
)
4382 targ
= TREE_OPERAND (targ
, 0);
4384 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4386 if (TREE_CODE (arg
) == SAVE_EXPR
)
4389 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, 1);
4390 return build1 (ADDR_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)), targ
);
4393 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4394 return build (SAVE_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)),
4395 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4397 /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
4398 we do, here's how to handle it. */
4399 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == WITH_CLEANUP_EXPR
)
4402 /* Not really a bug, but something to turn on when testing. */
4403 compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
4405 return unary_complex_lvalue (ADDR_EXPR
, targ
);
4409 /* Don't let anything else be handled specially. */
4413 /* Mark EXP saying that we need to be able to take the
4414 address of it; it should not be allocated in a register.
4415 Value is 1 if successful.
4417 C++: we do not allow `current_class_decl' to be addressable. */
4420 mark_addressable (exp
)
4423 register tree x
= exp
;
4425 if (TREE_ADDRESSABLE (x
) == 1)
4429 switch (TREE_CODE (x
))
4434 x
= TREE_OPERAND (x
, 0);
4438 if (x
== current_class_decl
)
4440 error ("address of `this' not available");
4441 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4442 put_var_into_stack (x
);
4447 && TREE_READONLY (x
)
4448 && DECL_RTL (x
) != 0
4449 && ! decl_in_memory_p (x
))
4451 /* We thought this would make a good constant variable,
4452 but we were wrong. */
4453 push_obstacks_nochange ();
4454 end_temporary_allocation ();
4456 TREE_ASM_WRITTEN (x
) = 0;
4458 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0, 0);
4459 TREE_ADDRESSABLE (x
) = 1;
4465 /* Caller should not be trying to mark initialized
4466 constant fields addressable. */
4467 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4468 || DECL_IN_AGGR_P (x
) == 0
4470 || DECL_EXTERNAL (x
), 314);
4474 /* For C++, we don't warn about taking the address of a register
4475 variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
4476 put_var_into_stack (x
);
4477 TREE_ADDRESSABLE (x
) = 1;
4481 /* We have to test both conditions here. The first may
4482 be non-zero in the case of processing a default function.
4483 The second may be non-zero in the case of a template function. */
4484 x
= DECL_MAIN_VARIANT (x
);
4485 if ((DECL_INLINE (x
) || DECL_PENDING_INLINE_INFO (x
))
4486 && (DECL_CONTEXT (x
) == NULL_TREE
4487 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x
))) != 't'
4488 || ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x
))))
4490 mark_inline_for_output (x
);
4491 if (x
== current_function_decl
)
4492 DECL_EXTERNAL (x
) = 0;
4494 TREE_ADDRESSABLE (x
) = 1;
4496 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4504 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4507 build_x_conditional_expr (ifexp
, op1
, op2
)
4508 tree ifexp
, op1
, op2
;
4510 tree rval
= NULL_TREE
;
4512 /* See comments in `build_x_binary_op'. */
4514 rval
= build_opfncall (COND_EXPR
, LOOKUP_SPECULATIVELY
, ifexp
, op1
, op2
);
4516 return build_opfncall (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4518 return build_conditional_expr (ifexp
, op1
, op2
);
4522 build_conditional_expr (ifexp
, op1
, op2
)
4523 tree ifexp
, op1
, op2
;
4525 register tree type1
;
4526 register tree type2
;
4527 register enum tree_code code1
;
4528 register enum tree_code code2
;
4529 register tree result_type
= NULL_TREE
;
4530 tree orig_op1
= op1
, orig_op2
= op2
;
4532 /* If second operand is omitted, it is the same as the first one;
4533 make sure it is calculated only once. */
4537 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4538 ifexp
= op1
= save_expr (ifexp
);
4541 ifexp
= bool_truthvalue_conversion (ifexp
);
4543 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4544 return error_mark_node
;
4546 op1
= require_instantiated_type (TREE_TYPE (op2
), op1
, error_mark_node
);
4547 if (op1
== error_mark_node
)
4548 return error_mark_node
;
4549 op2
= require_instantiated_type (TREE_TYPE (op1
), op2
, error_mark_node
);
4550 if (op2
== error_mark_node
)
4551 return error_mark_node
;
4553 /* C++: REFERENCE_TYPES must be dereferenced. */
4554 type1
= TREE_TYPE (op1
);
4555 code1
= TREE_CODE (type1
);
4556 type2
= TREE_TYPE (op2
);
4557 code2
= TREE_CODE (type2
);
4559 if (code1
== REFERENCE_TYPE
)
4561 op1
= convert_from_reference (op1
);
4562 type1
= TREE_TYPE (op1
);
4563 code1
= TREE_CODE (type1
);
4565 if (code2
== REFERENCE_TYPE
)
4567 op2
= convert_from_reference (op2
);
4568 type2
= TREE_TYPE (op2
);
4569 code2
= TREE_CODE (type2
);
4572 #if 1 /* Produces wrong result if within sizeof. Sorry. */
4573 /* Don't promote the operands separately if they promote
4574 the same way. Return the unpromoted type and let the combined
4575 value get promoted if necessary. */
4577 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4578 && code2
!= ARRAY_TYPE
4580 /* For C++, let the enumeral type come through. */
4581 && code2
!= ENUMERAL_TYPE
4583 && code2
!= FUNCTION_TYPE
4584 && code2
!= METHOD_TYPE
)
4588 if (TREE_CONSTANT (ifexp
)
4589 && (TREE_CODE (ifexp
) == INTEGER_CST
4590 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4591 return (integer_zerop (ifexp
) ? op2
: op1
);
4593 if (TREE_CODE (op1
) == CONST_DECL
)
4594 op1
= DECL_INITIAL (op1
);
4595 else if (TREE_READONLY_DECL_P (op1
))
4596 op1
= decl_constant_value (op1
);
4597 if (TREE_CODE (op2
) == CONST_DECL
)
4598 op2
= DECL_INITIAL (op2
);
4599 else if (TREE_READONLY_DECL_P (op2
))
4600 op2
= decl_constant_value (op2
);
4602 type1
= cp_build_type_variant
4604 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4605 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4606 /* ??? This is a kludge to deal with the fact that
4607 we don't sort out integers and enums properly, yet. */
4608 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4609 if (TREE_TYPE (result
) != type1
)
4610 result
= build1 (NOP_EXPR
, type1
, result
);
4615 /* They don't match; promote them both and then try to reconcile them.
4616 But don't permit mismatching enum types. */
4617 if (code1
== ENUMERAL_TYPE
)
4619 if (code2
== ENUMERAL_TYPE
)
4621 message_2_types (error
, "enumeral mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4622 return error_mark_node
;
4624 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
))
4625 warning ("enumeral and non-enumeral type in conditional expression");
4627 else if (extra_warnings
4628 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
))
4629 warning ("enumeral and non-enumeral type in conditional expression");
4631 if (code1
!= VOID_TYPE
)
4633 op1
= default_conversion (op1
);
4634 type1
= TREE_TYPE (op1
);
4635 code1
= TREE_CODE (type1
);
4637 if (code2
!= VOID_TYPE
)
4639 op2
= default_conversion (op2
);
4640 type2
= TREE_TYPE (op2
);
4641 code2
= TREE_CODE (type2
);
4644 /* Quickly detect the usual case where op1 and op2 have the same type
4646 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4649 result_type
= type1
;
4651 result_type
= cp_build_type_variant
4653 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4654 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4656 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
4657 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
4659 result_type
= common_type (type1
, type2
);
4661 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4663 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
4664 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
4665 result_type
= void_type_node
;
4667 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4669 if (comp_target_types (type1
, type2
, 1))
4670 result_type
= common_type (type1
, type2
);
4671 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
4672 && TREE_CODE (orig_op1
) != NOP_EXPR
)
4673 result_type
= qualify_type (type2
, type1
);
4674 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
4675 && TREE_CODE (orig_op2
) != NOP_EXPR
)
4676 result_type
= qualify_type (type1
, type2
);
4677 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
4679 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4680 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4681 result_type
= qualify_type (type1
, type2
);
4683 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
4685 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4686 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4687 result_type
= qualify_type (type2
, type1
);
4690 else if (comptypes (type2
, type1
, 0))
4691 result_type
= type2
;
4692 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
4693 && IS_AGGR_TYPE (TREE_TYPE (type2
))
4694 && (result_type
= common_base_type (TREE_TYPE (type1
), TREE_TYPE (type2
))))
4696 if (result_type
== error_mark_node
)
4698 cp_error ("common base type of types `%T' and `%T' is ambiguous",
4699 TREE_TYPE (type1
), TREE_TYPE (type2
));
4700 result_type
= ptr_type_node
;
4705 && result_type
!= TREE_TYPE (type1
)
4706 && result_type
!= TREE_TYPE (type2
))
4707 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
4708 type1
, type2
, result_type
);
4710 result_type
= TYPE_POINTER_TO (result_type
);
4715 pedwarn ("pointer type mismatch in conditional expression");
4716 result_type
= ptr_type_node
;
4719 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4721 if (!integer_zerop (op2
))
4722 pedwarn ("pointer/integer type mismatch in conditional expression");
4725 op2
= null_pointer_node
;
4726 #if 0 /* Sez who? */
4727 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4728 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4731 result_type
= type1
;
4733 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4735 if (!integer_zerop (op1
))
4736 pedwarn ("pointer/integer type mismatch in conditional expression");
4739 op1
= null_pointer_node
;
4740 #if 0 /* Sez who? */
4741 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4742 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4745 result_type
= type2
;
4750 /* The match does not look good. If either is
4751 an aggregate value, try converting to a scalar type. */
4752 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
4754 message_2_types (error
, "aggregate mismatch in conditional expression: `%s' vs `%s'", type1
, type2
);
4755 return error_mark_node
;
4757 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
4759 tree tmp
= build_type_conversion (CONVERT_EXPR
, type2
, op1
, 0);
4760 if (tmp
== NULL_TREE
)
4762 cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1
);
4763 return error_mark_node
;
4765 if (tmp
== error_mark_node
)
4766 error ("ambiguous pointer conversion");
4767 result_type
= type2
;
4770 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
4772 tree tmp
= build_type_conversion (CONVERT_EXPR
, type1
, op2
, 0);
4773 if (tmp
== NULL_TREE
)
4775 cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2
);
4776 return error_mark_node
;
4778 if (tmp
== error_mark_node
)
4779 error ("ambiguous pointer conversion");
4780 result_type
= type1
;
4783 else if (flag_cond_mismatch
)
4784 result_type
= void_type_node
;
4787 error ("type mismatch in conditional expression");
4788 return error_mark_node
;
4792 if (result_type
!= TREE_TYPE (op1
))
4793 op1
= convert_and_check (result_type
, op1
);
4794 if (result_type
!= TREE_TYPE (op2
))
4795 op2
= convert_and_check (result_type
, op2
);
4798 /* XXX delete me, I've been here for years. */
4799 if (IS_AGGR_TYPE_CODE (code1
))
4801 result_type
= TREE_TYPE (op1
);
4802 if (TREE_CONSTANT (ifexp
))
4803 return (integer_zerop (ifexp
) ? op2
: op1
);
4805 if (TYPE_MODE (result_type
) == BLKmode
)
4807 register tree tempvar
4808 = build_decl (VAR_DECL
, NULL_TREE
, result_type
);
4809 register tree xop1
= build_modify_expr (tempvar
, NOP_EXPR
, op1
);
4810 register tree xop2
= build_modify_expr (tempvar
, NOP_EXPR
, op2
);
4811 register tree result
= fold (build (COND_EXPR
, result_type
,
4812 ifexp
, xop1
, xop2
));
4814 layout_decl (tempvar
, 0);
4815 /* No way to handle variable-sized objects here.
4816 I fear that the entire handling of BLKmode conditional exprs
4817 needs to be redone. */
4818 my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar
)), 315);
4820 = assign_stack_local (DECL_MODE (tempvar
),
4821 (TREE_INT_CST_LOW (DECL_SIZE (tempvar
))
4822 + BITS_PER_UNIT
- 1)
4826 TREE_SIDE_EFFECTS (result
)
4827 = TREE_SIDE_EFFECTS (ifexp
) | TREE_SIDE_EFFECTS (op1
)
4828 | TREE_SIDE_EFFECTS (op2
);
4829 return build (COMPOUND_EXPR
, result_type
, result
, tempvar
);
4834 if (TREE_CONSTANT (ifexp
))
4835 return integer_zerop (ifexp
) ? op2
: op1
;
4837 return fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
4840 /* Handle overloading of the ',' operator when needed. Otherwise,
4841 this function just builds an expression list. */
4843 build_x_compound_expr (list
)
4846 tree rest
= TREE_CHAIN (list
);
4849 if (rest
== NULL_TREE
)
4850 return build_compound_expr (list
);
4852 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
4853 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
4855 return build_x_compound_expr (tree_cons (NULL_TREE
, result
, TREE_CHAIN (rest
)));
4856 return build_compound_expr (tree_cons (NULL_TREE
, TREE_VALUE (list
),
4857 build_tree_list (NULL_TREE
, build_x_compound_expr (rest
))));
4860 /* Given a list of expressions, return a compound expression
4861 that performs them all and returns the value of the last of them. */
4864 build_compound_expr (list
)
4869 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
4870 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
4872 if (TREE_CHAIN (list
) == 0)
4874 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4875 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4876 if (TREE_CODE (list
) == NOP_EXPR
4877 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
4878 list
= TREE_OPERAND (list
, 0);
4880 /* Convert arrays to pointers. */
4881 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
4882 return default_conversion (TREE_VALUE (list
));
4884 return TREE_VALUE (list
);
4887 rest
= build_compound_expr (TREE_CHAIN (list
));
4889 /* When pedantic, a compound expression can be neither an lvalue
4890 nor an integer constant expression. */
4891 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
4894 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
4895 break_out_cleanups (TREE_VALUE (list
)), rest
);
4898 tree
build_static_cast (type
, expr
)
4901 return build_c_cast (type
, expr
, 0);
4904 tree
build_reinterpret_cast (type
, expr
)
4907 return build_c_cast (type
, expr
, 0);
4910 tree
build_const_cast (type
, expr
)
4913 return build_c_cast (type
, expr
, 0);
4916 /* Build an expression representing a cast to type TYPE of expression EXPR.
4918 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
4919 when doing the cast. */
4922 build_c_cast (type
, expr
, allow_nonconverting
)
4925 int allow_nonconverting
;
4927 register tree value
= expr
;
4929 if (type
== error_mark_node
|| expr
== error_mark_node
)
4930 return error_mark_node
;
4932 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4933 Strip such NOP_EXPRs, since VALUE is being used in non-lvalue context. */
4934 if (TREE_CODE (value
) == NOP_EXPR
4935 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
4936 value
= TREE_OPERAND (value
, 0);
4938 if (TREE_TYPE (expr
)
4939 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
4940 && TREE_CODE (type
) != OFFSET_TYPE
)
4941 value
= resolve_offset_ref (value
);
4943 if (TREE_CODE (type
) == ARRAY_TYPE
)
4945 /* Allow casting from T1* to T2[] because Cfront allows it.
4946 NIHCL uses it. It is not valid ANSI C however, and hence, not
4948 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
4951 pedwarn ("ANSI C++ forbids casting to an array type");
4952 type
= build_pointer_type (TREE_TYPE (type
));
4956 error ("ANSI C++ forbids casting to an array type");
4957 return error_mark_node
;
4961 if (TREE_CODE (type
) == FUNCTION_TYPE
4962 || TREE_CODE (type
) == METHOD_TYPE
)
4964 cp_error ("casting to function type `%T'", type
);
4965 return error_mark_node
;
4968 if (IS_SIGNATURE (type
))
4970 error ("cast specifies signature type");
4971 return error_mark_node
;
4974 /* If there's only one function in the overloaded space,
4976 if (TREE_CODE (value
) == TREE_LIST
4977 && TREE_CHAIN (value
) == NULL_TREE
)
4978 value
= TREE_VALUE (value
);
4980 if (TREE_CODE (type
) == VOID_TYPE
)
4981 value
= build1 (CONVERT_EXPR
, type
, value
);
4982 else if (TREE_TYPE (value
) == NULL_TREE
4983 || type_unknown_p (value
))
4985 value
= instantiate_type (type
, value
, 1);
4987 if (value
== error_mark_node
)
4988 return error_mark_node
;
4994 /* Convert functions and arrays to pointers and
4995 convert references to their expanded types,
4996 but don't convert any other types. */
4997 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
4998 || TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
4999 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5000 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5001 value
= default_conversion (value
);
5002 otype
= TREE_TYPE (value
);
5004 /* Optionally warn about potentially worrisome casts. */
5007 && TREE_CODE (type
) == POINTER_TYPE
5008 && TREE_CODE (otype
) == POINTER_TYPE
)
5010 /* For C++ we make these regular warnings, rather than
5011 softening them into pedwarns. */
5012 if (TYPE_VOLATILE (TREE_TYPE (otype
))
5013 && ! TYPE_VOLATILE (TREE_TYPE (type
)))
5014 warning ("cast discards `volatile' from pointer target type");
5015 if (TYPE_READONLY (TREE_TYPE (otype
))
5016 && ! TYPE_READONLY (TREE_TYPE (type
)))
5017 warning ("cast discards `const' from pointer target type");
5020 /* Warn about possible alignment problems. */
5021 if (STRICT_ALIGNMENT
&& warn_cast_align
5022 && TREE_CODE (type
) == POINTER_TYPE
5023 && TREE_CODE (otype
) == POINTER_TYPE
5024 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5025 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5026 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5027 warning ("cast increases required alignment of target type");
5030 if (TREE_CODE (type
) == INTEGER_TYPE
5031 && TREE_CODE (otype
) == POINTER_TYPE
5032 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5033 warning ("cast from pointer to integer of different size");
5035 if (TREE_CODE (type
) == POINTER_TYPE
5036 && TREE_CODE (otype
) == INTEGER_TYPE
5037 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5038 /* Don't warn about converting 0 to pointer,
5039 provided the 0 was explicit--not cast or made by folding. */
5040 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5041 warning ("cast to pointer from integer of different size");
5044 if (TREE_READONLY_DECL_P (value
))
5045 value
= decl_constant_value (value
);
5048 value
= convert_force (type
, value
, allow_nonconverting
?CONV_NONCONVERTING
:0);
5050 /* Ignore any integer overflow caused by the cast. */
5051 if (TREE_CODE (value
) == INTEGER_CST
)
5053 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5054 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5058 /* Always produce some operator for an explicit cast,
5059 so we can tell (for -pedantic) that the cast is no lvalue.
5060 Also, pedantically, don't let (void *) (FOO *) 0 be a null
5061 pointer constant. */
5064 && TREE_CODE (value
) == INTEGER_CST
5065 && TREE_CODE (expr
) == INTEGER_CST
5066 && TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
))
5068 tree nvalue
= build1 (NOP_EXPR
, type
, value
);
5069 TREE_CONSTANT (nvalue
) = TREE_CONSTANT (value
);
5077 /* Build an assignment expression of lvalue LHS from value RHS.
5079 In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
5080 that reference becomes deferenced down to it base type. */
5082 /* Return a reference to the BASE_INDEX part of EXPR. TYPE is
5083 the type to which BASE_INDEX applies. */
5085 get_base_ref (type
, base_index
, expr
)
5090 tree binfos
= TYPE_BINFO_BASETYPES (type
);
5091 tree base_binfo
= TREE_VEC_ELT (binfos
, base_index
);
5094 if (TREE_CODE (expr
) == ARRAY_REF
5095 || ! BINFO_OFFSET_ZEROP (base_binfo
)
5096 || TREE_VIA_VIRTUAL (base_binfo
)
5097 || TYPE_MODE (type
) != TYPE_MODE (BINFO_TYPE (base_binfo
)))
5099 tree addr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5100 ref
= build_indirect_ref (convert_pointer_to (base_binfo
, addr
),
5105 ref
= copy_node (expr
);
5106 TREE_TYPE (ref
) = BINFO_TYPE (base_binfo
);
5111 /* Build an assignment expression of lvalue LHS from value RHS.
5112 MODIFYCODE is the code for a binary operator that we use
5113 to combine the old value of LHS with RHS to get the new value.
5114 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5116 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5118 `build_modify_expr_1' implements recursive part of memberwise
5119 assignment operation. */
5121 build_modify_expr_1 (lhs
, modifycode
, rhs
, basetype_path
)
5123 enum tree_code modifycode
;
5126 register tree result
;
5128 tree lhstype
= TREE_TYPE (lhs
);
5129 tree olhstype
= lhstype
;
5131 /* Avoid duplicate error messages from operands that had errors. */
5132 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5133 return error_mark_node
;
5135 /* If a binary op has been requested, combine the old LHS value with the RHS
5136 producing the value we should actually store into the LHS. */
5138 if (modifycode
== INIT_EXPR
)
5140 else if (modifycode
== NOP_EXPR
)
5142 /* must deal with overloading of `operator=' here. */
5143 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5144 lhstype
= TREE_TYPE (lhstype
);
5150 lhs
= stabilize_reference (lhs
);
5151 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5152 modifycode
= NOP_EXPR
;
5155 /* If storing into a structure or union member,
5156 it has probably been given type `int'.
5157 Compute the type that would go with
5158 the actual amount of storage the member occupies. */
5160 if (TREE_CODE (lhs
) == COMPONENT_REF
5161 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5162 || TREE_CODE (lhstype
) == REAL_TYPE
5163 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5164 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5166 /* C++: The semantics of C++ differ from those of C when an
5167 assignment of an aggregate is desired. Assignment in C++ is
5168 now defined as memberwise assignment of non-static members
5169 and base class objects. This rule applies recursively
5170 until a member of a built-in type is found.
5172 Also, we cannot do a bit-wise copy of aggregates which
5173 contain virtual function table pointers. Those
5174 pointer values must be preserved through the copy.
5175 However, this is handled in expand_expr, and not here.
5176 This is because much better code can be generated at
5177 that stage than this one. */
5178 if (TREE_CODE (lhstype
) == RECORD_TYPE
5179 && TYPE_LANG_SPECIFIC (lhstype
)
5180 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5185 /* Perform operation on object. */
5186 if (modifycode
== INIT_EXPR
&& TYPE_HAS_INIT_REF (lhstype
))
5188 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5189 build_tree_list (NULL_TREE
, rhs
),
5190 basetype_path
, LOOKUP_NORMAL
);
5191 return build_indirect_ref (result
, NULL_PTR
);
5193 else if (modifycode
== NOP_EXPR
)
5195 /* `operator=' is not an inheritable operator; see 13.4.3. */
5196 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5198 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5199 lhs
, rhs
, make_node (NOP_EXPR
));
5200 if (result
== NULL_TREE
)
5201 return error_mark_node
;
5206 if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype
)
5207 || (modifycode
== NOP_EXPR
&& TYPE_GETS_ASSIGNMENT (lhstype
))
5208 || (modifycode
== INIT_EXPR
&& TYPE_GETS_INIT_REF (lhstype
)))
5210 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (lhstype
));
5213 if (binfos
!= NULL_TREE
)
5214 /* Perform operation on each member, depth-first, left-right. */
5215 for (i
= 0; i
<= TREE_VEC_LENGTH (binfos
)-1; i
++)
5217 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
5218 tree base_lhs
, base_rhs
;
5221 /* Assignments from virtual baseclasses handled elsewhere. */
5222 if (TREE_VIA_VIRTUAL (base_binfo
))
5225 base_lhs
= get_base_ref (lhstype
, i
, lhs
);
5226 base_rhs
= get_base_ref (lhstype
, i
, newrhs
);
5228 BINFO_INHERITANCE_CHAIN (base_binfo
) = basetype_path
;
5230 = build_modify_expr_1 (base_lhs
, modifycode
, base_rhs
,
5233 /* We either get back a compound stmt, or a simple one. */
5234 if (new_result
&& TREE_CODE (new_result
) == TREE_LIST
)
5235 new_result
= build_compound_expr (new_result
);
5236 result
= tree_cons (NULL_TREE
, new_result
, result
);
5239 for (elt
= TYPE_FIELDS (lhstype
); elt
; elt
= TREE_CHAIN (elt
))
5241 tree vbases
= NULL_TREE
;
5242 tree elt_lhs
, elt_rhs
;
5244 if (TREE_CODE (elt
) != FIELD_DECL
)
5247 && (VFIELD_NAME_P (DECL_NAME (elt
))
5248 || VBASE_NAME_P (DECL_NAME (elt
))))
5251 if (TREE_READONLY (elt
)
5252 || TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5254 cp_error ("cannot generate default `%T::operator ='",
5256 if (TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5257 cp_error_at ("because member `%#D' is a reference", elt
);
5259 cp_error_at ("because member `%#D' is const", elt
);
5261 return error_mark_node
;
5264 if (IS_AGGR_TYPE (TREE_TYPE (elt
))
5265 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5266 vbases
= CLASSTYPE_VBASECLASSES (TREE_TYPE (elt
));
5268 elt_lhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), lhs
, elt
);
5269 elt_rhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), newrhs
, elt
);
5270 /* It is not always safe to go through `build_modify_expr_1'
5271 when performing element-wise copying. This is because
5272 an element may be of ARRAY_TYPE, which will not
5273 be properly copied as a naked element. */
5274 if (TREE_CODE (TREE_TYPE (elt
)) == RECORD_TYPE
5275 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5276 basetype_path
= TYPE_BINFO (TREE_TYPE (elt
));
5280 tree elt_lhs_addr
= build_unary_op (ADDR_EXPR
, elt_lhs
, 0);
5281 tree elt_rhs_addr
= build_unary_op (ADDR_EXPR
, elt_rhs
, 0);
5283 elt_lhs_addr
= convert_pointer_to (vbases
, elt_lhs_addr
);
5284 elt_rhs_addr
= convert_pointer_to (vbases
, elt_rhs_addr
);
5286 = tree_cons (NULL_TREE
,
5288 (build_indirect_ref (elt_lhs_addr
, NULL_PTR
),
5290 build_indirect_ref (elt_rhs_addr
, NULL_PTR
),
5293 if (TREE_VALUE (result
) == error_mark_node
)
5294 return error_mark_node
;
5295 vbases
= TREE_CHAIN (vbases
);
5297 elt_lhs
= build_modify_expr_1 (elt_lhs
, modifycode
, elt_rhs
,
5299 result
= tree_cons (NULL_TREE
, elt_lhs
, result
);
5303 return build_compound_expr (result
);
5304 /* No fields to move. */
5305 return integer_zero_node
;
5309 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5310 void_type_node
, lhs
, rhs
);
5311 TREE_SIDE_EFFECTS (result
) = 1;
5316 result
= build_modify_expr (lhs
, modifycode
, newrhs
);
5317 /* ARRAY_TYPEs cannot be converted to anything meaningful,
5318 and leaving it there screws up `build_compound_expr' when
5319 it tries to defaultly convert everything. */
5320 if (TREE_CODE (TREE_TYPE (result
)) == ARRAY_TYPE
)
5321 TREE_TYPE (result
) = void_type_node
;
5326 /* Taken from expr.c:
5327 Subroutine of expand_expr:
5328 record the non-copied parts (LIST) of an expr (LHS), and return a list
5329 which specifies the initial values of these parts. */
5332 init_noncopied_parts (lhs
, list
)
5339 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5340 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5341 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5344 tree part
= TREE_VALUE (tail
);
5345 tree part_type
= TREE_TYPE (part
);
5346 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5347 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
5352 /* Build an assignment expression of lvalue LHS from value RHS.
5353 MODIFYCODE is the code for a binary operator that we use
5354 to combine the old value of LHS with RHS to get the new value.
5355 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5357 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5360 build_modify_expr (lhs
, modifycode
, rhs
)
5362 enum tree_code modifycode
;
5365 register tree result
;
5367 tree lhstype
= TREE_TYPE (lhs
);
5368 tree olhstype
= lhstype
;
5371 /* Avoid duplicate error messages from operands that had errors. */
5372 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5373 return error_mark_node
;
5375 /* Types that aren't fully specified cannot be used in assignments. */
5376 lhs
= require_complete_type (lhs
);
5378 /* Decide early if we are going to protect RHS from GC
5379 before assigning it to LHS. */
5380 if (type_needs_gc_entry (TREE_TYPE (rhs
))
5381 && ! value_safe_from_gc (lhs
, rhs
))
5382 rhs
= protect_value_from_gc (lhs
, rhs
);
5386 /* Handle assignment to signature pointers/refs. */
5388 if (TYPE_LANG_SPECIFIC (lhstype
) &&
5389 (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5391 return build_signature_pointer_constructor (lhs
, rhs
);
5394 /* Handle control structure constructs used as "lvalues". */
5396 switch (TREE_CODE (lhs
))
5398 /* Handle --foo = 5; as these are valid constructs in C++ */
5399 case PREDECREMENT_EXPR
:
5400 case PREINCREMENT_EXPR
:
5401 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5402 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5403 stabilize_reference (TREE_OPERAND (lhs
, 0)));
5404 return build (COMPOUND_EXPR
, lhstype
,
5406 build_modify_expr (TREE_OPERAND (lhs
, 0),
5409 /* Handle (a, b) used as an "lvalue". */
5411 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5413 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5414 return error_mark_node
;
5415 return build (COMPOUND_EXPR
, lhstype
,
5416 TREE_OPERAND (lhs
, 0), newrhs
);
5419 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5420 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5421 return error_mark_node
;
5422 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5424 /* Handle (a ? b : c) used as an "lvalue". */
5426 rhs
= save_expr (rhs
);
5428 /* Produce (a ? (b = rhs) : (c = rhs))
5429 except that the RHS goes through a save-expr
5430 so the code to compute it is only emitted once. */
5432 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5433 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5435 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5437 if (TREE_CODE (cond
) == ERROR_MARK
)
5439 /* Make sure the code to compute the rhs comes out
5440 before the split. */
5441 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5442 /* Case to void to suppress warning
5443 from warn_if_unused_value. */
5444 convert (void_type_node
, rhs
), cond
);
5448 if (TREE_CODE (lhs
) == OFFSET_REF
)
5450 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5452 /* Static class member? */
5453 tree member
= TREE_OPERAND (lhs
, 1);
5454 if (TREE_CODE (member
) == VAR_DECL
)
5458 compiler_error ("invalid static class member");
5459 return error_mark_node
;
5463 lhs
= resolve_offset_ref (lhs
);
5465 olhstype
= lhstype
= TREE_TYPE (lhs
);
5468 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5469 && modifycode
!= INIT_EXPR
)
5471 lhs
= convert_from_reference (lhs
);
5472 olhstype
= lhstype
= TREE_TYPE (lhs
);
5475 /* If a binary op has been requested, combine the old LHS value with the RHS
5476 producing the value we should actually store into the LHS. */
5478 if (modifycode
== INIT_EXPR
)
5480 if (! IS_AGGR_TYPE (lhstype
))
5481 /* Do the default thing */;
5482 else if (! TYPE_HAS_CONSTRUCTOR (lhstype
))
5483 cp_error ("`%T' has no constructors", lhstype
);
5484 else if (! TYPE_NEEDS_CONSTRUCTING (lhstype
)
5485 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5486 /* Do the default thing */;
5489 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5490 build_tree_list (NULL_TREE
, rhs
),
5491 NULL_TREE
, LOOKUP_NORMAL
);
5492 if (result
== NULL_TREE
)
5493 return error_mark_node
;
5497 else if (modifycode
== NOP_EXPR
)
5500 /* `operator=' is not an inheritable operator. */
5501 if (! IS_AGGR_TYPE (lhstype
))
5502 /* Do the default thing */;
5503 else if (! TYPE_HAS_ASSIGNMENT (lhstype
))
5504 cp_error ("`%T' does not define operator=", lhstype
);
5505 else if (! TYPE_HAS_REAL_ASSIGNMENT (lhstype
)
5506 && ! TYPE_HAS_COMPLEX_ASSIGN_REF (lhstype
)
5507 /* FIXME find some way to deal with TARGET_EXPRs here. */
5508 && TREE_CODE (newrhs
) != TARGET_EXPR
5509 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5510 /* Do the default thing */;
5513 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5514 lhs
, rhs
, make_node (NOP_EXPR
));
5515 if (result
== NULL_TREE
)
5516 return error_mark_node
;
5520 /* Treat `operator=' as an inheritable operator. */
5521 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_GETS_ASSIGNMENT (lhstype
))
5523 tree orig_lhstype
= lhstype
;
5524 while (! TYPE_HAS_ASSIGNMENT (lhstype
))
5526 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (lhstype
);
5527 tree basetype
= NULL_TREE
;
5528 for (i
= 0; i
< n_baseclasses
; i
++)
5529 if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype
, i
)))
5531 if (basetype
!= NULL_TREE
)
5533 message_2_types (error
, "base classes `%s' and `%s' both have operator ='",
5535 TYPE_BINFO_BASETYPE (lhstype
, i
));
5536 return error_mark_node
;
5538 basetype
= TYPE_BINFO_BASETYPE (lhstype
, i
);
5542 if (orig_lhstype
!= lhstype
)
5544 lhs
= build_indirect_ref (convert_pointer_to (lhstype
,
5545 build_unary_op (ADDR_EXPR
, lhs
, 0)), NULL_PTR
);
5546 if (lhs
== error_mark_node
)
5548 cp_error ("conversion to private basetype `%T'", lhstype
);
5549 return error_mark_node
;
5552 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5553 lhs
, rhs
, make_node (NOP_EXPR
));
5554 if (result
== NULL_TREE
)
5555 return error_mark_node
;
5561 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5563 /* This case must convert to some sort of lvalue that
5564 can participate in an op= operation. */
5567 if (build_default_binary_type_conversion (modifycode
, &lhs_tmp
, &rhs_tmp
))
5569 lhs
= stabilize_reference (lhs_tmp
);
5570 /* Forget is was ever anything else. */
5571 olhstype
= lhstype
= TREE_TYPE (lhs
);
5572 newrhs
= build_binary_op (modifycode
, lhs
, rhs_tmp
, 1);
5575 return error_mark_node
;
5579 lhs
= stabilize_reference (lhs
);
5580 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5583 /* Handle a cast used as an "lvalue".
5584 We have already performed any binary operator using the value as cast.
5585 Now convert the result to the cast type of the lhs,
5586 and then true type of the lhs and store it there;
5587 then convert result back to the cast type to be the value
5588 of the assignment. */
5590 switch (TREE_CODE (lhs
))
5595 case FIX_TRUNC_EXPR
:
5596 case FIX_FLOOR_EXPR
:
5597 case FIX_ROUND_EXPR
:
5599 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5600 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5601 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5602 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5603 newrhs
= default_conversion (newrhs
);
5605 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5607 if (! lvalue_p (lhs
) && pedantic
)
5608 pedwarn ("cast to non-reference type used as lvalue");
5610 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5611 convert (TREE_TYPE (inner_lhs
),
5612 convert (lhstype
, newrhs
)));
5613 if (TREE_CODE (result
) == ERROR_MARK
)
5615 return convert (TREE_TYPE (lhs
), result
);
5619 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5620 Reject anything strange now. */
5622 if (!lvalue_or_else (lhs
, "assignment"))
5623 return error_mark_node
;
5625 GNU_xref_assign (lhs
);
5627 /* Warn about storing in something that is `const'. */
5628 /* For C++, don't warn if this is initialization. */
5629 if (modifycode
!= INIT_EXPR
5630 /* For assignment to `const' signature pointer/reference fields,
5631 don't warn either, we already printed a better message before. */
5632 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5633 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5634 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5635 && (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
5636 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5637 || TREE_CODE (lhstype
) == UNION_TYPE
)
5638 && C_TYPE_FIELDS_READONLY (lhstype
))
5639 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5640 && TYPE_READONLY (TREE_TYPE (lhstype
)))))
5641 readonly_error (lhs
, "assignment", 0);
5643 /* If storing into a structure or union member,
5644 it has probably been given type `int'.
5645 Compute the type that would go with
5646 the actual amount of storage the member occupies. */
5648 if (TREE_CODE (lhs
) == COMPONENT_REF
5649 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5650 || TREE_CODE (lhstype
) == REAL_TYPE
5651 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5653 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5655 /* If storing in a field that is in actuality a short or narrower
5656 than one, we must store in the field in its actual type. */
5658 if (lhstype
!= TREE_TYPE (lhs
))
5660 lhs
= copy_node (lhs
);
5661 TREE_TYPE (lhs
) = lhstype
;
5665 /* check to see if there is an assignment to `this' */
5666 if (lhs
== current_class_decl
)
5668 if (flag_this_is_variable
> 0
5669 && DECL_NAME (current_function_decl
) != NULL_TREE
5670 && current_class_name
!= DECL_NAME (current_function_decl
))
5671 warning ("assignment to `this' not in constructor or destructor");
5672 current_function_just_assigned_this
= 1;
5675 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
5676 when the type of RHS is not yet known, i.e. its type
5677 is inherited from LHS. */
5678 rhs
= require_instantiated_type (lhstype
, newrhs
, error_mark_node
);
5679 if (rhs
== error_mark_node
)
5680 return error_mark_node
;
5683 if (modifycode
!= INIT_EXPR
)
5685 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5686 modifycode
= NOP_EXPR
;
5687 /* Reference-bashing */
5688 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5690 tree tmp
= convert_from_reference (lhs
);
5691 lhstype
= TREE_TYPE (tmp
);
5692 if (TYPE_SIZE (lhstype
) == 0)
5694 incomplete_type_error (lhs
, lhstype
);
5695 return error_mark_node
;
5700 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
5702 tree tmp
= convert_from_reference (newrhs
);
5703 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
5705 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
5706 return error_mark_node
;
5712 if (TREE_SIDE_EFFECTS (lhs
))
5713 lhs
= stabilize_reference (lhs
);
5714 if (TREE_SIDE_EFFECTS (newrhs
))
5715 newrhs
= stabilize_reference (newrhs
);
5718 /* This is now done by generating X(X&) and operator=(X&). */
5719 /* C++: The semantics of C++ differ from those of C when an
5720 assignment of an aggregate is desired. Assignment in C++ is
5721 now defined as memberwise assignment of non-static members
5722 and base class objects. This rule applies recursively
5723 until a member of a built-in type is found.
5725 Also, we cannot do a bit-wise copy of aggregates which
5726 contain virtual function table pointers. Those
5727 pointer values must be preserved through the copy.
5728 However, this is handled in expand_expr, and not here.
5729 This is because much better code can be generated at
5730 that stage than this one. */
5731 if (TREE_CODE (lhstype
) == RECORD_TYPE
5732 && ! TYPE_PTRMEMFUNC_P (lhstype
)
5733 && (TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))
5734 || (TREE_CODE (TREE_TYPE (newrhs
)) == RECORD_TYPE
5735 && UNIQUELY_DERIVED_FROM_P (lhstype
, TREE_TYPE (newrhs
)))))
5737 tree vbases
= CLASSTYPE_VBASECLASSES (lhstype
);
5738 tree lhs_addr
= build_unary_op (ADDR_EXPR
, lhs
, 0);
5741 /* Memberwise assignment would cause NEWRHS to be
5742 evaluated for every member that gets assigned.
5743 By wrapping side-effecting exprs in a SAVE_EXPR,
5744 NEWRHS will only be evaluated once. */
5745 if (IS_AGGR_TYPE (TREE_TYPE (newrhs
))
5746 && TREE_SIDE_EFFECTS (newrhs
)
5747 /* This are things we don't have to save. */
5748 && TREE_CODE (newrhs
) != COND_EXPR
5749 && TREE_CODE (newrhs
) != TARGET_EXPR
5750 && TREE_CODE (newrhs
) != WITH_CLEANUP_EXPR
)
5751 /* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
5752 If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
5753 will result in expand_expr expanding the call without knowing
5754 that it should run the cleanup. */
5755 newrhs
= save_expr (break_out_cleanups (newrhs
));
5757 if (TREE_CODE (newrhs
) == COND_EXPR
)
5758 rhs_addr
= rationalize_conditional_expr (ADDR_EXPR
, newrhs
);
5760 rhs_addr
= build_unary_op (ADDR_EXPR
, newrhs
, 0);
5762 result
= tree_cons (NULL_TREE
,
5763 convert (build_reference_type (lhstype
), lhs
),
5766 if (! comptypes (TREE_TYPE (lhs_addr
), TREE_TYPE (rhs_addr
), 1))
5767 rhs_addr
= convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr
)), rhs_addr
);
5769 tree noncopied_parts
= NULL_TREE
;
5771 if (TYPE_NONCOPIED_PARTS (lhstype
) != 0)
5772 noncopied_parts
= init_noncopied_parts (lhs
,
5773 TYPE_NONCOPIED_PARTS (lhstype
));
5774 while (noncopied_parts
!= 0)
5776 result
= tree_cons (NULL_TREE
,
5777 build_modify_expr (convert (ptr_type_node
, TREE_VALUE (noncopied_parts
)),
5779 TREE_PURPOSE (noncopied_parts
)),
5781 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
5784 /* Once we have our hands on an address, we must change NEWRHS
5785 to work from there. Otherwise we can get multiple evaluations
5787 if (TREE_CODE (newrhs
) != SAVE_EXPR
)
5788 newrhs
= build_indirect_ref (rhs_addr
, NULL_PTR
);
5792 tree elt_lhs
= convert_pointer_to (vbases
, lhs_addr
);
5793 tree elt_rhs
= convert_pointer_to (vbases
, rhs_addr
);
5795 = tree_cons (NULL_TREE
,
5796 build_modify_expr_1 (build_indirect_ref (elt_lhs
, NULL_PTR
),
5798 build_indirect_ref (elt_rhs
, NULL_PTR
),
5799 TYPE_BINFO (lhstype
)),
5801 if (TREE_VALUE (result
) == error_mark_node
)
5802 return error_mark_node
;
5803 vbases
= TREE_CHAIN (vbases
);
5805 result
= tree_cons (NULL_TREE
,
5806 build_modify_expr_1 (lhs
,
5809 TYPE_BINFO (lhstype
)),
5811 return build_compound_expr (result
);
5815 /* Convert new value to destination type. */
5817 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5821 /* Allow array assignment in compiler-generated code. */
5822 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
5823 pedwarn ("ANSI C++ forbids assignment of arrays");
5825 /* Have to wrap this in RTL_EXPR for two cases:
5826 in base or member initialization and if we
5827 are a branch of a ?: operator. Since we
5828 can't easily know the latter, just do it always. */
5830 result
= make_node (RTL_EXPR
);
5832 TREE_TYPE (result
) = void_type_node
;
5833 do_pending_stack_adjust ();
5834 start_sequence_for_rtl_expr (result
);
5836 /* As a matter of principle, `start_sequence' should do this. */
5839 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5840 ? 1 + (modifycode
!= INIT_EXPR
): 0;
5841 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
5844 do_pending_stack_adjust ();
5846 TREE_SIDE_EFFECTS (result
) = 1;
5847 RTL_EXPR_SEQUENCE (result
) = get_insns ();
5848 RTL_EXPR_RTL (result
) = const0_rtx
;
5853 if (modifycode
== INIT_EXPR
)
5855 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
5856 "assignment", NULL_TREE
, 0);
5857 if (lhs
== DECL_RESULT (current_function_decl
))
5859 if (DECL_INITIAL (lhs
))
5860 warning ("return value from function receives multiple initializations");
5861 DECL_INITIAL (lhs
) = newrhs
;
5867 if (IS_AGGR_TYPE (lhstype
))
5869 if (result
= build_opfncall (MODIFY_EXPR
,
5870 LOOKUP_NORMAL
, lhs
, newrhs
,
5871 make_node (NOP_EXPR
)))
5875 /* Avoid warnings on enum bit fields. */
5876 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
5877 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
5879 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
5881 newrhs
= convert_force (lhstype
, newrhs
, 0);
5884 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
5886 if (flag_elide_constructors
== 0
5887 && TREE_CODE (newrhs
) == CALL_EXPR
5888 && TREE_ADDRESSABLE (lhstype
))
5890 /* Can't initialized directly from a CALL_EXPR, since
5891 we don't know about what doesn't alias what. */
5893 tree temp
= get_temp_name (lhstype
, 0);
5894 newrhs
= build (COMPOUND_EXPR
, lhstype
,
5895 build_modify_expr (temp
, INIT_EXPR
, newrhs
),
5900 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5901 return error_mark_node
;
5903 if (TREE_CODE (newrhs
) == COND_EXPR
)
5906 tree cond
= TREE_OPERAND (newrhs
, 0);
5908 if (TREE_SIDE_EFFECTS (lhs
))
5909 cond
= build_compound_expr (tree_cons
5911 build_tree_list (NULL_TREE
, cond
)));
5913 /* Cannot have two identical lhs on this one tree (result) as preexpand
5914 calls will rip them out and fill in RTL for them, but when the
5915 rtl is generated, the calls will only be in the first side of the
5916 condition, not on both, or before the conditional jump! (mrs) */
5917 lhs1
= break_out_calls (lhs
);
5920 /* If there's no change, the COND_EXPR behaves like any other rhs. */
5921 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5922 lhstype
, lhs
, newrhs
);
5925 tree result_type
= TREE_TYPE (newrhs
);
5926 /* We have to convert each arm to the proper type because the
5927 types may have been munged by constant folding. */
5929 = build (COND_EXPR
, result_type
, cond
,
5930 build_modify_expr (lhs
, modifycode
,
5931 convert (result_type
,
5932 TREE_OPERAND (newrhs
, 1))),
5933 build_modify_expr (lhs1
, modifycode
,
5934 convert (result_type
,
5935 TREE_OPERAND (newrhs
, 2))));
5938 else if (modifycode
!= INIT_EXPR
&& TREE_CODE (newrhs
) == WITH_CLEANUP_EXPR
)
5940 tree cleanup
= TREE_OPERAND (newrhs
, 2);
5943 /* Finish up by running cleanups and having the "value" of the lhs. */
5944 tree exprlist
= tree_cons (NULL_TREE
, cleanup
,
5945 build_tree_list (NULL_TREE
, lhs
));
5946 newrhs
= TREE_OPERAND (newrhs
, 0);
5947 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
5948 slot
= TREE_OPERAND (newrhs
, 0);
5949 else if (TREE_CODE (newrhs
) == ADDR_EXPR
)
5951 /* Bad but valid. */
5953 warning ("address taken of temporary object");
5956 my_friendly_abort (118);
5958 /* Copy the value computed in SLOT into LHS. */
5959 exprlist
= tree_cons (NULL_TREE
,
5960 build_modify_expr (lhs
, modifycode
, slot
),
5962 /* Evaluate the expression that needs CLEANUP. This will
5963 compute the value into SLOT. */
5964 exprlist
= tree_cons (NULL_TREE
, newrhs
, exprlist
);
5965 result
= convert (lhstype
, build_compound_expr (exprlist
));
5968 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5969 lhstype
, lhs
, newrhs
);
5970 TREE_SIDE_EFFECTS (result
) = 1;
5972 /* If we got the LHS in a different type for storing in,
5973 convert the result back to the nominal type of LHS
5974 so that the value we return always has the same type
5975 as the LHS argument. */
5977 if (olhstype
== TREE_TYPE (result
))
5979 /* Avoid warnings converting integral types back into enums
5980 for enum bit fields. */
5981 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
5982 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
5984 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
5985 TREE_NO_UNUSED_WARNING (result
) = 1;
5988 return convert_for_assignment (olhstype
, result
, "assignment",
5993 /* Return 0 if EXP is not a valid lvalue in this language
5994 even though `lvalue_or_else' would accept it. */
5997 language_lvalue_valid (exp
)
6003 /* Get differnce in deltas for different pointer to member function
6004 types. Return inetger_zero_node, if FROM cannot be converted to a
6005 TO type. If FORCE is true, then allow reverse conversions as well. */
6007 get_delta_difference (from
, to
, force
)
6011 tree delta
= integer_zero_node
;
6017 /* Should get_base_distance here, so we can check if any thing along the
6018 path is virtual, and we need to make sure we stay
6019 inside the real binfos when going through virtual bases.
6020 Maybe we should replace virtual bases with
6021 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6022 binfo
= get_binfo (from
, to
, 1);
6023 if (binfo
== error_mark_node
)
6025 error (" in pointer to member function conversion");
6032 error_not_base_type (from
, to
);
6033 error (" in pointer to member function conversion");
6036 binfo
= get_binfo (to
, from
, 1);
6037 if (binfo
== error_mark_node
)
6039 error (" in pointer to member function conversion");
6044 error ("cannot convert pointer to member of type %T to unrelated pointer to member of type %T", from
, to
);
6047 if (TREE_VIA_VIRTUAL (binfo
))
6049 warning ("pointer to member conversion to virtual base class will only work if your very careful");
6051 return build_binary_op (MINUS_EXPR
,
6053 BINFO_OFFSET (binfo
), 1);
6055 if (TREE_VIA_VIRTUAL (binfo
))
6057 warning ("pointer to member conversion from virtual base class will only work if your very careful");
6059 return BINFO_OFFSET (binfo
);
6062 /* Build a constructor for a pointer to member function. It can be
6063 used to initialize global variables, local variable, or used
6064 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6067 If FORCE is non-zero, then force this conversion, even if
6068 we would rather not do it. Usually set when using an explicit
6071 Return error_mark_node, if something goes wrong. */
6074 build_ptrmemfunc (type
, pfn
, force
)
6078 tree index
= integer_zero_node
;
6079 tree delta
= integer_zero_node
;
6080 tree delta2
= integer_zero_node
;
6085 /* Handle multiple conversions of pointer to member fucntions. */
6086 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6088 tree ndelta
, ndelta2
, nindex
;
6089 /* Is is already the right type? */
6091 /* Sorry, can't do this, the backend is too stupid. */
6092 if (TYPE_METHOD_BASETYPE (TREE_TYPE (type
))
6093 == TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))))
6095 if (type
!= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6097 npfn
= build1 (NOP_EXPR
, TYPE_GET_PTRMEMFUNC_TYPE (type
), pfn
);
6098 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6103 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6107 if (TREE_CODE (pfn
) != CONSTRUCTOR
)
6110 ndelta
= convert (ptrdiff_type_node
, build_component_ref (pfn
, delta_identifier
, 0, 0));
6111 ndelta2
= convert (ptrdiff_type_node
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6112 index
= build_component_ref (pfn
, index_identifier
, 0, 0);
6113 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))),
6114 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6116 delta
= build_binary_op (PLUS_EXPR
, delta
, ndelta
, 1);
6117 delta2
= build_binary_op (PLUS_EXPR
, ndelta2
, delta2
, 1);
6118 e1
= fold (build (GT_EXPR
, integer_type_node
, index
, integer_zero_node
));
6120 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6121 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6122 tree_cons (NULL_TREE
, index
,
6123 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6124 e2
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6126 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6127 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6128 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6130 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6131 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6132 tree_cons (NULL_TREE
, index
,
6133 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6134 e3
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6135 return build_conditional_expr (e1
, e2
, e3
);
6138 ndelta
= TREE_VALUE (CONSTRUCTOR_ELTS (pfn
));
6139 nindex
= TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
)));
6140 npfn
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
))));
6141 npfn
= TREE_VALUE (CONSTRUCTOR_ELTS (npfn
));
6142 if (integer_zerop (nindex
))
6143 pfn
= integer_zero_node
;
6146 sorry ("value casting of varible nonnull pointer to member functions not supported");
6147 return error_mark_node
;
6151 /* Handle null pointer to member function conversions. */
6152 if (integer_zerop (pfn
))
6154 pfn
= build_c_cast (type
, integer_zero_node
, 0);
6155 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6156 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, integer_zero_node
,
6157 tree_cons (NULL_TREE
, integer_zero_node
,
6158 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6159 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6162 if (TREE_CODE (pfn
) == TREE_LIST
6163 || (TREE_CODE (pfn
) == ADDR_EXPR
6164 && TREE_CODE (TREE_OPERAND (pfn
, 0)) == TREE_LIST
))
6166 pfn
= instantiate_type (type
, pfn
, 1);
6167 if (pfn
== error_mark_node
)
6168 return error_mark_node
;
6169 if (TREE_CODE (pfn
) != ADDR_EXPR
)
6170 pfn
= build_unary_op (ADDR_EXPR
, pfn
, 0);
6173 /* Allow pointer to member conversions here. */
6174 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6175 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6177 delta2
= build_binary_op (PLUS_EXPR
, delta2
, delta
, 1);
6179 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6180 warning ("assuming pointer to member function is non-virtual");
6182 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6183 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6185 /* Find the offset to the vfield pointer in the object. */
6186 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6187 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6189 vfield_offset
= get_vfield_offset (vfield_offset
);
6190 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6192 /* Map everything down one to make room for the null pointer to member. */
6193 index
= size_binop (PLUS_EXPR
,
6194 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6196 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6200 index
= size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
6202 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6203 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6205 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6208 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6209 tree_cons (NULL_TREE
, index
,
6210 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6211 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6214 /* Convert value RHS to type TYPE as preparation for an assignment
6215 to an lvalue of type TYPE.
6216 The real work of conversion is done by `convert'.
6217 The purpose of this function is to generate error messages
6218 for assignments that are not allowed in C.
6219 ERRTYPE is a string to use in error messages:
6220 "assignment", "return", etc.
6222 C++: attempts to allow `convert' to find conversions involving
6223 implicit type conversion between aggregate and scalar types
6224 as per 8.5.6 of C++ manual. Does not randomly dereference
6225 pointers to aggregates! */
6228 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6234 register enum tree_code codel
= TREE_CODE (type
);
6235 register tree rhstype
;
6236 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6238 if (coder
== UNKNOWN_TYPE
)
6239 rhs
= instantiate_type (type
, rhs
, 1);
6241 if (coder
== ERROR_MARK
)
6242 return error_mark_node
;
6244 if (codel
== OFFSET_TYPE
)
6246 type
= TREE_TYPE (type
);
6247 codel
= TREE_CODE (type
);
6250 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6251 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6252 rhs
= TREE_OPERAND (rhs
, 0);
6254 if (rhs
== error_mark_node
)
6255 return error_mark_node
;
6257 if (TREE_VALUE (rhs
) == error_mark_node
)
6258 return error_mark_node
;
6260 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6262 rhs
= resolve_offset_ref (rhs
);
6263 if (rhs
== error_mark_node
)
6264 return error_mark_node
;
6265 rhstype
= TREE_TYPE (rhs
);
6266 coder
= TREE_CODE (rhstype
);
6269 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6270 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6271 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6272 rhs
= default_conversion (rhs
);
6273 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6274 rhs
= convert_from_reference (rhs
);
6276 rhstype
= TREE_TYPE (rhs
);
6277 coder
= TREE_CODE (rhstype
);
6279 /* This should no longer change types on us. */
6280 if (TREE_CODE (rhs
) == CONST_DECL
)
6281 rhs
= DECL_INITIAL (rhs
);
6282 else if (TREE_READONLY_DECL_P (rhs
))
6283 rhs
= decl_constant_value (rhs
);
6285 if (type
== rhstype
)
6287 overflow_warning (rhs
);
6291 if (coder
== VOID_TYPE
)
6293 error ("void value not ignored as it ought to be");
6294 return error_mark_node
;
6296 /* Arithmetic types all interconvert. */
6297 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
)
6298 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
))
6300 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6301 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6304 cp_warning ("`%T' used for argument %P of `%D'",
6305 rhstype
, parmnum
, fndecl
);
6307 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6309 /* And we should warn if assigning a negative value to
6310 an unsigned variable. */
6311 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6313 if (TREE_CODE (rhs
) == INTEGER_CST
6314 && TREE_NEGATED_INT (rhs
))
6317 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6318 rhs
, parmnum
, fndecl
);
6320 cp_warning ("%s of negative value `%E' to `%T'",
6321 errtype
, rhs
, type
);
6323 overflow_warning (rhs
);
6324 if (TREE_CONSTANT (rhs
))
6328 return convert_and_check (type
, rhs
);
6330 /* Conversions involving enums. */
6331 else if ((codel
== ENUMERAL_TYPE
6332 && (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
))
6333 || (coder
== ENUMERAL_TYPE
6334 && (INTEGRAL_CODE_P (codel
) || codel
== REAL_TYPE
)))
6336 return cp_convert (type
, rhs
, CONV_IMPLICIT
, 0);
6338 /* Conversions among pointers */
6339 else if (codel
== POINTER_TYPE
6340 && (coder
== POINTER_TYPE
6341 || (coder
== RECORD_TYPE
6342 && (IS_SIGNATURE_POINTER (rhstype
)
6343 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6345 register tree ttl
= TREE_TYPE (type
);
6349 if (coder
== RECORD_TYPE
)
6351 rhs
= build_optr_ref (rhs
);
6352 rhstype
= TREE_TYPE (rhs
);
6354 ttr
= TREE_TYPE (rhstype
);
6356 /* If both pointers are of aggregate type, then we
6357 can give better error messages, and save some work
6359 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6363 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6364 || type
== class_star_type_node
6365 || rhstype
== class_star_type_node
)
6366 binfo
= TYPE_BINFO (ttl
);
6368 binfo
= get_binfo (ttl
, ttr
, 1);
6370 if (binfo
== error_mark_node
)
6371 return error_mark_node
;
6373 return error_not_base_type (ttl
, ttr
);
6375 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6378 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6379 rhstype
, parmnum
, fndecl
);
6381 cp_pedwarn ("%s to `%T' from `%T' discards const",
6382 errtype
, type
, rhstype
);
6384 if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6387 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6388 rhstype
, parmnum
, fndecl
);
6390 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6391 errtype
, type
, rhstype
);
6395 /* Any non-function converts to a [const][volatile] void *
6396 and vice versa; otherwise, targets must be the same.
6397 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6398 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6399 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6400 || (ctt
= comp_target_types (type
, rhstype
, 1))
6401 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6402 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6404 /* ARM $4.8, commentary on p39. */
6405 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6406 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6408 cp_error ("no standard conversion from `%T' to `void *'", ttr
);
6409 return error_mark_node
;
6413 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6416 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6417 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6418 && rhs
!= null_pointer_node
)
6420 if (coder
== RECORD_TYPE
)
6421 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6424 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6427 /* Const and volatile mean something different for function types,
6428 so the usual warnings are not appropriate. */
6429 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6430 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6432 if (TREE_CODE (ttl
) == OFFSET_TYPE
6433 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6434 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6436 sorry ("%s between pointer to members converting across virtual baseclasses", errtype
);
6437 return error_mark_node
;
6439 else if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6442 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6443 rhstype
, parmnum
, fndecl
);
6445 cp_pedwarn ("%s to `%T' from `%T' discards const",
6446 errtype
, type
, rhstype
);
6448 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6451 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6452 rhstype
, parmnum
, fndecl
);
6454 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6455 errtype
, type
, rhstype
);
6457 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6458 && ! comp_target_types (type
, rhstype
, 1))
6461 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6462 rhstype
, parmnum
, fndecl
);
6464 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6465 errtype
, type
, rhstype
);
6469 else if (TREE_CODE (ttr
) == OFFSET_TYPE
6470 && TREE_CODE (ttl
) != OFFSET_TYPE
)
6472 /* Normally, pointers to different type codes (other
6473 than void) are not compatible, but we perform
6474 some type instantiation if that resolves the
6475 ambiguity of (X Y::*) and (X *). */
6477 if (current_class_decl
)
6479 if (TREE_CODE (rhs
) == INTEGER_CST
)
6481 rhs
= build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (ttr
)),
6482 current_class_decl
, rhs
);
6483 return convert_for_assignment (type
, rhs
,
6484 errtype
, fndecl
, parmnum
);
6487 if (TREE_CODE (ttl
) == METHOD_TYPE
)
6488 error ("%s between pointer-to-method and pointer-to-member types",
6491 error ("%s between pointer and pointer-to-member types", errtype
);
6492 return error_mark_node
;
6496 int add_quals
= 0, const_parity
= 0, volatile_parity
= 0;
6498 int unsigned_parity
;
6501 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6502 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6505 const_parity
|= TYPE_READONLY (ttl
) < TYPE_READONLY (ttr
);
6506 volatile_parity
|= TYPE_VOLATILE (ttl
) < TYPE_VOLATILE (ttr
);
6509 && (TYPE_READONLY (ttl
) > TYPE_READONLY (ttr
)
6510 || TYPE_VOLATILE (ttl
) > TYPE_VOLATILE (ttr
)))
6512 left_const
&= TYPE_READONLY (ttl
);
6514 if (TREE_CODE (ttl
) != POINTER_TYPE
6515 || TREE_CODE (ttr
) != POINTER_TYPE
)
6518 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6519 if (unsigned_parity
)
6521 if (TREE_UNSIGNED (ttl
))
6522 ttr
= unsigned_type (ttr
);
6524 ttl
= unsigned_type (ttl
);
6527 if (comp_target_types (ttl
, ttr
, nptrs
) > 0)
6532 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6533 rhstype
, parmnum
, fndecl
);
6535 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6536 errtype
, type
, rhstype
);
6541 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6542 rhstype
, parmnum
, fndecl
);
6544 cp_pedwarn ("%s to `%T' from `%T' discards const",
6545 errtype
, type
, rhstype
);
6547 if (volatile_parity
)
6550 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6551 rhstype
, parmnum
, fndecl
);
6553 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6554 errtype
, type
, rhstype
);
6556 if (unsigned_parity
> 0)
6559 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6560 rhstype
, parmnum
, fndecl
);
6562 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6563 errtype
, type
, rhstype
);
6565 else if (unsigned_parity
< 0)
6568 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6569 rhstype
, parmnum
, fndecl
);
6571 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6572 errtype
, type
, rhstype
);
6575 /* C++ is not so friendly about converting function and
6576 member function pointers as C. Emit warnings here. */
6577 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6578 || TREE_CODE (ttl
) == METHOD_TYPE
)
6579 if (! comptypes (ttl
, ttr
, 0))
6581 warning ("conflicting function types in %s:", errtype
);
6582 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6585 else if (TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6587 /* When does this happen? */
6588 my_friendly_abort (119);
6589 /* Conversion of a pointer-to-member type to void *. */
6590 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6591 TREE_TYPE (rhs
) = type
;
6594 else if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6596 /* When does this happen? */
6597 my_friendly_abort (120);
6598 /* Conversion of a pointer-to-member type to void *. */
6599 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6600 TREE_TYPE (rhs
) = type
;
6606 cp_error ("passing `%T' as argument %P of `%D'",
6607 rhstype
, parmnum
, fndecl
);
6609 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6610 return error_mark_node
;
6613 return convert (type
, rhs
);
6615 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6617 /* An explicit constant 0 can convert to a pointer,
6618 but not a 0 that results from casting or folding. */
6619 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6622 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6623 rhstype
, parmnum
, fndecl
);
6625 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6626 errtype
, type
, rhstype
);
6627 return convert (type
, rhs
);
6629 return null_pointer_node
;
6631 else if (codel
== INTEGER_TYPE
6632 && (coder
== POINTER_TYPE
6633 || (coder
== RECORD_TYPE
6634 && (IS_SIGNATURE_POINTER (rhstype
)
6635 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6636 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6639 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6640 rhstype
, parmnum
, fndecl
);
6642 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6643 errtype
, type
, rhstype
);
6644 return convert (type
, rhs
);
6646 else if (codel
== BOOLEAN_TYPE
6647 && (coder
== POINTER_TYPE
6648 || (coder
== RECORD_TYPE
6649 && (IS_SIGNATURE_POINTER (rhstype
)
6650 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6651 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6652 return convert (type
, rhs
);
6655 else if (((coder
== POINTER_TYPE
&& TREE_CODE (rhs
) == ADDR_EXPR
6656 && TREE_CODE (rhstype
) == POINTER_TYPE
6657 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6658 || integer_zerop (rhs
)
6659 || TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6660 && TYPE_PTRMEMFUNC_P (type
))
6662 /* compatible pointer to member functions. */
6663 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), rhs
, 0);
6665 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6666 return error_mark_node
;
6668 /* This should no longer happen. References are initialized via
6669 `convert_for_initialization'. They should otherwise be
6670 bashed before coming here. */
6671 else if (codel
== REFERENCE_TYPE
)
6672 my_friendly_abort (317);
6673 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6675 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6676 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6679 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6680 return convert (type
, rhs
);
6682 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6683 return error_mark_node
;
6686 /* Convert RHS to be of type TYPE. If EXP is non-zero,
6687 it is the target of the initialization.
6688 ERRTYPE is a string to use in error messages.
6690 Two major differences between the behavior of
6691 `convert_for_assignment' and `convert_for_initialization'
6692 are that references are bashed in the former, while
6693 copied in the latter, and aggregates are assigned in
6694 the former (operator=) while initialized in the
6697 If using constructor make sure no conversion operator exists, if one does
6698 exist, an ambiguity exists. */
6700 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6701 tree exp
, type
, rhs
;
6707 register enum tree_code codel
= TREE_CODE (type
);
6708 register tree rhstype
;
6709 register enum tree_code coder
;
6711 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6712 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6713 if (TREE_CODE (rhs
) == NOP_EXPR
6714 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6715 && codel
!= REFERENCE_TYPE
)
6716 rhs
= TREE_OPERAND (rhs
, 0);
6718 if (rhs
== error_mark_node
6719 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6720 return error_mark_node
;
6722 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6724 rhs
= resolve_offset_ref (rhs
);
6725 if (rhs
== error_mark_node
)
6726 return error_mark_node
;
6727 rhstype
= TREE_TYPE (rhs
);
6728 coder
= TREE_CODE (rhstype
);
6731 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6732 && TREE_CODE (type
) != ARRAY_TYPE
&& TREE_CODE (type
) != REFERENCE_TYPE
)
6733 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6734 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6735 rhs
= default_conversion (rhs
);
6737 rhstype
= TREE_TYPE (rhs
);
6738 coder
= TREE_CODE (rhstype
);
6740 if (coder
== UNKNOWN_TYPE
)
6742 rhs
= instantiate_type (type
, rhs
, 1);
6743 rhstype
= TREE_TYPE (rhs
);
6744 coder
= TREE_CODE (rhstype
);
6747 if (coder
== ERROR_MARK
)
6748 return error_mark_node
;
6751 /* This is *not* the quick way out! It is the way to disaster. */
6752 if (type
== rhstype
)
6756 /* We accept references to incomplete types, so we can
6757 return here before checking if RHS is of complete type. */
6759 if (codel
== REFERENCE_TYPE
)
6761 /* This should eventually happen in convert_arguments. */
6762 extern int warningcount
, errorcount
;
6766 savew
= warningcount
, savee
= errorcount
;
6767 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6768 exp
? exp
: error_mark_node
);
6771 if (warningcount
> savew
)
6772 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6773 else if (errorcount
> savee
)
6774 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6779 rhs
= require_complete_type (rhs
);
6780 if (rhs
== error_mark_node
)
6781 return error_mark_node
;
6783 if (exp
!= 0) exp
= require_complete_type (exp
);
6784 if (exp
== error_mark_node
)
6785 return error_mark_node
;
6787 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6788 rhstype
= TREE_TYPE (rhstype
);
6790 if (TYPE_LANG_SPECIFIC (type
)
6791 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6792 return build_signature_pointer_constructor (type
, rhs
);
6794 if (IS_AGGR_TYPE (type
)
6795 && (TYPE_NEEDS_CONSTRUCTING (type
) || TREE_HAS_CONSTRUCTOR (rhs
)))
6797 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
6799 /* This is sufficient to perform initialization. No need,
6800 apparently, to go through X(X&) to do first-cut
6801 initialization. Return through a TARGET_EXPR so that we get
6802 cleanups if it is used. */
6803 if (TREE_CODE (rhs
) == CALL_EXPR
)
6805 rhs
= build_cplus_new (type
, rhs
, 0);
6808 /* Handle the case of default parameter initialization and
6809 initialization of static variables. */
6810 else if (TREE_CODE (rhs
) == TARGET_EXPR
)
6812 else if (TREE_CODE (rhs
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (rhs
))
6814 my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs
, 0)) == CALL_EXPR
, 318);
6817 my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1)) == NULL_TREE
, 316);
6818 TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1))
6819 = build_unary_op (ADDR_EXPR
, exp
, 0);
6822 rhs
= build_cplus_new (type
, TREE_OPERAND (rhs
, 0), 0);
6826 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
)
6827 || (IS_AGGR_TYPE (rhstype
) && UNIQUELY_DERIVED_FROM_P (type
, rhstype
)))
6829 if (TYPE_HAS_INIT_REF (type
))
6831 tree init
= build_method_call (exp
, constructor_name_full (type
),
6832 build_tree_list (NULL_TREE
, rhs
),
6833 TYPE_BINFO (type
), LOOKUP_NORMAL
);
6835 if (init
== error_mark_node
)
6836 return error_mark_node
;
6840 exp
= build_cplus_new (type
, init
, 0);
6844 return build (COMPOUND_EXPR
, type
, init
, exp
);
6847 /* ??? The following warnings are turned off because
6848 this is another place where the default X(X&) constructor
6850 if (TYPE_HAS_ASSIGNMENT (type
))
6851 cp_warning ("bitwise copy: `%T' defines operator=", type
);
6853 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6854 rhs
= convert_from_reference (rhs
);
6855 if (type
!= rhstype
)
6857 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6858 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6864 return convert (type
, rhs
);
6867 if (type
== TREE_TYPE (rhs
))
6869 if (TREE_READONLY_DECL_P (rhs
))
6870 rhs
= decl_constant_value (rhs
);
6874 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
6877 /* Expand an ASM statement with operands, handling output operands
6878 that are not variables or INDIRECT_REFS by transforming such
6879 cases into cases that expand_asm_operands can handle.
6881 Arguments are same as for expand_asm_operands.
6883 We don't do default conversions on all inputs, because it can screw
6884 up operands that are expected to be in memory. */
6887 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
6888 tree string
, outputs
, inputs
, clobbers
;
6893 int noutputs
= list_length (outputs
);
6895 /* o[I] is the place that output number I should be written. */
6896 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
6899 /* Record the contents of OUTPUTS before it is modified. */
6900 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6901 o
[i
] = TREE_VALUE (tail
);
6903 /* Generate the ASM_OPERANDS insn;
6904 store into the TREE_VALUEs of OUTPUTS some trees for
6905 where the values were actually stored. */
6906 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
6908 /* Copy all the intermediate outputs into the specified outputs. */
6909 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6911 if (o
[i
] != TREE_VALUE (tail
))
6913 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
6914 const0_rtx
, VOIDmode
, 0);
6917 /* Detect modification of read-only values.
6918 (Otherwise done by build_modify_expr.) */
6921 tree type
= TREE_TYPE (o
[i
]);
6922 if (TYPE_READONLY (type
)
6923 || ((TREE_CODE (type
) == RECORD_TYPE
6924 || TREE_CODE (type
) == UNION_TYPE
)
6925 && C_TYPE_FIELDS_READONLY (type
)))
6926 readonly_error (o
[i
], "modification by `asm'", 1);
6930 /* Those MODIFY_EXPRs could do autoincrements. */
6934 /* Expand a C `return' statement.
6935 RETVAL is the expression for what to return,
6936 or a null pointer for `return;' with no value.
6938 C++: upon seeing a `return', we must call destructors on all
6939 variables in scope which had constructors called on them.
6940 This means that if in a destructor, the base class destructors
6941 must be called before returning.
6943 The RETURN statement in C++ has initialization semantics. */
6946 c_expand_return (retval
)
6949 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
6950 extern tree dtor_label
, ctor_label
;
6951 tree result
= DECL_RESULT (current_function_decl
);
6952 tree valtype
= TREE_TYPE (result
);
6953 register int use_temp
= 0;
6954 int returns_value
= 1;
6956 if (TREE_THIS_VOLATILE (current_function_decl
))
6957 warning ("function declared `noreturn' has a `return' statement");
6959 if (retval
== error_mark_node
)
6961 current_function_returns_null
= 1;
6965 if (retval
== NULL_TREE
)
6967 /* A non-named return value does not count. */
6969 /* Can't just return from a destructor. */
6972 expand_goto (dtor_label
);
6976 if (DECL_CONSTRUCTOR_P (current_function_decl
))
6977 retval
= current_class_decl
;
6978 else if (DECL_NAME (result
) != NULL_TREE
6979 && TREE_CODE (valtype
) != VOID_TYPE
)
6983 current_function_returns_null
= 1;
6985 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
6987 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
6989 pedwarn ("`return' with no value, in function returning non-void");
6990 /* Clear this, so finish_function won't say that we
6991 reach the end of a non-void function (which we don't,
6992 we gave a return!). */
6993 current_function_returns_null
= 0;
6997 expand_null_return ();
7001 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
7002 && retval
!= current_class_decl
)
7004 error ("return from a constructor: use `this = ...' instead");
7005 retval
= current_class_decl
;
7008 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
7010 current_function_returns_null
= 1;
7011 /* We do this here so we'll avoid a warning about how the function
7012 "may or may not return a value" in finish_function. */
7016 pedwarn ("`return' with a value, in function returning void");
7017 expand_return (retval
);
7019 /* Add some useful error checking for C++. */
7020 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
7022 tree whats_returned
;
7023 tree tmp_result
= result
;
7025 /* Don't initialize directly into a non-BLKmode retval, since that
7026 could lose when being inlined by another caller. (GCC can't
7027 read the function return register in an inline function when
7028 the return value is being ignored). */
7029 if (result
&& TYPE_MODE (TREE_TYPE (tmp_result
)) != BLKmode
)
7032 /* convert to reference now, so we can give error if we
7033 return an reference to a non-lvalue. */
7034 retval
= convert_for_initialization (tmp_result
, valtype
, retval
,
7035 LOOKUP_NORMAL
, "return",
7038 /* Sort through common things to see what it is
7039 we are returning. */
7040 whats_returned
= retval
;
7041 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
7043 whats_returned
= TREE_OPERAND (whats_returned
, 1);
7044 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7045 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7047 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7049 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7050 while (TREE_CODE (whats_returned
) == NEW_EXPR
7051 || TREE_CODE (whats_returned
) == TARGET_EXPR
7052 || TREE_CODE (whats_returned
) == WITH_CLEANUP_EXPR
)
7054 /* Get the target. */
7055 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7056 warning ("returning reference to temporary");
7060 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
7062 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
7063 warning ("reference to non-lvalue returned");
7064 else if (! TREE_STATIC (whats_returned
)
7065 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
)))
7066 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7069 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7071 tree whats_returned
= TREE_OPERAND (retval
, 0);
7073 if (TREE_CODE (whats_returned
) == VAR_DECL
7074 && DECL_NAME (whats_returned
)
7075 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7076 && !TREE_STATIC (whats_returned
))
7077 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7080 /* Now deal with possible C++ hair:
7081 (1) Compute the return value.
7082 (2) If there are aggregate values with destructors which
7083 must be cleaned up, clean them (taking care
7084 not to clobber the return value).
7085 (3) If an X(X&) constructor is defined, the return
7086 value must be returned via that. */
7088 if (retval
== result
7089 /* Watch out for constructors, which "return" aggregates
7090 via initialization, but which otherwise "return" a pointer. */
7091 || DECL_CONSTRUCTOR_P (current_function_decl
))
7093 /* This is just an error--it's already been reported. */
7094 if (TYPE_SIZE (valtype
) == NULL_TREE
)
7097 if (TYPE_MODE (valtype
) != BLKmode
7098 && any_pending_cleanups (1))
7100 retval
= get_temp_regvar (valtype
, retval
);
7101 use_temp
= obey_regdecls
;
7104 else if (IS_AGGR_TYPE (valtype
) && TYPE_NEEDS_CONSTRUCTING (valtype
))
7106 /* Throw away the cleanup that `build_functional_cast' gave us. */
7107 if (TREE_CODE (retval
) == WITH_CLEANUP_EXPR
7108 && TREE_CODE (TREE_OPERAND (retval
, 0)) == TARGET_EXPR
)
7109 retval
= TREE_OPERAND (retval
, 0);
7110 expand_aggr_init (result
, retval
, 0, LOOKUP_ONLYCONVERTING
);
7111 expand_cleanups_to (NULL_TREE
);
7112 DECL_INITIAL (result
) = NULL_TREE
;
7117 if (TYPE_MODE (valtype
) == VOIDmode
)
7119 if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
7120 && warn_return_type
)
7121 warning ("return of void value in function returning non-void");
7122 expand_expr_stmt (retval
);
7126 else if (TYPE_MODE (valtype
) != BLKmode
7127 && any_pending_cleanups (1))
7129 retval
= get_temp_regvar (valtype
, retval
);
7130 expand_cleanups_to (NULL_TREE
);
7131 use_temp
= obey_regdecls
;
7136 retval
= convert_for_initialization (result
, valtype
, retval
,
7138 "return", NULL_TREE
, 0);
7139 DECL_INITIAL (result
) = NULL_TREE
;
7141 if (retval
== error_mark_node
)
7147 if (retval
!= NULL_TREE
7148 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7149 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7150 current_function_return_value
= retval
;
7154 /* Everything's great--RETVAL is in RESULT. */
7155 if (original_result_rtx
)
7157 store_expr (result
, original_result_rtx
, 0);
7158 expand_cleanups_to (NULL_TREE
);
7160 else if (retval
&& retval
!= result
)
7162 /* Clear this out so the later call to decl_function_context
7163 won't end up bombing on us. */
7164 if (DECL_CONTEXT (result
) == error_mark_node
)
7165 DECL_CONTEXT (result
) = NULL_TREE
;
7166 /* Here is where we finally get RETVAL into RESULT.
7167 `expand_return' does the magic of protecting
7168 RESULT from cleanups. */
7169 retval
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (result
), retval
);
7170 /* This part _must_ come second, because expand_return looks for
7171 the INIT_EXPR as the toplevel node only. :-( */
7172 retval
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7173 TREE_SIDE_EFFECTS (retval
) = 1;
7174 expand_return (retval
);
7177 expand_return (result
);
7179 use_variable (DECL_RTL (result
));
7180 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7181 expand_goto (ctor_label
);
7183 expand_null_return ();
7187 /* We may still need to put RETVAL into RESULT. */
7188 result
= DECL_RESULT (current_function_decl
);
7189 if (original_result_rtx
)
7191 /* Here we have a named return value that went
7192 into memory. We can compute RETVAL into that. */
7194 expand_assignment (result
, retval
, 0, 0);
7196 store_expr (result
, original_result_rtx
, 0);
7197 result
= make_tree (TREE_TYPE (result
), original_result_rtx
);
7199 else if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7201 /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do. */
7202 expand_goto (ctor_label
);
7206 /* Here is where we finally get RETVAL into RESULT.
7207 `expand_return' does the magic of protecting
7208 RESULT from cleanups. */
7209 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7210 TREE_SIDE_EFFECTS (result
) = 1;
7211 expand_return (result
);
7213 else if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
)
7214 expand_return (result
);
7217 current_function_returns_value
= returns_value
;
7219 /* These wind up after the BARRIER, which causes problems for
7220 expand_end_binding. What purpose were they supposed to serve? */
7221 if (original_result_rtx
)
7222 use_variable (original_result_rtx
);
7224 use_variable (DECL_RTL (DECL_RESULT (current_function_decl
)));
7227 /* One way to clear out cleanups that EXPR might
7228 generate. Note that this code will really be
7229 dead code, but that is ok--cleanups that were
7230 needed were handled by the magic of `return'. */
7231 expand_cleanups_to (NULL_TREE
);
7234 /* Start a C switch statement, testing expression EXP.
7235 Return EXP if it is valid, an error node otherwise. */
7238 c_expand_start_case (exp
)
7242 register enum tree_code code
;
7244 /* Convert from references, etc. */
7245 exp
= default_conversion (exp
);
7246 type
= TREE_TYPE (exp
);
7247 code
= TREE_CODE (type
);
7249 if (IS_AGGR_TYPE_CODE (code
))
7250 exp
= build_type_conversion (CONVERT_EXPR
, integer_type_node
, exp
, 1);
7252 if (exp
== NULL_TREE
)
7254 error ("switch quantity not an integer");
7255 exp
= error_mark_node
;
7257 type
= TREE_TYPE (exp
);
7258 code
= TREE_CODE (type
);
7260 if (code
!= INTEGER_TYPE
&& code
!= ENUMERAL_TYPE
&& code
!= ERROR_MARK
)
7262 error ("switch quantity not an integer");
7263 exp
= error_mark_node
;
7269 exp
= default_conversion (exp
);
7270 type
= TREE_TYPE (exp
);
7271 index
= get_unwidened (exp
, 0);
7272 /* We can't strip a conversion from a signed type to an unsigned,
7273 because if we did, int_fits_type_p would do the wrong thing
7274 when checking case values for being in range,
7275 and it's too hard to do the right thing. */
7276 if (TREE_UNSIGNED (TREE_TYPE (exp
))
7277 == TREE_UNSIGNED (TREE_TYPE (index
)))
7281 expand_start_case (1, build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
),
7282 type
, "switch statement");
7287 /* CONSTP remembers whether or not all the intervening pointers in the `to'
7288 type have been const. */
7290 comp_ptr_ttypes_real (to
, from
, constp
)
7294 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7296 if (TREE_CODE (to
) != TREE_CODE (from
))
7299 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7300 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7304 && (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7305 || TYPE_VOLATILE (to
) > TYPE_READONLY (from
)))
7307 constp
&= TYPE_READONLY (to
);
7309 if (TREE_CODE (to
) != POINTER_TYPE
)
7310 return comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1);
7314 /* When comparing, say, char ** to char const **, this function takes the
7315 'char *' and 'char const *'. Do not pass non-pointer types to this
7318 comp_ptr_ttypes (to
, from
)
7321 return comp_ptr_ttypes_real (to
, from
, 1);