1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
42 extern void compiler_error ();
44 static tree convert_for_assignment
PROTO((tree
, tree
, char*, tree
,
46 static tree pointer_int_sum
PROTO((enum tree_code
, tree
, tree
));
47 static tree rationalize_conditional_expr
PROTO((enum tree_code
, tree
));
48 static int comp_target_parms
PROTO((tree
, tree
, int));
49 static int comp_ptr_ttypes_real
PROTO((tree
, tree
, int));
50 static int comp_ptr_ttypes_const
PROTO((tree
, tree
));
51 static int comp_ptr_ttypes_reinterpret
PROTO((tree
, tree
));
52 static int comp_array_types
PROTO((int (*) (tree
, tree
, int), tree
,
54 static tree build_ptrmemfunc1
PROTO((tree
, tree
, tree
, tree
, tree
));
55 static tree common_base_type
PROTO((tree
, tree
));
57 static tree convert_sequence
PROTO((tree
, tree
));
59 static tree lookup_anon_field
PROTO((tree
, tree
));
60 static tree pointer_diff
PROTO((tree
, tree
, tree
));
61 static tree qualify_type
PROTO((tree
, tree
));
62 static tree get_delta_difference
PROTO((tree
, tree
, int));
64 /* Return the target type of TYPE, which meas return T for:
65 T*, T&, T[], T (...), and otherwise, just T. */
71 if (TREE_CODE (type
) == REFERENCE_TYPE
)
72 type
= TREE_TYPE (type
);
73 while (TREE_CODE (type
) == POINTER_TYPE
74 || TREE_CODE (type
) == ARRAY_TYPE
75 || TREE_CODE (type
) == FUNCTION_TYPE
76 || TREE_CODE (type
) == METHOD_TYPE
77 || TREE_CODE (type
) == OFFSET_TYPE
)
78 type
= TREE_TYPE (type
);
82 /* Do `exp = require_complete_type (exp);' to make sure exp
83 does not have an incomplete type. (That includes void types.)
84 Returns the error_mark_node if the VALUE does not have
85 complete type when this function returns. */
88 require_complete_type (value
)
93 if (processing_template_decl
)
96 if (TREE_CODE (value
) == OVERLOAD
)
97 type
= unknown_type_node
;
99 type
= TREE_TYPE (value
);
101 /* First, detect a valid value with a complete type. */
102 if (TYPE_SIZE (type
) != 0
103 && type
!= void_type_node
104 && ! (TYPE_LANG_SPECIFIC (type
)
105 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
106 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
109 /* If we see X::Y, we build an OFFSET_TYPE which has
110 not been laid out. Try to avoid an error by interpreting
111 it as this->X::Y, if reasonable. */
112 if (TREE_CODE (value
) == OFFSET_REF
113 && current_class_ref
!= 0
114 && TREE_OPERAND (value
, 0) == current_class_ref
)
116 tree base
, member
= TREE_OPERAND (value
, 1);
117 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
118 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
119 base
= convert_pointer_to (basetype
, current_class_ptr
);
120 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
121 build_indirect_ref (base
, NULL_PTR
), member
);
122 return require_complete_type (value
);
125 if (complete_type_or_else (type
))
128 return error_mark_node
;
131 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
132 a template instantiation, do the instantiation. Returns TYPE,
133 whether or not it could be completed, unless something goes
134 horribly wrong, in which case the error_mark_node is returned. */
140 if (type
== NULL_TREE
)
141 /* Rather than crash, we return something sure to cause an error
143 return error_mark_node
;
145 if (type
== error_mark_node
|| TYPE_SIZE (type
) != NULL_TREE
)
147 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
149 tree t
= complete_type (TREE_TYPE (type
));
150 if (TYPE_SIZE (t
) != NULL_TREE
&& ! processing_template_decl
)
152 TYPE_NEEDS_CONSTRUCTING (type
)
153 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
154 TYPE_NEEDS_DESTRUCTOR (type
)
155 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
157 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
158 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
163 /* Like complete_type, but issue an error if the TYPE cannot be
164 completed. Returns NULL_TREE if the type cannot be made
168 complete_type_or_else (type
)
171 type
= complete_type (type
);
172 if (type
== error_mark_node
)
173 /* We already issued an error. */
175 else if (!TYPE_SIZE (type
))
177 incomplete_type_error (NULL_TREE
, type
);
184 /* Return truthvalue of whether type of EXP is instantiated. */
190 return (TREE_CODE (exp
) == OVERLOAD
191 || TREE_CODE (exp
) == TREE_LIST
192 || TREE_TYPE (exp
) == unknown_type_node
193 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
194 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
197 /* Return truthvalue of whether T is function (or pfn) type. */
203 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
204 || (TREE_CODE (t
) == POINTER_TYPE
205 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
206 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
209 /* Return a variant of TYPE which has all the type qualifiers of LIKE
210 as well as those of TYPE. */
213 qualify_type (type
, like
)
216 /* @@ Must do member pointers here. */
217 return cp_build_qualified_type (type
, (CP_TYPE_QUALS (type
)
218 | CP_TYPE_QUALS (like
)));
221 /* Return the common type of two parameter lists.
222 We assume that comptypes has already been done and returned 1;
223 if that isn't so, this may crash.
225 As an optimization, free the space we allocate if the parameter
226 lists are already common. */
232 tree oldargs
= p1
, newargs
, n
;
235 char *first_obj
= (char *) oballoc (0);
237 len
= list_length (p1
);
238 newargs
= tree_last (p1
);
240 if (newargs
== void_list_node
)
249 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
254 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
256 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
258 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
261 else if (! TREE_PURPOSE (p1
))
263 if (TREE_PURPOSE (p2
))
265 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
271 if (1 != simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)))
273 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
275 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
278 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
281 TREE_VALUE (n
) = TREE_VALUE (p1
);
292 /* Given a type, perhaps copied for a typedef,
293 find the "original" version of it. */
298 while (TYPE_NAME (t
) != NULL_TREE
)
300 tree x
= TYPE_NAME (t
);
301 if (TREE_CODE (x
) != TYPE_DECL
)
303 x
= DECL_ORIGINAL_TYPE (x
);
311 /* Return the common type of two types.
312 We assume that comptypes has already been done and returned 1;
313 if that isn't so, this may crash.
315 This is the type for the result of most arithmetic operations
316 if the operands have the given two types.
318 We do not deal with enumeral types here because they have already been
319 converted to integer types. */
325 register enum tree_code code1
;
326 register enum tree_code code2
;
329 /* Save time if the two types are the same. */
332 t1
= original_type (t1
);
333 t2
= original_type (t2
);
337 /* If one type is nonsense, use the other. */
338 if (t1
== error_mark_node
)
340 if (t2
== error_mark_node
)
343 /* Merge the attributes. */
344 attributes
= merge_machine_type_attributes (t1
, t2
);
346 { register tree a1
, a2
;
347 a1
= TYPE_ATTRIBUTES (t1
);
348 a2
= TYPE_ATTRIBUTES (t2
);
350 /* Either one unset? Take the set one. */
352 if (!(attributes
= a1
))
355 /* One that completely contains the other? Take it. */
357 else if (a2
&& !attribute_list_contained (a1
, a2
))
359 if (attribute_list_contained (a2
, a1
))
363 /* Pick the longest list, and hang on the other list. */
364 /* ??? For the moment we punt on the issue of attrs with args. */
366 if (list_length (a1
) < list_length (a2
))
367 attributes
= a2
, a2
= a1
;
369 for (; a2
; a2
= TREE_CHAIN (a2
))
370 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
371 attributes
) == NULL_TREE
)
374 TREE_CHAIN (a1
) = attributes
;
381 /* Treat an enum type as the unsigned integer type of the same width. */
383 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
384 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
385 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
386 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
388 if (TYPE_PTRMEMFUNC_P (t1
))
389 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
390 if (TYPE_PTRMEMFUNC_P (t2
))
391 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
393 code1
= TREE_CODE (t1
);
394 code2
= TREE_CODE (t2
);
396 /* If one type is complex, form the common type of the non-complex
397 components, then make that complex. Use T1 or T2 if it is the
399 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
401 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
402 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
403 tree subtype
= common_type (subtype1
, subtype2
);
405 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
406 return build_type_attribute_variant (t1
, attributes
);
407 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
408 return build_type_attribute_variant (t2
, attributes
);
410 return build_type_attribute_variant (build_complex_type (subtype
),
418 /* If only one is real, use it as the result. */
420 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
421 return build_type_attribute_variant (t1
, attributes
);
423 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
424 return build_type_attribute_variant (t2
, attributes
);
426 /* Both real or both integers; use the one with greater precision. */
428 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
429 return build_type_attribute_variant (t1
, attributes
);
430 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
431 return build_type_attribute_variant (t2
, attributes
);
433 /* Same precision. Prefer longs to ints even when same size. */
435 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
436 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
437 return build_type_attribute_variant (long_unsigned_type_node
,
440 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
441 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
443 /* But preserve unsignedness from the other type,
444 since long cannot hold all the values of an unsigned int. */
445 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
446 t1
= long_unsigned_type_node
;
448 t1
= long_integer_type_node
;
449 return build_type_attribute_variant (t1
, attributes
);
452 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
453 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
454 return build_type_attribute_variant (long_double_type_node
,
457 /* Otherwise prefer the unsigned one. */
459 if (TREE_UNSIGNED (t1
))
460 return build_type_attribute_variant (t1
, attributes
);
462 return build_type_attribute_variant (t2
, attributes
);
466 /* For two pointers, do this recursively on the target type,
467 and combine the qualifiers of the two types' targets. */
468 /* This code was turned off; I don't know why.
469 But ANSI C++ specifies doing this with the qualifiers.
470 So I turned it on again. */
472 tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (t1
));
473 tree tt2
= TYPE_MAIN_VARIANT (TREE_TYPE (t2
));
474 int type_quals
= (CP_TYPE_QUALS (TREE_TYPE (t1
))
475 | CP_TYPE_QUALS (TREE_TYPE (t2
)));
480 else if (tt1
== void_type_node
|| tt2
== void_type_node
)
481 target
= void_type_node
;
482 else if (tt1
== unknown_type_node
)
484 else if (tt2
== unknown_type_node
)
487 target
= common_type (tt1
, tt2
);
489 target
= cp_build_qualified_type (target
, type_quals
);
490 if (code1
== POINTER_TYPE
)
491 t1
= build_pointer_type (target
);
493 t1
= build_reference_type (target
);
494 t1
= build_type_attribute_variant (t1
, attributes
);
496 if (TREE_CODE (target
) == METHOD_TYPE
)
497 t1
= build_ptrmemfunc_type (t1
);
504 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
505 /* Save space: see if the result is identical to one of the args. */
506 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
507 return build_type_attribute_variant (t1
, attributes
);
508 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
509 return build_type_attribute_variant (t2
, attributes
);
510 /* Merge the element types, and have a size if either arg has one. */
511 t1
= build_cplus_array_type
512 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
513 return build_type_attribute_variant (t1
, attributes
);
517 /* Function types: prefer the one that specified arg types.
518 If both do, merge the arg types. Also merge the return types. */
520 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
521 tree p1
= TYPE_ARG_TYPES (t1
);
522 tree p2
= TYPE_ARG_TYPES (t2
);
525 /* Save space: see if the result is identical to one of the args. */
526 if (valtype
== TREE_TYPE (t1
) && ! p2
)
527 return build_type_attribute_variant (t1
, attributes
);
528 if (valtype
== TREE_TYPE (t2
) && ! p1
)
529 return build_type_attribute_variant (t2
, attributes
);
531 /* Simple way if one arg fails to specify argument types. */
532 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
534 rval
= build_function_type (valtype
, p2
);
535 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
536 rval
= build_exception_variant (rval
, raises
);
537 return build_type_attribute_variant (rval
, attributes
);
539 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
540 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
542 rval
= build_function_type (valtype
, p1
);
544 rval
= build_exception_variant (rval
, raises
);
545 return build_type_attribute_variant (rval
, attributes
);
548 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
549 rval
= build_exception_variant (rval
, raises
);
550 return build_type_attribute_variant (rval
, attributes
);
555 t1
= TYPE_MAIN_VARIANT (t1
);
556 t2
= TYPE_MAIN_VARIANT (t2
);
558 if (DERIVED_FROM_P (t1
, t2
) && binfo_or_else (t1
, t2
))
559 return build_type_attribute_variant (t1
, attributes
);
560 else if (binfo_or_else (t2
, t1
))
561 return build_type_attribute_variant (t2
, attributes
);
564 compiler_error ("common_type called with uncommon aggregate types");
565 return error_mark_node
;
569 if (TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
571 /* Get this value the long way, since TYPE_METHOD_BASETYPE
572 is just the main variant of this. */
576 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
577 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
579 if (same_type_p (b1
, b2
)
580 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
581 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
584 if (binfo_or_else (b2
, b1
) == NULL_TREE
)
585 compiler_error ("common_type called with uncommon method types");
586 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
589 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
591 /* If this was a member function type, get back to the
592 original type of type member function (i.e., without
593 the class instance variable up front. */
594 t1
= build_function_type (TREE_TYPE (t1
),
595 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
596 t2
= build_function_type (TREE_TYPE (t2
),
597 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
598 t3
= common_type (t1
, t2
);
599 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
),
600 TYPE_ARG_TYPES (t3
));
601 t1
= build_exception_variant (t3
, raises
);
604 compiler_error ("common_type called with uncommon method types");
606 return build_type_attribute_variant (t1
, attributes
);
609 if (TREE_TYPE (t1
) == TREE_TYPE (t2
))
611 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
612 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
614 if (same_type_p (b1
, b2
)
615 || (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
)))
616 return build_type_attribute_variant (t2
, attributes
);
617 else if (binfo_or_else (b2
, b1
))
618 return build_type_attribute_variant (t1
, attributes
);
620 compiler_error ("common_type called with uncommon member types");
623 return build_type_attribute_variant (t1
, attributes
);
627 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
630 compexcepttypes (t1
, t2
)
633 return TYPE_RAISES_EXCEPTIONS (t1
) == TYPE_RAISES_EXCEPTIONS (t2
);
636 /* Compare the array types T1 and T2, using CMP as the type comparison
637 function for the element types. STRICT is as for comptypes. */
640 comp_array_types (cmp
, t1
, t2
, strict
)
641 register int (*cmp
) PROTO((tree
, tree
, int));
651 /* The type of the array elements must be the same. */
652 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
653 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
),
654 strict
& ~COMPARE_REDECLARATION
)))
657 d1
= TYPE_DOMAIN (t1
);
658 d2
= TYPE_DOMAIN (t2
);
663 /* If one of the arrays is dimensionless, and the other has a
664 dimension, they are of different types. However, it is legal to
672 declarations for an array object can specify
673 array types that differ by the presence or absence of a major
674 array bound (_dcl.array_). */
676 return strict
& COMPARE_REDECLARATION
;
678 /* Check that the dimensions are the same. */
679 return (cp_tree_equal (TYPE_MIN_VALUE (d1
),
681 && cp_tree_equal (TYPE_MAX_VALUE (d1
),
682 TYPE_MAX_VALUE (d2
)));
685 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
686 or various other operations. STRICT is a bitwise-or of the
690 comptypes (type1
, type2
, strict
)
694 register tree t1
= type1
;
695 register tree t2
= type2
;
697 int orig_strict
= strict
;
699 /* The special exemption for redeclaring array types without an
700 array bound only applies at the top level:
705 is not legal, for example. */
706 strict
&= ~COMPARE_REDECLARATION
;
708 /* Suppress errors caused by previously reported errors */
712 /* This should never happen. */
713 my_friendly_assert (t1
!= error_mark_node
, 307);
715 if (t2
== error_mark_node
)
718 if (strict
& COMPARE_RELAXED
)
720 /* Treat an enum type as the unsigned integer type of the same width. */
722 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
723 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
724 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
725 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
731 if (TYPE_PTRMEMFUNC_P (t1
))
732 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
733 if (TYPE_PTRMEMFUNC_P (t2
))
734 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
736 /* Different classes of types can't be compatible. */
737 if (TREE_CODE (t1
) != TREE_CODE (t2
))
740 /* Qualifiers must match. */
741 if (CP_TYPE_QUALS (t1
) != CP_TYPE_QUALS (t2
))
743 if (strict
== COMPARE_STRICT
744 && TYPE_FOR_JAVA (t1
) != TYPE_FOR_JAVA (t2
))
747 /* Allow for two different type nodes which have essentially the same
748 definition. Note that we already checked for equality of the type
749 qualifiers (just above). */
751 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
754 /* ??? COMP_TYPE_ATTRIBUTES is currently useless for variables as each
755 attribute is its own main variant (`val' will remain 0). */
756 #ifndef COMP_TYPE_ATTRIBUTES
757 #define COMP_TYPE_ATTRIBUTES(t1,t2) 1
760 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
761 if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
764 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
767 switch (TREE_CODE (t1
))
769 case TEMPLATE_TEMPLATE_PARM
:
770 if (TEMPLATE_TYPE_IDX (t1
) != TEMPLATE_TYPE_IDX (t2
)
771 || TEMPLATE_TYPE_LEVEL (t1
) != TEMPLATE_TYPE_LEVEL (t2
))
773 if (! comp_template_parms (DECL_TEMPLATE_PARMS (TYPE_NAME (t1
)),
774 DECL_TEMPLATE_PARMS (TYPE_NAME (t2
))))
776 if (!TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t1
)
777 && ! TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
))
779 /* Don't check inheritance. */
780 strict
= COMPARE_STRICT
;
785 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
786 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
787 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
))
788 val
= comp_template_args (TYPE_TI_ARGS (t1
),
791 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
796 if ((strict
& COMPARE_RELAXED
) && DERIVED_FROM_P (t2
, t1
))
804 val
= (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1
)),
805 build_pointer_type (TYPE_OFFSET_BASETYPE (t2
)), strict
)
806 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
810 if (! compexcepttypes (t1
, t2
))
813 /* This case is anti-symmetrical!
814 One can pass a base member (or member function)
815 to something expecting a derived member (or member function),
816 but not vice-versa! */
818 val
= (comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
819 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
826 /* first, check whether the referred types match with the
827 required level of strictness */
828 val
= comptypes (t1
, t2
, strict
);
831 if (TREE_CODE (t1
) == RECORD_TYPE
832 && TREE_CODE (t2
) == RECORD_TYPE
)
837 if (! compexcepttypes (t1
, t2
))
840 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
841 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
842 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
846 /* Target types must match incl. qualifiers. We use ORIG_STRICT
847 here since this is the one place where
848 COMPARE_REDECLARATION should be used. */
849 val
= comp_array_types (comptypes
, t1
, t2
, orig_strict
);
852 case TEMPLATE_TYPE_PARM
:
853 return TEMPLATE_TYPE_IDX (t1
) == TEMPLATE_TYPE_IDX (t2
)
854 && TEMPLATE_TYPE_LEVEL (t1
) == TEMPLATE_TYPE_LEVEL (t2
);
857 if (TYPE_IDENTIFIER (t1
) != TYPE_IDENTIFIER (t2
))
859 return same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
864 return attrval
== 2 && val
== 1 ? 2 : val
;
867 /* Subroutine of comp_target-types. Make sure that the cv-quals change
868 only in the same direction as the target type. */
871 comp_cv_target_types (ttl
, ttr
, nptrs
)
877 if (!at_least_as_qualified_p (ttl
, ttr
)
878 && !at_least_as_qualified_p (ttr
, ttl
))
879 /* The qualifications are incomparable. */
882 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
))
883 return more_qualified_p (ttr
, ttl
) ? -1 : 1;
885 t
= comp_target_types (ttl
, ttr
, nptrs
);
886 if ((t
== 1 && at_least_as_qualified_p (ttl
, ttr
))
887 || (t
== -1 && at_least_as_qualified_p (ttr
, ttl
)))
893 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
894 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
895 converted to TTL. Return -1 means that TTL can be converted to TTR but
898 NPTRS is the number of pointers we can strip off and keep cool.
899 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
900 but to not permit B** to convert to A**.
902 This should go away. Callers should use can_convert or something
903 similar instead. (jason 17 Apr 1997) */
906 comp_target_types (ttl
, ttr
, nptrs
)
910 ttl
= TYPE_MAIN_VARIANT (ttl
);
911 ttr
= TYPE_MAIN_VARIANT (ttr
);
915 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
918 if ((TREE_CODE (ttr
) == POINTER_TYPE
919 || TREE_CODE (ttr
) == REFERENCE_TYPE
)
920 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
921 of the type pointed to. This is necessary for reference init
922 semantics. We won't get here from a previous call with nptrs == 1;
923 for multi-level pointers we end up in comp_ptr_ttypes. */
926 int is_ptr
= TREE_CODE (ttr
) == POINTER_TYPE
;
928 ttl
= TREE_TYPE (ttl
);
929 ttr
= TREE_TYPE (ttr
);
933 if (TREE_CODE (ttl
) == UNKNOWN_TYPE
934 || TREE_CODE (ttr
) == UNKNOWN_TYPE
)
936 else if (TREE_CODE (ttl
) == VOID_TYPE
937 && TREE_CODE (ttr
) != FUNCTION_TYPE
938 && TREE_CODE (ttr
) != METHOD_TYPE
939 && TREE_CODE (ttr
) != OFFSET_TYPE
)
941 else if (TREE_CODE (ttr
) == VOID_TYPE
942 && TREE_CODE (ttl
) != FUNCTION_TYPE
943 && TREE_CODE (ttl
) != METHOD_TYPE
944 && TREE_CODE (ttl
) != OFFSET_TYPE
)
946 else if (TREE_CODE (ttl
) == POINTER_TYPE
947 || TREE_CODE (ttl
) == ARRAY_TYPE
)
949 if (comp_ptr_ttypes (ttl
, ttr
))
951 else if (comp_ptr_ttypes (ttr
, ttl
))
957 /* Const and volatile mean something different for function types,
958 so the usual checks are not appropriate. */
959 if (TREE_CODE (ttl
) == FUNCTION_TYPE
|| TREE_CODE (ttl
) == METHOD_TYPE
)
960 return comp_target_types (ttl
, ttr
, nptrs
- 1);
962 return comp_cv_target_types (ttl
, ttr
, nptrs
- 1);
965 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
966 return comp_array_types (comp_target_types
, ttl
, ttr
, COMPARE_STRICT
);
967 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
974 if (!same_type_p (TREE_TYPE (ttl
), TREE_TYPE (ttr
)))
979 switch (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), -1))
988 argsl
= TYPE_ARG_TYPES (ttl
);
989 argsr
= TYPE_ARG_TYPES (ttr
);
991 /* Compare 'this' here, not in comp_target_parms. */
992 if (TREE_CODE (ttr
) == METHOD_TYPE
)
994 tree tl
= TYPE_METHOD_BASETYPE (ttl
);
995 tree tr
= TYPE_METHOD_BASETYPE (ttr
);
997 if (!same_or_base_type_p (tr
, tl
))
999 if (same_or_base_type_p (tl
, tr
))
1005 argsl
= TREE_CHAIN (argsl
);
1006 argsr
= TREE_CHAIN (argsr
);
1009 switch (comp_target_parms (argsl
, argsr
, 1))
1017 return saw_contra
? -1 : 1;
1020 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
1024 /* Contravariance: we can assign a pointer to base member to a pointer
1025 to derived member. Note difference from simple pointer case, where
1026 we can pass a pointer to derived to a pointer to base. */
1027 if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr
),
1028 TYPE_OFFSET_BASETYPE (ttl
)))
1030 else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl
),
1031 TYPE_OFFSET_BASETYPE (ttr
)))
1041 ttl
= TREE_TYPE (ttl
);
1042 ttr
= TREE_TYPE (ttr
);
1044 if (TREE_CODE (ttl
) == POINTER_TYPE
1045 || TREE_CODE (ttl
) == ARRAY_TYPE
)
1047 if (comp_ptr_ttypes (ttl
, ttr
))
1053 if (comp_cv_target_types (ttl
, ttr
, nptrs
) == 1)
1058 else if (IS_AGGR_TYPE (ttl
))
1062 if (same_or_base_type_p (build_pointer_type (ttl
),
1063 build_pointer_type (ttr
)))
1065 if (same_or_base_type_p (build_pointer_type (ttr
),
1066 build_pointer_type (ttl
)))
1074 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1077 at_least_as_qualified_p (type1
, type2
)
1081 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1082 return ((CP_TYPE_QUALS (type1
) & CP_TYPE_QUALS (type2
))
1083 == CP_TYPE_QUALS (type2
));
1086 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1089 more_qualified_p (type1
, type2
)
1093 return (CP_TYPE_QUALS (type1
) != CP_TYPE_QUALS (type2
)
1094 && at_least_as_qualified_p (type1
, type2
));
1097 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1098 more cv-qualified that TYPE1, and 0 otherwise. */
1101 comp_cv_qualification (type1
, type2
)
1105 if (CP_TYPE_QUALS (type1
) == CP_TYPE_QUALS (type2
))
1108 if (at_least_as_qualified_p (type1
, type2
))
1111 else if (at_least_as_qualified_p (type2
, type1
))
1117 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1118 subset of the cv-qualification signature of TYPE2, and the types
1119 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1122 comp_cv_qual_signature (type1
, type2
)
1126 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1128 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1134 /* If two types share a common base type, return that basetype.
1135 If there is not a unique most-derived base type, this function
1136 returns ERROR_MARK_NODE. */
1139 common_base_type (tt1
, tt2
)
1142 tree best
= NULL_TREE
;
1145 /* If one is a baseclass of another, that's good enough. */
1146 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
1148 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
1151 /* Otherwise, try to find a unique baseclass of TT1
1152 that is shared by TT2, and follow that down. */
1153 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
1155 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
1156 tree trial
= common_base_type (basetype
, tt2
);
1159 if (trial
== error_mark_node
)
1161 if (best
== NULL_TREE
)
1163 else if (best
!= trial
)
1164 return error_mark_node
;
1169 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
1171 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
1172 tree trial
= common_base_type (tt1
, basetype
);
1175 if (trial
== error_mark_node
)
1177 if (best
== NULL_TREE
)
1179 else if (best
!= trial
)
1180 return error_mark_node
;
1186 /* Subroutines of `comptypes'. */
1188 /* Return 1 if two parameter type lists PARMS1 and PARMS2
1189 are equivalent in the sense that functions with those parameter types
1190 can have equivalent types.
1191 If either list is empty, we win.
1192 Otherwise, the two lists must be equivalent, element by element.
1194 C++: See comment above about TYPE1, TYPE2.
1196 STRICT is no longer used. */
1199 compparms (parms1
, parms2
)
1200 tree parms1
, parms2
;
1202 register tree t1
= parms1
, t2
= parms2
;
1204 /* An unspecified parmlist matches any specified parmlist
1205 whose argument types don't need default promotions. */
1209 if (t1
== 0 && t2
== 0)
1211 /* If one parmlist is shorter than the other,
1212 they fail to match. */
1213 if (t1
== 0 || t2
== 0)
1215 if (!same_type_p (TREE_VALUE (t2
), TREE_VALUE (t1
)))
1218 t1
= TREE_CHAIN (t1
);
1219 t2
= TREE_CHAIN (t2
);
1223 /* This really wants return whether or not parameter type lists
1224 would make their owning functions assignment compatible or not.
1226 The return value is like for comp_target_types.
1228 This should go away, possibly with the exception of the empty parmlist
1229 conversion; there are no conversions between function types in C++.
1230 (jason 17 Apr 1997) */
1233 comp_target_parms (parms1
, parms2
, strict
)
1234 tree parms1
, parms2
;
1237 register tree t1
= parms1
, t2
= parms2
;
1238 int warn_contravariance
= 0;
1240 /* In C, an unspecified parmlist matches any specified parmlist
1241 whose argument types don't need default promotions. This is not
1242 true for C++, but let's do it anyway for unfixed headers. */
1244 if (t1
== 0 && t2
!= 0)
1246 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
1248 return self_promoting_args_p (t2
);
1251 return self_promoting_args_p (t1
);
1253 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1257 /* If one parmlist is shorter than the other,
1258 they fail to match, unless STRICT is <= 0. */
1259 if (t1
== 0 || t2
== 0)
1264 return 1 + warn_contravariance
;
1265 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
1267 p1
= TREE_VALUE (t1
);
1268 p2
= TREE_VALUE (t2
);
1269 if (same_type_p (p1
, p2
))
1275 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
1276 || (TREE_CODE (p1
) == REFERENCE_TYPE
1277 && TREE_CODE (p2
) == REFERENCE_TYPE
))
1280 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
1281 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1284 /* The following is wrong for contravariance,
1285 but many programs depend on it. */
1286 if (TREE_TYPE (p1
) == void_type_node
)
1288 if (TREE_TYPE (p2
) == void_type_node
)
1290 warn_contravariance
= 1;
1293 if (IS_AGGR_TYPE (TREE_TYPE (p1
))
1294 && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (p1
)),
1295 TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1298 /* Note backwards order due to contravariance. */
1299 if (comp_target_types (p2
, p1
, 1) <= 0)
1301 if (comp_target_types (p1
, p2
, 1) > 0)
1303 warn_contravariance
= 1;
1310 return warn_contravariance
? -1 : 1;
1313 /* Return 1 if PARMS specifies a fixed number of parameters
1314 and none of their types is affected by default promotions. */
1317 self_promoting_args_p (parms
)
1321 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1323 register tree type
= TREE_VALUE (t
);
1325 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1331 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1334 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1340 /* Return an unsigned type the same as TYPE in other respects.
1342 C++: must make these work for type variants as well. */
1345 unsigned_type (type
)
1348 tree type1
= TYPE_MAIN_VARIANT (type
);
1349 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1350 return unsigned_char_type_node
;
1351 if (type1
== integer_type_node
)
1352 return unsigned_type_node
;
1353 if (type1
== short_integer_type_node
)
1354 return short_unsigned_type_node
;
1355 if (type1
== long_integer_type_node
)
1356 return long_unsigned_type_node
;
1357 if (type1
== long_long_integer_type_node
)
1358 return long_long_unsigned_type_node
;
1359 #if HOST_BITS_PER_WIDE_INT >= 64
1360 if (type1
== intTI_type_node
)
1361 return unsigned_intTI_type_node
;
1363 if (type1
== intDI_type_node
)
1364 return unsigned_intDI_type_node
;
1365 if (type1
== intSI_type_node
)
1366 return unsigned_intSI_type_node
;
1367 if (type1
== intHI_type_node
)
1368 return unsigned_intHI_type_node
;
1369 if (type1
== intQI_type_node
)
1370 return unsigned_intQI_type_node
;
1372 return signed_or_unsigned_type (1, type
);
1375 /* Return a signed type the same as TYPE in other respects. */
1381 tree type1
= TYPE_MAIN_VARIANT (type
);
1382 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1383 return signed_char_type_node
;
1384 if (type1
== unsigned_type_node
)
1385 return integer_type_node
;
1386 if (type1
== short_unsigned_type_node
)
1387 return short_integer_type_node
;
1388 if (type1
== long_unsigned_type_node
)
1389 return long_integer_type_node
;
1390 if (type1
== long_long_unsigned_type_node
)
1391 return long_long_integer_type_node
;
1392 #if HOST_BITS_PER_WIDE_INT >= 64
1393 if (type1
== unsigned_intTI_type_node
)
1394 return intTI_type_node
;
1396 if (type1
== unsigned_intDI_type_node
)
1397 return intDI_type_node
;
1398 if (type1
== unsigned_intSI_type_node
)
1399 return intSI_type_node
;
1400 if (type1
== unsigned_intHI_type_node
)
1401 return intHI_type_node
;
1402 if (type1
== unsigned_intQI_type_node
)
1403 return intQI_type_node
;
1405 return signed_or_unsigned_type (0, type
);
1408 /* Return a type the same as TYPE except unsigned or
1409 signed according to UNSIGNEDP. */
1412 signed_or_unsigned_type (unsignedp
, type
)
1416 if (! INTEGRAL_TYPE_P (type
)
1417 || TREE_UNSIGNED (type
) == unsignedp
)
1420 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1421 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1422 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1423 return unsignedp
? unsigned_type_node
: integer_type_node
;
1424 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1425 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1426 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1427 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1428 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1429 return (unsignedp
? long_long_unsigned_type_node
1430 : long_long_integer_type_node
);
1434 /* Compute the value of the `sizeof' operator. */
1440 enum tree_code code
= TREE_CODE (type
);
1443 if (processing_template_decl
)
1444 return build_min (SIZEOF_EXPR
, sizetype
, type
);
1446 if (code
== FUNCTION_TYPE
)
1448 if (pedantic
|| warn_pointer_arith
)
1449 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1450 return size_int (1);
1452 if (code
== METHOD_TYPE
)
1454 if (pedantic
|| warn_pointer_arith
)
1455 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1456 return size_int (1);
1458 if (code
== VOID_TYPE
)
1460 if (pedantic
|| warn_pointer_arith
)
1461 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1462 return size_int (1);
1464 if (code
== ERROR_MARK
)
1465 return size_int (1);
1467 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1468 referenced object.'' */
1469 if (code
== REFERENCE_TYPE
)
1470 type
= TREE_TYPE (type
);
1472 /* We couldn't find anything in the ARM or the draft standard that says,
1473 one way or the other, if doing sizeof on something that doesn't have
1474 an object associated with it is correct or incorrect. For example, if
1475 you declare `struct S { char str[16]; };', and in your program do
1476 a `sizeof (S::str)', should we flag that as an error or should we give
1477 the size of it? Since it seems like a reasonable thing to do, we'll go
1478 with giving the value. */
1479 if (code
== OFFSET_TYPE
)
1480 type
= TREE_TYPE (type
);
1482 /* @@ This also produces an error for a signature ref.
1483 In that case we should be able to do better. */
1484 if (IS_SIGNATURE (type
))
1486 error ("`sizeof' applied to a signature type");
1487 return size_int (0);
1490 if (TYPE_SIZE (complete_type (type
)) == 0)
1492 cp_error ("`sizeof' applied to incomplete type `%T'", type
);
1493 return size_int (0);
1496 /* Convert in case a char is more than one unit. */
1497 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1498 size_int (TYPE_PRECISION (char_type_node
)));
1499 t
= convert (sizetype
, t
);
1500 /* size_binop does not put the constant in range, so do it now. */
1501 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1502 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1510 if (processing_template_decl
)
1511 return build_min (SIZEOF_EXPR
, sizetype
, e
);
1513 if (TREE_CODE (e
) == COMPONENT_REF
1514 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1515 error ("sizeof applied to a bit-field");
1516 /* ANSI says arrays and functions are converted inside comma.
1517 But we can't really convert them in build_compound_expr
1518 because that would break commas in lvalues.
1519 So do the conversion here if operand was a comma. */
1520 if (TREE_CODE (e
) == COMPOUND_EXPR
1521 && (TREE_CODE (TREE_TYPE (e
)) == ARRAY_TYPE
1522 || TREE_CODE (TREE_TYPE (e
)) == FUNCTION_TYPE
))
1523 e
= default_conversion (e
);
1524 else if (is_overloaded_fn (e
))
1526 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1527 return size_int (1);
1530 return c_sizeof (TREE_TYPE (e
));
1534 c_sizeof_nowarn (type
)
1537 enum tree_code code
= TREE_CODE (type
);
1540 if (code
== FUNCTION_TYPE
1541 || code
== METHOD_TYPE
1542 || code
== VOID_TYPE
1543 || code
== ERROR_MARK
)
1544 return size_int (1);
1545 if (code
== REFERENCE_TYPE
)
1546 type
= TREE_TYPE (type
);
1548 if (TYPE_SIZE (type
) == 0)
1549 return size_int (0);
1551 /* Convert in case a char is more than one unit. */
1552 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1553 size_int (TYPE_PRECISION (char_type_node
)));
1554 t
= convert (sizetype
, t
);
1555 force_fit_type (t
, 0);
1559 /* Implement the __alignof keyword: Return the minimum required
1560 alignment of TYPE, measured in bytes. */
1566 enum tree_code code
= TREE_CODE (type
);
1569 if (processing_template_decl
)
1570 return build_min (ALIGNOF_EXPR
, sizetype
, type
);
1572 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1573 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1575 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1576 return size_int (1);
1578 /* C++: this is really correct! */
1579 if (code
== REFERENCE_TYPE
)
1580 type
= TREE_TYPE (type
);
1582 /* @@ This also produces an error for a signature ref.
1583 In that case we should be able to do better. */
1584 if (IS_SIGNATURE (type
))
1586 error ("`__alignof' applied to a signature type");
1587 return size_int (1);
1590 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1591 force_fit_type (t
, 0);
1595 /* Perform default promotions for C data used in expressions.
1596 Arrays and functions are converted to pointers;
1597 enumeral types or short or char, to int.
1598 In addition, manifest constants symbols are replaced by their values.
1600 C++: this will automatically bash references to their target type. */
1603 decay_conversion (exp
)
1606 register tree type
= TREE_TYPE (exp
);
1607 register enum tree_code code
= TREE_CODE (type
);
1609 if (code
== OFFSET_TYPE
)
1611 if (TREE_CODE (exp
) == OFFSET_REF
)
1612 return decay_conversion (resolve_offset_ref (exp
));
1614 type
= TREE_TYPE (type
);
1615 code
= TREE_CODE (type
);
1617 if (type
== unknown_type_node
)
1619 cp_pedwarn ("assuming & on overloaded member function");
1620 return build_unary_op (ADDR_EXPR
, exp
, 0);
1624 if (code
== REFERENCE_TYPE
)
1626 exp
= convert_from_reference (exp
);
1627 type
= TREE_TYPE (exp
);
1628 code
= TREE_CODE (type
);
1631 /* Constants can be used directly unless they're not loadable. */
1632 if (TREE_CODE (exp
) == CONST_DECL
)
1633 exp
= DECL_INITIAL (exp
);
1634 /* Replace a nonvolatile const static variable with its value. */
1635 else if (TREE_READONLY_DECL_P (exp
))
1637 exp
= decl_constant_value (exp
);
1638 type
= TREE_TYPE (exp
);
1641 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1642 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1644 if (code
== VOID_TYPE
)
1646 error ("void value not ignored as it ought to be");
1647 return error_mark_node
;
1649 if (code
== METHOD_TYPE
)
1651 cp_pedwarn ("assuming & on `%E'", exp
);
1652 return build_unary_op (ADDR_EXPR
, exp
, 0);
1654 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1656 return build_unary_op (ADDR_EXPR
, exp
, 0);
1658 if (code
== ARRAY_TYPE
)
1663 if (TREE_CODE (exp
) == INDIRECT_REF
)
1665 /* Stripping away the INDIRECT_REF is not the right
1666 thing to do for references... */
1667 tree inner
= TREE_OPERAND (exp
, 0);
1668 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1670 inner
= build1 (CONVERT_EXPR
,
1671 build_pointer_type (TREE_TYPE
1672 (TREE_TYPE (inner
))),
1674 TREE_CONSTANT (inner
) = TREE_CONSTANT (TREE_OPERAND (inner
, 0));
1676 return cp_convert (build_pointer_type (TREE_TYPE (type
)), inner
);
1679 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1681 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1682 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1683 TREE_OPERAND (exp
, 0), op1
);
1687 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1689 error ("invalid use of non-lvalue array");
1690 return error_mark_node
;
1693 ptrtype
= build_pointer_type (TREE_TYPE (type
));
1695 if (TREE_CODE (exp
) == VAR_DECL
)
1697 /* ??? This is not really quite correct
1698 in that the type of the operand of ADDR_EXPR
1699 is not the target type of the type of the ADDR_EXPR itself.
1700 Question is, can this lossage be avoided? */
1701 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1702 if (mark_addressable (exp
) == 0)
1703 return error_mark_node
;
1704 TREE_CONSTANT (adr
) = staticp (exp
);
1705 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1708 /* This way is better for a COMPONENT_REF since it can
1709 simplify the offset for a component. */
1710 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1711 return cp_convert (ptrtype
, adr
);
1718 default_conversion (exp
)
1722 enum tree_code code
;
1724 exp
= decay_conversion (exp
);
1726 type
= TREE_TYPE (exp
);
1727 code
= TREE_CODE (type
);
1729 if (INTEGRAL_CODE_P (code
))
1731 tree t
= type_promotes_to (type
);
1733 return cp_convert (t
, exp
);
1739 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1743 inline_conversion (exp
)
1746 if (TREE_CODE (exp
) == FUNCTION_DECL
)
1747 exp
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (exp
)), exp
);
1752 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1753 decay_conversion to one. */
1756 string_conv_p (totype
, exp
, warn
)
1762 if (! flag_const_strings
|| TREE_CODE (totype
) != POINTER_TYPE
)
1765 t
= TREE_TYPE (totype
);
1766 if (!same_type_p (t
, char_type_node
)
1767 && !same_type_p (t
, wchar_type_node
))
1770 if (TREE_CODE (exp
) == STRING_CST
)
1772 /* Make sure that we don't try to convert between char and wchar_t. */
1773 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))) != t
)
1778 /* Is this a string constant which has decayed to 'const char *'? */
1779 t
= build_pointer_type (build_qualified_type (t
, TYPE_QUAL_CONST
));
1780 if (!same_type_p (TREE_TYPE (exp
), t
))
1783 if (TREE_CODE (exp
) != ADDR_EXPR
1784 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1788 /* This warning is not very useful, as it complains about printf. */
1789 if (warn
&& warn_write_strings
)
1790 cp_warning ("deprecated conversion from string constant to `%T'", totype
);
1796 build_object_ref (datum
, basetype
, field
)
1797 tree datum
, basetype
, field
;
1800 if (datum
== error_mark_node
)
1801 return error_mark_node
;
1803 dtype
= TREE_TYPE (datum
);
1804 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1805 dtype
= TREE_TYPE (dtype
);
1806 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1808 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1809 basetype
, field
, dtype
);
1810 return error_mark_node
;
1812 else if (IS_SIGNATURE (basetype
))
1814 warning ("signature name in scope resolution ignored");
1815 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1817 else if (is_aggr_type (basetype
, 1))
1819 tree binfo
= binfo_or_else (basetype
, dtype
);
1821 return build_x_component_ref (build_scoped_ref (datum
, basetype
),
1824 return error_mark_node
;
1827 /* Like `build_component_ref, but uses an already found field, and converts
1828 from a reference. Must compute access for current_class_ref.
1832 build_component_ref_1 (datum
, field
, protect
)
1836 return convert_from_reference
1837 (build_component_ref (datum
, field
, NULL_TREE
, protect
));
1840 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1841 can, for example, use as an lvalue. This code used to be in
1842 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1843 expressions, where we're dealing with aggregates. But now it's again only
1844 called from unary_complex_lvalue. The case (in particular) that led to
1845 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1849 rationalize_conditional_expr (code
, t
)
1850 enum tree_code code
;
1853 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1854 the first operand is always the one to be used if both operands
1855 are equal, so we know what conditional expression this used to be. */
1856 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1859 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1860 ? LE_EXPR
: GE_EXPR
),
1861 TREE_OPERAND (t
, 0),
1862 TREE_OPERAND (t
, 1)),
1863 build_unary_op (code
, TREE_OPERAND (t
, 0), 0),
1864 build_unary_op (code
, TREE_OPERAND (t
, 1), 0));
1868 build_conditional_expr (TREE_OPERAND (t
, 0),
1869 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1870 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1873 /* Given the TYPE of an anonymous union field inside T, return the
1874 FIELD_DECL for the field. If not found return NULL_TREE. Because
1875 anonymous unions can nest, we must also search all anonymous unions
1876 that are directly reachable. */
1879 lookup_anon_field (t
, type
)
1884 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1886 if (TREE_STATIC (field
))
1888 if (TREE_CODE (field
) != FIELD_DECL
)
1891 /* If we find it directly, return the field. */
1892 if (DECL_NAME (field
) == NULL_TREE
1893 && type
== TREE_TYPE (field
))
1898 /* Otherwise, it could be nested, search harder. */
1899 if (DECL_NAME (field
) == NULL_TREE
1900 && TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1902 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
1910 /* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT.
1911 COMPONENT can be an IDENTIFIER_NODE that is the name of the member
1912 that we are interested in, or it can be a FIELD_DECL. */
1915 build_component_ref (datum
, component
, basetype_path
, protect
)
1916 tree datum
, component
, basetype_path
;
1919 register tree basetype
;
1920 register enum tree_code code
;
1921 register tree field
= NULL
;
1926 if (processing_template_decl
)
1927 return build_min_nt (COMPONENT_REF
, datum
, component
);
1929 if (datum
== error_mark_node
1930 || TREE_TYPE (datum
) == error_mark_node
)
1931 return error_mark_node
;
1933 /* BASETYPE holds the type of the class containing the COMPONENT. */
1934 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1936 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
1938 switch (TREE_CODE (datum
))
1942 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1943 basetype_path
, protect
);
1944 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1945 TREE_OPERAND (datum
, 0), value
);
1948 return build_conditional_expr
1949 (TREE_OPERAND (datum
, 0),
1950 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1951 basetype_path
, protect
),
1952 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1953 basetype_path
, protect
));
1956 cp_error ("invalid use of %D", datum
);
1957 datum
= error_mark_node
;
1964 code
= TREE_CODE (basetype
);
1966 if (code
== REFERENCE_TYPE
)
1968 datum
= convert_from_reference (datum
);
1969 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1970 code
= TREE_CODE (basetype
);
1972 if (TREE_CODE (datum
) == OFFSET_REF
)
1974 datum
= resolve_offset_ref (datum
);
1975 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1976 code
= TREE_CODE (basetype
);
1979 /* First, see if there is a field or component with name COMPONENT. */
1980 if (TREE_CODE (component
) == TREE_LIST
)
1982 /* I could not trigger this code. MvL */
1983 my_friendly_abort (980326);
1985 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1986 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1988 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1991 if (! IS_AGGR_TYPE_CODE (code
))
1993 if (code
!= ERROR_MARK
)
1994 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1995 component
, datum
, basetype
);
1996 return error_mark_node
;
1999 if (!complete_type_or_else (basetype
))
2000 return error_mark_node
;
2002 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
2004 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
2006 cp_error ("destructor specifier `%T::~%T' must have matching names",
2007 basetype
, TREE_OPERAND (component
, 0));
2008 return error_mark_node
;
2010 if (! TYPE_HAS_DESTRUCTOR (basetype
))
2012 cp_error ("type `%T' has no destructor", basetype
);
2013 return error_mark_node
;
2015 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1);
2018 /* Look up component name in the structure type definition. */
2019 if (CLASSTYPE_VFIELD (basetype
)
2020 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
2021 /* Special-case this because if we use normal lookups in an ambiguous
2022 hierarchy, the compiler will abort (because vptr lookups are
2023 not supposed to be ambiguous. */
2024 field
= CLASSTYPE_VFIELD (basetype
);
2025 else if (TREE_CODE (component
) == FIELD_DECL
)
2027 else if (TREE_CODE (component
) == TYPE_DECL
)
2029 cp_error ("invalid use of type decl `%#D' as expression", component
);
2030 return error_mark_node
;
2034 tree name
= component
;
2035 if (TREE_CODE (component
) == VAR_DECL
)
2036 name
= DECL_NAME (component
);
2037 if (basetype_path
== NULL_TREE
)
2038 basetype_path
= TYPE_BINFO (basetype
);
2039 field
= lookup_field (basetype_path
, name
,
2040 protect
&& !VFIELD_NAME_P (name
), 0);
2041 if (field
== error_mark_node
)
2042 return error_mark_node
;
2044 if (field
== NULL_TREE
)
2046 /* Not found as a data field, look for it as a method. If found,
2047 then if this is the only possible one, return it, else
2048 report ambiguity error. */
2049 tree fndecls
= lookup_fnfields (basetype_path
, name
, 1);
2050 if (fndecls
== error_mark_node
)
2051 return error_mark_node
;
2054 /* If the function is unique and static, we can resolve it
2055 now. Otherwise, we have to wait and see what context it is
2056 used in; a component_ref involving a non-static member
2057 function can only be used in a call (expr.ref). */
2058 if (TREE_CHAIN (fndecls
) == NULL_TREE
2059 && TREE_CODE (TREE_VALUE (fndecls
)) == FUNCTION_DECL
2060 && DECL_STATIC_FUNCTION_P (TREE_VALUE (fndecls
)))
2064 basetype
= TYPE_MAIN_VARIANT (TREE_PURPOSE (fndecls
));
2065 fndecl
= TREE_VALUE (fndecls
);
2066 enforce_access (TREE_PURPOSE (fndecls
), fndecl
);
2072 ref
= build (COMPONENT_REF
, unknown_type_node
,
2078 cp_error ("`%#T' has no member named `%D'", basetype
, name
);
2079 return error_mark_node
;
2081 else if (TREE_TYPE (field
) == error_mark_node
)
2082 return error_mark_node
;
2084 if (TREE_CODE (field
) != FIELD_DECL
)
2086 if (TREE_CODE (field
) == TYPE_DECL
)
2087 cp_pedwarn ("invalid use of type decl `%#D' as expression", field
);
2088 else if (DECL_RTL (field
) != 0)
2091 TREE_USED (field
) = 1;
2096 /* See if we have to do any conversions so that we pick up the field from the
2098 if (DECL_FIELD_CONTEXT (field
) != basetype
)
2100 tree context
= DECL_FIELD_CONTEXT (field
);
2101 tree base
= context
;
2102 while (!same_type_p (base
, basetype
) && TYPE_NAME (base
)
2103 && ANON_UNION_TYPE_P (base
))
2105 base
= TYPE_CONTEXT (base
);
2108 /* Handle base classes here... */
2109 if (base
!= basetype
&& TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2111 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
2112 if (integer_zerop (addr
))
2114 error ("invalid reference to NULL ptr, use ptr-to-member instead");
2115 return error_mark_node
;
2117 if (VBASE_NAME_P (DECL_NAME (field
)))
2119 /* It doesn't matter which vbase pointer we grab, just
2120 find one of them. */
2121 tree binfo
= get_binfo (base
,
2122 TREE_TYPE (TREE_TYPE (addr
)), 0);
2123 addr
= convert_pointer_to_real (binfo
, addr
);
2126 addr
= convert_pointer_to (base
, addr
);
2127 datum
= build_indirect_ref (addr
, NULL_PTR
);
2128 my_friendly_assert (datum
!= error_mark_node
, 311);
2132 /* Handle things from anon unions here... */
2133 if (TYPE_NAME (context
) && ANON_UNION_TYPE_P (context
))
2135 tree subfield
= lookup_anon_field (basetype
, context
);
2136 tree subdatum
= build_component_ref (datum
, subfield
,
2137 basetype_path
, protect
);
2138 return build_component_ref (subdatum
, field
, basetype_path
, protect
);
2142 /* Compute the type of the field, as described in [expr.ref]. */
2143 type_quals
= TYPE_UNQUALIFIED
;
2144 field_type
= TREE_TYPE (field
);
2145 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
2146 /* The standard says that the type of the result should be the
2147 type referred to by the reference. But for now, at least, we
2148 do the conversion from reference type later. */
2152 type_quals
= (CP_TYPE_QUALS (field_type
)
2153 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
2155 /* A field is const (volatile) if the enclosing object, or the
2156 field itself, is const (volatile). But, a mutable field is
2157 not const, even within a const object. */
2158 if (DECL_LANG_SPECIFIC (field
) && DECL_MUTABLE_P (field
))
2159 type_quals
&= ~TYPE_QUAL_CONST
;
2160 if (!IS_SIGNATURE (field_type
))
2161 field_type
= cp_build_qualified_type (field_type
, type_quals
);
2164 ref
= fold (build (COMPONENT_REF
, field_type
,
2165 break_out_cleanups (datum
), field
));
2167 /* Mark the expression const or volatile, as appropriate. Even
2168 though we've dealt with the type above, we still have to mark the
2169 expression itself. */
2170 if (type_quals
& TYPE_QUAL_CONST
)
2171 TREE_READONLY (ref
) = 1;
2172 else if (type_quals
& TYPE_QUAL_VOLATILE
)
2173 TREE_THIS_VOLATILE (ref
) = 1;
2178 /* Variant of build_component_ref for use in expressions, which should
2179 never have REFERENCE_TYPE. */
2182 build_x_component_ref (datum
, component
, basetype_path
, protect
)
2183 tree datum
, component
, basetype_path
;
2186 tree t
= build_component_ref (datum
, component
, basetype_path
, protect
);
2188 if (! processing_template_decl
)
2189 t
= convert_from_reference (t
);
2194 /* Given an expression PTR for a pointer, return an expression
2195 for the value pointed to.
2196 ERRORSTRING is the name of the operator to appear in error messages.
2198 This function may need to overload OPERATOR_FNNAME.
2199 Must also handle REFERENCE_TYPEs for C++. */
2202 build_x_indirect_ref (ptr
, errorstring
)
2208 if (processing_template_decl
)
2209 return build_min_nt (INDIRECT_REF
, ptr
);
2211 rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
,
2215 return build_indirect_ref (ptr
, errorstring
);
2219 build_indirect_ref (ptr
, errorstring
)
2223 register tree pointer
, type
;
2225 if (ptr
== error_mark_node
)
2226 return error_mark_node
;
2228 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2229 ? ptr
: default_conversion (ptr
));
2230 type
= TREE_TYPE (pointer
);
2232 if (ptr
== current_class_ptr
)
2233 return current_class_ref
;
2235 if (TYPE_PTR_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
2239 If the type of the expression is "pointer to T," the type
2240 of the result is "T."
2242 We must use the canonical variant because certain parts of
2243 the back end, like fold, do pointer comparisons between
2245 tree t
= canonical_type_variant (TREE_TYPE (type
));
2247 if (TREE_CODE (pointer
) == ADDR_EXPR
2249 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
2250 /* The POINTER was something like `&x'. We simplify `*&x' to
2252 return TREE_OPERAND (pointer
, 0);
2255 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
2257 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2258 so that we get the proper error message if the result is used
2259 to assign to. Also, &* is supposed to be a no-op. */
2260 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
2261 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
2262 TREE_SIDE_EFFECTS (ref
)
2263 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
)
2268 /* `pointer' won't be an error_mark_node if we were given a
2269 pointer to member, so it's cool to check for this here. */
2270 else if (TYPE_PTRMEM_P (type
) || TYPE_PTRMEMFUNC_P (type
))
2271 error ("invalid use of `%s' on pointer to member", errorstring
);
2272 else if (TREE_CODE (type
) == RECORD_TYPE
2273 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
2274 error ("cannot dereference signature pointer/reference");
2275 else if (pointer
!= error_mark_node
)
2278 error ("invalid type argument of `%s'", errorstring
);
2280 error ("invalid type argument");
2282 return error_mark_node
;
2285 /* This handles expressions of the form "a[i]", which denotes
2288 This is logically equivalent in C to *(a+i), but we may do it differently.
2289 If A is a variable or a member, we generate a primitive ARRAY_REF.
2290 This avoids forcing the array out of registers, and can work on
2291 arrays that are not lvalues (for example, members of structures returned
2294 If INDEX is of some user-defined type, it must be converted to
2295 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2296 will inherit the type of the array, which will be some pointer type. */
2299 build_array_ref (array
, idx
)
2304 error ("subscript missing in array reference");
2305 return error_mark_node
;
2308 if (TREE_TYPE (array
) == error_mark_node
2309 || TREE_TYPE (idx
) == error_mark_node
)
2310 return error_mark_node
;
2312 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
2313 && TREE_CODE (array
) != INDIRECT_REF
)
2317 /* Subscripting with type char is likely to lose
2318 on a machine where chars are signed.
2319 So warn on any machine, but optionally.
2320 Don't warn for unsigned char since that type is safe.
2321 Don't warn for signed char because anyone who uses that
2322 must have done so deliberately. */
2323 if (warn_char_subscripts
2324 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
2325 warning ("array subscript has type `char'");
2327 /* Apply default promotions *after* noticing character types. */
2328 idx
= default_conversion (idx
);
2330 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
2332 error ("array subscript is not an integer");
2333 return error_mark_node
;
2336 /* An array that is indexed by a non-constant
2337 cannot be stored in a register; we must be able to do
2338 address arithmetic on its address.
2339 Likewise an array of elements of variable size. */
2340 if (TREE_CODE (idx
) != INTEGER_CST
2341 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
2342 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2345 if (mark_addressable (array
) == 0)
2346 return error_mark_node
;
2348 /* An array that is indexed by a constant value which is not within
2349 the array bounds cannot be stored in a register either; because we
2350 would get a crash in store_bit_field/extract_bit_field when trying
2351 to access a non-existent part of the register. */
2352 if (TREE_CODE (idx
) == INTEGER_CST
2353 && TYPE_VALUES (TREE_TYPE (array
))
2354 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
2356 if (mark_addressable (array
) == 0)
2357 return error_mark_node
;
2360 if (pedantic
&& !lvalue_p (array
))
2361 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
2363 /* Note in C++ it is valid to subscript a `register' array, since
2364 it is valid to take the address of something with that
2365 storage specification. */
2369 while (TREE_CODE (foo
) == COMPONENT_REF
)
2370 foo
= TREE_OPERAND (foo
, 0);
2371 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2372 warning ("subscripting array declared `register'");
2375 type
= TREE_TYPE (TREE_TYPE (array
));
2376 rval
= build (ARRAY_REF
, type
, array
, idx
);
2377 /* Array ref is const/volatile if the array elements are
2378 or if the array is.. */
2379 TREE_READONLY (rval
)
2380 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
2381 TREE_SIDE_EFFECTS (rval
)
2382 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
2383 TREE_THIS_VOLATILE (rval
)
2384 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
2385 return require_complete_type (fold (rval
));
2389 tree ar
= default_conversion (array
);
2390 tree ind
= default_conversion (idx
);
2392 /* Put the integer in IND to simplify error checking. */
2393 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2400 if (ar
== error_mark_node
)
2403 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2405 error ("subscripted value is neither array nor pointer");
2406 return error_mark_node
;
2408 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2410 error ("array subscript is not an integer");
2411 return error_mark_node
;
2414 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
,
2420 /* Build a function call to function FUNCTION with parameters PARAMS.
2421 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2422 TREE_VALUE of each node is a parameter-expression. The PARAMS do
2423 not include any object pointer that may be required. FUNCTION's
2424 data type may be a function type or a pointer-to-function.
2426 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2427 is the list of possible methods that FUNCTION could conceivably
2428 be. If the list of methods comes from a class, then it will be
2429 a list of lists (where each element is associated with the class
2430 that produced it), otherwise it will be a simple list (for
2431 functions overloaded in global scope).
2433 In the first case, TREE_VALUE (function) is the head of one of those
2434 lists, and TREE_PURPOSE is the name of the function.
2436 In the second case, TREE_PURPOSE (function) is the function's
2439 DECL is the class instance variable, usually CURRENT_CLASS_REF.
2441 When calling a TEMPLATE_DECL, we don't require a complete return
2445 build_x_function_call (function
, params
, decl
)
2446 tree function
, params
, decl
;
2449 tree template_id
= NULL_TREE
;
2452 if (function
== error_mark_node
)
2453 return error_mark_node
;
2455 if (processing_template_decl
)
2456 return build_min_nt (CALL_EXPR
, function
, params
, NULL_TREE
);
2458 /* Save explicit template arguments if found */
2459 if (TREE_CODE (function
) == TEMPLATE_ID_EXPR
)
2461 template_id
= function
;
2462 function
= TREE_OPERAND (function
, 0);
2465 type
= TREE_TYPE (function
);
2467 if (TREE_CODE (type
) == OFFSET_TYPE
2468 && TREE_TYPE (type
) == unknown_type_node
2469 && TREE_CODE (function
) == TREE_LIST
2470 && TREE_CHAIN (function
) == NULL_TREE
)
2472 /* Undo (Foo:bar)()... */
2473 type
= TYPE_OFFSET_BASETYPE (type
);
2474 function
= TREE_VALUE (function
);
2475 my_friendly_assert (TREE_CODE (function
) == TREE_LIST
, 999);
2476 my_friendly_assert (TREE_CHAIN (function
) == NULL_TREE
, 999);
2477 function
= TREE_VALUE (function
);
2478 if (TREE_CODE (function
) == OVERLOAD
)
2479 function
= OVL_FUNCTION (function
);
2480 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 999);
2481 function
= DECL_NAME (function
);
2482 return build_method_call (decl
, function
, params
,
2483 TYPE_BINFO (type
), LOOKUP_NORMAL
);
2486 is_method
= ((TREE_CODE (function
) == TREE_LIST
2487 && current_class_type
!= NULL_TREE
2488 && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
))
2490 || TREE_CODE (function
) == IDENTIFIER_NODE
2491 || TREE_CODE (type
) == METHOD_TYPE
2492 || TYPE_PTRMEMFUNC_P (type
));
2494 if ((TREE_CODE (function
) == FUNCTION_DECL
2495 && DECL_STATIC_FUNCTION_P (function
))
2496 || (TREE_CODE (function
) == TEMPLATE_DECL
2497 && DECL_STATIC_FUNCTION_P (DECL_RESULT (function
))))
2498 return build_member_call
2499 (DECL_CONTEXT (function
), DECL_NAME (function
), params
);
2501 /* A friend template. Make it look like a toplevel declaration. */
2502 if (! is_method
&& TREE_CODE (function
) == TEMPLATE_DECL
)
2503 function
= scratch_ovl_cons (function
, NULL_TREE
);
2505 /* Handle methods, friends, and overloaded functions, respectively. */
2508 tree basetype
= NULL_TREE
;
2510 if (TREE_CODE (function
) == FUNCTION_DECL
2511 || DECL_FUNCTION_TEMPLATE_P (function
))
2513 basetype
= DECL_CLASS_CONTEXT (function
);
2515 if (DECL_NAME (function
))
2516 function
= DECL_NAME (function
);
2518 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2520 else if (TREE_CODE (function
) == TREE_LIST
)
2522 my_friendly_assert (TREE_CODE (TREE_VALUE (function
))
2523 == FUNCTION_DECL
, 312);
2524 basetype
= DECL_CLASS_CONTEXT (TREE_VALUE (function
));
2525 function
= TREE_PURPOSE (function
);
2527 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2529 if (TREE_CODE (function
) == OFFSET_REF
)
2531 if (TREE_OPERAND (function
, 0))
2532 decl
= TREE_OPERAND (function
, 0);
2534 /* Call via a pointer to member function. */
2535 if (decl
== NULL_TREE
)
2537 error ("pointer to member function called, but not in class scope");
2538 return error_mark_node
;
2540 /* What other type of POINTER_TYPE could this be? */
2541 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2542 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2543 && TREE_CODE (function
) != OFFSET_REF
)
2544 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
,
2549 /* this is an abbreviated method call.
2550 must go through here in case it is a virtual function.
2551 @@ Perhaps this could be optimized. */
2553 if (basetype
&& (! current_class_type
2554 || ! DERIVED_FROM_P (basetype
, current_class_type
)))
2555 return build_member_call (basetype
, function
, params
);
2557 if (decl
== NULL_TREE
)
2559 if (current_class_type
== NULL_TREE
)
2561 error ("object missing in call to method `%s'",
2562 IDENTIFIER_POINTER (function
));
2563 return error_mark_node
;
2565 /* Yow: call from a static member function. */
2566 decl
= build_dummy_object (current_class_type
);
2569 /* Put back explicit template arguments, if any. */
2571 function
= template_id
;
2572 return build_method_call (decl
, function
, params
,
2573 NULL_TREE
, LOOKUP_NORMAL
);
2575 else if (TREE_CODE (function
) == COMPONENT_REF
2576 && type
== unknown_type_node
)
2578 /* Undo what we did in build_component_ref. */
2579 decl
= TREE_OPERAND (function
, 0);
2580 function
= TREE_OPERAND (function
, 1);
2581 function
= DECL_NAME (OVL_CURRENT (TREE_VALUE (function
)));
2582 return build_method_call (decl
, function
, params
,
2583 NULL_TREE
, LOOKUP_NORMAL
);
2585 else if (really_overloaded_fn (function
))
2587 if (OVL_FUNCTION (function
) == NULL_TREE
)
2589 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2590 TREE_PURPOSE (function
));
2591 return error_mark_node
;
2595 /* Put back explicit template arguments, if any. */
2597 function
= template_id
;
2598 return build_new_function_call (function
, params
);
2602 /* Remove a potential OVERLOAD around it */
2603 function
= OVL_CURRENT (function
);
2606 if (TREE_CODE (function
) == OFFSET_REF
)
2608 /* If the component is a data element (or a virtual function), we play
2609 games here to make things work. */
2612 if (TREE_OPERAND (function
, 0))
2613 decl
= TREE_OPERAND (function
, 0);
2615 decl
= current_class_ref
;
2617 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2619 /* Sigh. OFFSET_REFs are being used for too many things.
2620 They're being used both for -> and ->*, and we want to resolve
2621 the -> cases here, but leave the ->*. We could use
2622 resolve_offset_ref for those, too, but it would call
2623 get_member_function_from_ptrfunc and decl_addr wouldn't get
2624 updated properly. Nasty. */
2625 if (TREE_CODE (TREE_OPERAND (function
, 1)) == FIELD_DECL
)
2626 function
= resolve_offset_ref (function
);
2628 function
= TREE_OPERAND (function
, 1);
2630 function
= get_member_function_from_ptrfunc (&decl_addr
, function
);
2631 params
= expr_tree_cons (NULL_TREE
, decl_addr
, params
);
2632 return build_function_call (function
, params
);
2635 type
= TREE_TYPE (function
);
2636 if (type
!= error_mark_node
)
2638 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2639 type
= TREE_TYPE (type
);
2641 if (IS_AGGR_TYPE (type
))
2642 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2647 tree fntype
= TREE_TYPE (function
);
2648 tree ctypeptr
= NULL_TREE
;
2650 /* Explicitly named method? */
2651 if (TREE_CODE (function
) == FUNCTION_DECL
)
2652 ctypeptr
= build_pointer_type (DECL_CLASS_CONTEXT (function
));
2653 /* Expression with ptr-to-method type? It could either be a plain
2654 usage, or it might be a case where the ptr-to-method is being
2655 passed in as an argument. */
2656 else if (TYPE_PTRMEMFUNC_P (fntype
))
2658 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE
2659 (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2660 ctypeptr
= build_pointer_type (rec
);
2662 /* Unexpected node type? */
2664 my_friendly_abort (116);
2665 if (decl
== NULL_TREE
)
2667 if (current_function_decl
2668 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2669 error ("invalid call to member function needing `this' in static member function scope");
2671 error ("pointer to member function called, but not in class scope");
2672 return error_mark_node
;
2674 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2675 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2677 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2678 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2681 decl
= build_c_cast (ctypeptr
, decl
);
2682 params
= expr_tree_cons (NULL_TREE
, decl
, params
);
2685 return build_function_call (function
, params
);
2688 /* Resolve a pointer to member function. INSTANCE is the object
2689 instance to use, if the member points to a virtual member. */
2692 get_member_function_from_ptrfunc (instance_ptrptr
, function
)
2693 tree
*instance_ptrptr
;
2696 if (TREE_CODE (function
) == OFFSET_REF
)
2698 function
= TREE_OPERAND (function
, 1);
2701 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2703 tree fntype
, idx
, e1
, delta
, delta2
, e2
, e3
, aref
, vtbl
;
2704 tree instance
, basetype
;
2706 tree instance_ptr
= *instance_ptrptr
;
2708 if (TREE_SIDE_EFFECTS (instance_ptr
))
2709 instance_ptr
= save_expr (instance_ptr
);
2711 if (TREE_SIDE_EFFECTS (function
))
2712 function
= save_expr (function
);
2714 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2715 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2717 delta
= cp_convert (ptrdiff_type_node
,
2718 build_component_ref (function
, delta_identifier
,
2720 e3
= PFN_FROM_PTRMEMFUNC (function
);
2722 if (TYPE_SIZE (basetype
) != NULL_TREE
2723 && ! TYPE_VIRTUAL_P (basetype
))
2724 /* If basetype doesn't have virtual functions, don't emit code to
2725 handle that case. */
2729 /* Promoting idx before saving it improves performance on RISC
2730 targets. Without promoting, the first compare used
2731 load-with-sign-extend, while the second used normal load then
2732 shift to sign-extend. An optimizer flaw, perhaps, but it's
2733 easier to make this change. */
2734 idx
= save_expr (default_conversion
2735 (build_component_ref (function
,
2738 e1
= build_binary_op (GT_EXPR
, idx
, integer_zero_node
, 1);
2740 /* Convert down to the right base, before using the instance. */
2741 instance
= convert_pointer_to_real (basetype
, instance_ptr
);
2742 if (instance
== error_mark_node
&& instance_ptr
!= error_mark_node
)
2745 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2746 delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2749 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2750 vtbl
, cp_convert (ptrdiff_type_node
, delta2
));
2751 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2752 aref
= build_array_ref (vtbl
, build_binary_op (MINUS_EXPR
,
2754 integer_one_node
, 1));
2755 if (! flag_vtable_thunks
)
2757 aref
= save_expr (aref
);
2759 delta
= build_binary_op
2761 build_conditional_expr (e1
,
2762 build_component_ref (aref
,
2769 if (flag_vtable_thunks
)
2772 e2
= build_component_ref (aref
, pfn_identifier
, NULL_TREE
, 0);
2773 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2774 e1
= build_conditional_expr (e1
, e2
, e3
);
2776 /* Make sure this doesn't get evaluated first inside one of the
2777 branches of the COND_EXPR. */
2778 if (TREE_CODE (instance_ptr
) == SAVE_EXPR
)
2779 e1
= build (COMPOUND_EXPR
, TREE_TYPE (e1
),
2783 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2784 instance_ptr
, delta
);
2786 if (instance_ptr
== error_mark_node
2787 && TREE_CODE (e1
) != ADDR_EXPR
2788 && TREE_CODE (TREE_OPERAND (e1
, 0)) != FUNCTION_DECL
)
2789 cp_error ("object missing in `%E'", function
);
2797 build_function_call_real (function
, params
, require_complete
, flags
)
2798 tree function
, params
;
2799 int require_complete
, flags
;
2801 register tree fntype
, fndecl
;
2802 register tree value_type
;
2803 register tree coerced_params
;
2804 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2807 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2808 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2809 if (TREE_CODE (function
) == NOP_EXPR
2810 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2811 function
= TREE_OPERAND (function
, 0);
2813 if (TREE_CODE (function
) == FUNCTION_DECL
)
2815 name
= DECL_NAME (function
);
2816 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2818 GNU_xref_call (current_function_decl
,
2819 IDENTIFIER_POINTER (name
? name
2820 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
2822 mark_used (function
);
2825 /* Convert anything with function type to a pointer-to-function. */
2826 if (pedantic
&& DECL_MAIN_P (function
))
2827 pedwarn ("ANSI C++ forbids calling `main' from within program");
2829 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2830 (because calling an inline function does not mean the function
2831 needs to be separately compiled). */
2833 if (DECL_INLINE (function
))
2834 function
= inline_conversion (function
);
2836 function
= build_addr_func (function
);
2842 function
= build_addr_func (function
);
2845 if (function
== error_mark_node
)
2846 return error_mark_node
;
2848 fntype
= TREE_TYPE (function
);
2850 if (TYPE_PTRMEMFUNC_P (fntype
))
2852 cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2854 return error_mark_node
;
2857 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2858 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2860 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2861 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2863 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
2865 cp_error ("`%E' cannot be used as a function", function
);
2866 return error_mark_node
;
2869 /* fntype now gets the type of function pointed to. */
2870 fntype
= TREE_TYPE (fntype
);
2872 /* Convert the parameters to the types declared in the
2873 function prototype, or apply default promotions. */
2875 if (flags
& LOOKUP_COMPLAIN
)
2876 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2877 params
, fndecl
, LOOKUP_NORMAL
);
2879 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2882 if (coerced_params
== error_mark_node
)
2884 if (flags
& LOOKUP_SPECULATIVELY
)
2887 return error_mark_node
;
2890 /* Check for errors in format strings. */
2892 if (warn_format
&& (name
|| assembler_name
))
2893 check_function_format (name
, assembler_name
, coerced_params
);
2895 /* Recognize certain built-in functions so we can make tree-codes
2896 other than CALL_EXPR. We do this when it enables fold-const.c
2897 to do something useful. */
2899 if (TREE_CODE (function
) == ADDR_EXPR
2900 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2901 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2902 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2907 if (coerced_params
== 0)
2908 return integer_zero_node
;
2909 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2916 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2918 register tree result
2919 = build_call (function
, value_type
, coerced_params
);
2921 if (require_complete
)
2923 if (value_type
== void_type_node
)
2925 result
= require_complete_type (result
);
2927 if (IS_AGGR_TYPE (value_type
))
2928 result
= build_cplus_new (value_type
, result
);
2929 return convert_from_reference (result
);
2934 build_function_call (function
, params
)
2935 tree function
, params
;
2937 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2940 /* Convert the actual parameter expressions in the list VALUES
2941 to the types in the list TYPELIST.
2942 If parmdecls is exhausted, or when an element has NULL as its type,
2943 perform the default conversions.
2945 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2947 This is also where warnings about wrong number of args are generated.
2949 Return a list of expressions for the parameters as converted.
2951 Both VALUES and the returned value are chains of TREE_LIST nodes
2952 with the elements of the list in the TREE_VALUE slots of those nodes.
2954 In C++, unspecified trailing parameters can be filled in with their
2955 default arguments, if such were specified. Do so here. */
2958 convert_arguments (typelist
, values
, fndecl
, flags
)
2959 tree typelist
, values
, fndecl
;
2962 register tree typetail
, valtail
;
2963 register tree result
= NULL_TREE
;
2964 char *called_thing
= 0;
2967 /* Argument passing is always copy-initialization. */
2968 flags
|= LOOKUP_ONLYCONVERTING
;
2972 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2974 if (DECL_NAME (fndecl
) == NULL_TREE
2975 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2976 called_thing
= "constructor";
2978 called_thing
= "member function";
2981 called_thing
= "function";
2984 for (valtail
= values
, typetail
= typelist
;
2986 valtail
= TREE_CHAIN (valtail
), i
++)
2988 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2989 register tree val
= TREE_VALUE (valtail
);
2991 if (val
== error_mark_node
)
2992 return error_mark_node
;
2994 if (type
== void_type_node
)
2998 cp_error_at ("too many arguments to %s `%+D'", called_thing
,
3000 error ("at this point in file");
3003 error ("too many arguments to function");
3004 /* In case anybody wants to know if this argument
3007 TREE_TYPE (tree_last (result
)) = error_mark_node
;
3011 if (TREE_CODE (val
) == OFFSET_REF
)
3012 val
= resolve_offset_ref (val
);
3014 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3015 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3016 if (TREE_CODE (val
) == NOP_EXPR
3017 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3018 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3019 val
= TREE_OPERAND (val
, 0);
3021 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3023 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3024 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3025 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3026 val
= default_conversion (val
);
3028 val
= require_complete_type (val
);
3031 if (val
== error_mark_node
)
3032 return error_mark_node
;
3036 /* Formal parm type is specified by a function prototype. */
3039 if (TYPE_SIZE (complete_type (type
)) == 0)
3041 error ("parameter type of called function is incomplete");
3046 parmval
= convert_for_initialization
3047 (NULL_TREE
, type
, val
, flags
,
3048 "argument passing", fndecl
, i
);
3049 #ifdef PROMOTE_PROTOTYPES
3050 if ((TREE_CODE (type
) == INTEGER_TYPE
3051 || TREE_CODE (type
) == ENUMERAL_TYPE
)
3052 && (TYPE_PRECISION (type
)
3053 < TYPE_PRECISION (integer_type_node
)))
3054 parmval
= default_conversion (parmval
);
3058 if (parmval
== error_mark_node
)
3059 return error_mark_node
;
3061 result
= expr_tree_cons (NULL_TREE
, parmval
, result
);
3065 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
3066 val
= convert_from_reference (val
);
3068 result
= expr_tree_cons (NULL_TREE
,
3069 convert_arg_to_ellipsis (val
),
3074 typetail
= TREE_CHAIN (typetail
);
3077 if (typetail
!= 0 && typetail
!= void_list_node
)
3079 /* See if there are default arguments that can be used */
3080 if (TREE_PURPOSE (typetail
))
3082 for (; typetail
!= void_list_node
; ++i
)
3084 tree type
= TREE_VALUE (typetail
);
3085 tree val
= TREE_PURPOSE (typetail
);
3086 tree parmval
= convert_default_arg (type
, val
);
3088 if (parmval
== error_mark_node
)
3089 return error_mark_node
;
3091 result
= expr_tree_cons (0, parmval
, result
);
3092 typetail
= TREE_CHAIN (typetail
);
3093 /* ends with `...'. */
3094 if (typetail
== NULL_TREE
)
3102 char *buf
= (char *)alloca (32 + strlen (called_thing
));
3103 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
3104 cp_error_at (buf
, fndecl
);
3105 error ("at this point in file");
3108 error ("too few arguments to function");
3109 return error_mark_list
;
3113 return nreverse (result
);
3116 /* Build a binary-operation expression, after performing default
3117 conversions on the operands. CODE is the kind of expression to build. */
3120 build_x_binary_op (code
, arg1
, arg2
)
3121 enum tree_code code
;
3124 if (processing_template_decl
)
3125 return build_min_nt (code
, arg1
, arg2
);
3127 return build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
3131 build_binary_op (code
, arg1
, arg2
, convert_p
)
3132 enum tree_code code
;
3136 return build_binary_op_nodefault (code
, arg1
, arg2
, code
);
3139 /* Build a binary-operation expression without default conversions.
3140 CODE is the kind of expression to build.
3141 This function differs from `build' in several ways:
3142 the data type of the result is computed and recorded in it,
3143 warnings are generated if arg data types are invalid,
3144 special handling for addition and subtraction of pointers is known,
3145 and some optimization is done (operations on narrow ints
3146 are done in the narrower type when that gives the same result).
3147 Constant folding is also done before the result is returned.
3149 ERROR_CODE is the code that determines what to say in error messages.
3150 It is usually, but not always, the same as CODE.
3152 Note that the operands will never have enumeral types
3153 because either they have just had the default conversions performed
3154 or they have both just been converted to some other type in which
3155 the arithmetic is to be done.
3157 C++: must do special pointer arithmetic when implementing
3158 multiple inheritance, and deal with pointer to member functions. */
3161 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
3162 enum tree_code code
;
3163 tree orig_op0
, orig_op1
;
3164 enum tree_code error_code
;
3167 register enum tree_code code0
, code1
;
3170 /* Expression code to give to the expression when it is built.
3171 Normally this is CODE, which is what the caller asked for,
3172 but in some special cases we change it. */
3173 register enum tree_code resultcode
= code
;
3175 /* Data type in which the computation is to be performed.
3176 In the simplest cases this is the common type of the arguments. */
3177 register tree result_type
= NULL
;
3179 /* Nonzero means operands have already been type-converted
3180 in whatever way is necessary.
3181 Zero means they need to be converted to RESULT_TYPE. */
3184 /* Nonzero means create the expression with this type, rather than
3186 tree build_type
= 0;
3188 /* Nonzero means after finally constructing the expression
3189 convert it to this type. */
3190 tree final_type
= 0;
3192 /* Nonzero if this is an operation like MIN or MAX which can
3193 safely be computed in short if both args are promoted shorts.
3194 Also implies COMMON.
3195 -1 indicates a bitwise operation; this makes a difference
3196 in the exact conditions for when it is safe to do the operation
3197 in a narrower mode. */
3200 /* Nonzero if this is a comparison operation;
3201 if both args are promoted shorts, compare the original shorts.
3202 Also implies COMMON. */
3203 int short_compare
= 0;
3205 /* Nonzero if this is a right-shift operation, which can be computed on the
3206 original short and then promoted if the operand is a promoted short. */
3207 int short_shift
= 0;
3209 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3212 /* Apply default conversions. */
3213 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3214 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3215 || code
== TRUTH_XOR_EXPR
)
3217 op0
= decay_conversion (orig_op0
);
3218 op1
= decay_conversion (orig_op1
);
3222 op0
= default_conversion (orig_op0
);
3223 op1
= default_conversion (orig_op1
);
3226 type0
= TREE_TYPE (op0
);
3227 type1
= TREE_TYPE (op1
);
3229 /* The expression codes of the data types of the arguments tell us
3230 whether the arguments are integers, floating, pointers, etc. */
3231 code0
= TREE_CODE (type0
);
3232 code1
= TREE_CODE (type1
);
3234 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3235 STRIP_TYPE_NOPS (op0
);
3236 STRIP_TYPE_NOPS (op1
);
3238 /* If an error was already reported for one of the arguments,
3239 avoid reporting another error. */
3241 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3242 return error_mark_node
;
3247 /* Handle the pointer + int case. */
3248 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3249 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
3250 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
3251 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
3257 /* Subtraction of two similar pointers.
3258 We must subtract them as integers, then divide by object size. */
3259 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3260 && comp_target_types (type0
, type1
, 1))
3261 return pointer_diff (op0
, op1
, common_type (type0
, type1
));
3262 /* Handle pointer minus int. Just like pointer plus int. */
3263 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3264 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
3273 case TRUNC_DIV_EXPR
:
3275 case FLOOR_DIV_EXPR
:
3276 case ROUND_DIV_EXPR
:
3277 case EXACT_DIV_EXPR
:
3278 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3279 || code0
== COMPLEX_TYPE
)
3280 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3281 || code1
== COMPLEX_TYPE
))
3283 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
3284 cp_warning ("division by zero in `%E / 0'", op0
);
3285 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
3286 cp_warning ("division by zero in `%E / 0.'", op0
);
3288 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
3289 resultcode
= RDIV_EXPR
;
3291 /* When dividing two signed integers, we have to promote to int.
3292 unless we divide by a constant != -1. Note that default
3293 conversion will have been performed on the operands at this
3294 point, so we have to dig out the original type to find out if
3296 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3297 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3298 || (TREE_CODE (op1
) == INTEGER_CST
3299 && (TREE_INT_CST_LOW (op1
) != -1
3300 || TREE_INT_CST_HIGH (op1
) != -1)));
3306 case BIT_ANDTC_EXPR
:
3309 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3311 /* If one operand is a constant, and the other is a short type
3312 that has been converted to an int,
3313 really do the work in the short type and then convert the
3314 result to int. If we are lucky, the constant will be 0 or 1
3315 in the short type, making the entire operation go away. */
3316 if (TREE_CODE (op0
) == INTEGER_CST
3317 && TREE_CODE (op1
) == NOP_EXPR
3318 && (TYPE_PRECISION (type1
)
3319 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3320 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3322 final_type
= result_type
;
3323 op1
= TREE_OPERAND (op1
, 0);
3324 result_type
= TREE_TYPE (op1
);
3326 if (TREE_CODE (op1
) == INTEGER_CST
3327 && TREE_CODE (op0
) == NOP_EXPR
3328 && (TYPE_PRECISION (type0
)
3329 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3330 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3332 final_type
= result_type
;
3333 op0
= TREE_OPERAND (op0
, 0);
3334 result_type
= TREE_TYPE (op0
);
3338 case TRUNC_MOD_EXPR
:
3339 case FLOOR_MOD_EXPR
:
3340 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
3341 cp_warning ("division by zero in `%E %% 0'", op0
);
3342 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
3343 cp_warning ("division by zero in `%E %% 0.'", op0
);
3345 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3347 /* Although it would be tempting to shorten always here, that loses
3348 on some targets, since the modulo instruction is undefined if the
3349 quotient can't be represented in the computation mode. We shorten
3350 only if unsigned or if dividing by something we know != -1. */
3351 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3352 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3353 || (TREE_CODE (op1
) == INTEGER_CST
3354 && (TREE_INT_CST_LOW (op1
) != -1
3355 || TREE_INT_CST_HIGH (op1
) != -1)));
3360 case TRUTH_ANDIF_EXPR
:
3361 case TRUTH_ORIF_EXPR
:
3362 case TRUTH_AND_EXPR
:
3364 result_type
= boolean_type_node
;
3367 /* Shift operations: result has same type as first operand;
3368 always convert second operand to int.
3369 Also set SHORT_SHIFT if shifting rightward. */
3372 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3374 result_type
= type0
;
3375 if (TREE_CODE (op1
) == INTEGER_CST
)
3377 if (tree_int_cst_lt (op1
, integer_zero_node
))
3378 warning ("right shift count is negative");
3381 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3383 if (TREE_INT_CST_HIGH (op1
) != 0
3384 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3385 >= TYPE_PRECISION (type0
)))
3386 warning ("right shift count >= width of type");
3389 /* Convert the shift-count to an integer, regardless of
3390 size of value being shifted. */
3391 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3392 op1
= cp_convert (integer_type_node
, op1
);
3393 /* Avoid converting op1 to result_type later. */
3399 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3401 result_type
= type0
;
3402 if (TREE_CODE (op1
) == INTEGER_CST
)
3404 if (tree_int_cst_lt (op1
, integer_zero_node
))
3405 warning ("left shift count is negative");
3406 else if (TREE_INT_CST_HIGH (op1
) != 0
3407 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3408 >= TYPE_PRECISION (type0
)))
3409 warning ("left shift count >= width of type");
3411 /* Convert the shift-count to an integer, regardless of
3412 size of value being shifted. */
3413 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3414 op1
= cp_convert (integer_type_node
, op1
);
3415 /* Avoid converting op1 to result_type later. */
3422 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3424 result_type
= type0
;
3425 if (TREE_CODE (op1
) == INTEGER_CST
)
3427 if (tree_int_cst_lt (op1
, integer_zero_node
))
3428 warning ("%s rotate count is negative",
3429 (code
== LROTATE_EXPR
) ? "left" : "right");
3430 else if (TREE_INT_CST_HIGH (op1
) != 0
3431 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3432 >= TYPE_PRECISION (type0
)))
3433 warning ("%s rotate count >= width of type",
3434 (code
== LROTATE_EXPR
) ? "left" : "right");
3436 /* Convert the shift-count to an integer, regardless of
3437 size of value being shifted. */
3438 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3439 op1
= cp_convert (integer_type_node
, op1
);
3445 build_type
= boolean_type_node
;
3446 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3447 || code0
== COMPLEX_TYPE
)
3448 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3449 || code1
== COMPLEX_TYPE
))
3451 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3453 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3454 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3456 if (comp_target_types (type0
, type1
, 1))
3457 result_type
= common_type (type0
, type1
);
3458 else if (tt0
== void_type_node
)
3460 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3461 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3462 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3463 else if (TREE_CODE (tt1
) == OFFSET_TYPE
)
3464 pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
3466 else if (tt1
== void_type_node
)
3468 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3469 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3470 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3473 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3476 if (result_type
== NULL_TREE
)
3477 result_type
= ptr_type_node
;
3479 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3480 && integer_zerop (op1
))
3481 result_type
= type0
;
3482 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3483 && integer_zerop (op0
))
3484 result_type
= type1
;
3485 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3487 result_type
= type0
;
3488 error ("ANSI C++ forbids comparison between pointer and integer");
3490 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3492 result_type
= type1
;
3493 error ("ANSI C++ forbids comparison between pointer and integer");
3495 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3496 && integer_zerop (op1
))
3498 op0
= build_component_ref (op0
, index_identifier
, NULL_TREE
, 0);
3499 op1
= integer_zero_node
;
3500 result_type
= TREE_TYPE (op0
);
3502 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3503 && integer_zerop (op0
))
3505 op0
= build_component_ref (op1
, index_identifier
, NULL_TREE
, 0);
3506 op1
= integer_zero_node
;
3507 result_type
= TREE_TYPE (op0
);
3509 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3510 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3511 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3513 /* The code we generate for the test is:
3515 (op0.index == op1.index
3516 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3517 || op0.pfn == op1.pfn)) */
3519 tree index0
= build_component_ref (op0
, index_identifier
,
3521 tree index1
= save_expr (build_component_ref (op1
, index_identifier
,
3523 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3524 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3525 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3526 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3528 tree integer_neg_one_node
3529 = build_binary_op (MINUS_EXPR
, integer_zero_node
,
3530 integer_one_node
, 1);
3531 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3532 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3533 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3534 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3536 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3537 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3538 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3539 if (code
== EQ_EXPR
)
3541 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3543 else if (TYPE_PTRMEMFUNC_P (type0
)
3544 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3546 tree index0
= build_component_ref (op0
, index_identifier
,
3549 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3550 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3551 tree delta21
= integer_zero_node
;
3553 tree integer_neg_one_node
3554 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3555 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3556 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3558 /* Map everything down one to make room for
3559 the null pointer to member. */
3560 index1
= size_binop (PLUS_EXPR
,
3561 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3563 op1
= integer_zero_node
;
3564 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE
3565 (TREE_TYPE (type1
)));
3566 delta21
= DECL_FIELD_BITPOS (delta21
);
3567 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
,
3568 size_int (BITS_PER_UNIT
));
3569 delta21
= convert (sizetype
, delta21
);
3572 index1
= integer_neg_one_node
;
3574 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
),
3576 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3579 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3580 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3581 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3582 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3584 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3585 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3586 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3587 if (code
== EQ_EXPR
)
3589 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3591 else if (TYPE_PTRMEMFUNC_P (type1
)
3592 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3594 return build_binary_op (code
, op1
, op0
, 1);
3600 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3601 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3603 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3605 if (comp_target_types (type0
, type1
, 1))
3606 result_type
= common_type (type0
, type1
);
3609 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3611 result_type
= ptr_type_node
;
3620 build_type
= boolean_type_node
;
3621 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3622 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3624 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3626 if (comp_target_types (type0
, type1
, 1))
3627 result_type
= common_type (type0
, type1
);
3630 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3632 result_type
= ptr_type_node
;
3635 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3636 && integer_zerop (op1
))
3637 result_type
= type0
;
3638 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3639 && integer_zerop (op0
))
3640 result_type
= type1
;
3641 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3643 result_type
= type0
;
3644 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3646 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3648 result_type
= type1
;
3649 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3657 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
3659 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
3661 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
3663 if (shorten
|| common
|| short_compare
)
3664 result_type
= common_type (type0
, type1
);
3666 /* For certain operations (which identify themselves by shorten != 0)
3667 if both args were extended from the same smaller type,
3668 do the arithmetic in that type and then extend.
3670 shorten !=0 and !=1 indicates a bitwise operation.
3671 For them, this optimization is safe only if
3672 both args are zero-extended or both are sign-extended.
3673 Otherwise, we might change the result.
3674 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3675 but calculated in (unsigned short) it would be (unsigned short)-1. */
3677 if (shorten
&& none_complex
)
3679 int unsigned0
, unsigned1
;
3680 tree arg0
= get_narrower (op0
, &unsigned0
);
3681 tree arg1
= get_narrower (op1
, &unsigned1
);
3682 /* UNS is 1 if the operation to be done is an unsigned one. */
3683 int uns
= TREE_UNSIGNED (result_type
);
3686 final_type
= result_type
;
3688 /* Handle the case that OP0 does not *contain* a conversion
3689 but it *requires* conversion to FINAL_TYPE. */
3691 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3692 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3693 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3694 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3696 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3698 /* For bitwise operations, signedness of nominal type
3699 does not matter. Consider only how operands were extended. */
3703 /* Note that in all three cases below we refrain from optimizing
3704 an unsigned operation on sign-extended args.
3705 That would not be valid. */
3707 /* Both args variable: if both extended in same way
3708 from same width, do it in that width.
3709 Do it unsigned if args were zero-extended. */
3710 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3711 < TYPE_PRECISION (result_type
))
3712 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3713 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3714 && unsigned0
== unsigned1
3715 && (unsigned0
|| !uns
))
3717 = signed_or_unsigned_type (unsigned0
,
3718 common_type (TREE_TYPE (arg0
),
3720 else if (TREE_CODE (arg0
) == INTEGER_CST
3721 && (unsigned1
|| !uns
)
3722 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3723 < TYPE_PRECISION (result_type
))
3724 && (type
= signed_or_unsigned_type (unsigned1
,
3726 int_fits_type_p (arg0
, type
)))
3728 else if (TREE_CODE (arg1
) == INTEGER_CST
3729 && (unsigned0
|| !uns
)
3730 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3731 < TYPE_PRECISION (result_type
))
3732 && (type
= signed_or_unsigned_type (unsigned0
,
3734 int_fits_type_p (arg1
, type
)))
3738 /* Shifts can be shortened if shifting right. */
3743 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3745 final_type
= result_type
;
3747 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3748 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3750 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3751 /* We can shorten only if the shift count is less than the
3752 number of bits in the smaller type size. */
3753 && TREE_INT_CST_HIGH (op1
) == 0
3754 && TYPE_PRECISION (TREE_TYPE (arg0
)) > TREE_INT_CST_LOW (op1
)
3755 /* If arg is sign-extended and then unsigned-shifted,
3756 we can simulate this with a signed shift in arg's type
3757 only if the extended result is at least twice as wide
3758 as the arg. Otherwise, the shift could use up all the
3759 ones made by sign-extension and bring in zeros.
3760 We can't optimize that case at all, but in most machines
3761 it never happens because available widths are 2**N. */
3762 && (!TREE_UNSIGNED (final_type
)
3764 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
)))
3765 <= TYPE_PRECISION (result_type
))))
3767 /* Do an unsigned shift if the operand was zero-extended. */
3769 = signed_or_unsigned_type (unsigned_arg
,
3771 /* Convert value-to-be-shifted to that type. */
3772 if (TREE_TYPE (op0
) != result_type
)
3773 op0
= cp_convert (result_type
, op0
);
3778 /* Comparison operations are shortened too but differently.
3779 They identify themselves by setting short_compare = 1. */
3783 /* Don't write &op0, etc., because that would prevent op0
3784 from being kept in a register.
3785 Instead, make copies of the our local variables and
3786 pass the copies by reference, then copy them back afterward. */
3787 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3788 enum tree_code xresultcode
= resultcode
;
3790 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3792 return cp_convert (boolean_type_node
, val
);
3793 op0
= xop0
, op1
= xop1
;
3795 resultcode
= xresultcode
;
3798 if (short_compare
&& warn_sign_compare
)
3800 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
3801 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3803 int unsignedp0
, unsignedp1
;
3804 tree primop0
= get_narrower (op0
, &unsignedp0
);
3805 tree primop1
= get_narrower (op1
, &unsignedp1
);
3807 /* Check for comparison of different enum types. */
3808 if (TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
3809 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
3810 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
3811 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
3813 cp_warning ("comparison between `%#T' and `%#T'",
3814 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
3817 /* Give warnings for comparisons between signed and unsigned
3818 quantities that may fail. */
3819 /* Do the checking based on the original operand trees, so that
3820 casts will be considered, but default promotions won't be. */
3822 /* Do not warn if the comparison is being done in a signed type,
3823 since the signed type will only be chosen if it can represent
3824 all the values of the unsigned type. */
3825 if (! TREE_UNSIGNED (result_type
))
3827 /* Do not warn if both operands are unsigned. */
3828 else if (op0_signed
== op1_signed
)
3830 /* Do not warn if the signed quantity is an unsuffixed
3831 integer literal (or some static constant expression
3832 involving such literals) and it is non-negative. */
3833 else if ((op0_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3834 && tree_int_cst_sgn (orig_op0
) >= 0)
3835 || (op1_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3836 && tree_int_cst_sgn (orig_op1
) >= 0))
3838 /* Do not warn if the comparison is an equality operation,
3839 the unsigned quantity is an integral constant and it does
3840 not use the most significant bit of result_type. */
3841 else if ((resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
3842 && ((op0_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3843 && int_fits_type_p (orig_op1
,
3844 signed_type (result_type
)))
3845 || (op1_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3846 && int_fits_type_p (orig_op0
,
3847 signed_type (result_type
)))))
3850 warning ("comparison between signed and unsigned");
3852 /* Warn if two unsigned values are being compared in a size
3853 larger than their original size, and one (and only one) is the
3854 result of a `~' operator. This comparison will always fail.
3856 Also warn if one operand is a constant, and the constant does not
3857 have all bits set that are set in the ~ operand when it is
3860 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3861 ^ (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
3863 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3864 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3865 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3866 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3868 if (TREE_CODE (primop0
) == INTEGER_CST
3869 || TREE_CODE (primop1
) == INTEGER_CST
)
3872 HOST_WIDE_INT constant
, mask
;
3876 if (TREE_CODE (primop0
) == INTEGER_CST
)
3879 unsignedp
= unsignedp1
;
3880 constant
= TREE_INT_CST_LOW (primop0
);
3885 unsignedp
= unsignedp0
;
3886 constant
= TREE_INT_CST_LOW (primop1
);
3889 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3890 if (bits
< TYPE_PRECISION (result_type
)
3891 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3893 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3894 if ((mask
& constant
) != mask
)
3895 warning ("comparison of promoted ~unsigned with constant");
3898 else if (unsignedp0
&& unsignedp1
3899 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3900 < TYPE_PRECISION (result_type
))
3901 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3902 < TYPE_PRECISION (result_type
)))
3903 warning ("comparison of promoted ~unsigned with unsigned");
3908 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3909 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3910 Then the expression will be built.
3911 It will be given type FINAL_TYPE if that is nonzero;
3912 otherwise, it will be given type RESULT_TYPE. */
3916 cp_error ("invalid operands `%T' and `%T' to binary `%O'",
3917 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), error_code
);
3918 return error_mark_node
;
3921 /* Issue warnings about peculiar, but legal, uses of NULL. */
3922 if (/* It's reasonable to use pointer values as operands of &&
3923 and ||, so NULL is no exception. */
3924 !(code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
3925 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3926 (orig_op0
== null_node
3927 && TREE_CODE (TREE_TYPE (op1
)) != POINTER_TYPE
)
3928 /* Or vice versa. */
3929 || (orig_op1
== null_node
3930 && TREE_CODE (TREE_TYPE (op0
)) != POINTER_TYPE
)
3931 /* Or, both are NULL and the operation was not a comparison. */
3932 || (orig_op0
== null_node
&& orig_op1
== null_node
3933 && code
!= EQ_EXPR
&& code
!= NE_EXPR
)))
3934 /* Some sort of arithmetic operation involving NULL was
3935 performed. Note that pointer-difference and pointer-addition
3936 have already been handled above, and so we don't end up here in
3938 cp_warning ("NULL used in arithmetic");
3942 if (TREE_TYPE (op0
) != result_type
)
3943 op0
= cp_convert (result_type
, op0
);
3944 if (TREE_TYPE (op1
) != result_type
)
3945 op1
= cp_convert (result_type
, op1
);
3947 if (op0
== error_mark_node
|| op1
== error_mark_node
)
3948 return error_mark_node
;
3951 if (build_type
== NULL_TREE
)
3952 build_type
= result_type
;
3955 register tree result
= build (resultcode
, build_type
, op0
, op1
);
3956 register tree folded
;
3958 folded
= fold (result
);
3959 if (folded
== result
)
3960 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3961 if (final_type
!= 0)
3962 return cp_convert (final_type
, folded
);
3967 /* Return a tree for the sum or difference (RESULTCODE says which)
3968 of pointer PTROP and integer INTOP. */
3971 pointer_int_sum (resultcode
, ptrop
, intop
)
3972 enum tree_code resultcode
;
3973 register tree ptrop
, intop
;
3977 register tree result
;
3978 register tree folded
= fold (intop
);
3980 /* The result is a pointer of the same type that is being added. */
3982 register tree result_type
= TREE_TYPE (ptrop
);
3984 if (!complete_type_or_else (result_type
))
3985 return error_mark_node
;
3987 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3989 if (pedantic
|| warn_pointer_arith
)
3990 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3991 size_exp
= integer_one_node
;
3993 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3995 if (pedantic
|| warn_pointer_arith
)
3996 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3997 size_exp
= integer_one_node
;
3999 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
4001 if (pedantic
|| warn_pointer_arith
)
4002 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
4003 size_exp
= integer_one_node
;
4005 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
4007 if (pedantic
|| warn_pointer_arith
)
4008 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
4009 size_exp
= integer_one_node
;
4012 size_exp
= size_in_bytes (complete_type (TREE_TYPE (result_type
)));
4014 /* Needed to make OOPS V2R3 work. */
4016 if (TREE_CODE (intop
) == INTEGER_CST
4017 && TREE_INT_CST_LOW (intop
) == 0
4018 && TREE_INT_CST_HIGH (intop
) == 0)
4021 /* If what we are about to multiply by the size of the elements
4022 contains a constant term, apply distributive law
4023 and multiply that constant term separately.
4024 This helps produce common subexpressions. */
4026 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
4027 && ! TREE_CONSTANT (intop
)
4028 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
4029 && TREE_CONSTANT (size_exp
))
4031 enum tree_code subcode
= resultcode
;
4032 if (TREE_CODE (intop
) == MINUS_EXPR
)
4033 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
4034 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
4035 intop
= TREE_OPERAND (intop
, 0);
4038 /* Convert the integer argument to a type the same size as sizetype
4039 so the multiply won't overflow spuriously. */
4041 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
))
4042 intop
= cp_convert (type_for_size (TYPE_PRECISION (sizetype
), 0), intop
);
4044 /* Replace the integer argument with a suitable product by the object size.
4045 Do this multiplication as signed, then convert to the appropriate
4046 pointer type (actually unsigned integral). */
4048 intop
= cp_convert (result_type
,
4049 build_binary_op (MULT_EXPR
, intop
,
4050 cp_convert (TREE_TYPE (intop
),
4054 /* Create the sum or difference. */
4056 result
= build (resultcode
, result_type
, ptrop
, intop
);
4058 folded
= fold (result
);
4059 if (folded
== result
)
4060 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
4064 /* Return a tree for the difference of pointers OP0 and OP1.
4065 The resulting tree has type int. */
4068 pointer_diff (op0
, op1
, ptrtype
)
4069 register tree op0
, op1
;
4070 register tree ptrtype
;
4072 register tree result
, folded
;
4073 tree restype
= ptrdiff_type_node
;
4074 tree target_type
= TREE_TYPE (ptrtype
);
4076 if (!complete_type_or_else (target_type
))
4077 return error_mark_node
;
4079 if (pedantic
|| warn_pointer_arith
)
4081 if (TREE_CODE (target_type
) == VOID_TYPE
)
4082 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
4083 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
4084 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
4085 if (TREE_CODE (target_type
) == METHOD_TYPE
)
4086 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
4087 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
4088 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
4091 /* First do the subtraction as integers;
4092 then drop through to build the divide operator. */
4094 op0
= build_binary_op (MINUS_EXPR
, cp_convert (restype
, op0
),
4095 cp_convert (restype
, op1
), 1);
4097 /* This generates an error if op1 is a pointer to an incomplete type. */
4098 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
4099 error ("arithmetic on pointer to an incomplete type");
4101 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
4102 || TREE_CODE (target_type
) == FUNCTION_TYPE
4103 || TREE_CODE (target_type
) == METHOD_TYPE
4104 || TREE_CODE (target_type
) == OFFSET_TYPE
)
4106 : size_in_bytes (target_type
));
4108 /* Do the division. */
4110 result
= build (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
4112 folded
= fold (result
);
4113 if (folded
== result
)
4114 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4118 /* Handle the case of taking the address of a COMPONENT_REF.
4119 Called by `build_unary_op' and `build_up_reference'.
4121 ARG is the COMPONENT_REF whose address we want.
4122 ARGTYPE is the pointer type that this address should have.
4123 MSG is an error message to print if this COMPONENT_REF is not
4124 addressable (such as a bitfield). */
4127 build_component_addr (arg
, argtype
, msg
)
4131 tree field
= TREE_OPERAND (arg
, 1);
4132 tree basetype
= decl_type_context (field
);
4133 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
4135 my_friendly_assert (TREE_CODE (field
) == FIELD_DECL
, 981018);
4137 if (DECL_C_BIT_FIELD (field
))
4139 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
4140 return error_mark_node
;
4143 if (TREE_CODE (field
) == FIELD_DECL
4144 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
4146 /* Can't convert directly to ARGTYPE, since that
4147 may have the same pointer type as one of our
4149 rval
= build1 (NOP_EXPR
, argtype
,
4150 convert_pointer_to (basetype
, rval
));
4151 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
4154 /* This conversion is harmless. */
4155 rval
= convert_force (argtype
, rval
, 0);
4157 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
4159 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
4160 size_int (BITS_PER_UNIT
));
4161 int flag
= TREE_CONSTANT (rval
);
4162 offset
= convert (sizetype
, offset
);
4163 rval
= fold (build (PLUS_EXPR
, argtype
,
4164 rval
, cp_convert (argtype
, offset
)));
4165 TREE_CONSTANT (rval
) = flag
;
4170 /* Construct and perhaps optimize a tree representation
4171 for a unary operation. CODE, a tree_code, specifies the operation
4172 and XARG is the operand. */
4175 build_x_unary_op (code
, xarg
)
4176 enum tree_code code
;
4179 if (processing_template_decl
)
4180 return build_min_nt (code
, xarg
, NULL_TREE
);
4182 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
4184 if (code
== ADDR_EXPR
4185 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
4186 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
4187 && TYPE_SIZE (TREE_TYPE (xarg
)) == NULL_TREE
)
4188 || (TREE_CODE (xarg
) == OFFSET_REF
)))
4189 /* don't look for a function */;
4194 rval
= build_new_op (code
, LOOKUP_NORMAL
, xarg
,
4195 NULL_TREE
, NULL_TREE
);
4196 if (rval
|| code
!= ADDR_EXPR
)
4200 if (code
== ADDR_EXPR
)
4202 if (TREE_CODE (xarg
) == TARGET_EXPR
)
4203 warning ("taking address of temporary");
4206 return build_unary_op (code
, xarg
, 0);
4209 /* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4212 condition_conversion (expr
)
4216 if (processing_template_decl
)
4218 t
= cp_convert (boolean_type_node
, expr
);
4219 t
= fold (build1 (CLEANUP_POINT_EXPR
, boolean_type_node
, t
));
4223 /* C++: Must handle pointers to members.
4225 Perhaps type instantiation should be extended to handle conversion
4226 from aggregates to types we don't yet know we want? (Or are those
4227 cases typically errors which should be reported?)
4229 NOCONVERT nonzero suppresses the default promotions
4230 (such as from short to int). */
4233 build_unary_op (code
, xarg
, noconvert
)
4234 enum tree_code code
;
4238 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4239 register tree arg
= xarg
;
4240 register tree argtype
= 0;
4241 char *errstring
= NULL
;
4244 if (arg
== error_mark_node
)
4245 return error_mark_node
;
4250 /* This is used for unary plus, because a CONVERT_EXPR
4251 is enough to prevent anybody from looking inside for
4252 associativity, but won't generate any code. */
4253 if (!(arg
= build_expr_type_conversion
4254 (WANT_ARITH
| WANT_ENUM
| WANT_POINTER
, arg
, 1)))
4255 errstring
= "wrong type argument to unary plus";
4259 arg
= default_conversion (arg
);
4260 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
4261 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4266 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4267 errstring
= "wrong type argument to unary minus";
4268 else if (!noconvert
)
4269 arg
= default_conversion (arg
);
4273 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4277 arg
= default_conversion (arg
);
4279 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
4281 errstring
= "wrong type argument to bit-complement";
4282 else if (!noconvert
)
4283 arg
= default_conversion (arg
);
4287 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4288 errstring
= "wrong type argument to abs";
4289 else if (!noconvert
)
4290 arg
= default_conversion (arg
);
4294 /* Conjugating a real value is a no-op, but allow it anyway. */
4295 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4296 errstring
= "wrong type argument to conjugation";
4297 else if (!noconvert
)
4298 arg
= default_conversion (arg
);
4301 case TRUTH_NOT_EXPR
:
4302 arg
= cp_convert (boolean_type_node
, arg
);
4303 val
= invert_truthvalue (arg
);
4304 if (arg
!= error_mark_node
)
4306 errstring
= "in argument to unary !";
4313 if (TREE_CODE (arg
) == COMPLEX_CST
)
4314 return TREE_REALPART (arg
);
4315 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4316 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4321 if (TREE_CODE (arg
) == COMPLEX_CST
)
4322 return TREE_IMAGPART (arg
);
4323 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4324 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4326 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4328 case PREINCREMENT_EXPR
:
4329 case POSTINCREMENT_EXPR
:
4330 case PREDECREMENT_EXPR
:
4331 case POSTDECREMENT_EXPR
:
4332 /* Handle complex lvalues (when permitted)
4333 by reduction to simpler cases. */
4335 val
= unary_complex_lvalue (code
, arg
);
4339 /* Increment or decrement the real part of the value,
4340 and don't change the imaginary part. */
4341 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4345 arg
= stabilize_reference (arg
);
4346 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
4347 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
4348 return build (COMPLEX_EXPR
, TREE_TYPE (arg
),
4349 build_unary_op (code
, real
, 1), imag
);
4352 /* Report invalid types. */
4354 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4357 if (code
== PREINCREMENT_EXPR
)
4358 errstring
="no pre-increment operator for type";
4359 else if (code
== POSTINCREMENT_EXPR
)
4360 errstring
="no post-increment operator for type";
4361 else if (code
== PREDECREMENT_EXPR
)
4362 errstring
="no pre-decrement operator for type";
4364 errstring
="no post-decrement operator for type";
4368 /* Report something read-only. */
4370 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
4371 || TREE_READONLY (arg
))
4372 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4373 || code
== POSTINCREMENT_EXPR
)
4374 ? "increment" : "decrement"),
4379 tree result_type
= TREE_TYPE (arg
);
4381 arg
= get_unwidened (arg
, 0);
4382 argtype
= TREE_TYPE (arg
);
4384 /* ARM $5.2.5 last annotation says this should be forbidden. */
4385 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4386 pedwarn ("ANSI C++ forbids %sing an enum",
4387 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4388 ? "increment" : "decrement");
4390 /* Compute the increment. */
4392 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4394 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
4395 if (TYPE_SIZE (complete_type (TREE_TYPE (argtype
))) == 0)
4396 cp_error ("cannot %s a pointer to incomplete type `%T'",
4397 ((code
== PREINCREMENT_EXPR
4398 || code
== POSTINCREMENT_EXPR
)
4399 ? "increment" : "decrement"), TREE_TYPE (argtype
));
4400 else if ((pedantic
|| warn_pointer_arith
)
4401 && (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
4402 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
))
4403 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
4404 ((code
== PREINCREMENT_EXPR
4405 || code
== POSTINCREMENT_EXPR
)
4406 ? "increment" : "decrement"), argtype
);
4407 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
4410 inc
= integer_one_node
;
4412 inc
= cp_convert (argtype
, inc
);
4414 /* Handle incrementing a cast-expression. */
4416 switch (TREE_CODE (arg
))
4421 case FIX_TRUNC_EXPR
:
4422 case FIX_FLOOR_EXPR
:
4423 case FIX_ROUND_EXPR
:
4426 tree incremented
, modify
, value
, compound
;
4427 if (! lvalue_p (arg
) && pedantic
)
4428 pedwarn ("cast to non-reference type used as lvalue");
4429 arg
= stabilize_reference (arg
);
4430 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4433 value
= save_expr (arg
);
4434 incremented
= build (((code
== PREINCREMENT_EXPR
4435 || code
== POSTINCREMENT_EXPR
)
4436 ? PLUS_EXPR
: MINUS_EXPR
),
4437 argtype
, value
, inc
);
4438 TREE_SIDE_EFFECTS (incremented
) = 1;
4440 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4441 compound
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4443 /* Eliminate warning about unused result of + or -. */
4444 TREE_NO_UNUSED_WARNING (compound
) = 1;
4452 /* Complain about anything else that is not a true lvalue. */
4453 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4454 || code
== POSTINCREMENT_EXPR
)
4455 ? "increment" : "decrement")))
4456 return error_mark_node
;
4458 /* Forbid using -- on `bool'. */
4459 if (TREE_TYPE (arg
) == boolean_type_node
)
4461 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4463 cp_error ("invalid use of `--' on bool variable `%D'", arg
);
4464 return error_mark_node
;
4467 /* This will only work if someone can convince Kenner to accept
4468 my patch to expand_increment. (jason) */
4469 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4471 if (code
== POSTINCREMENT_EXPR
)
4473 arg
= stabilize_reference (arg
);
4474 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4476 TREE_SIDE_EFFECTS (val
) = 1;
4477 arg
= save_expr (arg
);
4478 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4479 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4482 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4487 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4489 TREE_SIDE_EFFECTS (val
) = 1;
4490 return cp_convert (result_type
, val
);
4494 /* Note that this operation never does default_conversion
4495 regardless of NOCONVERT. */
4497 argtype
= lvalue_type (arg
);
4498 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4502 build_pointer_type (TREE_TYPE (argtype
)), arg
);
4503 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4506 else if (pedantic
&& DECL_MAIN_P (arg
))
4508 pedwarn ("taking address of function `main'");
4510 /* Let &* cancel out to simplify resulting code. */
4511 if (TREE_CODE (arg
) == INDIRECT_REF
)
4513 /* We don't need to have `current_class_ptr' wrapped in a
4514 NON_LVALUE_EXPR node. */
4515 if (arg
== current_class_ref
)
4516 return current_class_ptr
;
4518 arg
= TREE_OPERAND (arg
, 0);
4519 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4523 build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4524 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4526 else if (lvalue_p (arg
))
4527 /* Don't let this be an lvalue. */
4528 return non_lvalue (arg
);
4532 /* For &x[y], return x+y */
4533 if (TREE_CODE (arg
) == ARRAY_REF
)
4535 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4536 return error_mark_node
;
4537 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4538 TREE_OPERAND (arg
, 1), 1);
4541 /* Uninstantiated types are all functions. Taking the
4542 address of a function is a no-op, so just return the
4545 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4546 && IDENTIFIER_OPNAME_P (arg
))
4548 my_friendly_abort (117);
4549 /* We don't know the type yet, so just work around the problem.
4550 We know that this will resolve to an lvalue. */
4551 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4554 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
4559 /* We don't require a match here; it's possible that the
4560 context (like a cast to a particular type) will resolve
4561 the particular choice of template. */
4562 fn
= determine_specialization (arg
,
4570 fn
= instantiate_template (fn
, targs
);
4571 mark_addressable (fn
);
4572 return build_unary_op (ADDR_EXPR
, fn
, 0);
4575 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4577 else if (type_unknown_p (arg
))
4578 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4580 /* Handle complex lvalues (when permitted)
4581 by reduction to simpler cases. */
4582 val
= unary_complex_lvalue (code
, arg
);
4586 switch (TREE_CODE (arg
))
4591 case FIX_TRUNC_EXPR
:
4592 case FIX_FLOOR_EXPR
:
4593 case FIX_ROUND_EXPR
:
4595 if (! lvalue_p (arg
) && pedantic
)
4596 pedwarn ("taking the address of a cast to non-reference type");
4603 /* Allow the address of a constructor if all the elements
4605 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (arg
)
4606 && TREE_CONSTANT (arg
))
4608 /* Anything not already handled and not a true memory reference
4610 else if (TREE_CODE (argtype
) != FUNCTION_TYPE
4611 && TREE_CODE (argtype
) != METHOD_TYPE
4612 && !lvalue_or_else (arg
, "unary `&'"))
4613 return error_mark_node
;
4615 if (argtype
!= error_mark_node
)
4616 argtype
= build_pointer_type (argtype
);
4618 if (mark_addressable (arg
) == 0)
4619 return error_mark_node
;
4624 if (TREE_CODE (arg
) == COMPONENT_REF
)
4625 addr
= build_component_addr
4627 "attempt to take address of bit-field structure member `%s'");
4629 addr
= build1 (code
, argtype
, arg
);
4631 /* Address of a static or external variable or
4632 function counts as a constant */
4634 TREE_CONSTANT (addr
) = 1;
4636 if (TREE_CODE (argtype
) == POINTER_TYPE
4637 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4639 build_ptrmemfunc_type (argtype
);
4640 addr
= build_ptrmemfunc (argtype
, addr
, 0);
4653 argtype
= TREE_TYPE (arg
);
4654 return fold (build1 (code
, argtype
, arg
));
4658 return error_mark_node
;
4662 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4663 convert ARG with the same conversions in the same order
4664 and return the result. */
4667 convert_sequence (conversions
, arg
)
4671 switch (TREE_CODE (conversions
))
4676 case FIX_TRUNC_EXPR
:
4677 case FIX_FLOOR_EXPR
:
4678 case FIX_ROUND_EXPR
:
4680 return cp_convert (TREE_TYPE (conversions
),
4681 convert_sequence (TREE_OPERAND (conversions
, 0),
4690 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4691 for certain kinds of expressions which are not really lvalues
4692 but which we can accept as lvalues.
4694 If ARG is not a kind of expression we can handle, return zero. */
4697 unary_complex_lvalue (code
, arg
)
4698 enum tree_code code
;
4701 /* Handle (a, b) used as an "lvalue". */
4702 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4704 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4705 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4706 TREE_OPERAND (arg
, 0), real_result
);
4709 /* Handle (a ? b : c) used as an "lvalue". */
4710 if (TREE_CODE (arg
) == COND_EXPR
4711 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4712 return rationalize_conditional_expr (code
, arg
);
4714 if (TREE_CODE (arg
) == MODIFY_EXPR
4715 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4716 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4717 return unary_complex_lvalue
4718 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4719 arg
, TREE_OPERAND (arg
, 0)));
4721 if (code
!= ADDR_EXPR
)
4724 /* Handle (a = b) used as an "lvalue" for `&'. */
4725 if (TREE_CODE (arg
) == MODIFY_EXPR
4726 || TREE_CODE (arg
) == INIT_EXPR
)
4728 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4729 arg
= build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4730 TREE_NO_UNUSED_WARNING (arg
) = 1;
4734 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4735 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4736 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4738 /* The representation of something of type OFFSET_TYPE
4739 is really the representation of a pointer to it.
4740 Here give the representation its true type. */
4743 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4745 if (TREE_CODE (arg
) != OFFSET_REF
)
4748 t
= TREE_OPERAND (arg
, 1);
4750 /* Check all this code for right semantics. */
4751 if (TREE_CODE (t
) == FUNCTION_DECL
)
4753 if (DECL_DESTRUCTOR_P (t
))
4754 cp_error ("taking address of destructor");
4755 return build_unary_op (ADDR_EXPR
, t
, 0);
4757 if (TREE_CODE (t
) == VAR_DECL
)
4758 return build_unary_op (ADDR_EXPR
, t
, 0);
4763 if (TREE_OPERAND (arg
, 0)
4764 && ! is_dummy_object (TREE_OPERAND (arg
, 0))
4765 && TREE_CODE (t
) != FIELD_DECL
)
4767 cp_error ("taking address of bound pointer-to-member expression");
4768 return error_mark_node
;
4771 type
= build_offset_type (DECL_FIELD_CONTEXT (t
), TREE_TYPE (t
));
4772 type
= build_pointer_type (type
);
4774 t
= make_node (PTRMEM_CST
);
4775 TREE_TYPE (t
) = type
;
4776 PTRMEM_CST_MEMBER (t
) = TREE_OPERAND (arg
, 1);
4782 /* We permit compiler to make function calls returning
4783 objects of aggregate type look like lvalues. */
4787 if (TREE_CODE (targ
) == SAVE_EXPR
)
4788 targ
= TREE_OPERAND (targ
, 0);
4790 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4792 if (TREE_CODE (arg
) == SAVE_EXPR
)
4795 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4796 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4799 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4800 return build (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4801 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4804 /* Don't let anything else be handled specially. */
4808 /* Mark EXP saying that we need to be able to take the
4809 address of it; it should not be allocated in a register.
4810 Value is 1 if successful.
4812 C++: we do not allow `current_class_ptr' to be addressable. */
4815 mark_addressable (exp
)
4818 register tree x
= exp
;
4820 if (TREE_ADDRESSABLE (x
) == 1)
4824 switch (TREE_CODE (x
))
4831 x
= TREE_OPERAND (x
, 0);
4835 if (x
== current_class_ptr
)
4837 if (! flag_this_is_variable
)
4838 error ("address of `this' not available");
4839 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4840 put_var_into_stack (x
);
4844 if (TREE_STATIC (x
) && TREE_READONLY (x
)
4845 && DECL_RTL (x
) != 0
4846 && ! DECL_IN_MEMORY_P (x
))
4848 /* We thought this would make a good constant variable,
4849 but we were wrong. */
4850 push_obstacks_nochange ();
4851 end_temporary_allocation ();
4853 TREE_ASM_WRITTEN (x
) = 0;
4855 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0,
4857 TREE_ADDRESSABLE (x
) = 1;
4863 /* Caller should not be trying to mark initialized
4864 constant fields addressable. */
4865 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4866 || DECL_IN_AGGR_P (x
) == 0
4868 || DECL_EXTERNAL (x
), 314);
4872 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4873 && !DECL_ARTIFICIAL (x
) && extra_warnings
)
4874 cp_warning ("address requested for `%D', which is declared `register'",
4876 put_var_into_stack (x
);
4877 TREE_ADDRESSABLE (x
) = 1;
4881 if (DECL_LANG_SPECIFIC (x
) != 0)
4883 x
= DECL_MAIN_VARIANT (x
);
4884 /* We have to test both conditions here. The first may be
4885 non-zero in the case of processing a default function. The
4886 second may be non-zero in the case of a template function. */
4887 if (DECL_TEMPLATE_INFO (x
) && !DECL_TEMPLATE_SPECIALIZATION (x
))
4890 TREE_ADDRESSABLE (x
) = 1;
4892 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4896 TREE_ADDRESSABLE (x
) = 1;
4900 TREE_ADDRESSABLE (x
) = 1;
4901 mark_addressable (TREE_OPERAND (x
, 0));
4909 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4912 build_x_conditional_expr (ifexp
, op1
, op2
)
4913 tree ifexp
, op1
, op2
;
4915 if (processing_template_decl
)
4916 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
4918 return build_new_op (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4922 build_conditional_expr (ifexp
, op1
, op2
)
4923 tree ifexp
, op1
, op2
;
4925 register tree type1
;
4926 register tree type2
;
4927 register enum tree_code code1
;
4928 register enum tree_code code2
;
4929 register tree result_type
= NULL_TREE
;
4931 /* If second operand is omitted, it is the same as the first one;
4932 make sure it is calculated only once. */
4936 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4937 ifexp
= op1
= save_expr (ifexp
);
4940 ifexp
= cp_convert (boolean_type_node
, ifexp
);
4942 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4943 return error_mark_node
;
4945 /* C++: REFERENCE_TYPES must be dereferenced. */
4946 type1
= TREE_TYPE (op1
);
4947 code1
= TREE_CODE (type1
);
4948 type2
= TREE_TYPE (op2
);
4949 code2
= TREE_CODE (type2
);
4951 if (code1
== REFERENCE_TYPE
)
4953 op1
= convert_from_reference (op1
);
4954 type1
= TREE_TYPE (op1
);
4955 code1
= TREE_CODE (type1
);
4957 if (code2
== REFERENCE_TYPE
)
4959 op2
= convert_from_reference (op2
);
4960 type2
= TREE_TYPE (op2
);
4961 code2
= TREE_CODE (type2
);
4964 /* Don't promote the operands separately if they promote
4965 the same way. Return the unpromoted type and let the combined
4966 value get promoted if necessary. */
4968 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4969 && code2
!= ARRAY_TYPE
4970 && code2
!= FUNCTION_TYPE
4971 && code2
!= METHOD_TYPE
)
4975 if (TREE_CONSTANT (ifexp
)
4976 && (TREE_CODE (ifexp
) == INTEGER_CST
4977 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4978 return (integer_zerop (ifexp
) ? op2
: op1
);
4980 if (TREE_CODE (op1
) == CONST_DECL
)
4981 op1
= DECL_INITIAL (op1
);
4982 else if (TREE_READONLY_DECL_P (op1
))
4983 op1
= decl_constant_value (op1
);
4984 if (TREE_CODE (op2
) == CONST_DECL
)
4985 op2
= DECL_INITIAL (op2
);
4986 else if (TREE_READONLY_DECL_P (op2
))
4987 op2
= decl_constant_value (op2
);
4989 type1
= cp_build_qualified_type
4990 (type1
, (CP_TYPE_QUALS (TREE_TYPE (op1
))
4991 | CP_TYPE_QUALS (TREE_TYPE (op2
))));
4992 /* ??? This is a kludge to deal with the fact that
4993 we don't sort out integers and enums properly, yet. */
4994 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4995 if (TREE_TYPE (result
) != type1
)
4996 result
= build1 (NOP_EXPR
, type1
, result
);
4997 /* Expand both sides into the same slot,
4998 hopefully the target of the ?: expression. */
4999 if (TREE_CODE (op1
) == TARGET_EXPR
&& TREE_CODE (op2
) == TARGET_EXPR
)
5001 tree slot
= build (VAR_DECL
, TREE_TYPE (result
));
5002 layout_decl (slot
, 0);
5003 result
= build (TARGET_EXPR
, TREE_TYPE (result
),
5004 slot
, result
, NULL_TREE
, NULL_TREE
);
5009 /* They don't match; promote them both and then try to reconcile them.
5010 But don't permit mismatching enum types. */
5011 if (code1
== ENUMERAL_TYPE
)
5013 if (code2
== ENUMERAL_TYPE
)
5015 cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'",
5017 return error_mark_node
;
5019 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
)
5020 && type2
!= type_promotes_to (type1
))
5021 warning ("enumeral and non-enumeral type in conditional expression");
5023 else if (extra_warnings
5024 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
)
5025 && type1
!= type_promotes_to (type2
))
5026 warning ("enumeral and non-enumeral type in conditional expression");
5028 if (code1
!= VOID_TYPE
)
5030 op1
= default_conversion (op1
);
5031 type1
= TREE_TYPE (op1
);
5032 if (TYPE_PTRMEMFUNC_P (type1
))
5033 type1
= TYPE_PTRMEMFUNC_FN_TYPE (type1
);
5034 code1
= TREE_CODE (type1
);
5036 if (code2
!= VOID_TYPE
)
5038 op2
= default_conversion (op2
);
5039 type2
= TREE_TYPE (op2
);
5040 if (TYPE_PTRMEMFUNC_P (type2
))
5041 type2
= TYPE_PTRMEMFUNC_FN_TYPE (type2
);
5042 code2
= TREE_CODE (type2
);
5045 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
5046 && real_lvalue_p (op1
) && real_lvalue_p (op2
)
5047 && comptypes (type1
, type2
, COMPARE_BASE
| COMPARE_RELAXED
))
5049 type1
= build_reference_type (type1
);
5050 type2
= build_reference_type (type2
);
5051 result_type
= common_type (type1
, type2
);
5052 op1
= convert_to_reference (result_type
, op1
, CONV_IMPLICIT
,
5053 LOOKUP_NORMAL
, NULL_TREE
);
5054 op2
= convert_to_reference (result_type
, op2
, CONV_IMPLICIT
,
5055 LOOKUP_NORMAL
, NULL_TREE
);
5057 /* Quickly detect the usual case where op1 and op2 have the same type
5059 else if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
5062 result_type
= type1
;
5065 cp_build_qualified_type (type1
,
5066 CP_TYPE_QUALS (TREE_TYPE (op1
))
5067 | CP_TYPE_QUALS (TREE_TYPE (op2
)));
5069 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
5070 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
5072 result_type
= common_type (type1
, type2
);
5074 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
5076 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
5077 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
5078 result_type
= void_type_node
;
5080 else if (code1
== POINTER_TYPE
&& null_ptr_cst_p (op2
))
5081 result_type
= qualify_type (type1
, type2
);
5082 else if (code2
== POINTER_TYPE
&& null_ptr_cst_p (op1
))
5083 result_type
= qualify_type (type2
, type1
);
5084 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
5086 if (comp_target_types (type1
, type2
, 1))
5087 result_type
= common_type (type1
, type2
);
5088 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
5090 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
5091 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5092 result_type
= qualify_type (type1
, type2
);
5094 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
5096 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
5097 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5098 result_type
= qualify_type (type2
, type1
);
5101 else if (same_or_base_type_p (type2
, type1
))
5102 result_type
= type2
;
5103 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
5104 && IS_AGGR_TYPE (TREE_TYPE (type2
))
5105 && (result_type
= common_base_type (TREE_TYPE (type1
),
5106 TREE_TYPE (type2
))))
5108 if (result_type
== error_mark_node
)
5110 cp_error ("common base type of types `%T' and `%T' is ambiguous",
5111 TREE_TYPE (type1
), TREE_TYPE (type2
));
5112 result_type
= ptr_type_node
;
5117 && result_type
!= TREE_TYPE (type1
)
5118 && result_type
!= TREE_TYPE (type2
))
5119 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
5120 type1
, type2
, result_type
);
5122 result_type
= build_pointer_type (result_type
);
5127 pedwarn ("pointer type mismatch in conditional expression");
5128 result_type
= ptr_type_node
;
5131 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
5133 pedwarn ("pointer/integer type mismatch in conditional expression");
5134 result_type
= type1
;
5136 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5138 pedwarn ("pointer/integer type mismatch in conditional expression");
5139 result_type
= type2
;
5141 if (type2
== unknown_type_node
)
5142 result_type
= type1
;
5143 else if (type1
== unknown_type_node
)
5144 result_type
= type2
;
5148 /* The match does not look good. If either is
5149 an aggregate value, try converting to a scalar type. */
5150 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
5152 cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'",
5154 return error_mark_node
;
5156 /* Warning: this code assumes that conversion between cv-variants of
5157 a type is done using NOP_EXPRs. */
5158 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
5160 /* There are other types besides pointers and records. */
5162 if (code2
== POINTER_TYPE
)
5163 tmp
= build_pointer_type
5164 (cp_build_qualified_type (TREE_TYPE (type2
),
5166 | TYPE_QUAL_VOLATILE
5167 | TYPE_QUAL_RESTRICT
));
5170 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op1
, 0);
5171 if (tmp
== NULL_TREE
)
5173 cp_error ("incompatible types `%T' and `%T' in `?:'",
5175 return error_mark_node
;
5177 if (tmp
== error_mark_node
)
5178 error ("ambiguous pointer conversion");
5181 result_type
= common_type (type2
, TREE_TYPE (tmp
));
5184 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
5187 if (code1
== POINTER_TYPE
)
5188 tmp
= build_pointer_type
5189 (cp_build_qualified_type (TREE_TYPE (type1
),
5191 | TYPE_QUAL_VOLATILE
5192 | TYPE_QUAL_RESTRICT
));
5196 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op2
, 0);
5197 if (tmp
== NULL_TREE
)
5199 cp_error ("incompatible types `%T' and `%T' in `?:'",
5201 return error_mark_node
;
5203 if (tmp
== error_mark_node
)
5204 error ("ambiguous pointer conversion");
5207 result_type
= common_type (type1
, TREE_TYPE (tmp
));
5210 else if (flag_cond_mismatch
)
5211 result_type
= void_type_node
;
5214 error ("type mismatch in conditional expression");
5215 return error_mark_node
;
5219 if (TREE_CODE (result_type
) == POINTER_TYPE
5220 && TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
5221 result_type
= build_ptrmemfunc_type (result_type
);
5223 if (result_type
!= TREE_TYPE (op1
))
5224 op1
= convert_for_initialization
5225 (NULL_TREE
, result_type
, op1
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5226 if (result_type
!= TREE_TYPE (op2
))
5227 op2
= convert_for_initialization
5228 (NULL_TREE
, result_type
, op2
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5230 if (TREE_CODE (ifexp
) == INTEGER_CST
)
5231 return integer_zerop (ifexp
) ? op2
: op1
;
5233 return convert_from_reference
5234 (fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
)));
5237 /* Handle overloading of the ',' operator when needed. Otherwise,
5238 this function just builds an expression list. */
5241 build_x_compound_expr (list
)
5244 tree rest
= TREE_CHAIN (list
);
5247 if (processing_template_decl
)
5248 return build_min_nt (COMPOUND_EXPR
, list
, NULL_TREE
);
5250 if (rest
== NULL_TREE
)
5251 return build_compound_expr (list
);
5253 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
5254 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
5256 return build_x_compound_expr (expr_tree_cons (NULL_TREE
, result
,
5257 TREE_CHAIN (rest
)));
5259 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
5261 /* the left-hand operand of a comma expression is like an expression
5262 statement: we should warn if it doesn't have any side-effects,
5263 unless it was explicitly cast to (void). */
5264 if ((extra_warnings
|| warn_unused
)
5265 && !(TREE_CODE (TREE_VALUE(list
)) == CONVERT_EXPR
5266 && TREE_TYPE (TREE_VALUE(list
)) == void_type_node
))
5267 warning("left-hand operand of comma expression has no effect");
5269 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
5270 else if (warn_unused
)
5271 warn_if_unused_value (TREE_VALUE(list
));
5274 return build_compound_expr
5275 (expr_tree_cons (NULL_TREE
, TREE_VALUE (list
),
5276 build_expr_list (NULL_TREE
,
5277 build_x_compound_expr (rest
))));
5280 /* Given a list of expressions, return a compound expression
5281 that performs them all and returns the value of the last of them. */
5284 build_compound_expr (list
)
5289 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
5290 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
5292 if (TREE_CHAIN (list
) == 0)
5294 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5295 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
5296 if (TREE_CODE (list
) == NOP_EXPR
5297 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
5298 list
= TREE_OPERAND (list
, 0);
5300 /* Convert arrays to pointers. */
5301 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
5302 return default_conversion (TREE_VALUE (list
));
5304 return TREE_VALUE (list
);
5307 rest
= build_compound_expr (TREE_CHAIN (list
));
5309 /* When pedantic, a compound expression cannot be a constant expression. */
5310 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
5313 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
5314 break_out_cleanups (TREE_VALUE (list
)), rest
);
5318 build_static_cast (type
, expr
)
5324 if (type
== error_mark_node
|| expr
== error_mark_node
)
5325 return error_mark_node
;
5327 if (TREE_CODE (expr
) == OFFSET_REF
)
5328 expr
= resolve_offset_ref (expr
);
5330 if (processing_template_decl
)
5332 tree t
= build_min (STATIC_CAST_EXPR
, copy_to_permanent (type
),
5337 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5338 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5339 if (TREE_CODE (type
) != REFERENCE_TYPE
5340 && TREE_CODE (expr
) == NOP_EXPR
5341 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5342 expr
= TREE_OPERAND (expr
, 0);
5344 if (TREE_CODE (type
) == VOID_TYPE
)
5345 return build1 (CONVERT_EXPR
, type
, expr
);
5347 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5348 return (convert_from_reference
5349 (convert_to_reference (type
, expr
, CONV_STATIC
|CONV_IMPLICIT
,
5350 LOOKUP_COMPLAIN
, NULL_TREE
)));
5352 if (IS_AGGR_TYPE (type
))
5353 return build_cplus_new
5354 (type
, (build_method_call
5355 (NULL_TREE
, ctor_identifier
, build_expr_list (NULL_TREE
, expr
),
5356 TYPE_BINFO (type
), LOOKUP_NORMAL
)));
5358 expr
= decay_conversion (expr
);
5359 intype
= TREE_TYPE (expr
);
5361 /* FIXME handle casting to array type. */
5364 if (can_convert_arg (type
, intype
, expr
))
5366 else if (TYPE_PTROB_P (type
) && TYPE_PTROB_P (intype
))
5369 if (IS_AGGR_TYPE (TREE_TYPE (type
)) && IS_AGGR_TYPE (TREE_TYPE (intype
))
5370 && at_least_as_qualified_p (TREE_TYPE (type
),
5372 && (binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 0))
5373 && ! TREE_VIA_VIRTUAL (binfo
))
5376 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5378 if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
))),
5379 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (intype
))))
5380 && at_least_as_qualified_p (TREE_TYPE (TREE_TYPE (type
)),
5381 TREE_TYPE (TREE_TYPE (intype
)))
5382 && (binfo
= get_binfo (TYPE_OFFSET_BASETYPE (TREE_TYPE (type
)),
5383 TYPE_OFFSET_BASETYPE (TREE_TYPE (intype
)), 0))
5384 && ! TREE_VIA_VIRTUAL (binfo
))
5387 else if (TREE_CODE (intype
) != BOOLEAN_TYPE
5388 && TREE_CODE (type
) != ARRAY_TYPE
5389 && TREE_CODE (type
) != FUNCTION_TYPE
5390 && can_convert (intype
, type
))
5394 return build_c_cast (type
, expr
);
5396 cp_error ("static_cast from `%T' to `%T'", intype
, type
);
5397 return error_mark_node
;
5401 build_reinterpret_cast (type
, expr
)
5406 if (type
== error_mark_node
|| expr
== error_mark_node
)
5407 return error_mark_node
;
5409 if (TREE_CODE (expr
) == OFFSET_REF
)
5410 expr
= resolve_offset_ref (expr
);
5412 if (processing_template_decl
)
5414 tree t
= build_min (REINTERPRET_CAST_EXPR
,
5415 copy_to_permanent (type
), expr
);
5419 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5421 expr
= decay_conversion (expr
);
5423 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5424 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5425 if (TREE_CODE (expr
) == NOP_EXPR
5426 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5427 expr
= TREE_OPERAND (expr
, 0);
5430 intype
= TREE_TYPE (expr
);
5432 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5434 if (! real_lvalue_p (expr
))
5436 cp_error ("reinterpret_cast from `%T' rvalue to `%T'", intype
, type
);
5437 return error_mark_node
;
5439 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5440 if (expr
!= error_mark_node
)
5441 expr
= build_reinterpret_cast
5442 (build_pointer_type (TREE_TYPE (type
)), expr
);
5443 if (expr
!= error_mark_node
)
5444 expr
= build_indirect_ref (expr
, 0);
5447 else if (same_type_p (TYPE_MAIN_VARIANT (intype
),
5448 TYPE_MAIN_VARIANT (type
)))
5449 return build_static_cast (type
, expr
);
5451 if (TYPE_PTR_P (type
) && (TREE_CODE (intype
) == INTEGER_TYPE
5452 || TREE_CODE (intype
) == ENUMERAL_TYPE
))
5454 else if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_PTR_P (intype
))
5456 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5457 cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5460 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5461 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5463 if (TREE_READONLY_DECL_P (expr
))
5464 expr
= decl_constant_value (expr
);
5465 return fold (build1 (NOP_EXPR
, type
, expr
));
5467 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5468 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5470 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type
), TREE_TYPE (intype
)))
5471 cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5474 if (TREE_READONLY_DECL_P (expr
))
5475 expr
= decl_constant_value (expr
);
5476 return fold (build1 (NOP_EXPR
, type
, expr
));
5478 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5479 || (TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
)))
5481 pedwarn ("ANSI C++ forbids casting between pointers to functions and objects");
5482 if (TREE_READONLY_DECL_P (expr
))
5483 expr
= decl_constant_value (expr
);
5484 return fold (build1 (NOP_EXPR
, type
, expr
));
5488 cp_error ("reinterpret_cast from `%T' to `%T'", intype
, type
);
5489 return error_mark_node
;
5492 return cp_convert (type
, expr
);
5496 build_const_cast (type
, expr
)
5501 if (type
== error_mark_node
|| expr
== error_mark_node
)
5502 return error_mark_node
;
5504 if (TREE_CODE (expr
) == OFFSET_REF
)
5505 expr
= resolve_offset_ref (expr
);
5507 if (processing_template_decl
)
5509 tree t
= build_min (CONST_CAST_EXPR
, copy_to_permanent (type
),
5514 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5516 expr
= decay_conversion (expr
);
5518 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5519 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5520 if (TREE_CODE (expr
) == NOP_EXPR
5521 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5522 expr
= TREE_OPERAND (expr
, 0);
5525 intype
= TREE_TYPE (expr
);
5527 if (same_type_p (TYPE_MAIN_VARIANT (intype
), TYPE_MAIN_VARIANT (type
)))
5528 return build_static_cast (type
, expr
);
5529 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5531 if (! real_lvalue_p (expr
))
5533 cp_error ("const_cast from `%T' rvalue to `%T'", intype
, type
);
5534 return error_mark_node
;
5537 if (comp_ptr_ttypes_const (TREE_TYPE (type
), intype
))
5539 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5540 expr
= build1 (NOP_EXPR
, type
, expr
);
5541 return convert_from_reference (expr
);
5544 else if (TREE_CODE (type
) == POINTER_TYPE
5545 && TREE_CODE (intype
) == POINTER_TYPE
5546 && comp_ptr_ttypes_const (TREE_TYPE (type
), TREE_TYPE (intype
)))
5547 return cp_convert (type
, expr
);
5549 cp_error ("const_cast from `%T' to `%T'", intype
, type
);
5550 return error_mark_node
;
5553 /* Build an expression representing a cast to type TYPE of expression EXPR.
5555 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5556 when doing the cast. */
5559 build_c_cast (type
, expr
)
5562 register tree value
= expr
;
5565 if (type
== error_mark_node
|| expr
== error_mark_node
)
5566 return error_mark_node
;
5568 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5569 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5570 if (TREE_CODE (type
) != REFERENCE_TYPE
5571 && TREE_CODE (value
) == NOP_EXPR
5572 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5573 value
= TREE_OPERAND (value
, 0);
5575 if (TREE_TYPE (expr
)
5576 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
5577 && TREE_CODE (type
) != OFFSET_TYPE
)
5578 value
= resolve_offset_ref (value
);
5580 if (TREE_CODE (type
) == ARRAY_TYPE
)
5582 /* Allow casting from T1* to T2[] because Cfront allows it.
5583 NIHCL uses it. It is not valid ANSI C however, and hence, not
5585 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5588 pedwarn ("ANSI C++ forbids casting to an array type");
5589 type
= build_pointer_type (TREE_TYPE (type
));
5593 error ("ANSI C++ forbids casting to an array type");
5594 return error_mark_node
;
5598 if (TREE_CODE (type
) == FUNCTION_TYPE
5599 || TREE_CODE (type
) == METHOD_TYPE
)
5601 cp_error ("casting to function type `%T'", type
);
5602 return error_mark_node
;
5605 if (IS_SIGNATURE (type
))
5607 error ("cast specifies signature type");
5608 return error_mark_node
;
5611 if (processing_template_decl
)
5613 tree t
= build_min (CAST_EXPR
, type
,
5614 min_tree_cons (NULL_TREE
, value
, NULL_TREE
));
5618 /* Convert functions and arrays to pointers and
5619 convert references to their expanded types,
5620 but don't convert any other types. If, however, we are
5621 casting to a class type, there's no reason to do this: the
5622 cast will only succeed if there is a converting constructor,
5623 and the default conversions will be done at that point. In
5624 fact, doing the default conversion here is actually harmful
5628 struct S { S(const A&); };
5630 since we don't want the array-to-pointer conversion done. */
5631 if (!IS_AGGR_TYPE (type
))
5633 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5634 || (TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
5635 /* Don't do the default conversion if we want a
5636 pointer to a function. */
5637 && ! (TREE_CODE (type
) == POINTER_TYPE
5638 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
5639 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5640 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5641 value
= default_conversion (value
);
5643 else if (TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5644 /* However, even for class types, we still need to strip away
5645 the reference type, since the call to convert_force below
5646 does not expect the input expression to be of reference
5648 value
= convert_from_reference (value
);
5650 otype
= TREE_TYPE (value
);
5652 /* Optionally warn about potentially worrisome casts. */
5655 && TREE_CODE (type
) == POINTER_TYPE
5656 && TREE_CODE (otype
) == POINTER_TYPE
5657 && !at_least_as_qualified_p (TREE_TYPE (type
),
5659 cp_warning ("cast discards qualifiers from pointer target type");
5661 /* Warn about possible alignment problems. */
5662 if (STRICT_ALIGNMENT
&& warn_cast_align
5663 && TREE_CODE (type
) == POINTER_TYPE
5664 && TREE_CODE (otype
) == POINTER_TYPE
5665 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5666 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5667 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5668 warning ("cast increases required alignment of target type");
5671 /* We should see about re-enabling these, they seem useful to
5673 if (TREE_CODE (type
) == INTEGER_TYPE
5674 && TREE_CODE (otype
) == POINTER_TYPE
5675 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5676 warning ("cast from pointer to integer of different size");
5678 if (TREE_CODE (type
) == POINTER_TYPE
5679 && TREE_CODE (otype
) == INTEGER_TYPE
5680 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5681 /* Don't warn about converting 0 to pointer,
5682 provided the 0 was explicit--not cast or made by folding. */
5683 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5684 warning ("cast to pointer from integer of different size");
5687 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5688 value
= (convert_from_reference
5689 (convert_to_reference (type
, value
, CONV_C_CAST
,
5690 LOOKUP_COMPLAIN
, NULL_TREE
)));
5695 if (TREE_READONLY_DECL_P (value
))
5696 value
= decl_constant_value (value
);
5699 value
= convert_force (type
, value
, CONV_C_CAST
);
5701 /* Ignore any integer overflow caused by the cast. */
5702 if (TREE_CODE (value
) == INTEGER_CST
)
5704 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5705 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5709 /* Always produce some operator for an explicit cast,
5710 so we can tell (for -pedantic) that the cast is no lvalue. */
5711 if (TREE_CODE (type
) != REFERENCE_TYPE
&& value
== expr
5712 && real_lvalue_p (value
))
5713 value
= non_lvalue (value
);
5718 /* Build an assignment expression of lvalue LHS from value RHS.
5719 MODIFYCODE is the code for a binary operator that we use
5720 to combine the old value of LHS with RHS to get the new value.
5721 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5723 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5726 build_modify_expr (lhs
, modifycode
, rhs
)
5728 enum tree_code modifycode
;
5731 register tree result
;
5733 tree lhstype
= TREE_TYPE (lhs
);
5734 tree olhstype
= lhstype
;
5737 /* Avoid duplicate error messages from operands that had errors. */
5738 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
5739 return error_mark_node
;
5741 /* Types that aren't fully specified cannot be used in assignments. */
5742 lhs
= require_complete_type (lhs
);
5746 /* Handle assignment to signature pointers/refs. */
5748 if (TYPE_LANG_SPECIFIC (lhstype
)
5749 && (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5751 return build_signature_pointer_constructor (lhs
, rhs
);
5754 /* Handle control structure constructs used as "lvalues". */
5756 switch (TREE_CODE (lhs
))
5758 /* Handle --foo = 5; as these are valid constructs in C++ */
5759 case PREDECREMENT_EXPR
:
5760 case PREINCREMENT_EXPR
:
5761 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5762 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5763 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5764 TREE_OPERAND (lhs
, 1));
5765 return build (COMPOUND_EXPR
, lhstype
,
5767 build_modify_expr (TREE_OPERAND (lhs
, 0),
5770 /* Handle (a, b) used as an "lvalue". */
5772 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5774 if (newrhs
== error_mark_node
)
5775 return error_mark_node
;
5776 return build (COMPOUND_EXPR
, lhstype
,
5777 TREE_OPERAND (lhs
, 0), newrhs
);
5780 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5781 if (newrhs
== error_mark_node
)
5782 return error_mark_node
;
5783 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5785 /* Handle (a ? b : c) used as an "lvalue". */
5787 rhs
= save_expr (rhs
);
5789 /* Produce (a ? (b = rhs) : (c = rhs))
5790 except that the RHS goes through a save-expr
5791 so the code to compute it is only emitted once. */
5793 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5794 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5796 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5798 if (cond
== error_mark_node
)
5800 /* Make sure the code to compute the rhs comes out
5801 before the split. */
5802 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5803 /* Case to void to suppress warning
5804 from warn_if_unused_value. */
5805 cp_convert (void_type_node
, rhs
), cond
);
5812 if (TREE_CODE (lhs
) == OFFSET_REF
)
5814 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5816 /* Static class member? */
5817 tree member
= TREE_OPERAND (lhs
, 1);
5818 if (TREE_CODE (member
) == VAR_DECL
)
5822 compiler_error ("invalid static class member");
5823 return error_mark_node
;
5827 lhs
= resolve_offset_ref (lhs
);
5829 olhstype
= lhstype
= TREE_TYPE (lhs
);
5832 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5833 && modifycode
!= INIT_EXPR
)
5835 lhs
= convert_from_reference (lhs
);
5836 olhstype
= lhstype
= TREE_TYPE (lhs
);
5839 /* If a binary op has been requested, combine the old LHS value with the RHS
5840 producing the value we should actually store into the LHS. */
5842 if (modifycode
== INIT_EXPR
)
5844 if (! IS_AGGR_TYPE (lhstype
))
5845 /* Do the default thing */;
5848 result
= build_method_call (lhs
, ctor_identifier
,
5849 build_expr_list (NULL_TREE
, rhs
),
5850 TYPE_BINFO (lhstype
), LOOKUP_NORMAL
);
5851 if (result
== NULL_TREE
)
5852 return error_mark_node
;
5856 else if (modifycode
== NOP_EXPR
)
5858 /* `operator=' is not an inheritable operator. */
5859 if (! IS_AGGR_TYPE (lhstype
))
5860 /* Do the default thing */;
5863 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5864 lhs
, rhs
, make_node (NOP_EXPR
));
5865 if (result
== NULL_TREE
)
5866 return error_mark_node
;
5871 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5873 my_friendly_abort (978652);
5877 lhs
= stabilize_reference (lhs
);
5878 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5879 if (newrhs
== error_mark_node
)
5881 cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode
,
5882 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
5883 return error_mark_node
;
5887 /* Handle a cast used as an "lvalue".
5888 We have already performed any binary operator using the value as cast.
5889 Now convert the result to the cast type of the lhs,
5890 and then true type of the lhs and store it there;
5891 then convert result back to the cast type to be the value
5892 of the assignment. */
5894 switch (TREE_CODE (lhs
))
5899 case FIX_TRUNC_EXPR
:
5900 case FIX_FLOOR_EXPR
:
5901 case FIX_ROUND_EXPR
:
5903 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5904 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5905 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5906 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5907 newrhs
= default_conversion (newrhs
);
5909 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5912 /* WP 5.4.1: The result is an lvalue if T is a reference type,
5913 otherwise the result is an rvalue. */
5914 if (! lvalue_p (lhs
))
5915 pedwarn ("ANSI C++ forbids cast to non-reference type used as lvalue");
5917 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5918 cp_convert (TREE_TYPE (inner_lhs
),
5919 cp_convert (lhstype
, newrhs
)));
5920 if (result
== error_mark_node
)
5922 return cp_convert (TREE_TYPE (lhs
), result
);
5929 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5930 Reject anything strange now. */
5932 if (!lvalue_or_else (lhs
, "assignment"))
5933 return error_mark_node
;
5935 GNU_xref_assign (lhs
);
5937 /* Warn about storing in something that is `const'. */
5938 /* For C++, don't warn if this is initialization. */
5939 if (modifycode
!= INIT_EXPR
5940 /* For assignment to `const' signature pointer/reference fields,
5941 don't warn either, we already printed a better message before. */
5942 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5943 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5944 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5945 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
5946 /* Functions are not modifiable, even though they are
5948 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
5949 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5950 || TREE_CODE (lhstype
) == UNION_TYPE
)
5951 && C_TYPE_FIELDS_READONLY (lhstype
))
5952 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5953 && CP_TYPE_CONST_P (TREE_TYPE (lhstype
)))))
5954 readonly_error (lhs
, "assignment", 0);
5956 /* If storing into a structure or union member,
5957 it has probably been given type `int'.
5958 Compute the type that would go with
5959 the actual amount of storage the member occupies. */
5961 if (TREE_CODE (lhs
) == COMPONENT_REF
5962 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5963 || TREE_CODE (lhstype
) == REAL_TYPE
5964 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5966 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5968 /* If storing in a field that is in actuality a short or narrower
5969 than one, we must store in the field in its actual type. */
5971 if (lhstype
!= TREE_TYPE (lhs
))
5973 lhs
= copy_node (lhs
);
5974 TREE_TYPE (lhs
) = lhstype
;
5978 /* check to see if there is an assignment to `this' */
5979 if (lhs
== current_class_ptr
)
5981 if (flag_this_is_variable
> 0
5982 && DECL_NAME (current_function_decl
) != NULL_TREE
5983 && (DECL_NAME (current_function_decl
)
5984 != constructor_name (current_class_type
)))
5985 warning ("assignment to `this' not in constructor or destructor");
5986 current_function_just_assigned_this
= 1;
5989 if (modifycode
!= INIT_EXPR
)
5991 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5992 modifycode
= NOP_EXPR
;
5993 /* Reference-bashing */
5994 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5996 tree tmp
= convert_from_reference (lhs
);
5997 lhstype
= TREE_TYPE (tmp
);
5998 if (TYPE_SIZE (lhstype
) == 0)
6000 incomplete_type_error (lhs
, lhstype
);
6001 return error_mark_node
;
6006 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
6008 tree tmp
= convert_from_reference (newrhs
);
6009 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
6011 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
6012 return error_mark_node
;
6018 if (TREE_SIDE_EFFECTS (lhs
))
6019 lhs
= stabilize_reference (lhs
);
6020 if (TREE_SIDE_EFFECTS (newrhs
))
6021 newrhs
= stabilize_reference (newrhs
);
6023 /* Convert new value to destination type. */
6025 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
6029 if (!same_or_base_type_p (lhstype
, TREE_TYPE (rhs
)))
6031 cp_error ("incompatible types in assignment of `%T' to `%T'",
6032 TREE_TYPE (rhs
), lhstype
);
6033 return error_mark_node
;
6036 /* Allow array assignment in compiler-generated code. */
6037 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
6038 pedwarn ("ANSI C++ forbids assignment of arrays");
6040 /* Have to wrap this in RTL_EXPR for two cases:
6041 in base or member initialization and if we
6042 are a branch of a ?: operator. Since we
6043 can't easily know the latter, just do it always. */
6045 result
= make_node (RTL_EXPR
);
6047 TREE_TYPE (result
) = void_type_node
;
6048 do_pending_stack_adjust ();
6049 start_sequence_for_rtl_expr (result
);
6051 /* As a matter of principle, `start_sequence' should do this. */
6054 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6055 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6056 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
6059 do_pending_stack_adjust ();
6061 TREE_SIDE_EFFECTS (result
) = 1;
6062 RTL_EXPR_SEQUENCE (result
) = get_insns ();
6063 RTL_EXPR_RTL (result
) = const0_rtx
;
6068 if (modifycode
== INIT_EXPR
)
6070 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
6071 "assignment", NULL_TREE
, 0);
6072 if (lhs
== DECL_RESULT (current_function_decl
))
6074 if (DECL_INITIAL (lhs
))
6075 warning ("return value from function receives multiple initializations");
6076 DECL_INITIAL (lhs
) = newrhs
;
6081 /* Avoid warnings on enum bit fields. */
6082 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
6083 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
6085 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6087 newrhs
= convert_force (lhstype
, newrhs
, 0);
6090 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
6092 if (TREE_CODE (newrhs
) == CALL_EXPR
6093 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6094 newrhs
= build_cplus_new (lhstype
, newrhs
);
6096 /* Can't initialize directly from a TARGET_EXPR, since that would
6097 cause the lhs to be constructed twice, and possibly result in
6098 accidental self-initialization. So we force the TARGET_EXPR to be
6099 expanded without a target. */
6100 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6101 newrhs
= build (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
6102 TREE_OPERAND (newrhs
, 0));
6105 if (newrhs
== error_mark_node
)
6106 return error_mark_node
;
6108 if (TREE_CODE (newrhs
) == COND_EXPR
)
6111 tree cond
= TREE_OPERAND (newrhs
, 0);
6113 if (TREE_SIDE_EFFECTS (lhs
))
6114 cond
= build_compound_expr (tree_cons
6116 build_expr_list (NULL_TREE
, cond
)));
6118 /* Cannot have two identical lhs on this one tree (result) as preexpand
6119 calls will rip them out and fill in RTL for them, but when the
6120 rtl is generated, the calls will only be in the first side of the
6121 condition, not on both, or before the conditional jump! (mrs) */
6122 lhs1
= break_out_calls (lhs
);
6125 /* If there's no change, the COND_EXPR behaves like any other rhs. */
6126 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6127 lhstype
, lhs
, newrhs
);
6130 tree result_type
= TREE_TYPE (newrhs
);
6131 /* We have to convert each arm to the proper type because the
6132 types may have been munged by constant folding. */
6134 = build (COND_EXPR
, result_type
, cond
,
6135 build_modify_expr (lhs
, modifycode
,
6136 cp_convert (result_type
,
6137 TREE_OPERAND (newrhs
, 1))),
6138 build_modify_expr (lhs1
, modifycode
,
6139 cp_convert (result_type
,
6140 TREE_OPERAND (newrhs
, 2))));
6144 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6145 lhstype
, lhs
, newrhs
);
6147 TREE_SIDE_EFFECTS (result
) = 1;
6149 /* If we got the LHS in a different type for storing in,
6150 convert the result back to the nominal type of LHS
6151 so that the value we return always has the same type
6152 as the LHS argument. */
6154 if (olhstype
== TREE_TYPE (result
))
6156 /* Avoid warnings converting integral types back into enums
6157 for enum bit fields. */
6158 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
6159 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
6161 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
6162 TREE_NO_UNUSED_WARNING (result
) = 1;
6165 return convert_for_assignment (olhstype
, result
, "assignment",
6170 build_x_modify_expr (lhs
, modifycode
, rhs
)
6172 enum tree_code modifycode
;
6175 if (processing_template_decl
)
6176 return build_min_nt (MODOP_EXPR
, lhs
,
6177 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
6179 if (modifycode
!= NOP_EXPR
)
6181 tree rval
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
6182 make_node (modifycode
));
6186 return build_modify_expr (lhs
, modifycode
, rhs
);
6190 /* Get difference in deltas for different pointer to member function
6191 types. Return integer_zero_node, if FROM cannot be converted to a
6192 TO type. If FORCE is true, then allow reverse conversions as well. */
6195 get_delta_difference (from
, to
, force
)
6199 tree delta
= integer_zero_node
;
6205 /* Should get_base_distance here, so we can check if any thing along the
6206 path is virtual, and we need to make sure we stay
6207 inside the real binfos when going through virtual bases.
6208 Maybe we should replace virtual bases with
6209 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6210 binfo
= get_binfo (from
, to
, 1);
6211 if (binfo
== error_mark_node
)
6213 error (" in pointer to member function conversion");
6220 error_not_base_type (from
, to
);
6221 error (" in pointer to member conversion");
6224 binfo
= get_binfo (to
, from
, 1);
6225 if (binfo
== 0 || binfo
== error_mark_node
)
6227 if (TREE_VIA_VIRTUAL (binfo
))
6229 binfo
= binfo_member (BINFO_TYPE (binfo
),
6230 CLASSTYPE_VBASECLASSES (from
));
6231 cp_warning ("pointer to member cast to virtual base `%T'",
6232 BINFO_TYPE (binfo
));
6233 warning (" will only work if you are very careful");
6235 delta
= BINFO_OFFSET (binfo
);
6236 delta
= cp_convert (ptrdiff_type_node
, delta
);
6238 return build_binary_op (MINUS_EXPR
,
6243 if (TREE_VIA_VIRTUAL (binfo
))
6247 cp_warning ("pointer to member cast from virtual base `%T'",
6248 BINFO_TYPE (binfo
));
6249 warning (" will only work if you are very careful");
6252 cp_error ("pointer to member conversion from virtual base `%T'",
6253 BINFO_TYPE (binfo
));
6256 return BINFO_OFFSET (binfo
);
6260 build_ptrmemfunc1 (type
, delta
, idx
, pfn
, delta2
)
6261 tree type
, delta
, idx
, pfn
, delta2
;
6266 /* This is the old way we did it. We want to avoid calling
6267 digest_init, so that it can give an error if we use { } when
6268 initializing a pointer to member function. */
6272 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6273 expr_tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6277 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6278 expr_tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6281 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6282 expr_tree_cons (NULL_TREE
, delta
,
6283 expr_tree_cons (NULL_TREE
, idx
,
6284 expr_tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6286 return digest_init (type
, u
, (tree
*)0);
6288 tree delta_field
, idx_field
, pfn_or_delta2_field
, pfn_field
, delta2_field
;
6290 int allconstant
, allsimple
;
6292 delta_field
= TYPE_FIELDS (type
);
6293 idx_field
= TREE_CHAIN (delta_field
);
6294 pfn_or_delta2_field
= TREE_CHAIN (idx_field
);
6295 subtype
= TREE_TYPE (pfn_or_delta2_field
);
6296 pfn_field
= TYPE_FIELDS (subtype
);
6297 delta2_field
= TREE_CHAIN (pfn_field
);
6301 allconstant
= TREE_CONSTANT (pfn
);
6302 allsimple
= !! initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
));
6303 u
= expr_tree_cons (pfn_field
, pfn
, NULL_TREE
);
6307 delta2
= convert_and_check (delta_type_node
, delta2
);
6308 allconstant
= TREE_CONSTANT (delta2
);
6309 allsimple
= !! initializer_constant_valid_p (delta2
, TREE_TYPE (delta2
));
6310 u
= expr_tree_cons (delta2_field
, delta2
, NULL_TREE
);
6313 delta
= convert_and_check (delta_type_node
, delta
);
6314 idx
= convert_and_check (delta_type_node
, idx
);
6316 allconstant
= allconstant
&& TREE_CONSTANT (delta
) && TREE_CONSTANT (idx
);
6317 allsimple
= allsimple
6318 && initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
6319 && initializer_constant_valid_p (idx
, TREE_TYPE (idx
));
6321 u
= build (CONSTRUCTOR
, subtype
, NULL_TREE
, u
);
6322 u
= expr_tree_cons (delta_field
, delta
,
6323 expr_tree_cons (idx_field
, idx
,
6324 expr_tree_cons (pfn_or_delta2_field
, u
, NULL_TREE
)));
6325 u
= build (CONSTRUCTOR
, type
, NULL_TREE
, u
);
6326 TREE_CONSTANT (u
) = allconstant
;
6327 TREE_STATIC (u
) = allconstant
&& allsimple
;
6332 /* Build a constructor for a pointer to member function. It can be
6333 used to initialize global variables, local variable, or used
6334 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6337 If FORCE is non-zero, then force this conversion, even if
6338 we would rather not do it. Usually set when using an explicit
6341 Return error_mark_node, if something goes wrong. */
6344 build_ptrmemfunc (type
, pfn
, force
)
6348 tree idx
= integer_zero_node
;
6349 tree delta
= integer_zero_node
;
6350 tree delta2
= integer_zero_node
;
6352 tree npfn
= NULL_TREE
;
6354 /* Handle multiple conversions of pointer to member functions. */
6355 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6357 tree ndelta
, ndelta2
;
6361 /* Is is already the right type? */
6362 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6365 pfn_type
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
));
6367 && comp_target_types (type
, pfn_type
, 1) != 1)
6368 cp_error ("conversion to `%T' from `%T'", type
, pfn_type
);
6370 ndelta
= cp_convert (ptrdiff_type_node
, build_component_ref (pfn
, delta_identifier
, NULL_TREE
, 0));
6371 ndelta2
= cp_convert (ptrdiff_type_node
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6372 idx
= build_component_ref (pfn
, index_identifier
, NULL_TREE
, 0);
6374 n
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (pfn_type
)),
6375 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6378 delta
= build_binary_op (PLUS_EXPR
, ndelta
, n
, 1);
6379 delta2
= build_binary_op (PLUS_EXPR
, ndelta2
, n
, 1);
6380 e1
= fold (build (GT_EXPR
, boolean_type_node
, idx
, integer_zero_node
));
6382 e2
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
,
6385 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6386 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6387 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6389 e3
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
,
6391 return build_conditional_expr (e1
, e2
, e3
);
6394 /* Handle null pointer to member function conversions. */
6395 if (integer_zerop (pfn
))
6397 pfn
= build_c_cast (type
, integer_zero_node
);
6398 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
),
6399 integer_zero_node
, integer_zero_node
,
6403 if (type_unknown_p (pfn
))
6404 return instantiate_type (type
, pfn
, 1);
6407 && comp_target_types (type
, TREE_TYPE (pfn
), 0) != 1)
6408 cp_error ("conversion to `%T' from `%T'", type
, TREE_TYPE (pfn
));
6410 /* Allow pointer to member conversions here. */
6411 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6412 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6414 delta2
= build_binary_op (PLUS_EXPR
, delta2
, delta
, 1);
6416 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6417 warning ("assuming pointer to member function is non-virtual");
6419 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6420 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6422 /* Find the offset to the vfield pointer in the object. */
6423 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6424 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6426 vfield_offset
= get_vfield_offset (vfield_offset
);
6427 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6429 /* Map everything down one to make room for the null pointer to member. */
6430 idx
= size_binop (PLUS_EXPR
,
6431 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6436 idx
= size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
6438 if (type
== TREE_TYPE (pfn
))
6444 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6445 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6449 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
, delta2
);
6452 /* Convert value RHS to type TYPE as preparation for an assignment
6453 to an lvalue of type TYPE.
6454 The real work of conversion is done by `convert'.
6455 The purpose of this function is to generate error messages
6456 for assignments that are not allowed in C.
6457 ERRTYPE is a string to use in error messages:
6458 "assignment", "return", etc.
6460 C++: attempts to allow `convert' to find conversions involving
6461 implicit type conversion between aggregate and scalar types
6462 as per 8.5.6 of C++ manual. Does not randomly dereference
6463 pointers to aggregates! */
6466 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6472 register enum tree_code codel
= TREE_CODE (type
);
6473 register tree rhstype
;
6474 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6476 /* Issue warnings about peculiar, but legal, uses of NULL. */
6477 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
6478 cp_warning ("converting NULL to non-pointer type");
6480 if (coder
== ERROR_MARK
)
6481 return error_mark_node
;
6483 if (codel
== OFFSET_TYPE
)
6485 type
= TREE_TYPE (type
);
6486 codel
= TREE_CODE (type
);
6489 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6490 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6491 rhs
= TREE_OPERAND (rhs
, 0);
6493 if (rhs
== error_mark_node
)
6494 return error_mark_node
;
6496 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6497 return error_mark_node
;
6499 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6501 rhs
= resolve_offset_ref (rhs
);
6502 if (rhs
== error_mark_node
)
6503 return error_mark_node
;
6504 rhstype
= TREE_TYPE (rhs
);
6505 coder
= TREE_CODE (rhstype
);
6508 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6509 || is_overloaded_fn (rhs
))
6510 rhs
= default_conversion (rhs
);
6511 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6512 rhs
= convert_from_reference (rhs
);
6514 /* If rhs is some sort of overloaded function, ocp_convert will either
6515 do the right thing or complain; we don't need to check anything else.
6516 So just hand off. */
6517 if (type_unknown_p (rhs
))
6518 return ocp_convert (type
, rhs
, CONV_IMPLICIT
, LOOKUP_NORMAL
);
6520 rhstype
= TREE_TYPE (rhs
);
6521 coder
= TREE_CODE (rhstype
);
6523 /* This should no longer change types on us. */
6524 if (TREE_CODE (rhs
) == CONST_DECL
)
6525 rhs
= DECL_INITIAL (rhs
);
6526 else if (TREE_READONLY_DECL_P (rhs
))
6527 rhs
= decl_constant_value (rhs
);
6529 if (same_type_p (type
, rhstype
))
6531 overflow_warning (rhs
);
6535 if (coder
== VOID_TYPE
)
6537 error ("void value not ignored as it ought to be");
6538 return error_mark_node
;
6540 /* Arithmetic types all interconvert. */
6541 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
6542 || codel
== COMPLEX_TYPE
)
6543 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
6544 || coder
== COMPLEX_TYPE
))
6546 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6547 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6550 cp_warning ("`%T' used for argument %P of `%D'",
6551 rhstype
, parmnum
, fndecl
);
6553 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6555 /* And we should warn if assigning a negative value to
6556 an unsigned variable. */
6557 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6559 if (TREE_CODE (rhs
) == INTEGER_CST
6560 && TREE_NEGATED_INT (rhs
))
6563 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6564 rhs
, parmnum
, fndecl
);
6566 cp_warning ("%s of negative value `%E' to `%T'",
6567 errtype
, rhs
, type
);
6569 overflow_warning (rhs
);
6570 if (TREE_CONSTANT (rhs
))
6574 return convert_and_check (type
, rhs
);
6576 /* Conversions involving enums. */
6577 else if ((codel
== ENUMERAL_TYPE
6578 && (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
))
6579 || (coder
== ENUMERAL_TYPE
6580 && (INTEGRAL_CODE_P (codel
) || codel
== REAL_TYPE
)))
6582 return ocp_convert (type
, rhs
, CONV_IMPLICIT
, LOOKUP_NORMAL
);
6584 /* Conversions among pointers */
6585 else if (codel
== POINTER_TYPE
6586 && (coder
== POINTER_TYPE
6587 || (coder
== RECORD_TYPE
6588 && (IS_SIGNATURE_POINTER (rhstype
)
6589 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6591 register tree ttl
= TREE_TYPE (type
);
6595 if (coder
== RECORD_TYPE
)
6597 rhs
= build_optr_ref (rhs
);
6598 rhstype
= TREE_TYPE (rhs
);
6600 ttr
= TREE_TYPE (rhstype
);
6602 /* If both pointers are of aggregate type, then we
6603 can give better error messages, and save some work
6605 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6609 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6610 || type
== class_star_type_node
6611 || rhstype
== class_star_type_node
)
6612 binfo
= TYPE_BINFO (ttl
);
6614 binfo
= get_binfo (ttl
, ttr
, 1);
6616 if (binfo
== error_mark_node
)
6617 return error_mark_node
;
6619 return error_not_base_type (ttl
, ttr
);
6621 if (!at_least_as_qualified_p (ttl
, ttr
))
6624 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6625 rhstype
, parmnum
, fndecl
);
6627 cp_error ("%s to `%T' from `%T' discards qualifiers",
6628 errtype
, type
, rhstype
);
6632 /* Any non-function converts to a [const][volatile] void *
6633 and vice versa; otherwise, targets must be the same.
6634 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6635 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6636 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6637 || (ctt
= comp_target_types (type
, rhstype
, 1))
6638 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6639 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6641 /* ARM $4.8, commentary on p39. */
6642 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6643 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6645 cp_error ("no standard conversion from `%T' to `void *'", ttr
);
6646 return error_mark_node
;
6649 if (ctt
< 0 && TYPE_MAIN_VARIANT (ttl
) != TYPE_MAIN_VARIANT (ttr
))
6650 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6653 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6654 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6655 && ! null_ptr_cst_p (rhs
))
6657 if (coder
== RECORD_TYPE
)
6658 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6661 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6664 /* Const and volatile mean something different for function types,
6665 so the usual warnings are not appropriate. */
6666 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6667 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6669 if (TREE_CODE (ttl
) == OFFSET_TYPE
6670 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6671 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6673 error ("%s between pointer to members converting across virtual baseclasses", errtype
);
6674 return error_mark_node
;
6676 else if (!at_least_as_qualified_p (ttl
, ttr
))
6678 if (string_conv_p (type
, rhs
, 1))
6679 /* converting from string constant to char *, OK. */;
6681 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6682 rhstype
, parmnum
, fndecl
);
6684 cp_error ("%s to `%T' from `%T' discards qualifiers",
6685 errtype
, type
, rhstype
);
6687 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6688 && ! comp_target_types (type
, rhstype
, 1))
6691 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6692 rhstype
, parmnum
, fndecl
);
6694 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6695 errtype
, type
, rhstype
);
6702 int drops_quals
= 0;
6704 int unsigned_parity
;
6707 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6708 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6711 drops_quals
|= !at_least_as_qualified_p (ttl
, ttr
);
6714 && !at_least_as_qualified_p (ttr
, ttl
))
6716 left_const
&= TYPE_READONLY (ttl
);
6718 if (TREE_CODE (ttl
) != POINTER_TYPE
6719 || TREE_CODE (ttr
) != POINTER_TYPE
)
6722 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6723 if (unsigned_parity
)
6725 if (TREE_UNSIGNED (ttl
))
6726 ttr
= unsigned_type (ttr
);
6728 ttl
= unsigned_type (ttl
);
6731 if (comp_target_types (ttl
, ttr
, nptrs
) > 0)
6736 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6737 rhstype
, parmnum
, fndecl
);
6739 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6740 errtype
, type
, rhstype
);
6745 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6746 rhstype
, parmnum
, fndecl
);
6748 cp_error ("%s to `%T' from `%T' discards qualifiers",
6749 errtype
, type
, rhstype
);
6751 if (unsigned_parity
> 0)
6754 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6755 rhstype
, parmnum
, fndecl
);
6757 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6758 errtype
, type
, rhstype
);
6760 else if (unsigned_parity
< 0)
6763 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6764 rhstype
, parmnum
, fndecl
);
6766 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6767 errtype
, type
, rhstype
);
6770 /* C++ is not so friendly about converting function and
6771 member function pointers as C. Emit warnings here. */
6772 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6773 || TREE_CODE (ttl
) == METHOD_TYPE
)
6774 if (!same_or_base_type_p (ttl
, ttr
))
6776 warning ("conflicting function types in %s:", errtype
);
6777 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6783 cp_error ("passing `%T' as argument %P of `%D'",
6784 rhstype
, parmnum
, fndecl
);
6786 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6787 return error_mark_node
;
6790 return cp_convert (type
, rhs
);
6792 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6794 /* An explicit constant 0 can convert to a pointer,
6795 but not a 0 that results from casting or folding. */
6796 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6799 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6800 rhstype
, parmnum
, fndecl
);
6802 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6803 errtype
, type
, rhstype
);
6805 return cp_convert (type
, rhs
);
6807 else if (codel
== INTEGER_TYPE
6808 && (coder
== POINTER_TYPE
6809 || (coder
== RECORD_TYPE
6810 && (IS_SIGNATURE_POINTER (rhstype
)
6811 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6812 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6815 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6816 rhstype
, parmnum
, fndecl
);
6818 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6819 errtype
, type
, rhstype
);
6820 return cp_convert (type
, rhs
);
6822 else if (codel
== BOOLEAN_TYPE
6823 && (coder
== POINTER_TYPE
6824 || (coder
== RECORD_TYPE
6825 && (IS_SIGNATURE_POINTER (rhstype
)
6826 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6827 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6828 return cp_convert (type
, rhs
);
6831 else if (((coder
== POINTER_TYPE
6832 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6833 || integer_zerop (rhs
)
6834 || TYPE_PTRMEMFUNC_P (rhstype
))
6835 && TYPE_PTRMEMFUNC_P (type
))
6837 tree ttl
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
6838 tree ttr
= (TYPE_PTRMEMFUNC_P (rhstype
)
6839 ? TYPE_PTRMEMFUNC_FN_TYPE (rhstype
)
6841 int ctt
= (TREE_CODE (rhstype
) == INTEGER_TYPE
? 1
6842 : comp_target_types (ttl
, ttr
, 1));
6845 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6848 cp_error ("%s to `%T' from `%T'", errtype
, ttl
, ttr
);
6850 /* compatible pointer to member functions. */
6851 return build_ptrmemfunc (ttl
, rhs
, 0);
6853 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6854 return error_mark_node
;
6856 /* This should no longer happen. References are initialized via
6857 `convert_for_initialization'. They should otherwise be
6858 bashed before coming here. */
6859 else if (codel
== REFERENCE_TYPE
)
6860 my_friendly_abort (317);
6861 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6863 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6864 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6867 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6868 return cp_convert (type
, rhs
);
6869 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
6870 else if (TREE_CODE (type
) == POINTER_TYPE
6871 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
6872 || TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
6874 && TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6875 return cp_convert (type
, rhs
);
6877 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6878 return error_mark_node
;
6881 /* Convert RHS to be of type TYPE.
6882 If EXP is non-zero, it is the target of the initialization.
6883 ERRTYPE is a string to use in error messages.
6885 Two major differences between the behavior of
6886 `convert_for_assignment' and `convert_for_initialization'
6887 are that references are bashed in the former, while
6888 copied in the latter, and aggregates are assigned in
6889 the former (operator=) while initialized in the
6892 If using constructor make sure no conversion operator exists, if one does
6893 exist, an ambiguity exists.
6895 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6898 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6899 tree exp
, type
, rhs
;
6905 register enum tree_code codel
= TREE_CODE (type
);
6906 register tree rhstype
;
6907 register enum tree_code coder
;
6909 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6910 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6911 if (TREE_CODE (rhs
) == NOP_EXPR
6912 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6913 && codel
!= REFERENCE_TYPE
)
6914 rhs
= TREE_OPERAND (rhs
, 0);
6916 if (rhs
== error_mark_node
6917 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6918 return error_mark_node
;
6920 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6922 rhs
= resolve_offset_ref (rhs
);
6923 if (rhs
== error_mark_node
)
6924 return error_mark_node
;
6927 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6928 rhs
= convert_from_reference (rhs
);
6930 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6931 && TREE_CODE (type
) != ARRAY_TYPE
6932 && (TREE_CODE (type
) != REFERENCE_TYPE
6933 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6934 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6935 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6936 rhs
= default_conversion (rhs
);
6938 rhstype
= TREE_TYPE (rhs
);
6939 coder
= TREE_CODE (rhstype
);
6941 if (coder
== ERROR_MARK
)
6942 return error_mark_node
;
6944 /* We accept references to incomplete types, so we can
6945 return here before checking if RHS is of complete type. */
6947 if (codel
== REFERENCE_TYPE
)
6949 /* This should eventually happen in convert_arguments. */
6950 extern int warningcount
, errorcount
;
6951 int savew
= 0, savee
= 0;
6954 savew
= warningcount
, savee
= errorcount
;
6955 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6956 exp
? exp
: error_mark_node
);
6959 if (warningcount
> savew
)
6960 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6961 else if (errorcount
> savee
)
6962 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6967 rhs
= require_complete_type (rhs
);
6968 if (rhs
== error_mark_node
)
6969 return error_mark_node
;
6971 if (exp
!= 0) exp
= require_complete_type (exp
);
6972 if (exp
== error_mark_node
)
6973 return error_mark_node
;
6975 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6976 rhstype
= TREE_TYPE (rhstype
);
6978 type
= complete_type (type
);
6980 if (TYPE_LANG_SPECIFIC (type
)
6981 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6982 return build_signature_pointer_constructor (type
, rhs
);
6984 if (IS_AGGR_TYPE (type
))
6985 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
6987 if (type
== TREE_TYPE (rhs
))
6989 /* Issue warnings about peculiar, but legal, uses of NULL. We
6990 do this *before* the call to decl_constant_value so as to
6991 avoid duplicate warnings on code like `const int I = NULL;
6993 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
6994 cp_warning ("converting NULL to non-pointer type");
6996 if (TREE_READONLY_DECL_P (rhs
))
6997 rhs
= decl_constant_value (rhs
);
7002 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
7005 /* Expand an ASM statement with operands, handling output operands
7006 that are not variables or INDIRECT_REFS by transforming such
7007 cases into cases that expand_asm_operands can handle.
7009 Arguments are same as for expand_asm_operands.
7011 We don't do default conversions on all inputs, because it can screw
7012 up operands that are expected to be in memory. */
7015 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
7016 tree string
, outputs
, inputs
, clobbers
;
7021 int noutputs
= list_length (outputs
);
7023 /* o[I] is the place that output number I should be written. */
7024 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
7027 /* Record the contents of OUTPUTS before it is modified. */
7028 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7029 o
[i
] = TREE_VALUE (tail
);
7031 /* Generate the ASM_OPERANDS insn;
7032 store into the TREE_VALUEs of OUTPUTS some trees for
7033 where the values were actually stored. */
7034 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
7036 /* Copy all the intermediate outputs into the specified outputs. */
7037 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7039 if (o
[i
] != TREE_VALUE (tail
))
7041 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
7042 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
7045 /* Detect modification of read-only values.
7046 (Otherwise done by build_modify_expr.) */
7049 tree type
= TREE_TYPE (o
[i
]);
7050 if (CP_TYPE_CONST_P (type
)
7051 || ((TREE_CODE (type
) == RECORD_TYPE
7052 || TREE_CODE (type
) == UNION_TYPE
)
7053 && C_TYPE_FIELDS_READONLY (type
)))
7054 readonly_error (o
[i
], "modification by `asm'", 1);
7058 /* Those MODIFY_EXPRs could do autoincrements. */
7062 /* Expand a C `return' statement.
7063 RETVAL is the expression for what to return,
7064 or a null pointer for `return;' with no value.
7066 C++: upon seeing a `return', we must call destructors on all
7067 variables in scope which had constructors called on them.
7068 This means that if in a destructor, the base class destructors
7069 must be called before returning.
7071 The RETURN statement in C++ has initialization semantics. */
7074 c_expand_return (retval
)
7077 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
7078 extern tree dtor_label
, ctor_label
;
7079 tree result
= DECL_RESULT (current_function_decl
);
7080 tree valtype
= TREE_TYPE (result
);
7082 if (TREE_THIS_VOLATILE (current_function_decl
))
7083 warning ("function declared `noreturn' has a `return' statement");
7085 if (retval
== error_mark_node
)
7087 current_function_returns_null
= 1;
7091 if (processing_template_decl
)
7093 add_tree (build_min_nt (RETURN_STMT
, retval
));
7100 error ("returning a value from a destructor");
7102 /* Can't just return from a destructor. */
7103 expand_goto (dtor_label
);
7107 if (retval
== NULL_TREE
)
7109 /* A non-named return value does not count. */
7111 if (DECL_CONSTRUCTOR_P (current_function_decl
))
7112 retval
= current_class_ptr
;
7113 else if (DECL_NAME (result
) != NULL_TREE
7114 && TREE_CODE (valtype
) != VOID_TYPE
)
7118 current_function_returns_null
= 1;
7120 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
7122 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
7124 pedwarn ("`return' with no value, in function returning non-void");
7125 /* Clear this, so finish_function won't say that we
7126 reach the end of a non-void function (which we don't,
7127 we gave a return!). */
7128 current_function_returns_null
= 0;
7132 expand_null_return ();
7136 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
7138 if (flag_this_is_variable
)
7139 error ("return from a constructor: use `this = ...' instead");
7141 error ("returning a value from a constructor");
7142 retval
= current_class_ptr
;
7145 /* Effective C++ rule 15. See also start_function. */
7147 && DECL_NAME (current_function_decl
) == ansi_opname
[(int) MODIFY_EXPR
]
7148 && retval
!= current_class_ref
)
7149 cp_warning ("`operator=' should return a reference to `*this'");
7151 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
7153 current_function_returns_null
= 1;
7154 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
7155 pedwarn ("`return' with a value, in function returning void");
7156 expand_return (retval
);
7160 /* Now deal with possible C++ hair:
7161 (1) Compute the return value.
7162 (2) If there are aggregate values with destructors which
7163 must be cleaned up, clean them (taking care
7164 not to clobber the return value).
7165 (3) If an X(X&) constructor is defined, the return
7166 value must be returned via that. */
7168 if (retval
== result
7169 || DECL_CONSTRUCTOR_P (current_function_decl
))
7170 /* It's already done for us. */;
7171 else if (TREE_TYPE (retval
) == void_type_node
)
7173 pedwarn ("return of void value in function returning non-void");
7174 expand_expr_stmt (retval
);
7179 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7181 /* First convert the value to the function's return type, then
7182 to the type of return value's location to handle the
7183 case that functype is thiner than the valtype. */
7185 retval
= convert_for_initialization
7186 (NULL_TREE
, functype
, retval
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
7187 "return", NULL_TREE
, 0);
7189 retval
= convert (valtype
, retval
);
7191 if (retval
== error_mark_node
)
7193 /* Avoid warning about control reaching end of function. */
7194 expand_null_return ();
7198 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7199 else if (! current_function_returns_struct
7200 && TREE_CODE (retval
) == TARGET_EXPR
7201 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
7202 retval
= build (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
7203 TREE_OPERAND (retval
, 0));
7205 /* Add some useful error checking for C++. */
7206 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
7208 tree whats_returned
;
7210 /* Sort through common things to see what it is
7211 we are returning. */
7212 whats_returned
= retval
;
7213 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
7215 whats_returned
= TREE_OPERAND (whats_returned
, 1);
7216 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7217 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7219 while (TREE_CODE (whats_returned
) == CONVERT_EXPR
7220 || TREE_CODE (whats_returned
) == NOP_EXPR
)
7221 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7222 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7224 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7225 while (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
7226 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
7228 /* Get the target. */
7229 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7230 warning ("returning reference to temporary");
7234 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
7236 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
7237 warning ("reference to non-lvalue returned");
7238 else if (TREE_CODE (TREE_TYPE (whats_returned
)) != REFERENCE_TYPE
7239 && ! TREE_STATIC (whats_returned
)
7240 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7241 && !TREE_PUBLIC (whats_returned
))
7242 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7245 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7247 tree whats_returned
= TREE_OPERAND (retval
, 0);
7249 if (TREE_CODE (whats_returned
) == VAR_DECL
7250 && DECL_NAME (whats_returned
)
7251 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7252 && !TREE_STATIC (whats_returned
)
7253 && !TREE_PUBLIC (whats_returned
))
7254 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7258 if (retval
!= NULL_TREE
7259 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7260 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7261 current_function_return_value
= retval
;
7263 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7265 /* Here RETVAL is CURRENT_CLASS_PTR, so there's nothing to do. */
7266 expand_goto (ctor_label
);
7269 if (retval
&& retval
!= result
)
7271 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7272 TREE_SIDE_EFFECTS (result
) = 1;
7275 expand_start_target_temps ();
7277 expand_return (result
);
7279 expand_end_target_temps ();
7281 current_function_returns_value
= 1;
7284 /* Start a C switch statement, testing expression EXP.
7285 Return EXP if it is valid, an error node otherwise. */
7288 c_expand_start_case (exp
)
7293 exp
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, exp
, 1);
7294 if (exp
== NULL_TREE
)
7296 error ("switch quantity not an integer");
7297 exp
= error_mark_node
;
7299 if (exp
== error_mark_node
)
7300 return error_mark_node
;
7302 exp
= default_conversion (exp
);
7303 type
= TREE_TYPE (exp
);
7304 idx
= get_unwidened (exp
, 0);
7305 /* We can't strip a conversion from a signed type to an unsigned,
7306 because if we did, int_fits_type_p would do the wrong thing
7307 when checking case values for being in range,
7308 and it's too hard to do the right thing. */
7309 if (TREE_UNSIGNED (TREE_TYPE (exp
)) == TREE_UNSIGNED (TREE_TYPE (idx
)))
7313 (1, fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
)),
7314 type
, "switch statement");
7319 /* Returns non-zero if the pointer-type FROM can be converted to the
7320 pointer-type TO via a qualification conversion. If CONSTP is -1,
7321 then we return non-zero if the pointers are similar, and the
7322 cv-qualification signature of FROM is a proper subset of that of TO.
7324 If CONSTP is positive, then all outer pointers have been
7328 comp_ptr_ttypes_real (to
, from
, constp
)
7332 int to_more_cv_qualified
= 0;
7334 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7336 if (TREE_CODE (to
) != TREE_CODE (from
))
7339 if (TREE_CODE (from
) == OFFSET_TYPE
7340 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7341 TYPE_OFFSET_BASETYPE (to
)))
7344 /* Const and volatile mean something different for function types,
7345 so the usual checks are not appropriate. */
7346 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7348 if (!at_least_as_qualified_p (to
, from
))
7351 if (!at_least_as_qualified_p (from
, to
))
7356 ++to_more_cv_qualified
;
7360 constp
&= TYPE_READONLY (to
);
7363 if (TREE_CODE (to
) != POINTER_TYPE
)
7365 same_type_p (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
))
7366 && (constp
>= 0 || to_more_cv_qualified
);
7370 /* When comparing, say, char ** to char const **, this function takes the
7371 'char *' and 'char const *'. Do not pass non-pointer types to this
7375 comp_ptr_ttypes (to
, from
)
7378 return comp_ptr_ttypes_real (to
, from
, 1);
7381 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7382 type or inheritance-related types, regardless of cv-quals. */
7385 ptr_reasonably_similar (to
, from
)
7388 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7390 if (TREE_CODE (to
) != TREE_CODE (from
))
7393 if (TREE_CODE (from
) == OFFSET_TYPE
7394 && comptypes (TYPE_OFFSET_BASETYPE (to
),
7395 TYPE_OFFSET_BASETYPE (from
),
7396 COMPARE_BASE
| COMPARE_RELAXED
))
7399 if (TREE_CODE (to
) != POINTER_TYPE
)
7401 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
7402 COMPARE_BASE
| COMPARE_RELAXED
);
7406 /* Like comp_ptr_ttypes, for const_cast. */
7409 comp_ptr_ttypes_const (to
, from
)
7412 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7414 if (TREE_CODE (to
) != TREE_CODE (from
))
7417 if (TREE_CODE (from
) == OFFSET_TYPE
7418 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7419 TYPE_OFFSET_BASETYPE (to
)))
7422 if (TREE_CODE (to
) != POINTER_TYPE
)
7423 return same_type_p (TYPE_MAIN_VARIANT (to
),
7424 TYPE_MAIN_VARIANT (from
));
7428 /* Like comp_ptr_ttypes, for reinterpret_cast. */
7431 comp_ptr_ttypes_reinterpret (to
, from
)
7436 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7438 if (TREE_CODE (from
) == OFFSET_TYPE
)
7439 from
= TREE_TYPE (from
);
7440 if (TREE_CODE (to
) == OFFSET_TYPE
)
7441 to
= TREE_TYPE (to
);
7443 if (TREE_CODE (to
) != TREE_CODE (from
))
7446 /* Const and volatile mean something different for function types,
7447 so the usual checks are not appropriate. */
7448 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7450 if (!at_least_as_qualified_p (to
, from
))
7454 && !at_least_as_qualified_p (from
, to
))
7456 constp
&= TYPE_READONLY (to
);
7459 if (TREE_CODE (to
) != POINTER_TYPE
)
7464 /* Returns the type-qualifier set corresponding to TYPE. */
7467 cp_type_quals (type
)
7470 while (TREE_CODE (type
) == ARRAY_TYPE
)
7471 type
= TREE_TYPE (type
);
7473 return TYPE_QUALS (type
);