1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file is part of the C++ front end.
25 It contains routines to build C++ expressions given their operands,
26 including computing the types of the result, C and C++ specific error
27 checks, and some optimization.
29 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
30 and to process initializations in declarations (since they work
31 like a strange sort of assignment). */
44 static tree convert_for_assignment
PARAMS ((tree
, tree
, const char *, tree
,
46 static tree pointer_int_sum
PARAMS ((enum tree_code
, tree
, tree
));
47 static tree rationalize_conditional_expr
PARAMS ((enum tree_code
, tree
));
48 static int comp_target_parms
PARAMS ((tree
, tree
));
49 static int comp_ptr_ttypes_real
PARAMS ((tree
, tree
, int));
50 static int comp_ptr_ttypes_const
PARAMS ((tree
, tree
));
51 static int comp_ptr_ttypes_reinterpret
PARAMS ((tree
, tree
));
52 static int comp_except_types
PARAMS ((tree
, tree
, int));
53 static int comp_array_types
PARAMS ((int (*) (tree
, tree
, int), tree
,
55 static tree common_base_type
PARAMS ((tree
, tree
));
56 static tree lookup_anon_field
PARAMS ((tree
, tree
));
57 static tree pointer_diff
PARAMS ((tree
, tree
, tree
));
58 static tree build_component_addr
PARAMS ((tree
, tree
));
59 static tree qualify_type_recursive
PARAMS ((tree
, tree
));
60 static tree get_delta_difference
PARAMS ((tree
, tree
, int));
61 static int comp_cv_target_types
PARAMS ((tree
, tree
, int));
62 static void casts_away_constness_r
PARAMS ((tree
*, tree
*));
63 static int casts_away_constness
PARAMS ((tree
, tree
));
64 static void maybe_warn_about_returning_address_of_local
PARAMS ((tree
));
65 static tree strip_all_pointer_quals
PARAMS ((tree
));
67 /* Return the target type of TYPE, which means return T for:
68 T*, T&, T[], T (...), and otherwise, just T. */
74 if (TREE_CODE (type
) == REFERENCE_TYPE
)
75 type
= TREE_TYPE (type
);
76 while (TREE_CODE (type
) == POINTER_TYPE
77 || TREE_CODE (type
) == ARRAY_TYPE
78 || TREE_CODE (type
) == FUNCTION_TYPE
79 || TREE_CODE (type
) == METHOD_TYPE
80 || TREE_CODE (type
) == OFFSET_TYPE
)
81 type
= TREE_TYPE (type
);
85 /* Do `exp = require_complete_type (exp);' to make sure exp
86 does not have an incomplete type. (That includes void types.)
87 Returns the error_mark_node if the VALUE does not have
88 complete type when this function returns. */
91 require_complete_type (value
)
96 if (processing_template_decl
|| value
== error_mark_node
)
99 if (TREE_CODE (value
) == OVERLOAD
)
100 type
= unknown_type_node
;
102 type
= TREE_TYPE (value
);
104 /* First, detect a valid value with a complete type. */
105 if (COMPLETE_TYPE_P (type
))
108 /* If we see X::Y, we build an OFFSET_TYPE which has
109 not been laid out. Try to avoid an error by interpreting
110 it as this->X::Y, if reasonable. */
111 if (TREE_CODE (value
) == OFFSET_REF
112 && current_class_ref
!= 0
113 && TREE_OPERAND (value
, 0) == current_class_ref
)
115 tree base
, member
= TREE_OPERAND (value
, 1);
116 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
117 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
118 base
= convert_pointer_to (basetype
, current_class_ptr
);
119 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
120 build_indirect_ref (base
, NULL_PTR
), member
);
121 return require_complete_type (value
);
124 if (complete_type_or_else (type
, value
))
127 return error_mark_node
;
130 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
131 a template instantiation, do the instantiation. Returns TYPE,
132 whether or not it could be completed, unless something goes
133 horribly wrong, in which case the error_mark_node is returned. */
139 if (type
== NULL_TREE
)
140 /* Rather than crash, we return something sure to cause an error
142 return error_mark_node
;
144 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
146 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
148 tree t
= complete_type (TREE_TYPE (type
));
149 if (COMPLETE_TYPE_P (t
) && ! processing_template_decl
)
151 TYPE_NEEDS_CONSTRUCTING (type
)
152 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
153 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
154 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
156 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
157 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
162 /* Like complete_type, but issue an error if the TYPE cannot be
163 completed. VALUE is used for informative diagnostics.
164 Returns NULL_TREE if the type cannot be made complete. */
167 complete_type_or_else (type
, value
)
171 type
= complete_type (type
);
172 if (type
== error_mark_node
)
173 /* We already issued an error. */
175 else if (!COMPLETE_TYPE_P (type
))
177 incomplete_type_error (value
, 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 a pointer or pointer to member type similar to T1, with a
198 cv-qualification signature that is the union of the cv-qualification
199 signatures of T1 and T2: [expr.rel], [expr.eq]. */
202 qualify_type_recursive (t1
, t2
)
205 if ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
206 || (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
)))
208 tree tt1
= TREE_TYPE (t1
);
209 tree tt2
= TREE_TYPE (t2
);
213 tree attributes
= merge_machine_type_attributes (t1
, t2
);
215 if (TREE_CODE (tt1
) == OFFSET_TYPE
)
217 b1
= TYPE_OFFSET_BASETYPE (tt1
);
218 tt1
= TREE_TYPE (tt1
);
219 tt2
= TREE_TYPE (tt2
);
224 type_quals
= (CP_TYPE_QUALS (tt1
) | CP_TYPE_QUALS (tt2
));
225 target
= qualify_type_recursive (tt1
, tt2
);
226 target
= cp_build_qualified_type (target
, type_quals
);
228 target
= build_offset_type (b1
, target
);
229 t1
= build_pointer_type (target
);
230 t1
= build_type_attribute_variant (t1
, attributes
);
235 /* Return the common type of two parameter lists.
236 We assume that comptypes has already been done and returned 1;
237 if that isn't so, this may crash.
239 As an optimization, free the space we allocate if the parameter
240 lists are already common. */
246 tree oldargs
= p1
, newargs
, n
;
250 len
= list_length (p1
);
251 newargs
= tree_last (p1
);
253 if (newargs
== void_list_node
)
262 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
267 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
269 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
271 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
274 else if (! TREE_PURPOSE (p1
))
276 if (TREE_PURPOSE (p2
))
278 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
284 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
286 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
288 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
291 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
294 TREE_VALUE (n
) = TREE_VALUE (p1
);
302 /* Given a type, perhaps copied for a typedef,
303 find the "original" version of it. */
308 while (TYPE_NAME (t
) != NULL_TREE
)
310 tree x
= TYPE_NAME (t
);
311 if (TREE_CODE (x
) != TYPE_DECL
)
313 x
= DECL_ORIGINAL_TYPE (x
);
321 /* T1 and T2 are arithmetic or enumeration types. Return the type
322 that will result from the "usual arithmetic converions" on T1 and
323 T2 as described in [expr]. */
326 type_after_usual_arithmetic_conversions (t1
, t2
)
330 enum tree_code code1
= TREE_CODE (t1
);
331 enum tree_code code2
= TREE_CODE (t2
);
334 /* FIXME: Attributes. */
335 my_friendly_assert (ARITHMETIC_TYPE_P (t1
)
336 || TREE_CODE (t1
) == ENUMERAL_TYPE
,
338 my_friendly_assert (ARITHMETIC_TYPE_P (t2
)
339 || TREE_CODE (t2
) == ENUMERAL_TYPE
,
342 /* In what follows, we slightly generalize the rules given in [expr]
343 so as to deal with `long long'. First, merge the attributes. */
344 attributes
= merge_machine_type_attributes (t1
, t2
);
346 /* If only one is real, use it as the result. */
347 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
348 return build_type_attribute_variant (t1
, attributes
);
349 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
350 return build_type_attribute_variant (t2
, attributes
);
352 /* Perform the integral promotions. */
353 if (code1
!= REAL_TYPE
)
355 t1
= type_promotes_to (t1
);
356 t2
= type_promotes_to (t2
);
359 /* Both real or both integers; use the one with greater precision. */
360 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
361 return build_type_attribute_variant (t1
, attributes
);
362 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
363 return build_type_attribute_variant (t2
, attributes
);
365 if (code1
!= REAL_TYPE
)
367 /* If one is a sizetype, use it so size_binop doesn't blow up. */
368 if (TYPE_IS_SIZETYPE (t1
) > TYPE_IS_SIZETYPE (t2
))
369 return build_type_attribute_variant (t1
, attributes
);
370 if (TYPE_IS_SIZETYPE (t2
) > TYPE_IS_SIZETYPE (t1
))
371 return build_type_attribute_variant (t2
, attributes
);
373 /* If one is unsigned long long, then convert the other to unsigned
375 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
376 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
377 return build_type_attribute_variant (long_long_unsigned_type_node
,
379 /* If one is a long long, and the other is an unsigned long, and
380 long long can represent all the values of an unsigned long, then
381 convert to a long long. Otherwise, convert to an unsigned long
382 long. Otherwise, if either operand is long long, convert the
385 Since we're here, we know the TYPE_PRECISION is the same;
386 therefore converting to long long cannot represent all the values
387 of an unsigned long, so we choose unsigned long long in that
389 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
390 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
392 tree t
= ((TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
393 ? long_long_unsigned_type_node
394 : long_long_integer_type_node
);
395 return build_type_attribute_variant (t
, attributes
);
398 /* Go through the same procedure, but for longs. */
399 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
400 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
401 return build_type_attribute_variant (long_unsigned_type_node
,
403 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
404 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
406 tree t
= ((TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
407 ? long_unsigned_type_node
: long_integer_type_node
);
408 return build_type_attribute_variant (t
, attributes
);
410 /* Otherwise prefer the unsigned one. */
411 if (TREE_UNSIGNED (t1
))
412 return build_type_attribute_variant (t1
, attributes
);
414 return build_type_attribute_variant (t2
, attributes
);
418 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
419 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
420 return build_type_attribute_variant (long_double_type_node
,
422 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
423 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
424 return build_type_attribute_variant (double_type_node
,
427 return build_type_attribute_variant (float_type_node
,
432 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
433 ARG1 and ARG2 are the values with those types. The LOCATION is a
434 string describing the current location, in case an error occurs. */
437 composite_pointer_type (t1
, t2
, arg1
, arg2
, location
)
442 const char* location
;
448 If one operand is a null pointer constant, the composite pointer
449 type is the type of the other operand. */
450 if (null_ptr_cst_p (arg1
))
452 if (null_ptr_cst_p (arg2
))
455 /* Deal with pointer-to-member functions in the same way as we deal
456 with pointers to functions. */
457 if (TYPE_PTRMEMFUNC_P (t1
))
458 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
459 if (TYPE_PTRMEMFUNC_P (t2
))
460 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
466 If one of the operands has type "pointer to cv1 void*", then
467 the other has type "pointer to cv2T", and the composite pointer
468 type is "pointer to cv12 void", where cv12 is the union of cv1
471 If either type is a pointer to void, make sure it is T1. */
472 if (VOID_TYPE_P (TREE_TYPE (t2
)))
479 /* Now, if T1 is a pointer to void, merge the qualifiers. */
480 if (VOID_TYPE_P (TREE_TYPE (t1
)))
482 if (pedantic
&& TYPE_PTRFN_P (t2
))
483 pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location
);
486 result_type
= cp_build_qualified_type (void_type_node
,
488 | CP_TYPE_QUALS (t2
)));
489 result_type
= build_pointer_type (result_type
);
493 tree full1
= qualify_type_recursive (t1
, t2
);
494 tree full2
= qualify_type_recursive (t2
, t1
);
496 int val
= comp_target_types (full1
, full2
, 1);
504 cp_pedwarn ("%s between distinct pointer types `%T' and `%T' lacks a cast",
506 result_type
= ptr_type_node
;
513 /* Return the common type of two types.
514 We assume that comptypes has already been done and returned 1;
515 if that isn't so, this may crash.
517 This is the type for the result of most arithmetic operations
518 if the operands have the given two types.
520 We do not deal with enumeral types here because they have already been
521 converted to integer types. */
527 register enum tree_code code1
;
528 register enum tree_code code2
;
531 /* Save time if the two types are the same. */
534 t1
= original_type (t1
);
535 t2
= original_type (t2
);
539 /* If one type is nonsense, use the other. */
540 if (t1
== error_mark_node
)
542 if (t2
== error_mark_node
)
545 if ((ARITHMETIC_TYPE_P (t1
) || TREE_CODE (t1
) == ENUMERAL_TYPE
)
546 && (ARITHMETIC_TYPE_P (t2
) || TREE_CODE (t2
) == ENUMERAL_TYPE
))
547 return type_after_usual_arithmetic_conversions (t1
, t2
);
549 /* Merge the attributes. */
550 attributes
= merge_machine_type_attributes (t1
, t2
);
552 /* Treat an enum type as the unsigned integer type of the same width. */
554 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
555 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
556 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
557 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
559 if (TYPE_PTRMEMFUNC_P (t1
))
560 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
561 if (TYPE_PTRMEMFUNC_P (t2
))
562 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
564 code1
= TREE_CODE (t1
);
565 code2
= TREE_CODE (t2
);
567 /* If one type is complex, form the common type of the non-complex
568 components, then make that complex. Use T1 or T2 if it is the
570 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
572 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
573 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
574 tree subtype
= common_type (subtype1
, subtype2
);
576 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
577 return build_type_attribute_variant (t1
, attributes
);
578 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
579 return build_type_attribute_variant (t2
, attributes
);
581 return build_type_attribute_variant (build_complex_type (subtype
),
589 /* We should have called type_after_usual_arithmetic_conversions
591 my_friendly_abort (19990725);
596 /* For two pointers, do this recursively on the target type,
597 and combine the qualifiers of the two types' targets. */
598 /* This code was turned off; I don't know why.
599 But ISO C++ specifies doing this with the qualifiers.
600 So I turned it on again. */
602 tree tt1
= TREE_TYPE (t1
);
603 tree tt2
= TREE_TYPE (t2
);
608 if (TREE_CODE (tt1
) == OFFSET_TYPE
)
610 b1
= TYPE_OFFSET_BASETYPE (tt1
);
611 b2
= TYPE_OFFSET_BASETYPE (tt2
);
612 tt1
= TREE_TYPE (tt1
);
613 tt2
= TREE_TYPE (tt2
);
618 type_quals
= (CP_TYPE_QUALS (tt1
) | CP_TYPE_QUALS (tt2
));
619 tt1
= TYPE_MAIN_VARIANT (tt1
);
620 tt2
= TYPE_MAIN_VARIANT (tt2
);
624 else if (VOID_TYPE_P (tt1
) || VOID_TYPE_P (tt2
))
625 target
= void_type_node
;
626 else if (tt1
== unknown_type_node
)
628 else if (tt2
== unknown_type_node
)
631 target
= common_type (tt1
, tt2
);
633 target
= cp_build_qualified_type (target
, type_quals
);
637 if (same_type_p (b1
, b2
)
638 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
639 target
= build_offset_type (b2
, target
);
640 else if (binfo_or_else (b2
, b1
))
641 target
= build_offset_type (b1
, target
);
644 if (code1
== POINTER_TYPE
)
645 t1
= build_pointer_type (target
);
647 t1
= build_reference_type (target
);
648 t1
= build_type_attribute_variant (t1
, attributes
);
650 if (TREE_CODE (target
) == METHOD_TYPE
)
651 t1
= build_ptrmemfunc_type (t1
);
658 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
659 /* Save space: see if the result is identical to one of the args. */
660 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
661 return build_type_attribute_variant (t1
, attributes
);
662 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
663 return build_type_attribute_variant (t2
, attributes
);
664 /* Merge the element types, and have a size if either arg has one. */
665 t1
= build_cplus_array_type
666 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
667 return build_type_attribute_variant (t1
, attributes
);
671 /* Function types: prefer the one that specified arg types.
672 If both do, merge the arg types. Also merge the return types. */
674 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
675 tree p1
= TYPE_ARG_TYPES (t1
);
676 tree p2
= TYPE_ARG_TYPES (t2
);
679 /* Save space: see if the result is identical to one of the args. */
680 if (valtype
== TREE_TYPE (t1
) && ! p2
)
681 return build_type_attribute_variant (t1
, attributes
);
682 if (valtype
== TREE_TYPE (t2
) && ! p1
)
683 return build_type_attribute_variant (t2
, attributes
);
685 /* Simple way if one arg fails to specify argument types. */
686 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
688 rval
= build_function_type (valtype
, p2
);
689 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
690 rval
= build_exception_variant (rval
, raises
);
691 return build_type_attribute_variant (rval
, attributes
);
693 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
694 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
696 rval
= build_function_type (valtype
, p1
);
698 rval
= build_exception_variant (rval
, raises
);
699 return build_type_attribute_variant (rval
, attributes
);
702 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
703 rval
= build_exception_variant (rval
, raises
);
704 return build_type_attribute_variant (rval
, attributes
);
709 t1
= TYPE_MAIN_VARIANT (t1
);
710 t2
= TYPE_MAIN_VARIANT (t2
);
712 if (DERIVED_FROM_P (t1
, t2
) && binfo_or_else (t1
, t2
))
713 return build_type_attribute_variant (t1
, attributes
);
714 else if (binfo_or_else (t2
, t1
))
715 return build_type_attribute_variant (t2
, attributes
);
718 compiler_error ("common_type called with uncommon aggregate types");
719 return error_mark_node
;
723 if (TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
725 /* Get this value the long way, since TYPE_METHOD_BASETYPE
726 is just the main variant of this. */
730 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
731 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
733 if (same_type_p (b1
, b2
)
734 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
735 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
738 if (binfo_or_else (b2
, b1
) == NULL_TREE
)
739 compiler_error ("common_type called with uncommon method types");
740 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
743 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
745 /* If this was a member function type, get back to the
746 original type of type member function (i.e., without
747 the class instance variable up front. */
748 t1
= build_function_type (TREE_TYPE (t1
),
749 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
750 t2
= build_function_type (TREE_TYPE (t2
),
751 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
752 t3
= common_type (t1
, t2
);
753 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
),
754 TYPE_ARG_TYPES (t3
));
755 t1
= build_exception_variant (t3
, raises
);
758 compiler_error ("common_type called with uncommon method types");
760 return build_type_attribute_variant (t1
, attributes
);
763 /* Pointers to members should now be handled by the POINTER_TYPE
765 my_friendly_abort (990325);
768 return build_type_attribute_variant (t1
, attributes
);
772 /* Compare two exception specifier types for exactness or subsetness, if
773 allowed. Returns 0 for mismatch, 1 for same, 2 if B is allowed by A.
775 [except.spec] "If a class X ... objects of class X or any class publicly
776 and unambigously derrived from X. Similarly, if a pointer type Y * ...
777 exceptions of type Y * or that are pointers to any type publicly and
778 unambigously derrived from Y. Otherwise a function only allows exceptions
779 that have the same type ..."
780 This does not mention cv qualifiers and is different to what throw
781 [except.throw] and catch [except.catch] will do. They will ignore the
782 top level cv qualifiers, and allow qualifiers in the pointer to class
785 We implement the letter of the standard. */
788 comp_except_types (a
, b
, exact
)
792 if (same_type_p (a
, b
))
796 if (CP_TYPE_QUALS (a
) || CP_TYPE_QUALS (b
))
799 if (TREE_CODE (a
) == POINTER_TYPE
800 && TREE_CODE (b
) == POINTER_TYPE
)
804 if (CP_TYPE_QUALS (a
) || CP_TYPE_QUALS (b
))
808 if (TREE_CODE (a
) != RECORD_TYPE
809 || TREE_CODE (b
) != RECORD_TYPE
)
812 if (ACCESSIBLY_UNIQUELY_DERIVED_P (a
, b
))
818 /* Return 1 if TYPE1 and TYPE2 are equivalent exception specifiers.
819 If EXACT is 0, T2 can be a subset of T1 (according to 15.4/7),
820 otherwise it must be exact. Exception lists are unordered, but
821 we've already filtered out duplicates. Most lists will be in order,
822 we should try to make use of that. */
825 comp_except_specs (t1
, t2
, exact
)
836 if (t1
== NULL_TREE
) /* T1 is ... */
837 return t2
== NULL_TREE
|| !exact
;
838 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
839 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
840 if (t2
== NULL_TREE
) /* T2 is ... */
842 if (TREE_VALUE(t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
845 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
846 Count how many we find, to determine exactness. For exact matching and
847 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
849 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
851 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
853 tree a
= TREE_VALUE (probe
);
854 tree b
= TREE_VALUE (t2
);
856 if (comp_except_types (a
, b
, exact
))
858 if (probe
== base
&& exact
)
859 base
= TREE_CHAIN (probe
);
864 if (probe
== NULL_TREE
)
867 return !exact
|| base
== NULL_TREE
|| length
== list_length (t1
);
870 /* Compare the array types T1 and T2, using CMP as the type comparison
871 function for the element types. STRICT is as for comptypes. */
874 comp_array_types (cmp
, t1
, t2
, strict
)
875 register int (*cmp
) PARAMS ((tree
, tree
, int));
885 /* The type of the array elements must be the same. */
886 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
887 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
),
888 strict
& ~COMPARE_REDECLARATION
)))
891 d1
= TYPE_DOMAIN (t1
);
892 d2
= TYPE_DOMAIN (t2
);
897 /* If one of the arrays is dimensionless, and the other has a
898 dimension, they are of different types. However, it is legal to
906 declarations for an array object can specify
907 array types that differ by the presence or absence of a major
908 array bound (_dcl.array_). */
910 return strict
& COMPARE_REDECLARATION
;
912 /* Check that the dimensions are the same. */
913 return (cp_tree_equal (TYPE_MIN_VALUE (d1
),
915 && cp_tree_equal (TYPE_MAX_VALUE (d1
),
916 TYPE_MAX_VALUE (d2
)));
919 /* Return 1 if T1 and T2 are compatible types for assignment or
920 various other operations. STRICT is a bitwise-or of the COMPARE_*
924 comptypes (t1
, t2
, strict
)
930 int orig_strict
= strict
;
932 /* The special exemption for redeclaring array types without an
933 array bound only applies at the top level:
938 is not legal, for example. */
939 strict
&= ~COMPARE_REDECLARATION
;
941 /* Suppress errors caused by previously reported errors */
945 /* This should never happen. */
946 my_friendly_assert (t1
!= error_mark_node
, 307);
948 if (t2
== error_mark_node
)
951 /* If either type is the internal version of sizetype, return the
953 if (TREE_CODE (t1
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t1
)
954 && TYPE_DOMAIN (t1
) != 0)
955 t1
= TYPE_DOMAIN (t1
);
957 if (TREE_CODE (t2
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t2
)
958 && TYPE_DOMAIN (t2
) != 0)
959 t2
= TYPE_DOMAIN (t2
);
961 if (strict
& COMPARE_RELAXED
)
963 /* Treat an enum type as the unsigned integer type of the same width. */
965 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
966 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
967 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
968 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
974 if (TYPE_PTRMEMFUNC_P (t1
))
975 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
976 if (TYPE_PTRMEMFUNC_P (t2
))
977 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
979 /* Different classes of types can't be compatible. */
980 if (TREE_CODE (t1
) != TREE_CODE (t2
))
983 /* Qualifiers must match. */
984 if (CP_TYPE_QUALS (t1
) != CP_TYPE_QUALS (t2
))
986 if (strict
== COMPARE_STRICT
987 && TYPE_FOR_JAVA (t1
) != TYPE_FOR_JAVA (t2
))
990 /* Allow for two different type nodes which have essentially the same
991 definition. Note that we already checked for equality of the type
992 qualifiers (just above). */
994 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
997 /* ??? COMP_TYPE_ATTRIBUTES is currently useless for variables as each
998 attribute is its own main variant (`val' will remain 0). */
999 #ifndef COMP_TYPE_ATTRIBUTES
1000 #define COMP_TYPE_ATTRIBUTES(t1,t2) 1
1003 if (strict
& COMPARE_NO_ATTRIBUTES
)
1005 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1006 else if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
1009 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1012 switch (TREE_CODE (t1
))
1014 case TEMPLATE_TEMPLATE_PARM
:
1015 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1016 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
1017 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
))
1019 if (! comp_template_parms
1020 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1021 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1023 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1025 /* Don't check inheritance. */
1026 strict
= COMPARE_STRICT
;
1031 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1032 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1033 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
))
1034 val
= comp_template_args (TYPE_TI_ARGS (t1
),
1037 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1039 else if ((strict
& COMPARE_RELAXED
) && DERIVED_FROM_P (t2
, t1
))
1044 val
= (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1
)),
1045 build_pointer_type (TYPE_OFFSET_BASETYPE (t2
)), strict
)
1046 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
1050 if (! comp_except_specs (TYPE_RAISES_EXCEPTIONS (t1
),
1051 TYPE_RAISES_EXCEPTIONS (t2
), 1))
1054 /* This case is anti-symmetrical!
1055 One can pass a base member (or member function)
1056 to something expecting a derived member (or member function),
1057 but not vice-versa! */
1059 val
= (comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
1060 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
1064 case REFERENCE_TYPE
:
1065 t1
= TREE_TYPE (t1
);
1066 t2
= TREE_TYPE (t2
);
1067 /* first, check whether the referred types match with the
1068 required level of strictness */
1069 val
= comptypes (t1
, t2
, strict
);
1072 if (TREE_CODE (t1
) == RECORD_TYPE
1073 && TREE_CODE (t2
) == RECORD_TYPE
)
1078 if (! comp_except_specs (TYPE_RAISES_EXCEPTIONS (t1
),
1079 TYPE_RAISES_EXCEPTIONS (t2
), 1))
1082 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
1083 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
1084 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
1088 /* Target types must match incl. qualifiers. We use ORIG_STRICT
1089 here since this is the one place where
1090 COMPARE_REDECLARATION should be used. */
1091 val
= comp_array_types (comptypes
, t1
, t2
, orig_strict
);
1094 case TEMPLATE_TYPE_PARM
:
1095 return TEMPLATE_TYPE_IDX (t1
) == TEMPLATE_TYPE_IDX (t2
)
1096 && TEMPLATE_TYPE_LEVEL (t1
) == TEMPLATE_TYPE_LEVEL (t2
);
1099 if (cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1100 TYPENAME_TYPE_FULLNAME (t2
)) < 1)
1102 return same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1105 return same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
));
1110 return attrval
== 2 && val
== 1 ? 2 : val
;
1113 /* Subroutine of comp_target-types. Make sure that the cv-quals change
1114 only in the same direction as the target type. */
1117 comp_cv_target_types (ttl
, ttr
, nptrs
)
1123 if (!at_least_as_qualified_p (ttl
, ttr
)
1124 && !at_least_as_qualified_p (ttr
, ttl
))
1125 /* The qualifications are incomparable. */
1128 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
))
1129 return more_qualified_p (ttr
, ttl
) ? -1 : 1;
1131 t
= comp_target_types (ttl
, ttr
, nptrs
);
1132 if ((t
== 1 && at_least_as_qualified_p (ttl
, ttr
))
1133 || (t
== -1 && at_least_as_qualified_p (ttr
, ttl
)))
1139 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
1140 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
1141 converted to TTL. Return -1 means that TTL can be converted to TTR but
1144 NPTRS is the number of pointers we can strip off and keep cool.
1145 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
1146 but to not permit B** to convert to A**.
1148 This should go away. Callers should use can_convert or something
1149 similar instead. (jason 17 Apr 1997) */
1152 comp_target_types (ttl
, ttr
, nptrs
)
1156 ttl
= TYPE_MAIN_VARIANT (ttl
);
1157 ttr
= TYPE_MAIN_VARIANT (ttr
);
1158 if (same_type_p (ttl
, ttr
))
1161 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
1164 if ((TREE_CODE (ttr
) == POINTER_TYPE
1165 || TREE_CODE (ttr
) == REFERENCE_TYPE
)
1166 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
1167 of the type pointed to. This is necessary for reference init
1168 semantics. We won't get here from a previous call with nptrs == 1;
1169 for multi-level pointers we end up in comp_ptr_ttypes. */
1172 int is_ptr
= TREE_CODE (ttr
) == POINTER_TYPE
;
1174 ttl
= TREE_TYPE (ttl
);
1175 ttr
= TREE_TYPE (ttr
);
1179 if (TREE_CODE (ttl
) == UNKNOWN_TYPE
1180 || TREE_CODE (ttr
) == UNKNOWN_TYPE
)
1182 else if (TREE_CODE (ttl
) == VOID_TYPE
1183 && TREE_CODE (ttr
) != FUNCTION_TYPE
1184 && TREE_CODE (ttr
) != METHOD_TYPE
1185 && TREE_CODE (ttr
) != OFFSET_TYPE
)
1187 else if (TREE_CODE (ttr
) == VOID_TYPE
1188 && TREE_CODE (ttl
) != FUNCTION_TYPE
1189 && TREE_CODE (ttl
) != METHOD_TYPE
1190 && TREE_CODE (ttl
) != OFFSET_TYPE
)
1192 else if (TREE_CODE (ttl
) == POINTER_TYPE
1193 || TREE_CODE (ttl
) == ARRAY_TYPE
)
1195 if (comp_ptr_ttypes (ttl
, ttr
))
1197 else if (comp_ptr_ttypes (ttr
, ttl
))
1203 /* Const and volatile mean something different for function types,
1204 so the usual checks are not appropriate. */
1205 if (TREE_CODE (ttl
) == FUNCTION_TYPE
|| TREE_CODE (ttl
) == METHOD_TYPE
)
1206 return comp_target_types (ttl
, ttr
, nptrs
- 1);
1208 return comp_cv_target_types (ttl
, ttr
, nptrs
- 1);
1211 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
1212 return comp_array_types (comp_target_types
, ttl
, ttr
, COMPARE_STRICT
);
1213 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
1220 if (!same_type_p (TREE_TYPE (ttl
), TREE_TYPE (ttr
)))
1225 switch (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), -1))
1234 argsl
= TYPE_ARG_TYPES (ttl
);
1235 argsr
= TYPE_ARG_TYPES (ttr
);
1237 /* Compare 'this' here, not in comp_target_parms. */
1238 if (TREE_CODE (ttr
) == METHOD_TYPE
)
1240 tree tl
= TYPE_METHOD_BASETYPE (ttl
);
1241 tree tr
= TYPE_METHOD_BASETYPE (ttr
);
1243 if (!same_or_base_type_p (tr
, tl
))
1245 if (same_or_base_type_p (tl
, tr
))
1251 argsl
= TREE_CHAIN (argsl
);
1252 argsr
= TREE_CHAIN (argsr
);
1255 switch (comp_target_parms (argsl
, argsr
))
1263 return saw_contra
? -1 : 1;
1266 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
1270 /* Contravariance: we can assign a pointer to base member to a pointer
1271 to derived member. Note difference from simple pointer case, where
1272 we can pass a pointer to derived to a pointer to base. */
1273 if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr
),
1274 TYPE_OFFSET_BASETYPE (ttl
)))
1276 else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl
),
1277 TYPE_OFFSET_BASETYPE (ttr
)))
1287 ttl
= TREE_TYPE (ttl
);
1288 ttr
= TREE_TYPE (ttr
);
1290 if (TREE_CODE (ttl
) == POINTER_TYPE
1291 || TREE_CODE (ttl
) == ARRAY_TYPE
)
1293 if (comp_ptr_ttypes (ttl
, ttr
))
1299 if (comp_cv_target_types (ttl
, ttr
, nptrs
) == 1)
1304 else if (IS_AGGR_TYPE (ttl
))
1308 if (same_or_base_type_p (build_pointer_type (ttl
),
1309 build_pointer_type (ttr
)))
1311 if (same_or_base_type_p (build_pointer_type (ttr
),
1312 build_pointer_type (ttl
)))
1320 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1323 at_least_as_qualified_p (type1
, type2
)
1327 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1328 return ((CP_TYPE_QUALS (type1
) & CP_TYPE_QUALS (type2
))
1329 == CP_TYPE_QUALS (type2
));
1332 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1335 more_qualified_p (type1
, type2
)
1339 return (CP_TYPE_QUALS (type1
) != CP_TYPE_QUALS (type2
)
1340 && at_least_as_qualified_p (type1
, type2
));
1343 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1344 more cv-qualified that TYPE1, and 0 otherwise. */
1347 comp_cv_qualification (type1
, type2
)
1351 if (CP_TYPE_QUALS (type1
) == CP_TYPE_QUALS (type2
))
1354 if (at_least_as_qualified_p (type1
, type2
))
1357 else if (at_least_as_qualified_p (type2
, type1
))
1363 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1364 subset of the cv-qualification signature of TYPE2, and the types
1365 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1368 comp_cv_qual_signature (type1
, type2
)
1372 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1374 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1380 /* If two types share a common base type, return that basetype.
1381 If there is not a unique most-derived base type, this function
1382 returns ERROR_MARK_NODE. */
1385 common_base_type (tt1
, tt2
)
1388 tree best
= NULL_TREE
;
1391 /* If one is a baseclass of another, that's good enough. */
1392 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
1394 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
1397 /* Otherwise, try to find a unique baseclass of TT1
1398 that is shared by TT2, and follow that down. */
1399 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
1401 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
1402 tree trial
= common_base_type (basetype
, tt2
);
1405 if (trial
== error_mark_node
)
1407 if (best
== NULL_TREE
)
1409 else if (best
!= trial
)
1410 return error_mark_node
;
1415 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
1417 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
1418 tree trial
= common_base_type (tt1
, basetype
);
1421 if (trial
== error_mark_node
)
1423 if (best
== NULL_TREE
)
1425 else if (best
!= trial
)
1426 return error_mark_node
;
1432 /* Subroutines of `comptypes'. */
1434 /* Return 1 if two parameter type lists PARMS1 and PARMS2 are
1435 equivalent in the sense that functions with those parameter types
1436 can have equivalent types. The two lists must be equivalent,
1439 C++: See comment above about TYPE1, TYPE2. */
1442 compparms (parms1
, parms2
)
1443 tree parms1
, parms2
;
1445 register tree t1
= parms1
, t2
= parms2
;
1447 /* An unspecified parmlist matches any specified parmlist
1448 whose argument types don't need default promotions. */
1452 if (t1
== 0 && t2
== 0)
1454 /* If one parmlist is shorter than the other,
1455 they fail to match. */
1456 if (t1
== 0 || t2
== 0)
1458 if (!same_type_p (TREE_VALUE (t2
), TREE_VALUE (t1
)))
1461 t1
= TREE_CHAIN (t1
);
1462 t2
= TREE_CHAIN (t2
);
1466 /* This really wants return whether or not parameter type lists
1467 would make their owning functions assignment compatible or not.
1469 The return value is like for comp_target_types.
1471 This should go away, possibly with the exception of the empty parmlist
1472 conversion; there are no conversions between function types in C++.
1473 (jason 17 Apr 1997) */
1476 comp_target_parms (parms1
, parms2
)
1477 tree parms1
, parms2
;
1479 register tree t1
= parms1
, t2
= parms2
;
1480 int warn_contravariance
= 0;
1482 /* In C, an unspecified parmlist matches any specified parmlist
1483 whose argument types don't need default promotions. This is not
1484 true for C++, but let's do it anyway for unfixed headers. */
1486 if (t1
== 0 && t2
!= 0)
1488 cp_pedwarn ("ISO C++ prohibits conversion from `%#T' to `(...)'",
1490 return self_promoting_args_p (t2
);
1493 return self_promoting_args_p (t1
);
1495 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1499 /* If one parmlist is shorter than the other,
1500 they fail to match, unless STRICT is <= 0. */
1501 if (t1
== 0 || t2
== 0)
1503 p1
= TREE_VALUE (t1
);
1504 p2
= TREE_VALUE (t2
);
1505 if (same_type_p (p1
, p2
))
1511 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
1512 || (TREE_CODE (p1
) == REFERENCE_TYPE
1513 && TREE_CODE (p2
) == REFERENCE_TYPE
))
1515 /* The following is wrong for contravariance,
1516 but many programs depend on it. */
1517 if (TREE_TYPE (p1
) == void_type_node
)
1519 if (TREE_TYPE (p2
) == void_type_node
)
1521 warn_contravariance
= 1;
1524 if (IS_AGGR_TYPE (TREE_TYPE (p1
))
1525 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (p1
),
1529 /* Note backwards order due to contravariance. */
1530 if (comp_target_types (p2
, p1
, 1) <= 0)
1532 if (comp_target_types (p1
, p2
, 1) > 0)
1534 warn_contravariance
= 1;
1540 return warn_contravariance
? -1 : 1;
1543 /* Compute the value of the `sizeof' operator. */
1549 enum tree_code code
= TREE_CODE (type
);
1552 if (processing_template_decl
)
1553 return build_min (SIZEOF_EXPR
, sizetype
, type
);
1555 if (code
== FUNCTION_TYPE
)
1557 if (pedantic
|| warn_pointer_arith
)
1558 pedwarn ("ISO C++ forbids applying `sizeof' to a function type");
1559 size
= size_one_node
;
1561 else if (code
== METHOD_TYPE
)
1563 if (pedantic
|| warn_pointer_arith
)
1564 pedwarn ("ISO C++ forbids applying `sizeof' to a member function");
1565 size
= size_one_node
;
1567 else if (code
== VOID_TYPE
)
1569 if (pedantic
|| warn_pointer_arith
)
1570 pedwarn ("ISO C++ forbids applying `sizeof' to type `void' which is an incomplete type");
1571 size
= size_one_node
;
1573 else if (code
== ERROR_MARK
)
1574 size
= size_one_node
;
1577 /* ARM $5.3.2: ``When applied to a reference, the result is the
1578 size of the referenced object.'' */
1579 if (code
== REFERENCE_TYPE
)
1580 type
= TREE_TYPE (type
);
1582 if (code
== OFFSET_TYPE
)
1584 cp_error ("`sizeof' applied to non-static member");
1585 size
= size_zero_node
;
1587 else if (!COMPLETE_TYPE_P (complete_type (type
)))
1589 cp_error ("`sizeof' applied to incomplete type `%T'", type
);
1590 size
= size_zero_node
;
1593 /* Convert in case a char is more than one unit. */
1594 size
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1595 size_int (TYPE_PRECISION (char_type_node
)
1599 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
1600 TYPE_IS_SIZETYPE means that certain things (like overflow) will
1601 never happen. However, this node should really have type
1602 `size_t', which is just a typedef for an ordinary integer type. */
1603 size
= fold (build1 (NOP_EXPR
, c_size_type_node
, size
));
1604 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (size
)),
1614 if (processing_template_decl
)
1615 return build_min (SIZEOF_EXPR
, sizetype
, e
);
1617 if (TREE_CODE (e
) == COMPONENT_REF
1618 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1619 error ("sizeof applied to a bit-field");
1620 if (is_overloaded_fn (e
))
1622 pedwarn ("ISO C++ forbids applying `sizeof' to an expression of function type");
1623 return c_sizeof (char_type_node
);
1625 else if (type_unknown_p (e
))
1627 incomplete_type_error (e
, TREE_TYPE (e
));
1628 return c_sizeof (char_type_node
);
1630 /* It's illegal to say `sizeof (X::i)' for `i' a non-static data
1631 member unless you're in a non-static member of X. So hand off to
1632 resolve_offset_ref. [expr.prim] */
1633 else if (TREE_CODE (e
) == OFFSET_REF
)
1634 e
= resolve_offset_ref (e
);
1636 if (e
== error_mark_node
)
1639 return c_sizeof (TREE_TYPE (e
));
1643 c_sizeof_nowarn (type
)
1646 enum tree_code code
= TREE_CODE (type
);
1649 if (code
== FUNCTION_TYPE
1650 || code
== METHOD_TYPE
1651 || code
== VOID_TYPE
1652 || code
== ERROR_MARK
)
1653 size
= size_one_node
;
1656 if (code
== REFERENCE_TYPE
)
1657 type
= TREE_TYPE (type
);
1659 if (!COMPLETE_TYPE_P (type
))
1660 size
= size_zero_node
;
1662 /* Convert in case a char is more than one unit. */
1663 size
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1664 size_int (TYPE_PRECISION (char_type_node
)
1668 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
1669 TYPE_IS_SIZETYPE means that certain things (like overflow) will
1670 never happen. However, this node should really have type
1671 `size_t', which is just a typedef for an ordinary integer type. */
1672 size
= fold (build1 (NOP_EXPR
, c_size_type_node
, size
));
1673 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (size
)),
1678 /* Implement the __alignof keyword: Return the minimum required
1679 alignment of TYPE, measured in bytes. */
1685 enum tree_code code
= TREE_CODE (type
);
1688 if (processing_template_decl
)
1689 return build_min (ALIGNOF_EXPR
, sizetype
, type
);
1691 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1692 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1693 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1697 /* Similar to sizeof, __alignof applies to the referant. */
1698 if (code
== REFERENCE_TYPE
)
1699 type
= TREE_TYPE (type
);
1701 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1704 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
1707 /* Perform the array-to-pointer and function-to-pointer conversions
1710 In addition, references are converted to lvalues and manifest
1711 constants are replaced by their values. */
1714 decay_conversion (exp
)
1718 register enum tree_code code
;
1720 if (TREE_CODE (exp
) == OFFSET_REF
)
1721 exp
= resolve_offset_ref (exp
);
1723 type
= TREE_TYPE (exp
);
1724 code
= TREE_CODE (type
);
1726 if (code
== REFERENCE_TYPE
)
1728 exp
= convert_from_reference (exp
);
1729 type
= TREE_TYPE (exp
);
1730 code
= TREE_CODE (type
);
1733 if (type
== error_mark_node
)
1734 return error_mark_node
;
1736 /* Constants can be used directly unless they're not loadable. */
1737 if (TREE_CODE (exp
) == CONST_DECL
)
1738 exp
= DECL_INITIAL (exp
);
1739 /* Replace a nonvolatile const static variable with its value. We
1740 don't do this for arrays, though; we want the address of the
1741 first element of the array, not the address of the first element
1742 of its initializing constant. */
1743 else if (code
!= ARRAY_TYPE
)
1745 exp
= decl_constant_value (exp
);
1746 type
= TREE_TYPE (exp
);
1749 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1750 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1752 if (code
== VOID_TYPE
)
1754 error ("void value not ignored as it ought to be");
1755 return error_mark_node
;
1757 if (code
== METHOD_TYPE
)
1758 my_friendly_abort (990506);
1759 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1760 return build_unary_op (ADDR_EXPR
, exp
, 0);
1761 if (code
== ARRAY_TYPE
)
1766 if (TREE_CODE (exp
) == INDIRECT_REF
)
1768 /* Stripping away the INDIRECT_REF is not the right
1769 thing to do for references... */
1770 tree inner
= TREE_OPERAND (exp
, 0);
1771 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1773 inner
= build1 (CONVERT_EXPR
,
1774 build_pointer_type (TREE_TYPE
1775 (TREE_TYPE (inner
))),
1777 TREE_CONSTANT (inner
) = TREE_CONSTANT (TREE_OPERAND (inner
, 0));
1779 return cp_convert (build_pointer_type (TREE_TYPE (type
)), inner
);
1782 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1784 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1785 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1786 TREE_OPERAND (exp
, 0), op1
);
1790 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1792 error ("invalid use of non-lvalue array");
1793 return error_mark_node
;
1796 ptrtype
= build_pointer_type (TREE_TYPE (type
));
1798 if (TREE_CODE (exp
) == VAR_DECL
)
1800 /* ??? This is not really quite correct
1801 in that the type of the operand of ADDR_EXPR
1802 is not the target type of the type of the ADDR_EXPR itself.
1803 Question is, can this lossage be avoided? */
1804 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1805 if (mark_addressable (exp
) == 0)
1806 return error_mark_node
;
1807 TREE_CONSTANT (adr
) = staticp (exp
);
1808 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1811 /* This way is better for a COMPONENT_REF since it can
1812 simplify the offset for a component. */
1813 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1814 return cp_convert (ptrtype
, adr
);
1817 /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1818 rvalues always have cv-unqualified types. */
1819 if (! CLASS_TYPE_P (type
))
1820 exp
= cp_convert (TYPE_MAIN_VARIANT (type
), exp
);
1826 default_conversion (exp
)
1830 enum tree_code code
;
1832 exp
= decay_conversion (exp
);
1834 type
= TREE_TYPE (exp
);
1835 code
= TREE_CODE (type
);
1837 if (INTEGRAL_CODE_P (code
))
1839 tree t
= type_promotes_to (type
);
1841 return cp_convert (t
, exp
);
1847 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1851 inline_conversion (exp
)
1854 if (TREE_CODE (exp
) == FUNCTION_DECL
)
1855 exp
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (exp
)), exp
);
1860 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1861 decay_conversion to one. */
1864 string_conv_p (totype
, exp
, warn
)
1870 if (! flag_const_strings
|| TREE_CODE (totype
) != POINTER_TYPE
)
1873 t
= TREE_TYPE (totype
);
1874 if (!same_type_p (t
, char_type_node
)
1875 && !same_type_p (t
, wchar_type_node
))
1878 if (TREE_CODE (exp
) == STRING_CST
)
1880 /* Make sure that we don't try to convert between char and wchar_t. */
1881 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
1886 /* Is this a string constant which has decayed to 'const char *'? */
1887 t
= build_pointer_type (build_qualified_type (t
, TYPE_QUAL_CONST
));
1888 if (!same_type_p (TREE_TYPE (exp
), t
))
1891 if (TREE_CODE (exp
) != ADDR_EXPR
1892 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1896 /* This warning is not very useful, as it complains about printf. */
1897 if (warn
&& warn_write_strings
)
1898 cp_warning ("deprecated conversion from string constant to `%T'", totype
);
1904 build_object_ref (datum
, basetype
, field
)
1905 tree datum
, basetype
, field
;
1908 if (datum
== error_mark_node
)
1909 return error_mark_node
;
1911 dtype
= TREE_TYPE (datum
);
1912 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1913 dtype
= TREE_TYPE (dtype
);
1914 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1916 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1917 basetype
, field
, dtype
);
1918 return error_mark_node
;
1920 else if (is_aggr_type (basetype
, 1))
1922 tree binfo
= binfo_or_else (basetype
, dtype
);
1924 return build_x_component_ref (build_scoped_ref (datum
, basetype
),
1927 return error_mark_node
;
1930 /* Like `build_component_ref, but uses an already found field, and converts
1931 from a reference. Must compute access for current_class_ref.
1935 build_component_ref_1 (datum
, field
, protect
)
1939 return convert_from_reference
1940 (build_component_ref (datum
, field
, NULL_TREE
, protect
));
1943 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1944 can, for example, use as an lvalue. This code used to be in
1945 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1946 expressions, where we're dealing with aggregates. But now it's again only
1947 called from unary_complex_lvalue. The case (in particular) that led to
1948 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1952 rationalize_conditional_expr (code
, t
)
1953 enum tree_code code
;
1956 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1957 the first operand is always the one to be used if both operands
1958 are equal, so we know what conditional expression this used to be. */
1959 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1962 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1963 ? LE_EXPR
: GE_EXPR
),
1964 TREE_OPERAND (t
, 0),
1965 TREE_OPERAND (t
, 1)),
1966 build_unary_op (code
, TREE_OPERAND (t
, 0), 0),
1967 build_unary_op (code
, TREE_OPERAND (t
, 1), 0));
1971 build_conditional_expr (TREE_OPERAND (t
, 0),
1972 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1973 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1976 /* Given the TYPE of an anonymous union field inside T, return the
1977 FIELD_DECL for the field. If not found return NULL_TREE. Because
1978 anonymous unions can nest, we must also search all anonymous unions
1979 that are directly reachable. */
1982 lookup_anon_field (t
, type
)
1987 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1989 if (TREE_STATIC (field
))
1991 if (TREE_CODE (field
) != FIELD_DECL
)
1994 /* If we find it directly, return the field. */
1995 if (DECL_NAME (field
) == NULL_TREE
1996 && type
== TYPE_MAIN_VARIANT (TREE_TYPE (field
)))
2001 /* Otherwise, it could be nested, search harder. */
2002 if (DECL_NAME (field
) == NULL_TREE
2003 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2005 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
2013 /* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT.
2014 COMPONENT can be an IDENTIFIER_NODE that is the name of the member
2015 that we are interested in, or it can be a FIELD_DECL. */
2018 build_component_ref (datum
, component
, basetype_path
, protect
)
2019 tree datum
, component
, basetype_path
;
2022 register tree basetype
;
2023 register enum tree_code code
;
2024 register tree field
= NULL
;
2029 if (processing_template_decl
)
2030 return build_min_nt (COMPONENT_REF
, datum
, component
);
2032 if (datum
== error_mark_node
2033 || TREE_TYPE (datum
) == error_mark_node
)
2034 return error_mark_node
;
2036 /* BASETYPE holds the type of the class containing the COMPONENT. */
2037 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2039 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
2041 switch (TREE_CODE (datum
))
2045 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
2046 basetype_path
, protect
);
2047 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2048 TREE_OPERAND (datum
, 0), value
);
2051 return build_conditional_expr
2052 (TREE_OPERAND (datum
, 0),
2053 build_component_ref (TREE_OPERAND (datum
, 1), component
,
2054 basetype_path
, protect
),
2055 build_component_ref (TREE_OPERAND (datum
, 2), component
,
2056 basetype_path
, protect
));
2059 cp_error ("invalid use of %D", datum
);
2060 datum
= error_mark_node
;
2067 code
= TREE_CODE (basetype
);
2069 if (code
== REFERENCE_TYPE
)
2071 datum
= convert_from_reference (datum
);
2072 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2073 code
= TREE_CODE (basetype
);
2075 if (TREE_CODE (datum
) == OFFSET_REF
)
2077 datum
= resolve_offset_ref (datum
);
2078 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2079 code
= TREE_CODE (basetype
);
2082 /* First, see if there is a field or component with name COMPONENT. */
2083 if (TREE_CODE (component
) == TREE_LIST
)
2085 /* I could not trigger this code. MvL */
2086 my_friendly_abort (980326);
2088 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
2089 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
2091 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
2094 if (! IS_AGGR_TYPE_CODE (code
))
2096 if (code
!= ERROR_MARK
)
2097 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
2098 component
, datum
, basetype
);
2099 return error_mark_node
;
2102 if (!complete_type_or_else (basetype
, datum
))
2103 return error_mark_node
;
2105 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
2107 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
2109 cp_error ("destructor specifier `%T::~%T' must have matching names",
2110 basetype
, TREE_OPERAND (component
, 0));
2111 return error_mark_node
;
2113 if (! TYPE_HAS_DESTRUCTOR (basetype
))
2115 cp_error ("type `%T' has no destructor", basetype
);
2116 return error_mark_node
;
2118 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1);
2121 /* Look up component name in the structure type definition. */
2122 if (TYPE_VFIELD (basetype
)
2123 && DECL_NAME (TYPE_VFIELD (basetype
)) == component
)
2124 /* Special-case this because if we use normal lookups in an ambiguous
2125 hierarchy, the compiler will abort (because vptr lookups are
2126 not supposed to be ambiguous. */
2127 field
= TYPE_VFIELD (basetype
);
2128 else if (TREE_CODE (component
) == FIELD_DECL
)
2130 else if (TREE_CODE (component
) == TYPE_DECL
)
2132 cp_error ("invalid use of type decl `%#D' as expression", component
);
2133 return error_mark_node
;
2135 else if (TREE_CODE (component
) == TEMPLATE_DECL
)
2137 cp_error ("invalid use of template `%#D' as expression", component
);
2138 return error_mark_node
;
2142 tree name
= component
;
2143 if (TREE_CODE (component
) == VAR_DECL
)
2144 name
= DECL_NAME (component
);
2145 if (TREE_CODE (component
) == NAMESPACE_DECL
)
2146 /* Source is in error, but produce a sensible diagnostic. */
2147 name
= DECL_NAME (component
);
2148 if (basetype_path
== NULL_TREE
)
2149 basetype_path
= TYPE_BINFO (basetype
);
2150 field
= lookup_field (basetype_path
, name
,
2151 protect
&& !VFIELD_NAME_P (name
), 0);
2152 if (field
== error_mark_node
)
2153 return error_mark_node
;
2155 if (field
== NULL_TREE
)
2157 /* Not found as a data field, look for it as a method. If found,
2158 then if this is the only possible one, return it, else
2159 report ambiguity error. */
2160 tree fndecls
= lookup_fnfields (basetype_path
, name
, 1);
2161 if (fndecls
== error_mark_node
)
2162 return error_mark_node
;
2165 /* If the function is unique and static, we can resolve it
2166 now. Otherwise, we have to wait and see what context it is
2167 used in; a component_ref involving a non-static member
2168 function can only be used in a call (expr.ref). */
2170 if (TREE_CHAIN (fndecls
) == NULL_TREE
2171 && TREE_CODE (TREE_VALUE (fndecls
)) == FUNCTION_DECL
)
2173 if (DECL_STATIC_FUNCTION_P (TREE_VALUE (fndecls
)))
2175 tree fndecl
= TREE_VALUE (fndecls
);
2176 enforce_access (basetype_path
, fndecl
);
2182 /* A unique non-static member function. Other parts
2183 of the compiler expect something with
2184 unknown_type_node to be really overloaded, so
2186 TREE_VALUE (fndecls
)
2187 = ovl_cons (TREE_VALUE (fndecls
), NULL_TREE
);
2191 ref
= build (COMPONENT_REF
, unknown_type_node
,
2192 datum
, TREE_VALUE (fndecls
));
2196 cp_error ("`%#T' has no member named `%D'", basetype
, name
);
2197 return error_mark_node
;
2199 else if (TREE_TYPE (field
) == error_mark_node
)
2200 return error_mark_node
;
2202 if (TREE_CODE (field
) != FIELD_DECL
)
2204 if (TREE_CODE (field
) == TYPE_DECL
)
2205 cp_pedwarn ("invalid use of type decl `%#D' as expression", field
);
2206 else if (DECL_RTL (field
) != 0)
2209 TREE_USED (field
) = 1;
2211 /* Do evaluate the object when accessing a static member. */
2212 if (TREE_SIDE_EFFECTS (datum
))
2213 field
= build (COMPOUND_EXPR
, TREE_TYPE (field
), datum
, field
);
2219 /* See if we have to do any conversions so that we pick up the field from the
2221 if (DECL_FIELD_CONTEXT (field
) != basetype
)
2223 tree context
= DECL_FIELD_CONTEXT (field
);
2224 tree base
= context
;
2225 while (!same_type_p (base
, basetype
) && TYPE_NAME (base
)
2226 && ANON_AGGR_TYPE_P (base
))
2227 base
= TYPE_CONTEXT (base
);
2229 /* Handle base classes here... */
2230 if (base
!= basetype
&& TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
))
2232 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
2233 if (integer_zerop (addr
))
2235 error ("invalid reference to NULL ptr, use ptr-to-member instead");
2236 return error_mark_node
;
2238 if (VBASE_NAME_P (DECL_NAME (field
)))
2240 /* It doesn't matter which vbase pointer we grab, just
2241 find one of them. */
2242 tree binfo
= get_binfo (base
,
2243 TREE_TYPE (TREE_TYPE (addr
)), 0);
2244 addr
= convert_pointer_to_real (binfo
, addr
);
2247 addr
= convert_pointer_to (base
, addr
);
2248 datum
= build_indirect_ref (addr
, NULL_PTR
);
2249 if (datum
== error_mark_node
)
2250 return error_mark_node
;
2254 /* Handle things from anon unions here... */
2255 if (TYPE_NAME (context
) && ANON_AGGR_TYPE_P (context
))
2257 tree subfield
= lookup_anon_field (basetype
, context
);
2258 tree subdatum
= build_component_ref (datum
, subfield
,
2259 basetype_path
, protect
);
2260 return build_component_ref (subdatum
, field
, basetype_path
, protect
);
2264 /* Compute the type of the field, as described in [expr.ref]. */
2265 type_quals
= TYPE_UNQUALIFIED
;
2266 field_type
= TREE_TYPE (field
);
2267 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
2268 /* The standard says that the type of the result should be the
2269 type referred to by the reference. But for now, at least, we
2270 do the conversion from reference type later. */
2274 type_quals
= (CP_TYPE_QUALS (field_type
)
2275 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
2277 /* A field is const (volatile) if the enclosing object, or the
2278 field itself, is const (volatile). But, a mutable field is
2279 not const, even within a const object. */
2280 if (DECL_MUTABLE_P (field
))
2281 type_quals
&= ~TYPE_QUAL_CONST
;
2282 field_type
= cp_build_qualified_type (field_type
, type_quals
);
2285 ref
= fold (build (COMPONENT_REF
, field_type
, datum
, field
));
2287 /* Mark the expression const or volatile, as appropriate. Even
2288 though we've dealt with the type above, we still have to mark the
2289 expression itself. */
2290 if (type_quals
& TYPE_QUAL_CONST
)
2291 TREE_READONLY (ref
) = 1;
2292 else if (type_quals
& TYPE_QUAL_VOLATILE
)
2293 TREE_THIS_VOLATILE (ref
) = 1;
2298 /* Variant of build_component_ref for use in expressions, which should
2299 never have REFERENCE_TYPE. */
2302 build_x_component_ref (datum
, component
, basetype_path
, protect
)
2303 tree datum
, component
, basetype_path
;
2306 tree t
= build_component_ref (datum
, component
, basetype_path
, protect
);
2308 if (! processing_template_decl
)
2309 t
= convert_from_reference (t
);
2314 /* Given an expression PTR for a pointer, return an expression
2315 for the value pointed to.
2316 ERRORSTRING is the name of the operator to appear in error messages.
2318 This function may need to overload OPERATOR_FNNAME.
2319 Must also handle REFERENCE_TYPEs for C++. */
2322 build_x_indirect_ref (ptr
, errorstring
)
2324 const char *errorstring
;
2328 if (processing_template_decl
)
2329 return build_min_nt (INDIRECT_REF
, ptr
);
2331 rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
,
2335 return build_indirect_ref (ptr
, errorstring
);
2339 build_indirect_ref (ptr
, errorstring
)
2341 const char *errorstring
;
2343 register tree pointer
, type
;
2345 if (ptr
== error_mark_node
)
2346 return error_mark_node
;
2348 if (ptr
== current_class_ptr
)
2349 return current_class_ref
;
2351 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2352 ? ptr
: default_conversion (ptr
));
2353 type
= TREE_TYPE (pointer
);
2355 if (TYPE_PTR_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
2359 If the type of the expression is "pointer to T," the type
2360 of the result is "T."
2362 We must use the canonical variant because certain parts of
2363 the back end, like fold, do pointer comparisons between
2365 tree t
= canonical_type_variant (TREE_TYPE (type
));
2367 if (VOID_TYPE_P (t
))
2369 /* A pointer to incomplete type (other than cv void) can be
2370 dereferenced [expr.unary.op]/1 */
2371 cp_error ("`%T' is not a pointer-to-object type", type
);
2372 return error_mark_node
;
2374 else if (TREE_CODE (pointer
) == ADDR_EXPR
2376 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
2377 /* The POINTER was something like `&x'. We simplify `*&x' to
2379 return TREE_OPERAND (pointer
, 0);
2382 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
2384 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2385 so that we get the proper error message if the result is used
2386 to assign to. Also, &* is supposed to be a no-op. */
2387 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
2388 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
2389 TREE_SIDE_EFFECTS (ref
)
2390 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
)
2395 /* `pointer' won't be an error_mark_node if we were given a
2396 pointer to member, so it's cool to check for this here. */
2397 else if (TYPE_PTRMEM_P (type
) || TYPE_PTRMEMFUNC_P (type
))
2398 error ("invalid use of `%s' on pointer to member", errorstring
);
2399 else if (pointer
!= error_mark_node
)
2402 error ("invalid type argument of `%s'", errorstring
);
2404 error ("invalid type argument");
2406 return error_mark_node
;
2409 /* This handles expressions of the form "a[i]", which denotes
2412 This is logically equivalent in C to *(a+i), but we may do it differently.
2413 If A is a variable or a member, we generate a primitive ARRAY_REF.
2414 This avoids forcing the array out of registers, and can work on
2415 arrays that are not lvalues (for example, members of structures returned
2418 If INDEX is of some user-defined type, it must be converted to
2419 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2420 will inherit the type of the array, which will be some pointer type. */
2423 build_array_ref (array
, idx
)
2428 error ("subscript missing in array reference");
2429 return error_mark_node
;
2432 if (TREE_TYPE (array
) == error_mark_node
2433 || TREE_TYPE (idx
) == error_mark_node
)
2434 return error_mark_node
;
2436 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
2437 && TREE_CODE (array
) != INDIRECT_REF
)
2441 /* Subscripting with type char is likely to lose
2442 on a machine where chars are signed.
2443 So warn on any machine, but optionally.
2444 Don't warn for unsigned char since that type is safe.
2445 Don't warn for signed char because anyone who uses that
2446 must have done so deliberately. */
2447 if (warn_char_subscripts
2448 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
2449 warning ("array subscript has type `char'");
2451 /* Apply default promotions *after* noticing character types. */
2452 idx
= default_conversion (idx
);
2454 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
2456 error ("array subscript is not an integer");
2457 return error_mark_node
;
2460 /* An array that is indexed by a non-constant
2461 cannot be stored in a register; we must be able to do
2462 address arithmetic on its address.
2463 Likewise an array of elements of variable size. */
2464 if (TREE_CODE (idx
) != INTEGER_CST
2465 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
2466 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2469 if (mark_addressable (array
) == 0)
2470 return error_mark_node
;
2472 /* An array that is indexed by a constant value which is not within
2473 the array bounds cannot be stored in a register either; because we
2474 would get a crash in store_bit_field/extract_bit_field when trying
2475 to access a non-existent part of the register. */
2476 if (TREE_CODE (idx
) == INTEGER_CST
2477 && TYPE_VALUES (TREE_TYPE (array
))
2478 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
2480 if (mark_addressable (array
) == 0)
2481 return error_mark_node
;
2484 if (pedantic
&& !lvalue_p (array
))
2485 pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2487 /* Note in C++ it is valid to subscript a `register' array, since
2488 it is valid to take the address of something with that
2489 storage specification. */
2493 while (TREE_CODE (foo
) == COMPONENT_REF
)
2494 foo
= TREE_OPERAND (foo
, 0);
2495 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2496 warning ("subscripting array declared `register'");
2499 type
= TREE_TYPE (TREE_TYPE (array
));
2500 rval
= build (ARRAY_REF
, type
, array
, idx
);
2501 /* Array ref is const/volatile if the array elements are
2502 or if the array is.. */
2503 TREE_READONLY (rval
)
2504 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
2505 TREE_SIDE_EFFECTS (rval
)
2506 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
2507 TREE_THIS_VOLATILE (rval
)
2508 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
2509 return require_complete_type (fold (rval
));
2513 tree ar
= default_conversion (array
);
2514 tree ind
= default_conversion (idx
);
2516 /* Put the integer in IND to simplify error checking. */
2517 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2524 if (ar
== error_mark_node
)
2527 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2529 error ("subscripted value is neither array nor pointer");
2530 return error_mark_node
;
2532 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2534 error ("array subscript is not an integer");
2535 return error_mark_node
;
2538 return build_indirect_ref (cp_build_binary_op (PLUS_EXPR
, ar
, ind
),
2543 /* Build a function call to function FUNCTION with parameters PARAMS.
2544 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2545 TREE_VALUE of each node is a parameter-expression. The PARAMS do
2546 not include any object pointer that may be required. FUNCTION's
2547 data type may be a function type or a pointer-to-function.
2549 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2550 is the list of possible methods that FUNCTION could conceivably
2551 be. If the list of methods comes from a class, then it will be
2552 a list of lists (where each element is associated with the class
2553 that produced it), otherwise it will be a simple list (for
2554 functions overloaded in global scope).
2556 In the first case, TREE_VALUE (function) is the head of one of those
2557 lists, and TREE_PURPOSE is the name of the function.
2559 In the second case, TREE_PURPOSE (function) is the function's
2562 DECL is the class instance variable, usually CURRENT_CLASS_REF.
2564 When calling a TEMPLATE_DECL, we don't require a complete return
2568 build_x_function_call (function
, params
, decl
)
2569 tree function
, params
, decl
;
2572 tree template_id
= NULL_TREE
;
2575 if (function
== error_mark_node
)
2576 return error_mark_node
;
2578 if (processing_template_decl
)
2579 return build_min_nt (CALL_EXPR
, function
, params
, NULL_TREE
);
2581 /* Save explicit template arguments if found */
2582 if (TREE_CODE (function
) == TEMPLATE_ID_EXPR
)
2584 template_id
= function
;
2585 function
= TREE_OPERAND (function
, 0);
2588 type
= TREE_TYPE (function
);
2590 if (TREE_CODE (type
) == OFFSET_TYPE
2591 && TREE_TYPE (type
) == unknown_type_node
2592 && TREE_CODE (function
) == TREE_LIST
2593 && TREE_CHAIN (function
) == NULL_TREE
)
2595 /* Undo (Foo:bar)()... */
2596 type
= TYPE_OFFSET_BASETYPE (type
);
2597 function
= TREE_VALUE (function
);
2598 my_friendly_assert (TREE_CODE (function
) == TREE_LIST
, 999);
2599 my_friendly_assert (TREE_CHAIN (function
) == NULL_TREE
, 999);
2600 function
= TREE_VALUE (function
);
2601 if (TREE_CODE (function
) == OVERLOAD
)
2602 function
= OVL_FUNCTION (function
);
2603 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 999);
2604 function
= DECL_NAME (function
);
2605 return build_method_call (decl
, function
, params
,
2606 TYPE_BINFO (type
), LOOKUP_NORMAL
);
2609 if (TREE_CODE (function
) == OFFSET_REF
2610 && TREE_CODE (type
) != METHOD_TYPE
)
2611 function
= resolve_offset_ref (function
);
2613 if ((TREE_CODE (function
) == FUNCTION_DECL
2614 && DECL_STATIC_FUNCTION_P (function
))
2615 || (DECL_FUNCTION_TEMPLATE_P (function
)
2616 && DECL_STATIC_FUNCTION_P (DECL_TEMPLATE_RESULT (function
))))
2617 return build_member_call (DECL_CONTEXT (function
),
2619 ? template_id
: DECL_NAME (function
),
2622 is_method
= ((TREE_CODE (function
) == TREE_LIST
2623 && current_class_type
!= NULL_TREE
2624 && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
))
2626 || (TREE_CODE (function
) == OVERLOAD
2627 && DECL_FUNCTION_MEMBER_P (OVL_CURRENT (function
)))
2628 || TREE_CODE (function
) == IDENTIFIER_NODE
2629 || TREE_CODE (type
) == METHOD_TYPE
2630 || TYPE_PTRMEMFUNC_P (type
));
2632 /* A friend template. Make it look like a toplevel declaration. */
2633 if (! is_method
&& TREE_CODE (function
) == TEMPLATE_DECL
)
2634 function
= ovl_cons (function
, NULL_TREE
);
2636 /* Handle methods, friends, and overloaded functions, respectively. */
2639 tree basetype
= NULL_TREE
;
2641 if (TREE_CODE (function
) == OVERLOAD
)
2642 function
= OVL_CURRENT (function
);
2644 if (TREE_CODE (function
) == FUNCTION_DECL
2645 || DECL_FUNCTION_TEMPLATE_P (function
))
2647 basetype
= DECL_CONTEXT (function
);
2649 if (DECL_NAME (function
))
2650 function
= DECL_NAME (function
);
2652 function
= TYPE_IDENTIFIER (DECL_CONTEXT (function
));
2654 else if (TREE_CODE (function
) == TREE_LIST
)
2656 my_friendly_assert (TREE_CODE (TREE_VALUE (function
))
2657 == FUNCTION_DECL
, 312);
2658 basetype
= DECL_CONTEXT (TREE_VALUE (function
));
2659 function
= TREE_PURPOSE (function
);
2661 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2663 if (TREE_CODE (function
) == OFFSET_REF
)
2665 if (TREE_OPERAND (function
, 0))
2666 decl
= TREE_OPERAND (function
, 0);
2668 /* Call via a pointer to member function. */
2669 if (decl
== NULL_TREE
)
2671 error ("pointer to member function called, but not in class scope");
2672 return error_mark_node
;
2674 /* What other type of POINTER_TYPE could this be? */
2675 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2676 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2677 && TREE_CODE (function
) != OFFSET_REF
)
2678 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
,
2683 /* this is an abbreviated method call.
2684 must go through here in case it is a virtual function.
2685 @@ Perhaps this could be optimized. */
2687 if (basetype
&& (! current_class_type
2688 || ! DERIVED_FROM_P (basetype
, current_class_type
)))
2689 return build_member_call (basetype
, function
, params
);
2691 if (decl
== NULL_TREE
)
2693 if (current_class_type
== NULL_TREE
)
2695 cp_error ("object missing in call to method `%D'", function
);
2696 return error_mark_node
;
2698 /* Yow: call from a static member function. */
2699 decl
= build_dummy_object (current_class_type
);
2702 /* Put back explicit template arguments, if any. */
2704 function
= template_id
;
2705 return build_method_call (decl
, function
, params
,
2706 NULL_TREE
, LOOKUP_NORMAL
);
2708 else if (TREE_CODE (function
) == COMPONENT_REF
2709 && type
== unknown_type_node
)
2711 /* Undo what we did in build_component_ref. */
2712 decl
= TREE_OPERAND (function
, 0);
2713 function
= TREE_OPERAND (function
, 1);
2714 function
= DECL_NAME (OVL_CURRENT (function
));
2718 TREE_OPERAND (template_id
, 0) = function
;
2719 function
= template_id
;
2722 return build_method_call (decl
, function
, params
,
2723 NULL_TREE
, LOOKUP_NORMAL
);
2725 else if (really_overloaded_fn (function
))
2727 if (OVL_FUNCTION (function
) == NULL_TREE
)
2729 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2730 TREE_PURPOSE (function
));
2731 return error_mark_node
;
2735 /* Put back explicit template arguments, if any. */
2737 function
= template_id
;
2738 return build_new_function_call (function
, params
);
2742 /* Remove a potential OVERLOAD around it */
2743 function
= OVL_CURRENT (function
);
2746 if (TREE_CODE (function
) == OFFSET_REF
)
2748 /* If the component is a data element (or a virtual function), we play
2749 games here to make things work. */
2752 if (TREE_OPERAND (function
, 0))
2753 decl
= TREE_OPERAND (function
, 0);
2755 decl
= current_class_ref
;
2757 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2759 /* Sigh. OFFSET_REFs are being used for too many things.
2760 They're being used both for -> and ->*, and we want to resolve
2761 the -> cases here, but leave the ->*. We could use
2762 resolve_offset_ref for those, too, but it would call
2763 get_member_function_from_ptrfunc and decl_addr wouldn't get
2764 updated properly. Nasty. */
2765 if (TREE_CODE (TREE_OPERAND (function
, 1)) == FIELD_DECL
)
2766 function
= resolve_offset_ref (function
);
2768 function
= TREE_OPERAND (function
, 1);
2770 function
= get_member_function_from_ptrfunc (&decl_addr
, function
);
2771 params
= tree_cons (NULL_TREE
, decl_addr
, params
);
2772 return build_function_call (function
, params
);
2775 type
= TREE_TYPE (function
);
2776 if (type
!= error_mark_node
)
2778 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2779 type
= TREE_TYPE (type
);
2781 if (IS_AGGR_TYPE (type
))
2782 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2787 tree fntype
= TREE_TYPE (function
);
2788 tree ctypeptr
= NULL_TREE
;
2790 /* Explicitly named method? */
2791 if (TREE_CODE (function
) == FUNCTION_DECL
)
2792 ctypeptr
= build_pointer_type (DECL_CLASS_CONTEXT (function
));
2793 /* Expression with ptr-to-method type? It could either be a plain
2794 usage, or it might be a case where the ptr-to-method is being
2795 passed in as an argument. */
2796 else if (TYPE_PTRMEMFUNC_P (fntype
))
2798 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE
2799 (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2800 ctypeptr
= build_pointer_type (rec
);
2802 /* Unexpected node type? */
2804 my_friendly_abort (116);
2805 if (decl
== NULL_TREE
)
2807 if (current_function_decl
2808 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2809 error ("invalid call to member function needing `this' in static member function scope");
2811 error ("pointer to member function called, but not in class scope");
2812 return error_mark_node
;
2814 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2815 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2817 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2818 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2821 decl
= build_c_cast (ctypeptr
, decl
);
2822 params
= tree_cons (NULL_TREE
, decl
, params
);
2825 return build_function_call (function
, params
);
2828 /* Resolve a pointer to member function. INSTANCE is the object
2829 instance to use, if the member points to a virtual member. */
2832 get_member_function_from_ptrfunc (instance_ptrptr
, function
)
2833 tree
*instance_ptrptr
;
2836 if (TREE_CODE (function
) == OFFSET_REF
)
2838 function
= TREE_OPERAND (function
, 1);
2841 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2843 tree fntype
, idx
, e1
, delta
, delta2
, e2
, e3
, aref
, vtbl
;
2844 tree instance
, basetype
;
2846 tree instance_ptr
= *instance_ptrptr
;
2848 if (instance_ptr
== error_mark_node
2849 && TREE_CODE (function
) == PTRMEM_CST
)
2851 /* Extracting the function address from a pmf is only
2852 allowed with -Wno-pmf-conversions. It only works for
2854 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
));
2855 e1
= convert (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
)), e1
);
2859 if (TREE_SIDE_EFFECTS (instance_ptr
))
2860 instance_ptr
= save_expr (instance_ptr
);
2862 if (TREE_SIDE_EFFECTS (function
))
2863 function
= save_expr (function
);
2865 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2866 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2868 /* Convert down to the right base, before using the instance. */
2869 instance
= convert_pointer_to_real (basetype
, instance_ptr
);
2870 if (instance
== error_mark_node
&& instance_ptr
!= error_mark_node
)
2873 e3
= PFN_FROM_PTRMEMFUNC (function
);
2875 /* This used to avoid checking for virtual functions if basetype
2876 has no virtual functions, according to an earlier ANSI draft.
2877 With the final ISO C++ rules, such an optimization is
2878 incorrect: A pointer to a derived member can be static_cast
2879 to pointer-to-base-member, as long as the dynamic object
2880 later has the right member. */
2882 /* Promoting idx before saving it improves performance on RISC
2883 targets. Without promoting, the first compare used
2884 load-with-sign-extend, while the second used normal load then
2885 shift to sign-extend. An optimizer flaw, perhaps, but it's
2886 easier to make this change. */
2887 idx
= cp_build_binary_op (TRUNC_DIV_EXPR
,
2888 build1 (NOP_EXPR
, vtable_index_type
, e3
),
2889 TYPE_SIZE_UNIT (vtable_entry_type
));
2890 e1
= cp_build_binary_op (BIT_AND_EXPR
,
2891 build1 (NOP_EXPR
, vtable_index_type
, e3
),
2894 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2895 delta
= cp_convert (ptrdiff_type_node
,
2896 build_component_ref (function
, delta_identifier
,
2898 /* DELTA2 is the amount by which to adjust the `this' pointer
2899 to find the vtbl. */
2903 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2904 vtbl
, cp_convert (ptrdiff_type_node
, delta2
));
2905 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2906 aref
= build_array_ref (vtbl
, idx
);
2908 if (! flag_vtable_thunks
)
2910 aref
= save_expr (aref
);
2912 delta
= cp_build_binary_op
2914 build_conditional_expr (e1
,
2915 build_component_ref (aref
,
2922 if (flag_vtable_thunks
)
2925 e2
= build_component_ref (aref
, pfn_identifier
, NULL_TREE
, 0);
2926 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2927 e1
= build_conditional_expr (e1
, e2
, e3
);
2929 /* Make sure this doesn't get evaluated first inside one of the
2930 branches of the COND_EXPR. */
2931 if (TREE_CODE (instance_ptr
) == SAVE_EXPR
)
2932 e1
= build (COMPOUND_EXPR
, TREE_TYPE (e1
),
2935 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2936 instance_ptr
, delta
);
2938 if (instance_ptr
== error_mark_node
2939 && TREE_CODE (e1
) != ADDR_EXPR
2940 && TREE_CODE (TREE_OPERAND (e1
, 0)) != FUNCTION_DECL
)
2941 cp_error ("object missing in `%E'", function
);
2949 build_function_call_real (function
, params
, require_complete
, flags
)
2950 tree function
, params
;
2951 int require_complete
, flags
;
2953 register tree fntype
, fndecl
;
2954 register tree value_type
;
2955 register tree coerced_params
;
2957 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2960 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2961 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2962 if (TREE_CODE (function
) == NOP_EXPR
2963 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2964 function
= TREE_OPERAND (function
, 0);
2966 if (TREE_CODE (function
) == FUNCTION_DECL
)
2968 name
= DECL_NAME (function
);
2969 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2971 GNU_xref_call (current_function_decl
,
2972 IDENTIFIER_POINTER (name
? name
2973 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
2975 mark_used (function
);
2978 /* Convert anything with function type to a pointer-to-function. */
2979 if (pedantic
&& DECL_MAIN_P (function
))
2980 pedwarn ("ISO C++ forbids calling `::main' from within program");
2982 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2983 (because calling an inline function does not mean the function
2984 needs to be separately compiled). */
2986 if (DECL_INLINE (function
))
2987 function
= inline_conversion (function
);
2989 function
= build_addr_func (function
);
2995 function
= build_addr_func (function
);
2998 if (function
== error_mark_node
)
2999 return error_mark_node
;
3001 fntype
= TREE_TYPE (function
);
3003 if (TYPE_PTRMEMFUNC_P (fntype
))
3005 cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
3007 return error_mark_node
;
3010 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
3011 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
3013 if (!((TREE_CODE (fntype
) == POINTER_TYPE
3014 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
3016 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
3018 cp_error ("`%E' cannot be used as a function", function
);
3019 return error_mark_node
;
3022 /* fntype now gets the type of function pointed to. */
3023 fntype
= TREE_TYPE (fntype
);
3025 /* Convert the parameters to the types declared in the
3026 function prototype, or apply default promotions. */
3028 if (flags
& LOOKUP_COMPLAIN
)
3029 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
3030 params
, fndecl
, LOOKUP_NORMAL
);
3032 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
3035 if (coerced_params
== error_mark_node
)
3037 if (flags
& LOOKUP_SPECULATIVELY
)
3040 return error_mark_node
;
3043 /* Check for errors in format strings. */
3045 if (warn_format
&& (name
|| assembler_name
))
3046 check_function_format (NULL
, name
, assembler_name
, coerced_params
);
3048 /* Recognize certain built-in functions so we can make tree-codes
3049 other than CALL_EXPR. We do this when it enables fold-const.c
3050 to do something useful. */
3052 if (TREE_CODE (function
) == ADDR_EXPR
3053 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
3054 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
3056 result
= expand_tree_builtin (TREE_OPERAND (function
, 0),
3057 params
, coerced_params
);
3062 /* Some built-in function calls will be evaluated at
3063 compile-time in fold (). */
3064 result
= fold (build_call (function
, coerced_params
));
3065 value_type
= TREE_TYPE (result
);
3067 if (require_complete
)
3069 if (TREE_CODE (value_type
) == VOID_TYPE
)
3071 result
= require_complete_type (result
);
3073 if (IS_AGGR_TYPE (value_type
))
3074 result
= build_cplus_new (value_type
, result
);
3075 return convert_from_reference (result
);
3079 build_function_call (function
, params
)
3080 tree function
, params
;
3082 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
3085 /* Convert the actual parameter expressions in the list VALUES
3086 to the types in the list TYPELIST.
3087 If parmdecls is exhausted, or when an element has NULL as its type,
3088 perform the default conversions.
3090 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
3092 This is also where warnings about wrong number of args are generated.
3094 Return a list of expressions for the parameters as converted.
3096 Both VALUES and the returned value are chains of TREE_LIST nodes
3097 with the elements of the list in the TREE_VALUE slots of those nodes.
3099 In C++, unspecified trailing parameters can be filled in with their
3100 default arguments, if such were specified. Do so here. */
3103 convert_arguments (typelist
, values
, fndecl
, flags
)
3104 tree typelist
, values
, fndecl
;
3107 register tree typetail
, valtail
;
3108 register tree result
= NULL_TREE
;
3109 const char *called_thing
= 0;
3112 /* Argument passing is always copy-initialization. */
3113 flags
|= LOOKUP_ONLYCONVERTING
;
3117 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
3119 if (DECL_NAME (fndecl
) == NULL_TREE
3120 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
3121 called_thing
= "constructor";
3123 called_thing
= "member function";
3126 called_thing
= "function";
3129 for (valtail
= values
, typetail
= typelist
;
3131 valtail
= TREE_CHAIN (valtail
), i
++)
3133 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
3134 register tree val
= TREE_VALUE (valtail
);
3136 if (val
== error_mark_node
)
3137 return error_mark_node
;
3139 if (type
== void_type_node
)
3143 cp_error_at ("too many arguments to %s `%+#D'", called_thing
,
3145 error ("at this point in file");
3148 error ("too many arguments to function");
3149 /* In case anybody wants to know if this argument
3152 TREE_TYPE (tree_last (result
)) = error_mark_node
;
3156 if (TREE_CODE (val
) == OFFSET_REF
)
3157 val
= resolve_offset_ref (val
);
3159 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3160 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3161 if (TREE_CODE (val
) == NOP_EXPR
3162 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3163 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3164 val
= TREE_OPERAND (val
, 0);
3166 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3168 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3169 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3170 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3171 val
= default_conversion (val
);
3174 if (val
== error_mark_node
)
3175 return error_mark_node
;
3179 /* Formal parm type is specified by a function prototype. */
3182 if (!COMPLETE_TYPE_P (complete_type (type
)))
3184 error ("parameter type of called function is incomplete");
3189 parmval
= convert_for_initialization
3190 (NULL_TREE
, type
, val
, flags
,
3191 "argument passing", fndecl
, i
);
3192 if (PROMOTE_PROTOTYPES
3193 && (TREE_CODE (type
) == INTEGER_TYPE
3194 || TREE_CODE (type
) == ENUMERAL_TYPE
)
3195 && (TYPE_PRECISION (type
)
3196 < TYPE_PRECISION (integer_type_node
)))
3197 parmval
= default_conversion (parmval
);
3200 if (parmval
== error_mark_node
)
3201 return error_mark_node
;
3203 result
= tree_cons (NULL_TREE
, parmval
, result
);
3207 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
3208 val
= convert_from_reference (val
);
3210 result
= tree_cons (NULL_TREE
,
3211 convert_arg_to_ellipsis (val
),
3216 typetail
= TREE_CHAIN (typetail
);
3219 if (typetail
!= 0 && typetail
!= void_list_node
)
3221 /* See if there are default arguments that can be used */
3222 if (TREE_PURPOSE (typetail
))
3224 for (; typetail
!= void_list_node
; ++i
)
3227 = convert_default_arg (TREE_VALUE (typetail
),
3228 TREE_PURPOSE (typetail
),
3231 if (parmval
== error_mark_node
)
3232 return error_mark_node
;
3234 result
= tree_cons (0, parmval
, result
);
3235 typetail
= TREE_CHAIN (typetail
);
3236 /* ends with `...'. */
3237 if (typetail
== NULL_TREE
)
3245 cp_error_at ("too few arguments to %s `%+#D'",
3246 called_thing
, fndecl
);
3247 error ("at this point in file");
3250 error ("too few arguments to function");
3251 return error_mark_list
;
3255 return nreverse (result
);
3258 /* Build a binary-operation expression, after performing default
3259 conversions on the operands. CODE is the kind of expression to build. */
3262 build_x_binary_op (code
, arg1
, arg2
)
3263 enum tree_code code
;
3266 if (processing_template_decl
)
3267 return build_min_nt (code
, arg1
, arg2
);
3269 return build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
3272 /* Build a binary-operation expression without default conversions.
3273 CODE is the kind of expression to build.
3274 This function differs from `build' in several ways:
3275 the data type of the result is computed and recorded in it,
3276 warnings are generated if arg data types are invalid,
3277 special handling for addition and subtraction of pointers is known,
3278 and some optimization is done (operations on narrow ints
3279 are done in the narrower type when that gives the same result).
3280 Constant folding is also done before the result is returned.
3282 Note that the operands will never have enumeral types
3283 because either they have just had the default conversions performed
3284 or they have both just been converted to some other type in which
3285 the arithmetic is to be done.
3287 C++: must do special pointer arithmetic when implementing
3288 multiple inheritance, and deal with pointer to member functions. */
3291 build_binary_op (code
, orig_op0
, orig_op1
, convert_p
)
3292 enum tree_code code
;
3293 tree orig_op0
, orig_op1
;
3294 int convert_p ATTRIBUTE_UNUSED
;
3297 register enum tree_code code0
, code1
;
3300 /* Expression code to give to the expression when it is built.
3301 Normally this is CODE, which is what the caller asked for,
3302 but in some special cases we change it. */
3303 register enum tree_code resultcode
= code
;
3305 /* Data type in which the computation is to be performed.
3306 In the simplest cases this is the common type of the arguments. */
3307 register tree result_type
= NULL
;
3309 /* Nonzero means operands have already been type-converted
3310 in whatever way is necessary.
3311 Zero means they need to be converted to RESULT_TYPE. */
3314 /* Nonzero means create the expression with this type, rather than
3316 tree build_type
= 0;
3318 /* Nonzero means after finally constructing the expression
3319 convert it to this type. */
3320 tree final_type
= 0;
3322 /* Nonzero if this is an operation like MIN or MAX which can
3323 safely be computed in short if both args are promoted shorts.
3324 Also implies COMMON.
3325 -1 indicates a bitwise operation; this makes a difference
3326 in the exact conditions for when it is safe to do the operation
3327 in a narrower mode. */
3330 /* Nonzero if this is a comparison operation;
3331 if both args are promoted shorts, compare the original shorts.
3332 Also implies COMMON. */
3333 int short_compare
= 0;
3335 /* Nonzero if this is a right-shift operation, which can be computed on the
3336 original short and then promoted if the operand is a promoted short. */
3337 int short_shift
= 0;
3339 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3342 /* Apply default conversions. */
3343 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3344 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3345 || code
== TRUTH_XOR_EXPR
)
3347 op0
= decay_conversion (orig_op0
);
3348 op1
= decay_conversion (orig_op1
);
3352 op0
= default_conversion (orig_op0
);
3353 op1
= default_conversion (orig_op1
);
3356 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3357 STRIP_TYPE_NOPS (op0
);
3358 STRIP_TYPE_NOPS (op1
);
3360 /* DTRT if one side is an overloaded function, but complain about it. */
3361 if (type_unknown_p (op0
))
3363 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, itf_none
);
3364 if (t
!= error_mark_node
)
3366 cp_pedwarn ("assuming cast to type `%T' from overloaded function",
3371 if (type_unknown_p (op1
))
3373 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, itf_none
);
3374 if (t
!= error_mark_node
)
3376 cp_pedwarn ("assuming cast to type `%T' from overloaded function",
3382 type0
= TREE_TYPE (op0
);
3383 type1
= TREE_TYPE (op1
);
3385 /* The expression codes of the data types of the arguments tell us
3386 whether the arguments are integers, floating, pointers, etc. */
3387 code0
= TREE_CODE (type0
);
3388 code1
= TREE_CODE (type1
);
3390 /* If an error was already reported for one of the arguments,
3391 avoid reporting another error. */
3393 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3394 return error_mark_node
;
3399 /* Handle the pointer + int case. */
3400 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3401 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
3402 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
3403 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
3409 /* Subtraction of two similar pointers.
3410 We must subtract them as integers, then divide by object size. */
3411 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3412 && comp_target_types (type0
, type1
, 1))
3413 return pointer_diff (op0
, op1
, common_type (type0
, type1
));
3414 /* Handle pointer minus int. Just like pointer plus int. */
3415 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3416 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
3425 case TRUNC_DIV_EXPR
:
3427 case FLOOR_DIV_EXPR
:
3428 case ROUND_DIV_EXPR
:
3429 case EXACT_DIV_EXPR
:
3430 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3431 || code0
== COMPLEX_TYPE
)
3432 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3433 || code1
== COMPLEX_TYPE
))
3435 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
3436 cp_warning ("division by zero in `%E / 0'", op0
);
3437 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
3438 cp_warning ("division by zero in `%E / 0.'", op0
);
3440 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
3441 resultcode
= RDIV_EXPR
;
3443 /* When dividing two signed integers, we have to promote to int.
3444 unless we divide by a constant != -1. Note that default
3445 conversion will have been performed on the operands at this
3446 point, so we have to dig out the original type to find out if
3448 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3449 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3450 || (TREE_CODE (op1
) == INTEGER_CST
3451 && ! integer_all_onesp (op1
)));
3458 case BIT_ANDTC_EXPR
:
3461 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3463 /* If one operand is a constant, and the other is a short type
3464 that has been converted to an int,
3465 really do the work in the short type and then convert the
3466 result to int. If we are lucky, the constant will be 0 or 1
3467 in the short type, making the entire operation go away. */
3468 if (TREE_CODE (op0
) == INTEGER_CST
3469 && TREE_CODE (op1
) == NOP_EXPR
3470 && (TYPE_PRECISION (type1
)
3471 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3472 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3474 final_type
= result_type
;
3475 op1
= TREE_OPERAND (op1
, 0);
3476 result_type
= TREE_TYPE (op1
);
3478 if (TREE_CODE (op1
) == INTEGER_CST
3479 && TREE_CODE (op0
) == NOP_EXPR
3480 && (TYPE_PRECISION (type0
)
3481 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3482 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3484 final_type
= result_type
;
3485 op0
= TREE_OPERAND (op0
, 0);
3486 result_type
= TREE_TYPE (op0
);
3490 case TRUNC_MOD_EXPR
:
3491 case FLOOR_MOD_EXPR
:
3492 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
3493 cp_warning ("division by zero in `%E %% 0'", op0
);
3494 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
3495 cp_warning ("division by zero in `%E %% 0.'", op0
);
3497 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3499 /* Although it would be tempting to shorten always here, that loses
3500 on some targets, since the modulo instruction is undefined if the
3501 quotient can't be represented in the computation mode. We shorten
3502 only if unsigned or if dividing by something we know != -1. */
3503 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3504 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3505 || (TREE_CODE (op1
) == INTEGER_CST
3506 && ! integer_all_onesp (op1
)));
3511 case TRUTH_ANDIF_EXPR
:
3512 case TRUTH_ORIF_EXPR
:
3513 case TRUTH_AND_EXPR
:
3515 result_type
= boolean_type_node
;
3518 /* Shift operations: result has same type as first operand;
3519 always convert second operand to int.
3520 Also set SHORT_SHIFT if shifting rightward. */
3523 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3525 result_type
= type0
;
3526 if (TREE_CODE (op1
) == INTEGER_CST
)
3528 if (tree_int_cst_lt (op1
, integer_zero_node
))
3529 warning ("right shift count is negative");
3532 if (! integer_zerop (op1
))
3534 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3535 warning ("right shift count >= width of type");
3538 /* Convert the shift-count to an integer, regardless of
3539 size of value being shifted. */
3540 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3541 op1
= cp_convert (integer_type_node
, op1
);
3542 /* Avoid converting op1 to result_type later. */
3548 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3550 result_type
= type0
;
3551 if (TREE_CODE (op1
) == INTEGER_CST
)
3553 if (tree_int_cst_lt (op1
, integer_zero_node
))
3554 warning ("left shift count is negative");
3555 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3556 warning ("left shift count >= width of type");
3558 /* Convert the shift-count to an integer, regardless of
3559 size of value being shifted. */
3560 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3561 op1
= cp_convert (integer_type_node
, op1
);
3562 /* Avoid converting op1 to result_type later. */
3569 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3571 result_type
= type0
;
3572 if (TREE_CODE (op1
) == INTEGER_CST
)
3574 if (tree_int_cst_lt (op1
, integer_zero_node
))
3575 warning ("%s rotate count is negative",
3576 (code
== LROTATE_EXPR
) ? "left" : "right");
3577 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
3578 warning ("%s rotate count >= width of type",
3579 (code
== LROTATE_EXPR
) ? "left" : "right");
3581 /* Convert the shift-count to an integer, regardless of
3582 size of value being shifted. */
3583 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3584 op1
= cp_convert (integer_type_node
, op1
);
3590 if (warn_float_equal
&& (code0
== REAL_TYPE
|| code1
== REAL_TYPE
))
3591 warning ("comparing floating point with == or != is unsafe");
3593 build_type
= boolean_type_node
;
3594 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3595 || code0
== COMPLEX_TYPE
)
3596 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3597 || code1
== COMPLEX_TYPE
))
3599 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3600 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3602 else if (code0
== POINTER_TYPE
&& null_ptr_cst_p (op1
))
3603 result_type
= type0
;
3604 else if (code1
== POINTER_TYPE
&& null_ptr_cst_p (op0
))
3605 result_type
= type1
;
3606 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3608 result_type
= type0
;
3609 error ("ISO C++ forbids comparison between pointer and integer");
3611 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3613 result_type
= type1
;
3614 error ("ISO C++ forbids comparison between pointer and integer");
3616 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (op1
))
3618 op0
= build_component_ref (op0
, pfn_identifier
, NULL_TREE
, 0);
3619 op1
= cp_convert (TREE_TYPE (op0
), integer_zero_node
);
3620 result_type
= TREE_TYPE (op0
);
3622 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (op0
))
3623 return cp_build_binary_op (code
, op1
, op0
);
3624 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3625 && same_type_p (type0
, type1
))
3627 /* E will be the final comparison. */
3629 /* E1 and E2 are for scratch. */
3637 if (TREE_SIDE_EFFECTS (op0
))
3638 op0
= save_expr (op0
);
3639 if (TREE_SIDE_EFFECTS (op1
))
3640 op1
= save_expr (op1
);
3645 && (!op0.pfn || op0.delta == op1.delta))
3647 The reason for the `!op0.pfn' bit is that a NULL
3648 pointer-to-member is any member with a zero PFN; the
3649 DELTA field is unspecified. */
3650 pfn0
= pfn_from_ptrmemfunc (op0
);
3651 pfn1
= pfn_from_ptrmemfunc (op1
);
3652 delta0
= build_component_ref (op0
, delta_identifier
,
3654 delta1
= build_component_ref (op1
, delta_identifier
,
3656 e1
= cp_build_binary_op (EQ_EXPR
, delta0
, delta1
);
3657 e2
= cp_build_binary_op (EQ_EXPR
,
3659 cp_convert (TREE_TYPE (pfn0
),
3660 integer_zero_node
));
3661 e1
= cp_build_binary_op (TRUTH_ORIF_EXPR
, e1
, e2
);
3662 e2
= build (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
3663 e
= cp_build_binary_op (TRUTH_ANDIF_EXPR
, e2
, e1
);
3664 if (code
== EQ_EXPR
)
3666 return cp_build_binary_op (EQ_EXPR
, e
, integer_zero_node
);
3668 else if ((TYPE_PTRMEMFUNC_P (type0
)
3669 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
), type1
))
3670 || (TYPE_PTRMEMFUNC_P (type1
)
3671 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
), type0
)))
3672 my_friendly_abort (20000221);
3677 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3678 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3680 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3681 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3689 build_type
= boolean_type_node
;
3690 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3691 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3693 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3694 result_type
= composite_pointer_type (type0
, type1
, op0
, op1
,
3696 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3697 && integer_zerop (op1
))
3698 result_type
= type0
;
3699 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3700 && integer_zerop (op0
))
3701 result_type
= type1
;
3702 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3704 result_type
= type0
;
3705 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3707 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3709 result_type
= type1
;
3710 pedwarn ("ISO C++ forbids comparison between pointer and integer");
3714 case UNORDERED_EXPR
:
3721 build_type
= integer_type_node
;
3722 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
3724 error ("unordered comparison on non-floating point argument");
3725 return error_mark_node
;
3734 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
3736 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
3738 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
3740 if (shorten
|| common
|| short_compare
)
3741 result_type
= common_type (type0
, type1
);
3743 /* For certain operations (which identify themselves by shorten != 0)
3744 if both args were extended from the same smaller type,
3745 do the arithmetic in that type and then extend.
3747 shorten !=0 and !=1 indicates a bitwise operation.
3748 For them, this optimization is safe only if
3749 both args are zero-extended or both are sign-extended.
3750 Otherwise, we might change the result.
3751 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3752 but calculated in (unsigned short) it would be (unsigned short)-1. */
3754 if (shorten
&& none_complex
)
3756 int unsigned0
, unsigned1
;
3757 tree arg0
= get_narrower (op0
, &unsigned0
);
3758 tree arg1
= get_narrower (op1
, &unsigned1
);
3759 /* UNS is 1 if the operation to be done is an unsigned one. */
3760 int uns
= TREE_UNSIGNED (result_type
);
3763 final_type
= result_type
;
3765 /* Handle the case that OP0 does not *contain* a conversion
3766 but it *requires* conversion to FINAL_TYPE. */
3768 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3769 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3770 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3771 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3773 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3775 /* For bitwise operations, signedness of nominal type
3776 does not matter. Consider only how operands were extended. */
3780 /* Note that in all three cases below we refrain from optimizing
3781 an unsigned operation on sign-extended args.
3782 That would not be valid. */
3784 /* Both args variable: if both extended in same way
3785 from same width, do it in that width.
3786 Do it unsigned if args were zero-extended. */
3787 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3788 < TYPE_PRECISION (result_type
))
3789 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3790 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3791 && unsigned0
== unsigned1
3792 && (unsigned0
|| !uns
))
3794 = signed_or_unsigned_type (unsigned0
,
3795 common_type (TREE_TYPE (arg0
),
3797 else if (TREE_CODE (arg0
) == INTEGER_CST
3798 && (unsigned1
|| !uns
)
3799 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3800 < TYPE_PRECISION (result_type
))
3801 && (type
= signed_or_unsigned_type (unsigned1
,
3803 int_fits_type_p (arg0
, type
)))
3805 else if (TREE_CODE (arg1
) == INTEGER_CST
3806 && (unsigned0
|| !uns
)
3807 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3808 < TYPE_PRECISION (result_type
))
3809 && (type
= signed_or_unsigned_type (unsigned0
,
3811 int_fits_type_p (arg1
, type
)))
3815 /* Shifts can be shortened if shifting right. */
3820 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3822 final_type
= result_type
;
3824 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3825 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3827 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3828 /* We can shorten only if the shift count is less than the
3829 number of bits in the smaller type size. */
3830 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
3831 /* If arg is sign-extended and then unsigned-shifted,
3832 we can simulate this with a signed shift in arg's type
3833 only if the extended result is at least twice as wide
3834 as the arg. Otherwise, the shift could use up all the
3835 ones made by sign-extension and bring in zeros.
3836 We can't optimize that case at all, but in most machines
3837 it never happens because available widths are 2**N. */
3838 && (!TREE_UNSIGNED (final_type
)
3840 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
)))
3841 <= TYPE_PRECISION (result_type
))))
3843 /* Do an unsigned shift if the operand was zero-extended. */
3845 = signed_or_unsigned_type (unsigned_arg
,
3847 /* Convert value-to-be-shifted to that type. */
3848 if (TREE_TYPE (op0
) != result_type
)
3849 op0
= cp_convert (result_type
, op0
);
3854 /* Comparison operations are shortened too but differently.
3855 They identify themselves by setting short_compare = 1. */
3859 /* Don't write &op0, etc., because that would prevent op0
3860 from being kept in a register.
3861 Instead, make copies of the our local variables and
3862 pass the copies by reference, then copy them back afterward. */
3863 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3864 enum tree_code xresultcode
= resultcode
;
3866 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3868 return cp_convert (boolean_type_node
, val
);
3869 op0
= xop0
, op1
= xop1
;
3871 resultcode
= xresultcode
;
3874 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
3875 && warn_sign_compare
)
3877 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
3878 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3880 int unsignedp0
, unsignedp1
;
3881 tree primop0
= get_narrower (op0
, &unsignedp0
);
3882 tree primop1
= get_narrower (op1
, &unsignedp1
);
3884 /* Check for comparison of different enum types. */
3885 if (TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
3886 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
3887 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
3888 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
3890 cp_warning ("comparison between types `%#T' and `%#T'",
3891 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
3894 /* Give warnings for comparisons between signed and unsigned
3895 quantities that may fail. */
3896 /* Do the checking based on the original operand trees, so that
3897 casts will be considered, but default promotions won't be. */
3899 /* Do not warn if the comparison is being done in a signed type,
3900 since the signed type will only be chosen if it can represent
3901 all the values of the unsigned type. */
3902 if (! TREE_UNSIGNED (result_type
))
3904 /* Do not warn if both operands are unsigned. */
3905 else if (op0_signed
== op1_signed
)
3907 /* Do not warn if the signed quantity is an unsuffixed
3908 integer literal (or some static constant expression
3909 involving such literals or a conditional expression
3910 involving such literals) and it is non-negative. */
3911 else if ((op0_signed
&& tree_expr_nonnegative_p (orig_op0
))
3912 || (op1_signed
&& tree_expr_nonnegative_p (orig_op1
)))
3914 /* Do not warn if the comparison is an equality operation,
3915 the unsigned quantity is an integral constant and it does
3916 not use the most significant bit of result_type. */
3917 else if ((resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
3918 && ((op0_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3919 && int_fits_type_p (orig_op1
,
3920 signed_type (result_type
)))
3921 || (op1_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3922 && int_fits_type_p (orig_op0
,
3923 signed_type (result_type
)))))
3926 warning ("comparison between signed and unsigned integer expressions");
3928 /* Warn if two unsigned values are being compared in a size
3929 larger than their original size, and one (and only one) is the
3930 result of a `~' operator. This comparison will always fail.
3932 Also warn if one operand is a constant, and the constant does not
3933 have all bits set that are set in the ~ operand when it is
3936 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3937 ^ (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
3939 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3940 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3941 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3942 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3944 if (host_integerp (primop0
, 0) || host_integerp (primop1
, 0))
3947 HOST_WIDE_INT constant
, mask
;
3951 if (host_integerp (primop0
, 0))
3954 unsignedp
= unsignedp1
;
3955 constant
= tree_low_cst (primop0
, 0);
3960 unsignedp
= unsignedp0
;
3961 constant
= tree_low_cst (primop1
, 0);
3964 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3965 if (bits
< TYPE_PRECISION (result_type
)
3966 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3968 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3969 if ((mask
& constant
) != mask
)
3970 warning ("comparison of promoted ~unsigned with constant");
3973 else if (unsignedp0
&& unsignedp1
3974 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3975 < TYPE_PRECISION (result_type
))
3976 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3977 < TYPE_PRECISION (result_type
)))
3978 warning ("comparison of promoted ~unsigned with unsigned");
3983 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3984 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3985 Then the expression will be built.
3986 It will be given type FINAL_TYPE if that is nonzero;
3987 otherwise, it will be given type RESULT_TYPE. */
3991 cp_error ("invalid operands of types `%T' and `%T' to binary `%O'",
3992 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
3993 return error_mark_node
;
3996 /* Issue warnings about peculiar, but legal, uses of NULL. */
3997 if (/* It's reasonable to use pointer values as operands of &&
3998 and ||, so NULL is no exception. */
3999 !(code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
4000 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
4001 (orig_op0
== null_node
4002 && TREE_CODE (TREE_TYPE (op1
)) != POINTER_TYPE
)
4003 /* Or vice versa. */
4004 || (orig_op1
== null_node
4005 && TREE_CODE (TREE_TYPE (op0
)) != POINTER_TYPE
)
4006 /* Or, both are NULL and the operation was not a comparison. */
4007 || (orig_op0
== null_node
&& orig_op1
== null_node
4008 && code
!= EQ_EXPR
&& code
!= NE_EXPR
)))
4009 /* Some sort of arithmetic operation involving NULL was
4010 performed. Note that pointer-difference and pointer-addition
4011 have already been handled above, and so we don't end up here in
4013 cp_warning ("NULL used in arithmetic");
4017 if (TREE_TYPE (op0
) != result_type
)
4018 op0
= cp_convert (result_type
, op0
);
4019 if (TREE_TYPE (op1
) != result_type
)
4020 op1
= cp_convert (result_type
, op1
);
4022 if (op0
== error_mark_node
|| op1
== error_mark_node
)
4023 return error_mark_node
;
4026 if (build_type
== NULL_TREE
)
4027 build_type
= result_type
;
4030 register tree result
= build (resultcode
, build_type
, op0
, op1
);
4031 register tree folded
;
4033 folded
= fold (result
);
4034 if (folded
== result
)
4035 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4036 if (final_type
!= 0)
4037 return cp_convert (final_type
, folded
);
4042 /* Return a tree for the sum or difference (RESULTCODE says which)
4043 of pointer PTROP and integer INTOP. */
4046 pointer_int_sum (resultcode
, ptrop
, intop
)
4047 enum tree_code resultcode
;
4048 register tree ptrop
, intop
;
4052 register tree result
;
4053 register tree folded
= fold (intop
);
4055 /* The result is a pointer of the same type that is being added. */
4057 register tree result_type
= TREE_TYPE (ptrop
);
4059 if (!complete_type_or_else (result_type
, ptrop
))
4060 return error_mark_node
;
4062 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
4064 if (pedantic
|| warn_pointer_arith
)
4065 pedwarn ("ISO C++ forbids using pointer of type `void *' in pointer arithmetic");
4066 size_exp
= integer_one_node
;
4068 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
4070 if (pedantic
|| warn_pointer_arith
)
4071 pedwarn ("ISO C++ forbids using a pointer-to-function in pointer arithmetic");
4072 size_exp
= integer_one_node
;
4074 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
4076 if (pedantic
|| warn_pointer_arith
)
4077 pedwarn ("ISO C++ forbids using a pointer to member function in pointer arithmetic");
4078 size_exp
= integer_one_node
;
4080 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
4082 if (pedantic
|| warn_pointer_arith
)
4083 pedwarn ("ISO C++ forbids using pointer to a member in pointer arithmetic");
4084 size_exp
= integer_one_node
;
4087 size_exp
= size_in_bytes (complete_type (TREE_TYPE (result_type
)));
4089 /* Needed to make OOPS V2R3 work. */
4091 if (integer_zerop (intop
))
4094 /* If what we are about to multiply by the size of the elements
4095 contains a constant term, apply distributive law
4096 and multiply that constant term separately.
4097 This helps produce common subexpressions. */
4099 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
4100 && ! TREE_CONSTANT (intop
)
4101 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
4102 && TREE_CONSTANT (size_exp
))
4104 enum tree_code subcode
= resultcode
;
4105 if (TREE_CODE (intop
) == MINUS_EXPR
)
4106 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
4107 ptrop
= cp_build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1));
4108 intop
= TREE_OPERAND (intop
, 0);
4111 /* Convert the integer argument to a type the same size as sizetype
4112 so the multiply won't overflow spuriously. */
4114 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
))
4115 intop
= cp_convert (type_for_size (TYPE_PRECISION (sizetype
), 0), intop
);
4117 /* Replace the integer argument with a suitable product by the object size.
4118 Do this multiplication as signed, then convert to the appropriate
4119 pointer type (actually unsigned integral). */
4121 intop
= cp_convert (result_type
,
4122 cp_build_binary_op (MULT_EXPR
, intop
,
4123 cp_convert (TREE_TYPE (intop
),
4126 /* Create the sum or difference. */
4128 result
= build (resultcode
, result_type
, ptrop
, intop
);
4130 folded
= fold (result
);
4131 if (folded
== result
)
4132 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
4136 /* Return a tree for the difference of pointers OP0 and OP1.
4137 The resulting tree has type int. */
4140 pointer_diff (op0
, op1
, ptrtype
)
4141 register tree op0
, op1
;
4142 register tree ptrtype
;
4144 register tree result
, folded
;
4145 tree restype
= ptrdiff_type_node
;
4146 tree target_type
= TREE_TYPE (ptrtype
);
4148 if (!complete_type_or_else (target_type
, NULL_TREE
))
4149 return error_mark_node
;
4151 if (pedantic
|| warn_pointer_arith
)
4153 if (TREE_CODE (target_type
) == VOID_TYPE
)
4154 pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
4155 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
4156 pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
4157 if (TREE_CODE (target_type
) == METHOD_TYPE
)
4158 pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
4159 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
4160 pedwarn ("ISO C++ forbids using pointer to a member in subtraction");
4163 /* First do the subtraction as integers;
4164 then drop through to build the divide operator. */
4166 op0
= cp_build_binary_op (MINUS_EXPR
,
4167 cp_convert (restype
, op0
),
4168 cp_convert (restype
, op1
));
4170 /* This generates an error if op1 is a pointer to an incomplete type. */
4171 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
4172 error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4174 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
4175 || TREE_CODE (target_type
) == FUNCTION_TYPE
4176 || TREE_CODE (target_type
) == METHOD_TYPE
4177 || TREE_CODE (target_type
) == OFFSET_TYPE
)
4179 : size_in_bytes (target_type
));
4181 /* Do the division. */
4183 result
= build (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
4185 folded
= fold (result
);
4186 if (folded
== result
)
4187 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4191 /* Handle the case of taking the address of a COMPONENT_REF.
4192 Called by `build_unary_op'.
4194 ARG is the COMPONENT_REF whose address we want.
4195 ARGTYPE is the pointer type that this address should have. */
4198 build_component_addr (arg
, argtype
)
4201 tree field
= TREE_OPERAND (arg
, 1);
4202 tree basetype
= decl_type_context (field
);
4203 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
4205 my_friendly_assert (TREE_CODE (field
) == FIELD_DECL
, 981018);
4207 if (DECL_C_BIT_FIELD (field
))
4209 cp_error ("attempt to take address of bit-field structure member `%D'",
4211 return error_mark_node
;
4214 if (TREE_CODE (field
) == FIELD_DECL
4215 && TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
))
4217 /* Can't convert directly to ARGTYPE, since that
4218 may have the same pointer type as one of our
4220 rval
= build1 (NOP_EXPR
, argtype
,
4221 convert_pointer_to (basetype
, rval
));
4222 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
4225 /* This conversion is harmless. */
4226 rval
= convert_force (argtype
, rval
, 0);
4228 return fold (build (PLUS_EXPR
, argtype
, rval
,
4229 cp_convert (argtype
, byte_position (field
))));
4232 /* Construct and perhaps optimize a tree representation
4233 for a unary operation. CODE, a tree_code, specifies the operation
4234 and XARG is the operand. */
4237 build_x_unary_op (code
, xarg
)
4238 enum tree_code code
;
4244 if (processing_template_decl
)
4245 return build_min_nt (code
, xarg
, NULL_TREE
);
4247 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
4249 if (code
== ADDR_EXPR
4250 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
4251 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
4252 && !COMPLETE_TYPE_P (TREE_TYPE (xarg
)))
4253 || (TREE_CODE (xarg
) == OFFSET_REF
)))
4254 /* don't look for a function */;
4259 rval
= build_new_op (code
, LOOKUP_NORMAL
, xarg
,
4260 NULL_TREE
, NULL_TREE
);
4261 if (rval
|| code
!= ADDR_EXPR
)
4264 if (code
== ADDR_EXPR
)
4266 if (TREE_CODE (xarg
) == OFFSET_REF
)
4268 ptrmem
= PTRMEM_OK_P (xarg
);
4270 if (!ptrmem
&& !flag_ms_extensions
4271 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
4272 /* A single non-static member, make sure we don't allow a
4273 pointer-to-member. */
4274 xarg
= ovl_cons (TREE_OPERAND (xarg
, 1), NULL_TREE
);
4276 else if (TREE_CODE (xarg
) == TARGET_EXPR
)
4277 warning ("taking address of temporary");
4279 exp
= build_unary_op (code
, xarg
, 0);
4280 if (TREE_CODE (exp
) == ADDR_EXPR
)
4281 PTRMEM_OK_P (exp
) = ptrmem
;
4286 /* Like truthvalue_conversion, but handle pointer-to-member constants, where
4287 a null value is represented by an INTEGER_CST of -1. */
4290 cp_truthvalue_conversion (expr
)
4293 tree type
= TREE_TYPE (expr
);
4294 if (TYPE_PTRMEM_P (type
))
4295 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
4297 return truthvalue_conversion (expr
);
4300 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4303 condition_conversion (expr
)
4307 if (processing_template_decl
)
4309 t
= perform_implicit_conversion (boolean_type_node
, expr
);
4310 t
= fold (build1 (CLEANUP_POINT_EXPR
, boolean_type_node
, t
));
4314 /* C++: Must handle pointers to members.
4316 Perhaps type instantiation should be extended to handle conversion
4317 from aggregates to types we don't yet know we want? (Or are those
4318 cases typically errors which should be reported?)
4320 NOCONVERT nonzero suppresses the default promotions
4321 (such as from short to int). */
4324 build_unary_op (code
, xarg
, noconvert
)
4325 enum tree_code code
;
4329 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4330 register tree arg
= xarg
;
4331 register tree argtype
= 0;
4332 const char *errstring
= NULL
;
4335 if (arg
== error_mark_node
)
4336 return error_mark_node
;
4341 /* This is used for unary plus, because a CONVERT_EXPR
4342 is enough to prevent anybody from looking inside for
4343 associativity, but won't generate any code. */
4344 if (!(arg
= build_expr_type_conversion
4345 (WANT_ARITH
| WANT_ENUM
| WANT_POINTER
, arg
, 1)))
4346 errstring
= "wrong type argument to unary plus";
4350 arg
= default_conversion (arg
);
4351 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
4352 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4357 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4358 errstring
= "wrong type argument to unary minus";
4359 else if (!noconvert
)
4360 arg
= default_conversion (arg
);
4364 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4368 arg
= default_conversion (arg
);
4370 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
4372 errstring
= "wrong type argument to bit-complement";
4373 else if (!noconvert
)
4374 arg
= default_conversion (arg
);
4378 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4379 errstring
= "wrong type argument to abs";
4380 else if (!noconvert
)
4381 arg
= default_conversion (arg
);
4385 /* Conjugating a real value is a no-op, but allow it anyway. */
4386 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4387 errstring
= "wrong type argument to conjugation";
4388 else if (!noconvert
)
4389 arg
= default_conversion (arg
);
4392 case TRUTH_NOT_EXPR
:
4393 arg
= cp_convert (boolean_type_node
, arg
);
4394 val
= invert_truthvalue (arg
);
4395 if (arg
!= error_mark_node
)
4397 errstring
= "in argument to unary !";
4404 if (TREE_CODE (arg
) == COMPLEX_CST
)
4405 return TREE_REALPART (arg
);
4406 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4407 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4412 if (TREE_CODE (arg
) == COMPLEX_CST
)
4413 return TREE_IMAGPART (arg
);
4414 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4415 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4417 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4419 case PREINCREMENT_EXPR
:
4420 case POSTINCREMENT_EXPR
:
4421 case PREDECREMENT_EXPR
:
4422 case POSTDECREMENT_EXPR
:
4423 /* Handle complex lvalues (when permitted)
4424 by reduction to simpler cases. */
4426 val
= unary_complex_lvalue (code
, arg
);
4430 /* Increment or decrement the real part of the value,
4431 and don't change the imaginary part. */
4432 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4436 arg
= stabilize_reference (arg
);
4437 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
4438 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
4439 return build (COMPLEX_EXPR
, TREE_TYPE (arg
),
4440 build_unary_op (code
, real
, 1), imag
);
4443 /* Report invalid types. */
4445 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4448 if (code
== PREINCREMENT_EXPR
)
4449 errstring
="no pre-increment operator for type";
4450 else if (code
== POSTINCREMENT_EXPR
)
4451 errstring
="no post-increment operator for type";
4452 else if (code
== PREDECREMENT_EXPR
)
4453 errstring
="no pre-decrement operator for type";
4455 errstring
="no post-decrement operator for type";
4459 /* Report something read-only. */
4461 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
4462 || TREE_READONLY (arg
))
4463 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4464 || code
== POSTINCREMENT_EXPR
)
4465 ? "increment" : "decrement"),
4470 tree result_type
= TREE_TYPE (arg
);
4472 arg
= get_unwidened (arg
, 0);
4473 argtype
= TREE_TYPE (arg
);
4475 /* ARM $5.2.5 last annotation says this should be forbidden. */
4476 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4477 pedwarn ("ISO C++ forbids %sing an enum",
4478 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4479 ? "increment" : "decrement");
4481 /* Compute the increment. */
4483 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4485 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
4486 tree type
= complete_type (TREE_TYPE (argtype
));
4488 if (!COMPLETE_OR_VOID_TYPE_P (type
))
4489 cp_error ("cannot %s a pointer to incomplete type `%T'",
4490 ((code
== PREINCREMENT_EXPR
4491 || code
== POSTINCREMENT_EXPR
)
4492 ? "increment" : "decrement"), TREE_TYPE (argtype
));
4493 else if ((pedantic
|| warn_pointer_arith
)
4494 && (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
4495 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
))
4496 cp_pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
4497 ((code
== PREINCREMENT_EXPR
4498 || code
== POSTINCREMENT_EXPR
)
4499 ? "increment" : "decrement"), argtype
);
4500 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
4503 inc
= integer_one_node
;
4505 inc
= cp_convert (argtype
, inc
);
4507 /* Handle incrementing a cast-expression. */
4509 switch (TREE_CODE (arg
))
4514 case FIX_TRUNC_EXPR
:
4515 case FIX_FLOOR_EXPR
:
4516 case FIX_ROUND_EXPR
:
4519 tree incremented
, modify
, value
, compound
;
4520 if (! lvalue_p (arg
) && pedantic
)
4521 pedwarn ("cast to non-reference type used as lvalue");
4522 arg
= stabilize_reference (arg
);
4523 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4526 value
= save_expr (arg
);
4527 incremented
= build (((code
== PREINCREMENT_EXPR
4528 || code
== POSTINCREMENT_EXPR
)
4529 ? PLUS_EXPR
: MINUS_EXPR
),
4530 argtype
, value
, inc
);
4532 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4533 compound
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4535 /* Eliminate warning about unused result of + or -. */
4536 TREE_NO_UNUSED_WARNING (compound
) = 1;
4544 /* Complain about anything else that is not a true lvalue. */
4545 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4546 || code
== POSTINCREMENT_EXPR
)
4547 ? "increment" : "decrement")))
4548 return error_mark_node
;
4550 /* Forbid using -- on `bool'. */
4551 if (TREE_TYPE (arg
) == boolean_type_node
)
4553 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4555 cp_error ("invalid use of `--' on bool variable `%D'", arg
);
4556 return error_mark_node
;
4559 /* This will only work if someone can convince Kenner to accept
4560 my patch to expand_increment. (jason) */
4561 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4563 val
= boolean_increment (code
, arg
);
4567 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4569 TREE_SIDE_EFFECTS (val
) = 1;
4570 return cp_convert (result_type
, val
);
4574 /* Note that this operation never does default_conversion
4575 regardless of NOCONVERT. */
4577 argtype
= lvalue_type (arg
);
4578 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4582 build_pointer_type (TREE_TYPE (argtype
)), arg
);
4583 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4586 else if (pedantic
&& DECL_MAIN_P (arg
))
4588 pedwarn ("ISO C++ forbids taking address of function `::main'");
4590 /* Let &* cancel out to simplify resulting code. */
4591 if (TREE_CODE (arg
) == INDIRECT_REF
)
4593 /* We don't need to have `current_class_ptr' wrapped in a
4594 NON_LVALUE_EXPR node. */
4595 if (arg
== current_class_ref
)
4596 return current_class_ptr
;
4598 arg
= TREE_OPERAND (arg
, 0);
4599 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4603 build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4604 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4606 else if (lvalue_p (arg
))
4607 /* Don't let this be an lvalue. */
4608 return non_lvalue (arg
);
4612 /* For &x[y], return x+y */
4613 if (TREE_CODE (arg
) == ARRAY_REF
)
4615 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4616 return error_mark_node
;
4617 return cp_build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4618 TREE_OPERAND (arg
, 1));
4621 /* Uninstantiated types are all functions. Taking the
4622 address of a function is a no-op, so just return the
4625 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4626 && IDENTIFIER_OPNAME_P (arg
))
4628 my_friendly_abort (117);
4629 /* We don't know the type yet, so just work around the problem.
4630 We know that this will resolve to an lvalue. */
4631 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4634 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
4635 && OVL_NEXT (TREE_OPERAND (arg
, 1)) == NULL_TREE
)
4637 /* They're trying to take the address of a unique non-static
4638 member function. This is ill-formed (except in MS-land),
4639 but let's try to DTRT.
4640 Note: We only handle unique functions here because we don't
4641 want to complain if there's a static overload; non-unique
4642 cases will be handled by instantiate_type. But we need to
4643 handle this case here to allow casts on the resulting PMF.
4644 We could defer this in non-MS mode, but it's easier to give
4645 a useful error here. */
4647 tree base
= TREE_TYPE (TREE_OPERAND (arg
, 0));
4648 tree name
= DECL_NAME (OVL_CURRENT (TREE_OPERAND (arg
, 1)));
4650 if (! flag_ms_extensions
)
4652 if (current_class_type
4653 && TREE_OPERAND (arg
, 0) == current_class_ref
)
4654 /* An expression like &memfn. */
4655 cp_pedwarn ("ISO C++ forbids taking the address of an unqualified non-static member function to form a pointer to member function. Say `&%T::%D'", base
, name
);
4657 cp_pedwarn ("ISO C++ forbids taking the address of a bound member function to form a pointer to member function. Say `&%T::%D'", base
, name
);
4659 arg
= build_offset_ref (base
, name
);
4662 if (type_unknown_p (arg
))
4663 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4665 /* Handle complex lvalues (when permitted)
4666 by reduction to simpler cases. */
4667 val
= unary_complex_lvalue (code
, arg
);
4671 switch (TREE_CODE (arg
))
4676 case FIX_TRUNC_EXPR
:
4677 case FIX_FLOOR_EXPR
:
4678 case FIX_ROUND_EXPR
:
4680 if (! lvalue_p (arg
) && pedantic
)
4681 pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4688 /* Allow the address of a constructor if all the elements
4690 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (arg
)
4691 && TREE_CONSTANT (arg
))
4693 /* Anything not already handled and not a true memory reference
4695 else if (TREE_CODE (argtype
) != FUNCTION_TYPE
4696 && TREE_CODE (argtype
) != METHOD_TYPE
4697 && !lvalue_or_else (arg
, "unary `&'"))
4698 return error_mark_node
;
4700 if (argtype
!= error_mark_node
)
4701 argtype
= build_pointer_type (argtype
);
4703 if (mark_addressable (arg
) == 0)
4704 return error_mark_node
;
4709 if (TREE_CODE (arg
) == COMPONENT_REF
)
4710 addr
= build_component_addr (arg
, argtype
);
4712 addr
= build1 (ADDR_EXPR
, argtype
, arg
);
4714 /* Address of a static or external variable or
4715 function counts as a constant */
4717 TREE_CONSTANT (addr
) = 1;
4719 if (TREE_CODE (argtype
) == POINTER_TYPE
4720 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4722 build_ptrmemfunc_type (argtype
);
4723 addr
= build_ptrmemfunc (argtype
, addr
, 0);
4736 argtype
= TREE_TYPE (arg
);
4737 return fold (build1 (code
, argtype
, arg
));
4740 error ("%s", errstring
);
4741 return error_mark_node
;
4744 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4745 for certain kinds of expressions which are not really lvalues
4746 but which we can accept as lvalues.
4748 If ARG is not a kind of expression we can handle, return zero. */
4751 unary_complex_lvalue (code
, arg
)
4752 enum tree_code code
;
4755 /* Handle (a, b) used as an "lvalue". */
4756 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4758 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4759 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4760 TREE_OPERAND (arg
, 0), real_result
);
4763 /* Handle (a ? b : c) used as an "lvalue". */
4764 if (TREE_CODE (arg
) == COND_EXPR
4765 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4766 return rationalize_conditional_expr (code
, arg
);
4768 if (TREE_CODE (arg
) == MODIFY_EXPR
4769 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4770 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4771 return unary_complex_lvalue
4772 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4773 arg
, TREE_OPERAND (arg
, 0)));
4775 if (code
!= ADDR_EXPR
)
4778 /* Handle (a = b) used as an "lvalue" for `&'. */
4779 if (TREE_CODE (arg
) == MODIFY_EXPR
4780 || TREE_CODE (arg
) == INIT_EXPR
)
4782 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4783 arg
= build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4784 TREE_NO_UNUSED_WARNING (arg
) = 1;
4788 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4789 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4790 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4792 /* The representation of something of type OFFSET_TYPE
4793 is really the representation of a pointer to it.
4794 Here give the representation its true type. */
4797 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4799 if (TREE_CODE (arg
) != OFFSET_REF
)
4802 t
= TREE_OPERAND (arg
, 1);
4804 /* Check all this code for right semantics. */
4805 if (TREE_CODE (t
) == FUNCTION_DECL
)
4807 if (DECL_DESTRUCTOR_P (t
))
4808 cp_error ("taking address of destructor");
4809 return build_unary_op (ADDR_EXPR
, t
, 0);
4811 if (TREE_CODE (t
) == VAR_DECL
)
4812 return build_unary_op (ADDR_EXPR
, t
, 0);
4817 if (TREE_OPERAND (arg
, 0)
4818 && ! is_dummy_object (TREE_OPERAND (arg
, 0))
4819 && TREE_CODE (t
) != FIELD_DECL
)
4821 cp_error ("taking address of bound pointer-to-member expression");
4822 return error_mark_node
;
4825 type
= build_offset_type (DECL_FIELD_CONTEXT (t
), TREE_TYPE (t
));
4826 type
= build_pointer_type (type
);
4828 t
= make_ptrmem_cst (type
, TREE_OPERAND (arg
, 1));
4834 /* We permit compiler to make function calls returning
4835 objects of aggregate type look like lvalues. */
4839 if (TREE_CODE (targ
) == SAVE_EXPR
)
4840 targ
= TREE_OPERAND (targ
, 0);
4842 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4844 if (TREE_CODE (arg
) == SAVE_EXPR
)
4847 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4848 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4851 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4852 return build (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4853 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4856 /* Don't let anything else be handled specially. */
4860 /* Mark EXP saying that we need to be able to take the
4861 address of it; it should not be allocated in a register.
4862 Value is 1 if successful.
4864 C++: we do not allow `current_class_ptr' to be addressable. */
4867 mark_addressable (exp
)
4870 register tree x
= exp
;
4872 if (TREE_ADDRESSABLE (x
) == 1)
4876 switch (TREE_CODE (x
))
4883 x
= TREE_OPERAND (x
, 0);
4887 if (x
== current_class_ptr
)
4889 error ("cannot take the address of `this', which is an rvalue expression");
4890 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4894 /* Caller should not be trying to mark initialized
4895 constant fields addressable. */
4896 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4897 || DECL_IN_AGGR_P (x
) == 0
4899 || DECL_EXTERNAL (x
), 314);
4903 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4904 && !DECL_ARTIFICIAL (x
) && extra_warnings
)
4905 cp_warning ("address requested for `%D', which is declared `register'",
4907 TREE_ADDRESSABLE (x
) = 1;
4911 TREE_ADDRESSABLE (x
) = 1;
4912 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4916 TREE_ADDRESSABLE (x
) = 1;
4920 TREE_ADDRESSABLE (x
) = 1;
4921 mark_addressable (TREE_OPERAND (x
, 0));
4929 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4932 build_x_conditional_expr (ifexp
, op1
, op2
)
4933 tree ifexp
, op1
, op2
;
4935 if (processing_template_decl
)
4936 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
4938 return build_conditional_expr (ifexp
, op1
, op2
);
4941 /* Handle overloading of the ',' operator when needed. Otherwise,
4942 this function just builds an expression list. */
4945 build_x_compound_expr (list
)
4948 tree rest
= TREE_CHAIN (list
);
4951 if (processing_template_decl
)
4952 return build_min_nt (COMPOUND_EXPR
, list
, NULL_TREE
);
4954 if (rest
== NULL_TREE
)
4955 return build_compound_expr (list
);
4957 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
4958 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
4960 return build_x_compound_expr (tree_cons (NULL_TREE
, result
,
4961 TREE_CHAIN (rest
)));
4963 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
4965 /* FIXME: This test should be in the implicit cast to void of the LHS. */
4966 /* the left-hand operand of a comma expression is like an expression
4967 statement: we should warn if it doesn't have any side-effects,
4968 unless it was explicitly cast to (void). */
4969 if ((extra_warnings
|| warn_unused_value
)
4970 && !(TREE_CODE (TREE_VALUE(list
)) == CONVERT_EXPR
4971 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE(list
)))))
4972 warning("left-hand operand of comma expression has no effect");
4974 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
4975 else if (warn_unused_value
)
4976 warn_if_unused_value (TREE_VALUE(list
));
4979 return build_compound_expr
4980 (tree_cons (NULL_TREE
, TREE_VALUE (list
),
4981 build_tree_list (NULL_TREE
,
4982 build_x_compound_expr (rest
))));
4985 /* Given a list of expressions, return a compound expression
4986 that performs them all and returns the value of the last of them. */
4989 build_compound_expr (list
)
4995 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
4997 if (TREE_CHAIN (list
) == 0)
4999 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5000 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
5001 if (TREE_CODE (list
) == NOP_EXPR
5002 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
5003 list
= TREE_OPERAND (list
, 0);
5005 return TREE_VALUE (list
);
5008 first
= TREE_VALUE (list
);
5009 first
= convert_to_void (first
, "left-hand operand of comma");
5010 if (first
== error_mark_node
)
5011 return error_mark_node
;
5013 rest
= build_compound_expr (TREE_CHAIN (list
));
5014 if (rest
== error_mark_node
)
5015 return error_mark_node
;
5017 /* When pedantic, a compound expression cannot be a constant expression. */
5018 if (! TREE_SIDE_EFFECTS (first
) && ! pedantic
)
5021 return build (COMPOUND_EXPR
, TREE_TYPE (rest
), first
, rest
);
5025 build_static_cast (type
, expr
)
5031 if (type
== error_mark_node
|| expr
== error_mark_node
)
5032 return error_mark_node
;
5034 if (TREE_CODE (expr
) == OFFSET_REF
)
5035 expr
= resolve_offset_ref (expr
);
5037 if (processing_template_decl
)
5039 tree t
= build_min (STATIC_CAST_EXPR
, type
, expr
);
5043 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5044 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5045 if (TREE_CODE (type
) != REFERENCE_TYPE
5046 && TREE_CODE (expr
) == NOP_EXPR
5047 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5048 expr
= TREE_OPERAND (expr
, 0);
5050 if (TREE_CODE (type
) == VOID_TYPE
)
5052 expr
= convert_to_void (expr
, /*implicit=*/NULL
);
5056 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5057 return (convert_from_reference
5058 (convert_to_reference (type
, expr
, CONV_STATIC
|CONV_IMPLICIT
,
5059 LOOKUP_COMPLAIN
, NULL_TREE
)));
5061 if (IS_AGGR_TYPE (type
))
5062 return build_cplus_new (type
, (build_method_call
5063 (NULL_TREE
, complete_ctor_identifier
,
5064 build_tree_list (NULL_TREE
, expr
),
5065 TYPE_BINFO (type
), LOOKUP_NORMAL
)));
5067 expr
= decay_conversion (expr
);
5068 intype
= TREE_TYPE (expr
);
5070 /* FIXME handle casting to array type. */
5073 if (IS_AGGR_TYPE (intype
)
5074 ? can_convert_arg (type
, intype
, expr
)
5075 : can_convert_arg (strip_all_pointer_quals (type
),
5076 strip_all_pointer_quals (intype
), expr
))
5077 /* This is a standard conversion. */
5079 else if (TYPE_PTROB_P (type
) && TYPE_PTROB_P (intype
))
5081 /* They're pointers to objects. They must be aggregates that
5082 are related non-virtually. */
5086 if (IS_AGGR_TYPE (TREE_TYPE (type
)) && IS_AGGR_TYPE (TREE_TYPE (intype
))
5087 && (binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 0))
5088 && !binfo_from_vbase (binfo
))
5091 else if (TREE_CODE (intype
) != BOOLEAN_TYPE
5092 && TREE_CODE (type
) != ARRAY_TYPE
5093 && TREE_CODE (type
) != FUNCTION_TYPE
5094 && can_convert (intype
, strip_all_pointer_quals (type
)))
5097 /* [expr.static.cast]
5099 The static_cast operator shall not be used to cast away
5101 if (ok
&& casts_away_constness (intype
, type
))
5103 cp_error ("static_cast from type `%T' to type `%T' casts away constness",
5105 return error_mark_node
;
5109 return build_c_cast (type
, expr
);
5111 cp_error ("invalid static_cast from type `%T' to type `%T'", intype
, type
);
5112 return error_mark_node
;
5116 build_reinterpret_cast (type
, expr
)
5121 if (type
== error_mark_node
|| expr
== error_mark_node
)
5122 return error_mark_node
;
5124 if (TREE_CODE (expr
) == OFFSET_REF
)
5125 expr
= resolve_offset_ref (expr
);
5127 if (processing_template_decl
)
5129 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
5133 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5135 expr
= decay_conversion (expr
);
5137 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5138 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5139 if (TREE_CODE (expr
) == NOP_EXPR
5140 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5141 expr
= TREE_OPERAND (expr
, 0);
5144 intype
= TREE_TYPE (expr
);
5146 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5148 if (! real_lvalue_p (expr
))
5150 cp_error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype
, type
);
5151 return error_mark_node
;
5153 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5154 if (expr
!= error_mark_node
)
5155 expr
= build_reinterpret_cast
5156 (build_pointer_type (TREE_TYPE (type
)), expr
);
5157 if (expr
!= error_mark_node
)
5158 expr
= build_indirect_ref (expr
, 0);
5161 else if (same_type_ignoring_top_level_qualifiers_p (intype
, type
))
5162 return build_static_cast (type
, expr
);
5164 if (TYPE_PTR_P (type
) && (TREE_CODE (intype
) == INTEGER_TYPE
5165 || TREE_CODE (intype
) == ENUMERAL_TYPE
))
5167 else if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_PTR_P (intype
))
5169 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5170 cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5173 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5174 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5176 expr
= decl_constant_value (expr
);
5177 return fold (build1 (NOP_EXPR
, type
, expr
));
5179 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5180 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5182 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type
), TREE_TYPE (intype
)))
5183 cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5186 expr
= decl_constant_value (expr
);
5187 return fold (build1 (NOP_EXPR
, type
, expr
));
5189 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5190 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
5192 pedwarn ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5193 expr
= decl_constant_value (expr
);
5194 return fold (build1 (NOP_EXPR
, type
, expr
));
5198 cp_error ("invalid reinterpret_cast from type `%T' to type `%T'",
5200 return error_mark_node
;
5203 return cp_convert (type
, expr
);
5207 build_const_cast (type
, expr
)
5212 if (type
== error_mark_node
|| expr
== error_mark_node
)
5213 return error_mark_node
;
5215 if (TREE_CODE (expr
) == OFFSET_REF
)
5216 expr
= resolve_offset_ref (expr
);
5218 if (processing_template_decl
)
5220 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
5224 if (!POINTER_TYPE_P (type
))
5225 cp_error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type
);
5226 else if (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5228 cp_error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type
);
5229 return error_mark_node
;
5232 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5234 expr
= decay_conversion (expr
);
5236 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5237 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5238 if (TREE_CODE (expr
) == NOP_EXPR
5239 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5240 expr
= TREE_OPERAND (expr
, 0);
5243 intype
= TREE_TYPE (expr
);
5245 if (same_type_ignoring_top_level_qualifiers_p (intype
, type
))
5246 return build_static_cast (type
, expr
);
5247 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5249 if (! real_lvalue_p (expr
))
5251 cp_error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype
, type
);
5252 return error_mark_node
;
5255 if (comp_ptr_ttypes_const (TREE_TYPE (type
), intype
))
5257 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5258 expr
= build1 (NOP_EXPR
, type
, expr
);
5259 return convert_from_reference (expr
);
5262 else if (TREE_CODE (type
) == POINTER_TYPE
5263 && TREE_CODE (intype
) == POINTER_TYPE
5264 && comp_ptr_ttypes_const (TREE_TYPE (type
), TREE_TYPE (intype
)))
5265 return cp_convert (type
, expr
);
5267 cp_error ("invalid const_cast from type `%T' to type `%T'", intype
, type
);
5268 return error_mark_node
;
5271 /* Build an expression representing a cast to type TYPE of expression EXPR.
5273 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5274 when doing the cast. */
5277 build_c_cast (type
, expr
)
5280 register tree value
= expr
;
5283 if (type
== error_mark_node
|| expr
== error_mark_node
)
5284 return error_mark_node
;
5286 if (processing_template_decl
)
5288 tree t
= build_min (CAST_EXPR
, type
,
5289 tree_cons (NULL_TREE
, value
, NULL_TREE
));
5293 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5294 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5295 if (TREE_CODE (type
) != REFERENCE_TYPE
5296 && TREE_CODE (value
) == NOP_EXPR
5297 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5298 value
= TREE_OPERAND (value
, 0);
5300 if (TREE_CODE (value
) == OFFSET_REF
)
5301 value
= resolve_offset_ref (value
);
5303 if (TREE_CODE (type
) == ARRAY_TYPE
)
5305 /* Allow casting from T1* to T2[] because Cfront allows it.
5306 NIHCL uses it. It is not valid ISO C++ however. */
5307 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5309 cp_pedwarn ("ISO C++ forbids casting to an array type `%T'", type
);
5310 type
= build_pointer_type (TREE_TYPE (type
));
5314 cp_error ("ISO C++ forbids casting to an array type `%T'", type
);
5315 return error_mark_node
;
5319 if (TREE_CODE (type
) == FUNCTION_TYPE
5320 || TREE_CODE (type
) == METHOD_TYPE
)
5322 cp_error ("invalid cast to function type `%T'", type
);
5323 return error_mark_node
;
5326 if (TREE_CODE (type
) == VOID_TYPE
)
5328 /* Conversion to void does not cause any of the normal function to
5329 * pointer, array to pointer and lvalue to rvalue decays. */
5331 value
= convert_to_void (value
, /*implicit=*/NULL
);
5334 /* Convert functions and arrays to pointers and
5335 convert references to their expanded types,
5336 but don't convert any other types. If, however, we are
5337 casting to a class type, there's no reason to do this: the
5338 cast will only succeed if there is a converting constructor,
5339 and the default conversions will be done at that point. In
5340 fact, doing the default conversion here is actually harmful
5344 struct S { S(const A&); };
5346 since we don't want the array-to-pointer conversion done. */
5347 if (!IS_AGGR_TYPE (type
))
5349 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5350 || (TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
5351 /* Don't do the default conversion on a ->* expression. */
5352 && ! (TREE_CODE (type
) == POINTER_TYPE
5353 && bound_pmf_p (value
)))
5354 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5355 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5356 value
= default_conversion (value
);
5358 else if (TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5359 /* However, even for class types, we still need to strip away
5360 the reference type, since the call to convert_force below
5361 does not expect the input expression to be of reference
5363 value
= convert_from_reference (value
);
5365 otype
= TREE_TYPE (value
);
5367 /* Optionally warn about potentially worrisome casts. */
5370 && TREE_CODE (type
) == POINTER_TYPE
5371 && TREE_CODE (otype
) == POINTER_TYPE
5372 && !at_least_as_qualified_p (TREE_TYPE (type
),
5374 cp_warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
5377 if (TREE_CODE (type
) == INTEGER_TYPE
5378 && TREE_CODE (otype
) == POINTER_TYPE
5379 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5380 warning ("cast from pointer to integer of different size");
5382 if (TREE_CODE (type
) == POINTER_TYPE
5383 && TREE_CODE (otype
) == INTEGER_TYPE
5384 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5385 /* Don't warn about converting any constant. */
5386 && !TREE_CONSTANT (value
))
5387 warning ("cast to pointer from integer of different size");
5389 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5390 value
= (convert_from_reference
5391 (convert_to_reference (type
, value
, CONV_C_CAST
,
5392 LOOKUP_COMPLAIN
, NULL_TREE
)));
5397 value
= decl_constant_value (value
);
5400 value
= convert_force (type
, value
, CONV_C_CAST
);
5402 /* Ignore any integer overflow caused by the cast. */
5403 if (TREE_CODE (value
) == INTEGER_CST
)
5405 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5406 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5410 /* Warn about possible alignment problems. Do this here when we will have
5411 instantiated any necessary template types. */
5412 if (STRICT_ALIGNMENT
&& warn_cast_align
5413 && TREE_CODE (type
) == POINTER_TYPE
5414 && TREE_CODE (otype
) == POINTER_TYPE
5415 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5416 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5417 && COMPLETE_TYPE_P (TREE_TYPE (otype
))
5418 && COMPLETE_TYPE_P (TREE_TYPE (type
))
5419 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5420 cp_warning ("cast from `%T' to `%T' increases required alignment of target type",
5423 /* Always produce some operator for an explicit cast,
5424 so we can tell (for -pedantic) that the cast is no lvalue. */
5425 if (TREE_CODE (type
) != REFERENCE_TYPE
&& value
== expr
5426 && real_lvalue_p (value
))
5427 value
= non_lvalue (value
);
5432 /* Build an assignment expression of lvalue LHS from value RHS.
5433 MODIFYCODE is the code for a binary operator that we use
5434 to combine the old value of LHS with RHS to get the new value.
5435 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5437 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5440 build_modify_expr (lhs
, modifycode
, rhs
)
5442 enum tree_code modifycode
;
5445 register tree result
;
5447 tree lhstype
= TREE_TYPE (lhs
);
5448 tree olhstype
= lhstype
;
5451 /* Avoid duplicate error messages from operands that had errors. */
5452 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
5453 return error_mark_node
;
5455 /* Types that aren't fully specified cannot be used in assignments. */
5456 lhs
= require_complete_type (lhs
);
5460 /* Handle control structure constructs used as "lvalues". */
5462 switch (TREE_CODE (lhs
))
5464 /* Handle --foo = 5; as these are valid constructs in C++ */
5465 case PREDECREMENT_EXPR
:
5466 case PREINCREMENT_EXPR
:
5467 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5468 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5469 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5470 TREE_OPERAND (lhs
, 1));
5471 return build (COMPOUND_EXPR
, lhstype
,
5473 build_modify_expr (TREE_OPERAND (lhs
, 0),
5476 /* Handle (a, b) used as an "lvalue". */
5478 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5480 if (newrhs
== error_mark_node
)
5481 return error_mark_node
;
5482 return build (COMPOUND_EXPR
, lhstype
,
5483 TREE_OPERAND (lhs
, 0), newrhs
);
5486 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5487 if (newrhs
== error_mark_node
)
5488 return error_mark_node
;
5489 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5491 /* Handle (a ? b : c) used as an "lvalue". */
5493 rhs
= save_expr (rhs
);
5495 /* Produce (a ? (b = rhs) : (c = rhs))
5496 except that the RHS goes through a save-expr
5497 so the code to compute it is only emitted once. */
5500 /* Check this here to avoid odd errors when trying to convert
5501 a throw to the type of the COND_EXPR. */
5502 if (!lvalue_or_else (lhs
, "assignment"))
5503 return error_mark_node
;
5505 cond
= build_conditional_expr
5506 (TREE_OPERAND (lhs
, 0),
5507 build_modify_expr (cp_convert (TREE_TYPE (lhs
),
5508 TREE_OPERAND (lhs
, 1)),
5510 build_modify_expr (cp_convert (TREE_TYPE (lhs
),
5511 TREE_OPERAND (lhs
, 2)),
5514 if (cond
== error_mark_node
)
5516 /* Make sure the code to compute the rhs comes out
5517 before the split. */
5518 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5519 /* Case to void to suppress warning
5520 from warn_if_unused_value. */
5521 cp_convert (void_type_node
, rhs
), cond
);
5528 if (TREE_CODE (lhs
) == OFFSET_REF
)
5530 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5532 /* Static class member? */
5533 tree member
= TREE_OPERAND (lhs
, 1);
5534 if (TREE_CODE (member
) == VAR_DECL
)
5538 compiler_error ("invalid static class member");
5539 return error_mark_node
;
5543 lhs
= resolve_offset_ref (lhs
);
5545 olhstype
= lhstype
= TREE_TYPE (lhs
);
5548 if (lhs
== error_mark_node
)
5551 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5552 && modifycode
!= INIT_EXPR
)
5554 lhs
= convert_from_reference (lhs
);
5555 olhstype
= lhstype
= TREE_TYPE (lhs
);
5558 /* If a binary op has been requested, combine the old LHS value with the RHS
5559 producing the value we should actually store into the LHS. */
5561 if (modifycode
== INIT_EXPR
)
5563 if (TREE_CODE (rhs
) == CONSTRUCTOR
)
5565 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
5567 result
= build (INIT_EXPR
, lhstype
, lhs
, rhs
);
5568 TREE_SIDE_EFFECTS (result
) = 1;
5571 else if (! IS_AGGR_TYPE (lhstype
))
5572 /* Do the default thing */;
5575 result
= build_method_call (lhs
, complete_ctor_identifier
,
5576 build_tree_list (NULL_TREE
, rhs
),
5577 TYPE_BINFO (lhstype
), LOOKUP_NORMAL
);
5578 if (result
== NULL_TREE
)
5579 return error_mark_node
;
5583 else if (modifycode
== NOP_EXPR
)
5585 /* `operator=' is not an inheritable operator. */
5586 if (! IS_AGGR_TYPE (lhstype
))
5587 /* Do the default thing */;
5590 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5591 lhs
, rhs
, make_node (NOP_EXPR
));
5592 if (result
== NULL_TREE
)
5593 return error_mark_node
;
5598 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5600 my_friendly_abort (978652);
5604 lhs
= stabilize_reference (lhs
);
5605 newrhs
= cp_build_binary_op (modifycode
, lhs
, rhs
);
5606 if (newrhs
== error_mark_node
)
5608 cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode
,
5609 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
5610 return error_mark_node
;
5614 /* Handle a cast used as an "lvalue".
5615 We have already performed any binary operator using the value as cast.
5616 Now convert the result to the cast type of the lhs,
5617 and then true type of the lhs and store it there;
5618 then convert result back to the cast type to be the value
5619 of the assignment. */
5621 switch (TREE_CODE (lhs
))
5626 case FIX_TRUNC_EXPR
:
5627 case FIX_FLOOR_EXPR
:
5628 case FIX_ROUND_EXPR
:
5630 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5631 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5632 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5633 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5634 newrhs
= default_conversion (newrhs
);
5636 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5639 /* ISO C++ 5.4/1: The result is an lvalue if T is a reference
5640 type, otherwise the result is an rvalue. */
5641 if (! lvalue_p (lhs
))
5642 pedwarn ("ISO C++ forbids cast to non-reference type used as lvalue");
5644 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5645 cp_convert (TREE_TYPE (inner_lhs
),
5646 cp_convert (lhstype
, newrhs
)));
5647 if (result
== error_mark_node
)
5649 return cp_convert (TREE_TYPE (lhs
), result
);
5656 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5657 Reject anything strange now. */
5659 if (!lvalue_or_else (lhs
, "assignment"))
5660 return error_mark_node
;
5662 GNU_xref_assign (lhs
);
5664 /* Warn about storing in something that is `const'. */
5665 /* For C++, don't warn if this is initialization. */
5666 if (modifycode
!= INIT_EXPR
5667 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
5668 /* Functions are not modifiable, even though they are
5670 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
5671 || (IS_AGGR_TYPE_CODE (TREE_CODE (lhstype
))
5672 && C_TYPE_FIELDS_READONLY (lhstype
))
5673 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5674 && CP_TYPE_CONST_P (TREE_TYPE (lhstype
)))))
5675 readonly_error (lhs
, "assignment", 0);
5677 /* If storing into a structure or union member,
5678 it has probably been given type `int'.
5679 Compute the type that would go with
5680 the actual amount of storage the member occupies. */
5682 if (TREE_CODE (lhs
) == COMPONENT_REF
5683 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5684 || TREE_CODE (lhstype
) == REAL_TYPE
5685 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5687 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5689 /* If storing in a field that is in actuality a short or narrower
5690 than one, we must store in the field in its actual type. */
5692 if (lhstype
!= TREE_TYPE (lhs
))
5694 lhs
= copy_node (lhs
);
5695 TREE_TYPE (lhs
) = lhstype
;
5699 if (modifycode
!= INIT_EXPR
)
5701 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5702 modifycode
= NOP_EXPR
;
5703 /* Reference-bashing */
5704 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5706 tree tmp
= convert_from_reference (lhs
);
5707 lhstype
= TREE_TYPE (tmp
);
5708 if (!COMPLETE_TYPE_P (lhstype
))
5710 incomplete_type_error (lhs
, lhstype
);
5711 return error_mark_node
;
5716 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
5718 tree tmp
= convert_from_reference (newrhs
);
5719 if (!COMPLETE_TYPE_P (TREE_TYPE (tmp
)))
5721 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
5722 return error_mark_node
;
5728 if (TREE_SIDE_EFFECTS (lhs
))
5729 lhs
= stabilize_reference (lhs
);
5730 if (TREE_SIDE_EFFECTS (newrhs
))
5731 newrhs
= stabilize_reference (newrhs
);
5733 /* Convert new value to destination type. */
5735 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5739 if (!same_or_base_type_p (lhstype
, TREE_TYPE (rhs
)))
5741 cp_error ("incompatible types in assignment of `%T' to `%T'",
5742 TREE_TYPE (rhs
), lhstype
);
5743 return error_mark_node
;
5746 /* Allow array assignment in compiler-generated code. */
5747 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
5748 pedwarn ("ISO C++ forbids assignment of arrays");
5750 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5751 ? 1 + (modifycode
!= INIT_EXPR
): 0;
5752 return build_vec_init (lhs
, newrhs
, from_array
);
5755 if (modifycode
== INIT_EXPR
)
5757 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
5758 "initialization", NULL_TREE
, 0);
5759 if (current_function_decl
&&
5760 lhs
== DECL_RESULT (current_function_decl
))
5762 if (DECL_INITIAL (lhs
))
5763 warning ("return value from function receives multiple initializations");
5764 DECL_INITIAL (lhs
) = newrhs
;
5769 /* Avoid warnings on enum bit fields. */
5770 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
5771 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
5773 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
5775 newrhs
= convert_force (lhstype
, newrhs
, 0);
5778 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
5780 if (TREE_CODE (newrhs
) == CALL_EXPR
5781 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
5782 newrhs
= build_cplus_new (lhstype
, newrhs
);
5784 /* Can't initialize directly from a TARGET_EXPR, since that would
5785 cause the lhs to be constructed twice, and possibly result in
5786 accidental self-initialization. So we force the TARGET_EXPR to be
5787 expanded without a target. */
5788 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
5789 newrhs
= build (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
5790 TREE_OPERAND (newrhs
, 0));
5793 if (newrhs
== error_mark_node
)
5794 return error_mark_node
;
5796 if (TREE_CODE (newrhs
) == COND_EXPR
)
5799 tree cond
= TREE_OPERAND (newrhs
, 0);
5801 if (TREE_SIDE_EFFECTS (lhs
))
5802 cond
= build_compound_expr (tree_cons
5804 build_tree_list (NULL_TREE
, cond
)));
5806 /* Cannot have two identical lhs on this one tree (result) as preexpand
5807 calls will rip them out and fill in RTL for them, but when the
5808 rtl is generated, the calls will only be in the first side of the
5809 condition, not on both, or before the conditional jump! (mrs) */
5810 lhs1
= break_out_calls (lhs
);
5813 /* If there's no change, the COND_EXPR behaves like any other rhs. */
5814 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5815 lhstype
, lhs
, newrhs
);
5818 tree result_type
= TREE_TYPE (newrhs
);
5819 /* We have to convert each arm to the proper type because the
5820 types may have been munged by constant folding. */
5822 = build (COND_EXPR
, result_type
, cond
,
5823 build_modify_expr (lhs
, modifycode
,
5824 cp_convert (result_type
,
5825 TREE_OPERAND (newrhs
, 1))),
5826 build_modify_expr (lhs1
, modifycode
,
5827 cp_convert (result_type
,
5828 TREE_OPERAND (newrhs
, 2))));
5832 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5833 lhstype
, lhs
, newrhs
);
5835 TREE_SIDE_EFFECTS (result
) = 1;
5837 /* If we got the LHS in a different type for storing in,
5838 convert the result back to the nominal type of LHS
5839 so that the value we return always has the same type
5840 as the LHS argument. */
5842 if (olhstype
== TREE_TYPE (result
))
5844 /* Avoid warnings converting integral types back into enums
5845 for enum bit fields. */
5846 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
5847 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
5849 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
5850 TREE_NO_UNUSED_WARNING (result
) = 1;
5853 return convert_for_assignment (olhstype
, result
, "assignment",
5858 build_x_modify_expr (lhs
, modifycode
, rhs
)
5860 enum tree_code modifycode
;
5863 if (processing_template_decl
)
5864 return build_min_nt (MODOP_EXPR
, lhs
,
5865 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
5867 if (modifycode
!= NOP_EXPR
)
5869 tree rval
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
5870 make_node (modifycode
));
5874 return build_modify_expr (lhs
, modifycode
, rhs
);
5878 /* Get difference in deltas for different pointer to member function
5879 types. Return integer_zero_node, if FROM cannot be converted to a
5880 TO type. If FORCE is true, then allow reverse conversions as well.
5882 Note that the naming of FROM and TO is kind of backwards; the return
5883 value is what we add to a TO in order to get a FROM. They are named
5884 this way because we call this function to find out how to convert from
5885 a pointer to member of FROM to a pointer to member of TO. */
5888 get_delta_difference (from
, to
, force
)
5892 tree delta
= integer_zero_node
;
5899 /* Should get_base_distance here, so we can check if any thing along
5900 the path is virtual, and we need to make sure we stay inside the
5901 real binfos when going through virtual bases. Maybe we should
5902 replace virtual bases with BINFO_FOR_VBASE ... (mrs) */
5903 binfo
= get_binfo (from
, to
, 1);
5904 if (binfo
== error_mark_node
)
5906 error (" in pointer to member function conversion");
5913 error_not_base_type (from
, to
);
5914 error (" in pointer to member conversion");
5917 binfo
= get_binfo (to
, from
, 1);
5918 if (binfo
== 0 || binfo
== error_mark_node
)
5920 virt_binfo
= binfo_from_vbase (binfo
);
5924 /* This is a reinterpret cast, we choose to do nothing. */
5925 cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
5926 BINFO_TYPE (virt_binfo
),
5927 BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo
)));
5930 delta
= BINFO_OFFSET (binfo
);
5931 delta
= cp_convert (ptrdiff_type_node
, delta
);
5932 delta
= cp_build_binary_op (MINUS_EXPR
,
5939 virt_binfo
= binfo_from_vbase (binfo
);
5942 /* This is a reinterpret cast, we choose to do nothing. */
5944 cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
5945 BINFO_TYPE (virt_binfo
),
5946 BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo
)));
5948 cp_error ("pointer to member conversion via virtual base `%T' of `%T'",
5949 BINFO_TYPE (virt_binfo
),
5950 BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo
)));
5953 delta
= BINFO_OFFSET (binfo
);
5955 return cp_convert (ptrdiff_type_node
, delta
);
5958 /* Return a constructor for the pointer-to-member-function TYPE using
5959 the other components as specified. */
5962 build_ptrmemfunc1 (type
, delta
, pfn
)
5963 tree type
, delta
, pfn
;
5968 tree pfn_or_delta2_field
;
5972 int allconstant
, allsimple
;
5974 /* Pull the FIELD_DECLs out of the type. */
5975 pfn_field
= TYPE_FIELDS (type
);
5976 delta_field
= TREE_CHAIN (pfn_field
);
5977 idx_field
= NULL_TREE
;
5978 pfn_or_delta2_field
= NULL_TREE
;
5979 delta2_field
= NULL_TREE
;
5980 subtype
= NULL_TREE
;
5982 /* Make sure DELTA has the type we want. */
5983 delta
= convert_and_check (delta_type_node
, delta
);
5985 /* Keep track of whether the initializer is a) constant, and b) can
5986 be done statically. */
5987 allconstant
= TREE_CONSTANT (delta
);
5988 allsimple
= (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
5993 /* A non-virtual function. */
5994 allconstant
&= TREE_CONSTANT (pfn
);
5995 allsimple
&= (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
6000 /* A virtual function. */
6001 allconstant
&= TREE_CONSTANT (pfn
);
6002 allsimple
&= (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
6006 /* Finish creating the initializer. */
6007 u
= tree_cons (pfn_field
, pfn
,
6008 build_tree_list (delta_field
, delta
));
6009 u
= build (CONSTRUCTOR
, type
, NULL_TREE
, u
);
6010 TREE_CONSTANT (u
) = allconstant
;
6011 TREE_STATIC (u
) = allconstant
&& allsimple
;
6015 /* Build a constructor for a pointer to member function. It can be
6016 used to initialize global variables, local variable, or used
6017 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6020 If FORCE is non-zero, then force this conversion, even if
6021 we would rather not do it. Usually set when using an explicit
6024 Return error_mark_node, if something goes wrong. */
6027 build_ptrmemfunc (type
, pfn
, force
)
6032 tree pfn_type
= TREE_TYPE (pfn
);
6033 tree to_type
= build_ptrmemfunc_type (type
);
6035 /* Handle multiple conversions of pointer to member functions. */
6036 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6038 tree delta
= integer_zero_node
;
6039 tree npfn
= NULL_TREE
;
6043 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
))
6044 cp_error ("invalid conversion to type `%T' from type `%T'",
6047 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
6048 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
6051 /* We don't have to do any conversion to convert a
6052 pointer-to-member to its own type. But, we don't want to
6053 just return a PTRMEM_CST if there's an explicit cast; that
6054 cast should make the expression an invalid template argument. */
6055 if (TREE_CODE (pfn
) != PTRMEM_CST
)
6057 if (same_type_p (to_type
, pfn_type
))
6059 else if (integer_zerop (n
))
6060 return build_reinterpret_cast (to_type
, pfn
);
6063 if (TREE_SIDE_EFFECTS (pfn
))
6064 pfn
= save_expr (pfn
);
6066 /* Under the new ABI, the conversion is easy. Just adjust
6068 npfn
= build_component_ref (pfn
, pfn_identifier
, NULL_TREE
, 0);
6069 delta
= build_component_ref (pfn
, delta_identifier
, NULL_TREE
, 0);
6070 delta
= cp_convert (ptrdiff_type_node
, delta
);
6071 delta
= cp_build_binary_op (PLUS_EXPR
, delta
, n
);
6072 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
6075 /* Handle null pointer to member function conversions. */
6076 if (integer_zerop (pfn
))
6078 pfn
= build_c_cast (type
, integer_zero_node
);
6079 return build_ptrmemfunc1 (to_type
,
6084 if (type_unknown_p (pfn
))
6085 return instantiate_type (type
, pfn
, itf_complain
);
6087 fn
= TREE_OPERAND (pfn
, 0);
6088 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
, 0);
6089 return make_ptrmem_cst (to_type
, fn
);
6092 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6095 ??? There is no consistency as to the types returned for the above
6096 values. Some code acts as if its a sizetype and some as if its
6097 integer_type_node. */
6100 expand_ptrmemfunc_cst (cst
, delta
, idx
, pfn
, delta2
)
6107 tree type
= TREE_TYPE (cst
);
6108 tree fn
= PTRMEM_CST_MEMBER (cst
);
6109 tree ptr_class
, fn_class
;
6111 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
, 0);
6113 /* The class that the function belongs to. */
6114 fn_class
= DECL_CONTEXT (fn
);
6116 /* The class that we're creating a pointer to member of. */
6117 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
6119 /* First, calculate the adjustment to the function's class. */
6120 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0);
6122 if (!DECL_VIRTUAL_P (fn
))
6125 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), build_addr_func (fn
));
6126 *delta2
= NULL_TREE
;
6130 /* If we're dealing with a virtual function, we have to adjust 'this'
6131 again, to point to the base which provides the vtable entry for
6132 fn; the call will do the opposite adjustment. */
6133 tree orig_class
= DECL_VIRTUAL_CONTEXT (fn
);
6134 tree binfo
= binfo_or_else (orig_class
, fn_class
);
6135 *delta
= fold (build (PLUS_EXPR
, TREE_TYPE (*delta
),
6136 *delta
, BINFO_OFFSET (binfo
)));
6138 /* Under the new ABI, we set PFN to the vtable offset, plus
6139 one, at which the function can be found. */
6141 *pfn
= fold (build (MULT_EXPR
, integer_type_node
,
6143 TYPE_SIZE_UNIT (vtable_entry_type
)));
6144 *pfn
= fold (build (PLUS_EXPR
, integer_type_node
, *pfn
,
6146 *pfn
= fold (build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type
),
6149 /* Offset from an object of PTR_CLASS to the vptr for ORIG_CLASS. */
6150 *delta2
= fold (build (PLUS_EXPR
, integer_type_node
, *delta
,
6151 get_vfield_offset (TYPE_BINFO (orig_class
))));
6155 /* Return an expression for DELTA2 from the pointer-to-member function
6159 delta2_from_ptrmemfunc (t
)
6162 my_friendly_assert (0, 20000221);
6164 if (TREE_CODE (t
) == PTRMEM_CST
)
6171 expand_ptrmemfunc_cst (t
, &delta
, &idx
, &pfn
, &delta2
);
6176 return (build_component_ref
6177 (build_component_ref (t
,
6178 pfn_or_delta2_identifier
, NULL_TREE
,
6180 delta2_identifier
, NULL_TREE
, 0));
6183 /* Return an expression for PFN from the pointer-to-member function
6187 pfn_from_ptrmemfunc (t
)
6190 if (TREE_CODE (t
) == PTRMEM_CST
)
6197 expand_ptrmemfunc_cst (t
, &delta
, &idx
, &pfn
, &delta2
);
6202 return build_component_ref (t
, pfn_identifier
, NULL_TREE
, 0);
6205 /* Expression EXPR is about to be implicitly converted to TYPE. Warn
6206 if this is a potentially dangerous thing to do. Returns a possibly
6210 dubious_conversion_warnings (type
, expr
, errtype
, fndecl
, parmnum
)
6213 const char *errtype
;
6217 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6218 type
= TREE_TYPE (type
);
6220 /* Issue warnings about peculiar, but legal, uses of NULL. */
6221 if (ARITHMETIC_TYPE_P (type
) && expr
== null_node
)
6224 cp_warning ("passing NULL used for non-pointer %s %P of `%D'",
6225 errtype
, parmnum
, fndecl
);
6227 cp_warning ("%s to non-pointer type `%T' from NULL", errtype
, type
);
6230 /* Warn about assigning a floating-point type to an integer type. */
6231 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
6232 && TREE_CODE (type
) == INTEGER_TYPE
)
6235 cp_warning ("passing `%T' for %s %P of `%D'",
6236 TREE_TYPE (expr
), errtype
, parmnum
, fndecl
);
6238 cp_warning ("%s to `%T' from `%T'", errtype
, type
, TREE_TYPE (expr
));
6240 /* And warn about assigning a negative value to an unsigned
6242 else if (TREE_UNSIGNED (type
) && TREE_CODE (type
) != BOOLEAN_TYPE
)
6244 if (TREE_CODE (expr
) == INTEGER_CST
6245 && TREE_NEGATED_INT (expr
))
6248 cp_warning ("passing negative value `%E' for %s %P of `%D'",
6249 expr
, errtype
, parmnum
, fndecl
);
6251 cp_warning ("%s of negative value `%E' to `%T'",
6252 errtype
, expr
, type
);
6255 overflow_warning (expr
);
6257 if (TREE_CONSTANT (expr
))
6263 /* Convert value RHS to type TYPE as preparation for an assignment to
6264 an lvalue of type TYPE. ERRTYPE is a string to use in error
6265 messages: "assignment", "return", etc. If FNDECL is non-NULL, we
6266 are doing the conversion in order to pass the PARMNUMth argument of
6270 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6272 const char *errtype
;
6276 register enum tree_code codel
= TREE_CODE (type
);
6277 register tree rhstype
;
6278 register enum tree_code coder
;
6280 if (codel
== OFFSET_TYPE
)
6281 my_friendly_abort (990505);
6283 if (TREE_CODE (rhs
) == OFFSET_REF
)
6284 rhs
= resolve_offset_ref (rhs
);
6286 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6287 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6288 rhs
= TREE_OPERAND (rhs
, 0);
6290 rhstype
= TREE_TYPE (rhs
);
6291 coder
= TREE_CODE (rhstype
);
6293 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
6294 return error_mark_node
;
6295 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6296 return error_mark_node
;
6298 rhs
= dubious_conversion_warnings (type
, rhs
, errtype
, fndecl
, parmnum
);
6300 /* The RHS of an assignment cannot have void type. */
6301 if (coder
== VOID_TYPE
)
6303 error ("void value not ignored as it ought to be");
6304 return error_mark_node
;
6307 /* Simplify the RHS if possible. */
6308 if (TREE_CODE (rhs
) == CONST_DECL
)
6309 rhs
= DECL_INITIAL (rhs
);
6310 else if (coder
!= ARRAY_TYPE
)
6311 rhs
= decl_constant_value (rhs
);
6315 The expression is implicitly converted (clause _conv_) to the
6316 cv-unqualified type of the left operand. */
6317 if (!can_convert_arg (type
, rhstype
, rhs
))
6319 /* When -Wno-pmf-conversions is use, we just silently allow
6320 conversions from pointers-to-members to plain pointers. If
6321 the conversion doesn't work, cp_convert will complain. */
6323 && TYPE_PTR_P (type
)
6324 && TYPE_PTRMEMFUNC_P (rhstype
))
6325 rhs
= cp_convert (strip_top_quals (type
), rhs
);
6328 /* If the right-hand side has unknown type, then it is an
6329 overloaded function. Call instantiate_type to get error
6331 if (rhstype
== unknown_type_node
)
6332 instantiate_type (type
, rhs
, itf_complain
);
6334 cp_error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
6335 rhstype
, type
, parmnum
, fndecl
);
6337 cp_error ("cannot convert `%T' to `%T' in %s", rhstype
, type
,
6339 return error_mark_node
;
6342 return perform_implicit_conversion (strip_top_quals (type
), rhs
);
6345 /* Convert RHS to be of type TYPE.
6346 If EXP is non-zero, it is the target of the initialization.
6347 ERRTYPE is a string to use in error messages.
6349 Two major differences between the behavior of
6350 `convert_for_assignment' and `convert_for_initialization'
6351 are that references are bashed in the former, while
6352 copied in the latter, and aggregates are assigned in
6353 the former (operator=) while initialized in the
6356 If using constructor make sure no conversion operator exists, if one does
6357 exist, an ambiguity exists.
6359 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6362 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6363 tree exp
, type
, rhs
;
6365 const char *errtype
;
6369 register enum tree_code codel
= TREE_CODE (type
);
6370 register tree rhstype
;
6371 register enum tree_code coder
;
6373 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6374 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6375 if (TREE_CODE (rhs
) == NOP_EXPR
6376 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6377 && codel
!= REFERENCE_TYPE
)
6378 rhs
= TREE_OPERAND (rhs
, 0);
6380 if (rhs
== error_mark_node
6381 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6382 return error_mark_node
;
6384 if (TREE_CODE (rhs
) == OFFSET_REF
)
6386 rhs
= resolve_offset_ref (rhs
);
6387 if (rhs
== error_mark_node
)
6388 return error_mark_node
;
6391 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6392 rhs
= convert_from_reference (rhs
);
6394 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6395 && TREE_CODE (type
) != ARRAY_TYPE
6396 && (TREE_CODE (type
) != REFERENCE_TYPE
6397 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6398 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6399 && (TREE_CODE (type
) != REFERENCE_TYPE
6400 || TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
))
6401 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6402 rhs
= default_conversion (rhs
);
6404 rhstype
= TREE_TYPE (rhs
);
6405 coder
= TREE_CODE (rhstype
);
6407 if (coder
== ERROR_MARK
)
6408 return error_mark_node
;
6410 /* We accept references to incomplete types, so we can
6411 return here before checking if RHS is of complete type. */
6413 if (codel
== REFERENCE_TYPE
)
6415 /* This should eventually happen in convert_arguments. */
6416 extern int warningcount
, errorcount
;
6417 int savew
= 0, savee
= 0;
6420 savew
= warningcount
, savee
= errorcount
;
6421 rhs
= initialize_reference (type
, rhs
);
6424 if (warningcount
> savew
)
6425 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6426 else if (errorcount
> savee
)
6427 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6433 exp
= require_complete_type (exp
);
6434 if (exp
== error_mark_node
)
6435 return error_mark_node
;
6437 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6438 rhstype
= TREE_TYPE (rhstype
);
6440 type
= complete_type (type
);
6442 if (IS_AGGR_TYPE (type
))
6443 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
6445 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
6448 /* Expand an ASM statement with operands, handling output operands
6449 that are not variables or INDIRECT_REFS by transforming such
6450 cases into cases that expand_asm_operands can handle.
6452 Arguments are same as for expand_asm_operands.
6454 We don't do default conversions on all inputs, because it can screw
6455 up operands that are expected to be in memory. */
6458 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
6459 tree string
, outputs
, inputs
, clobbers
;
6461 const char *filename
;
6464 int noutputs
= list_length (outputs
);
6466 /* o[I] is the place that output number I should be written. */
6467 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
6470 /* Record the contents of OUTPUTS before it is modified. */
6471 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6472 o
[i
] = TREE_VALUE (tail
);
6474 /* Generate the ASM_OPERANDS insn;
6475 store into the TREE_VALUEs of OUTPUTS some trees for
6476 where the values were actually stored. */
6477 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
6479 /* Copy all the intermediate outputs into the specified outputs. */
6480 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6482 if (o
[i
] != TREE_VALUE (tail
))
6484 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
6485 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
6488 /* Restore the original value so that it's correct the next
6489 time we expand this function. */
6490 TREE_VALUE (tail
) = o
[i
];
6492 /* Detect modification of read-only values.
6493 (Otherwise done by build_modify_expr.) */
6496 tree type
= TREE_TYPE (o
[i
]);
6497 if (CP_TYPE_CONST_P (type
)
6498 || (IS_AGGR_TYPE_CODE (TREE_CODE (type
))
6499 && C_TYPE_FIELDS_READONLY (type
)))
6500 readonly_error (o
[i
], "modification by `asm'", 1);
6504 /* Those MODIFY_EXPRs could do autoincrements. */
6508 /* If RETVAL is the address of, or a reference to, a local variable or
6509 temporary give an appropraite warning. */
6512 maybe_warn_about_returning_address_of_local (retval
)
6515 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
6516 tree whats_returned
= retval
;
6520 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
6521 whats_returned
= TREE_OPERAND (whats_returned
, 1);
6522 else if (TREE_CODE (whats_returned
) == CONVERT_EXPR
6523 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
6524 || TREE_CODE (whats_returned
) == NOP_EXPR
)
6525 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6530 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
6532 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6534 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6536 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
6537 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
6539 /* Get the target. */
6540 whats_returned
= TREE_OPERAND (whats_returned
, 0);
6541 warning ("returning reference to temporary");
6544 if (TREE_CODE (whats_returned
) == VAR_DECL
6545 && DECL_NAME (whats_returned
)
6546 && TEMP_NAME_P (DECL_NAME (whats_returned
)))
6548 warning ("reference to non-lvalue returned");
6553 if (TREE_CODE (whats_returned
) == VAR_DECL
6554 && DECL_NAME (whats_returned
)
6555 && DECL_FUNCTION_SCOPE_P (whats_returned
)
6556 && !(TREE_STATIC (whats_returned
)
6557 || TREE_PUBLIC (whats_returned
)))
6559 if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
6560 cp_warning_at ("reference to local variable `%D' returned",
6563 cp_warning_at ("address of local variable `%D' returned",
6569 /* Check that returning RETVAL from the current function is legal.
6570 Return an expression explicitly showing all conversions required to
6571 change RETVAL into the function return type, and to assign it to
6572 the DECL_RESULT for the function. */
6575 check_return_expr (retval
)
6579 /* The type actually returned by the function, after any
6582 int fn_returns_value_p
;
6584 /* A `volatile' function is one that isn't supposed to return, ever.
6585 (This is a G++ extension, used to get better code for functions
6586 that call the `volatile' function.) */
6587 if (TREE_THIS_VOLATILE (current_function_decl
))
6588 warning ("function declared `noreturn' has a `return' statement");
6590 /* Check for various simple errors. */
6594 error ("returning a value from a destructor");
6597 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
6599 if (in_function_try_handler
)
6600 /* If a return statement appears in a handler of the
6601 function-try-block of a constructor, the program is ill-formed. */
6602 error ("cannot return from a handler of a function-try-block of a constructor");
6604 /* You can't return a value from a constructor. */
6605 error ("returning a value from a constructor");
6609 /* When no explicit return-value is given in a function with a named
6610 return value, the named return value is used. */
6611 result
= DECL_RESULT (current_function_decl
);
6612 valtype
= TREE_TYPE (result
);
6613 my_friendly_assert (valtype
!= NULL_TREE
, 19990924);
6614 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
6615 if (!retval
&& DECL_NAME (result
) && fn_returns_value_p
)
6618 /* Check for a return statement with no return value in a function
6619 that's supposed to return a value. */
6620 if (!retval
&& fn_returns_value_p
)
6622 pedwarn ("return-statement with no value, in function declared with a non-void return type");
6623 /* Clear this, so finish_function won't say that we reach the
6624 end of a non-void function (which we don't, we gave a
6626 current_function_returns_null
= 0;
6628 /* Check for a return statement with a value in a function that
6629 isn't supposed to return a value. */
6630 else if (retval
&& !fn_returns_value_p
)
6632 if (VOID_TYPE_P (TREE_TYPE (retval
)))
6633 /* You can return a `void' value from a function of `void'
6634 type. In that case, we have to evaluate the expression for
6635 its side-effects. */
6636 finish_expr_stmt (retval
);
6638 pedwarn ("return-statement with a value, in function declared with a void return type");
6640 current_function_returns_null
= 1;
6642 /* There's really no value to return, after all. */
6646 /* Remember that this function can sometimes return without a
6648 current_function_returns_null
= 1;
6650 /* Remember that this function did return a value. */
6651 current_function_returns_value
= 1;
6653 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
6654 if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == NEW_EXPR
6655 || DECL_OVERLOADED_OPERATOR_P (current_function_decl
) == VEC_NEW_EXPR
)
6656 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
6658 && null_ptr_cst_p (retval
))
6659 cp_warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
6661 /* Effective C++ rule 15. See also start_function. */
6663 && DECL_NAME (current_function_decl
) == ansi_assopname(NOP_EXPR
)
6664 && retval
!= current_class_ref
)
6665 cp_warning ("`operator=' should return a reference to `*this'");
6667 /* We don't need to do any conversions when there's nothing being
6669 if (!retval
|| retval
== error_mark_node
)
6672 /* Do any required conversions. */
6673 if (retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
6674 /* No conversions are required. */
6678 /* The type the function is declared to return. */
6679 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6681 /* First convert the value to the function's return type, then
6682 to the type of return value's location to handle the
6683 case that functype is smaller than the valtype. */
6684 retval
= convert_for_initialization
6685 (NULL_TREE
, functype
, retval
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
6686 "return", NULL_TREE
, 0);
6687 retval
= convert (valtype
, retval
);
6689 /* If the conversion failed, treat this just like `return;'. */
6690 if (retval
== error_mark_node
)
6692 /* We can't initialize a register from a AGGR_INIT_EXPR. */
6693 else if (! current_function_returns_struct
6694 && TREE_CODE (retval
) == TARGET_EXPR
6695 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
6696 retval
= build (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
6697 TREE_OPERAND (retval
, 0));
6699 maybe_warn_about_returning_address_of_local (retval
);
6702 /* Actually copy the value returned into the appropriate location. */
6703 if (retval
&& retval
!= result
)
6704 retval
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
6710 /* Returns non-zero if the pointer-type FROM can be converted to the
6711 pointer-type TO via a qualification conversion. If CONSTP is -1,
6712 then we return non-zero if the pointers are similar, and the
6713 cv-qualification signature of FROM is a proper subset of that of TO.
6715 If CONSTP is positive, then all outer pointers have been
6719 comp_ptr_ttypes_real (to
, from
, constp
)
6723 int to_more_cv_qualified
= 0;
6725 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
6727 if (TREE_CODE (to
) != TREE_CODE (from
))
6730 if (TREE_CODE (from
) == OFFSET_TYPE
6731 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
6732 TYPE_OFFSET_BASETYPE (to
)))
6735 /* Const and volatile mean something different for function types,
6736 so the usual checks are not appropriate. */
6737 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
6739 if (!at_least_as_qualified_p (to
, from
))
6742 if (!at_least_as_qualified_p (from
, to
))
6747 ++to_more_cv_qualified
;
6751 constp
&= TYPE_READONLY (to
);
6754 if (TREE_CODE (to
) != POINTER_TYPE
)
6756 same_type_ignoring_top_level_qualifiers_p (to
, from
)
6757 && (constp
>= 0 || to_more_cv_qualified
);
6761 /* When comparing, say, char ** to char const **, this function takes the
6762 'char *' and 'char const *'. Do not pass non-pointer types to this
6766 comp_ptr_ttypes (to
, from
)
6769 return comp_ptr_ttypes_real (to
, from
, 1);
6772 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6773 type or inheritance-related types, regardless of cv-quals. */
6776 ptr_reasonably_similar (to
, from
)
6779 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
6781 if (TREE_CODE (to
) != TREE_CODE (from
))
6784 if (TREE_CODE (from
) == OFFSET_TYPE
6785 && comptypes (TYPE_OFFSET_BASETYPE (to
),
6786 TYPE_OFFSET_BASETYPE (from
),
6787 COMPARE_BASE
| COMPARE_RELAXED
))
6790 if (TREE_CODE (to
) != POINTER_TYPE
)
6792 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
6793 COMPARE_BASE
| COMPARE_RELAXED
);
6797 /* Like comp_ptr_ttypes, for const_cast. */
6800 comp_ptr_ttypes_const (to
, from
)
6803 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
6805 if (TREE_CODE (to
) != TREE_CODE (from
))
6808 if (TREE_CODE (from
) == OFFSET_TYPE
6809 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
6810 TYPE_OFFSET_BASETYPE (to
)))
6813 if (TREE_CODE (to
) != POINTER_TYPE
)
6814 return same_type_ignoring_top_level_qualifiers_p (to
, from
);
6818 /* Like comp_ptr_ttypes, for reinterpret_cast. */
6821 comp_ptr_ttypes_reinterpret (to
, from
)
6826 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
6828 if (TREE_CODE (from
) == OFFSET_TYPE
)
6829 from
= TREE_TYPE (from
);
6830 if (TREE_CODE (to
) == OFFSET_TYPE
)
6831 to
= TREE_TYPE (to
);
6833 /* Const and volatile mean something different for function types,
6834 so the usual checks are not appropriate. */
6835 if (TREE_CODE (from
) != FUNCTION_TYPE
&& TREE_CODE (from
) != METHOD_TYPE
6836 && TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
6838 if (!at_least_as_qualified_p (to
, from
))
6842 && !at_least_as_qualified_p (from
, to
))
6844 constp
&= TYPE_READONLY (to
);
6847 if (TREE_CODE (from
) != POINTER_TYPE
6848 || TREE_CODE (to
) != POINTER_TYPE
)
6853 /* Returns the type-qualifier set corresponding to TYPE. */
6856 cp_type_quals (type
)
6859 type
= strip_array_types (type
);
6860 return TYPE_QUALS (type
);
6863 /* Returns non-zero if the TYPE contains a mutable member */
6866 cp_has_mutable_p (type
)
6869 type
= strip_array_types (type
);
6871 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
6874 /* Subroutine of casts_away_constness. Make T1 and T2 point at
6875 exemplar types such that casting T1 to T2 is casting away castness
6876 if and only if there is no implicit conversion from T1 to T2. */
6879 casts_away_constness_r (t1
, t2
)
6886 /* [expr.const.cast]
6888 For multi-level pointer to members and multi-level mixed pointers
6889 and pointers to members (conv.qual), the "member" aspect of a
6890 pointer to member level is ignored when determining if a const
6891 cv-qualifier has been cast away. */
6892 if (TYPE_PTRMEM_P (*t1
))
6893 *t1
= build_pointer_type (TREE_TYPE (TREE_TYPE (*t1
)));
6894 if (TYPE_PTRMEM_P (*t2
))
6895 *t2
= build_pointer_type (TREE_TYPE (TREE_TYPE (*t2
)));
6897 /* [expr.const.cast]
6899 For two pointer types:
6901 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
6902 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
6905 casting from X1 to X2 casts away constness if, for a non-pointer
6906 type T there does not exist an implicit conversion (clause
6909 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6913 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
6915 if (TREE_CODE (*t1
) != POINTER_TYPE
6916 || TREE_CODE (*t2
) != POINTER_TYPE
)
6918 *t1
= cp_build_qualified_type (void_type_node
,
6919 CP_TYPE_QUALS (*t1
));
6920 *t2
= cp_build_qualified_type (void_type_node
,
6921 CP_TYPE_QUALS (*t2
));
6925 quals1
= CP_TYPE_QUALS (*t1
);
6926 quals2
= CP_TYPE_QUALS (*t2
);
6927 *t1
= TREE_TYPE (*t1
);
6928 *t2
= TREE_TYPE (*t2
);
6929 casts_away_constness_r (t1
, t2
);
6930 *t1
= build_pointer_type (*t1
);
6931 *t2
= build_pointer_type (*t2
);
6932 *t1
= cp_build_qualified_type (*t1
, quals1
);
6933 *t2
= cp_build_qualified_type (*t2
, quals2
);
6936 /* Returns non-zero if casting from TYPE1 to TYPE2 casts away
6940 casts_away_constness (t1
, t2
)
6944 if (TREE_CODE (t2
) == REFERENCE_TYPE
)
6946 /* [expr.const.cast]
6948 Casting from an lvalue of type T1 to an lvalue of type T2
6949 using a reference cast casts away constness if a cast from an
6950 rvalue of type "pointer to T1" to the type "pointer to T2"
6951 casts away constness. */
6952 t1
= (TREE_CODE (t1
) == REFERENCE_TYPE
6953 ? TREE_TYPE (t1
) : t1
);
6954 return casts_away_constness (build_pointer_type (t1
),
6955 build_pointer_type (TREE_TYPE (t2
)));
6958 if (TYPE_PTRMEM_P (t1
) && TYPE_PTRMEM_P (t2
))
6959 /* [expr.const.cast]
6961 Casting from an rvalue of type "pointer to data member of X
6962 of type T1" to the type "pointer to data member of Y of type
6963 T2" casts away constness if a cast from an rvalue of type
6964 "poitner to T1" to the type "pointer to T2" casts away
6966 return casts_away_constness
6967 (build_pointer_type (TREE_TYPE (TREE_TYPE (t1
))),
6968 build_pointer_type (TREE_TYPE (TREE_TYPE (t2
))));
6970 /* Casting away constness is only something that makes sense for
6971 pointer or reference types. */
6972 if (TREE_CODE (t1
) != POINTER_TYPE
6973 || TREE_CODE (t2
) != POINTER_TYPE
)
6976 /* Top-level qualifiers don't matter. */
6977 t1
= TYPE_MAIN_VARIANT (t1
);
6978 t2
= TYPE_MAIN_VARIANT (t2
);
6979 casts_away_constness_r (&t1
, &t2
);
6980 if (!can_convert (t2
, t1
))
6986 /* Returns TYPE with its cv qualifiers removed
6987 TYPE is T cv* .. *cv where T is not a pointer type,
6988 returns T * .. *. (If T is an array type, then the cv qualifiers
6989 above are those of the array members.) */
6992 strip_all_pointer_quals (type
)
6995 if (TREE_CODE (type
) == POINTER_TYPE
)
6996 return build_pointer_type (strip_all_pointer_quals (TREE_TYPE (type
)));
6997 else if (TREE_CODE (type
) == OFFSET_TYPE
)
6998 return build_offset_type (TYPE_OFFSET_BASETYPE (type
),
6999 strip_all_pointer_quals (TREE_TYPE (type
)));
7001 return TYPE_MAIN_VARIANT (type
);