1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
42 extern void compiler_error ();
44 static tree convert_for_assignment
PROTO((tree
, tree
, char*, tree
,
46 static tree pointer_int_sum
PROTO((enum tree_code
, tree
, tree
));
47 static tree rationalize_conditional_expr
PROTO((enum tree_code
, tree
));
48 static int comp_target_parms
PROTO((tree
, tree
, int));
49 static int comp_ptr_ttypes_real
PROTO((tree
, tree
, int));
50 static int comp_ptr_ttypes_const
PROTO((tree
, tree
));
51 static int comp_ptr_ttypes_reinterpret
PROTO((tree
, tree
));
52 static int comp_array_types
PROTO((int (*) (tree
, tree
, int), tree
,
54 static tree build_ptrmemfunc1
PROTO((tree
, tree
, tree
, tree
, tree
));
55 static tree common_base_type
PROTO((tree
, tree
));
57 static tree convert_sequence
PROTO((tree
, tree
));
59 static tree lookup_anon_field
PROTO((tree
, tree
));
60 static tree pointer_diff
PROTO((tree
, tree
, tree
));
61 static tree qualify_type
PROTO((tree
, tree
));
62 static tree get_delta_difference
PROTO((tree
, tree
, int));
64 /* Return the target type of TYPE, which meas return T for:
65 T*, T&, T[], T (...), and otherwise, just T. */
71 if (TREE_CODE (type
) == REFERENCE_TYPE
)
72 type
= TREE_TYPE (type
);
73 while (TREE_CODE (type
) == POINTER_TYPE
74 || TREE_CODE (type
) == ARRAY_TYPE
75 || TREE_CODE (type
) == FUNCTION_TYPE
76 || TREE_CODE (type
) == METHOD_TYPE
77 || TREE_CODE (type
) == OFFSET_TYPE
)
78 type
= TREE_TYPE (type
);
82 /* Do `exp = require_complete_type (exp);' to make sure exp
83 does not have an incomplete type. (That includes void types.)
84 Returns the error_mark_node if the VALUE does not have
85 complete type when this function returns. */
88 require_complete_type (value
)
93 if (processing_template_decl
)
96 if (TREE_CODE (value
) == OVERLOAD
)
97 type
= unknown_type_node
;
99 type
= TREE_TYPE (value
);
101 /* First, detect a valid value with a complete type. */
102 if (TYPE_SIZE (type
) != 0
103 && type
!= void_type_node
104 && ! (TYPE_LANG_SPECIFIC (type
)
105 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
106 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
109 /* If we see X::Y, we build an OFFSET_TYPE which has
110 not been laid out. Try to avoid an error by interpreting
111 it as this->X::Y, if reasonable. */
112 if (TREE_CODE (value
) == OFFSET_REF
113 && current_class_ref
!= 0
114 && TREE_OPERAND (value
, 0) == current_class_ref
)
116 tree base
, member
= TREE_OPERAND (value
, 1);
117 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
118 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
119 base
= convert_pointer_to (basetype
, current_class_ptr
);
120 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
121 build_indirect_ref (base
, NULL_PTR
), member
);
122 return require_complete_type (value
);
125 if (complete_type_or_else (type
))
128 return error_mark_node
;
131 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
132 a template instantiation, do the instantiation. Returns TYPE,
133 whether or not it could be completed, unless something goes
134 horribly wrong, in which case the error_mark_node is returned. */
140 if (type
== NULL_TREE
)
141 /* Rather than crash, we return something sure to cause an error
143 return error_mark_node
;
145 if (type
== error_mark_node
|| TYPE_SIZE (type
) != NULL_TREE
)
147 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
149 tree t
= complete_type (TREE_TYPE (type
));
150 if (TYPE_SIZE (t
) != NULL_TREE
&& ! processing_template_decl
)
152 TYPE_NEEDS_CONSTRUCTING (type
)
153 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
154 TYPE_NEEDS_DESTRUCTOR (type
)
155 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
157 else if (IS_AGGR_TYPE (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
158 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
163 /* Like complete_type, but issue an error if the TYPE cannot be
164 completed. Returns NULL_TREE if the type cannot be made
168 complete_type_or_else (type
)
171 type
= complete_type (type
);
172 if (type
== error_mark_node
)
173 /* We already issued an error. */
175 else if (!TYPE_SIZE (type
))
177 incomplete_type_error (NULL_TREE
, type
);
184 /* Return truthvalue of whether type of EXP is instantiated. */
190 return (TREE_CODE (exp
) == OVERLOAD
191 || TREE_CODE (exp
) == TREE_LIST
192 || TREE_TYPE (exp
) == unknown_type_node
193 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
194 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
197 /* Return truthvalue of whether T is function (or pfn) type. */
203 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
204 || (TREE_CODE (t
) == POINTER_TYPE
205 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
206 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
209 /* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
210 does not have an uninstantiated type.
211 TYPE is type to instantiate with, if uninstantiated. */
214 require_instantiated_type (type
, exp
, errval
)
215 tree type
, exp
, errval
;
217 if (TREE_TYPE (exp
) == NULL_TREE
)
219 error ("argument list may not have an initializer list");
223 if (TREE_CODE (exp
) == OVERLOAD
224 || TREE_TYPE (exp
) == unknown_type_node
225 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
226 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
))
228 exp
= instantiate_type (type
, exp
, 1);
229 if (TREE_TYPE (exp
) == error_mark_node
)
235 /* Return a variant of TYPE which has all the type qualifiers of LIKE
236 as well as those of TYPE. */
239 qualify_type (type
, like
)
242 int constflag
= TYPE_READONLY (type
) || TYPE_READONLY (like
);
243 int volflag
= TYPE_VOLATILE (type
) || TYPE_VOLATILE (like
);
244 /* @@ Must do member pointers here. */
245 return cp_build_type_variant (type
, constflag
, volflag
);
248 /* Return the common type of two parameter lists.
249 We assume that comptypes has already been done and returned 1;
250 if that isn't so, this may crash.
252 As an optimization, free the space we allocate if the parameter
253 lists are already common. */
259 tree oldargs
= p1
, newargs
, n
;
262 char *first_obj
= (char *) oballoc (0);
264 len
= list_length (p1
);
265 newargs
= tree_last (p1
);
267 if (newargs
== void_list_node
)
276 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
281 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
283 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
285 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
288 else if (! TREE_PURPOSE (p1
))
290 if (TREE_PURPOSE (p2
))
292 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
298 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
300 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
302 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
305 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
308 TREE_VALUE (n
) = TREE_VALUE (p1
);
319 /* Given a type, perhaps copied for a typedef,
320 find the "original" version of it. */
325 while (TYPE_NAME (t
) != NULL_TREE
)
327 tree x
= TYPE_NAME (t
);
328 if (TREE_CODE (x
) != TYPE_DECL
)
330 x
= DECL_ORIGINAL_TYPE (x
);
338 /* Return the common type of two types.
339 We assume that comptypes has already been done and returned 1;
340 if that isn't so, this may crash.
342 This is the type for the result of most arithmetic operations
343 if the operands have the given two types.
345 We do not deal with enumeral types here because they have already been
346 converted to integer types. */
352 register enum tree_code code1
;
353 register enum tree_code code2
;
356 /* Save time if the two types are the same. */
359 t1
= original_type (t1
);
360 t2
= original_type (t2
);
364 /* If one type is nonsense, use the other. */
365 if (t1
== error_mark_node
)
367 if (t2
== error_mark_node
)
370 /* Merge the attributes. */
371 attributes
= merge_machine_type_attributes (t1
, t2
);
373 { register tree a1
, a2
;
374 a1
= TYPE_ATTRIBUTES (t1
);
375 a2
= TYPE_ATTRIBUTES (t2
);
377 /* Either one unset? Take the set one. */
379 if (!(attributes
= a1
))
382 /* One that completely contains the other? Take it. */
384 else if (a2
&& !attribute_list_contained (a1
, a2
))
386 if (attribute_list_contained (a2
, a1
))
390 /* Pick the longest list, and hang on the other list. */
391 /* ??? For the moment we punt on the issue of attrs with args. */
393 if (list_length (a1
) < list_length (a2
))
394 attributes
= a2
, a2
= a1
;
396 for (; a2
; a2
= TREE_CHAIN (a2
))
397 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
398 attributes
) == NULL_TREE
)
401 TREE_CHAIN (a1
) = attributes
;
408 /* Treat an enum type as the unsigned integer type of the same width. */
410 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
411 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
412 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
413 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
415 if (TYPE_PTRMEMFUNC_P (t1
))
416 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
417 if (TYPE_PTRMEMFUNC_P (t2
))
418 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
420 code1
= TREE_CODE (t1
);
421 code2
= TREE_CODE (t2
);
423 /* If one type is complex, form the common type of the non-complex
424 components, then make that complex. Use T1 or T2 if it is the
426 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
428 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
429 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
430 tree subtype
= common_type (subtype1
, subtype2
);
432 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
433 return build_type_attribute_variant (t1
, attributes
);
434 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
435 return build_type_attribute_variant (t2
, attributes
);
437 return build_type_attribute_variant (build_complex_type (subtype
),
445 /* If only one is real, use it as the result. */
447 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
448 return build_type_attribute_variant (t1
, attributes
);
450 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
451 return build_type_attribute_variant (t2
, attributes
);
453 /* Both real or both integers; use the one with greater precision. */
455 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
456 return build_type_attribute_variant (t1
, attributes
);
457 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
458 return build_type_attribute_variant (t2
, attributes
);
460 /* Same precision. Prefer longs to ints even when same size. */
462 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
463 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
464 return build_type_attribute_variant (long_unsigned_type_node
,
467 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
468 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
470 /* But preserve unsignedness from the other type,
471 since long cannot hold all the values of an unsigned int. */
472 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
473 t1
= long_unsigned_type_node
;
475 t1
= long_integer_type_node
;
476 return build_type_attribute_variant (t1
, attributes
);
479 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
480 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
481 return build_type_attribute_variant (long_double_type_node
,
484 /* Otherwise prefer the unsigned one. */
486 if (TREE_UNSIGNED (t1
))
487 return build_type_attribute_variant (t1
, attributes
);
489 return build_type_attribute_variant (t2
, attributes
);
493 /* For two pointers, do this recursively on the target type,
494 and combine the qualifiers of the two types' targets. */
495 /* This code was turned off; I don't know why.
496 But ANSI C++ specifies doing this with the qualifiers.
497 So I turned it on again. */
499 tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (t1
));
500 tree tt2
= TYPE_MAIN_VARIANT (TREE_TYPE (t2
));
502 = TYPE_READONLY (TREE_TYPE (t1
)) || TYPE_READONLY (TREE_TYPE (t2
));
504 = TYPE_VOLATILE (TREE_TYPE (t1
)) || TYPE_VOLATILE (TREE_TYPE (t2
));
509 else if (tt1
== void_type_node
|| tt2
== void_type_node
)
510 target
= void_type_node
;
511 else if (tt1
== unknown_type_node
)
513 else if (tt2
== unknown_type_node
)
516 target
= common_type (tt1
, tt2
);
518 target
= cp_build_type_variant (target
, constp
, volatilep
);
519 if (code1
== POINTER_TYPE
)
520 t1
= build_pointer_type (target
);
522 t1
= build_reference_type (target
);
523 t1
= build_type_attribute_variant (t1
, attributes
);
525 if (TREE_CODE (target
) == METHOD_TYPE
)
526 t1
= build_ptrmemfunc_type (t1
);
533 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
534 /* Save space: see if the result is identical to one of the args. */
535 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
536 return build_type_attribute_variant (t1
, attributes
);
537 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
538 return build_type_attribute_variant (t2
, attributes
);
539 /* Merge the element types, and have a size if either arg has one. */
540 t1
= build_cplus_array_type
541 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
542 return build_type_attribute_variant (t1
, attributes
);
546 /* Function types: prefer the one that specified arg types.
547 If both do, merge the arg types. Also merge the return types. */
549 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
550 tree p1
= TYPE_ARG_TYPES (t1
);
551 tree p2
= TYPE_ARG_TYPES (t2
);
554 /* Save space: see if the result is identical to one of the args. */
555 if (valtype
== TREE_TYPE (t1
) && ! p2
)
556 return build_type_attribute_variant (t1
, attributes
);
557 if (valtype
== TREE_TYPE (t2
) && ! p1
)
558 return build_type_attribute_variant (t2
, attributes
);
560 /* Simple way if one arg fails to specify argument types. */
561 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
563 rval
= build_function_type (valtype
, p2
);
564 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
565 rval
= build_exception_variant (rval
, raises
);
566 return build_type_attribute_variant (rval
, attributes
);
568 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
569 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
571 rval
= build_function_type (valtype
, p1
);
573 rval
= build_exception_variant (rval
, raises
);
574 return build_type_attribute_variant (rval
, attributes
);
577 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
578 rval
= build_exception_variant (rval
, raises
);
579 return build_type_attribute_variant (rval
, attributes
);
584 t1
= TYPE_MAIN_VARIANT (t1
);
585 t2
= TYPE_MAIN_VARIANT (t2
);
587 if (DERIVED_FROM_P (t1
, t2
) && binfo_or_else (t1
, t2
))
588 return build_type_attribute_variant (t1
, attributes
);
589 else if (binfo_or_else (t2
, t1
))
590 return build_type_attribute_variant (t2
, attributes
);
593 compiler_error ("common_type called with uncommon aggregate types");
594 return error_mark_node
;
598 if (TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
600 /* Get this value the long way, since TYPE_METHOD_BASETYPE
601 is just the main variant of this. */
605 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
606 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
608 if (comptypes (b1
, b2
, 1)
609 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
610 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
613 if (binfo_or_else (b2
, b1
) == NULL_TREE
)
614 compiler_error ("common_type called with uncommon method types");
615 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
618 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
620 /* If this was a member function type, get back to the
621 original type of type member function (i.e., without
622 the class instance variable up front. */
623 t1
= build_function_type (TREE_TYPE (t1
),
624 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
625 t2
= build_function_type (TREE_TYPE (t2
),
626 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
627 t3
= common_type (t1
, t2
);
628 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
),
629 TYPE_ARG_TYPES (t3
));
630 t1
= build_exception_variant (t3
, raises
);
633 compiler_error ("common_type called with uncommon method types");
635 return build_type_attribute_variant (t1
, attributes
);
638 if (TREE_TYPE (t1
) == TREE_TYPE (t2
))
640 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
641 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
643 if (comptypes (b1
, b2
, 1)
644 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
645 return build_type_attribute_variant (t2
, attributes
);
646 else if (binfo_or_else (b2
, b1
))
647 return build_type_attribute_variant (t1
, attributes
);
649 compiler_error ("common_type called with uncommon member types");
652 return build_type_attribute_variant (t1
, attributes
);
656 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
659 compexcepttypes (t1
, t2
)
662 return TYPE_RAISES_EXCEPTIONS (t1
) == TYPE_RAISES_EXCEPTIONS (t2
);
666 comp_array_types (cmp
, t1
, t2
, strict
)
667 register int (*cmp
) PROTO((tree
, tree
, int));
671 tree d1
= TYPE_DOMAIN (t1
);
672 tree d2
= TYPE_DOMAIN (t2
);
674 /* Target types must match incl. qualifiers. */
675 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
676 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)))
679 /* Sizes must match unless one is missing or variable. */
680 if (d1
== 0 || d2
== 0 || d1
== d2
681 || TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
682 || TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
683 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
684 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
)
687 return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1
))
688 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2
)))
689 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1
))
690 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2
)))
691 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1
))
692 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2
)))
693 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1
))
694 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2
))));
697 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
698 or various other operations. This is what ANSI C++ speaks of as
701 For C++: argument STRICT says we should be strict about this
704 2 : strict, except that if one type is a reference and
705 the other is not, compare the target type of the
706 reference to the type that's not a reference (ARM, p308).
707 This is used for checking for invalid overloading.
708 1 : strict (compared according to ANSI C)
709 This is used for checking whether two function decls match.
710 0 : <= (compared according to C++)
711 -1: <= or >= (relaxed)
713 Otherwise, pointers involving base classes and derived classes can
714 be mixed as valid: i.e. a pointer to a derived class may be converted
715 to a pointer to one of its base classes, as per C++. A pointer to
716 a derived class may be passed as a parameter to a function expecting a
717 pointer to a base classes. These allowances do not commute. In this
718 case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
719 be the derived class. */
722 comptypes (type1
, type2
, strict
)
726 register tree t1
= type1
;
727 register tree t2
= type2
;
730 /* Suppress errors caused by previously reported errors */
735 /* This should never happen. */
736 my_friendly_assert (t1
!= error_mark_node
, 307);
738 if (t2
== error_mark_node
)
743 /* Treat an enum type as the unsigned integer type of the same width. */
745 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
746 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
747 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
748 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
754 if (TYPE_PTRMEMFUNC_P (t1
))
755 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
756 if (TYPE_PTRMEMFUNC_P (t2
))
757 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
759 /* Different classes of types can't be compatible. */
761 if (TREE_CODE (t1
) != TREE_CODE (t2
))
764 && ((TREE_CODE (t1
) == REFERENCE_TYPE
)
765 ^ (TREE_CODE (t2
) == REFERENCE_TYPE
)))
767 if (TREE_CODE (t1
) == REFERENCE_TYPE
)
768 return comptypes (TREE_TYPE (t1
), t2
, 1);
769 return comptypes (t1
, TREE_TYPE (t2
), 1);
777 /* Qualifiers must match. */
779 if (TYPE_READONLY (t1
) != TYPE_READONLY (t2
))
781 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
783 if (strict
> 0 && TYPE_FOR_JAVA (t1
) != TYPE_FOR_JAVA (t2
))
786 /* Allow for two different type nodes which have essentially the same
787 definition. Note that we already checked for equality of the type
788 qualifiers (just above). */
790 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
793 /* ??? COMP_TYPE_ATTRIBUTES is currently useless for variables as each
794 attribute is its own main variant (`val' will remain 0). */
795 #ifndef COMP_TYPE_ATTRIBUTES
796 #define COMP_TYPE_ATTRIBUTES(t1,t2) 1
799 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
800 if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
803 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
806 switch (TREE_CODE (t1
))
808 case TEMPLATE_TEMPLATE_PARM
:
809 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
810 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
))
812 if (! comp_template_parms (DECL_TEMPLATE_PARMS (TYPE_NAME (t1
)),
813 DECL_TEMPLATE_PARMS (TYPE_NAME (t2
))))
815 if (! CLASSTYPE_TEMPLATE_INFO (t1
) && ! CLASSTYPE_TEMPLATE_INFO (t2
))
817 /* Don't check inheritance. */
823 if (CLASSTYPE_TEMPLATE_INFO (t1
) && CLASSTYPE_TEMPLATE_INFO (t2
)
824 && (CLASSTYPE_TI_TEMPLATE (t1
) == CLASSTYPE_TI_TEMPLATE (t2
)
825 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
))
826 return comp_template_args (CLASSTYPE_TI_ARGS (t1
),
827 CLASSTYPE_TI_ARGS (t2
));
833 val
= (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1
)),
834 build_pointer_type (TYPE_OFFSET_BASETYPE (t2
)), strict
)
835 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
839 if (! compexcepttypes (t1
, t2
))
842 /* This case is anti-symmetrical!
843 One can pass a base member (or member function)
844 to something expecting a derived member (or member function),
845 but not vice-versa! */
847 val
= (comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
848 && compparms (TYPE_ARG_TYPES (t1
),
849 TYPE_ARG_TYPES (t2
), strict
));
863 if (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
)
867 rval
= t1
== t2
|| DERIVED_FROM_P (t1
, t2
);
876 val
= DERIVED_FROM_P (t2
, t1
);
883 val
= comptypes (t1
, t2
, strict
);
887 if (! compexcepttypes (t1
, t2
))
890 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
891 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
892 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
), strict
));
896 /* Target types must match incl. qualifiers. */
897 val
= comp_array_types (comptypes
, t1
, t2
, strict
);
900 case TEMPLATE_TYPE_PARM
:
901 return TEMPLATE_TYPE_IDX (t1
) == TEMPLATE_TYPE_IDX (t2
)
902 && TEMPLATE_TYPE_LEVEL (t1
) == TEMPLATE_TYPE_LEVEL (t2
);
905 if (TYPE_IDENTIFIER (t1
) != TYPE_IDENTIFIER (t2
))
907 return comptypes (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
), 1);
912 return attrval
== 2 && val
== 1 ? 2 : val
;
915 /* Subroutine of comp_target-types. Make sure that the cv-quals change
916 only in the same direction as the target type. */
919 comp_cv_target_types (ttl
, ttr
, nptrs
)
924 int c
= TYPE_READONLY (ttl
) - TYPE_READONLY (ttr
);
925 int v
= TYPE_VOLATILE (ttl
) - TYPE_VOLATILE (ttr
);
927 if ((c
> 0 && v
< 0) || (c
< 0 && v
> 0))
930 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
))
931 return (c
+ v
< 0) ? -1 : 1;
933 t
= comp_target_types (ttl
, ttr
, nptrs
);
934 if ((t
== 1 && c
+ v
>= 0) || (t
== -1 && c
+ v
<= 0))
940 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
941 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
942 converted to TTL. Return -1 means that TTL can be converted to TTR but
945 NPTRS is the number of pointers we can strip off and keep cool.
946 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
947 but to not permit B** to convert to A**.
949 This should go away. Callers should use can_convert or something
950 similar instead. (jason 17 Apr 1997) */
953 comp_target_types (ttl
, ttr
, nptrs
)
957 ttl
= TYPE_MAIN_VARIANT (ttl
);
958 ttr
= TYPE_MAIN_VARIANT (ttr
);
962 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
965 if ((TREE_CODE (ttr
) == POINTER_TYPE
966 || TREE_CODE (ttr
) == REFERENCE_TYPE
)
967 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
968 of the type pointed to. This is necessary for reference init
969 semantics. We won't get here from a previous call with nptrs == 1;
970 for multi-level pointers we end up in comp_ptr_ttypes. */
973 int is_ptr
= TREE_CODE (ttr
) == POINTER_TYPE
;
975 ttl
= TREE_TYPE (ttl
);
976 ttr
= TREE_TYPE (ttr
);
980 if (TREE_CODE (ttl
) == UNKNOWN_TYPE
981 || TREE_CODE (ttr
) == UNKNOWN_TYPE
)
983 else if (TREE_CODE (ttl
) == VOID_TYPE
984 && TREE_CODE (ttr
) != FUNCTION_TYPE
985 && TREE_CODE (ttr
) != METHOD_TYPE
986 && TREE_CODE (ttr
) != OFFSET_TYPE
)
988 else if (TREE_CODE (ttr
) == VOID_TYPE
989 && TREE_CODE (ttl
) != FUNCTION_TYPE
990 && TREE_CODE (ttl
) != METHOD_TYPE
991 && TREE_CODE (ttl
) != OFFSET_TYPE
)
993 else if (TREE_CODE (ttl
) == POINTER_TYPE
994 || TREE_CODE (ttl
) == ARRAY_TYPE
)
996 if (comp_ptr_ttypes (ttl
, ttr
))
998 else if (comp_ptr_ttypes (ttr
, ttl
))
1004 /* Const and volatile mean something different for function types,
1005 so the usual checks are not appropriate. */
1006 if (TREE_CODE (ttl
) == FUNCTION_TYPE
|| TREE_CODE (ttl
) == METHOD_TYPE
)
1007 return comp_target_types (ttl
, ttr
, nptrs
- 1);
1009 return comp_cv_target_types (ttl
, ttr
, nptrs
- 1);
1012 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
1013 return comp_array_types (comp_target_types
, ttl
, ttr
, 0);
1014 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
1021 if (comptypes (TREE_TYPE (ttl
), TREE_TYPE (ttr
), 1) == 0)
1026 switch (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), -1))
1035 argsl
= TYPE_ARG_TYPES (ttl
);
1036 argsr
= TYPE_ARG_TYPES (ttr
);
1038 /* Compare 'this' here, not in comp_target_parms. */
1039 if (TREE_CODE (ttr
) == METHOD_TYPE
)
1041 tree tl
= TYPE_METHOD_BASETYPE (ttl
);
1042 tree tr
= TYPE_METHOD_BASETYPE (ttr
);
1044 if (comptypes (tr
, tl
, 0) == 0)
1046 if (comptypes (tl
, tr
, 0))
1052 argsl
= TREE_CHAIN (argsl
);
1053 argsr
= TREE_CHAIN (argsr
);
1056 switch (comp_target_parms (argsl
, argsr
, 1))
1064 return saw_contra
? -1 : 1;
1067 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
1071 /* Contravariance: we can assign a pointer to base member to a pointer
1072 to derived member. Note difference from simple pointer case, where
1073 we can pass a pointer to derived to a pointer to base. */
1074 if (comptypes (TYPE_OFFSET_BASETYPE (ttr
),
1075 TYPE_OFFSET_BASETYPE (ttl
), 0))
1077 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl
),
1078 TYPE_OFFSET_BASETYPE (ttr
), 0))
1088 ttl
= TREE_TYPE (ttl
);
1089 ttr
= TREE_TYPE (ttr
);
1091 if (TREE_CODE (ttl
) == POINTER_TYPE
1092 || TREE_CODE (ttl
) == ARRAY_TYPE
)
1094 if (comp_ptr_ttypes (ttl
, ttr
))
1100 if (comp_cv_target_types (ttl
, ttr
, nptrs
) == 1)
1105 else if (IS_AGGR_TYPE (ttl
))
1109 if (comptypes (build_pointer_type (ttl
), build_pointer_type (ttr
), 0))
1111 if (comptypes (build_pointer_type (ttr
), build_pointer_type (ttl
), 0))
1119 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1120 more cv-qualified that TYPE1, and 0 otherwise. */
1123 comp_cv_qualification (type1
, type2
)
1127 if (TYPE_READONLY (type1
) == TYPE_READONLY (type2
)
1128 && TYPE_VOLATILE (type1
) == TYPE_VOLATILE (type2
))
1131 if (TYPE_READONLY (type1
) >= TYPE_READONLY (type2
)
1132 && TYPE_VOLATILE (type1
) >= TYPE_VOLATILE (type2
))
1135 if (TYPE_READONLY (type2
) >= TYPE_READONLY (type1
)
1136 && TYPE_VOLATILE (type2
) >= TYPE_VOLATILE (type1
))
1142 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1143 subset of the cv-qualification signature of TYPE2, and the types
1144 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1147 comp_cv_qual_signature (type1
, type2
)
1151 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1153 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1159 /* If two types share a common base type, return that basetype.
1160 If there is not a unique most-derived base type, this function
1161 returns ERROR_MARK_NODE. */
1164 common_base_type (tt1
, tt2
)
1167 tree best
= NULL_TREE
;
1170 /* If one is a baseclass of another, that's good enough. */
1171 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
1173 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
1176 /* Otherwise, try to find a unique baseclass of TT1
1177 that is shared by TT2, and follow that down. */
1178 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
1180 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
1181 tree trial
= common_base_type (basetype
, tt2
);
1184 if (trial
== error_mark_node
)
1186 if (best
== NULL_TREE
)
1188 else if (best
!= trial
)
1189 return error_mark_node
;
1194 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
1196 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
1197 tree trial
= common_base_type (tt1
, basetype
);
1200 if (trial
== error_mark_node
)
1202 if (best
== NULL_TREE
)
1204 else if (best
!= trial
)
1205 return error_mark_node
;
1211 /* Subroutines of `comptypes'. */
1213 /* Return 1 if two parameter type lists PARMS1 and PARMS2
1214 are equivalent in the sense that functions with those parameter types
1215 can have equivalent types.
1216 If either list is empty, we win.
1217 Otherwise, the two lists must be equivalent, element by element.
1219 C++: See comment above about TYPE1, TYPE2.
1221 STRICT is no longer used. */
1224 compparms (parms1
, parms2
, strict
)
1225 tree parms1
, parms2
;
1228 register tree t1
= parms1
, t2
= parms2
;
1230 /* An unspecified parmlist matches any specified parmlist
1231 whose argument types don't need default promotions. */
1235 if (t1
== 0 && t2
== 0)
1237 /* If one parmlist is shorter than the other,
1238 they fail to match. */
1239 if (t1
== 0 || t2
== 0)
1241 if (! comptypes (TREE_VALUE (t2
), TREE_VALUE (t1
), 1))
1244 t1
= TREE_CHAIN (t1
);
1245 t2
= TREE_CHAIN (t2
);
1249 /* This really wants return whether or not parameter type lists
1250 would make their owning functions assignment compatible or not.
1252 The return value is like for comp_target_types.
1254 This should go away, possibly with the exception of the empty parmlist
1255 conversion; there are no conversions between function types in C++.
1256 (jason 17 Apr 1997) */
1259 comp_target_parms (parms1
, parms2
, strict
)
1260 tree parms1
, parms2
;
1263 register tree t1
= parms1
, t2
= parms2
;
1264 int warn_contravariance
= 0;
1266 /* In C, an unspecified parmlist matches any specified parmlist
1267 whose argument types don't need default promotions. This is not
1268 true for C++, but let's do it anyway for unfixed headers. */
1270 if (t1
== 0 && t2
!= 0)
1272 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
1274 return self_promoting_args_p (t2
);
1277 return self_promoting_args_p (t1
);
1279 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1283 /* If one parmlist is shorter than the other,
1284 they fail to match, unless STRICT is <= 0. */
1285 if (t1
== 0 || t2
== 0)
1290 return 1 + warn_contravariance
;
1291 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
1293 p1
= TREE_VALUE (t1
);
1294 p2
= TREE_VALUE (t2
);
1295 if (comptypes (p1
, p2
, 1))
1301 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
1302 || (TREE_CODE (p1
) == REFERENCE_TYPE
1303 && TREE_CODE (p2
) == REFERENCE_TYPE
))
1306 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
1307 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1310 /* The following is wrong for contravariance,
1311 but many programs depend on it. */
1312 if (TREE_TYPE (p1
) == void_type_node
)
1314 if (TREE_TYPE (p2
) == void_type_node
)
1316 warn_contravariance
= 1;
1319 if (IS_AGGR_TYPE (TREE_TYPE (p1
)))
1321 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (p1
)),
1322 TYPE_MAIN_VARIANT (TREE_TYPE (p2
)), 1) == 0)
1326 /* Note backwards order due to contravariance. */
1327 if (comp_target_types (p2
, p1
, 1) <= 0)
1329 if (comp_target_types (p1
, p2
, 1) > 0)
1331 warn_contravariance
= 1;
1338 return warn_contravariance
? -1 : 1;
1341 /* Return 1 if PARMS specifies a fixed number of parameters
1342 and none of their types is affected by default promotions. */
1345 self_promoting_args_p (parms
)
1349 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1351 register tree type
= TREE_VALUE (t
);
1353 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1359 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1362 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1368 /* Return an unsigned type the same as TYPE in other respects.
1370 C++: must make these work for type variants as well. */
1373 unsigned_type (type
)
1376 tree type1
= TYPE_MAIN_VARIANT (type
);
1377 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1378 return unsigned_char_type_node
;
1379 if (type1
== integer_type_node
)
1380 return unsigned_type_node
;
1381 if (type1
== short_integer_type_node
)
1382 return short_unsigned_type_node
;
1383 if (type1
== long_integer_type_node
)
1384 return long_unsigned_type_node
;
1385 if (type1
== long_long_integer_type_node
)
1386 return long_long_unsigned_type_node
;
1387 if (type1
== intTI_type_node
)
1388 return unsigned_intTI_type_node
;
1389 if (type1
== intDI_type_node
)
1390 return unsigned_intDI_type_node
;
1391 if (type1
== intSI_type_node
)
1392 return unsigned_intSI_type_node
;
1393 if (type1
== intHI_type_node
)
1394 return unsigned_intHI_type_node
;
1395 if (type1
== intQI_type_node
)
1396 return unsigned_intQI_type_node
;
1398 return signed_or_unsigned_type (1, type
);
1401 /* Return a signed type the same as TYPE in other respects. */
1407 tree type1
= TYPE_MAIN_VARIANT (type
);
1408 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1409 return signed_char_type_node
;
1410 if (type1
== unsigned_type_node
)
1411 return integer_type_node
;
1412 if (type1
== short_unsigned_type_node
)
1413 return short_integer_type_node
;
1414 if (type1
== long_unsigned_type_node
)
1415 return long_integer_type_node
;
1416 if (type1
== long_long_unsigned_type_node
)
1417 return long_long_integer_type_node
;
1418 if (type1
== unsigned_intTI_type_node
)
1419 return intTI_type_node
;
1420 if (type1
== unsigned_intDI_type_node
)
1421 return intDI_type_node
;
1422 if (type1
== unsigned_intSI_type_node
)
1423 return intSI_type_node
;
1424 if (type1
== unsigned_intHI_type_node
)
1425 return intHI_type_node
;
1426 if (type1
== unsigned_intQI_type_node
)
1427 return intQI_type_node
;
1429 return signed_or_unsigned_type (0, type
);
1432 /* Return a type the same as TYPE except unsigned or
1433 signed according to UNSIGNEDP. */
1436 signed_or_unsigned_type (unsignedp
, type
)
1440 if (! INTEGRAL_TYPE_P (type
)
1441 || TREE_UNSIGNED (type
) == unsignedp
)
1444 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1445 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1446 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1447 return unsignedp
? unsigned_type_node
: integer_type_node
;
1448 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1449 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1450 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1451 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1452 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1453 return (unsignedp
? long_long_unsigned_type_node
1454 : long_long_integer_type_node
);
1458 /* Compute the value of the `sizeof' operator. */
1464 enum tree_code code
= TREE_CODE (type
);
1467 if (processing_template_decl
)
1468 return build_min (SIZEOF_EXPR
, sizetype
, type
);
1470 if (code
== FUNCTION_TYPE
)
1472 if (pedantic
|| warn_pointer_arith
)
1473 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1474 return size_int (1);
1476 if (code
== METHOD_TYPE
)
1478 if (pedantic
|| warn_pointer_arith
)
1479 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1480 return size_int (1);
1482 if (code
== VOID_TYPE
)
1484 if (pedantic
|| warn_pointer_arith
)
1485 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1486 return size_int (1);
1488 if (code
== ERROR_MARK
)
1489 return size_int (1);
1491 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1492 referenced object.'' */
1493 if (code
== REFERENCE_TYPE
)
1494 type
= TREE_TYPE (type
);
1496 /* We couldn't find anything in the ARM or the draft standard that says,
1497 one way or the other, if doing sizeof on something that doesn't have
1498 an object associated with it is correct or incorrect. For example, if
1499 you declare `struct S { char str[16]; };', and in your program do
1500 a `sizeof (S::str)', should we flag that as an error or should we give
1501 the size of it? Since it seems like a reasonable thing to do, we'll go
1502 with giving the value. */
1503 if (code
== OFFSET_TYPE
)
1504 type
= TREE_TYPE (type
);
1506 /* @@ This also produces an error for a signature ref.
1507 In that case we should be able to do better. */
1508 if (IS_SIGNATURE (type
))
1510 error ("`sizeof' applied to a signature type");
1511 return size_int (0);
1514 if (TYPE_SIZE (complete_type (type
)) == 0)
1516 cp_error ("`sizeof' applied to incomplete type `%T'", type
);
1517 return size_int (0);
1520 /* Convert in case a char is more than one unit. */
1521 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1522 size_int (TYPE_PRECISION (char_type_node
)));
1523 t
= convert (sizetype
, t
);
1524 /* size_binop does not put the constant in range, so do it now. */
1525 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1526 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1534 if (processing_template_decl
)
1535 return build_min (SIZEOF_EXPR
, sizetype
, e
);
1537 if (TREE_CODE (e
) == COMPONENT_REF
1538 && DECL_BIT_FIELD (TREE_OPERAND (e
, 1)))
1539 error ("sizeof applied to a bit-field");
1540 /* ANSI says arrays and functions are converted inside comma.
1541 But we can't really convert them in build_compound_expr
1542 because that would break commas in lvalues.
1543 So do the conversion here if operand was a comma. */
1544 if (TREE_CODE (e
) == COMPOUND_EXPR
1545 && (TREE_CODE (TREE_TYPE (e
)) == ARRAY_TYPE
1546 || TREE_CODE (TREE_TYPE (e
)) == FUNCTION_TYPE
))
1547 e
= default_conversion (e
);
1548 else if (TREE_CODE (e
) == TREE_LIST
)
1550 tree t
= TREE_VALUE (e
);
1553 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1554 || is_overloaded_fn (t
)))
1555 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1557 return c_sizeof (TREE_TYPE (e
));
1561 c_sizeof_nowarn (type
)
1564 enum tree_code code
= TREE_CODE (type
);
1567 if (code
== FUNCTION_TYPE
1568 || code
== METHOD_TYPE
1569 || code
== VOID_TYPE
1570 || code
== ERROR_MARK
)
1571 return size_int (1);
1572 if (code
== REFERENCE_TYPE
)
1573 type
= TREE_TYPE (type
);
1575 if (TYPE_SIZE (type
) == 0)
1576 return size_int (0);
1578 /* Convert in case a char is more than one unit. */
1579 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1580 size_int (TYPE_PRECISION (char_type_node
)));
1581 t
= convert (sizetype
, t
);
1582 force_fit_type (t
, 0);
1586 /* Implement the __alignof keyword: Return the minimum required
1587 alignment of TYPE, measured in bytes. */
1593 enum tree_code code
= TREE_CODE (type
);
1596 if (processing_template_decl
)
1597 return build_min (ALIGNOF_EXPR
, sizetype
, type
);
1599 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1600 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1602 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1603 return size_int (1);
1605 /* C++: this is really correct! */
1606 if (code
== REFERENCE_TYPE
)
1607 type
= TREE_TYPE (type
);
1609 /* @@ This also produces an error for a signature ref.
1610 In that case we should be able to do better. */
1611 if (IS_SIGNATURE (type
))
1613 error ("`__alignof' applied to a signature type");
1614 return size_int (1);
1617 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1618 force_fit_type (t
, 0);
1622 /* Perform default promotions for C data used in expressions.
1623 Arrays and functions are converted to pointers;
1624 enumeral types or short or char, to int.
1625 In addition, manifest constants symbols are replaced by their values.
1627 C++: this will automatically bash references to their target type. */
1630 decay_conversion (exp
)
1633 register tree type
= TREE_TYPE (exp
);
1634 register enum tree_code code
= TREE_CODE (type
);
1636 if (code
== OFFSET_TYPE
)
1638 if (TREE_CODE (exp
) == OFFSET_REF
)
1639 return decay_conversion (resolve_offset_ref (exp
));
1641 type
= TREE_TYPE (type
);
1642 code
= TREE_CODE (type
);
1644 if (type
== unknown_type_node
)
1646 cp_pedwarn ("assuming & on overloaded member function");
1647 return build_unary_op (ADDR_EXPR
, exp
, 0);
1651 if (code
== REFERENCE_TYPE
)
1653 exp
= convert_from_reference (exp
);
1654 type
= TREE_TYPE (exp
);
1655 code
= TREE_CODE (type
);
1658 /* Constants can be used directly unless they're not loadable. */
1659 if (TREE_CODE (exp
) == CONST_DECL
)
1660 exp
= DECL_INITIAL (exp
);
1661 /* Replace a nonvolatile const static variable with its value. */
1662 else if (TREE_READONLY_DECL_P (exp
))
1664 exp
= decl_constant_value (exp
);
1665 type
= TREE_TYPE (exp
);
1668 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1669 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1671 if (code
== VOID_TYPE
)
1673 error ("void value not ignored as it ought to be");
1674 return error_mark_node
;
1676 if (code
== FUNCTION_TYPE
)
1678 return build_unary_op (ADDR_EXPR
, exp
, 0);
1680 if (code
== METHOD_TYPE
)
1682 cp_pedwarn ("assuming & on `%E'", exp
);
1683 return build_unary_op (ADDR_EXPR
, exp
, 0);
1685 if (code
== ARRAY_TYPE
)
1690 int constp
, volatilep
;
1692 if (TREE_CODE (exp
) == INDIRECT_REF
)
1694 /* Stripping away the INDIRECT_REF is not the right
1695 thing to do for references... */
1696 tree inner
= TREE_OPERAND (exp
, 0);
1697 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1699 inner
= build1 (CONVERT_EXPR
,
1700 build_pointer_type (TREE_TYPE
1701 (TREE_TYPE (inner
))),
1703 TREE_CONSTANT (inner
) = TREE_CONSTANT (TREE_OPERAND (inner
, 0));
1705 return cp_convert (build_pointer_type (TREE_TYPE (type
)), inner
);
1708 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1710 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1711 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1712 TREE_OPERAND (exp
, 0), op1
);
1716 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1718 error ("invalid use of non-lvalue array");
1719 return error_mark_node
;
1722 constp
= volatilep
= 0;
1723 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r'
1724 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
1726 constp
= TREE_READONLY (exp
);
1727 volatilep
= TREE_THIS_VOLATILE (exp
);
1730 restype
= TREE_TYPE (type
);
1731 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)
1732 || constp
|| volatilep
)
1733 restype
= cp_build_type_variant (restype
,
1734 TYPE_READONLY (type
) || constp
,
1735 TYPE_VOLATILE (type
) || volatilep
);
1736 ptrtype
= build_pointer_type (restype
);
1738 if (TREE_CODE (exp
) == VAR_DECL
)
1740 /* ??? This is not really quite correct
1741 in that the type of the operand of ADDR_EXPR
1742 is not the target type of the type of the ADDR_EXPR itself.
1743 Question is, can this lossage be avoided? */
1744 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1745 if (mark_addressable (exp
) == 0)
1746 return error_mark_node
;
1747 TREE_CONSTANT (adr
) = staticp (exp
);
1748 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1751 /* This way is better for a COMPONENT_REF since it can
1752 simplify the offset for a component. */
1753 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1754 return cp_convert (ptrtype
, adr
);
1761 default_conversion (exp
)
1765 enum tree_code code
;
1767 exp
= decay_conversion (exp
);
1769 type
= TREE_TYPE (exp
);
1770 code
= TREE_CODE (type
);
1772 if (INTEGRAL_CODE_P (code
))
1774 tree t
= type_promotes_to (type
);
1776 return cp_convert (t
, exp
);
1782 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1786 inline_conversion (exp
)
1789 if (TREE_CODE (exp
) == FUNCTION_DECL
)
1791 tree type
= build_type_variant
1792 (TREE_TYPE (exp
), TREE_READONLY (exp
), TREE_THIS_VOLATILE (exp
));
1793 exp
= build1 (ADDR_EXPR
, build_pointer_type (type
), exp
);
1798 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1799 decay_conversion to one. */
1802 string_conv_p (totype
, exp
, warn
)
1808 if (! flag_const_strings
|| TREE_CODE (totype
) != POINTER_TYPE
)
1811 t
= TREE_TYPE (totype
);
1812 if (! comptypes (t
, char_type_node
, 1)
1813 && ! comptypes (t
, wchar_type_node
, 1))
1816 if (TREE_CODE (exp
) != STRING_CST
)
1818 t
= build_pointer_type (build_type_variant (t
, 1, 0));
1819 if (! comptypes (TREE_TYPE (exp
), t
, 1))
1822 if (TREE_CODE (exp
) != ADDR_EXPR
1823 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1827 /* This warning is not very useful, as it complains about printf. */
1828 if (warn
&& warn_write_strings
)
1829 cp_warning ("deprecated conversion from string constant to `char *'");
1835 build_object_ref (datum
, basetype
, field
)
1836 tree datum
, basetype
, field
;
1839 if (datum
== error_mark_node
)
1840 return error_mark_node
;
1842 dtype
= TREE_TYPE (datum
);
1843 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1844 dtype
= TREE_TYPE (dtype
);
1845 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1847 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1848 basetype
, field
, dtype
);
1849 return error_mark_node
;
1851 else if (IS_SIGNATURE (basetype
))
1853 warning ("signature name in scope resolution ignored");
1854 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1856 else if (is_aggr_type (basetype
, 1))
1858 tree binfo
= binfo_or_else (basetype
, dtype
);
1860 return build_x_component_ref (build_scoped_ref (datum
, basetype
),
1863 return error_mark_node
;
1866 /* Like `build_component_ref, but uses an already found field, and converts
1867 from a reference. Must compute access for current_class_ref.
1871 build_component_ref_1 (datum
, field
, protect
)
1875 return convert_from_reference
1876 (build_component_ref (datum
, field
, NULL_TREE
, protect
));
1879 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1880 can, for example, use as an lvalue. This code used to be in
1881 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1882 expressions, where we're dealing with aggregates. But now it's again only
1883 called from unary_complex_lvalue. The case (in particular) that led to
1884 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1888 rationalize_conditional_expr (code
, t
)
1889 enum tree_code code
;
1892 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1893 the first operand is always the one to be used if both operands
1894 are equal, so we know what conditional expression this used to be. */
1895 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1898 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1899 ? LE_EXPR
: GE_EXPR
),
1900 TREE_OPERAND (t
, 0),
1901 TREE_OPERAND (t
, 1)),
1902 build_unary_op (code
, TREE_OPERAND (t
, 0), 0),
1903 build_unary_op (code
, TREE_OPERAND (t
, 1), 0));
1907 build_conditional_expr (TREE_OPERAND (t
, 0),
1908 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1909 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1912 /* Given the TYPE of an anonymous union field inside T, return the
1913 FIELD_DECL for the field. If not found return NULL_TREE. Because
1914 anonymous unions can nest, we must also search all anonymous unions
1915 that are directly reachable. */
1918 lookup_anon_field (t
, type
)
1923 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1925 if (TREE_STATIC (field
))
1927 if (TREE_CODE (field
) != FIELD_DECL
)
1930 /* If we find it directly, return the field. */
1931 if (DECL_NAME (field
) == NULL_TREE
1932 && type
== TREE_TYPE (field
))
1937 /* Otherwise, it could be nested, search harder. */
1938 if (DECL_NAME (field
) == NULL_TREE
1939 && TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1941 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
1949 /* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT.
1950 COMPONENT can be an IDENTIFIER_NODE that is the name of the member
1951 that we are interested in, or it can be a FIELD_DECL. */
1954 build_component_ref (datum
, component
, basetype_path
, protect
)
1955 tree datum
, component
, basetype_path
;
1958 register tree basetype
= TREE_TYPE (datum
);
1959 register enum tree_code code
;
1960 register tree field
= NULL
;
1963 if (processing_template_decl
)
1964 return build_min_nt (COMPONENT_REF
, datum
, component
);
1966 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
1968 switch (TREE_CODE (datum
))
1972 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1973 basetype_path
, protect
);
1974 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1975 TREE_OPERAND (datum
, 0), value
);
1978 return build_conditional_expr
1979 (TREE_OPERAND (datum
, 0),
1980 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1981 basetype_path
, protect
),
1982 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1983 basetype_path
, protect
));
1986 cp_error ("invalid use of %D", datum
);
1987 datum
= error_mark_node
;
1994 code
= TREE_CODE (basetype
);
1996 if (code
== REFERENCE_TYPE
)
1998 datum
= convert_from_reference (datum
);
1999 basetype
= TREE_TYPE (datum
);
2000 code
= TREE_CODE (basetype
);
2002 if (TREE_CODE (datum
) == OFFSET_REF
)
2004 datum
= resolve_offset_ref (datum
);
2005 basetype
= TREE_TYPE (datum
);
2006 code
= TREE_CODE (basetype
);
2009 /* First, see if there is a field or component with name COMPONENT. */
2010 if (TREE_CODE (component
) == TREE_LIST
)
2012 /* I could not trigger this code. MvL */
2013 my_friendly_abort (980326);
2015 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
2016 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
2018 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
2021 if (! IS_AGGR_TYPE_CODE (code
))
2023 if (code
!= ERROR_MARK
)
2024 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
2025 component
, datum
, basetype
);
2026 return error_mark_node
;
2029 if (!complete_type_or_else (basetype
))
2030 return error_mark_node
;
2032 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
2034 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
2036 cp_error ("destructor specifier `%T::~%T' must have matching names",
2037 basetype
, TREE_OPERAND (component
, 0));
2038 return error_mark_node
;
2040 if (! TYPE_HAS_DESTRUCTOR (basetype
))
2042 cp_error ("type `%T' has no destructor", basetype
);
2043 return error_mark_node
;
2045 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1);
2048 /* Look up component name in the structure type definition. */
2049 if (CLASSTYPE_VFIELD (basetype
)
2050 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
2051 /* Special-case this because if we use normal lookups in an ambiguous
2052 hierarchy, the compiler will abort (because vptr lookups are
2053 not supposed to be ambiguous. */
2054 field
= CLASSTYPE_VFIELD (basetype
);
2055 else if (TREE_CODE (component
) == FIELD_DECL
)
2057 else if (TREE_CODE (component
) == TYPE_DECL
)
2059 cp_pedwarn ("invalid use of type decl `%#D' as expression", component
);
2064 tree name
= component
;
2065 if (TREE_CODE (component
) == VAR_DECL
)
2066 name
= DECL_NAME (component
);
2067 if (basetype_path
== NULL_TREE
)
2068 basetype_path
= TYPE_BINFO (basetype
);
2069 field
= lookup_field (basetype_path
, name
,
2070 protect
&& !VFIELD_NAME_P (name
), 0);
2071 if (field
== error_mark_node
)
2072 return error_mark_node
;
2074 if (field
== NULL_TREE
)
2076 /* Not found as a data field, look for it as a method. If found,
2077 then if this is the only possible one, return it, else
2078 report ambiguity error. */
2079 tree fndecls
= lookup_fnfields (basetype_path
, name
, 1);
2080 if (fndecls
== error_mark_node
)
2081 return error_mark_node
;
2084 if (TREE_CHAIN (fndecls
) == NULL_TREE
2085 && TREE_CODE (TREE_VALUE (fndecls
)) != OVERLOAD
)
2087 tree access
, fndecl
;
2089 /* Unique, so use this one now. */
2090 basetype
= TREE_PURPOSE (fndecls
);
2091 fndecl
= TREE_VALUE (fndecls
);
2092 access
= compute_access (TREE_PURPOSE (fndecls
), fndecl
);
2093 if (access
== access_public_node
)
2095 if (DECL_VINDEX (fndecl
)
2096 && ! resolves_to_fixed_type_p (datum
, 0))
2098 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
2099 tree fntype
= TREE_TYPE (fndecl
);
2101 addr
= convert_pointer_to (DECL_CONTEXT (fndecl
),
2103 datum
= build_indirect_ref (addr
, NULL_PTR
);
2104 my_friendly_assert (datum
!= error_mark_node
, 310);
2105 fndecl
= build_vfn_ref (&addr
, datum
,
2106 DECL_VINDEX (fndecl
));
2107 /* The type of fndecl is a function type,
2108 not a pointer-to-function type, since
2109 build_vfn_ref returns not the correct
2110 vtable slot, but the indirection of the
2111 correct vtable slot. */
2112 TREE_TYPE (fndecl
) = fntype
;
2116 return build (OFFSET_REF
, TREE_TYPE (fndecl
),
2119 if (access
== access_protected_node
)
2120 cp_error ("member function `%D' is protected", fndecl
);
2122 cp_error ("member function `%D' is private", fndecl
);
2123 return error_mark_node
;
2127 /* Just act like build_offset_ref, since the object does
2128 not matter unless we're actually calling the function. */
2131 t
= build_tree_list (error_mark_node
, fndecls
);
2132 TREE_TYPE (t
) = build_offset_type (basetype
,
2138 cp_error ("`%#T' has no member named `%D'", basetype
, name
);
2139 return error_mark_node
;
2141 else if (TREE_TYPE (field
) == error_mark_node
)
2142 return error_mark_node
;
2144 if (TREE_CODE (field
) != FIELD_DECL
)
2146 if (TREE_CODE (field
) == TYPE_DECL
)
2147 cp_pedwarn ("invalid use of type decl `%#D' as expression", field
);
2148 else if (DECL_RTL (field
) != 0)
2151 TREE_USED (field
) = 1;
2156 /* See if we have to do any conversions so that we pick up the field from the
2158 if (DECL_FIELD_CONTEXT (field
) != basetype
)
2160 tree context
= DECL_FIELD_CONTEXT (field
);
2161 tree base
= context
;
2162 while (!comptypes (base
, basetype
,1) && TYPE_NAME (base
)
2163 && ANON_UNION_TYPE_P (base
))
2165 base
= TYPE_CONTEXT (base
);
2168 /* Handle base classes here... */
2169 if (base
!= basetype
&& TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2171 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
2172 if (integer_zerop (addr
))
2174 error ("invalid reference to NULL ptr, use ptr-to-member instead");
2175 return error_mark_node
;
2177 if (VBASE_NAME_P (DECL_NAME (field
)))
2179 /* It doesn't matter which vbase pointer we grab, just
2180 find one of them. */
2181 tree binfo
= get_binfo (base
,
2182 TREE_TYPE (TREE_TYPE (addr
)), 0);
2183 addr
= convert_pointer_to_real (binfo
, addr
);
2186 addr
= convert_pointer_to (base
, addr
);
2187 datum
= build_indirect_ref (addr
, NULL_PTR
);
2188 my_friendly_assert (datum
!= error_mark_node
, 311);
2192 /* Handle things from anon unions here... */
2193 if (TYPE_NAME (context
) && ANON_UNION_TYPE_P (context
))
2195 tree subfield
= lookup_anon_field (basetype
, context
);
2196 tree subdatum
= build_component_ref (datum
, subfield
,
2197 basetype_path
, protect
);
2198 return build_component_ref (subdatum
, field
, basetype_path
, protect
);
2202 ref
= fold (build (COMPONENT_REF
, TREE_TYPE (field
),
2203 break_out_cleanups (datum
), field
));
2205 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
2206 TREE_READONLY (ref
) = 1;
2207 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
2208 TREE_THIS_VOLATILE (ref
) = 1;
2209 if (DECL_LANG_SPECIFIC (field
) && DECL_MUTABLE_P (field
))
2210 TREE_READONLY (ref
) = 0;
2215 /* Variant of build_component_ref for use in expressions, which should
2216 never have REFERENCE_TYPE. */
2219 build_x_component_ref (datum
, component
, basetype_path
, protect
)
2220 tree datum
, component
, basetype_path
;
2223 tree t
= build_component_ref (datum
, component
, basetype_path
, protect
);
2225 if (! processing_template_decl
)
2226 t
= convert_from_reference (t
);
2231 /* Given an expression PTR for a pointer, return an expression
2232 for the value pointed to.
2233 ERRORSTRING is the name of the operator to appear in error messages.
2235 This function may need to overload OPERATOR_FNNAME.
2236 Must also handle REFERENCE_TYPEs for C++. */
2239 build_x_indirect_ref (ptr
, errorstring
)
2245 if (processing_template_decl
)
2246 return build_min_nt (INDIRECT_REF
, ptr
);
2248 rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
,
2252 return build_indirect_ref (ptr
, errorstring
);
2256 build_indirect_ref (ptr
, errorstring
)
2260 register tree pointer
, type
;
2262 if (ptr
== error_mark_node
)
2263 return error_mark_node
;
2265 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2266 ? ptr
: default_conversion (ptr
));
2267 type
= TREE_TYPE (pointer
);
2269 if (ptr
== current_class_ptr
)
2270 return current_class_ref
;
2272 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
2274 if (TREE_CODE (pointer
) == ADDR_EXPR
2276 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (pointer
, 0)))
2277 == TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
2278 && (TREE_READONLY (TREE_OPERAND (pointer
, 0))
2279 == TYPE_READONLY (TREE_TYPE (type
)))
2280 && (TREE_THIS_VOLATILE (TREE_OPERAND (pointer
, 0))
2281 == TYPE_VOLATILE (TREE_TYPE (type
))))
2282 return TREE_OPERAND (pointer
, 0);
2285 tree t
= TREE_TYPE (type
);
2286 register tree ref
= build1 (INDIRECT_REF
,
2287 TYPE_MAIN_VARIANT (t
), pointer
);
2289 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2290 so that we get the proper error message if the result is used
2291 to assign to. Also, &* is supposed to be a no-op. */
2292 TREE_READONLY (ref
) = TYPE_READONLY (t
);
2293 TREE_SIDE_EFFECTS (ref
)
2294 = (TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
)
2296 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
2300 /* `pointer' won't be an error_mark_node if we were given a
2301 pointer to member, so it's cool to check for this here. */
2302 else if (TYPE_PTRMEMFUNC_P (type
))
2303 error ("invalid use of `%s' on pointer to member function", errorstring
);
2304 else if (TREE_CODE (type
) == RECORD_TYPE
2305 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
2306 error ("cannot dereference signature pointer/reference");
2307 else if (pointer
!= error_mark_node
)
2310 error ("invalid type argument of `%s'", errorstring
);
2312 error ("invalid type argument");
2314 return error_mark_node
;
2317 /* This handles expressions of the form "a[i]", which denotes
2320 This is logically equivalent in C to *(a+i), but we may do it differently.
2321 If A is a variable or a member, we generate a primitive ARRAY_REF.
2322 This avoids forcing the array out of registers, and can work on
2323 arrays that are not lvalues (for example, members of structures returned
2326 If INDEX is of some user-defined type, it must be converted to
2327 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2328 will inherit the type of the array, which will be some pointer type. */
2331 build_array_ref (array
, idx
)
2336 error ("subscript missing in array reference");
2337 return error_mark_node
;
2340 if (TREE_TYPE (array
) == error_mark_node
2341 || TREE_TYPE (idx
) == error_mark_node
)
2342 return error_mark_node
;
2344 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
2345 && TREE_CODE (array
) != INDIRECT_REF
)
2349 /* Subscripting with type char is likely to lose
2350 on a machine where chars are signed.
2351 So warn on any machine, but optionally.
2352 Don't warn for unsigned char since that type is safe.
2353 Don't warn for signed char because anyone who uses that
2354 must have done so deliberately. */
2355 if (warn_char_subscripts
2356 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
2357 warning ("array subscript has type `char'");
2359 /* Apply default promotions *after* noticing character types. */
2360 idx
= default_conversion (idx
);
2362 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
2364 error ("array subscript is not an integer");
2365 return error_mark_node
;
2368 /* An array that is indexed by a non-constant
2369 cannot be stored in a register; we must be able to do
2370 address arithmetic on its address.
2371 Likewise an array of elements of variable size. */
2372 if (TREE_CODE (idx
) != INTEGER_CST
2373 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
2374 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2377 if (mark_addressable (array
) == 0)
2378 return error_mark_node
;
2380 /* An array that is indexed by a constant value which is not within
2381 the array bounds cannot be stored in a register either; because we
2382 would get a crash in store_bit_field/extract_bit_field when trying
2383 to access a non-existent part of the register. */
2384 if (TREE_CODE (idx
) == INTEGER_CST
2385 && TYPE_VALUES (TREE_TYPE (array
))
2386 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
2388 if (mark_addressable (array
) == 0)
2389 return error_mark_node
;
2392 if (pedantic
&& !lvalue_p (array
))
2393 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
2395 /* Note in C++ it is valid to subscript a `register' array, since
2396 it is valid to take the address of something with that
2397 storage specification. */
2401 while (TREE_CODE (foo
) == COMPONENT_REF
)
2402 foo
= TREE_OPERAND (foo
, 0);
2403 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2404 warning ("subscripting array declared `register'");
2407 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
2408 rval
= build (ARRAY_REF
, type
, array
, idx
);
2409 /* Array ref is const/volatile if the array elements are
2410 or if the array is.. */
2411 TREE_READONLY (rval
)
2412 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
2413 | TREE_READONLY (array
));
2414 TREE_SIDE_EFFECTS (rval
)
2415 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2416 | TREE_SIDE_EFFECTS (array
));
2417 TREE_THIS_VOLATILE (rval
)
2418 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2419 /* This was added by rms on 16 Nov 91.
2420 It fixes vol struct foo *a; a->elts[1]
2421 in an inline function.
2422 Hope it doesn't break something else. */
2423 | TREE_THIS_VOLATILE (array
));
2424 return require_complete_type (fold (rval
));
2428 tree ar
= default_conversion (array
);
2429 tree ind
= default_conversion (idx
);
2431 /* Put the integer in IND to simplify error checking. */
2432 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2439 if (ar
== error_mark_node
)
2442 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2444 error ("subscripted value is neither array nor pointer");
2445 return error_mark_node
;
2447 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2449 error ("array subscript is not an integer");
2450 return error_mark_node
;
2453 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
,
2459 /* Build a function call to function FUNCTION with parameters PARAMS.
2460 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2461 TREE_VALUE of each node is a parameter-expression. The PARAMS do
2462 not include any object pointer that may be required. FUNCTION's
2463 data type may be a function type or a pointer-to-function.
2465 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2466 is the list of possible methods that FUNCTION could conceivably
2467 be. If the list of methods comes from a class, then it will be
2468 a list of lists (where each element is associated with the class
2469 that produced it), otherwise it will be a simple list (for
2470 functions overloaded in global scope).
2472 In the first case, TREE_VALUE (function) is the head of one of those
2473 lists, and TREE_PURPOSE is the name of the function.
2475 In the second case, TREE_PURPOSE (function) is the function's
2478 DECL is the class instance variable, usually CURRENT_CLASS_REF.
2480 When calling a TEMPLATE_DECL, we don't require a complete return
2484 build_x_function_call (function
, params
, decl
)
2485 tree function
, params
, decl
;
2488 tree template_id
= NULL_TREE
;
2491 if (function
== error_mark_node
)
2492 return error_mark_node
;
2494 if (processing_template_decl
)
2495 return build_min_nt (CALL_EXPR
, function
, params
, NULL_TREE
);
2497 /* Save explicit template arguments if found */
2498 if (TREE_CODE (function
) == TEMPLATE_ID_EXPR
)
2500 template_id
= function
;
2501 function
= TREE_OPERAND (function
, 0);
2504 type
= TREE_TYPE (function
);
2506 if (TREE_CODE (type
) == OFFSET_TYPE
2507 && TREE_TYPE (type
) == unknown_type_node
2508 && TREE_CODE (function
) == TREE_LIST
2509 && TREE_CHAIN (function
) == NULL_TREE
)
2511 /* Undo (Foo:bar)()... */
2512 type
= TYPE_OFFSET_BASETYPE (type
);
2513 function
= TREE_VALUE (function
);
2514 my_friendly_assert (TREE_CODE (function
) == TREE_LIST
, 999);
2515 my_friendly_assert (TREE_CHAIN (function
) == NULL_TREE
, 999);
2516 function
= TREE_VALUE (function
);
2517 if (TREE_CODE (function
) == OVERLOAD
)
2518 function
= OVL_FUNCTION (function
);
2519 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 999);
2520 function
= DECL_NAME (function
);
2521 return build_method_call (decl
, function
, params
,
2522 TYPE_BINFO (type
), LOOKUP_NORMAL
);
2525 is_method
= ((TREE_CODE (function
) == TREE_LIST
2526 && current_class_type
!= NULL_TREE
2527 && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
))
2529 || TREE_CODE (function
) == IDENTIFIER_NODE
2530 || TREE_CODE (type
) == METHOD_TYPE
2531 || TYPE_PTRMEMFUNC_P (type
));
2533 if ((TREE_CODE (function
) == FUNCTION_DECL
2534 && DECL_STATIC_FUNCTION_P (function
))
2535 || (TREE_CODE (function
) == TEMPLATE_DECL
2536 && DECL_STATIC_FUNCTION_P (DECL_RESULT (function
))))
2537 return build_member_call
2538 (DECL_CONTEXT (function
), DECL_NAME (function
), params
);
2540 /* A friend template. Make it look like a toplevel declaration. */
2541 if (! is_method
&& TREE_CODE (function
) == TEMPLATE_DECL
)
2542 function
= scratch_ovl_cons (function
, NULL_TREE
);
2544 /* Handle methods, friends, and overloaded functions, respectively. */
2547 tree basetype
= NULL_TREE
;
2549 if (TREE_CODE (function
) == FUNCTION_DECL
2550 || DECL_FUNCTION_TEMPLATE_P (function
))
2552 basetype
= DECL_CLASS_CONTEXT (function
);
2554 if (DECL_NAME (function
))
2555 function
= DECL_NAME (function
);
2557 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2559 else if (TREE_CODE (function
) == TREE_LIST
)
2561 my_friendly_assert (TREE_CODE (TREE_VALUE (function
))
2562 == FUNCTION_DECL
, 312);
2563 basetype
= DECL_CLASS_CONTEXT (TREE_VALUE (function
));
2564 function
= TREE_PURPOSE (function
);
2566 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2568 if (TREE_CODE (function
) == OFFSET_REF
)
2570 if (TREE_OPERAND (function
, 0))
2571 decl
= TREE_OPERAND (function
, 0);
2573 /* Call via a pointer to member function. */
2574 if (decl
== NULL_TREE
)
2576 error ("pointer to member function called, but not in class scope");
2577 return error_mark_node
;
2579 /* What other type of POINTER_TYPE could this be? */
2580 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2581 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2582 && TREE_CODE (function
) != OFFSET_REF
)
2583 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
,
2588 /* this is an abbreviated method call.
2589 must go through here in case it is a virtual function.
2590 @@ Perhaps this could be optimized. */
2592 if (basetype
&& (! current_class_type
2593 || ! DERIVED_FROM_P (basetype
, current_class_type
)))
2594 return build_member_call (basetype
, function
, params
);
2596 if (decl
== NULL_TREE
)
2598 if (current_class_type
== NULL_TREE
)
2600 error ("object missing in call to method `%s'",
2601 IDENTIFIER_POINTER (function
));
2602 return error_mark_node
;
2604 /* Yow: call from a static member function. */
2605 decl
= build1 (NOP_EXPR
, build_pointer_type (current_class_type
),
2607 decl
= build_indirect_ref (decl
, NULL_PTR
);
2610 /* Put back explicit template arguments, if any. */
2612 function
= template_id
;
2613 return build_method_call (decl
, function
, params
,
2614 NULL_TREE
, LOOKUP_NORMAL
);
2616 else if (TREE_CODE (function
) == COMPONENT_REF
2617 && type
== unknown_type_node
)
2619 /* Should we undo what was done in build_component_ref? */
2620 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function
, 1))) == TREE_VEC
)
2621 /* Get the name that build_component_ref hid. */
2622 function
= DECL_NAME (TREE_VALUE (TREE_OPERAND (function
, 1)));
2624 function
= TREE_PURPOSE (TREE_OPERAND (function
, 1));
2625 return build_method_call (decl
, function
, params
,
2626 NULL_TREE
, LOOKUP_NORMAL
);
2628 else if (really_overloaded_fn (function
))
2630 if (OVL_FUNCTION (function
) == NULL_TREE
)
2632 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2633 TREE_PURPOSE (function
));
2634 return error_mark_node
;
2638 /* Put back explicit template arguments, if any. */
2640 function
= template_id
;
2641 return build_new_function_call (function
, params
);
2645 /* Remove a potential OVERLOAD around it */
2646 function
= OVL_CURRENT (function
);
2649 if (TREE_CODE (function
) == OFFSET_REF
)
2651 /* If the component is a data element (or a virtual function), we play
2652 games here to make things work. */
2655 if (TREE_OPERAND (function
, 0))
2656 decl
= TREE_OPERAND (function
, 0);
2658 decl
= current_class_ref
;
2660 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2662 /* Sigh. OFFSET_REFs are being used for too many things.
2663 They're being used both for -> and ->*, and we want to resolve
2664 the -> cases here, but leave the ->*. We could use
2665 resolve_offset_ref for those, too, but it would call
2666 get_member_function_from_ptrfunc and decl_addr wouldn't get
2667 updated properly. Nasty. */
2668 if (TREE_CODE (TREE_OPERAND (function
, 1)) == FIELD_DECL
)
2669 function
= resolve_offset_ref (function
);
2671 function
= TREE_OPERAND (function
, 1);
2673 function
= get_member_function_from_ptrfunc (&decl_addr
, function
);
2674 params
= expr_tree_cons (NULL_TREE
, decl_addr
, params
);
2675 return build_function_call (function
, params
);
2678 type
= TREE_TYPE (function
);
2679 if (type
!= error_mark_node
)
2681 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2682 type
= TREE_TYPE (type
);
2684 if (IS_AGGR_TYPE (type
))
2685 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2690 tree fntype
= TREE_TYPE (function
);
2691 tree ctypeptr
= NULL_TREE
;
2693 /* Explicitly named method? */
2694 if (TREE_CODE (function
) == FUNCTION_DECL
)
2695 ctypeptr
= build_pointer_type (DECL_CLASS_CONTEXT (function
));
2696 /* Expression with ptr-to-method type? It could either be a plain
2697 usage, or it might be a case where the ptr-to-method is being
2698 passed in as an argument. */
2699 else if (TYPE_PTRMEMFUNC_P (fntype
))
2701 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE
2702 (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2703 ctypeptr
= build_pointer_type (rec
);
2705 /* Unexpected node type? */
2707 my_friendly_abort (116);
2708 if (decl
== NULL_TREE
)
2710 if (current_function_decl
2711 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2712 error ("invalid call to member function needing `this' in static member function scope");
2714 error ("pointer to member function called, but not in class scope");
2715 return error_mark_node
;
2717 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2718 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2720 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2721 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2724 decl
= build_c_cast (ctypeptr
, decl
);
2725 params
= expr_tree_cons (NULL_TREE
, decl
, params
);
2728 return build_function_call (function
, params
);
2731 /* Resolve a pointer to member function. INSTANCE is the object
2732 instance to use, if the member points to a virtual member. */
2735 get_member_function_from_ptrfunc (instance_ptrptr
, function
)
2736 tree
*instance_ptrptr
;
2739 if (TREE_CODE (function
) == OFFSET_REF
)
2741 function
= TREE_OPERAND (function
, 1);
2744 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2746 tree fntype
, idx
, e1
, delta
, delta2
, e2
, e3
, aref
, vtbl
;
2747 tree instance
, basetype
;
2749 tree instance_ptr
= *instance_ptrptr
;
2751 if (TREE_SIDE_EFFECTS (instance_ptr
))
2752 instance_ptr
= save_expr (instance_ptr
);
2754 if (TREE_SIDE_EFFECTS (function
))
2755 function
= save_expr (function
);
2757 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2758 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2760 delta
= cp_convert (ptrdiff_type_node
,
2761 build_component_ref (function
, delta_identifier
,
2763 e3
= PFN_FROM_PTRMEMFUNC (function
);
2765 if (TYPE_SIZE (basetype
) != NULL_TREE
2766 && ! TYPE_VIRTUAL_P (basetype
))
2767 /* If basetype doesn't have virtual functions, don't emit code to
2768 handle that case. */
2772 /* Promoting idx before saving it improves performance on RISC
2773 targets. Without promoting, the first compare used
2774 load-with-sign-extend, while the second used normal load then
2775 shift to sign-extend. An optimizer flaw, perhaps, but it's
2776 easier to make this change. */
2777 idx
= save_expr (default_conversion
2778 (build_component_ref (function
,
2781 e1
= build_binary_op (GT_EXPR
, idx
, integer_zero_node
, 1);
2783 /* Convert down to the right base, before using the instance. */
2784 instance
= convert_pointer_to_real (basetype
, instance_ptr
);
2785 if (instance
== error_mark_node
&& instance_ptr
!= error_mark_node
)
2788 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2789 delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2792 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2793 vtbl
, cp_convert (ptrdiff_type_node
, delta2
));
2794 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2795 aref
= build_array_ref (vtbl
, build_binary_op (MINUS_EXPR
,
2797 integer_one_node
, 1));
2798 if (! flag_vtable_thunks
)
2800 aref
= save_expr (aref
);
2802 delta
= build_binary_op
2804 build_conditional_expr (e1
,
2805 build_component_ref (aref
,
2812 if (flag_vtable_thunks
)
2815 e2
= build_component_ref (aref
, pfn_identifier
, NULL_TREE
, 0);
2816 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2817 e1
= build_conditional_expr (e1
, e2
, e3
);
2819 /* Make sure this doesn't get evaluated first inside one of the
2820 branches of the COND_EXPR. */
2821 if (TREE_CODE (instance_ptr
) == SAVE_EXPR
)
2822 e1
= build (COMPOUND_EXPR
, TREE_TYPE (e1
),
2826 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2827 instance_ptr
, delta
);
2829 if (instance_ptr
== error_mark_node
2830 && TREE_CODE (e1
) != ADDR_EXPR
2831 && TREE_CODE (TREE_OPERAND (e1
, 0)) != FUNCTION_DECL
)
2832 cp_error ("object missing in `%E'", function
);
2840 build_function_call_real (function
, params
, require_complete
, flags
)
2841 tree function
, params
;
2842 int require_complete
, flags
;
2844 register tree fntype
, fndecl
;
2845 register tree value_type
;
2846 register tree coerced_params
;
2847 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2850 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2851 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2852 if (TREE_CODE (function
) == NOP_EXPR
2853 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2854 function
= TREE_OPERAND (function
, 0);
2856 if (TREE_CODE (function
) == FUNCTION_DECL
)
2858 name
= DECL_NAME (function
);
2859 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2861 GNU_xref_call (current_function_decl
,
2862 IDENTIFIER_POINTER (name
? name
2863 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
2865 mark_used (function
);
2868 /* Convert anything with function type to a pointer-to-function. */
2869 if (pedantic
&& DECL_MAIN_P (function
))
2870 pedwarn ("ANSI C++ forbids calling `main' from within program");
2872 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2873 (because calling an inline function does not mean the function
2874 needs to be separately compiled). */
2876 if (DECL_INLINE (function
))
2877 function
= inline_conversion (function
);
2879 function
= build_addr_func (function
);
2885 function
= build_addr_func (function
);
2888 if (function
== error_mark_node
)
2889 return error_mark_node
;
2891 fntype
= TREE_TYPE (function
);
2893 if (TYPE_PTRMEMFUNC_P (fntype
))
2895 cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2897 return error_mark_node
;
2900 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2901 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2903 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2904 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2906 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
2908 cp_error ("`%E' cannot be used as a function", function
);
2909 return error_mark_node
;
2912 /* fntype now gets the type of function pointed to. */
2913 fntype
= TREE_TYPE (fntype
);
2915 /* Convert the parameters to the types declared in the
2916 function prototype, or apply default promotions. */
2918 if (flags
& LOOKUP_COMPLAIN
)
2919 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2920 params
, fndecl
, LOOKUP_NORMAL
);
2922 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2925 if (coerced_params
== error_mark_node
)
2927 if (flags
& LOOKUP_SPECULATIVELY
)
2930 return error_mark_node
;
2933 /* Check for errors in format strings. */
2935 if (warn_format
&& (name
|| assembler_name
))
2936 check_function_format (name
, assembler_name
, coerced_params
);
2938 /* Recognize certain built-in functions so we can make tree-codes
2939 other than CALL_EXPR. We do this when it enables fold-const.c
2940 to do something useful. */
2942 if (TREE_CODE (function
) == ADDR_EXPR
2943 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2944 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2945 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2950 if (coerced_params
== 0)
2951 return integer_zero_node
;
2952 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2959 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2961 register tree result
2962 = build_call (function
, value_type
, coerced_params
);
2964 if (require_complete
)
2966 if (value_type
== void_type_node
)
2968 result
= require_complete_type (result
);
2970 if (IS_AGGR_TYPE (value_type
))
2971 result
= build_cplus_new (value_type
, result
);
2972 return convert_from_reference (result
);
2977 build_function_call (function
, params
)
2978 tree function
, params
;
2980 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2983 /* Convert the actual parameter expressions in the list VALUES
2984 to the types in the list TYPELIST.
2985 If parmdecls is exhausted, or when an element has NULL as its type,
2986 perform the default conversions.
2988 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2990 This is also where warnings about wrong number of args are generated.
2992 Return a list of expressions for the parameters as converted.
2994 Both VALUES and the returned value are chains of TREE_LIST nodes
2995 with the elements of the list in the TREE_VALUE slots of those nodes.
2997 In C++, unspecified trailing parameters can be filled in with their
2998 default arguments, if such were specified. Do so here. */
3001 convert_arguments (typelist
, values
, fndecl
, flags
)
3002 tree typelist
, values
, fndecl
;
3005 register tree typetail
, valtail
;
3006 register tree result
= NULL_TREE
;
3007 char *called_thing
= 0;
3010 /* Argument passing is always copy-initialization. */
3011 flags
|= LOOKUP_ONLYCONVERTING
;
3015 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
3017 if (DECL_NAME (fndecl
) == NULL_TREE
3018 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
3019 called_thing
= "constructor";
3021 called_thing
= "member function";
3024 called_thing
= "function";
3027 for (valtail
= values
, typetail
= typelist
;
3029 valtail
= TREE_CHAIN (valtail
), i
++)
3031 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
3032 register tree val
= TREE_VALUE (valtail
);
3034 if (val
== error_mark_node
)
3035 return error_mark_node
;
3037 if (type
== void_type_node
)
3041 cp_error_at ("too many arguments to %s `%+D'", called_thing
,
3043 error ("at this point in file");
3046 error ("too many arguments to function");
3047 /* In case anybody wants to know if this argument
3050 TREE_TYPE (tree_last (result
)) = error_mark_node
;
3054 /* The tree type of the parameter being passed may not yet be
3055 known. In this case, its type is TYPE_UNKNOWN, and will
3056 be instantiated by the type given by TYPE. If TYPE
3057 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
3058 if (type
&& type_unknown_p (val
))
3059 val
= require_instantiated_type (type
, val
, integer_zero_node
);
3060 else if (type_unknown_p (val
))
3062 /* Strip the `&' from an overloaded FUNCTION_DECL. */
3063 if (TREE_CODE (val
) == ADDR_EXPR
)
3064 val
= TREE_OPERAND (val
, 0);
3065 if (really_overloaded_fn (val
))
3066 cp_error ("insufficient type information to resolve address of overloaded function `%D'",
3067 DECL_NAME (get_first_fn (val
)));
3069 error ("insufficient type information in parameter list");
3070 val
= integer_zero_node
;
3072 else if (TREE_CODE (val
) == OFFSET_REF
3073 && TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3075 /* This is unclean. Should be handled elsewhere. */
3076 val
= build_unary_op (ADDR_EXPR
, val
, 0);
3078 else if (TREE_CODE (val
) == OFFSET_REF
)
3079 val
= resolve_offset_ref (val
);
3081 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3082 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3083 if (TREE_CODE (val
) == NOP_EXPR
3084 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3085 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3086 val
= TREE_OPERAND (val
, 0);
3088 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3090 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3091 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3092 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3093 val
= default_conversion (val
);
3095 val
= require_complete_type (val
);
3098 if (val
== error_mark_node
)
3099 return error_mark_node
;
3103 /* Formal parm type is specified by a function prototype. */
3106 if (TYPE_SIZE (complete_type (type
)) == 0)
3108 error ("parameter type of called function is incomplete");
3113 parmval
= convert_for_initialization
3114 (NULL_TREE
, type
, val
, flags
,
3115 "argument passing", fndecl
, i
);
3116 #ifdef PROMOTE_PROTOTYPES
3117 if ((TREE_CODE (type
) == INTEGER_TYPE
3118 || TREE_CODE (type
) == ENUMERAL_TYPE
)
3119 && (TYPE_PRECISION (type
)
3120 < TYPE_PRECISION (integer_type_node
)))
3121 parmval
= default_conversion (parmval
);
3125 if (parmval
== error_mark_node
)
3126 return error_mark_node
;
3128 result
= expr_tree_cons (NULL_TREE
, parmval
, result
);
3132 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
3133 val
= convert_from_reference (val
);
3135 result
= expr_tree_cons (NULL_TREE
,
3136 convert_arg_to_ellipsis (val
),
3141 typetail
= TREE_CHAIN (typetail
);
3144 if (typetail
!= 0 && typetail
!= void_list_node
)
3146 /* See if there are default arguments that can be used */
3147 if (TREE_PURPOSE (typetail
))
3149 for (; typetail
!= void_list_node
; ++i
)
3151 tree type
= TREE_VALUE (typetail
);
3152 tree val
= TREE_PURPOSE (typetail
);
3153 tree parmval
= convert_default_arg (type
, val
);
3155 if (parmval
== error_mark_node
)
3156 return error_mark_node
;
3158 result
= expr_tree_cons (0, parmval
, result
);
3159 typetail
= TREE_CHAIN (typetail
);
3160 /* ends with `...'. */
3161 if (typetail
== NULL_TREE
)
3169 char *buf
= (char *)alloca (32 + strlen (called_thing
));
3170 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
3171 cp_error_at (buf
, fndecl
);
3172 error ("at this point in file");
3175 error ("too few arguments to function");
3176 return error_mark_list
;
3180 return nreverse (result
);
3183 /* Build a binary-operation expression, after performing default
3184 conversions on the operands. CODE is the kind of expression to build. */
3187 build_x_binary_op (code
, arg1
, arg2
)
3188 enum tree_code code
;
3191 if (processing_template_decl
)
3192 return build_min_nt (code
, arg1
, arg2
);
3194 return build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
3198 build_binary_op (code
, arg1
, arg2
, convert_p
)
3199 enum tree_code code
;
3211 args
[0] = decay_conversion (args
[0]);
3212 args
[1] = decay_conversion (args
[1]);
3214 if (args
[0] == error_mark_node
|| args
[1] == error_mark_node
)
3215 return error_mark_node
;
3217 type0
= TREE_TYPE (args
[0]);
3218 type1
= TREE_TYPE (args
[1]);
3220 if (type_unknown_p (args
[0]))
3222 args
[0] = instantiate_type (type1
, args
[0], 1);
3223 args
[0] = decay_conversion (args
[0]);
3225 else if (type_unknown_p (args
[1]))
3227 args
[1] = require_instantiated_type (type0
, args
[1],
3229 args
[1] = decay_conversion (args
[1]);
3232 if (IS_AGGR_TYPE (type0
) || IS_AGGR_TYPE (type1
))
3233 my_friendly_abort (754867);
3235 return build_binary_op_nodefault (code
, args
[0], args
[1], code
);
3238 /* Build a binary-operation expression without default conversions.
3239 CODE is the kind of expression to build.
3240 This function differs from `build' in several ways:
3241 the data type of the result is computed and recorded in it,
3242 warnings are generated if arg data types are invalid,
3243 special handling for addition and subtraction of pointers is known,
3244 and some optimization is done (operations on narrow ints
3245 are done in the narrower type when that gives the same result).
3246 Constant folding is also done before the result is returned.
3248 ERROR_CODE is the code that determines what to say in error messages.
3249 It is usually, but not always, the same as CODE.
3251 Note that the operands will never have enumeral types
3252 because either they have just had the default conversions performed
3253 or they have both just been converted to some other type in which
3254 the arithmetic is to be done.
3256 C++: must do special pointer arithmetic when implementing
3257 multiple inheritance, and deal with pointer to member functions. */
3260 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
3261 enum tree_code code
;
3262 tree orig_op0
, orig_op1
;
3263 enum tree_code error_code
;
3266 register enum tree_code code0
, code1
;
3269 /* Expression code to give to the expression when it is built.
3270 Normally this is CODE, which is what the caller asked for,
3271 but in some special cases we change it. */
3272 register enum tree_code resultcode
= code
;
3274 /* Data type in which the computation is to be performed.
3275 In the simplest cases this is the common type of the arguments. */
3276 register tree result_type
= NULL
;
3278 /* Nonzero means operands have already been type-converted
3279 in whatever way is necessary.
3280 Zero means they need to be converted to RESULT_TYPE. */
3283 /* Nonzero means create the expression with this type, rather than
3285 tree build_type
= 0;
3287 /* Nonzero means after finally constructing the expression
3288 convert it to this type. */
3289 tree final_type
= 0;
3291 /* Nonzero if this is an operation like MIN or MAX which can
3292 safely be computed in short if both args are promoted shorts.
3293 Also implies COMMON.
3294 -1 indicates a bitwise operation; this makes a difference
3295 in the exact conditions for when it is safe to do the operation
3296 in a narrower mode. */
3299 /* Nonzero if this is a comparison operation;
3300 if both args are promoted shorts, compare the original shorts.
3301 Also implies COMMON. */
3302 int short_compare
= 0;
3304 /* Nonzero if this is a right-shift operation, which can be computed on the
3305 original short and then promoted if the operand is a promoted short. */
3306 int short_shift
= 0;
3308 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3311 /* Apply default conversions. */
3312 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3313 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3314 || code
== TRUTH_XOR_EXPR
)
3316 op0
= decay_conversion (orig_op0
);
3317 op1
= decay_conversion (orig_op1
);
3321 op0
= default_conversion (orig_op0
);
3322 op1
= default_conversion (orig_op1
);
3325 type0
= TREE_TYPE (op0
);
3326 type1
= TREE_TYPE (op1
);
3328 /* The expression codes of the data types of the arguments tell us
3329 whether the arguments are integers, floating, pointers, etc. */
3330 code0
= TREE_CODE (type0
);
3331 code1
= TREE_CODE (type1
);
3333 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3334 STRIP_TYPE_NOPS (op0
);
3335 STRIP_TYPE_NOPS (op1
);
3337 /* If an error was already reported for one of the arguments,
3338 avoid reporting another error. */
3340 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3341 return error_mark_node
;
3346 /* Handle the pointer + int case. */
3347 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3348 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
3349 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
3350 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
3356 /* Subtraction of two similar pointers.
3357 We must subtract them as integers, then divide by object size. */
3358 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3359 && comp_target_types (type0
, type1
, 1))
3360 return pointer_diff (op0
, op1
, common_type (type0
, type1
));
3361 /* Handle pointer minus int. Just like pointer plus int. */
3362 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3363 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
3372 case TRUNC_DIV_EXPR
:
3374 case FLOOR_DIV_EXPR
:
3375 case ROUND_DIV_EXPR
:
3376 case EXACT_DIV_EXPR
:
3377 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3378 || code0
== COMPLEX_TYPE
)
3379 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3380 || code1
== COMPLEX_TYPE
))
3382 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
3383 cp_warning ("division by zero in `%E / 0'", op0
);
3384 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
3385 cp_warning ("division by zero in `%E / 0.'", op0
);
3387 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
3388 resultcode
= RDIV_EXPR
;
3390 /* When dividing two signed integers, we have to promote to int.
3391 unless we divide by a constant != -1. Note that default
3392 conversion will have been performed on the operands at this
3393 point, so we have to dig out the original type to find out if
3395 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3396 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3397 || (TREE_CODE (op1
) == INTEGER_CST
3398 && (TREE_INT_CST_LOW (op1
) != -1
3399 || TREE_INT_CST_HIGH (op1
) != -1)));
3405 case BIT_ANDTC_EXPR
:
3408 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3410 /* If one operand is a constant, and the other is a short type
3411 that has been converted to an int,
3412 really do the work in the short type and then convert the
3413 result to int. If we are lucky, the constant will be 0 or 1
3414 in the short type, making the entire operation go away. */
3415 if (TREE_CODE (op0
) == INTEGER_CST
3416 && TREE_CODE (op1
) == NOP_EXPR
3417 && (TYPE_PRECISION (type1
)
3418 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3419 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3421 final_type
= result_type
;
3422 op1
= TREE_OPERAND (op1
, 0);
3423 result_type
= TREE_TYPE (op1
);
3425 if (TREE_CODE (op1
) == INTEGER_CST
3426 && TREE_CODE (op0
) == NOP_EXPR
3427 && (TYPE_PRECISION (type0
)
3428 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3429 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3431 final_type
= result_type
;
3432 op0
= TREE_OPERAND (op0
, 0);
3433 result_type
= TREE_TYPE (op0
);
3437 case TRUNC_MOD_EXPR
:
3438 case FLOOR_MOD_EXPR
:
3439 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
3440 cp_warning ("division by zero in `%E %% 0'", op0
);
3441 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
3442 cp_warning ("division by zero in `%E %% 0.'", op0
);
3444 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3446 /* Although it would be tempting to shorten always here, that loses
3447 on some targets, since the modulo instruction is undefined if the
3448 quotient can't be represented in the computation mode. We shorten
3449 only if unsigned or if dividing by something we know != -1. */
3450 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3451 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3452 || (TREE_CODE (op1
) == INTEGER_CST
3453 && (TREE_INT_CST_LOW (op1
) != -1
3454 || TREE_INT_CST_HIGH (op1
) != -1)));
3459 case TRUTH_ANDIF_EXPR
:
3460 case TRUTH_ORIF_EXPR
:
3461 case TRUTH_AND_EXPR
:
3463 result_type
= boolean_type_node
;
3466 /* Shift operations: result has same type as first operand;
3467 always convert second operand to int.
3468 Also set SHORT_SHIFT if shifting rightward. */
3471 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3473 result_type
= type0
;
3474 if (TREE_CODE (op1
) == INTEGER_CST
)
3476 if (tree_int_cst_lt (op1
, integer_zero_node
))
3477 warning ("right shift count is negative");
3480 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3482 if (TREE_INT_CST_HIGH (op1
) != 0
3483 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3484 >= TYPE_PRECISION (type0
)))
3485 warning ("right shift count >= width of type");
3488 /* Convert the shift-count to an integer, regardless of
3489 size of value being shifted. */
3490 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3491 op1
= cp_convert (integer_type_node
, op1
);
3492 /* Avoid converting op1 to result_type later. */
3498 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3500 result_type
= type0
;
3501 if (TREE_CODE (op1
) == INTEGER_CST
)
3503 if (tree_int_cst_lt (op1
, integer_zero_node
))
3504 warning ("left shift count is negative");
3505 else if (TREE_INT_CST_HIGH (op1
) != 0
3506 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3507 >= TYPE_PRECISION (type0
)))
3508 warning ("left shift count >= width of type");
3510 /* Convert the shift-count to an integer, regardless of
3511 size of value being shifted. */
3512 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3513 op1
= cp_convert (integer_type_node
, op1
);
3514 /* Avoid converting op1 to result_type later. */
3521 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3523 result_type
= type0
;
3524 if (TREE_CODE (op1
) == INTEGER_CST
)
3526 if (tree_int_cst_lt (op1
, integer_zero_node
))
3527 warning ("%s rotate count is negative",
3528 (code
== LROTATE_EXPR
) ? "left" : "right");
3529 else if (TREE_INT_CST_HIGH (op1
) != 0
3530 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3531 >= TYPE_PRECISION (type0
)))
3532 warning ("%s rotate count >= width of type",
3533 (code
== LROTATE_EXPR
) ? "left" : "right");
3535 /* Convert the shift-count to an integer, regardless of
3536 size of value being shifted. */
3537 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3538 op1
= cp_convert (integer_type_node
, op1
);
3544 build_type
= boolean_type_node
;
3545 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3546 || code0
== COMPLEX_TYPE
)
3547 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3548 || code1
== COMPLEX_TYPE
))
3550 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3552 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3553 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3555 if (comp_target_types (type0
, type1
, 1))
3556 result_type
= common_type (type0
, type1
);
3557 else if (tt0
== void_type_node
)
3559 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3560 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3561 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3562 else if (TREE_CODE (tt1
) == OFFSET_TYPE
)
3563 pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
3565 else if (tt1
== void_type_node
)
3567 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3568 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3569 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3572 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3575 if (result_type
== NULL_TREE
)
3576 result_type
= ptr_type_node
;
3578 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3579 && integer_zerop (op1
))
3580 result_type
= type0
;
3581 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3582 && integer_zerop (op0
))
3583 result_type
= type1
;
3584 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3586 result_type
= type0
;
3587 error ("ANSI C++ forbids comparison between pointer and integer");
3589 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3591 result_type
= type1
;
3592 error ("ANSI C++ forbids comparison between pointer and integer");
3594 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3595 && integer_zerop (op1
))
3597 op0
= build_component_ref (op0
, index_identifier
, NULL_TREE
, 0);
3598 op1
= integer_zero_node
;
3599 result_type
= TREE_TYPE (op0
);
3601 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3602 && integer_zerop (op0
))
3604 op0
= build_component_ref (op1
, index_identifier
, NULL_TREE
, 0);
3605 op1
= integer_zero_node
;
3606 result_type
= TREE_TYPE (op0
);
3608 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3609 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3610 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3612 /* The code we generate for the test is:
3614 (op0.index == op1.index
3615 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3616 || op0.pfn == op1.pfn)) */
3618 tree index0
= build_component_ref (op0
, index_identifier
,
3620 tree index1
= save_expr (build_component_ref (op1
, index_identifier
,
3622 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3623 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3624 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3625 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3627 tree integer_neg_one_node
3628 = build_binary_op (MINUS_EXPR
, integer_zero_node
,
3629 integer_one_node
, 1);
3630 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3631 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3632 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3633 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3635 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3636 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3637 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3638 if (code
== EQ_EXPR
)
3640 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3642 else if (TYPE_PTRMEMFUNC_P (type0
)
3643 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3645 tree index0
= build_component_ref (op0
, index_identifier
,
3648 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3649 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3650 tree delta21
= integer_zero_node
;
3652 tree integer_neg_one_node
3653 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3654 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3655 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3657 /* Map everything down one to make room for
3658 the null pointer to member. */
3659 index1
= size_binop (PLUS_EXPR
,
3660 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3662 op1
= integer_zero_node
;
3663 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE
3664 (TREE_TYPE (type1
)));
3665 delta21
= DECL_FIELD_BITPOS (delta21
);
3666 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
,
3667 size_int (BITS_PER_UNIT
));
3668 delta21
= convert (sizetype
, delta21
);
3671 index1
= integer_neg_one_node
;
3673 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
),
3675 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3678 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3679 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3680 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3681 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3683 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3684 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3685 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3686 if (code
== EQ_EXPR
)
3688 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3690 else if (TYPE_PTRMEMFUNC_P (type1
)
3691 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3693 return build_binary_op (code
, op1
, op0
, 1);
3699 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3700 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3702 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3704 if (comp_target_types (type0
, type1
, 1))
3705 result_type
= common_type (type0
, type1
);
3708 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3710 result_type
= ptr_type_node
;
3719 build_type
= boolean_type_node
;
3720 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3721 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3723 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3725 if (comp_target_types (type0
, type1
, 1))
3726 result_type
= common_type (type0
, type1
);
3729 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3731 result_type
= ptr_type_node
;
3734 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3735 && integer_zerop (op1
))
3736 result_type
= type0
;
3737 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3738 && integer_zerop (op0
))
3739 result_type
= type1
;
3740 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3742 result_type
= type0
;
3743 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3745 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3747 result_type
= type1
;
3748 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3756 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
3758 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
3760 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
3762 if (shorten
|| common
|| short_compare
)
3763 result_type
= common_type (type0
, type1
);
3765 /* For certain operations (which identify themselves by shorten != 0)
3766 if both args were extended from the same smaller type,
3767 do the arithmetic in that type and then extend.
3769 shorten !=0 and !=1 indicates a bitwise operation.
3770 For them, this optimization is safe only if
3771 both args are zero-extended or both are sign-extended.
3772 Otherwise, we might change the result.
3773 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3774 but calculated in (unsigned short) it would be (unsigned short)-1. */
3776 if (shorten
&& none_complex
)
3778 int unsigned0
, unsigned1
;
3779 tree arg0
= get_narrower (op0
, &unsigned0
);
3780 tree arg1
= get_narrower (op1
, &unsigned1
);
3781 /* UNS is 1 if the operation to be done is an unsigned one. */
3782 int uns
= TREE_UNSIGNED (result_type
);
3785 final_type
= result_type
;
3787 /* Handle the case that OP0 does not *contain* a conversion
3788 but it *requires* conversion to FINAL_TYPE. */
3790 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3791 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3792 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3793 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3795 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3797 /* For bitwise operations, signedness of nominal type
3798 does not matter. Consider only how operands were extended. */
3802 /* Note that in all three cases below we refrain from optimizing
3803 an unsigned operation on sign-extended args.
3804 That would not be valid. */
3806 /* Both args variable: if both extended in same way
3807 from same width, do it in that width.
3808 Do it unsigned if args were zero-extended. */
3809 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3810 < TYPE_PRECISION (result_type
))
3811 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3812 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3813 && unsigned0
== unsigned1
3814 && (unsigned0
|| !uns
))
3816 = signed_or_unsigned_type (unsigned0
,
3817 common_type (TREE_TYPE (arg0
),
3819 else if (TREE_CODE (arg0
) == INTEGER_CST
3820 && (unsigned1
|| !uns
)
3821 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3822 < TYPE_PRECISION (result_type
))
3823 && (type
= signed_or_unsigned_type (unsigned1
,
3825 int_fits_type_p (arg0
, type
)))
3827 else if (TREE_CODE (arg1
) == INTEGER_CST
3828 && (unsigned0
|| !uns
)
3829 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3830 < TYPE_PRECISION (result_type
))
3831 && (type
= signed_or_unsigned_type (unsigned0
,
3833 int_fits_type_p (arg1
, type
)))
3837 /* Shifts can be shortened if shifting right. */
3842 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3844 final_type
= result_type
;
3846 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3847 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3849 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3850 /* We can shorten only if the shift count is less than the
3851 number of bits in the smaller type size. */
3852 && TREE_INT_CST_HIGH (op1
) == 0
3853 && TYPE_PRECISION (TREE_TYPE (arg0
)) > TREE_INT_CST_LOW (op1
)
3854 /* If arg is sign-extended and then unsigned-shifted,
3855 we can simulate this with a signed shift in arg's type
3856 only if the extended result is at least twice as wide
3857 as the arg. Otherwise, the shift could use up all the
3858 ones made by sign-extension and bring in zeros.
3859 We can't optimize that case at all, but in most machines
3860 it never happens because available widths are 2**N. */
3861 && (!TREE_UNSIGNED (final_type
)
3863 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
)))
3864 <= TYPE_PRECISION (result_type
))))
3866 /* Do an unsigned shift if the operand was zero-extended. */
3868 = signed_or_unsigned_type (unsigned_arg
,
3870 /* Convert value-to-be-shifted to that type. */
3871 if (TREE_TYPE (op0
) != result_type
)
3872 op0
= cp_convert (result_type
, op0
);
3877 /* Comparison operations are shortened too but differently.
3878 They identify themselves by setting short_compare = 1. */
3882 /* Don't write &op0, etc., because that would prevent op0
3883 from being kept in a register.
3884 Instead, make copies of the our local variables and
3885 pass the copies by reference, then copy them back afterward. */
3886 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3887 enum tree_code xresultcode
= resultcode
;
3889 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3891 return cp_convert (boolean_type_node
, val
);
3892 op0
= xop0
, op1
= xop1
;
3894 resultcode
= xresultcode
;
3897 if (short_compare
&& warn_sign_compare
)
3899 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
3900 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3902 int unsignedp0
, unsignedp1
;
3903 tree primop0
= get_narrower (op0
, &unsignedp0
);
3904 tree primop1
= get_narrower (op1
, &unsignedp1
);
3906 /* Check for comparison of different enum types. */
3907 if (flag_int_enum_equivalence
== 0
3908 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
3909 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
3910 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
3911 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
3913 cp_warning ("comparison between `%#T' and `%#T'",
3914 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
3917 /* Give warnings for comparisons between signed and unsigned
3918 quantities that may fail. */
3919 /* Do the checking based on the original operand trees, so that
3920 casts will be considered, but default promotions won't be. */
3922 /* Do not warn if the comparison is being done in a signed type,
3923 since the signed type will only be chosen if it can represent
3924 all the values of the unsigned type. */
3925 if (! TREE_UNSIGNED (result_type
))
3927 /* Do not warn if both operands are unsigned. */
3928 else if (op0_signed
== op1_signed
)
3930 /* Do not warn if the signed quantity is an unsuffixed
3931 integer literal (or some static constant expression
3932 involving such literals) and it is non-negative. */
3933 else if ((op0_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3934 && tree_int_cst_sgn (orig_op0
) >= 0)
3935 || (op1_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3936 && tree_int_cst_sgn (orig_op1
) >= 0))
3938 /* Do not warn if the comparison is an equality operation,
3939 the unsigned quantity is an integral constant and it does
3940 not use the most significant bit of result_type. */
3941 else if ((resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
3942 && ((op0_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3943 && int_fits_type_p (orig_op1
,
3944 signed_type (result_type
)))
3945 || (op1_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3946 && int_fits_type_p (orig_op0
,
3947 signed_type (result_type
)))))
3950 warning ("comparison between signed and unsigned");
3952 /* Warn if two unsigned values are being compared in a size
3953 larger than their original size, and one (and only one) is the
3954 result of a `~' operator. This comparison will always fail.
3956 Also warn if one operand is a constant, and the constant does not
3957 have all bits set that are set in the ~ operand when it is
3960 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3961 ^ (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
3963 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3964 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3965 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3966 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3968 if (TREE_CODE (primop0
) == INTEGER_CST
3969 || TREE_CODE (primop1
) == INTEGER_CST
)
3972 HOST_WIDE_INT constant
, mask
;
3976 if (TREE_CODE (primop0
) == INTEGER_CST
)
3979 unsignedp
= unsignedp1
;
3980 constant
= TREE_INT_CST_LOW (primop0
);
3985 unsignedp
= unsignedp0
;
3986 constant
= TREE_INT_CST_LOW (primop1
);
3989 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3990 if (bits
< TYPE_PRECISION (result_type
)
3991 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3993 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3994 if ((mask
& constant
) != mask
)
3995 warning ("comparison of promoted ~unsigned with constant");
3998 else if (unsignedp0
&& unsignedp1
3999 && (TYPE_PRECISION (TREE_TYPE (primop0
))
4000 < TYPE_PRECISION (result_type
))
4001 && (TYPE_PRECISION (TREE_TYPE (primop1
))
4002 < TYPE_PRECISION (result_type
)))
4003 warning ("comparison of promoted ~unsigned with unsigned");
4008 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
4009 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4010 Then the expression will be built.
4011 It will be given type FINAL_TYPE if that is nonzero;
4012 otherwise, it will be given type RESULT_TYPE. */
4016 cp_error ("invalid operands `%T' and `%T' to binary `%O'",
4017 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), error_code
);
4018 return error_mark_node
;
4021 /* Issue warnings about peculiar, but legal, uses of NULL. */
4022 if (/* It's reasonable to use pointer values as operands of &&
4023 and ||, so NULL is no exception. */
4024 !(code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
4025 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
4026 (orig_op0
== null_node
4027 && TREE_CODE (TREE_TYPE (op1
)) != POINTER_TYPE
)
4028 /* Or vice versa. */
4029 || (orig_op1
== null_node
4030 && TREE_CODE (TREE_TYPE (op0
)) != POINTER_TYPE
)
4031 /* Or, both are NULL and the operation was not a comparison. */
4032 || (orig_op0
== null_node
&& orig_op1
== null_node
4033 && code
!= EQ_EXPR
&& code
!= NE_EXPR
)))
4034 /* Some sort of arithmetic operation involving NULL was
4035 performed. Note that pointer-difference and pointer-addition
4036 have already been handled above, and so we don't end up here in
4038 cp_warning ("NULL used in arithmetic");
4042 if (TREE_TYPE (op0
) != result_type
)
4043 op0
= cp_convert (result_type
, op0
);
4044 if (TREE_TYPE (op1
) != result_type
)
4045 op1
= cp_convert (result_type
, op1
);
4048 if (build_type
== NULL_TREE
)
4049 build_type
= result_type
;
4052 register tree result
= build (resultcode
, build_type
, op0
, op1
);
4053 register tree folded
;
4055 folded
= fold (result
);
4056 if (folded
== result
)
4057 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4058 if (final_type
!= 0)
4059 return cp_convert (final_type
, folded
);
4064 /* Return a tree for the sum or difference (RESULTCODE says which)
4065 of pointer PTROP and integer INTOP. */
4068 pointer_int_sum (resultcode
, ptrop
, intop
)
4069 enum tree_code resultcode
;
4070 register tree ptrop
, intop
;
4074 register tree result
;
4075 register tree folded
= fold (intop
);
4077 /* The result is a pointer of the same type that is being added. */
4079 register tree result_type
= TREE_TYPE (ptrop
);
4081 if (!complete_type_or_else (result_type
))
4082 return error_mark_node
;
4084 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
4086 if (pedantic
|| warn_pointer_arith
)
4087 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
4088 size_exp
= integer_one_node
;
4090 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
4092 if (pedantic
|| warn_pointer_arith
)
4093 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
4094 size_exp
= integer_one_node
;
4096 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
4098 if (pedantic
|| warn_pointer_arith
)
4099 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
4100 size_exp
= integer_one_node
;
4102 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
4104 if (pedantic
|| warn_pointer_arith
)
4105 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
4106 size_exp
= integer_one_node
;
4109 size_exp
= size_in_bytes (complete_type (TREE_TYPE (result_type
)));
4111 /* Needed to make OOPS V2R3 work. */
4113 if (TREE_CODE (intop
) == INTEGER_CST
4114 && TREE_INT_CST_LOW (intop
) == 0
4115 && TREE_INT_CST_HIGH (intop
) == 0)
4118 /* If what we are about to multiply by the size of the elements
4119 contains a constant term, apply distributive law
4120 and multiply that constant term separately.
4121 This helps produce common subexpressions. */
4123 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
4124 && ! TREE_CONSTANT (intop
)
4125 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
4126 && TREE_CONSTANT (size_exp
))
4128 enum tree_code subcode
= resultcode
;
4129 if (TREE_CODE (intop
) == MINUS_EXPR
)
4130 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
4131 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
4132 intop
= TREE_OPERAND (intop
, 0);
4135 /* Convert the integer argument to a type the same size as sizetype
4136 so the multiply won't overflow spuriously. */
4138 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
))
4139 intop
= cp_convert (type_for_size (TYPE_PRECISION (sizetype
), 0), intop
);
4141 /* Replace the integer argument with a suitable product by the object size.
4142 Do this multiplication as signed, then convert to the appropriate
4143 pointer type (actually unsigned integral). */
4145 intop
= cp_convert (result_type
,
4146 build_binary_op (MULT_EXPR
, intop
,
4147 cp_convert (TREE_TYPE (intop
),
4151 /* Create the sum or difference. */
4153 result
= build (resultcode
, result_type
, ptrop
, intop
);
4155 folded
= fold (result
);
4156 if (folded
== result
)
4157 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
4161 /* Return a tree for the difference of pointers OP0 and OP1.
4162 The resulting tree has type int. */
4165 pointer_diff (op0
, op1
, ptrtype
)
4166 register tree op0
, op1
;
4167 register tree ptrtype
;
4169 register tree result
, folded
;
4170 tree restype
= ptrdiff_type_node
;
4171 tree target_type
= TREE_TYPE (ptrtype
);
4173 if (!complete_type_or_else (target_type
))
4174 return error_mark_node
;
4176 if (pedantic
|| warn_pointer_arith
)
4178 if (TREE_CODE (target_type
) == VOID_TYPE
)
4179 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
4180 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
4181 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
4182 if (TREE_CODE (target_type
) == METHOD_TYPE
)
4183 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
4184 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
4185 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
4188 /* First do the subtraction as integers;
4189 then drop through to build the divide operator. */
4191 op0
= build_binary_op (MINUS_EXPR
, cp_convert (restype
, op0
),
4192 cp_convert (restype
, op1
), 1);
4194 /* This generates an error if op1 is a pointer to an incomplete type. */
4195 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
4196 error ("arithmetic on pointer to an incomplete type");
4198 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
4199 || TREE_CODE (target_type
) == FUNCTION_TYPE
4200 || TREE_CODE (target_type
) == METHOD_TYPE
4201 || TREE_CODE (target_type
) == OFFSET_TYPE
)
4203 : size_in_bytes (target_type
));
4205 /* Do the division. */
4207 result
= build (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
4209 folded
= fold (result
);
4210 if (folded
== result
)
4211 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4215 /* Handle the case of taking the address of a COMPONENT_REF.
4216 Called by `build_unary_op' and `build_up_reference'.
4218 ARG is the COMPONENT_REF whose address we want.
4219 ARGTYPE is the pointer type that this address should have.
4220 MSG is an error message to print if this COMPONENT_REF is not
4221 addressable (such as a bitfield). */
4224 build_component_addr (arg
, argtype
, msg
)
4228 tree field
= TREE_OPERAND (arg
, 1);
4229 tree basetype
= decl_type_context (field
);
4230 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
4232 if (DECL_BIT_FIELD (field
))
4234 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
4235 return error_mark_node
;
4238 if (TREE_CODE (field
) == FIELD_DECL
4239 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
4241 /* Can't convert directly to ARGTYPE, since that
4242 may have the same pointer type as one of our
4244 rval
= build1 (NOP_EXPR
, argtype
,
4245 convert_pointer_to (basetype
, rval
));
4246 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
4249 /* This conversion is harmless. */
4250 rval
= convert_force (argtype
, rval
, 0);
4252 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
4254 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
4255 size_int (BITS_PER_UNIT
));
4256 int flag
= TREE_CONSTANT (rval
);
4257 offset
= convert (sizetype
, offset
);
4258 rval
= fold (build (PLUS_EXPR
, argtype
,
4259 rval
, cp_convert (argtype
, offset
)));
4260 TREE_CONSTANT (rval
) = flag
;
4265 /* Construct and perhaps optimize a tree representation
4266 for a unary operation. CODE, a tree_code, specifies the operation
4267 and XARG is the operand. */
4270 build_x_unary_op (code
, xarg
)
4271 enum tree_code code
;
4274 if (processing_template_decl
)
4275 return build_min_nt (code
, xarg
, NULL_TREE
);
4277 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
4279 if (code
== ADDR_EXPR
4280 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
4281 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
4282 && TYPE_SIZE (TREE_TYPE (xarg
)) == NULL_TREE
)
4283 || (TREE_CODE (xarg
) == OFFSET_REF
)))
4284 /* don't look for a function */;
4289 rval
= build_new_op (code
, LOOKUP_NORMAL
, xarg
,
4290 NULL_TREE
, NULL_TREE
);
4291 if (rval
|| code
!= ADDR_EXPR
)
4295 if (code
== ADDR_EXPR
)
4297 if (TREE_CODE (xarg
) == TARGET_EXPR
)
4298 warning ("taking address of temporary");
4301 return build_unary_op (code
, xarg
, 0);
4304 /* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4307 condition_conversion (expr
)
4311 if (processing_template_decl
)
4313 t
= cp_convert (boolean_type_node
, expr
);
4314 t
= fold (build1 (CLEANUP_POINT_EXPR
, boolean_type_node
, t
));
4318 /* C++: Must handle pointers to members.
4320 Perhaps type instantiation should be extended to handle conversion
4321 from aggregates to types we don't yet know we want? (Or are those
4322 cases typically errors which should be reported?)
4324 NOCONVERT nonzero suppresses the default promotions
4325 (such as from short to int). */
4328 build_unary_op (code
, xarg
, noconvert
)
4329 enum tree_code code
;
4333 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4334 register tree arg
= xarg
;
4335 register tree argtype
= 0;
4336 char *errstring
= NULL
;
4339 if (arg
== error_mark_node
)
4340 return error_mark_node
;
4345 /* This is used for unary plus, because a CONVERT_EXPR
4346 is enough to prevent anybody from looking inside for
4347 associativity, but won't generate any code. */
4348 if (!(arg
= build_expr_type_conversion
4349 (WANT_ARITH
| WANT_ENUM
| WANT_POINTER
, arg
, 1)))
4350 errstring
= "wrong type argument to unary plus";
4354 arg
= default_conversion (arg
);
4355 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
4356 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4361 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4362 errstring
= "wrong type argument to unary minus";
4363 else if (!noconvert
)
4364 arg
= default_conversion (arg
);
4368 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4372 arg
= default_conversion (arg
);
4374 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
4376 errstring
= "wrong type argument to bit-complement";
4377 else if (!noconvert
)
4378 arg
= default_conversion (arg
);
4382 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4383 errstring
= "wrong type argument to abs";
4384 else if (!noconvert
)
4385 arg
= default_conversion (arg
);
4389 /* Conjugating a real value is a no-op, but allow it anyway. */
4390 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4391 errstring
= "wrong type argument to conjugation";
4392 else if (!noconvert
)
4393 arg
= default_conversion (arg
);
4396 case TRUTH_NOT_EXPR
:
4397 arg
= cp_convert (boolean_type_node
, arg
);
4398 val
= invert_truthvalue (arg
);
4399 if (arg
!= error_mark_node
)
4401 errstring
= "in argument to unary !";
4408 if (TREE_CODE (arg
) == COMPLEX_CST
)
4409 return TREE_REALPART (arg
);
4410 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4411 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4416 if (TREE_CODE (arg
) == COMPLEX_CST
)
4417 return TREE_IMAGPART (arg
);
4418 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4419 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4421 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4423 case PREINCREMENT_EXPR
:
4424 case POSTINCREMENT_EXPR
:
4425 case PREDECREMENT_EXPR
:
4426 case POSTDECREMENT_EXPR
:
4427 /* Handle complex lvalues (when permitted)
4428 by reduction to simpler cases. */
4430 val
= unary_complex_lvalue (code
, arg
);
4434 /* Increment or decrement the real part of the value,
4435 and don't change the imaginary part. */
4436 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4440 arg
= stabilize_reference (arg
);
4441 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
4442 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
4443 return build (COMPLEX_EXPR
, TREE_TYPE (arg
),
4444 build_unary_op (code
, real
, 1), imag
);
4447 /* Report invalid types. */
4449 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4452 if (code
== PREINCREMENT_EXPR
)
4453 errstring
="no pre-increment operator for type";
4454 else if (code
== POSTINCREMENT_EXPR
)
4455 errstring
="no post-increment operator for type";
4456 else if (code
== PREDECREMENT_EXPR
)
4457 errstring
="no pre-decrement operator for type";
4459 errstring
="no post-decrement operator for type";
4463 /* Report something read-only. */
4465 if (TYPE_READONLY (TREE_TYPE (arg
))
4466 || TREE_READONLY (arg
))
4467 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4468 || code
== POSTINCREMENT_EXPR
)
4469 ? "increment" : "decrement"),
4474 tree result_type
= TREE_TYPE (arg
);
4476 arg
= get_unwidened (arg
, 0);
4477 argtype
= TREE_TYPE (arg
);
4479 /* ARM $5.2.5 last annotation says this should be forbidden. */
4480 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4481 pedwarn ("ANSI C++ forbids %sing an enum",
4482 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4483 ? "increment" : "decrement");
4485 /* Compute the increment. */
4487 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4489 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
4490 if (TYPE_SIZE (complete_type (TREE_TYPE (argtype
))) == 0)
4491 cp_error ("cannot %s a pointer to incomplete type `%T'",
4492 ((code
== PREINCREMENT_EXPR
4493 || code
== POSTINCREMENT_EXPR
)
4494 ? "increment" : "decrement"), TREE_TYPE (argtype
));
4495 else if ((pedantic
|| warn_pointer_arith
)
4496 && (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
4497 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
))
4498 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
4499 ((code
== PREINCREMENT_EXPR
4500 || code
== POSTINCREMENT_EXPR
)
4501 ? "increment" : "decrement"), argtype
);
4502 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
4505 inc
= integer_one_node
;
4507 inc
= cp_convert (argtype
, inc
);
4509 /* Handle incrementing a cast-expression. */
4511 switch (TREE_CODE (arg
))
4516 case FIX_TRUNC_EXPR
:
4517 case FIX_FLOOR_EXPR
:
4518 case FIX_ROUND_EXPR
:
4521 tree incremented
, modify
, value
, compound
;
4522 if (! lvalue_p (arg
) && pedantic
)
4523 pedwarn ("cast to non-reference type used as lvalue");
4524 arg
= stabilize_reference (arg
);
4525 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4528 value
= save_expr (arg
);
4529 incremented
= build (((code
== PREINCREMENT_EXPR
4530 || code
== POSTINCREMENT_EXPR
)
4531 ? PLUS_EXPR
: MINUS_EXPR
),
4532 argtype
, value
, inc
);
4533 TREE_SIDE_EFFECTS (incremented
) = 1;
4535 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4536 compound
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4538 /* Eliminate warning about unused result of + or -. */
4539 TREE_NO_UNUSED_WARNING (compound
) = 1;
4547 /* Complain about anything else that is not a true lvalue. */
4548 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4549 || code
== POSTINCREMENT_EXPR
)
4550 ? "increment" : "decrement")))
4551 return error_mark_node
;
4553 /* Forbid using -- on `bool'. */
4554 if (TREE_TYPE (arg
) == boolean_type_node
)
4556 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4558 cp_error ("invalid use of `--' on bool variable `%D'", arg
);
4559 return error_mark_node
;
4562 /* This will only work if someone can convince Kenner to accept
4563 my patch to expand_increment. (jason) */
4564 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4566 if (code
== POSTINCREMENT_EXPR
)
4568 arg
= stabilize_reference (arg
);
4569 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4571 TREE_SIDE_EFFECTS (val
) = 1;
4572 arg
= save_expr (arg
);
4573 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4574 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4577 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4582 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4584 TREE_SIDE_EFFECTS (val
) = 1;
4585 return cp_convert (result_type
, val
);
4589 /* Note that this operation never does default_conversion
4590 regardless of NOCONVERT. */
4592 argtype
= lvalue_type (arg
);
4593 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4597 build_pointer_type (TREE_TYPE (argtype
)), arg
);
4598 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4601 else if (pedantic
&& DECL_MAIN_P (arg
))
4603 pedwarn ("taking address of function `main'");
4605 /* Let &* cancel out to simplify resulting code. */
4606 if (TREE_CODE (arg
) == INDIRECT_REF
)
4608 /* We don't need to have `current_class_ptr' wrapped in a
4609 NON_LVALUE_EXPR node. */
4610 if (arg
== current_class_ref
)
4611 return current_class_ptr
;
4613 arg
= TREE_OPERAND (arg
, 0);
4614 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4618 build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4619 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4621 else if (lvalue_p (arg
))
4622 /* Don't let this be an lvalue. */
4623 return non_lvalue (arg
);
4627 /* For &x[y], return x+y */
4628 if (TREE_CODE (arg
) == ARRAY_REF
)
4630 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4631 return error_mark_node
;
4632 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4633 TREE_OPERAND (arg
, 1), 1);
4636 /* Uninstantiated types are all functions. Taking the
4637 address of a function is a no-op, so just return the
4640 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4641 && IDENTIFIER_OPNAME_P (arg
))
4643 my_friendly_abort (117);
4644 /* We don't know the type yet, so just work around the problem.
4645 We know that this will resolve to an lvalue. */
4646 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4649 if (TREE_CODE (arg
) == OVERLOAD
4650 || (TREE_CODE (arg
) == OFFSET_REF
4651 && TREE_CODE (TREE_OPERAND (arg
, 1)) == TEMPLATE_ID_EXPR
))
4652 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4653 else if (TREE_CODE (arg
) == TREE_LIST
)
4655 if (TREE_CODE (TREE_VALUE (arg
)) == FUNCTION_DECL
)
4656 /* Unique overloaded non-member function. */
4657 return build_unary_op (ADDR_EXPR
, TREE_VALUE (arg
), 0);
4658 if (TREE_CHAIN (arg
) == NULL_TREE
4659 && TREE_CODE (TREE_VALUE (arg
)) == TREE_LIST
4660 && TREE_CODE (TREE_VALUE (TREE_VALUE (arg
))) != OVERLOAD
)
4661 /* Unique overloaded member function. */
4662 return build_unary_op (ADDR_EXPR
, TREE_VALUE (TREE_VALUE (arg
)),
4664 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4666 else if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
4671 /* We don't require a match here; it's possible that the
4672 context (like a cast to a particular type) will resolve
4673 the particular choice of template. */
4674 fn
= determine_specialization (arg
,
4682 fn
= instantiate_template (fn
, targs
);
4683 mark_addressable (fn
);
4684 return build_unary_op (ADDR_EXPR
, fn
, 0);
4687 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4690 /* Handle complex lvalues (when permitted)
4691 by reduction to simpler cases. */
4692 val
= unary_complex_lvalue (code
, arg
);
4696 switch (TREE_CODE (arg
))
4701 case FIX_TRUNC_EXPR
:
4702 case FIX_FLOOR_EXPR
:
4703 case FIX_ROUND_EXPR
:
4705 if (! lvalue_p (arg
) && pedantic
)
4706 pedwarn ("taking the address of a cast to non-reference type");
4713 /* Allow the address of a constructor if all the elements
4715 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (arg
)
4716 && TREE_CONSTANT (arg
))
4718 /* Anything not already handled and not a true memory reference
4720 else if (TREE_CODE (argtype
) != FUNCTION_TYPE
4721 && TREE_CODE (argtype
) != METHOD_TYPE
4722 && !lvalue_or_else (arg
, "unary `&'"))
4723 return error_mark_node
;
4725 argtype
= build_pointer_type (argtype
);
4727 if (mark_addressable (arg
) == 0)
4728 return error_mark_node
;
4733 if (TREE_CODE (arg
) == COMPONENT_REF
)
4734 addr
= build_component_addr
4736 "attempt to take address of bit-field structure member `%s'");
4738 addr
= build1 (code
, argtype
, arg
);
4740 /* Address of a static or external variable or
4741 function counts as a constant */
4743 TREE_CONSTANT (addr
) = 1;
4745 if (TREE_CODE (argtype
) == POINTER_TYPE
4746 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4748 build_ptrmemfunc_type (argtype
);
4749 addr
= build_ptrmemfunc (argtype
, addr
, 0);
4762 argtype
= TREE_TYPE (arg
);
4763 return fold (build1 (code
, argtype
, arg
));
4767 return error_mark_node
;
4771 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4772 convert ARG with the same conversions in the same order
4773 and return the result. */
4776 convert_sequence (conversions
, arg
)
4780 switch (TREE_CODE (conversions
))
4785 case FIX_TRUNC_EXPR
:
4786 case FIX_FLOOR_EXPR
:
4787 case FIX_ROUND_EXPR
:
4789 return cp_convert (TREE_TYPE (conversions
),
4790 convert_sequence (TREE_OPERAND (conversions
, 0),
4799 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4800 for certain kinds of expressions which are not really lvalues
4801 but which we can accept as lvalues.
4803 If ARG is not a kind of expression we can handle, return zero. */
4806 unary_complex_lvalue (code
, arg
)
4807 enum tree_code code
;
4810 /* Handle (a, b) used as an "lvalue". */
4811 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4813 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4814 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4815 TREE_OPERAND (arg
, 0), real_result
);
4818 /* Handle (a ? b : c) used as an "lvalue". */
4819 if (TREE_CODE (arg
) == COND_EXPR
4820 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4821 return rationalize_conditional_expr (code
, arg
);
4823 if (TREE_CODE (arg
) == MODIFY_EXPR
4824 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4825 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4826 return unary_complex_lvalue
4827 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4828 arg
, TREE_OPERAND (arg
, 0)));
4830 if (code
!= ADDR_EXPR
)
4833 /* Handle (a = b) used as an "lvalue" for `&'. */
4834 if (TREE_CODE (arg
) == MODIFY_EXPR
4835 || TREE_CODE (arg
) == INIT_EXPR
)
4837 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4838 arg
= build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4839 TREE_NO_UNUSED_WARNING (arg
) = 1;
4843 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4844 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4845 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4847 /* The representation of something of type OFFSET_TYPE
4848 is really the representation of a pointer to it.
4849 Here give the representation its true type. */
4852 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4854 if (TREE_CODE (arg
) != OFFSET_REF
)
4857 t
= TREE_OPERAND (arg
, 1);
4859 /* Check all this code for right semantics. */
4860 if (TREE_CODE (t
) == FUNCTION_DECL
)
4862 if (DECL_DESTRUCTOR_P (t
))
4863 cp_error ("taking address of destructor");
4864 return build_unary_op (ADDR_EXPR
, t
, 0);
4866 if (TREE_CODE (t
) == VAR_DECL
)
4867 return build_unary_op (ADDR_EXPR
, t
, 0);
4873 if (TREE_OPERAND (arg
, 0)
4874 && (TREE_CODE (TREE_OPERAND (arg
, 0)) != NOP_EXPR
4875 || (TREE_OPERAND (TREE_OPERAND (arg
, 0), 0)
4876 != error_mark_node
)))
4877 if (TREE_CODE (t
) != FIELD_DECL
)
4879 /* Don't know if this should return address to just
4880 _DECL, or actual address resolved in this expression. */
4881 sorry ("address of bound pointer-to-member expression");
4882 return error_mark_node
;
4885 /* Add in the offset to the field. */
4886 offset
= convert (sizetype
,
4887 size_binop (EASY_DIV_EXPR
,
4888 DECL_FIELD_BITPOS (t
),
4889 size_int (BITS_PER_UNIT
)));
4891 /* We offset all pointer to data members by 1 so that we can
4892 distinguish between a null pointer to data member and the first
4893 data member of a structure. */
4894 offset
= size_binop (PLUS_EXPR
, offset
, size_int (1));
4896 type
= build_offset_type (DECL_FIELD_CONTEXT (t
), TREE_TYPE (t
));
4897 type
= build_pointer_type (type
);
4899 return cp_convert (type
, offset
);
4904 /* We permit compiler to make function calls returning
4905 objects of aggregate type look like lvalues. */
4909 if (TREE_CODE (targ
) == SAVE_EXPR
)
4910 targ
= TREE_OPERAND (targ
, 0);
4912 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4914 if (TREE_CODE (arg
) == SAVE_EXPR
)
4917 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4918 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4921 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4922 return build (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4923 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4926 /* Don't let anything else be handled specially. */
4930 /* Mark EXP saying that we need to be able to take the
4931 address of it; it should not be allocated in a register.
4932 Value is 1 if successful.
4934 C++: we do not allow `current_class_ptr' to be addressable. */
4937 mark_addressable (exp
)
4940 register tree x
= exp
;
4942 if (TREE_ADDRESSABLE (x
) == 1)
4946 switch (TREE_CODE (x
))
4953 x
= TREE_OPERAND (x
, 0);
4957 if (x
== current_class_ptr
)
4959 if (! flag_this_is_variable
)
4960 error ("address of `this' not available");
4961 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4962 put_var_into_stack (x
);
4966 if (TREE_STATIC (x
) && TREE_READONLY (x
)
4967 && DECL_RTL (x
) != 0
4968 && ! DECL_IN_MEMORY_P (x
))
4970 /* We thought this would make a good constant variable,
4971 but we were wrong. */
4972 push_obstacks_nochange ();
4973 end_temporary_allocation ();
4975 TREE_ASM_WRITTEN (x
) = 0;
4977 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0,
4979 TREE_ADDRESSABLE (x
) = 1;
4985 /* Caller should not be trying to mark initialized
4986 constant fields addressable. */
4987 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4988 || DECL_IN_AGGR_P (x
) == 0
4990 || DECL_EXTERNAL (x
), 314);
4994 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4995 && !DECL_ARTIFICIAL (x
) && extra_warnings
)
4996 cp_warning ("address requested for `%D', which is declared `register'",
4998 put_var_into_stack (x
);
4999 TREE_ADDRESSABLE (x
) = 1;
5003 if (DECL_LANG_SPECIFIC (x
) != 0)
5005 x
= DECL_MAIN_VARIANT (x
);
5006 /* We have to test both conditions here. The first may be
5007 non-zero in the case of processing a default function. The
5008 second may be non-zero in the case of a template function. */
5009 if (DECL_TEMPLATE_INFO (x
) && !DECL_TEMPLATE_SPECIALIZATION (x
))
5012 TREE_ADDRESSABLE (x
) = 1;
5014 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
5018 TREE_ADDRESSABLE (x
) = 1;
5022 TREE_ADDRESSABLE (x
) = 1;
5023 mark_addressable (TREE_OPERAND (x
, 0));
5031 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
5034 build_x_conditional_expr (ifexp
, op1
, op2
)
5035 tree ifexp
, op1
, op2
;
5037 if (processing_template_decl
)
5038 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
5040 return build_new_op (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
5044 build_conditional_expr (ifexp
, op1
, op2
)
5045 tree ifexp
, op1
, op2
;
5047 register tree type1
;
5048 register tree type2
;
5049 register enum tree_code code1
;
5050 register enum tree_code code2
;
5051 register tree result_type
= NULL_TREE
;
5053 /* If second operand is omitted, it is the same as the first one;
5054 make sure it is calculated only once. */
5058 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
5059 ifexp
= op1
= save_expr (ifexp
);
5062 ifexp
= cp_convert (boolean_type_node
, ifexp
);
5064 if (TREE_CODE (ifexp
) == ERROR_MARK
)
5065 return error_mark_node
;
5067 op1
= require_instantiated_type (TREE_TYPE (op2
), op1
, error_mark_node
);
5068 if (op1
== error_mark_node
)
5069 return error_mark_node
;
5070 op2
= require_instantiated_type (TREE_TYPE (op1
), op2
, error_mark_node
);
5071 if (op2
== error_mark_node
)
5072 return error_mark_node
;
5074 /* C++: REFERENCE_TYPES must be dereferenced. */
5075 type1
= TREE_TYPE (op1
);
5076 code1
= TREE_CODE (type1
);
5077 type2
= TREE_TYPE (op2
);
5078 code2
= TREE_CODE (type2
);
5080 if (code1
== REFERENCE_TYPE
)
5082 op1
= convert_from_reference (op1
);
5083 type1
= TREE_TYPE (op1
);
5084 code1
= TREE_CODE (type1
);
5086 if (code2
== REFERENCE_TYPE
)
5088 op2
= convert_from_reference (op2
);
5089 type2
= TREE_TYPE (op2
);
5090 code2
= TREE_CODE (type2
);
5093 /* Don't promote the operands separately if they promote
5094 the same way. Return the unpromoted type and let the combined
5095 value get promoted if necessary. */
5097 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
5098 && code2
!= ARRAY_TYPE
5099 && code2
!= FUNCTION_TYPE
5100 && code2
!= METHOD_TYPE
)
5104 if (TREE_CONSTANT (ifexp
)
5105 && (TREE_CODE (ifexp
) == INTEGER_CST
5106 || TREE_CODE (ifexp
) == ADDR_EXPR
))
5107 return (integer_zerop (ifexp
) ? op2
: op1
);
5109 if (TREE_CODE (op1
) == CONST_DECL
)
5110 op1
= DECL_INITIAL (op1
);
5111 else if (TREE_READONLY_DECL_P (op1
))
5112 op1
= decl_constant_value (op1
);
5113 if (TREE_CODE (op2
) == CONST_DECL
)
5114 op2
= DECL_INITIAL (op2
);
5115 else if (TREE_READONLY_DECL_P (op2
))
5116 op2
= decl_constant_value (op2
);
5118 type1
= cp_build_type_variant
5120 TREE_READONLY (op1
) || TREE_READONLY (op2
),
5121 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
5122 /* ??? This is a kludge to deal with the fact that
5123 we don't sort out integers and enums properly, yet. */
5124 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
5125 if (TREE_TYPE (result
) != type1
)
5126 result
= build1 (NOP_EXPR
, type1
, result
);
5127 /* Expand both sides into the same slot,
5128 hopefully the target of the ?: expression. */
5129 if (TREE_CODE (op1
) == TARGET_EXPR
&& TREE_CODE (op2
) == TARGET_EXPR
)
5131 tree slot
= build (VAR_DECL
, TREE_TYPE (result
));
5132 layout_decl (slot
, 0);
5133 result
= build (TARGET_EXPR
, TREE_TYPE (result
),
5134 slot
, result
, NULL_TREE
, NULL_TREE
);
5139 /* They don't match; promote them both and then try to reconcile them.
5140 But don't permit mismatching enum types. */
5141 if (code1
== ENUMERAL_TYPE
)
5143 if (code2
== ENUMERAL_TYPE
)
5145 cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'",
5147 return error_mark_node
;
5149 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
)
5150 && type2
!= type_promotes_to (type1
))
5151 warning ("enumeral and non-enumeral type in conditional expression");
5153 else if (extra_warnings
5154 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
)
5155 && type1
!= type_promotes_to (type2
))
5156 warning ("enumeral and non-enumeral type in conditional expression");
5158 if (code1
!= VOID_TYPE
)
5160 op1
= default_conversion (op1
);
5161 type1
= TREE_TYPE (op1
);
5162 if (TYPE_PTRMEMFUNC_P (type1
))
5163 type1
= TYPE_PTRMEMFUNC_FN_TYPE (type1
);
5164 code1
= TREE_CODE (type1
);
5166 if (code2
!= VOID_TYPE
)
5168 op2
= default_conversion (op2
);
5169 type2
= TREE_TYPE (op2
);
5170 if (TYPE_PTRMEMFUNC_P (type2
))
5171 type2
= TYPE_PTRMEMFUNC_FN_TYPE (type2
);
5172 code2
= TREE_CODE (type2
);
5175 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
5176 && real_lvalue_p (op1
) && real_lvalue_p (op2
)
5177 && comptypes (type1
, type2
, -1))
5179 type1
= build_reference_type (type1
);
5180 type2
= build_reference_type (type2
);
5181 result_type
= common_type (type1
, type2
);
5182 op1
= convert_to_reference (result_type
, op1
, CONV_IMPLICIT
,
5183 LOOKUP_NORMAL
, NULL_TREE
);
5184 op2
= convert_to_reference (result_type
, op2
, CONV_IMPLICIT
,
5185 LOOKUP_NORMAL
, NULL_TREE
);
5187 /* Quickly detect the usual case where op1 and op2 have the same type
5189 else if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
5192 result_type
= type1
;
5194 result_type
= cp_build_type_variant
5196 TREE_READONLY (op1
) || TREE_READONLY (op2
),
5197 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
5199 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
5200 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
5202 result_type
= common_type (type1
, type2
);
5204 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
5206 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
5207 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
5208 result_type
= void_type_node
;
5210 else if (code1
== POINTER_TYPE
&& null_ptr_cst_p (op2
))
5211 result_type
= qualify_type (type1
, type2
);
5212 else if (code2
== POINTER_TYPE
&& null_ptr_cst_p (op1
))
5213 result_type
= qualify_type (type2
, type1
);
5214 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
5216 if (comp_target_types (type1
, type2
, 1))
5217 result_type
= common_type (type1
, type2
);
5218 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
5220 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
5221 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5222 result_type
= qualify_type (type1
, type2
);
5224 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
5226 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
5227 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5228 result_type
= qualify_type (type2
, type1
);
5231 else if (comptypes (type2
, type1
, 0))
5232 result_type
= type2
;
5233 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
5234 && IS_AGGR_TYPE (TREE_TYPE (type2
))
5235 && (result_type
= common_base_type (TREE_TYPE (type1
),
5236 TREE_TYPE (type2
))))
5238 if (result_type
== error_mark_node
)
5240 cp_error ("common base type of types `%T' and `%T' is ambiguous",
5241 TREE_TYPE (type1
), TREE_TYPE (type2
));
5242 result_type
= ptr_type_node
;
5247 && result_type
!= TREE_TYPE (type1
)
5248 && result_type
!= TREE_TYPE (type2
))
5249 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
5250 type1
, type2
, result_type
);
5252 result_type
= build_pointer_type (result_type
);
5257 pedwarn ("pointer type mismatch in conditional expression");
5258 result_type
= ptr_type_node
;
5261 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
5263 pedwarn ("pointer/integer type mismatch in conditional expression");
5264 result_type
= type1
;
5266 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5268 pedwarn ("pointer/integer type mismatch in conditional expression");
5269 result_type
= type2
;
5274 /* The match does not look good. If either is
5275 an aggregate value, try converting to a scalar type. */
5276 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
5278 cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'",
5280 return error_mark_node
;
5282 /* Warning: this code assumes that conversion between cv-variants of
5283 a type is done using NOP_EXPRs. */
5284 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
5286 /* There are other types besides pointers and records. */
5288 if (code2
== POINTER_TYPE
)
5289 tmp
= build_pointer_type
5290 (build_type_variant (TREE_TYPE (type2
), 1, 1));
5293 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op1
, 0);
5294 if (tmp
== NULL_TREE
)
5296 cp_error ("incompatible types `%T' and `%T' in `?:'",
5298 return error_mark_node
;
5300 if (tmp
== error_mark_node
)
5301 error ("ambiguous pointer conversion");
5304 result_type
= common_type (type2
, TREE_TYPE (tmp
));
5307 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
5310 if (code1
== POINTER_TYPE
)
5311 tmp
= build_pointer_type
5312 (build_type_variant (TREE_TYPE (type1
), 1, 1));
5316 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op2
, 0);
5317 if (tmp
== NULL_TREE
)
5319 cp_error ("incompatible types `%T' and `%T' in `?:'",
5321 return error_mark_node
;
5323 if (tmp
== error_mark_node
)
5324 error ("ambiguous pointer conversion");
5327 result_type
= common_type (type1
, TREE_TYPE (tmp
));
5330 else if (flag_cond_mismatch
)
5331 result_type
= void_type_node
;
5334 error ("type mismatch in conditional expression");
5335 return error_mark_node
;
5339 if (TREE_CODE (result_type
) == POINTER_TYPE
5340 && TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
5341 result_type
= build_ptrmemfunc_type (result_type
);
5343 if (result_type
!= TREE_TYPE (op1
))
5344 op1
= convert_for_initialization
5345 (NULL_TREE
, result_type
, op1
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5346 if (result_type
!= TREE_TYPE (op2
))
5347 op2
= convert_for_initialization
5348 (NULL_TREE
, result_type
, op2
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5350 if (TREE_CONSTANT (ifexp
))
5351 return integer_zerop (ifexp
) ? op2
: op1
;
5353 return convert_from_reference
5354 (fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
)));
5357 /* Handle overloading of the ',' operator when needed. Otherwise,
5358 this function just builds an expression list. */
5361 build_x_compound_expr (list
)
5364 tree rest
= TREE_CHAIN (list
);
5367 if (processing_template_decl
)
5368 return build_min_nt (COMPOUND_EXPR
, list
, NULL_TREE
);
5370 if (rest
== NULL_TREE
)
5371 return build_compound_expr (list
);
5373 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
5374 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
5376 return build_x_compound_expr (expr_tree_cons (NULL_TREE
, result
,
5377 TREE_CHAIN (rest
)));
5379 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
5381 /* the left-hand operand of a comma expression is like an expression
5382 statement: we should warn if it doesn't have any side-effects,
5383 unless it was explicitly cast to (void). */
5384 if ((extra_warnings
|| warn_unused
)
5385 && !(TREE_CODE (TREE_VALUE(list
)) == CONVERT_EXPR
5386 && TREE_TYPE (TREE_VALUE(list
)) == void_type_node
))
5387 warning("left-hand operand of comma expression has no effect");
5389 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
5390 else if (warn_unused
)
5391 warn_if_unused_value (TREE_VALUE(list
));
5394 return build_compound_expr
5395 (expr_tree_cons (NULL_TREE
, TREE_VALUE (list
),
5396 build_expr_list (NULL_TREE
,
5397 build_x_compound_expr (rest
))));
5400 /* Given a list of expressions, return a compound expression
5401 that performs them all and returns the value of the last of them. */
5404 build_compound_expr (list
)
5409 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
5410 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
5412 if (TREE_CHAIN (list
) == 0)
5414 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5415 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
5416 if (TREE_CODE (list
) == NOP_EXPR
5417 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
5418 list
= TREE_OPERAND (list
, 0);
5420 /* Convert arrays to pointers. */
5421 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
5422 return default_conversion (TREE_VALUE (list
));
5424 return TREE_VALUE (list
);
5427 rest
= build_compound_expr (TREE_CHAIN (list
));
5429 /* When pedantic, a compound expression cannot be a constant expression. */
5430 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
5433 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
5434 break_out_cleanups (TREE_VALUE (list
)), rest
);
5438 build_static_cast (type
, expr
)
5444 if (type
== error_mark_node
|| expr
== error_mark_node
)
5445 return error_mark_node
;
5447 if (TREE_CODE (expr
) == OFFSET_REF
)
5448 expr
= resolve_offset_ref (expr
);
5450 if (processing_template_decl
)
5452 tree t
= build_min (STATIC_CAST_EXPR
, copy_to_permanent (type
),
5457 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5458 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5459 if (TREE_CODE (type
) != REFERENCE_TYPE
5460 && TREE_CODE (expr
) == NOP_EXPR
5461 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5462 expr
= TREE_OPERAND (expr
, 0);
5464 if (TREE_CODE (type
) == VOID_TYPE
)
5465 return build1 (CONVERT_EXPR
, type
, expr
);
5467 if (type_unknown_p (expr
))
5469 expr
= instantiate_type (type
, expr
, 1);
5470 if (expr
== error_mark_node
)
5471 return error_mark_node
;
5474 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5475 return (convert_from_reference
5476 (convert_to_reference (type
, expr
, CONV_STATIC
|CONV_IMPLICIT
,
5477 LOOKUP_COMPLAIN
, NULL_TREE
)));
5479 if (IS_AGGR_TYPE (type
))
5480 return build_cplus_new
5481 (type
, (build_method_call
5482 (NULL_TREE
, ctor_identifier
, build_expr_list (NULL_TREE
, expr
),
5483 TYPE_BINFO (type
), LOOKUP_NORMAL
)));
5485 expr
= decay_conversion (expr
);
5486 intype
= TREE_TYPE (expr
);
5488 /* FIXME handle casting to array type. */
5491 if (can_convert_arg (type
, intype
, expr
))
5493 else if (TYPE_PTROB_P (type
) && TYPE_PTROB_P (intype
))
5496 if (IS_AGGR_TYPE (TREE_TYPE (type
)) && IS_AGGR_TYPE (TREE_TYPE (intype
))
5497 && (TYPE_READONLY (TREE_TYPE (type
))
5498 >= TYPE_READONLY (TREE_TYPE (intype
)))
5499 && (TYPE_VOLATILE (TREE_TYPE (type
))
5500 >= TYPE_VOLATILE (TREE_TYPE (intype
)))
5501 && (binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 0))
5502 && ! TREE_VIA_VIRTUAL (binfo
))
5505 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5507 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
))),
5508 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (intype
))), 1)
5509 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (type
)))
5510 >= TYPE_READONLY (TREE_TYPE (TREE_TYPE (intype
))))
5511 && (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (type
)))
5512 >= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (intype
))))
5513 && (binfo
= get_binfo (TYPE_OFFSET_BASETYPE (TREE_TYPE (type
)),
5514 TYPE_OFFSET_BASETYPE (TREE_TYPE (intype
)), 0))
5515 && ! TREE_VIA_VIRTUAL (binfo
))
5518 else if (TREE_CODE (intype
) != BOOLEAN_TYPE
5519 && TREE_CODE (type
) != ARRAY_TYPE
5520 && TREE_CODE (type
) != FUNCTION_TYPE
5521 && can_convert (intype
, type
))
5525 return build_c_cast (type
, expr
);
5527 cp_error ("static_cast from `%T' to `%T'", intype
, type
);
5528 return error_mark_node
;
5532 build_reinterpret_cast (type
, expr
)
5537 if (type
== error_mark_node
|| expr
== error_mark_node
)
5538 return error_mark_node
;
5540 if (TREE_CODE (expr
) == OFFSET_REF
)
5541 expr
= resolve_offset_ref (expr
);
5543 if (processing_template_decl
)
5545 tree t
= build_min (REINTERPRET_CAST_EXPR
,
5546 copy_to_permanent (type
), expr
);
5550 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5552 expr
= decay_conversion (expr
);
5554 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5555 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5556 if (TREE_CODE (expr
) == NOP_EXPR
5557 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5558 expr
= TREE_OPERAND (expr
, 0);
5561 if (type_unknown_p (expr
))
5563 expr
= instantiate_type (type
, expr
, 1);
5564 if (expr
== error_mark_node
)
5565 return error_mark_node
;
5568 intype
= TREE_TYPE (expr
);
5570 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5572 if (! real_lvalue_p (expr
))
5574 cp_error ("reinterpret_cast from `%T' rvalue to `%T'", intype
, type
);
5575 return error_mark_node
;
5577 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5578 if (expr
!= error_mark_node
)
5579 expr
= build_reinterpret_cast
5580 (build_pointer_type (TREE_TYPE (type
)), expr
);
5581 if (expr
!= error_mark_node
)
5582 expr
= build_indirect_ref (expr
, 0);
5585 else if (comptypes (TYPE_MAIN_VARIANT (intype
), TYPE_MAIN_VARIANT (type
), 1))
5586 return build_static_cast (type
, expr
);
5588 if (TYPE_PTR_P (type
) && (TREE_CODE (intype
) == INTEGER_TYPE
5589 || TREE_CODE (intype
) == ENUMERAL_TYPE
))
5591 else if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_PTR_P (intype
))
5593 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5594 cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5597 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5598 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5600 if (TREE_READONLY_DECL_P (expr
))
5601 expr
= decl_constant_value (expr
);
5602 return fold (build1 (NOP_EXPR
, type
, expr
));
5604 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5605 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5607 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type
), TREE_TYPE (intype
)))
5608 cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5611 if (TREE_READONLY_DECL_P (expr
))
5612 expr
= decl_constant_value (expr
);
5613 return fold (build1 (NOP_EXPR
, type
, expr
));
5615 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5616 || (TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
)))
5618 pedwarn ("ANSI C++ forbids casting between pointers to functions and objects");
5619 if (TREE_READONLY_DECL_P (expr
))
5620 expr
= decl_constant_value (expr
);
5621 return fold (build1 (NOP_EXPR
, type
, expr
));
5625 cp_error ("reinterpret_cast from `%T' to `%T'", intype
, type
);
5626 return error_mark_node
;
5629 return cp_convert (type
, expr
);
5633 build_const_cast (type
, expr
)
5638 if (type
== error_mark_node
|| expr
== error_mark_node
)
5639 return error_mark_node
;
5641 if (TREE_CODE (expr
) == OFFSET_REF
)
5642 expr
= resolve_offset_ref (expr
);
5644 if (processing_template_decl
)
5646 tree t
= build_min (CONST_CAST_EXPR
, copy_to_permanent (type
),
5651 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5653 expr
= decay_conversion (expr
);
5655 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5656 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5657 if (TREE_CODE (expr
) == NOP_EXPR
5658 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5659 expr
= TREE_OPERAND (expr
, 0);
5662 if (type_unknown_p (expr
))
5664 expr
= instantiate_type (type
, expr
, 1);
5665 if (expr
== error_mark_node
)
5666 return error_mark_node
;
5669 intype
= TREE_TYPE (expr
);
5671 if (comptypes (TYPE_MAIN_VARIANT (intype
), TYPE_MAIN_VARIANT (type
), 1))
5672 return build_static_cast (type
, expr
);
5673 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5675 if (! real_lvalue_p (expr
))
5677 cp_error ("const_cast from `%T' rvalue to `%T'", intype
, type
);
5678 return error_mark_node
;
5681 if (comp_ptr_ttypes_const (TREE_TYPE (type
), intype
))
5683 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5684 expr
= build1 (NOP_EXPR
, type
, expr
);
5685 return convert_from_reference (expr
);
5688 else if (TREE_CODE (type
) == POINTER_TYPE
5689 && TREE_CODE (intype
) == POINTER_TYPE
5690 && comp_ptr_ttypes_const (TREE_TYPE (type
), TREE_TYPE (intype
)))
5691 return cp_convert (type
, expr
);
5693 cp_error ("const_cast from `%T' to `%T'", intype
, type
);
5694 return error_mark_node
;
5697 /* Build an expression representing a cast to type TYPE of expression EXPR.
5699 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5700 when doing the cast. */
5703 build_c_cast (type
, expr
)
5706 register tree value
= expr
;
5708 if (type
== error_mark_node
|| expr
== error_mark_node
)
5709 return error_mark_node
;
5711 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5712 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5713 if (TREE_CODE (type
) != REFERENCE_TYPE
5714 && TREE_CODE (value
) == NOP_EXPR
5715 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5716 value
= TREE_OPERAND (value
, 0);
5718 if (TREE_TYPE (expr
)
5719 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
5720 && TREE_CODE (type
) != OFFSET_TYPE
)
5721 value
= resolve_offset_ref (value
);
5723 if (TREE_CODE (type
) == ARRAY_TYPE
)
5725 /* Allow casting from T1* to T2[] because Cfront allows it.
5726 NIHCL uses it. It is not valid ANSI C however, and hence, not
5728 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5731 pedwarn ("ANSI C++ forbids casting to an array type");
5732 type
= build_pointer_type (TREE_TYPE (type
));
5736 error ("ANSI C++ forbids casting to an array type");
5737 return error_mark_node
;
5741 if (TREE_CODE (type
) == FUNCTION_TYPE
5742 || TREE_CODE (type
) == METHOD_TYPE
)
5744 cp_error ("casting to function type `%T'", type
);
5745 return error_mark_node
;
5748 if (IS_SIGNATURE (type
))
5750 error ("cast specifies signature type");
5751 return error_mark_node
;
5754 if (processing_template_decl
)
5756 tree t
= build_min (CAST_EXPR
, type
,
5757 min_tree_cons (NULL_TREE
, value
, NULL_TREE
));
5761 if (TREE_CODE (type
) == VOID_TYPE
)
5762 value
= build1 (CONVERT_EXPR
, type
, value
);
5763 else if (TREE_TYPE (value
) == NULL_TREE
5764 || type_unknown_p (value
))
5766 value
= instantiate_type (type
, value
, 1);
5768 if (value
== error_mark_node
)
5769 return error_mark_node
;
5775 /* Convert functions and arrays to pointers and
5776 convert references to their expanded types,
5777 but don't convert any other types. If, however, we are
5778 casting to a class type, there's no reason to do this: the
5779 cast will only succeed if there is a converting constructor,
5780 and the default conversions will be done at that point. In
5781 fact, doing the default conversion here is actually harmful
5785 struct S { S(const A&); };
5787 since we don't want the array-to-pointer conversion done. */
5788 if (!IS_AGGR_TYPE (type
))
5790 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5791 || (TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
5792 /* Don't do the default conversion if we want a
5793 pointer to a function. */
5794 && ! (TREE_CODE (type
) == POINTER_TYPE
5795 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
5796 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5797 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5798 value
= default_conversion (value
);
5800 else if (TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5801 /* However, even for class types, we still need to strip away
5802 the reference type, since the call to convert_force below
5803 does not expect the input expression to be of reference
5805 value
= convert_from_reference (value
);
5807 otype
= TREE_TYPE (value
);
5809 /* Optionally warn about potentially worrisome casts. */
5812 && TREE_CODE (type
) == POINTER_TYPE
5813 && TREE_CODE (otype
) == POINTER_TYPE
)
5815 /* For C++ we make these regular warnings, rather than
5816 softening them into pedwarns. */
5817 if (TYPE_VOLATILE (TREE_TYPE (otype
))
5818 && ! TYPE_VOLATILE (TREE_TYPE (type
)))
5819 warning ("cast discards `volatile' from pointer target type");
5820 if (TYPE_READONLY (TREE_TYPE (otype
))
5821 && ! TYPE_READONLY (TREE_TYPE (type
)))
5822 warning ("cast discards `const' from pointer target type");
5825 /* Warn about possible alignment problems. */
5826 if (STRICT_ALIGNMENT
&& warn_cast_align
5827 && TREE_CODE (type
) == POINTER_TYPE
5828 && TREE_CODE (otype
) == POINTER_TYPE
5829 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5830 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5831 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5832 warning ("cast increases required alignment of target type");
5835 /* We should see about re-enabling these, they seem useful to
5837 if (TREE_CODE (type
) == INTEGER_TYPE
5838 && TREE_CODE (otype
) == POINTER_TYPE
5839 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5840 warning ("cast from pointer to integer of different size");
5842 if (TREE_CODE (type
) == POINTER_TYPE
5843 && TREE_CODE (otype
) == INTEGER_TYPE
5844 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5845 /* Don't warn about converting 0 to pointer,
5846 provided the 0 was explicit--not cast or made by folding. */
5847 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5848 warning ("cast to pointer from integer of different size");
5851 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5852 value
= (convert_from_reference
5853 (convert_to_reference (type
, value
, CONV_C_CAST
,
5854 LOOKUP_COMPLAIN
, NULL_TREE
)));
5859 if (TREE_READONLY_DECL_P (value
))
5860 value
= decl_constant_value (value
);
5863 value
= convert_force (type
, value
, CONV_C_CAST
);
5865 /* Ignore any integer overflow caused by the cast. */
5866 if (TREE_CODE (value
) == INTEGER_CST
)
5868 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5869 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5874 /* Always produce some operator for an explicit cast,
5875 so we can tell (for -pedantic) that the cast is no lvalue. */
5876 if (TREE_CODE (type
) != REFERENCE_TYPE
&& value
== expr
5877 && real_lvalue_p (value
))
5878 value
= non_lvalue (value
);
5883 /* Build an assignment expression of lvalue LHS from value RHS.
5884 MODIFYCODE is the code for a binary operator that we use
5885 to combine the old value of LHS with RHS to get the new value.
5886 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5888 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5891 build_modify_expr (lhs
, modifycode
, rhs
)
5893 enum tree_code modifycode
;
5896 register tree result
;
5898 tree lhstype
= TREE_TYPE (lhs
);
5899 tree olhstype
= lhstype
;
5902 /* Avoid duplicate error messages from operands that had errors. */
5903 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
5904 return error_mark_node
;
5906 /* Types that aren't fully specified cannot be used in assignments. */
5907 lhs
= require_complete_type (lhs
);
5911 /* Handle assignment to signature pointers/refs. */
5913 if (TYPE_LANG_SPECIFIC (lhstype
)
5914 && (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5916 return build_signature_pointer_constructor (lhs
, rhs
);
5919 /* Handle control structure constructs used as "lvalues". */
5921 switch (TREE_CODE (lhs
))
5923 /* Handle --foo = 5; as these are valid constructs in C++ */
5924 case PREDECREMENT_EXPR
:
5925 case PREINCREMENT_EXPR
:
5926 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5927 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5928 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5929 TREE_OPERAND (lhs
, 1));
5930 return build (COMPOUND_EXPR
, lhstype
,
5932 build_modify_expr (TREE_OPERAND (lhs
, 0),
5935 /* Handle (a, b) used as an "lvalue". */
5937 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5939 if (newrhs
== error_mark_node
)
5940 return error_mark_node
;
5941 return build (COMPOUND_EXPR
, lhstype
,
5942 TREE_OPERAND (lhs
, 0), newrhs
);
5945 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5946 if (newrhs
== error_mark_node
)
5947 return error_mark_node
;
5948 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5950 /* Handle (a ? b : c) used as an "lvalue". */
5952 rhs
= save_expr (rhs
);
5954 /* Produce (a ? (b = rhs) : (c = rhs))
5955 except that the RHS goes through a save-expr
5956 so the code to compute it is only emitted once. */
5958 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5959 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5961 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5963 if (cond
== error_mark_node
)
5965 /* Make sure the code to compute the rhs comes out
5966 before the split. */
5967 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5968 /* Case to void to suppress warning
5969 from warn_if_unused_value. */
5970 cp_convert (void_type_node
, rhs
), cond
);
5977 if (TREE_CODE (lhs
) == OFFSET_REF
)
5979 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5981 /* Static class member? */
5982 tree member
= TREE_OPERAND (lhs
, 1);
5983 if (TREE_CODE (member
) == VAR_DECL
)
5987 compiler_error ("invalid static class member");
5988 return error_mark_node
;
5992 lhs
= resolve_offset_ref (lhs
);
5994 olhstype
= lhstype
= TREE_TYPE (lhs
);
5997 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5998 && modifycode
!= INIT_EXPR
)
6000 lhs
= convert_from_reference (lhs
);
6001 olhstype
= lhstype
= TREE_TYPE (lhs
);
6004 /* If a binary op has been requested, combine the old LHS value with the RHS
6005 producing the value we should actually store into the LHS. */
6007 if (modifycode
== INIT_EXPR
)
6009 if (! IS_AGGR_TYPE (lhstype
))
6010 /* Do the default thing */;
6013 result
= build_method_call (lhs
, ctor_identifier
,
6014 build_expr_list (NULL_TREE
, rhs
),
6015 TYPE_BINFO (lhstype
), LOOKUP_NORMAL
);
6016 if (result
== NULL_TREE
)
6017 return error_mark_node
;
6021 else if (modifycode
== NOP_EXPR
)
6023 /* `operator=' is not an inheritable operator. */
6024 if (! IS_AGGR_TYPE (lhstype
))
6025 /* Do the default thing */;
6028 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
6029 lhs
, rhs
, make_node (NOP_EXPR
));
6030 if (result
== NULL_TREE
)
6031 return error_mark_node
;
6036 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
6038 my_friendly_abort (978652);
6042 lhs
= stabilize_reference (lhs
);
6043 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
6044 if (newrhs
== error_mark_node
)
6046 cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode
,
6047 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
6048 return error_mark_node
;
6052 /* Handle a cast used as an "lvalue".
6053 We have already performed any binary operator using the value as cast.
6054 Now convert the result to the cast type of the lhs,
6055 and then true type of the lhs and store it there;
6056 then convert result back to the cast type to be the value
6057 of the assignment. */
6059 switch (TREE_CODE (lhs
))
6064 case FIX_TRUNC_EXPR
:
6065 case FIX_FLOOR_EXPR
:
6066 case FIX_ROUND_EXPR
:
6068 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6069 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
6070 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
6071 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
6072 newrhs
= default_conversion (newrhs
);
6074 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
6077 /* WP 5.4.1: The result is an lvalue if T is a reference type,
6078 otherwise the result is an rvalue. */
6079 if (! lvalue_p (lhs
))
6080 pedwarn ("ANSI C++ forbids cast to non-reference type used as lvalue");
6082 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
6083 cp_convert (TREE_TYPE (inner_lhs
),
6084 cp_convert (lhstype
, newrhs
)));
6085 if (result
== error_mark_node
)
6087 return cp_convert (TREE_TYPE (lhs
), result
);
6094 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
6095 Reject anything strange now. */
6097 if (!lvalue_or_else (lhs
, "assignment"))
6098 return error_mark_node
;
6100 GNU_xref_assign (lhs
);
6102 /* Warn about storing in something that is `const'. */
6103 /* For C++, don't warn if this is initialization. */
6104 if (modifycode
!= INIT_EXPR
6105 /* For assignment to `const' signature pointer/reference fields,
6106 don't warn either, we already printed a better message before. */
6107 && ! (TREE_CODE (lhs
) == COMPONENT_REF
6108 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
6109 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
6110 && (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
6111 || ((TREE_CODE (lhstype
) == RECORD_TYPE
6112 || TREE_CODE (lhstype
) == UNION_TYPE
)
6113 && C_TYPE_FIELDS_READONLY (lhstype
))
6114 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
6115 && TYPE_READONLY (TREE_TYPE (lhstype
)))))
6116 readonly_error (lhs
, "assignment", 0);
6118 /* If storing into a structure or union member,
6119 it has probably been given type `int'.
6120 Compute the type that would go with
6121 the actual amount of storage the member occupies. */
6123 if (TREE_CODE (lhs
) == COMPONENT_REF
6124 && (TREE_CODE (lhstype
) == INTEGER_TYPE
6125 || TREE_CODE (lhstype
) == REAL_TYPE
6126 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
6128 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
6130 /* If storing in a field that is in actuality a short or narrower
6131 than one, we must store in the field in its actual type. */
6133 if (lhstype
!= TREE_TYPE (lhs
))
6135 lhs
= copy_node (lhs
);
6136 TREE_TYPE (lhs
) = lhstype
;
6140 /* check to see if there is an assignment to `this' */
6141 if (lhs
== current_class_ptr
)
6143 if (flag_this_is_variable
> 0
6144 && DECL_NAME (current_function_decl
) != NULL_TREE
6145 && (DECL_NAME (current_function_decl
)
6146 != constructor_name (current_class_type
)))
6147 warning ("assignment to `this' not in constructor or destructor");
6148 current_function_just_assigned_this
= 1;
6151 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
6152 when the type of RHS is not yet known, i.e. its type
6153 is inherited from LHS. */
6154 rhs
= require_instantiated_type (lhstype
, newrhs
, error_mark_node
);
6155 if (rhs
== error_mark_node
)
6156 return error_mark_node
;
6159 if (modifycode
!= INIT_EXPR
)
6161 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
6162 modifycode
= NOP_EXPR
;
6163 /* Reference-bashing */
6164 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
6166 tree tmp
= convert_from_reference (lhs
);
6167 lhstype
= TREE_TYPE (tmp
);
6168 if (TYPE_SIZE (lhstype
) == 0)
6170 incomplete_type_error (lhs
, lhstype
);
6171 return error_mark_node
;
6176 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
6178 tree tmp
= convert_from_reference (newrhs
);
6179 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
6181 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
6182 return error_mark_node
;
6188 if (TREE_SIDE_EFFECTS (lhs
))
6189 lhs
= stabilize_reference (lhs
);
6190 if (TREE_SIDE_EFFECTS (newrhs
))
6191 newrhs
= stabilize_reference (newrhs
);
6193 /* Convert new value to destination type. */
6195 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
6199 if (! comptypes (lhstype
, TREE_TYPE (rhs
), 0))
6201 cp_error ("incompatible types in assignment of `%T' to `%T'",
6202 TREE_TYPE (rhs
), lhstype
);
6203 return error_mark_node
;
6206 /* Allow array assignment in compiler-generated code. */
6207 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
6208 pedwarn ("ANSI C++ forbids assignment of arrays");
6210 /* Have to wrap this in RTL_EXPR for two cases:
6211 in base or member initialization and if we
6212 are a branch of a ?: operator. Since we
6213 can't easily know the latter, just do it always. */
6215 result
= make_node (RTL_EXPR
);
6217 TREE_TYPE (result
) = void_type_node
;
6218 do_pending_stack_adjust ();
6219 start_sequence_for_rtl_expr (result
);
6221 /* As a matter of principle, `start_sequence' should do this. */
6224 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6225 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6226 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
6229 do_pending_stack_adjust ();
6231 TREE_SIDE_EFFECTS (result
) = 1;
6232 RTL_EXPR_SEQUENCE (result
) = get_insns ();
6233 RTL_EXPR_RTL (result
) = const0_rtx
;
6238 if (modifycode
== INIT_EXPR
)
6240 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
6241 "assignment", NULL_TREE
, 0);
6242 if (lhs
== DECL_RESULT (current_function_decl
))
6244 if (DECL_INITIAL (lhs
))
6245 warning ("return value from function receives multiple initializations");
6246 DECL_INITIAL (lhs
) = newrhs
;
6251 /* Avoid warnings on enum bit fields. */
6252 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
6253 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
6255 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6257 newrhs
= convert_force (lhstype
, newrhs
, 0);
6260 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
6262 if (TREE_CODE (newrhs
) == CALL_EXPR
6263 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6264 newrhs
= build_cplus_new (lhstype
, newrhs
);
6266 /* Can't initialize directly from a TARGET_EXPR, since that would
6267 cause the lhs to be constructed twice, and possibly result in
6268 accidental self-initialization. So we force the TARGET_EXPR to be
6269 expanded without a target. */
6270 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6271 newrhs
= build (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
6272 TREE_OPERAND (newrhs
, 0));
6275 if (newrhs
== error_mark_node
)
6276 return error_mark_node
;
6278 if (TREE_CODE (newrhs
) == COND_EXPR
)
6281 tree cond
= TREE_OPERAND (newrhs
, 0);
6283 if (TREE_SIDE_EFFECTS (lhs
))
6284 cond
= build_compound_expr (tree_cons
6286 build_expr_list (NULL_TREE
, cond
)));
6288 /* Cannot have two identical lhs on this one tree (result) as preexpand
6289 calls will rip them out and fill in RTL for them, but when the
6290 rtl is generated, the calls will only be in the first side of the
6291 condition, not on both, or before the conditional jump! (mrs) */
6292 lhs1
= break_out_calls (lhs
);
6295 /* If there's no change, the COND_EXPR behaves like any other rhs. */
6296 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6297 lhstype
, lhs
, newrhs
);
6300 tree result_type
= TREE_TYPE (newrhs
);
6301 /* We have to convert each arm to the proper type because the
6302 types may have been munged by constant folding. */
6304 = build (COND_EXPR
, result_type
, cond
,
6305 build_modify_expr (lhs
, modifycode
,
6306 cp_convert (result_type
,
6307 TREE_OPERAND (newrhs
, 1))),
6308 build_modify_expr (lhs1
, modifycode
,
6309 cp_convert (result_type
,
6310 TREE_OPERAND (newrhs
, 2))));
6314 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6315 lhstype
, lhs
, newrhs
);
6317 TREE_SIDE_EFFECTS (result
) = 1;
6319 /* If we got the LHS in a different type for storing in,
6320 convert the result back to the nominal type of LHS
6321 so that the value we return always has the same type
6322 as the LHS argument. */
6324 if (olhstype
== TREE_TYPE (result
))
6326 /* Avoid warnings converting integral types back into enums
6327 for enum bit fields. */
6328 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
6329 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
6331 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
6332 TREE_NO_UNUSED_WARNING (result
) = 1;
6335 return convert_for_assignment (olhstype
, result
, "assignment",
6340 build_x_modify_expr (lhs
, modifycode
, rhs
)
6342 enum tree_code modifycode
;
6345 if (processing_template_decl
)
6346 return build_min_nt (MODOP_EXPR
, lhs
,
6347 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
6349 if (modifycode
!= NOP_EXPR
)
6351 tree rval
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
6352 make_node (modifycode
));
6356 return build_modify_expr (lhs
, modifycode
, rhs
);
6359 /* Return 0 if EXP is not a valid lvalue in this language
6360 even though `lvalue_or_else' would accept it. */
6363 language_lvalue_valid (exp
)
6364 tree exp ATTRIBUTE_UNUSED
;
6369 /* Get difference in deltas for different pointer to member function
6370 types. Return integer_zero_node, if FROM cannot be converted to a
6371 TO type. If FORCE is true, then allow reverse conversions as well. */
6374 get_delta_difference (from
, to
, force
)
6378 tree delta
= integer_zero_node
;
6384 /* Should get_base_distance here, so we can check if any thing along the
6385 path is virtual, and we need to make sure we stay
6386 inside the real binfos when going through virtual bases.
6387 Maybe we should replace virtual bases with
6388 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6389 binfo
= get_binfo (from
, to
, 1);
6390 if (binfo
== error_mark_node
)
6392 error (" in pointer to member function conversion");
6399 error_not_base_type (from
, to
);
6400 error (" in pointer to member conversion");
6403 binfo
= get_binfo (to
, from
, 1);
6404 if (binfo
== 0 || binfo
== error_mark_node
)
6406 if (TREE_VIA_VIRTUAL (binfo
))
6408 binfo
= binfo_member (BINFO_TYPE (binfo
),
6409 CLASSTYPE_VBASECLASSES (from
));
6410 cp_warning ("pointer to member cast to virtual base `%T'",
6411 BINFO_TYPE (binfo
));
6412 warning (" will only work if you are very careful");
6414 delta
= BINFO_OFFSET (binfo
);
6415 delta
= cp_convert (ptrdiff_type_node
, delta
);
6417 return build_binary_op (MINUS_EXPR
,
6422 if (TREE_VIA_VIRTUAL (binfo
))
6426 cp_warning ("pointer to member cast from virtual base `%T'",
6427 BINFO_TYPE (binfo
));
6428 warning (" will only work if you are very careful");
6431 cp_error ("pointer to member conversion from virtual base `%T'",
6432 BINFO_TYPE (binfo
));
6435 return BINFO_OFFSET (binfo
);
6439 build_ptrmemfunc1 (type
, delta
, idx
, pfn
, delta2
)
6440 tree type
, delta
, idx
, pfn
, delta2
;
6445 /* This is the old way we did it. We want to avoid calling
6446 digest_init, so that it can give an error if we use { } when
6447 initializing a pointer to member function. */
6451 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6452 expr_tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6456 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6457 expr_tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6460 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6461 expr_tree_cons (NULL_TREE
, delta
,
6462 expr_tree_cons (NULL_TREE
, idx
,
6463 expr_tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6465 return digest_init (type
, u
, (tree
*)0);
6467 tree delta_field
, idx_field
, pfn_or_delta2_field
, pfn_field
, delta2_field
;
6469 int allconstant
, allsimple
;
6471 delta_field
= TYPE_FIELDS (type
);
6472 idx_field
= TREE_CHAIN (delta_field
);
6473 pfn_or_delta2_field
= TREE_CHAIN (idx_field
);
6474 subtype
= TREE_TYPE (pfn_or_delta2_field
);
6475 pfn_field
= TYPE_FIELDS (subtype
);
6476 delta2_field
= TREE_CHAIN (pfn_field
);
6480 allconstant
= TREE_CONSTANT (pfn
);
6481 allsimple
= !! initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
));
6482 u
= expr_tree_cons (pfn_field
, pfn
, NULL_TREE
);
6486 delta2
= convert_and_check (delta_type_node
, delta2
);
6487 allconstant
= TREE_CONSTANT (delta2
);
6488 allsimple
= !! initializer_constant_valid_p (delta2
, TREE_TYPE (delta2
));
6489 u
= expr_tree_cons (delta2_field
, delta2
, NULL_TREE
);
6492 delta
= convert_and_check (delta_type_node
, delta
);
6493 idx
= convert_and_check (delta_type_node
, idx
);
6495 allconstant
= allconstant
&& TREE_CONSTANT (delta
) && TREE_CONSTANT (idx
);
6496 allsimple
= allsimple
6497 && initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
6498 && initializer_constant_valid_p (idx
, TREE_TYPE (idx
));
6500 u
= build (CONSTRUCTOR
, subtype
, NULL_TREE
, u
);
6501 u
= expr_tree_cons (delta_field
, delta
,
6502 expr_tree_cons (idx_field
, idx
,
6503 expr_tree_cons (pfn_or_delta2_field
, u
, NULL_TREE
)));
6504 u
= build (CONSTRUCTOR
, type
, NULL_TREE
, u
);
6505 TREE_CONSTANT (u
) = allconstant
;
6506 TREE_STATIC (u
) = allconstant
&& allsimple
;
6511 /* Build a constructor for a pointer to member function. It can be
6512 used to initialize global variables, local variable, or used
6513 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6516 If FORCE is non-zero, then force this conversion, even if
6517 we would rather not do it. Usually set when using an explicit
6520 Return error_mark_node, if something goes wrong. */
6523 build_ptrmemfunc (type
, pfn
, force
)
6527 tree idx
= integer_zero_node
;
6528 tree delta
= integer_zero_node
;
6529 tree delta2
= integer_zero_node
;
6531 tree npfn
= NULL_TREE
;
6533 /* Handle multiple conversions of pointer to member functions. */
6534 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6536 tree ndelta
, ndelta2
;
6540 /* Is is already the right type? */
6541 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6544 pfn_type
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
));
6546 && comp_target_types (type
, pfn_type
, 1) != 1)
6547 cp_error ("conversion to `%T' from `%T'", type
, pfn_type
);
6549 ndelta
= cp_convert (ptrdiff_type_node
, build_component_ref (pfn
, delta_identifier
, NULL_TREE
, 0));
6550 ndelta2
= cp_convert (ptrdiff_type_node
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6551 idx
= build_component_ref (pfn
, index_identifier
, NULL_TREE
, 0);
6553 n
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (pfn_type
)),
6554 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6557 delta
= build_binary_op (PLUS_EXPR
, ndelta
, n
, 1);
6558 delta2
= build_binary_op (PLUS_EXPR
, ndelta2
, n
, 1);
6559 e1
= fold (build (GT_EXPR
, boolean_type_node
, idx
, integer_zero_node
));
6561 e2
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
,
6564 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6565 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6566 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6568 e3
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
,
6570 return build_conditional_expr (e1
, e2
, e3
);
6573 /* Handle null pointer to member function conversions. */
6574 if (integer_zerop (pfn
))
6576 pfn
= build_c_cast (type
, integer_zero_node
);
6577 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
),
6578 integer_zero_node
, integer_zero_node
,
6582 if (TREE_CODE (pfn
) == TREE_LIST
6583 || (TREE_CODE (pfn
) == ADDR_EXPR
6584 && TREE_CODE (TREE_OPERAND (pfn
, 0)) == TREE_LIST
))
6585 return instantiate_type (type
, pfn
, 1);
6588 && comp_target_types (type
, TREE_TYPE (pfn
), 0) != 1)
6589 cp_error ("conversion to `%T' from `%T'", type
, TREE_TYPE (pfn
));
6591 /* Allow pointer to member conversions here. */
6592 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6593 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6595 delta2
= build_binary_op (PLUS_EXPR
, delta2
, delta
, 1);
6597 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6598 warning ("assuming pointer to member function is non-virtual");
6600 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6601 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6603 /* Find the offset to the vfield pointer in the object. */
6604 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6605 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6607 vfield_offset
= get_vfield_offset (vfield_offset
);
6608 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6610 /* Map everything down one to make room for the null pointer to member. */
6611 idx
= size_binop (PLUS_EXPR
,
6612 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6617 idx
= size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
6619 if (type
== TREE_TYPE (pfn
))
6625 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6626 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6630 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
, delta2
);
6633 /* Convert value RHS to type TYPE as preparation for an assignment
6634 to an lvalue of type TYPE.
6635 The real work of conversion is done by `convert'.
6636 The purpose of this function is to generate error messages
6637 for assignments that are not allowed in C.
6638 ERRTYPE is a string to use in error messages:
6639 "assignment", "return", etc.
6641 C++: attempts to allow `convert' to find conversions involving
6642 implicit type conversion between aggregate and scalar types
6643 as per 8.5.6 of C++ manual. Does not randomly dereference
6644 pointers to aggregates! */
6647 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6653 register enum tree_code codel
= TREE_CODE (type
);
6654 register tree rhstype
;
6655 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6657 /* Issue warnings about peculiar, but legal, uses of NULL. */
6658 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
6659 cp_warning ("converting NULL to non-pointer type");
6661 if (coder
== UNKNOWN_TYPE
)
6662 rhs
= instantiate_type (type
, rhs
, 1);
6664 if (coder
== ERROR_MARK
)
6665 return error_mark_node
;
6667 if (codel
== OFFSET_TYPE
)
6669 type
= TREE_TYPE (type
);
6670 codel
= TREE_CODE (type
);
6673 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6674 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6675 rhs
= TREE_OPERAND (rhs
, 0);
6677 if (rhs
== error_mark_node
)
6678 return error_mark_node
;
6680 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6681 return error_mark_node
;
6683 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6685 rhs
= resolve_offset_ref (rhs
);
6686 if (rhs
== error_mark_node
)
6687 return error_mark_node
;
6688 rhstype
= TREE_TYPE (rhs
);
6689 coder
= TREE_CODE (rhstype
);
6692 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6693 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6694 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6695 rhs
= default_conversion (rhs
);
6696 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6697 rhs
= convert_from_reference (rhs
);
6699 rhstype
= TREE_TYPE (rhs
);
6700 coder
= TREE_CODE (rhstype
);
6702 /* This should no longer change types on us. */
6703 if (TREE_CODE (rhs
) == CONST_DECL
)
6704 rhs
= DECL_INITIAL (rhs
);
6705 else if (TREE_READONLY_DECL_P (rhs
))
6706 rhs
= decl_constant_value (rhs
);
6708 if (comptypes (type
, rhstype
, 1))
6710 overflow_warning (rhs
);
6714 if (coder
== VOID_TYPE
)
6716 error ("void value not ignored as it ought to be");
6717 return error_mark_node
;
6719 /* Arithmetic types all interconvert. */
6720 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
6721 || codel
== COMPLEX_TYPE
)
6722 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
6723 || coder
== COMPLEX_TYPE
))
6725 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6726 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6729 cp_warning ("`%T' used for argument %P of `%D'",
6730 rhstype
, parmnum
, fndecl
);
6732 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6734 /* And we should warn if assigning a negative value to
6735 an unsigned variable. */
6736 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6738 if (TREE_CODE (rhs
) == INTEGER_CST
6739 && TREE_NEGATED_INT (rhs
))
6742 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6743 rhs
, parmnum
, fndecl
);
6745 cp_warning ("%s of negative value `%E' to `%T'",
6746 errtype
, rhs
, type
);
6748 overflow_warning (rhs
);
6749 if (TREE_CONSTANT (rhs
))
6753 return convert_and_check (type
, rhs
);
6755 /* Conversions involving enums. */
6756 else if ((codel
== ENUMERAL_TYPE
6757 && (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
))
6758 || (coder
== ENUMERAL_TYPE
6759 && (INTEGRAL_CODE_P (codel
) || codel
== REAL_TYPE
)))
6761 return ocp_convert (type
, rhs
, CONV_IMPLICIT
, LOOKUP_NORMAL
);
6763 /* Conversions among pointers */
6764 else if (codel
== POINTER_TYPE
6765 && (coder
== POINTER_TYPE
6766 || (coder
== RECORD_TYPE
6767 && (IS_SIGNATURE_POINTER (rhstype
)
6768 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6770 register tree ttl
= TREE_TYPE (type
);
6774 if (coder
== RECORD_TYPE
)
6776 rhs
= build_optr_ref (rhs
);
6777 rhstype
= TREE_TYPE (rhs
);
6779 ttr
= TREE_TYPE (rhstype
);
6781 /* If both pointers are of aggregate type, then we
6782 can give better error messages, and save some work
6784 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6788 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6789 || type
== class_star_type_node
6790 || rhstype
== class_star_type_node
)
6791 binfo
= TYPE_BINFO (ttl
);
6793 binfo
= get_binfo (ttl
, ttr
, 1);
6795 if (binfo
== error_mark_node
)
6796 return error_mark_node
;
6798 return error_not_base_type (ttl
, ttr
);
6800 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6803 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6804 rhstype
, parmnum
, fndecl
);
6806 cp_pedwarn ("%s to `%T' from `%T' discards const",
6807 errtype
, type
, rhstype
);
6809 if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6812 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6813 rhstype
, parmnum
, fndecl
);
6815 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6816 errtype
, type
, rhstype
);
6820 /* Any non-function converts to a [const][volatile] void *
6821 and vice versa; otherwise, targets must be the same.
6822 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6823 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6824 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6825 || (ctt
= comp_target_types (type
, rhstype
, 1))
6826 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6827 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6829 /* ARM $4.8, commentary on p39. */
6830 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6831 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6833 cp_error ("no standard conversion from `%T' to `void *'", ttr
);
6834 return error_mark_node
;
6837 if (ctt
< 0 && TYPE_MAIN_VARIANT (ttl
) != TYPE_MAIN_VARIANT (ttr
))
6838 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6841 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6842 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6843 && ! null_ptr_cst_p (rhs
))
6845 if (coder
== RECORD_TYPE
)
6846 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6849 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6852 /* Const and volatile mean something different for function types,
6853 so the usual warnings are not appropriate. */
6854 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6855 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6857 if (TREE_CODE (ttl
) == OFFSET_TYPE
6858 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6859 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6861 error ("%s between pointer to members converting across virtual baseclasses", errtype
);
6862 return error_mark_node
;
6864 else if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6866 if (string_conv_p (type
, rhs
, 1))
6867 /* converting from string constant to char *, OK. */;
6869 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6870 rhstype
, parmnum
, fndecl
);
6872 cp_pedwarn ("%s to `%T' from `%T' discards const",
6873 errtype
, type
, rhstype
);
6875 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6878 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6879 rhstype
, parmnum
, fndecl
);
6881 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6882 errtype
, type
, rhstype
);
6884 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6885 && ! comp_target_types (type
, rhstype
, 1))
6888 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6889 rhstype
, parmnum
, fndecl
);
6891 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6892 errtype
, type
, rhstype
);
6898 int add_quals
= 0, const_parity
= 0, volatile_parity
= 0;
6900 int unsigned_parity
;
6903 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6904 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6907 const_parity
|= (TYPE_READONLY (ttl
) < TYPE_READONLY (ttr
));
6908 volatile_parity
|= (TYPE_VOLATILE (ttl
) < TYPE_VOLATILE (ttr
));
6911 && (TYPE_READONLY (ttl
) > TYPE_READONLY (ttr
)
6912 || TYPE_VOLATILE (ttl
) > TYPE_VOLATILE (ttr
)))
6914 left_const
&= TYPE_READONLY (ttl
);
6916 if (TREE_CODE (ttl
) != POINTER_TYPE
6917 || TREE_CODE (ttr
) != POINTER_TYPE
)
6920 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6921 if (unsigned_parity
)
6923 if (TREE_UNSIGNED (ttl
))
6924 ttr
= unsigned_type (ttr
);
6926 ttl
= unsigned_type (ttl
);
6929 if (comp_target_types (ttl
, ttr
, nptrs
) > 0)
6934 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6935 rhstype
, parmnum
, fndecl
);
6937 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6938 errtype
, type
, rhstype
);
6943 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6944 rhstype
, parmnum
, fndecl
);
6946 cp_pedwarn ("%s to `%T' from `%T' discards const",
6947 errtype
, type
, rhstype
);
6949 if (volatile_parity
)
6952 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6953 rhstype
, parmnum
, fndecl
);
6955 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6956 errtype
, type
, rhstype
);
6958 if (unsigned_parity
> 0)
6961 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6962 rhstype
, parmnum
, fndecl
);
6964 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6965 errtype
, type
, rhstype
);
6967 else if (unsigned_parity
< 0)
6970 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6971 rhstype
, parmnum
, fndecl
);
6973 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6974 errtype
, type
, rhstype
);
6977 /* C++ is not so friendly about converting function and
6978 member function pointers as C. Emit warnings here. */
6979 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6980 || TREE_CODE (ttl
) == METHOD_TYPE
)
6981 if (! comptypes (ttl
, ttr
, 0))
6983 warning ("conflicting function types in %s:", errtype
);
6984 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6990 cp_error ("passing `%T' as argument %P of `%D'",
6991 rhstype
, parmnum
, fndecl
);
6993 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6994 return error_mark_node
;
6997 return cp_convert (type
, rhs
);
6999 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
7001 /* An explicit constant 0 can convert to a pointer,
7002 but not a 0 that results from casting or folding. */
7003 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
7006 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
7007 rhstype
, parmnum
, fndecl
);
7009 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
7010 errtype
, type
, rhstype
);
7012 return cp_convert (type
, rhs
);
7014 else if (codel
== INTEGER_TYPE
7015 && (coder
== POINTER_TYPE
7016 || (coder
== RECORD_TYPE
7017 && (IS_SIGNATURE_POINTER (rhstype
)
7018 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
7019 || IS_SIGNATURE_REFERENCE (rhstype
)))))
7022 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
7023 rhstype
, parmnum
, fndecl
);
7025 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
7026 errtype
, type
, rhstype
);
7027 return cp_convert (type
, rhs
);
7029 else if (codel
== BOOLEAN_TYPE
7030 && (coder
== POINTER_TYPE
7031 || (coder
== RECORD_TYPE
7032 && (IS_SIGNATURE_POINTER (rhstype
)
7033 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
7034 || IS_SIGNATURE_REFERENCE (rhstype
)))))
7035 return cp_convert (type
, rhs
);
7038 else if (((coder
== POINTER_TYPE
7039 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
7040 || integer_zerop (rhs
)
7041 || TYPE_PTRMEMFUNC_P (rhstype
))
7042 && TYPE_PTRMEMFUNC_P (type
))
7044 tree ttl
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
7045 tree ttr
= (TYPE_PTRMEMFUNC_P (rhstype
)
7046 ? TYPE_PTRMEMFUNC_FN_TYPE (rhstype
)
7048 int ctt
= (TREE_CODE (rhstype
) == INTEGER_TYPE
? 1
7049 : comp_target_types (ttl
, ttr
, 1));
7052 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
7055 cp_error ("%s to `%T' from `%T'", errtype
, ttl
, ttr
);
7057 /* compatible pointer to member functions. */
7058 return build_ptrmemfunc (ttl
, rhs
, 0);
7060 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
7061 return error_mark_node
;
7063 /* This should no longer happen. References are initialized via
7064 `convert_for_initialization'. They should otherwise be
7065 bashed before coming here. */
7066 else if (codel
== REFERENCE_TYPE
)
7067 my_friendly_abort (317);
7068 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
7070 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
7071 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
7074 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
7075 return cp_convert (type
, rhs
);
7076 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
7077 else if (TREE_CODE (type
) == POINTER_TYPE
7078 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
7079 || TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
7081 && TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
7082 return cp_convert (type
, rhs
);
7084 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
7085 return error_mark_node
;
7088 /* Convert RHS to be of type TYPE.
7089 If EXP is non-zero, it is the target of the initialization.
7090 ERRTYPE is a string to use in error messages.
7092 Two major differences between the behavior of
7093 `convert_for_assignment' and `convert_for_initialization'
7094 are that references are bashed in the former, while
7095 copied in the latter, and aggregates are assigned in
7096 the former (operator=) while initialized in the
7099 If using constructor make sure no conversion operator exists, if one does
7100 exist, an ambiguity exists.
7102 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
7105 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
7106 tree exp
, type
, rhs
;
7112 register enum tree_code codel
= TREE_CODE (type
);
7113 register tree rhstype
;
7114 register enum tree_code coder
;
7116 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
7117 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
7118 if (TREE_CODE (rhs
) == NOP_EXPR
7119 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
7120 && codel
!= REFERENCE_TYPE
)
7121 rhs
= TREE_OPERAND (rhs
, 0);
7123 if (rhs
== error_mark_node
7124 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
7125 return error_mark_node
;
7127 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
7129 rhs
= resolve_offset_ref (rhs
);
7130 if (rhs
== error_mark_node
)
7131 return error_mark_node
;
7134 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
7135 rhs
= convert_from_reference (rhs
);
7137 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
7138 && TREE_CODE (type
) != ARRAY_TYPE
7139 && (TREE_CODE (type
) != REFERENCE_TYPE
7140 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
7141 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
7142 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
7143 rhs
= default_conversion (rhs
);
7145 rhstype
= TREE_TYPE (rhs
);
7146 coder
= TREE_CODE (rhstype
);
7148 if (coder
== UNKNOWN_TYPE
)
7150 rhs
= instantiate_type (type
, rhs
, 1);
7151 rhstype
= TREE_TYPE (rhs
);
7152 coder
= TREE_CODE (rhstype
);
7155 if (coder
== ERROR_MARK
)
7156 return error_mark_node
;
7158 /* We accept references to incomplete types, so we can
7159 return here before checking if RHS is of complete type. */
7161 if (codel
== REFERENCE_TYPE
)
7163 /* This should eventually happen in convert_arguments. */
7164 extern int warningcount
, errorcount
;
7165 int savew
= 0, savee
= 0;
7168 savew
= warningcount
, savee
= errorcount
;
7169 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
7170 exp
? exp
: error_mark_node
);
7173 if (warningcount
> savew
)
7174 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
7175 else if (errorcount
> savee
)
7176 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
7181 rhs
= require_complete_type (rhs
);
7182 if (rhs
== error_mark_node
)
7183 return error_mark_node
;
7185 if (exp
!= 0) exp
= require_complete_type (exp
);
7186 if (exp
== error_mark_node
)
7187 return error_mark_node
;
7189 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
7190 rhstype
= TREE_TYPE (rhstype
);
7192 type
= complete_type (type
);
7194 if (TYPE_LANG_SPECIFIC (type
)
7195 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
7196 return build_signature_pointer_constructor (type
, rhs
);
7198 if (IS_AGGR_TYPE (type
))
7199 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
7201 if (type
== TREE_TYPE (rhs
))
7203 /* Issue warnings about peculiar, but legal, uses of NULL. We
7204 do this *before* the call to decl_constant_value so as to
7205 avoid duplicate warnings on code like `const int I = NULL;
7207 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
7208 cp_warning ("converting NULL to non-pointer type");
7210 if (TREE_READONLY_DECL_P (rhs
))
7211 rhs
= decl_constant_value (rhs
);
7216 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
7219 /* Expand an ASM statement with operands, handling output operands
7220 that are not variables or INDIRECT_REFS by transforming such
7221 cases into cases that expand_asm_operands can handle.
7223 Arguments are same as for expand_asm_operands.
7225 We don't do default conversions on all inputs, because it can screw
7226 up operands that are expected to be in memory. */
7229 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
7230 tree string
, outputs
, inputs
, clobbers
;
7235 int noutputs
= list_length (outputs
);
7237 /* o[I] is the place that output number I should be written. */
7238 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
7241 /* Record the contents of OUTPUTS before it is modified. */
7242 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7243 o
[i
] = TREE_VALUE (tail
);
7245 /* Generate the ASM_OPERANDS insn;
7246 store into the TREE_VALUEs of OUTPUTS some trees for
7247 where the values were actually stored. */
7248 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
7250 /* Copy all the intermediate outputs into the specified outputs. */
7251 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7253 if (o
[i
] != TREE_VALUE (tail
))
7255 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
7256 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
7259 /* Detect modification of read-only values.
7260 (Otherwise done by build_modify_expr.) */
7263 tree type
= TREE_TYPE (o
[i
]);
7264 if (TYPE_READONLY (type
)
7265 || ((TREE_CODE (type
) == RECORD_TYPE
7266 || TREE_CODE (type
) == UNION_TYPE
)
7267 && C_TYPE_FIELDS_READONLY (type
)))
7268 readonly_error (o
[i
], "modification by `asm'", 1);
7272 /* Those MODIFY_EXPRs could do autoincrements. */
7276 /* Expand a C `return' statement.
7277 RETVAL is the expression for what to return,
7278 or a null pointer for `return;' with no value.
7280 C++: upon seeing a `return', we must call destructors on all
7281 variables in scope which had constructors called on them.
7282 This means that if in a destructor, the base class destructors
7283 must be called before returning.
7285 The RETURN statement in C++ has initialization semantics. */
7288 c_expand_return (retval
)
7291 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
7292 extern tree dtor_label
, ctor_label
;
7293 tree result
= DECL_RESULT (current_function_decl
);
7294 tree valtype
= TREE_TYPE (result
);
7296 if (TREE_THIS_VOLATILE (current_function_decl
))
7297 warning ("function declared `noreturn' has a `return' statement");
7299 if (retval
== error_mark_node
)
7301 current_function_returns_null
= 1;
7305 if (processing_template_decl
)
7307 add_tree (build_min_nt (RETURN_STMT
, retval
));
7314 error ("returning a value from a destructor");
7316 /* Can't just return from a destructor. */
7317 expand_goto (dtor_label
);
7321 if (retval
== NULL_TREE
)
7323 /* A non-named return value does not count. */
7325 if (DECL_CONSTRUCTOR_P (current_function_decl
))
7326 retval
= current_class_ptr
;
7327 else if (DECL_NAME (result
) != NULL_TREE
7328 && TREE_CODE (valtype
) != VOID_TYPE
)
7332 current_function_returns_null
= 1;
7334 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
7336 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
7338 pedwarn ("`return' with no value, in function returning non-void");
7339 /* Clear this, so finish_function won't say that we
7340 reach the end of a non-void function (which we don't,
7341 we gave a return!). */
7342 current_function_returns_null
= 0;
7346 expand_null_return ();
7350 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
7352 if (flag_this_is_variable
)
7353 error ("return from a constructor: use `this = ...' instead");
7355 error ("returning a value from a constructor");
7356 retval
= current_class_ptr
;
7359 /* Effective C++ rule 15. See also start_function. */
7361 && DECL_NAME (current_function_decl
) == ansi_opname
[(int) MODIFY_EXPR
]
7362 && retval
!= current_class_ref
)
7363 cp_warning ("`operator=' should return a reference to `*this'");
7365 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
7367 current_function_returns_null
= 1;
7368 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
7369 pedwarn ("`return' with a value, in function returning void");
7370 expand_return (retval
);
7374 /* Now deal with possible C++ hair:
7375 (1) Compute the return value.
7376 (2) If there are aggregate values with destructors which
7377 must be cleaned up, clean them (taking care
7378 not to clobber the return value).
7379 (3) If an X(X&) constructor is defined, the return
7380 value must be returned via that. */
7382 if (retval
== result
7383 || DECL_CONSTRUCTOR_P (current_function_decl
))
7384 /* It's already done for us. */;
7385 else if (TREE_TYPE (retval
) == void_type_node
)
7387 pedwarn ("return of void value in function returning non-void");
7388 expand_expr_stmt (retval
);
7393 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7395 /* First convert the value to the function's return type, then
7396 to the type of return value's location to handle the
7397 case that functype is thiner than the valtype. */
7399 retval
= convert_for_initialization
7400 (NULL_TREE
, functype
, retval
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
7401 "return", NULL_TREE
, 0);
7403 retval
= convert (valtype
, retval
);
7405 if (retval
== error_mark_node
)
7407 /* Avoid warning about control reaching end of function. */
7408 expand_null_return ();
7412 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7413 else if (! current_function_returns_struct
7414 && TREE_CODE (retval
) == TARGET_EXPR
7415 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
7416 retval
= build (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
7417 TREE_OPERAND (retval
, 0));
7419 /* Add some useful error checking for C++. */
7420 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
7422 tree whats_returned
;
7424 /* Sort through common things to see what it is
7425 we are returning. */
7426 whats_returned
= retval
;
7427 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
7429 whats_returned
= TREE_OPERAND (whats_returned
, 1);
7430 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7431 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7433 while (TREE_CODE (whats_returned
) == CONVERT_EXPR
7434 || TREE_CODE (whats_returned
) == NOP_EXPR
)
7435 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7436 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7438 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7439 while (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
7440 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
7442 /* Get the target. */
7443 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7444 warning ("returning reference to temporary");
7448 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
7450 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
7451 warning ("reference to non-lvalue returned");
7452 else if (TREE_CODE (TREE_TYPE (whats_returned
)) != REFERENCE_TYPE
7453 && ! TREE_STATIC (whats_returned
)
7454 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7455 && !TREE_PUBLIC (whats_returned
))
7456 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7459 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7461 tree whats_returned
= TREE_OPERAND (retval
, 0);
7463 if (TREE_CODE (whats_returned
) == VAR_DECL
7464 && DECL_NAME (whats_returned
)
7465 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7466 && !TREE_STATIC (whats_returned
)
7467 && !TREE_PUBLIC (whats_returned
))
7468 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7472 if (retval
!= NULL_TREE
7473 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7474 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7475 current_function_return_value
= retval
;
7477 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7479 /* Here RETVAL is CURRENT_CLASS_PTR, so there's nothing to do. */
7480 expand_goto (ctor_label
);
7483 if (retval
&& retval
!= result
)
7485 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7486 TREE_SIDE_EFFECTS (result
) = 1;
7489 expand_start_target_temps ();
7491 expand_return (result
);
7493 expand_end_target_temps ();
7495 current_function_returns_value
= 1;
7498 /* Start a C switch statement, testing expression EXP.
7499 Return EXP if it is valid, an error node otherwise. */
7502 c_expand_start_case (exp
)
7506 register enum tree_code code
;
7508 /* Convert from references, etc. */
7509 exp
= default_conversion (exp
);
7510 type
= TREE_TYPE (exp
);
7511 code
= TREE_CODE (type
);
7513 if (IS_AGGR_TYPE_CODE (code
))
7514 exp
= build_type_conversion (CONVERT_EXPR
, integer_type_node
, exp
, 1);
7516 if (exp
== NULL_TREE
)
7518 error ("switch quantity not an integer");
7519 exp
= error_mark_node
;
7521 type
= TREE_TYPE (exp
);
7522 code
= TREE_CODE (type
);
7524 if (code
!= INTEGER_TYPE
&& code
!= ENUMERAL_TYPE
&& code
!= ERROR_MARK
)
7526 error ("switch quantity not an integer");
7527 exp
= error_mark_node
;
7533 exp
= default_conversion (exp
);
7534 type
= TREE_TYPE (exp
);
7535 idx
= get_unwidened (exp
, 0);
7536 /* We can't strip a conversion from a signed type to an unsigned,
7537 because if we did, int_fits_type_p would do the wrong thing
7538 when checking case values for being in range,
7539 and it's too hard to do the right thing. */
7540 if (TREE_UNSIGNED (TREE_TYPE (exp
))
7541 == TREE_UNSIGNED (TREE_TYPE (idx
)))
7546 (1, fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
)),
7547 type
, "switch statement");
7552 /* Returns non-zero if the pointer-type FROM can be converted to the
7553 pointer-type TO via a qualification conversion. If CONSTP is -1,
7554 then we return non-zero if the pointers are similar, and the
7555 cv-qualification signature of FROM is a proper subset of that of TO.
7557 If CONSTP is positive, then all outer pointers have been
7561 comp_ptr_ttypes_real (to
, from
, constp
)
7565 int to_more_cv_qualified
= 0;
7567 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7569 if (TREE_CODE (to
) != TREE_CODE (from
))
7572 if (TREE_CODE (from
) == OFFSET_TYPE
7573 && comptypes (TYPE_OFFSET_BASETYPE (from
),
7574 TYPE_OFFSET_BASETYPE (to
), 1))
7577 /* Const and volatile mean something different for function types,
7578 so the usual checks are not appropriate. */
7579 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7581 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7582 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7585 if (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7586 || TYPE_VOLATILE (to
) > TYPE_VOLATILE (from
))
7591 ++to_more_cv_qualified
;
7595 constp
&= TYPE_READONLY (to
);
7598 if (TREE_CODE (to
) != POINTER_TYPE
)
7600 comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1)
7601 && (constp
>= 0 || to_more_cv_qualified
);
7605 /* When comparing, say, char ** to char const **, this function takes the
7606 'char *' and 'char const *'. Do not pass non-pointer types to this
7610 comp_ptr_ttypes (to
, from
)
7613 return comp_ptr_ttypes_real (to
, from
, 1);
7616 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7617 type or inheritance-related types, regardless of cv-quals. */
7620 ptr_reasonably_similar (to
, from
)
7623 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7625 if (TREE_CODE (to
) != TREE_CODE (from
))
7628 if (TREE_CODE (from
) == OFFSET_TYPE
7629 && comptypes (TYPE_OFFSET_BASETYPE (to
),
7630 TYPE_OFFSET_BASETYPE (from
), -1))
7633 if (TREE_CODE (to
) != POINTER_TYPE
)
7635 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), -1);
7639 /* Like comp_ptr_ttypes, for const_cast. */
7642 comp_ptr_ttypes_const (to
, from
)
7645 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7647 if (TREE_CODE (to
) != TREE_CODE (from
))
7650 if (TREE_CODE (from
) == OFFSET_TYPE
7651 && comptypes (TYPE_OFFSET_BASETYPE (from
),
7652 TYPE_OFFSET_BASETYPE (to
), 1))
7655 if (TREE_CODE (to
) != POINTER_TYPE
)
7656 return comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1);
7660 /* Like comp_ptr_ttypes, for reinterpret_cast. */
7663 comp_ptr_ttypes_reinterpret (to
, from
)
7668 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7670 if (TREE_CODE (from
) == OFFSET_TYPE
)
7671 from
= TREE_TYPE (from
);
7672 if (TREE_CODE (to
) == OFFSET_TYPE
)
7673 to
= TREE_TYPE (to
);
7675 if (TREE_CODE (to
) != TREE_CODE (from
))
7678 /* Const and volatile mean something different for function types,
7679 so the usual checks are not appropriate. */
7680 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7682 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7683 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7687 && (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7688 || TYPE_VOLATILE (to
) > TYPE_READONLY (from
)))
7690 constp
&= TYPE_READONLY (to
);
7693 if (TREE_CODE (to
) != POINTER_TYPE
)