1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
42 extern void compiler_error ();
44 static tree convert_for_assignment
PROTO((tree
, tree
, char*, tree
,
46 static tree pointer_int_sum
PROTO((enum tree_code
, tree
, tree
));
47 static tree rationalize_conditional_expr
PROTO((enum tree_code
, tree
));
48 static int comp_target_parms
PROTO((tree
, tree
, int));
49 static int comp_ptr_ttypes_real
PROTO((tree
, tree
, int));
50 static int comp_ptr_ttypes_const
PROTO((tree
, tree
));
51 static int comp_ptr_ttypes_reinterpret
PROTO((tree
, tree
));
52 static int comp_array_types
PROTO((int (*) (tree
, tree
, int), tree
,
54 static tree build_ptrmemfunc1
PROTO((tree
, tree
, tree
, tree
, tree
));
55 static tree common_base_type
PROTO((tree
, tree
));
57 static tree convert_sequence
PROTO((tree
, tree
));
59 static tree lookup_anon_field
PROTO((tree
, tree
));
60 static tree pointer_diff
PROTO((tree
, tree
, tree
));
61 static tree qualify_type
PROTO((tree
, tree
));
62 static tree get_delta_difference
PROTO((tree
, tree
, int));
64 /* Return the target type of TYPE, which meas return T for:
65 T*, T&, T[], T (...), and otherwise, just T. */
71 if (TREE_CODE (type
) == REFERENCE_TYPE
)
72 type
= TREE_TYPE (type
);
73 while (TREE_CODE (type
) == POINTER_TYPE
74 || TREE_CODE (type
) == ARRAY_TYPE
75 || TREE_CODE (type
) == FUNCTION_TYPE
76 || TREE_CODE (type
) == METHOD_TYPE
77 || TREE_CODE (type
) == OFFSET_TYPE
)
78 type
= TREE_TYPE (type
);
82 /* Do `exp = require_complete_type (exp);' to make sure exp
83 does not have an incomplete type. (That includes void types.)
84 Returns the error_mark_node if the VALUE does not have
85 complete type when this function returns. */
88 require_complete_type (value
)
93 if (processing_template_decl
)
96 if (TREE_CODE (value
) == OVERLOAD
)
97 type
= unknown_type_node
;
99 type
= TREE_TYPE (value
);
101 /* First, detect a valid value with a complete type. */
102 if (TYPE_SIZE (type
) != 0
103 && type
!= void_type_node
104 && ! (TYPE_LANG_SPECIFIC (type
)
105 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
106 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
109 /* If we see X::Y, we build an OFFSET_TYPE which has
110 not been laid out. Try to avoid an error by interpreting
111 it as this->X::Y, if reasonable. */
112 if (TREE_CODE (value
) == OFFSET_REF
113 && current_class_ref
!= 0
114 && TREE_OPERAND (value
, 0) == current_class_ref
)
116 tree base
, member
= TREE_OPERAND (value
, 1);
117 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
118 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
119 base
= convert_pointer_to (basetype
, current_class_ptr
);
120 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
121 build_indirect_ref (base
, NULL_PTR
), member
);
122 return require_complete_type (value
);
125 if (complete_type_or_else (type
))
128 return error_mark_node
;
131 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
132 a template instantiation, do the instantiation. Returns TYPE,
133 whether or not it could be completed, unless something goes
134 horribly wrong, in which case the error_mark_node is returned. */
140 if (type
== NULL_TREE
)
141 /* Rather than crash, we return something sure to cause an error
143 return error_mark_node
;
145 if (type
== error_mark_node
|| TYPE_SIZE (type
) != NULL_TREE
)
147 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
149 tree t
= complete_type (TREE_TYPE (type
));
150 if (TYPE_SIZE (t
) != NULL_TREE
&& ! processing_template_decl
)
152 TYPE_NEEDS_CONSTRUCTING (type
)
153 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
154 TYPE_NEEDS_DESTRUCTOR (type
)
155 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
157 else if (IS_AGGR_TYPE (type
) && CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
158 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
163 /* Like complete_type, but issue an error if the TYPE cannot be
164 completed. Returns NULL_TREE if the type cannot be made
168 complete_type_or_else (type
)
171 type
= complete_type (type
);
172 if (type
== error_mark_node
)
173 /* We already issued an error. */
175 else if (!TYPE_SIZE (type
))
177 incomplete_type_error (NULL_TREE
, type
);
184 /* Return truthvalue of whether type of EXP is instantiated. */
190 return (TREE_CODE (exp
) == OVERLOAD
191 || TREE_CODE (exp
) == TREE_LIST
192 || TREE_TYPE (exp
) == unknown_type_node
193 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
194 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
197 /* Return truthvalue of whether T is function (or pfn) type. */
203 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
204 || (TREE_CODE (t
) == POINTER_TYPE
205 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
206 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
209 /* 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 (! CLASSTYPE_TEMPLATE_INFO (t1
) && ! CLASSTYPE_TEMPLATE_INFO (t2
))
778 /* Don't check inheritance. */
779 strict
= COMPARE_STRICT
;
784 if (CLASSTYPE_TEMPLATE_INFO (t1
) && CLASSTYPE_TEMPLATE_INFO (t2
)
785 && (CLASSTYPE_TI_TEMPLATE (t1
) == CLASSTYPE_TI_TEMPLATE (t2
)
786 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
))
787 val
= comp_template_args (CLASSTYPE_TI_ARGS (t1
),
788 CLASSTYPE_TI_ARGS (t2
));
790 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
795 if ((strict
& COMPARE_RELAXED
) && DERIVED_FROM_P (t2
, t1
))
803 val
= (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1
)),
804 build_pointer_type (TYPE_OFFSET_BASETYPE (t2
)), strict
)
805 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
809 if (! compexcepttypes (t1
, t2
))
812 /* This case is anti-symmetrical!
813 One can pass a base member (or member function)
814 to something expecting a derived member (or member function),
815 but not vice-versa! */
817 val
= (comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
818 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
825 /* first, check whether the referred types match with the
826 required level of strictness */
827 val
= comptypes (t1
, t2
, strict
);
830 if (TREE_CODE (t1
) == RECORD_TYPE
831 && TREE_CODE (t2
) == RECORD_TYPE
)
836 if (! compexcepttypes (t1
, t2
))
839 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
840 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
841 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)));
845 /* Target types must match incl. qualifiers. We use ORIG_STRICT
846 here since this is the one place where
847 COMPARE_REDECLARATION should be used. */
848 val
= comp_array_types (comptypes
, t1
, t2
, orig_strict
);
851 case TEMPLATE_TYPE_PARM
:
852 return TEMPLATE_TYPE_IDX (t1
) == TEMPLATE_TYPE_IDX (t2
)
853 && TEMPLATE_TYPE_LEVEL (t1
) == TEMPLATE_TYPE_LEVEL (t2
);
856 if (TYPE_IDENTIFIER (t1
) != TYPE_IDENTIFIER (t2
))
858 return same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
863 return attrval
== 2 && val
== 1 ? 2 : val
;
866 /* Subroutine of comp_target-types. Make sure that the cv-quals change
867 only in the same direction as the target type. */
870 comp_cv_target_types (ttl
, ttr
, nptrs
)
876 if (!at_least_as_qualified_p (ttl
, ttr
)
877 && !at_least_as_qualified_p (ttr
, ttl
))
878 /* The qualifications are incomparable. */
881 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
))
882 return more_qualified_p (ttr
, ttl
) ? -1 : 1;
884 t
= comp_target_types (ttl
, ttr
, nptrs
);
885 if ((t
== 1 && at_least_as_qualified_p (ttl
, ttr
))
886 || (t
== -1 && at_least_as_qualified_p (ttr
, ttl
)))
892 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
893 ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
894 converted to TTL. Return -1 means that TTL can be converted to TTR but
897 NPTRS is the number of pointers we can strip off and keep cool.
898 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
899 but to not permit B** to convert to A**.
901 This should go away. Callers should use can_convert or something
902 similar instead. (jason 17 Apr 1997) */
905 comp_target_types (ttl
, ttr
, nptrs
)
909 ttl
= TYPE_MAIN_VARIANT (ttl
);
910 ttr
= TYPE_MAIN_VARIANT (ttr
);
914 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
917 if ((TREE_CODE (ttr
) == POINTER_TYPE
918 || TREE_CODE (ttr
) == REFERENCE_TYPE
)
919 /* If we get a pointer with nptrs == 0, we don't allow any tweaking
920 of the type pointed to. This is necessary for reference init
921 semantics. We won't get here from a previous call with nptrs == 1;
922 for multi-level pointers we end up in comp_ptr_ttypes. */
925 int is_ptr
= TREE_CODE (ttr
) == POINTER_TYPE
;
927 ttl
= TREE_TYPE (ttl
);
928 ttr
= TREE_TYPE (ttr
);
932 if (TREE_CODE (ttl
) == UNKNOWN_TYPE
933 || TREE_CODE (ttr
) == UNKNOWN_TYPE
)
935 else if (TREE_CODE (ttl
) == VOID_TYPE
936 && TREE_CODE (ttr
) != FUNCTION_TYPE
937 && TREE_CODE (ttr
) != METHOD_TYPE
938 && TREE_CODE (ttr
) != OFFSET_TYPE
)
940 else if (TREE_CODE (ttr
) == VOID_TYPE
941 && TREE_CODE (ttl
) != FUNCTION_TYPE
942 && TREE_CODE (ttl
) != METHOD_TYPE
943 && TREE_CODE (ttl
) != OFFSET_TYPE
)
945 else if (TREE_CODE (ttl
) == POINTER_TYPE
946 || TREE_CODE (ttl
) == ARRAY_TYPE
)
948 if (comp_ptr_ttypes (ttl
, ttr
))
950 else if (comp_ptr_ttypes (ttr
, ttl
))
956 /* Const and volatile mean something different for function types,
957 so the usual checks are not appropriate. */
958 if (TREE_CODE (ttl
) == FUNCTION_TYPE
|| TREE_CODE (ttl
) == METHOD_TYPE
)
959 return comp_target_types (ttl
, ttr
, nptrs
- 1);
961 return comp_cv_target_types (ttl
, ttr
, nptrs
- 1);
964 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
965 return comp_array_types (comp_target_types
, ttl
, ttr
, COMPARE_STRICT
);
966 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
973 if (!same_type_p (TREE_TYPE (ttl
), TREE_TYPE (ttr
)))
978 switch (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), -1))
987 argsl
= TYPE_ARG_TYPES (ttl
);
988 argsr
= TYPE_ARG_TYPES (ttr
);
990 /* Compare 'this' here, not in comp_target_parms. */
991 if (TREE_CODE (ttr
) == METHOD_TYPE
)
993 tree tl
= TYPE_METHOD_BASETYPE (ttl
);
994 tree tr
= TYPE_METHOD_BASETYPE (ttr
);
996 if (!same_or_base_type_p (tr
, tl
))
998 if (same_or_base_type_p (tl
, tr
))
1004 argsl
= TREE_CHAIN (argsl
);
1005 argsr
= TREE_CHAIN (argsr
);
1008 switch (comp_target_parms (argsl
, argsr
, 1))
1016 return saw_contra
? -1 : 1;
1019 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
1023 /* Contravariance: we can assign a pointer to base member to a pointer
1024 to derived member. Note difference from simple pointer case, where
1025 we can pass a pointer to derived to a pointer to base. */
1026 if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr
),
1027 TYPE_OFFSET_BASETYPE (ttl
)))
1029 else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl
),
1030 TYPE_OFFSET_BASETYPE (ttr
)))
1040 ttl
= TREE_TYPE (ttl
);
1041 ttr
= TREE_TYPE (ttr
);
1043 if (TREE_CODE (ttl
) == POINTER_TYPE
1044 || TREE_CODE (ttl
) == ARRAY_TYPE
)
1046 if (comp_ptr_ttypes (ttl
, ttr
))
1052 if (comp_cv_target_types (ttl
, ttr
, nptrs
) == 1)
1057 else if (IS_AGGR_TYPE (ttl
))
1061 if (same_or_base_type_p (build_pointer_type (ttl
),
1062 build_pointer_type (ttr
)))
1064 if (same_or_base_type_p (build_pointer_type (ttr
),
1065 build_pointer_type (ttl
)))
1073 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1076 at_least_as_qualified_p (type1
, type2
)
1080 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1081 return ((CP_TYPE_QUALS (type1
) & CP_TYPE_QUALS (type2
))
1082 == CP_TYPE_QUALS (type2
));
1085 /* Returns 1 if TYPE1 is more qualified than TYPE2. */
1088 more_qualified_p (type1
, type2
)
1092 return (CP_TYPE_QUALS (type1
) != CP_TYPE_QUALS (type2
)
1093 && at_least_as_qualified_p (type1
, type2
));
1096 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1097 more cv-qualified that TYPE1, and 0 otherwise. */
1100 comp_cv_qualification (type1
, type2
)
1104 if (CP_TYPE_QUALS (type1
) == CP_TYPE_QUALS (type2
))
1107 if (at_least_as_qualified_p (type1
, type2
))
1110 else if (at_least_as_qualified_p (type2
, type1
))
1116 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1117 subset of the cv-qualification signature of TYPE2, and the types
1118 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1121 comp_cv_qual_signature (type1
, type2
)
1125 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1127 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1133 /* If two types share a common base type, return that basetype.
1134 If there is not a unique most-derived base type, this function
1135 returns ERROR_MARK_NODE. */
1138 common_base_type (tt1
, tt2
)
1141 tree best
= NULL_TREE
;
1144 /* If one is a baseclass of another, that's good enough. */
1145 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
1147 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
1150 /* Otherwise, try to find a unique baseclass of TT1
1151 that is shared by TT2, and follow that down. */
1152 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
1154 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
1155 tree trial
= common_base_type (basetype
, tt2
);
1158 if (trial
== error_mark_node
)
1160 if (best
== NULL_TREE
)
1162 else if (best
!= trial
)
1163 return error_mark_node
;
1168 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
1170 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
1171 tree trial
= common_base_type (tt1
, basetype
);
1174 if (trial
== error_mark_node
)
1176 if (best
== NULL_TREE
)
1178 else if (best
!= trial
)
1179 return error_mark_node
;
1185 /* Subroutines of `comptypes'. */
1187 /* Return 1 if two parameter type lists PARMS1 and PARMS2
1188 are equivalent in the sense that functions with those parameter types
1189 can have equivalent types.
1190 If either list is empty, we win.
1191 Otherwise, the two lists must be equivalent, element by element.
1193 C++: See comment above about TYPE1, TYPE2.
1195 STRICT is no longer used. */
1198 compparms (parms1
, parms2
)
1199 tree parms1
, parms2
;
1201 register tree t1
= parms1
, t2
= parms2
;
1203 /* An unspecified parmlist matches any specified parmlist
1204 whose argument types don't need default promotions. */
1208 if (t1
== 0 && t2
== 0)
1210 /* If one parmlist is shorter than the other,
1211 they fail to match. */
1212 if (t1
== 0 || t2
== 0)
1214 if (!same_type_p (TREE_VALUE (t2
), TREE_VALUE (t1
)))
1217 t1
= TREE_CHAIN (t1
);
1218 t2
= TREE_CHAIN (t2
);
1222 /* This really wants return whether or not parameter type lists
1223 would make their owning functions assignment compatible or not.
1225 The return value is like for comp_target_types.
1227 This should go away, possibly with the exception of the empty parmlist
1228 conversion; there are no conversions between function types in C++.
1229 (jason 17 Apr 1997) */
1232 comp_target_parms (parms1
, parms2
, strict
)
1233 tree parms1
, parms2
;
1236 register tree t1
= parms1
, t2
= parms2
;
1237 int warn_contravariance
= 0;
1239 /* In C, an unspecified parmlist matches any specified parmlist
1240 whose argument types don't need default promotions. This is not
1241 true for C++, but let's do it anyway for unfixed headers. */
1243 if (t1
== 0 && t2
!= 0)
1245 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
1247 return self_promoting_args_p (t2
);
1250 return self_promoting_args_p (t1
);
1252 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1256 /* If one parmlist is shorter than the other,
1257 they fail to match, unless STRICT is <= 0. */
1258 if (t1
== 0 || t2
== 0)
1263 return 1 + warn_contravariance
;
1264 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
1266 p1
= TREE_VALUE (t1
);
1267 p2
= TREE_VALUE (t2
);
1268 if (same_type_p (p1
, p2
))
1274 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
1275 || (TREE_CODE (p1
) == REFERENCE_TYPE
1276 && TREE_CODE (p2
) == REFERENCE_TYPE
))
1279 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
1280 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1283 /* The following is wrong for contravariance,
1284 but many programs depend on it. */
1285 if (TREE_TYPE (p1
) == void_type_node
)
1287 if (TREE_TYPE (p2
) == void_type_node
)
1289 warn_contravariance
= 1;
1292 if (IS_AGGR_TYPE (TREE_TYPE (p1
))
1293 && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (p1
)),
1294 TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1297 /* Note backwards order due to contravariance. */
1298 if (comp_target_types (p2
, p1
, 1) <= 0)
1300 if (comp_target_types (p1
, p2
, 1) > 0)
1302 warn_contravariance
= 1;
1309 return warn_contravariance
? -1 : 1;
1312 /* Return 1 if PARMS specifies a fixed number of parameters
1313 and none of their types is affected by default promotions. */
1316 self_promoting_args_p (parms
)
1320 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1322 register tree type
= TREE_VALUE (t
);
1324 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1330 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1333 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1339 /* Return an unsigned type the same as TYPE in other respects.
1341 C++: must make these work for type variants as well. */
1344 unsigned_type (type
)
1347 tree type1
= TYPE_MAIN_VARIANT (type
);
1348 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1349 return unsigned_char_type_node
;
1350 if (type1
== integer_type_node
)
1351 return unsigned_type_node
;
1352 if (type1
== short_integer_type_node
)
1353 return short_unsigned_type_node
;
1354 if (type1
== long_integer_type_node
)
1355 return long_unsigned_type_node
;
1356 if (type1
== long_long_integer_type_node
)
1357 return long_long_unsigned_type_node
;
1358 #if HOST_BITS_PER_WIDE_INT >= 64
1359 if (type1
== intTI_type_node
)
1360 return unsigned_intTI_type_node
;
1362 if (type1
== intDI_type_node
)
1363 return unsigned_intDI_type_node
;
1364 if (type1
== intSI_type_node
)
1365 return unsigned_intSI_type_node
;
1366 if (type1
== intHI_type_node
)
1367 return unsigned_intHI_type_node
;
1368 if (type1
== intQI_type_node
)
1369 return unsigned_intQI_type_node
;
1371 return signed_or_unsigned_type (1, type
);
1374 /* Return a signed type the same as TYPE in other respects. */
1380 tree type1
= TYPE_MAIN_VARIANT (type
);
1381 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1382 return signed_char_type_node
;
1383 if (type1
== unsigned_type_node
)
1384 return integer_type_node
;
1385 if (type1
== short_unsigned_type_node
)
1386 return short_integer_type_node
;
1387 if (type1
== long_unsigned_type_node
)
1388 return long_integer_type_node
;
1389 if (type1
== long_long_unsigned_type_node
)
1390 return long_long_integer_type_node
;
1391 #if HOST_BITS_PER_WIDE_INT >= 64
1392 if (type1
== unsigned_intTI_type_node
)
1393 return intTI_type_node
;
1395 if (type1
== unsigned_intDI_type_node
)
1396 return intDI_type_node
;
1397 if (type1
== unsigned_intSI_type_node
)
1398 return intSI_type_node
;
1399 if (type1
== unsigned_intHI_type_node
)
1400 return intHI_type_node
;
1401 if (type1
== unsigned_intQI_type_node
)
1402 return intQI_type_node
;
1404 return signed_or_unsigned_type (0, type
);
1407 /* Return a type the same as TYPE except unsigned or
1408 signed according to UNSIGNEDP. */
1411 signed_or_unsigned_type (unsignedp
, type
)
1415 if (! INTEGRAL_TYPE_P (type
)
1416 || TREE_UNSIGNED (type
) == unsignedp
)
1419 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1420 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1421 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1422 return unsignedp
? unsigned_type_node
: integer_type_node
;
1423 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1424 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1425 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1426 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1427 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1428 return (unsignedp
? long_long_unsigned_type_node
1429 : long_long_integer_type_node
);
1433 /* Compute the value of the `sizeof' operator. */
1439 enum tree_code code
= TREE_CODE (type
);
1442 if (processing_template_decl
)
1443 return build_min (SIZEOF_EXPR
, sizetype
, type
);
1445 if (code
== FUNCTION_TYPE
)
1447 if (pedantic
|| warn_pointer_arith
)
1448 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1449 return size_int (1);
1451 if (code
== METHOD_TYPE
)
1453 if (pedantic
|| warn_pointer_arith
)
1454 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1455 return size_int (1);
1457 if (code
== VOID_TYPE
)
1459 if (pedantic
|| warn_pointer_arith
)
1460 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1461 return size_int (1);
1463 if (code
== ERROR_MARK
)
1464 return size_int (1);
1466 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1467 referenced object.'' */
1468 if (code
== REFERENCE_TYPE
)
1469 type
= TREE_TYPE (type
);
1471 /* We couldn't find anything in the ARM or the draft standard that says,
1472 one way or the other, if doing sizeof on something that doesn't have
1473 an object associated with it is correct or incorrect. For example, if
1474 you declare `struct S { char str[16]; };', and in your program do
1475 a `sizeof (S::str)', should we flag that as an error or should we give
1476 the size of it? Since it seems like a reasonable thing to do, we'll go
1477 with giving the value. */
1478 if (code
== OFFSET_TYPE
)
1479 type
= TREE_TYPE (type
);
1481 /* @@ This also produces an error for a signature ref.
1482 In that case we should be able to do better. */
1483 if (IS_SIGNATURE (type
))
1485 error ("`sizeof' applied to a signature type");
1486 return size_int (0);
1489 if (TYPE_SIZE (complete_type (type
)) == 0)
1491 cp_error ("`sizeof' applied to incomplete type `%T'", type
);
1492 return size_int (0);
1495 /* Convert in case a char is more than one unit. */
1496 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1497 size_int (TYPE_PRECISION (char_type_node
)));
1498 t
= convert (sizetype
, t
);
1499 /* size_binop does not put the constant in range, so do it now. */
1500 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1501 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1509 if (processing_template_decl
)
1510 return build_min (SIZEOF_EXPR
, sizetype
, e
);
1512 if (TREE_CODE (e
) == COMPONENT_REF
1513 && DECL_C_BIT_FIELD (TREE_OPERAND (e
, 1)))
1514 error ("sizeof applied to a bit-field");
1515 /* ANSI says arrays and functions are converted inside comma.
1516 But we can't really convert them in build_compound_expr
1517 because that would break commas in lvalues.
1518 So do the conversion here if operand was a comma. */
1519 if (TREE_CODE (e
) == COMPOUND_EXPR
1520 && (TREE_CODE (TREE_TYPE (e
)) == ARRAY_TYPE
1521 || TREE_CODE (TREE_TYPE (e
)) == FUNCTION_TYPE
))
1522 e
= default_conversion (e
);
1523 else if (is_overloaded_fn (e
))
1525 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1526 return size_int (1);
1529 return c_sizeof (TREE_TYPE (e
));
1533 c_sizeof_nowarn (type
)
1536 enum tree_code code
= TREE_CODE (type
);
1539 if (code
== FUNCTION_TYPE
1540 || code
== METHOD_TYPE
1541 || code
== VOID_TYPE
1542 || code
== ERROR_MARK
)
1543 return size_int (1);
1544 if (code
== REFERENCE_TYPE
)
1545 type
= TREE_TYPE (type
);
1547 if (TYPE_SIZE (type
) == 0)
1548 return size_int (0);
1550 /* Convert in case a char is more than one unit. */
1551 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1552 size_int (TYPE_PRECISION (char_type_node
)));
1553 t
= convert (sizetype
, t
);
1554 force_fit_type (t
, 0);
1558 /* Implement the __alignof keyword: Return the minimum required
1559 alignment of TYPE, measured in bytes. */
1565 enum tree_code code
= TREE_CODE (type
);
1568 if (processing_template_decl
)
1569 return build_min (ALIGNOF_EXPR
, sizetype
, type
);
1571 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1572 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1574 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1575 return size_int (1);
1577 /* C++: this is really correct! */
1578 if (code
== REFERENCE_TYPE
)
1579 type
= TREE_TYPE (type
);
1581 /* @@ This also produces an error for a signature ref.
1582 In that case we should be able to do better. */
1583 if (IS_SIGNATURE (type
))
1585 error ("`__alignof' applied to a signature type");
1586 return size_int (1);
1589 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1590 force_fit_type (t
, 0);
1594 /* Perform default promotions for C data used in expressions.
1595 Arrays and functions are converted to pointers;
1596 enumeral types or short or char, to int.
1597 In addition, manifest constants symbols are replaced by their values.
1599 C++: this will automatically bash references to their target type. */
1602 decay_conversion (exp
)
1605 register tree type
= TREE_TYPE (exp
);
1606 register enum tree_code code
= TREE_CODE (type
);
1608 if (code
== OFFSET_TYPE
)
1610 if (TREE_CODE (exp
) == OFFSET_REF
)
1611 return decay_conversion (resolve_offset_ref (exp
));
1613 type
= TREE_TYPE (type
);
1614 code
= TREE_CODE (type
);
1616 if (type
== unknown_type_node
)
1618 cp_pedwarn ("assuming & on overloaded member function");
1619 return build_unary_op (ADDR_EXPR
, exp
, 0);
1623 if (code
== REFERENCE_TYPE
)
1625 exp
= convert_from_reference (exp
);
1626 type
= TREE_TYPE (exp
);
1627 code
= TREE_CODE (type
);
1630 /* Constants can be used directly unless they're not loadable. */
1631 if (TREE_CODE (exp
) == CONST_DECL
)
1632 exp
= DECL_INITIAL (exp
);
1633 /* Replace a nonvolatile const static variable with its value. */
1634 else if (TREE_READONLY_DECL_P (exp
))
1636 exp
= decl_constant_value (exp
);
1637 type
= TREE_TYPE (exp
);
1640 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1641 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1643 if (code
== VOID_TYPE
)
1645 error ("void value not ignored as it ought to be");
1646 return error_mark_node
;
1648 if (code
== METHOD_TYPE
)
1650 cp_pedwarn ("assuming & on `%E'", exp
);
1651 return build_unary_op (ADDR_EXPR
, exp
, 0);
1653 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
1655 return build_unary_op (ADDR_EXPR
, exp
, 0);
1657 if (code
== ARRAY_TYPE
)
1662 if (TREE_CODE (exp
) == INDIRECT_REF
)
1664 /* Stripping away the INDIRECT_REF is not the right
1665 thing to do for references... */
1666 tree inner
= TREE_OPERAND (exp
, 0);
1667 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1669 inner
= build1 (CONVERT_EXPR
,
1670 build_pointer_type (TREE_TYPE
1671 (TREE_TYPE (inner
))),
1673 TREE_CONSTANT (inner
) = TREE_CONSTANT (TREE_OPERAND (inner
, 0));
1675 return cp_convert (build_pointer_type (TREE_TYPE (type
)), inner
);
1678 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1680 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1));
1681 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1682 TREE_OPERAND (exp
, 0), op1
);
1686 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1688 error ("invalid use of non-lvalue array");
1689 return error_mark_node
;
1692 ptrtype
= build_pointer_type (TREE_TYPE (type
));
1694 if (TREE_CODE (exp
) == VAR_DECL
)
1696 /* ??? This is not really quite correct
1697 in that the type of the operand of ADDR_EXPR
1698 is not the target type of the type of the ADDR_EXPR itself.
1699 Question is, can this lossage be avoided? */
1700 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1701 if (mark_addressable (exp
) == 0)
1702 return error_mark_node
;
1703 TREE_CONSTANT (adr
) = staticp (exp
);
1704 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1707 /* This way is better for a COMPONENT_REF since it can
1708 simplify the offset for a component. */
1709 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1710 return cp_convert (ptrtype
, adr
);
1717 default_conversion (exp
)
1721 enum tree_code code
;
1723 exp
= decay_conversion (exp
);
1725 type
= TREE_TYPE (exp
);
1726 code
= TREE_CODE (type
);
1728 if (INTEGRAL_CODE_P (code
))
1730 tree t
= type_promotes_to (type
);
1732 return cp_convert (t
, exp
);
1738 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1742 inline_conversion (exp
)
1745 if (TREE_CODE (exp
) == FUNCTION_DECL
)
1746 exp
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (exp
)), exp
);
1751 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1752 decay_conversion to one. */
1755 string_conv_p (totype
, exp
, warn
)
1761 if (! flag_const_strings
|| TREE_CODE (totype
) != POINTER_TYPE
)
1764 t
= TREE_TYPE (totype
);
1765 if (!same_type_p (t
, char_type_node
)
1766 && !same_type_p (t
, wchar_type_node
))
1769 if (TREE_CODE (exp
) == STRING_CST
)
1771 /* Make sure that we don't try to convert between char and wchar_t. */
1772 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))) != t
)
1777 /* Is this a string constant which has decayed to 'const char *'? */
1778 t
= build_pointer_type (build_qualified_type (t
, TYPE_QUAL_CONST
));
1779 if (!same_type_p (TREE_TYPE (exp
), t
))
1782 if (TREE_CODE (exp
) != ADDR_EXPR
1783 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
1787 /* This warning is not very useful, as it complains about printf. */
1788 if (warn
&& warn_write_strings
)
1789 cp_warning ("deprecated conversion from string constant to `%T'", totype
);
1795 build_object_ref (datum
, basetype
, field
)
1796 tree datum
, basetype
, field
;
1799 if (datum
== error_mark_node
)
1800 return error_mark_node
;
1802 dtype
= TREE_TYPE (datum
);
1803 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1804 dtype
= TREE_TYPE (dtype
);
1805 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1807 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1808 basetype
, field
, dtype
);
1809 return error_mark_node
;
1811 else if (IS_SIGNATURE (basetype
))
1813 warning ("signature name in scope resolution ignored");
1814 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1816 else if (is_aggr_type (basetype
, 1))
1818 tree binfo
= binfo_or_else (basetype
, dtype
);
1820 return build_x_component_ref (build_scoped_ref (datum
, basetype
),
1823 return error_mark_node
;
1826 /* Like `build_component_ref, but uses an already found field, and converts
1827 from a reference. Must compute access for current_class_ref.
1831 build_component_ref_1 (datum
, field
, protect
)
1835 return convert_from_reference
1836 (build_component_ref (datum
, field
, NULL_TREE
, protect
));
1839 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1840 can, for example, use as an lvalue. This code used to be in
1841 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1842 expressions, where we're dealing with aggregates. But now it's again only
1843 called from unary_complex_lvalue. The case (in particular) that led to
1844 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1848 rationalize_conditional_expr (code
, t
)
1849 enum tree_code code
;
1852 /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1853 the first operand is always the one to be used if both operands
1854 are equal, so we know what conditional expression this used to be. */
1855 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
1858 build_conditional_expr (build_x_binary_op ((TREE_CODE (t
) == MIN_EXPR
1859 ? LE_EXPR
: GE_EXPR
),
1860 TREE_OPERAND (t
, 0),
1861 TREE_OPERAND (t
, 1)),
1862 build_unary_op (code
, TREE_OPERAND (t
, 0), 0),
1863 build_unary_op (code
, TREE_OPERAND (t
, 1), 0));
1867 build_conditional_expr (TREE_OPERAND (t
, 0),
1868 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1869 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1872 /* Given the TYPE of an anonymous union field inside T, return the
1873 FIELD_DECL for the field. If not found return NULL_TREE. Because
1874 anonymous unions can nest, we must also search all anonymous unions
1875 that are directly reachable. */
1878 lookup_anon_field (t
, type
)
1883 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1885 if (TREE_STATIC (field
))
1887 if (TREE_CODE (field
) != FIELD_DECL
)
1890 /* If we find it directly, return the field. */
1891 if (DECL_NAME (field
) == NULL_TREE
1892 && type
== TREE_TYPE (field
))
1897 /* Otherwise, it could be nested, search harder. */
1898 if (DECL_NAME (field
) == NULL_TREE
1899 && TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1901 tree subfield
= lookup_anon_field (TREE_TYPE (field
), type
);
1909 /* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT.
1910 COMPONENT can be an IDENTIFIER_NODE that is the name of the member
1911 that we are interested in, or it can be a FIELD_DECL. */
1914 build_component_ref (datum
, component
, basetype_path
, protect
)
1915 tree datum
, component
, basetype_path
;
1918 register tree basetype
;
1919 register enum tree_code code
;
1920 register tree field
= NULL
;
1925 if (processing_template_decl
)
1926 return build_min_nt (COMPONENT_REF
, datum
, component
);
1928 if (datum
== error_mark_node
1929 || TREE_TYPE (datum
) == error_mark_node
)
1930 return error_mark_node
;
1932 /* BASETYPE holds the type of the class containing the COMPONENT. */
1933 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1935 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
1937 switch (TREE_CODE (datum
))
1941 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1942 basetype_path
, protect
);
1943 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1944 TREE_OPERAND (datum
, 0), value
);
1947 return build_conditional_expr
1948 (TREE_OPERAND (datum
, 0),
1949 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1950 basetype_path
, protect
),
1951 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1952 basetype_path
, protect
));
1955 cp_error ("invalid use of %D", datum
);
1956 datum
= error_mark_node
;
1963 code
= TREE_CODE (basetype
);
1965 if (code
== REFERENCE_TYPE
)
1967 datum
= convert_from_reference (datum
);
1968 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1969 code
= TREE_CODE (basetype
);
1971 if (TREE_CODE (datum
) == OFFSET_REF
)
1973 datum
= resolve_offset_ref (datum
);
1974 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1975 code
= TREE_CODE (basetype
);
1978 /* First, see if there is a field or component with name COMPONENT. */
1979 if (TREE_CODE (component
) == TREE_LIST
)
1981 /* I could not trigger this code. MvL */
1982 my_friendly_abort (980326);
1984 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1985 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1987 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1990 if (! IS_AGGR_TYPE_CODE (code
))
1992 if (code
!= ERROR_MARK
)
1993 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1994 component
, datum
, basetype
);
1995 return error_mark_node
;
1998 if (!complete_type_or_else (basetype
))
1999 return error_mark_node
;
2001 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
2003 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
2005 cp_error ("destructor specifier `%T::~%T' must have matching names",
2006 basetype
, TREE_OPERAND (component
, 0));
2007 return error_mark_node
;
2009 if (! TYPE_HAS_DESTRUCTOR (basetype
))
2011 cp_error ("type `%T' has no destructor", basetype
);
2012 return error_mark_node
;
2014 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1);
2017 /* Look up component name in the structure type definition. */
2018 if (CLASSTYPE_VFIELD (basetype
)
2019 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
2020 /* Special-case this because if we use normal lookups in an ambiguous
2021 hierarchy, the compiler will abort (because vptr lookups are
2022 not supposed to be ambiguous. */
2023 field
= CLASSTYPE_VFIELD (basetype
);
2024 else if (TREE_CODE (component
) == FIELD_DECL
)
2026 else if (TREE_CODE (component
) == TYPE_DECL
)
2028 cp_error ("invalid use of type decl `%#D' as expression", component
);
2029 return error_mark_node
;
2033 tree name
= component
;
2034 if (TREE_CODE (component
) == VAR_DECL
)
2035 name
= DECL_NAME (component
);
2036 if (basetype_path
== NULL_TREE
)
2037 basetype_path
= TYPE_BINFO (basetype
);
2038 field
= lookup_field (basetype_path
, name
,
2039 protect
&& !VFIELD_NAME_P (name
), 0);
2040 if (field
== error_mark_node
)
2041 return error_mark_node
;
2043 if (field
== NULL_TREE
)
2045 /* Not found as a data field, look for it as a method. If found,
2046 then if this is the only possible one, return it, else
2047 report ambiguity error. */
2048 tree fndecls
= lookup_fnfields (basetype_path
, name
, 1);
2049 if (fndecls
== error_mark_node
)
2050 return error_mark_node
;
2053 /* If the function is unique and static, we can resolve it
2054 now. Otherwise, we have to wait and see what context it is
2055 used in; a component_ref involving a non-static member
2056 function can only be used in a call (expr.ref). */
2057 if (TREE_CHAIN (fndecls
) == NULL_TREE
2058 && TREE_CODE (TREE_VALUE (fndecls
)) == FUNCTION_DECL
2059 && DECL_STATIC_FUNCTION_P (TREE_VALUE (fndecls
)))
2063 basetype
= TYPE_MAIN_VARIANT (TREE_PURPOSE (fndecls
));
2064 fndecl
= TREE_VALUE (fndecls
);
2065 enforce_access (TREE_PURPOSE (fndecls
), fndecl
);
2071 ref
= build (COMPONENT_REF
, unknown_type_node
,
2077 cp_error ("`%#T' has no member named `%D'", basetype
, name
);
2078 return error_mark_node
;
2080 else if (TREE_TYPE (field
) == error_mark_node
)
2081 return error_mark_node
;
2083 if (TREE_CODE (field
) != FIELD_DECL
)
2085 if (TREE_CODE (field
) == TYPE_DECL
)
2086 cp_pedwarn ("invalid use of type decl `%#D' as expression", field
);
2087 else if (DECL_RTL (field
) != 0)
2090 TREE_USED (field
) = 1;
2095 /* See if we have to do any conversions so that we pick up the field from the
2097 if (DECL_FIELD_CONTEXT (field
) != basetype
)
2099 tree context
= DECL_FIELD_CONTEXT (field
);
2100 tree base
= context
;
2101 while (!same_type_p (base
, basetype
) && TYPE_NAME (base
)
2102 && ANON_UNION_TYPE_P (base
))
2104 base
= TYPE_CONTEXT (base
);
2107 /* Handle base classes here... */
2108 if (base
!= basetype
&& TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2110 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
2111 if (integer_zerop (addr
))
2113 error ("invalid reference to NULL ptr, use ptr-to-member instead");
2114 return error_mark_node
;
2116 if (VBASE_NAME_P (DECL_NAME (field
)))
2118 /* It doesn't matter which vbase pointer we grab, just
2119 find one of them. */
2120 tree binfo
= get_binfo (base
,
2121 TREE_TYPE (TREE_TYPE (addr
)), 0);
2122 addr
= convert_pointer_to_real (binfo
, addr
);
2125 addr
= convert_pointer_to (base
, addr
);
2126 datum
= build_indirect_ref (addr
, NULL_PTR
);
2127 my_friendly_assert (datum
!= error_mark_node
, 311);
2131 /* Handle things from anon unions here... */
2132 if (TYPE_NAME (context
) && ANON_UNION_TYPE_P (context
))
2134 tree subfield
= lookup_anon_field (basetype
, context
);
2135 tree subdatum
= build_component_ref (datum
, subfield
,
2136 basetype_path
, protect
);
2137 return build_component_ref (subdatum
, field
, basetype_path
, protect
);
2141 /* Compute the type of the field, as described in [expr.ref]. */
2142 type_quals
= TYPE_UNQUALIFIED
;
2143 field_type
= TREE_TYPE (field
);
2144 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
2145 /* The standard says that the type of the result should be the
2146 type referred to by the reference. But for now, at least, we
2147 do the conversion from reference type later. */
2151 type_quals
= (CP_TYPE_QUALS (field_type
)
2152 | CP_TYPE_QUALS (TREE_TYPE (datum
)));
2154 /* A field is const (volatile) if the enclosing object, or the
2155 field itself, is const (volatile). But, a mutable field is
2156 not const, even within a const object. */
2157 if (DECL_LANG_SPECIFIC (field
) && DECL_MUTABLE_P (field
))
2158 type_quals
&= ~TYPE_QUAL_CONST
;
2159 if (!IS_SIGNATURE (field_type
))
2160 field_type
= cp_build_qualified_type (field_type
, type_quals
);
2163 ref
= fold (build (COMPONENT_REF
, field_type
,
2164 break_out_cleanups (datum
), field
));
2166 /* Mark the expression const or volatile, as appropriate. Even
2167 though we've dealt with the type above, we still have to mark the
2168 expression itself. */
2169 if (type_quals
& TYPE_QUAL_CONST
)
2170 TREE_READONLY (ref
) = 1;
2171 else if (type_quals
& TYPE_QUAL_VOLATILE
)
2172 TREE_THIS_VOLATILE (ref
) = 1;
2177 /* Variant of build_component_ref for use in expressions, which should
2178 never have REFERENCE_TYPE. */
2181 build_x_component_ref (datum
, component
, basetype_path
, protect
)
2182 tree datum
, component
, basetype_path
;
2185 tree t
= build_component_ref (datum
, component
, basetype_path
, protect
);
2187 if (! processing_template_decl
)
2188 t
= convert_from_reference (t
);
2193 /* Given an expression PTR for a pointer, return an expression
2194 for the value pointed to.
2195 ERRORSTRING is the name of the operator to appear in error messages.
2197 This function may need to overload OPERATOR_FNNAME.
2198 Must also handle REFERENCE_TYPEs for C++. */
2201 build_x_indirect_ref (ptr
, errorstring
)
2207 if (processing_template_decl
)
2208 return build_min_nt (INDIRECT_REF
, ptr
);
2210 rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
,
2214 return build_indirect_ref (ptr
, errorstring
);
2218 build_indirect_ref (ptr
, errorstring
)
2222 register tree pointer
, type
;
2224 if (ptr
== error_mark_node
)
2225 return error_mark_node
;
2227 pointer
= (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
2228 ? ptr
: default_conversion (ptr
));
2229 type
= TREE_TYPE (pointer
);
2231 if (ptr
== current_class_ptr
)
2232 return current_class_ref
;
2234 if (TYPE_PTR_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
2238 If the type of the expression is "pointer to T," the type
2239 of the result is "T."
2241 We must use the canonical variant because certain parts of
2242 the back end, like fold, do pointer comparisons between
2244 tree t
= canonical_type_variant (TREE_TYPE (type
));
2246 if (TREE_CODE (pointer
) == ADDR_EXPR
2248 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
2249 /* The POINTER was something like `&x'. We simplify `*&x' to
2251 return TREE_OPERAND (pointer
, 0);
2254 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
2256 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2257 so that we get the proper error message if the result is used
2258 to assign to. Also, &* is supposed to be a no-op. */
2259 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
2260 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
2261 TREE_SIDE_EFFECTS (ref
)
2262 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
)
2267 /* `pointer' won't be an error_mark_node if we were given a
2268 pointer to member, so it's cool to check for this here. */
2269 else if (TYPE_PTRMEM_P (type
) || TYPE_PTRMEMFUNC_P (type
))
2270 error ("invalid use of `%s' on pointer to member", errorstring
);
2271 else if (TREE_CODE (type
) == RECORD_TYPE
2272 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
2273 error ("cannot dereference signature pointer/reference");
2274 else if (pointer
!= error_mark_node
)
2277 error ("invalid type argument of `%s'", errorstring
);
2279 error ("invalid type argument");
2281 return error_mark_node
;
2284 /* This handles expressions of the form "a[i]", which denotes
2287 This is logically equivalent in C to *(a+i), but we may do it differently.
2288 If A is a variable or a member, we generate a primitive ARRAY_REF.
2289 This avoids forcing the array out of registers, and can work on
2290 arrays that are not lvalues (for example, members of structures returned
2293 If INDEX is of some user-defined type, it must be converted to
2294 integer type. Otherwise, to make a compatible PLUS_EXPR, it
2295 will inherit the type of the array, which will be some pointer type. */
2298 build_array_ref (array
, idx
)
2303 error ("subscript missing in array reference");
2304 return error_mark_node
;
2307 if (TREE_TYPE (array
) == error_mark_node
2308 || TREE_TYPE (idx
) == error_mark_node
)
2309 return error_mark_node
;
2311 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
2312 && TREE_CODE (array
) != INDIRECT_REF
)
2316 /* Subscripting with type char is likely to lose
2317 on a machine where chars are signed.
2318 So warn on any machine, but optionally.
2319 Don't warn for unsigned char since that type is safe.
2320 Don't warn for signed char because anyone who uses that
2321 must have done so deliberately. */
2322 if (warn_char_subscripts
2323 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
2324 warning ("array subscript has type `char'");
2326 /* Apply default promotions *after* noticing character types. */
2327 idx
= default_conversion (idx
);
2329 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
2331 error ("array subscript is not an integer");
2332 return error_mark_node
;
2335 /* An array that is indexed by a non-constant
2336 cannot be stored in a register; we must be able to do
2337 address arithmetic on its address.
2338 Likewise an array of elements of variable size. */
2339 if (TREE_CODE (idx
) != INTEGER_CST
2340 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
2341 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
2344 if (mark_addressable (array
) == 0)
2345 return error_mark_node
;
2347 /* An array that is indexed by a constant value which is not within
2348 the array bounds cannot be stored in a register either; because we
2349 would get a crash in store_bit_field/extract_bit_field when trying
2350 to access a non-existent part of the register. */
2351 if (TREE_CODE (idx
) == INTEGER_CST
2352 && TYPE_VALUES (TREE_TYPE (array
))
2353 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
2355 if (mark_addressable (array
) == 0)
2356 return error_mark_node
;
2359 if (pedantic
&& !lvalue_p (array
))
2360 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
2362 /* Note in C++ it is valid to subscript a `register' array, since
2363 it is valid to take the address of something with that
2364 storage specification. */
2368 while (TREE_CODE (foo
) == COMPONENT_REF
)
2369 foo
= TREE_OPERAND (foo
, 0);
2370 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
2371 warning ("subscripting array declared `register'");
2374 type
= TREE_TYPE (TREE_TYPE (array
));
2375 rval
= build (ARRAY_REF
, type
, array
, idx
);
2376 /* Array ref is const/volatile if the array elements are
2377 or if the array is.. */
2378 TREE_READONLY (rval
)
2379 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
2380 TREE_SIDE_EFFECTS (rval
)
2381 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
2382 TREE_THIS_VOLATILE (rval
)
2383 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
2384 return require_complete_type (fold (rval
));
2388 tree ar
= default_conversion (array
);
2389 tree ind
= default_conversion (idx
);
2391 /* Put the integer in IND to simplify error checking. */
2392 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2399 if (ar
== error_mark_node
)
2402 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2404 error ("subscripted value is neither array nor pointer");
2405 return error_mark_node
;
2407 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2409 error ("array subscript is not an integer");
2410 return error_mark_node
;
2413 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
,
2419 /* Build a function call to function FUNCTION with parameters PARAMS.
2420 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2421 TREE_VALUE of each node is a parameter-expression. The PARAMS do
2422 not include any object pointer that may be required. FUNCTION's
2423 data type may be a function type or a pointer-to-function.
2425 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2426 is the list of possible methods that FUNCTION could conceivably
2427 be. If the list of methods comes from a class, then it will be
2428 a list of lists (where each element is associated with the class
2429 that produced it), otherwise it will be a simple list (for
2430 functions overloaded in global scope).
2432 In the first case, TREE_VALUE (function) is the head of one of those
2433 lists, and TREE_PURPOSE is the name of the function.
2435 In the second case, TREE_PURPOSE (function) is the function's
2438 DECL is the class instance variable, usually CURRENT_CLASS_REF.
2440 When calling a TEMPLATE_DECL, we don't require a complete return
2444 build_x_function_call (function
, params
, decl
)
2445 tree function
, params
, decl
;
2448 tree template_id
= NULL_TREE
;
2451 if (function
== error_mark_node
)
2452 return error_mark_node
;
2454 if (processing_template_decl
)
2455 return build_min_nt (CALL_EXPR
, function
, params
, NULL_TREE
);
2457 /* Save explicit template arguments if found */
2458 if (TREE_CODE (function
) == TEMPLATE_ID_EXPR
)
2460 template_id
= function
;
2461 function
= TREE_OPERAND (function
, 0);
2464 type
= TREE_TYPE (function
);
2466 if (TREE_CODE (type
) == OFFSET_TYPE
2467 && TREE_TYPE (type
) == unknown_type_node
2468 && TREE_CODE (function
) == TREE_LIST
2469 && TREE_CHAIN (function
) == NULL_TREE
)
2471 /* Undo (Foo:bar)()... */
2472 type
= TYPE_OFFSET_BASETYPE (type
);
2473 function
= TREE_VALUE (function
);
2474 my_friendly_assert (TREE_CODE (function
) == TREE_LIST
, 999);
2475 my_friendly_assert (TREE_CHAIN (function
) == NULL_TREE
, 999);
2476 function
= TREE_VALUE (function
);
2477 if (TREE_CODE (function
) == OVERLOAD
)
2478 function
= OVL_FUNCTION (function
);
2479 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 999);
2480 function
= DECL_NAME (function
);
2481 return build_method_call (decl
, function
, params
,
2482 TYPE_BINFO (type
), LOOKUP_NORMAL
);
2485 is_method
= ((TREE_CODE (function
) == TREE_LIST
2486 && current_class_type
!= NULL_TREE
2487 && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
))
2489 || TREE_CODE (function
) == IDENTIFIER_NODE
2490 || TREE_CODE (type
) == METHOD_TYPE
2491 || TYPE_PTRMEMFUNC_P (type
));
2493 if ((TREE_CODE (function
) == FUNCTION_DECL
2494 && DECL_STATIC_FUNCTION_P (function
))
2495 || (TREE_CODE (function
) == TEMPLATE_DECL
2496 && DECL_STATIC_FUNCTION_P (DECL_RESULT (function
))))
2497 return build_member_call
2498 (DECL_CONTEXT (function
), DECL_NAME (function
), params
);
2500 /* A friend template. Make it look like a toplevel declaration. */
2501 if (! is_method
&& TREE_CODE (function
) == TEMPLATE_DECL
)
2502 function
= scratch_ovl_cons (function
, NULL_TREE
);
2504 /* Handle methods, friends, and overloaded functions, respectively. */
2507 tree basetype
= NULL_TREE
;
2509 if (TREE_CODE (function
) == FUNCTION_DECL
2510 || DECL_FUNCTION_TEMPLATE_P (function
))
2512 basetype
= DECL_CLASS_CONTEXT (function
);
2514 if (DECL_NAME (function
))
2515 function
= DECL_NAME (function
);
2517 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2519 else if (TREE_CODE (function
) == TREE_LIST
)
2521 my_friendly_assert (TREE_CODE (TREE_VALUE (function
))
2522 == FUNCTION_DECL
, 312);
2523 basetype
= DECL_CLASS_CONTEXT (TREE_VALUE (function
));
2524 function
= TREE_PURPOSE (function
);
2526 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2528 if (TREE_CODE (function
) == OFFSET_REF
)
2530 if (TREE_OPERAND (function
, 0))
2531 decl
= TREE_OPERAND (function
, 0);
2533 /* Call via a pointer to member function. */
2534 if (decl
== NULL_TREE
)
2536 error ("pointer to member function called, but not in class scope");
2537 return error_mark_node
;
2539 /* What other type of POINTER_TYPE could this be? */
2540 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2541 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2542 && TREE_CODE (function
) != OFFSET_REF
)
2543 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
,
2548 /* this is an abbreviated method call.
2549 must go through here in case it is a virtual function.
2550 @@ Perhaps this could be optimized. */
2552 if (basetype
&& (! current_class_type
2553 || ! DERIVED_FROM_P (basetype
, current_class_type
)))
2554 return build_member_call (basetype
, function
, params
);
2556 if (decl
== NULL_TREE
)
2558 if (current_class_type
== NULL_TREE
)
2560 error ("object missing in call to method `%s'",
2561 IDENTIFIER_POINTER (function
));
2562 return error_mark_node
;
2564 /* Yow: call from a static member function. */
2565 decl
= build_dummy_object (current_class_type
);
2568 /* Put back explicit template arguments, if any. */
2570 function
= template_id
;
2571 return build_method_call (decl
, function
, params
,
2572 NULL_TREE
, LOOKUP_NORMAL
);
2574 else if (TREE_CODE (function
) == COMPONENT_REF
2575 && type
== unknown_type_node
)
2577 /* Undo what we did in build_component_ref. */
2578 decl
= TREE_OPERAND (function
, 0);
2579 function
= TREE_OPERAND (function
, 1);
2580 function
= DECL_NAME (OVL_CURRENT (TREE_VALUE (function
)));
2581 return build_method_call (decl
, function
, params
,
2582 NULL_TREE
, LOOKUP_NORMAL
);
2584 else if (really_overloaded_fn (function
))
2586 if (OVL_FUNCTION (function
) == NULL_TREE
)
2588 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2589 TREE_PURPOSE (function
));
2590 return error_mark_node
;
2594 /* Put back explicit template arguments, if any. */
2596 function
= template_id
;
2597 return build_new_function_call (function
, params
);
2601 /* Remove a potential OVERLOAD around it */
2602 function
= OVL_CURRENT (function
);
2605 if (TREE_CODE (function
) == OFFSET_REF
)
2607 /* If the component is a data element (or a virtual function), we play
2608 games here to make things work. */
2611 if (TREE_OPERAND (function
, 0))
2612 decl
= TREE_OPERAND (function
, 0);
2614 decl
= current_class_ref
;
2616 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2618 /* Sigh. OFFSET_REFs are being used for too many things.
2619 They're being used both for -> and ->*, and we want to resolve
2620 the -> cases here, but leave the ->*. We could use
2621 resolve_offset_ref for those, too, but it would call
2622 get_member_function_from_ptrfunc and decl_addr wouldn't get
2623 updated properly. Nasty. */
2624 if (TREE_CODE (TREE_OPERAND (function
, 1)) == FIELD_DECL
)
2625 function
= resolve_offset_ref (function
);
2627 function
= TREE_OPERAND (function
, 1);
2629 function
= get_member_function_from_ptrfunc (&decl_addr
, function
);
2630 params
= expr_tree_cons (NULL_TREE
, decl_addr
, params
);
2631 return build_function_call (function
, params
);
2634 type
= TREE_TYPE (function
);
2635 if (type
!= error_mark_node
)
2637 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2638 type
= TREE_TYPE (type
);
2640 if (IS_AGGR_TYPE (type
))
2641 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2646 tree fntype
= TREE_TYPE (function
);
2647 tree ctypeptr
= NULL_TREE
;
2649 /* Explicitly named method? */
2650 if (TREE_CODE (function
) == FUNCTION_DECL
)
2651 ctypeptr
= build_pointer_type (DECL_CLASS_CONTEXT (function
));
2652 /* Expression with ptr-to-method type? It could either be a plain
2653 usage, or it might be a case where the ptr-to-method is being
2654 passed in as an argument. */
2655 else if (TYPE_PTRMEMFUNC_P (fntype
))
2657 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE
2658 (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2659 ctypeptr
= build_pointer_type (rec
);
2661 /* Unexpected node type? */
2663 my_friendly_abort (116);
2664 if (decl
== NULL_TREE
)
2666 if (current_function_decl
2667 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2668 error ("invalid call to member function needing `this' in static member function scope");
2670 error ("pointer to member function called, but not in class scope");
2671 return error_mark_node
;
2673 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2674 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2676 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2677 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2680 decl
= build_c_cast (ctypeptr
, decl
);
2681 params
= expr_tree_cons (NULL_TREE
, decl
, params
);
2684 return build_function_call (function
, params
);
2687 /* Resolve a pointer to member function. INSTANCE is the object
2688 instance to use, if the member points to a virtual member. */
2691 get_member_function_from_ptrfunc (instance_ptrptr
, function
)
2692 tree
*instance_ptrptr
;
2695 if (TREE_CODE (function
) == OFFSET_REF
)
2697 function
= TREE_OPERAND (function
, 1);
2700 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2702 tree fntype
, idx
, e1
, delta
, delta2
, e2
, e3
, aref
, vtbl
;
2703 tree instance
, basetype
;
2705 tree instance_ptr
= *instance_ptrptr
;
2707 if (TREE_SIDE_EFFECTS (instance_ptr
))
2708 instance_ptr
= save_expr (instance_ptr
);
2710 if (TREE_SIDE_EFFECTS (function
))
2711 function
= save_expr (function
);
2713 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2714 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
2716 delta
= cp_convert (ptrdiff_type_node
,
2717 build_component_ref (function
, delta_identifier
,
2719 e3
= PFN_FROM_PTRMEMFUNC (function
);
2721 if (TYPE_SIZE (basetype
) != NULL_TREE
2722 && ! TYPE_VIRTUAL_P (basetype
))
2723 /* If basetype doesn't have virtual functions, don't emit code to
2724 handle that case. */
2728 /* Promoting idx before saving it improves performance on RISC
2729 targets. Without promoting, the first compare used
2730 load-with-sign-extend, while the second used normal load then
2731 shift to sign-extend. An optimizer flaw, perhaps, but it's
2732 easier to make this change. */
2733 idx
= save_expr (default_conversion
2734 (build_component_ref (function
,
2737 e1
= build_binary_op (GT_EXPR
, idx
, integer_zero_node
, 1);
2739 /* Convert down to the right base, before using the instance. */
2740 instance
= convert_pointer_to_real (basetype
, instance_ptr
);
2741 if (instance
== error_mark_node
&& instance_ptr
!= error_mark_node
)
2744 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2745 delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2748 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2749 vtbl
, cp_convert (ptrdiff_type_node
, delta2
));
2750 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2751 aref
= build_array_ref (vtbl
, build_binary_op (MINUS_EXPR
,
2753 integer_one_node
, 1));
2754 if (! flag_vtable_thunks
)
2756 aref
= save_expr (aref
);
2758 delta
= build_binary_op
2760 build_conditional_expr (e1
,
2761 build_component_ref (aref
,
2768 if (flag_vtable_thunks
)
2771 e2
= build_component_ref (aref
, pfn_identifier
, NULL_TREE
, 0);
2772 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2773 e1
= build_conditional_expr (e1
, e2
, e3
);
2775 /* Make sure this doesn't get evaluated first inside one of the
2776 branches of the COND_EXPR. */
2777 if (TREE_CODE (instance_ptr
) == SAVE_EXPR
)
2778 e1
= build (COMPOUND_EXPR
, TREE_TYPE (e1
),
2782 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2783 instance_ptr
, delta
);
2785 if (instance_ptr
== error_mark_node
2786 && TREE_CODE (e1
) != ADDR_EXPR
2787 && TREE_CODE (TREE_OPERAND (e1
, 0)) != FUNCTION_DECL
)
2788 cp_error ("object missing in `%E'", function
);
2796 build_function_call_real (function
, params
, require_complete
, flags
)
2797 tree function
, params
;
2798 int require_complete
, flags
;
2800 register tree fntype
, fndecl
;
2801 register tree value_type
;
2802 register tree coerced_params
;
2803 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2806 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2807 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2808 if (TREE_CODE (function
) == NOP_EXPR
2809 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2810 function
= TREE_OPERAND (function
, 0);
2812 if (TREE_CODE (function
) == FUNCTION_DECL
)
2814 name
= DECL_NAME (function
);
2815 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2817 GNU_xref_call (current_function_decl
,
2818 IDENTIFIER_POINTER (name
? name
2819 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
2821 mark_used (function
);
2824 /* Convert anything with function type to a pointer-to-function. */
2825 if (pedantic
&& DECL_MAIN_P (function
))
2826 pedwarn ("ANSI C++ forbids calling `main' from within program");
2828 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2829 (because calling an inline function does not mean the function
2830 needs to be separately compiled). */
2832 if (DECL_INLINE (function
))
2833 function
= inline_conversion (function
);
2835 function
= build_addr_func (function
);
2841 function
= build_addr_func (function
);
2844 if (function
== error_mark_node
)
2845 return error_mark_node
;
2847 fntype
= TREE_TYPE (function
);
2849 if (TYPE_PTRMEMFUNC_P (fntype
))
2851 cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2853 return error_mark_node
;
2856 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2857 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2859 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2860 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2862 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
2864 cp_error ("`%E' cannot be used as a function", function
);
2865 return error_mark_node
;
2868 /* fntype now gets the type of function pointed to. */
2869 fntype
= TREE_TYPE (fntype
);
2871 /* Convert the parameters to the types declared in the
2872 function prototype, or apply default promotions. */
2874 if (flags
& LOOKUP_COMPLAIN
)
2875 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2876 params
, fndecl
, LOOKUP_NORMAL
);
2878 coerced_params
= convert_arguments (TYPE_ARG_TYPES (fntype
),
2881 if (coerced_params
== error_mark_node
)
2883 if (flags
& LOOKUP_SPECULATIVELY
)
2886 return error_mark_node
;
2889 /* Check for errors in format strings. */
2891 if (warn_format
&& (name
|| assembler_name
))
2892 check_function_format (name
, assembler_name
, coerced_params
);
2894 /* Recognize certain built-in functions so we can make tree-codes
2895 other than CALL_EXPR. We do this when it enables fold-const.c
2896 to do something useful. */
2898 if (TREE_CODE (function
) == ADDR_EXPR
2899 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2900 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2901 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2906 if (coerced_params
== 0)
2907 return integer_zero_node
;
2908 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2915 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2917 register tree result
2918 = build_call (function
, value_type
, coerced_params
);
2920 if (require_complete
)
2922 if (value_type
== void_type_node
)
2924 result
= require_complete_type (result
);
2926 if (IS_AGGR_TYPE (value_type
))
2927 result
= build_cplus_new (value_type
, result
);
2928 return convert_from_reference (result
);
2933 build_function_call (function
, params
)
2934 tree function
, params
;
2936 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2939 /* Convert the actual parameter expressions in the list VALUES
2940 to the types in the list TYPELIST.
2941 If parmdecls is exhausted, or when an element has NULL as its type,
2942 perform the default conversions.
2944 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2946 This is also where warnings about wrong number of args are generated.
2948 Return a list of expressions for the parameters as converted.
2950 Both VALUES and the returned value are chains of TREE_LIST nodes
2951 with the elements of the list in the TREE_VALUE slots of those nodes.
2953 In C++, unspecified trailing parameters can be filled in with their
2954 default arguments, if such were specified. Do so here. */
2957 convert_arguments (typelist
, values
, fndecl
, flags
)
2958 tree typelist
, values
, fndecl
;
2961 register tree typetail
, valtail
;
2962 register tree result
= NULL_TREE
;
2963 char *called_thing
= 0;
2966 /* Argument passing is always copy-initialization. */
2967 flags
|= LOOKUP_ONLYCONVERTING
;
2971 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2973 if (DECL_NAME (fndecl
) == NULL_TREE
2974 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2975 called_thing
= "constructor";
2977 called_thing
= "member function";
2980 called_thing
= "function";
2983 for (valtail
= values
, typetail
= typelist
;
2985 valtail
= TREE_CHAIN (valtail
), i
++)
2987 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2988 register tree val
= TREE_VALUE (valtail
);
2990 if (val
== error_mark_node
)
2991 return error_mark_node
;
2993 if (type
== void_type_node
)
2997 cp_error_at ("too many arguments to %s `%+D'", called_thing
,
2999 error ("at this point in file");
3002 error ("too many arguments to function");
3003 /* In case anybody wants to know if this argument
3006 TREE_TYPE (tree_last (result
)) = error_mark_node
;
3010 if (TREE_CODE (val
) == OFFSET_REF
)
3011 val
= resolve_offset_ref (val
);
3013 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3014 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
3015 if (TREE_CODE (val
) == NOP_EXPR
3016 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
3017 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
3018 val
= TREE_OPERAND (val
, 0);
3020 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
3022 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
3023 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
3024 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
3025 val
= default_conversion (val
);
3027 val
= require_complete_type (val
);
3030 if (val
== error_mark_node
)
3031 return error_mark_node
;
3035 /* Formal parm type is specified by a function prototype. */
3038 if (TYPE_SIZE (complete_type (type
)) == 0)
3040 error ("parameter type of called function is incomplete");
3045 parmval
= convert_for_initialization
3046 (NULL_TREE
, type
, val
, flags
,
3047 "argument passing", fndecl
, i
);
3048 #ifdef PROMOTE_PROTOTYPES
3049 if ((TREE_CODE (type
) == INTEGER_TYPE
3050 || TREE_CODE (type
) == ENUMERAL_TYPE
)
3051 && (TYPE_PRECISION (type
)
3052 < TYPE_PRECISION (integer_type_node
)))
3053 parmval
= default_conversion (parmval
);
3057 if (parmval
== error_mark_node
)
3058 return error_mark_node
;
3060 result
= expr_tree_cons (NULL_TREE
, parmval
, result
);
3064 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
3065 val
= convert_from_reference (val
);
3067 result
= expr_tree_cons (NULL_TREE
,
3068 convert_arg_to_ellipsis (val
),
3073 typetail
= TREE_CHAIN (typetail
);
3076 if (typetail
!= 0 && typetail
!= void_list_node
)
3078 /* See if there are default arguments that can be used */
3079 if (TREE_PURPOSE (typetail
))
3081 for (; typetail
!= void_list_node
; ++i
)
3083 tree type
= TREE_VALUE (typetail
);
3084 tree val
= TREE_PURPOSE (typetail
);
3085 tree parmval
= convert_default_arg (type
, val
);
3087 if (parmval
== error_mark_node
)
3088 return error_mark_node
;
3090 result
= expr_tree_cons (0, parmval
, result
);
3091 typetail
= TREE_CHAIN (typetail
);
3092 /* ends with `...'. */
3093 if (typetail
== NULL_TREE
)
3101 char *buf
= (char *)alloca (32 + strlen (called_thing
));
3102 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
3103 cp_error_at (buf
, fndecl
);
3104 error ("at this point in file");
3107 error ("too few arguments to function");
3108 return error_mark_list
;
3112 return nreverse (result
);
3115 /* Build a binary-operation expression, after performing default
3116 conversions on the operands. CODE is the kind of expression to build. */
3119 build_x_binary_op (code
, arg1
, arg2
)
3120 enum tree_code code
;
3123 if (processing_template_decl
)
3124 return build_min_nt (code
, arg1
, arg2
);
3126 return build_new_op (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
3130 build_binary_op (code
, arg1
, arg2
, convert_p
)
3131 enum tree_code code
;
3135 return build_binary_op_nodefault (code
, arg1
, arg2
, code
);
3138 /* Build a binary-operation expression without default conversions.
3139 CODE is the kind of expression to build.
3140 This function differs from `build' in several ways:
3141 the data type of the result is computed and recorded in it,
3142 warnings are generated if arg data types are invalid,
3143 special handling for addition and subtraction of pointers is known,
3144 and some optimization is done (operations on narrow ints
3145 are done in the narrower type when that gives the same result).
3146 Constant folding is also done before the result is returned.
3148 ERROR_CODE is the code that determines what to say in error messages.
3149 It is usually, but not always, the same as CODE.
3151 Note that the operands will never have enumeral types
3152 because either they have just had the default conversions performed
3153 or they have both just been converted to some other type in which
3154 the arithmetic is to be done.
3156 C++: must do special pointer arithmetic when implementing
3157 multiple inheritance, and deal with pointer to member functions. */
3160 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
3161 enum tree_code code
;
3162 tree orig_op0
, orig_op1
;
3163 enum tree_code error_code
;
3166 register enum tree_code code0
, code1
;
3169 /* Expression code to give to the expression when it is built.
3170 Normally this is CODE, which is what the caller asked for,
3171 but in some special cases we change it. */
3172 register enum tree_code resultcode
= code
;
3174 /* Data type in which the computation is to be performed.
3175 In the simplest cases this is the common type of the arguments. */
3176 register tree result_type
= NULL
;
3178 /* Nonzero means operands have already been type-converted
3179 in whatever way is necessary.
3180 Zero means they need to be converted to RESULT_TYPE. */
3183 /* Nonzero means create the expression with this type, rather than
3185 tree build_type
= 0;
3187 /* Nonzero means after finally constructing the expression
3188 convert it to this type. */
3189 tree final_type
= 0;
3191 /* Nonzero if this is an operation like MIN or MAX which can
3192 safely be computed in short if both args are promoted shorts.
3193 Also implies COMMON.
3194 -1 indicates a bitwise operation; this makes a difference
3195 in the exact conditions for when it is safe to do the operation
3196 in a narrower mode. */
3199 /* Nonzero if this is a comparison operation;
3200 if both args are promoted shorts, compare the original shorts.
3201 Also implies COMMON. */
3202 int short_compare
= 0;
3204 /* Nonzero if this is a right-shift operation, which can be computed on the
3205 original short and then promoted if the operand is a promoted short. */
3206 int short_shift
= 0;
3208 /* Nonzero means set RESULT_TYPE to the common type of the args. */
3211 /* Apply default conversions. */
3212 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
3213 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
3214 || code
== TRUTH_XOR_EXPR
)
3216 op0
= decay_conversion (orig_op0
);
3217 op1
= decay_conversion (orig_op1
);
3221 op0
= default_conversion (orig_op0
);
3222 op1
= default_conversion (orig_op1
);
3225 type0
= TREE_TYPE (op0
);
3226 type1
= TREE_TYPE (op1
);
3228 /* The expression codes of the data types of the arguments tell us
3229 whether the arguments are integers, floating, pointers, etc. */
3230 code0
= TREE_CODE (type0
);
3231 code1
= TREE_CODE (type1
);
3233 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3234 STRIP_TYPE_NOPS (op0
);
3235 STRIP_TYPE_NOPS (op1
);
3237 /* If an error was already reported for one of the arguments,
3238 avoid reporting another error. */
3240 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
3241 return error_mark_node
;
3246 /* Handle the pointer + int case. */
3247 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3248 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
3249 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
3250 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
3256 /* Subtraction of two similar pointers.
3257 We must subtract them as integers, then divide by object size. */
3258 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
3259 && comp_target_types (type0
, type1
, 1))
3260 return pointer_diff (op0
, op1
, common_type (type0
, type1
));
3261 /* Handle pointer minus int. Just like pointer plus int. */
3262 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3263 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
3272 case TRUNC_DIV_EXPR
:
3274 case FLOOR_DIV_EXPR
:
3275 case ROUND_DIV_EXPR
:
3276 case EXACT_DIV_EXPR
:
3277 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3278 || code0
== COMPLEX_TYPE
)
3279 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3280 || code1
== COMPLEX_TYPE
))
3282 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
3283 cp_warning ("division by zero in `%E / 0'", op0
);
3284 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
3285 cp_warning ("division by zero in `%E / 0.'", op0
);
3287 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
3288 resultcode
= RDIV_EXPR
;
3290 /* When dividing two signed integers, we have to promote to int.
3291 unless we divide by a constant != -1. Note that default
3292 conversion will have been performed on the operands at this
3293 point, so we have to dig out the original type to find out if
3295 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3296 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3297 || (TREE_CODE (op1
) == INTEGER_CST
3298 && (TREE_INT_CST_LOW (op1
) != -1
3299 || TREE_INT_CST_HIGH (op1
) != -1)));
3305 case BIT_ANDTC_EXPR
:
3308 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3310 /* If one operand is a constant, and the other is a short type
3311 that has been converted to an int,
3312 really do the work in the short type and then convert the
3313 result to int. If we are lucky, the constant will be 0 or 1
3314 in the short type, making the entire operation go away. */
3315 if (TREE_CODE (op0
) == INTEGER_CST
3316 && TREE_CODE (op1
) == NOP_EXPR
3317 && (TYPE_PRECISION (type1
)
3318 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3319 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3321 final_type
= result_type
;
3322 op1
= TREE_OPERAND (op1
, 0);
3323 result_type
= TREE_TYPE (op1
);
3325 if (TREE_CODE (op1
) == INTEGER_CST
3326 && TREE_CODE (op0
) == NOP_EXPR
3327 && (TYPE_PRECISION (type0
)
3328 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3329 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3331 final_type
= result_type
;
3332 op0
= TREE_OPERAND (op0
, 0);
3333 result_type
= TREE_TYPE (op0
);
3337 case TRUNC_MOD_EXPR
:
3338 case FLOOR_MOD_EXPR
:
3339 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
3340 cp_warning ("division by zero in `%E %% 0'", op0
);
3341 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
3342 cp_warning ("division by zero in `%E %% 0.'", op0
);
3344 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3346 /* Although it would be tempting to shorten always here, that loses
3347 on some targets, since the modulo instruction is undefined if the
3348 quotient can't be represented in the computation mode. We shorten
3349 only if unsigned or if dividing by something we know != -1. */
3350 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3351 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3352 || (TREE_CODE (op1
) == INTEGER_CST
3353 && (TREE_INT_CST_LOW (op1
) != -1
3354 || TREE_INT_CST_HIGH (op1
) != -1)));
3359 case TRUTH_ANDIF_EXPR
:
3360 case TRUTH_ORIF_EXPR
:
3361 case TRUTH_AND_EXPR
:
3363 result_type
= boolean_type_node
;
3366 /* Shift operations: result has same type as first operand;
3367 always convert second operand to int.
3368 Also set SHORT_SHIFT if shifting rightward. */
3371 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3373 result_type
= type0
;
3374 if (TREE_CODE (op1
) == INTEGER_CST
)
3376 if (tree_int_cst_lt (op1
, integer_zero_node
))
3377 warning ("right shift count is negative");
3380 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3382 if (TREE_INT_CST_HIGH (op1
) != 0
3383 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3384 >= TYPE_PRECISION (type0
)))
3385 warning ("right shift count >= width of type");
3388 /* Convert the shift-count to an integer, regardless of
3389 size of value being shifted. */
3390 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3391 op1
= cp_convert (integer_type_node
, op1
);
3392 /* Avoid converting op1 to result_type later. */
3398 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3400 result_type
= type0
;
3401 if (TREE_CODE (op1
) == INTEGER_CST
)
3403 if (tree_int_cst_lt (op1
, integer_zero_node
))
3404 warning ("left shift count is negative");
3405 else if (TREE_INT_CST_HIGH (op1
) != 0
3406 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3407 >= TYPE_PRECISION (type0
)))
3408 warning ("left shift count >= width of type");
3410 /* Convert the shift-count to an integer, regardless of
3411 size of value being shifted. */
3412 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3413 op1
= cp_convert (integer_type_node
, op1
);
3414 /* Avoid converting op1 to result_type later. */
3421 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3423 result_type
= type0
;
3424 if (TREE_CODE (op1
) == INTEGER_CST
)
3426 if (tree_int_cst_lt (op1
, integer_zero_node
))
3427 warning ("%s rotate count is negative",
3428 (code
== LROTATE_EXPR
) ? "left" : "right");
3429 else if (TREE_INT_CST_HIGH (op1
) != 0
3430 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3431 >= TYPE_PRECISION (type0
)))
3432 warning ("%s rotate count >= width of type",
3433 (code
== LROTATE_EXPR
) ? "left" : "right");
3435 /* Convert the shift-count to an integer, regardless of
3436 size of value being shifted. */
3437 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3438 op1
= cp_convert (integer_type_node
, op1
);
3444 build_type
= boolean_type_node
;
3445 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
3446 || code0
== COMPLEX_TYPE
)
3447 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3448 || code1
== COMPLEX_TYPE
))
3450 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3452 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3453 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3455 if (comp_target_types (type0
, type1
, 1))
3456 result_type
= common_type (type0
, type1
);
3457 else if (tt0
== void_type_node
)
3459 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3460 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3461 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3462 else if (TREE_CODE (tt1
) == OFFSET_TYPE
)
3463 pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
3465 else if (tt1
== void_type_node
)
3467 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3468 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3469 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3472 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3475 if (result_type
== NULL_TREE
)
3476 result_type
= ptr_type_node
;
3478 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3479 && integer_zerop (op1
))
3480 result_type
= type0
;
3481 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3482 && integer_zerop (op0
))
3483 result_type
= type1
;
3484 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3486 result_type
= type0
;
3487 error ("ANSI C++ forbids comparison between pointer and integer");
3489 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3491 result_type
= type1
;
3492 error ("ANSI C++ forbids comparison between pointer and integer");
3494 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3495 && integer_zerop (op1
))
3497 op0
= build_component_ref (op0
, index_identifier
, NULL_TREE
, 0);
3498 op1
= integer_zero_node
;
3499 result_type
= TREE_TYPE (op0
);
3501 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3502 && integer_zerop (op0
))
3504 op0
= build_component_ref (op1
, index_identifier
, NULL_TREE
, 0);
3505 op1
= integer_zero_node
;
3506 result_type
= TREE_TYPE (op0
);
3508 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3509 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3510 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3512 /* The code we generate for the test is:
3514 (op0.index == op1.index
3515 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3516 || op0.pfn == op1.pfn)) */
3518 tree index0
= build_component_ref (op0
, index_identifier
,
3520 tree index1
= save_expr (build_component_ref (op1
, index_identifier
,
3522 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3523 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3524 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3525 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3527 tree integer_neg_one_node
3528 = build_binary_op (MINUS_EXPR
, integer_zero_node
,
3529 integer_one_node
, 1);
3530 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3531 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3532 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3533 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3535 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3536 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3537 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3538 if (code
== EQ_EXPR
)
3540 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3542 else if (TYPE_PTRMEMFUNC_P (type0
)
3543 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3545 tree index0
= build_component_ref (op0
, index_identifier
,
3548 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3549 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3550 tree delta21
= integer_zero_node
;
3552 tree integer_neg_one_node
3553 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3554 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3555 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3557 /* Map everything down one to make room for
3558 the null pointer to member. */
3559 index1
= size_binop (PLUS_EXPR
,
3560 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3562 op1
= integer_zero_node
;
3563 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE
3564 (TREE_TYPE (type1
)));
3565 delta21
= DECL_FIELD_BITPOS (delta21
);
3566 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
,
3567 size_int (BITS_PER_UNIT
));
3568 delta21
= convert (sizetype
, delta21
);
3571 index1
= integer_neg_one_node
;
3573 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
),
3575 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3578 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3579 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3580 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
,
3581 build_binary_op (EQ_EXPR
, delta20
, delta21
, 1),
3583 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3584 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3585 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3586 if (code
== EQ_EXPR
)
3588 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3590 else if (TYPE_PTRMEMFUNC_P (type1
)
3591 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3593 return build_binary_op (code
, op1
, op0
, 1);
3599 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3600 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3602 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3604 if (comp_target_types (type0
, type1
, 1))
3605 result_type
= common_type (type0
, type1
);
3608 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3610 result_type
= ptr_type_node
;
3619 build_type
= boolean_type_node
;
3620 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3621 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3623 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3625 if (comp_target_types (type0
, type1
, 1))
3626 result_type
= common_type (type0
, type1
);
3629 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3631 result_type
= ptr_type_node
;
3634 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3635 && integer_zerop (op1
))
3636 result_type
= type0
;
3637 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3638 && integer_zerop (op0
))
3639 result_type
= type1
;
3640 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3642 result_type
= type0
;
3643 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3645 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3647 result_type
= type1
;
3648 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3656 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
3658 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
3660 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
3662 if (shorten
|| common
|| short_compare
)
3663 result_type
= common_type (type0
, type1
);
3665 /* For certain operations (which identify themselves by shorten != 0)
3666 if both args were extended from the same smaller type,
3667 do the arithmetic in that type and then extend.
3669 shorten !=0 and !=1 indicates a bitwise operation.
3670 For them, this optimization is safe only if
3671 both args are zero-extended or both are sign-extended.
3672 Otherwise, we might change the result.
3673 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3674 but calculated in (unsigned short) it would be (unsigned short)-1. */
3676 if (shorten
&& none_complex
)
3678 int unsigned0
, unsigned1
;
3679 tree arg0
= get_narrower (op0
, &unsigned0
);
3680 tree arg1
= get_narrower (op1
, &unsigned1
);
3681 /* UNS is 1 if the operation to be done is an unsigned one. */
3682 int uns
= TREE_UNSIGNED (result_type
);
3685 final_type
= result_type
;
3687 /* Handle the case that OP0 does not *contain* a conversion
3688 but it *requires* conversion to FINAL_TYPE. */
3690 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3691 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3692 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3693 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3695 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3697 /* For bitwise operations, signedness of nominal type
3698 does not matter. Consider only how operands were extended. */
3702 /* Note that in all three cases below we refrain from optimizing
3703 an unsigned operation on sign-extended args.
3704 That would not be valid. */
3706 /* Both args variable: if both extended in same way
3707 from same width, do it in that width.
3708 Do it unsigned if args were zero-extended. */
3709 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3710 < TYPE_PRECISION (result_type
))
3711 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3712 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3713 && unsigned0
== unsigned1
3714 && (unsigned0
|| !uns
))
3716 = signed_or_unsigned_type (unsigned0
,
3717 common_type (TREE_TYPE (arg0
),
3719 else if (TREE_CODE (arg0
) == INTEGER_CST
3720 && (unsigned1
|| !uns
)
3721 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3722 < TYPE_PRECISION (result_type
))
3723 && (type
= signed_or_unsigned_type (unsigned1
,
3725 int_fits_type_p (arg0
, type
)))
3727 else if (TREE_CODE (arg1
) == INTEGER_CST
3728 && (unsigned0
|| !uns
)
3729 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3730 < TYPE_PRECISION (result_type
))
3731 && (type
= signed_or_unsigned_type (unsigned0
,
3733 int_fits_type_p (arg1
, type
)))
3737 /* Shifts can be shortened if shifting right. */
3742 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3744 final_type
= result_type
;
3746 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3747 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3749 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3750 /* We can shorten only if the shift count is less than the
3751 number of bits in the smaller type size. */
3752 && TREE_INT_CST_HIGH (op1
) == 0
3753 && TYPE_PRECISION (TREE_TYPE (arg0
)) > TREE_INT_CST_LOW (op1
)
3754 /* If arg is sign-extended and then unsigned-shifted,
3755 we can simulate this with a signed shift in arg's type
3756 only if the extended result is at least twice as wide
3757 as the arg. Otherwise, the shift could use up all the
3758 ones made by sign-extension and bring in zeros.
3759 We can't optimize that case at all, but in most machines
3760 it never happens because available widths are 2**N. */
3761 && (!TREE_UNSIGNED (final_type
)
3763 || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
)))
3764 <= TYPE_PRECISION (result_type
))))
3766 /* Do an unsigned shift if the operand was zero-extended. */
3768 = signed_or_unsigned_type (unsigned_arg
,
3770 /* Convert value-to-be-shifted to that type. */
3771 if (TREE_TYPE (op0
) != result_type
)
3772 op0
= cp_convert (result_type
, op0
);
3777 /* Comparison operations are shortened too but differently.
3778 They identify themselves by setting short_compare = 1. */
3782 /* Don't write &op0, etc., because that would prevent op0
3783 from being kept in a register.
3784 Instead, make copies of the our local variables and
3785 pass the copies by reference, then copy them back afterward. */
3786 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3787 enum tree_code xresultcode
= resultcode
;
3789 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3791 return cp_convert (boolean_type_node
, val
);
3792 op0
= xop0
, op1
= xop1
;
3794 resultcode
= xresultcode
;
3797 if (short_compare
&& warn_sign_compare
)
3799 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
3800 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3802 int unsignedp0
, unsignedp1
;
3803 tree primop0
= get_narrower (op0
, &unsignedp0
);
3804 tree primop1
= get_narrower (op1
, &unsignedp1
);
3806 /* Check for comparison of different enum types. */
3807 if (TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
3808 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
3809 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
3810 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
3812 cp_warning ("comparison between `%#T' and `%#T'",
3813 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
3816 /* Give warnings for comparisons between signed and unsigned
3817 quantities that may fail. */
3818 /* Do the checking based on the original operand trees, so that
3819 casts will be considered, but default promotions won't be. */
3821 /* Do not warn if the comparison is being done in a signed type,
3822 since the signed type will only be chosen if it can represent
3823 all the values of the unsigned type. */
3824 if (! TREE_UNSIGNED (result_type
))
3826 /* Do not warn if both operands are unsigned. */
3827 else if (op0_signed
== op1_signed
)
3829 /* Do not warn if the signed quantity is an unsuffixed
3830 integer literal (or some static constant expression
3831 involving such literals) and it is non-negative. */
3832 else if ((op0_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3833 && tree_int_cst_sgn (orig_op0
) >= 0)
3834 || (op1_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3835 && tree_int_cst_sgn (orig_op1
) >= 0))
3837 /* Do not warn if the comparison is an equality operation,
3838 the unsigned quantity is an integral constant and it does
3839 not use the most significant bit of result_type. */
3840 else if ((resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
3841 && ((op0_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3842 && int_fits_type_p (orig_op1
,
3843 signed_type (result_type
)))
3844 || (op1_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3845 && int_fits_type_p (orig_op0
,
3846 signed_type (result_type
)))))
3849 warning ("comparison between signed and unsigned");
3851 /* Warn if two unsigned values are being compared in a size
3852 larger than their original size, and one (and only one) is the
3853 result of a `~' operator. This comparison will always fail.
3855 Also warn if one operand is a constant, and the constant does not
3856 have all bits set that are set in the ~ operand when it is
3859 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3860 ^ (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
3862 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3863 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3864 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3865 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3867 if (TREE_CODE (primop0
) == INTEGER_CST
3868 || TREE_CODE (primop1
) == INTEGER_CST
)
3871 HOST_WIDE_INT constant
, mask
;
3875 if (TREE_CODE (primop0
) == INTEGER_CST
)
3878 unsignedp
= unsignedp1
;
3879 constant
= TREE_INT_CST_LOW (primop0
);
3884 unsignedp
= unsignedp0
;
3885 constant
= TREE_INT_CST_LOW (primop1
);
3888 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3889 if (bits
< TYPE_PRECISION (result_type
)
3890 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3892 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3893 if ((mask
& constant
) != mask
)
3894 warning ("comparison of promoted ~unsigned with constant");
3897 else if (unsignedp0
&& unsignedp1
3898 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3899 < TYPE_PRECISION (result_type
))
3900 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3901 < TYPE_PRECISION (result_type
)))
3902 warning ("comparison of promoted ~unsigned with unsigned");
3907 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3908 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3909 Then the expression will be built.
3910 It will be given type FINAL_TYPE if that is nonzero;
3911 otherwise, it will be given type RESULT_TYPE. */
3915 cp_error ("invalid operands `%T' and `%T' to binary `%O'",
3916 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), error_code
);
3917 return error_mark_node
;
3920 /* Issue warnings about peculiar, but legal, uses of NULL. */
3921 if (/* It's reasonable to use pointer values as operands of &&
3922 and ||, so NULL is no exception. */
3923 !(code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
3924 && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */
3925 (orig_op0
== null_node
3926 && TREE_CODE (TREE_TYPE (op1
)) != POINTER_TYPE
)
3927 /* Or vice versa. */
3928 || (orig_op1
== null_node
3929 && TREE_CODE (TREE_TYPE (op0
)) != POINTER_TYPE
)
3930 /* Or, both are NULL and the operation was not a comparison. */
3931 || (orig_op0
== null_node
&& orig_op1
== null_node
3932 && code
!= EQ_EXPR
&& code
!= NE_EXPR
)))
3933 /* Some sort of arithmetic operation involving NULL was
3934 performed. Note that pointer-difference and pointer-addition
3935 have already been handled above, and so we don't end up here in
3937 cp_warning ("NULL used in arithmetic");
3941 if (TREE_TYPE (op0
) != result_type
)
3942 op0
= cp_convert (result_type
, op0
);
3943 if (TREE_TYPE (op1
) != result_type
)
3944 op1
= cp_convert (result_type
, op1
);
3946 if (op0
== error_mark_node
|| op1
== error_mark_node
)
3947 return error_mark_node
;
3950 if (build_type
== NULL_TREE
)
3951 build_type
= result_type
;
3954 register tree result
= build (resultcode
, build_type
, op0
, op1
);
3955 register tree folded
;
3957 folded
= fold (result
);
3958 if (folded
== result
)
3959 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3960 if (final_type
!= 0)
3961 return cp_convert (final_type
, folded
);
3966 /* Return a tree for the sum or difference (RESULTCODE says which)
3967 of pointer PTROP and integer INTOP. */
3970 pointer_int_sum (resultcode
, ptrop
, intop
)
3971 enum tree_code resultcode
;
3972 register tree ptrop
, intop
;
3976 register tree result
;
3977 register tree folded
= fold (intop
);
3979 /* The result is a pointer of the same type that is being added. */
3981 register tree result_type
= TREE_TYPE (ptrop
);
3983 if (!complete_type_or_else (result_type
))
3984 return error_mark_node
;
3986 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3988 if (pedantic
|| warn_pointer_arith
)
3989 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3990 size_exp
= integer_one_node
;
3992 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3994 if (pedantic
|| warn_pointer_arith
)
3995 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3996 size_exp
= integer_one_node
;
3998 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
4000 if (pedantic
|| warn_pointer_arith
)
4001 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
4002 size_exp
= integer_one_node
;
4004 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
4006 if (pedantic
|| warn_pointer_arith
)
4007 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
4008 size_exp
= integer_one_node
;
4011 size_exp
= size_in_bytes (complete_type (TREE_TYPE (result_type
)));
4013 /* Needed to make OOPS V2R3 work. */
4015 if (TREE_CODE (intop
) == INTEGER_CST
4016 && TREE_INT_CST_LOW (intop
) == 0
4017 && TREE_INT_CST_HIGH (intop
) == 0)
4020 /* If what we are about to multiply by the size of the elements
4021 contains a constant term, apply distributive law
4022 and multiply that constant term separately.
4023 This helps produce common subexpressions. */
4025 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
4026 && ! TREE_CONSTANT (intop
)
4027 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
4028 && TREE_CONSTANT (size_exp
))
4030 enum tree_code subcode
= resultcode
;
4031 if (TREE_CODE (intop
) == MINUS_EXPR
)
4032 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
4033 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
4034 intop
= TREE_OPERAND (intop
, 0);
4037 /* Convert the integer argument to a type the same size as sizetype
4038 so the multiply won't overflow spuriously. */
4040 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
))
4041 intop
= cp_convert (type_for_size (TYPE_PRECISION (sizetype
), 0), intop
);
4043 /* Replace the integer argument with a suitable product by the object size.
4044 Do this multiplication as signed, then convert to the appropriate
4045 pointer type (actually unsigned integral). */
4047 intop
= cp_convert (result_type
,
4048 build_binary_op (MULT_EXPR
, intop
,
4049 cp_convert (TREE_TYPE (intop
),
4053 /* Create the sum or difference. */
4055 result
= build (resultcode
, result_type
, ptrop
, intop
);
4057 folded
= fold (result
);
4058 if (folded
== result
)
4059 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
4063 /* Return a tree for the difference of pointers OP0 and OP1.
4064 The resulting tree has type int. */
4067 pointer_diff (op0
, op1
, ptrtype
)
4068 register tree op0
, op1
;
4069 register tree ptrtype
;
4071 register tree result
, folded
;
4072 tree restype
= ptrdiff_type_node
;
4073 tree target_type
= TREE_TYPE (ptrtype
);
4075 if (!complete_type_or_else (target_type
))
4076 return error_mark_node
;
4078 if (pedantic
|| warn_pointer_arith
)
4080 if (TREE_CODE (target_type
) == VOID_TYPE
)
4081 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
4082 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
4083 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
4084 if (TREE_CODE (target_type
) == METHOD_TYPE
)
4085 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
4086 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
4087 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
4090 /* First do the subtraction as integers;
4091 then drop through to build the divide operator. */
4093 op0
= build_binary_op (MINUS_EXPR
, cp_convert (restype
, op0
),
4094 cp_convert (restype
, op1
), 1);
4096 /* This generates an error if op1 is a pointer to an incomplete type. */
4097 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
4098 error ("arithmetic on pointer to an incomplete type");
4100 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
4101 || TREE_CODE (target_type
) == FUNCTION_TYPE
4102 || TREE_CODE (target_type
) == METHOD_TYPE
4103 || TREE_CODE (target_type
) == OFFSET_TYPE
)
4105 : size_in_bytes (target_type
));
4107 /* Do the division. */
4109 result
= build (EXACT_DIV_EXPR
, restype
, op0
, cp_convert (restype
, op1
));
4111 folded
= fold (result
);
4112 if (folded
== result
)
4113 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
4117 /* Handle the case of taking the address of a COMPONENT_REF.
4118 Called by `build_unary_op' and `build_up_reference'.
4120 ARG is the COMPONENT_REF whose address we want.
4121 ARGTYPE is the pointer type that this address should have.
4122 MSG is an error message to print if this COMPONENT_REF is not
4123 addressable (such as a bitfield). */
4126 build_component_addr (arg
, argtype
, msg
)
4130 tree field
= TREE_OPERAND (arg
, 1);
4131 tree basetype
= decl_type_context (field
);
4132 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
4134 my_friendly_assert (TREE_CODE (field
) == FIELD_DECL
, 981018);
4136 if (DECL_C_BIT_FIELD (field
))
4138 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
4139 return error_mark_node
;
4142 if (TREE_CODE (field
) == FIELD_DECL
4143 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
4145 /* Can't convert directly to ARGTYPE, since that
4146 may have the same pointer type as one of our
4148 rval
= build1 (NOP_EXPR
, argtype
,
4149 convert_pointer_to (basetype
, rval
));
4150 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
4153 /* This conversion is harmless. */
4154 rval
= convert_force (argtype
, rval
, 0);
4156 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
4158 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
4159 size_int (BITS_PER_UNIT
));
4160 int flag
= TREE_CONSTANT (rval
);
4161 offset
= convert (sizetype
, offset
);
4162 rval
= fold (build (PLUS_EXPR
, argtype
,
4163 rval
, cp_convert (argtype
, offset
)));
4164 TREE_CONSTANT (rval
) = flag
;
4169 /* Construct and perhaps optimize a tree representation
4170 for a unary operation. CODE, a tree_code, specifies the operation
4171 and XARG is the operand. */
4174 build_x_unary_op (code
, xarg
)
4175 enum tree_code code
;
4178 if (processing_template_decl
)
4179 return build_min_nt (code
, xarg
, NULL_TREE
);
4181 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
4183 if (code
== ADDR_EXPR
4184 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
4185 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
4186 && TYPE_SIZE (TREE_TYPE (xarg
)) == NULL_TREE
)
4187 || (TREE_CODE (xarg
) == OFFSET_REF
)))
4188 /* don't look for a function */;
4193 rval
= build_new_op (code
, LOOKUP_NORMAL
, xarg
,
4194 NULL_TREE
, NULL_TREE
);
4195 if (rval
|| code
!= ADDR_EXPR
)
4199 if (code
== ADDR_EXPR
)
4201 if (TREE_CODE (xarg
) == TARGET_EXPR
)
4202 warning ("taking address of temporary");
4205 return build_unary_op (code
, xarg
, 0);
4208 /* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
4211 condition_conversion (expr
)
4215 if (processing_template_decl
)
4217 t
= cp_convert (boolean_type_node
, expr
);
4218 t
= fold (build1 (CLEANUP_POINT_EXPR
, boolean_type_node
, t
));
4222 /* C++: Must handle pointers to members.
4224 Perhaps type instantiation should be extended to handle conversion
4225 from aggregates to types we don't yet know we want? (Or are those
4226 cases typically errors which should be reported?)
4228 NOCONVERT nonzero suppresses the default promotions
4229 (such as from short to int). */
4232 build_unary_op (code
, xarg
, noconvert
)
4233 enum tree_code code
;
4237 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4238 register tree arg
= xarg
;
4239 register tree argtype
= 0;
4240 char *errstring
= NULL
;
4243 if (arg
== error_mark_node
)
4244 return error_mark_node
;
4249 /* This is used for unary plus, because a CONVERT_EXPR
4250 is enough to prevent anybody from looking inside for
4251 associativity, but won't generate any code. */
4252 if (!(arg
= build_expr_type_conversion
4253 (WANT_ARITH
| WANT_ENUM
| WANT_POINTER
, arg
, 1)))
4254 errstring
= "wrong type argument to unary plus";
4258 arg
= default_conversion (arg
);
4259 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
4260 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4265 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4266 errstring
= "wrong type argument to unary minus";
4267 else if (!noconvert
)
4268 arg
= default_conversion (arg
);
4272 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4276 arg
= default_conversion (arg
);
4278 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
4280 errstring
= "wrong type argument to bit-complement";
4281 else if (!noconvert
)
4282 arg
= default_conversion (arg
);
4286 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4287 errstring
= "wrong type argument to abs";
4288 else if (!noconvert
)
4289 arg
= default_conversion (arg
);
4293 /* Conjugating a real value is a no-op, but allow it anyway. */
4294 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
4295 errstring
= "wrong type argument to conjugation";
4296 else if (!noconvert
)
4297 arg
= default_conversion (arg
);
4300 case TRUTH_NOT_EXPR
:
4301 arg
= cp_convert (boolean_type_node
, arg
);
4302 val
= invert_truthvalue (arg
);
4303 if (arg
!= error_mark_node
)
4305 errstring
= "in argument to unary !";
4312 if (TREE_CODE (arg
) == COMPLEX_CST
)
4313 return TREE_REALPART (arg
);
4314 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4315 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4320 if (TREE_CODE (arg
) == COMPLEX_CST
)
4321 return TREE_IMAGPART (arg
);
4322 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4323 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
4325 return cp_convert (TREE_TYPE (arg
), integer_zero_node
);
4327 case PREINCREMENT_EXPR
:
4328 case POSTINCREMENT_EXPR
:
4329 case PREDECREMENT_EXPR
:
4330 case POSTDECREMENT_EXPR
:
4331 /* Handle complex lvalues (when permitted)
4332 by reduction to simpler cases. */
4334 val
= unary_complex_lvalue (code
, arg
);
4338 /* Increment or decrement the real part of the value,
4339 and don't change the imaginary part. */
4340 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
4344 arg
= stabilize_reference (arg
);
4345 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
4346 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
4347 return build (COMPLEX_EXPR
, TREE_TYPE (arg
),
4348 build_unary_op (code
, real
, 1), imag
);
4351 /* Report invalid types. */
4353 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
4356 if (code
== PREINCREMENT_EXPR
)
4357 errstring
="no pre-increment operator for type";
4358 else if (code
== POSTINCREMENT_EXPR
)
4359 errstring
="no post-increment operator for type";
4360 else if (code
== PREDECREMENT_EXPR
)
4361 errstring
="no pre-decrement operator for type";
4363 errstring
="no post-decrement operator for type";
4367 /* Report something read-only. */
4369 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
4370 || TREE_READONLY (arg
))
4371 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
4372 || code
== POSTINCREMENT_EXPR
)
4373 ? "increment" : "decrement"),
4378 tree result_type
= TREE_TYPE (arg
);
4380 arg
= get_unwidened (arg
, 0);
4381 argtype
= TREE_TYPE (arg
);
4383 /* ARM $5.2.5 last annotation says this should be forbidden. */
4384 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
4385 pedwarn ("ANSI C++ forbids %sing an enum",
4386 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4387 ? "increment" : "decrement");
4389 /* Compute the increment. */
4391 if (TREE_CODE (argtype
) == POINTER_TYPE
)
4393 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
4394 if (TYPE_SIZE (complete_type (TREE_TYPE (argtype
))) == 0)
4395 cp_error ("cannot %s a pointer to incomplete type `%T'",
4396 ((code
== PREINCREMENT_EXPR
4397 || code
== POSTINCREMENT_EXPR
)
4398 ? "increment" : "decrement"), TREE_TYPE (argtype
));
4399 else if ((pedantic
|| warn_pointer_arith
)
4400 && (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
4401 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
))
4402 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
4403 ((code
== PREINCREMENT_EXPR
4404 || code
== POSTINCREMENT_EXPR
)
4405 ? "increment" : "decrement"), argtype
);
4406 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
4409 inc
= integer_one_node
;
4411 inc
= cp_convert (argtype
, inc
);
4413 /* Handle incrementing a cast-expression. */
4415 switch (TREE_CODE (arg
))
4420 case FIX_TRUNC_EXPR
:
4421 case FIX_FLOOR_EXPR
:
4422 case FIX_ROUND_EXPR
:
4425 tree incremented
, modify
, value
, compound
;
4426 if (! lvalue_p (arg
) && pedantic
)
4427 pedwarn ("cast to non-reference type used as lvalue");
4428 arg
= stabilize_reference (arg
);
4429 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4432 value
= save_expr (arg
);
4433 incremented
= build (((code
== PREINCREMENT_EXPR
4434 || code
== POSTINCREMENT_EXPR
)
4435 ? PLUS_EXPR
: MINUS_EXPR
),
4436 argtype
, value
, inc
);
4437 TREE_SIDE_EFFECTS (incremented
) = 1;
4439 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4440 compound
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4442 /* Eliminate warning about unused result of + or -. */
4443 TREE_NO_UNUSED_WARNING (compound
) = 1;
4451 /* Complain about anything else that is not a true lvalue. */
4452 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4453 || code
== POSTINCREMENT_EXPR
)
4454 ? "increment" : "decrement")))
4455 return error_mark_node
;
4457 /* Forbid using -- on `bool'. */
4458 if (TREE_TYPE (arg
) == boolean_type_node
)
4460 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4462 cp_error ("invalid use of `--' on bool variable `%D'", arg
);
4463 return error_mark_node
;
4466 /* This will only work if someone can convince Kenner to accept
4467 my patch to expand_increment. (jason) */
4468 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4470 if (code
== POSTINCREMENT_EXPR
)
4472 arg
= stabilize_reference (arg
);
4473 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4475 TREE_SIDE_EFFECTS (val
) = 1;
4476 arg
= save_expr (arg
);
4477 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4478 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4481 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4486 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4488 TREE_SIDE_EFFECTS (val
) = 1;
4489 return cp_convert (result_type
, val
);
4493 /* Note that this operation never does default_conversion
4494 regardless of NOCONVERT. */
4496 argtype
= lvalue_type (arg
);
4497 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4501 build_pointer_type (TREE_TYPE (argtype
)), arg
);
4502 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4505 else if (pedantic
&& DECL_MAIN_P (arg
))
4507 pedwarn ("taking address of function `main'");
4509 /* Let &* cancel out to simplify resulting code. */
4510 if (TREE_CODE (arg
) == INDIRECT_REF
)
4512 /* We don't need to have `current_class_ptr' wrapped in a
4513 NON_LVALUE_EXPR node. */
4514 if (arg
== current_class_ref
)
4515 return current_class_ptr
;
4517 arg
= TREE_OPERAND (arg
, 0);
4518 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4522 build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4523 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4525 else if (lvalue_p (arg
))
4526 /* Don't let this be an lvalue. */
4527 return non_lvalue (arg
);
4531 /* For &x[y], return x+y */
4532 if (TREE_CODE (arg
) == ARRAY_REF
)
4534 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4535 return error_mark_node
;
4536 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4537 TREE_OPERAND (arg
, 1), 1);
4540 /* Uninstantiated types are all functions. Taking the
4541 address of a function is a no-op, so just return the
4544 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4545 && IDENTIFIER_OPNAME_P (arg
))
4547 my_friendly_abort (117);
4548 /* We don't know the type yet, so just work around the problem.
4549 We know that this will resolve to an lvalue. */
4550 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4553 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
4558 /* We don't require a match here; it's possible that the
4559 context (like a cast to a particular type) will resolve
4560 the particular choice of template. */
4561 fn
= determine_specialization (arg
,
4569 fn
= instantiate_template (fn
, targs
);
4570 mark_addressable (fn
);
4571 return build_unary_op (ADDR_EXPR
, fn
, 0);
4574 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4576 else if (type_unknown_p (arg
))
4577 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4579 /* Handle complex lvalues (when permitted)
4580 by reduction to simpler cases. */
4581 val
= unary_complex_lvalue (code
, arg
);
4585 switch (TREE_CODE (arg
))
4590 case FIX_TRUNC_EXPR
:
4591 case FIX_FLOOR_EXPR
:
4592 case FIX_ROUND_EXPR
:
4594 if (! lvalue_p (arg
) && pedantic
)
4595 pedwarn ("taking the address of a cast to non-reference type");
4602 /* Allow the address of a constructor if all the elements
4604 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_HAS_CONSTRUCTOR (arg
)
4605 && TREE_CONSTANT (arg
))
4607 /* Anything not already handled and not a true memory reference
4609 else if (TREE_CODE (argtype
) != FUNCTION_TYPE
4610 && TREE_CODE (argtype
) != METHOD_TYPE
4611 && !lvalue_or_else (arg
, "unary `&'"))
4612 return error_mark_node
;
4614 if (argtype
!= error_mark_node
)
4615 argtype
= build_pointer_type (argtype
);
4617 if (mark_addressable (arg
) == 0)
4618 return error_mark_node
;
4623 if (TREE_CODE (arg
) == COMPONENT_REF
)
4624 addr
= build_component_addr
4626 "attempt to take address of bit-field structure member `%s'");
4628 addr
= build1 (code
, argtype
, arg
);
4630 /* Address of a static or external variable or
4631 function counts as a constant */
4633 TREE_CONSTANT (addr
) = 1;
4635 if (TREE_CODE (argtype
) == POINTER_TYPE
4636 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
4638 build_ptrmemfunc_type (argtype
);
4639 addr
= build_ptrmemfunc (argtype
, addr
, 0);
4652 argtype
= TREE_TYPE (arg
);
4653 return fold (build1 (code
, argtype
, arg
));
4657 return error_mark_node
;
4661 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4662 convert ARG with the same conversions in the same order
4663 and return the result. */
4666 convert_sequence (conversions
, arg
)
4670 switch (TREE_CODE (conversions
))
4675 case FIX_TRUNC_EXPR
:
4676 case FIX_FLOOR_EXPR
:
4677 case FIX_ROUND_EXPR
:
4679 return cp_convert (TREE_TYPE (conversions
),
4680 convert_sequence (TREE_OPERAND (conversions
, 0),
4689 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4690 for certain kinds of expressions which are not really lvalues
4691 but which we can accept as lvalues.
4693 If ARG is not a kind of expression we can handle, return zero. */
4696 unary_complex_lvalue (code
, arg
)
4697 enum tree_code code
;
4700 /* Handle (a, b) used as an "lvalue". */
4701 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4703 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4704 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4705 TREE_OPERAND (arg
, 0), real_result
);
4708 /* Handle (a ? b : c) used as an "lvalue". */
4709 if (TREE_CODE (arg
) == COND_EXPR
4710 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
4711 return rationalize_conditional_expr (code
, arg
);
4713 if (TREE_CODE (arg
) == MODIFY_EXPR
4714 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4715 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4716 return unary_complex_lvalue
4717 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4718 arg
, TREE_OPERAND (arg
, 0)));
4720 if (code
!= ADDR_EXPR
)
4723 /* Handle (a = b) used as an "lvalue" for `&'. */
4724 if (TREE_CODE (arg
) == MODIFY_EXPR
4725 || TREE_CODE (arg
) == INIT_EXPR
)
4727 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4728 arg
= build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4729 TREE_NO_UNUSED_WARNING (arg
) = 1;
4733 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4734 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4735 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4737 /* The representation of something of type OFFSET_TYPE
4738 is really the representation of a pointer to it.
4739 Here give the representation its true type. */
4742 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4744 if (TREE_CODE (arg
) != OFFSET_REF
)
4747 t
= TREE_OPERAND (arg
, 1);
4749 /* Check all this code for right semantics. */
4750 if (TREE_CODE (t
) == FUNCTION_DECL
)
4752 if (DECL_DESTRUCTOR_P (t
))
4753 cp_error ("taking address of destructor");
4754 return build_unary_op (ADDR_EXPR
, t
, 0);
4756 if (TREE_CODE (t
) == VAR_DECL
)
4757 return build_unary_op (ADDR_EXPR
, t
, 0);
4762 if (TREE_OPERAND (arg
, 0)
4763 && ! is_dummy_object (TREE_OPERAND (arg
, 0))
4764 && TREE_CODE (t
) != FIELD_DECL
)
4766 cp_error ("taking address of bound pointer-to-member expression");
4767 return error_mark_node
;
4770 type
= build_offset_type (DECL_FIELD_CONTEXT (t
), TREE_TYPE (t
));
4771 type
= build_pointer_type (type
);
4773 t
= make_node (PTRMEM_CST
);
4774 TREE_TYPE (t
) = type
;
4775 PTRMEM_CST_MEMBER (t
) = TREE_OPERAND (arg
, 1);
4781 /* We permit compiler to make function calls returning
4782 objects of aggregate type look like lvalues. */
4786 if (TREE_CODE (targ
) == SAVE_EXPR
)
4787 targ
= TREE_OPERAND (targ
, 0);
4789 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4791 if (TREE_CODE (arg
) == SAVE_EXPR
)
4794 targ
= build_cplus_new (TREE_TYPE (arg
), arg
);
4795 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
4798 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4799 return build (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4800 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4803 /* Don't let anything else be handled specially. */
4807 /* Mark EXP saying that we need to be able to take the
4808 address of it; it should not be allocated in a register.
4809 Value is 1 if successful.
4811 C++: we do not allow `current_class_ptr' to be addressable. */
4814 mark_addressable (exp
)
4817 register tree x
= exp
;
4819 if (TREE_ADDRESSABLE (x
) == 1)
4823 switch (TREE_CODE (x
))
4830 x
= TREE_OPERAND (x
, 0);
4834 if (x
== current_class_ptr
)
4836 if (! flag_this_is_variable
)
4837 error ("address of `this' not available");
4838 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4839 put_var_into_stack (x
);
4843 if (TREE_STATIC (x
) && TREE_READONLY (x
)
4844 && DECL_RTL (x
) != 0
4845 && ! DECL_IN_MEMORY_P (x
))
4847 /* We thought this would make a good constant variable,
4848 but we were wrong. */
4849 push_obstacks_nochange ();
4850 end_temporary_allocation ();
4852 TREE_ASM_WRITTEN (x
) = 0;
4854 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0,
4856 TREE_ADDRESSABLE (x
) = 1;
4862 /* Caller should not be trying to mark initialized
4863 constant fields addressable. */
4864 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4865 || DECL_IN_AGGR_P (x
) == 0
4867 || DECL_EXTERNAL (x
), 314);
4871 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
4872 && !DECL_ARTIFICIAL (x
) && extra_warnings
)
4873 cp_warning ("address requested for `%D', which is declared `register'",
4875 put_var_into_stack (x
);
4876 TREE_ADDRESSABLE (x
) = 1;
4880 if (DECL_LANG_SPECIFIC (x
) != 0)
4882 x
= DECL_MAIN_VARIANT (x
);
4883 /* We have to test both conditions here. The first may be
4884 non-zero in the case of processing a default function. The
4885 second may be non-zero in the case of a template function. */
4886 if (DECL_TEMPLATE_INFO (x
) && !DECL_TEMPLATE_SPECIALIZATION (x
))
4889 TREE_ADDRESSABLE (x
) = 1;
4891 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4895 TREE_ADDRESSABLE (x
) = 1;
4899 TREE_ADDRESSABLE (x
) = 1;
4900 mark_addressable (TREE_OPERAND (x
, 0));
4908 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4911 build_x_conditional_expr (ifexp
, op1
, op2
)
4912 tree ifexp
, op1
, op2
;
4914 if (processing_template_decl
)
4915 return build_min_nt (COND_EXPR
, ifexp
, op1
, op2
);
4917 return build_new_op (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4921 build_conditional_expr (ifexp
, op1
, op2
)
4922 tree ifexp
, op1
, op2
;
4924 register tree type1
;
4925 register tree type2
;
4926 register enum tree_code code1
;
4927 register enum tree_code code2
;
4928 register tree result_type
= NULL_TREE
;
4930 /* If second operand is omitted, it is the same as the first one;
4931 make sure it is calculated only once. */
4935 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4936 ifexp
= op1
= save_expr (ifexp
);
4939 ifexp
= cp_convert (boolean_type_node
, ifexp
);
4941 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4942 return error_mark_node
;
4944 /* C++: REFERENCE_TYPES must be dereferenced. */
4945 type1
= TREE_TYPE (op1
);
4946 code1
= TREE_CODE (type1
);
4947 type2
= TREE_TYPE (op2
);
4948 code2
= TREE_CODE (type2
);
4950 if (code1
== REFERENCE_TYPE
)
4952 op1
= convert_from_reference (op1
);
4953 type1
= TREE_TYPE (op1
);
4954 code1
= TREE_CODE (type1
);
4956 if (code2
== REFERENCE_TYPE
)
4958 op2
= convert_from_reference (op2
);
4959 type2
= TREE_TYPE (op2
);
4960 code2
= TREE_CODE (type2
);
4963 /* Don't promote the operands separately if they promote
4964 the same way. Return the unpromoted type and let the combined
4965 value get promoted if necessary. */
4967 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4968 && code2
!= ARRAY_TYPE
4969 && code2
!= FUNCTION_TYPE
4970 && code2
!= METHOD_TYPE
)
4974 if (TREE_CONSTANT (ifexp
)
4975 && (TREE_CODE (ifexp
) == INTEGER_CST
4976 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4977 return (integer_zerop (ifexp
) ? op2
: op1
);
4979 if (TREE_CODE (op1
) == CONST_DECL
)
4980 op1
= DECL_INITIAL (op1
);
4981 else if (TREE_READONLY_DECL_P (op1
))
4982 op1
= decl_constant_value (op1
);
4983 if (TREE_CODE (op2
) == CONST_DECL
)
4984 op2
= DECL_INITIAL (op2
);
4985 else if (TREE_READONLY_DECL_P (op2
))
4986 op2
= decl_constant_value (op2
);
4988 type1
= cp_build_qualified_type
4989 (type1
, (CP_TYPE_QUALS (TREE_TYPE (op1
))
4990 | CP_TYPE_QUALS (TREE_TYPE (op2
))));
4991 /* ??? This is a kludge to deal with the fact that
4992 we don't sort out integers and enums properly, yet. */
4993 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4994 if (TREE_TYPE (result
) != type1
)
4995 result
= build1 (NOP_EXPR
, type1
, result
);
4996 /* Expand both sides into the same slot,
4997 hopefully the target of the ?: expression. */
4998 if (TREE_CODE (op1
) == TARGET_EXPR
&& TREE_CODE (op2
) == TARGET_EXPR
)
5000 tree slot
= build (VAR_DECL
, TREE_TYPE (result
));
5001 layout_decl (slot
, 0);
5002 result
= build (TARGET_EXPR
, TREE_TYPE (result
),
5003 slot
, result
, NULL_TREE
, NULL_TREE
);
5008 /* They don't match; promote them both and then try to reconcile them.
5009 But don't permit mismatching enum types. */
5010 if (code1
== ENUMERAL_TYPE
)
5012 if (code2
== ENUMERAL_TYPE
)
5014 cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'",
5016 return error_mark_node
;
5018 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
)
5019 && type2
!= type_promotes_to (type1
))
5020 warning ("enumeral and non-enumeral type in conditional expression");
5022 else if (extra_warnings
5023 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
)
5024 && type1
!= type_promotes_to (type2
))
5025 warning ("enumeral and non-enumeral type in conditional expression");
5027 if (code1
!= VOID_TYPE
)
5029 op1
= default_conversion (op1
);
5030 type1
= TREE_TYPE (op1
);
5031 if (TYPE_PTRMEMFUNC_P (type1
))
5032 type1
= TYPE_PTRMEMFUNC_FN_TYPE (type1
);
5033 code1
= TREE_CODE (type1
);
5035 if (code2
!= VOID_TYPE
)
5037 op2
= default_conversion (op2
);
5038 type2
= TREE_TYPE (op2
);
5039 if (TYPE_PTRMEMFUNC_P (type2
))
5040 type2
= TYPE_PTRMEMFUNC_FN_TYPE (type2
);
5041 code2
= TREE_CODE (type2
);
5044 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
5045 && real_lvalue_p (op1
) && real_lvalue_p (op2
)
5046 && comptypes (type1
, type2
, COMPARE_BASE
| COMPARE_RELAXED
))
5048 type1
= build_reference_type (type1
);
5049 type2
= build_reference_type (type2
);
5050 result_type
= common_type (type1
, type2
);
5051 op1
= convert_to_reference (result_type
, op1
, CONV_IMPLICIT
,
5052 LOOKUP_NORMAL
, NULL_TREE
);
5053 op2
= convert_to_reference (result_type
, op2
, CONV_IMPLICIT
,
5054 LOOKUP_NORMAL
, NULL_TREE
);
5056 /* Quickly detect the usual case where op1 and op2 have the same type
5058 else if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
5061 result_type
= type1
;
5064 cp_build_qualified_type (type1
,
5065 CP_TYPE_QUALS (TREE_TYPE (op1
))
5066 | CP_TYPE_QUALS (TREE_TYPE (op2
)));
5068 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
5069 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
5071 result_type
= common_type (type1
, type2
);
5073 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
5075 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
5076 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
5077 result_type
= void_type_node
;
5079 else if (code1
== POINTER_TYPE
&& null_ptr_cst_p (op2
))
5080 result_type
= qualify_type (type1
, type2
);
5081 else if (code2
== POINTER_TYPE
&& null_ptr_cst_p (op1
))
5082 result_type
= qualify_type (type2
, type1
);
5083 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
5085 if (comp_target_types (type1
, type2
, 1))
5086 result_type
= common_type (type1
, type2
);
5087 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
5089 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
5090 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5091 result_type
= qualify_type (type1
, type2
);
5093 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
5095 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
5096 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
5097 result_type
= qualify_type (type2
, type1
);
5100 else if (same_or_base_type_p (type2
, type1
))
5101 result_type
= type2
;
5102 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
5103 && IS_AGGR_TYPE (TREE_TYPE (type2
))
5104 && (result_type
= common_base_type (TREE_TYPE (type1
),
5105 TREE_TYPE (type2
))))
5107 if (result_type
== error_mark_node
)
5109 cp_error ("common base type of types `%T' and `%T' is ambiguous",
5110 TREE_TYPE (type1
), TREE_TYPE (type2
));
5111 result_type
= ptr_type_node
;
5116 && result_type
!= TREE_TYPE (type1
)
5117 && result_type
!= TREE_TYPE (type2
))
5118 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
5119 type1
, type2
, result_type
);
5121 result_type
= build_pointer_type (result_type
);
5126 pedwarn ("pointer type mismatch in conditional expression");
5127 result_type
= ptr_type_node
;
5130 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
5132 pedwarn ("pointer/integer type mismatch in conditional expression");
5133 result_type
= type1
;
5135 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5137 pedwarn ("pointer/integer type mismatch in conditional expression");
5138 result_type
= type2
;
5140 if (type2
== unknown_type_node
)
5141 result_type
= type1
;
5142 else if (type1
== unknown_type_node
)
5143 result_type
= type2
;
5147 /* The match does not look good. If either is
5148 an aggregate value, try converting to a scalar type. */
5149 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
5151 cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'",
5153 return error_mark_node
;
5155 /* Warning: this code assumes that conversion between cv-variants of
5156 a type is done using NOP_EXPRs. */
5157 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
5159 /* There are other types besides pointers and records. */
5161 if (code2
== POINTER_TYPE
)
5162 tmp
= build_pointer_type
5163 (cp_build_qualified_type (TREE_TYPE (type2
),
5165 | TYPE_QUAL_VOLATILE
5166 | TYPE_QUAL_RESTRICT
));
5169 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op1
, 0);
5170 if (tmp
== NULL_TREE
)
5172 cp_error ("incompatible types `%T' and `%T' in `?:'",
5174 return error_mark_node
;
5176 if (tmp
== error_mark_node
)
5177 error ("ambiguous pointer conversion");
5180 result_type
= common_type (type2
, TREE_TYPE (tmp
));
5183 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
5186 if (code1
== POINTER_TYPE
)
5187 tmp
= build_pointer_type
5188 (cp_build_qualified_type (TREE_TYPE (type1
),
5190 | TYPE_QUAL_VOLATILE
5191 | TYPE_QUAL_RESTRICT
));
5195 tmp
= build_type_conversion (CONVERT_EXPR
, tmp
, op2
, 0);
5196 if (tmp
== NULL_TREE
)
5198 cp_error ("incompatible types `%T' and `%T' in `?:'",
5200 return error_mark_node
;
5202 if (tmp
== error_mark_node
)
5203 error ("ambiguous pointer conversion");
5206 result_type
= common_type (type1
, TREE_TYPE (tmp
));
5209 else if (flag_cond_mismatch
)
5210 result_type
= void_type_node
;
5213 error ("type mismatch in conditional expression");
5214 return error_mark_node
;
5218 if (TREE_CODE (result_type
) == POINTER_TYPE
5219 && TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
5220 result_type
= build_ptrmemfunc_type (result_type
);
5222 if (result_type
!= TREE_TYPE (op1
))
5223 op1
= convert_for_initialization
5224 (NULL_TREE
, result_type
, op1
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5225 if (result_type
!= TREE_TYPE (op2
))
5226 op2
= convert_for_initialization
5227 (NULL_TREE
, result_type
, op2
, LOOKUP_NORMAL
, "converting", NULL_TREE
, 0);
5229 if (TREE_CODE (ifexp
) == INTEGER_CST
)
5230 return integer_zerop (ifexp
) ? op2
: op1
;
5232 return convert_from_reference
5233 (fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
)));
5236 /* Handle overloading of the ',' operator when needed. Otherwise,
5237 this function just builds an expression list. */
5240 build_x_compound_expr (list
)
5243 tree rest
= TREE_CHAIN (list
);
5246 if (processing_template_decl
)
5247 return build_min_nt (COMPOUND_EXPR
, list
, NULL_TREE
);
5249 if (rest
== NULL_TREE
)
5250 return build_compound_expr (list
);
5252 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
5253 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
5255 return build_x_compound_expr (expr_tree_cons (NULL_TREE
, result
,
5256 TREE_CHAIN (rest
)));
5258 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
5260 /* the left-hand operand of a comma expression is like an expression
5261 statement: we should warn if it doesn't have any side-effects,
5262 unless it was explicitly cast to (void). */
5263 if ((extra_warnings
|| warn_unused
)
5264 && !(TREE_CODE (TREE_VALUE(list
)) == CONVERT_EXPR
5265 && TREE_TYPE (TREE_VALUE(list
)) == void_type_node
))
5266 warning("left-hand operand of comma expression has no effect");
5268 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
5269 else if (warn_unused
)
5270 warn_if_unused_value (TREE_VALUE(list
));
5273 return build_compound_expr
5274 (expr_tree_cons (NULL_TREE
, TREE_VALUE (list
),
5275 build_expr_list (NULL_TREE
,
5276 build_x_compound_expr (rest
))));
5279 /* Given a list of expressions, return a compound expression
5280 that performs them all and returns the value of the last of them. */
5283 build_compound_expr (list
)
5288 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
5289 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
5291 if (TREE_CHAIN (list
) == 0)
5293 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5294 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
5295 if (TREE_CODE (list
) == NOP_EXPR
5296 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
5297 list
= TREE_OPERAND (list
, 0);
5299 /* Convert arrays to pointers. */
5300 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
5301 return default_conversion (TREE_VALUE (list
));
5303 return TREE_VALUE (list
);
5306 rest
= build_compound_expr (TREE_CHAIN (list
));
5308 /* When pedantic, a compound expression cannot be a constant expression. */
5309 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
5312 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
5313 break_out_cleanups (TREE_VALUE (list
)), rest
);
5317 build_static_cast (type
, expr
)
5323 if (type
== error_mark_node
|| expr
== error_mark_node
)
5324 return error_mark_node
;
5326 if (TREE_CODE (expr
) == OFFSET_REF
)
5327 expr
= resolve_offset_ref (expr
);
5329 if (processing_template_decl
)
5331 tree t
= build_min (STATIC_CAST_EXPR
, copy_to_permanent (type
),
5336 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5337 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5338 if (TREE_CODE (type
) != REFERENCE_TYPE
5339 && TREE_CODE (expr
) == NOP_EXPR
5340 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5341 expr
= TREE_OPERAND (expr
, 0);
5343 if (TREE_CODE (type
) == VOID_TYPE
)
5344 return build1 (CONVERT_EXPR
, type
, expr
);
5346 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5347 return (convert_from_reference
5348 (convert_to_reference (type
, expr
, CONV_STATIC
|CONV_IMPLICIT
,
5349 LOOKUP_COMPLAIN
, NULL_TREE
)));
5351 if (IS_AGGR_TYPE (type
))
5352 return build_cplus_new
5353 (type
, (build_method_call
5354 (NULL_TREE
, ctor_identifier
, build_expr_list (NULL_TREE
, expr
),
5355 TYPE_BINFO (type
), LOOKUP_NORMAL
)));
5357 expr
= decay_conversion (expr
);
5358 intype
= TREE_TYPE (expr
);
5360 /* FIXME handle casting to array type. */
5363 if (can_convert_arg (type
, intype
, expr
))
5365 else if (TYPE_PTROB_P (type
) && TYPE_PTROB_P (intype
))
5368 if (IS_AGGR_TYPE (TREE_TYPE (type
)) && IS_AGGR_TYPE (TREE_TYPE (intype
))
5369 && at_least_as_qualified_p (TREE_TYPE (type
),
5371 && (binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 0))
5372 && ! TREE_VIA_VIRTUAL (binfo
))
5375 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5377 if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
))),
5378 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (intype
))))
5379 && at_least_as_qualified_p (TREE_TYPE (TREE_TYPE (type
)),
5380 TREE_TYPE (TREE_TYPE (intype
)))
5381 && (binfo
= get_binfo (TYPE_OFFSET_BASETYPE (TREE_TYPE (type
)),
5382 TYPE_OFFSET_BASETYPE (TREE_TYPE (intype
)), 0))
5383 && ! TREE_VIA_VIRTUAL (binfo
))
5386 else if (TREE_CODE (intype
) != BOOLEAN_TYPE
5387 && TREE_CODE (type
) != ARRAY_TYPE
5388 && TREE_CODE (type
) != FUNCTION_TYPE
5389 && can_convert (intype
, type
))
5393 return build_c_cast (type
, expr
);
5395 cp_error ("static_cast from `%T' to `%T'", intype
, type
);
5396 return error_mark_node
;
5400 build_reinterpret_cast (type
, expr
)
5405 if (type
== error_mark_node
|| expr
== error_mark_node
)
5406 return error_mark_node
;
5408 if (TREE_CODE (expr
) == OFFSET_REF
)
5409 expr
= resolve_offset_ref (expr
);
5411 if (processing_template_decl
)
5413 tree t
= build_min (REINTERPRET_CAST_EXPR
,
5414 copy_to_permanent (type
), expr
);
5418 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5420 expr
= decay_conversion (expr
);
5422 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5423 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5424 if (TREE_CODE (expr
) == NOP_EXPR
5425 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5426 expr
= TREE_OPERAND (expr
, 0);
5429 intype
= TREE_TYPE (expr
);
5431 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5433 if (! real_lvalue_p (expr
))
5435 cp_error ("reinterpret_cast from `%T' rvalue to `%T'", intype
, type
);
5436 return error_mark_node
;
5438 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5439 if (expr
!= error_mark_node
)
5440 expr
= build_reinterpret_cast
5441 (build_pointer_type (TREE_TYPE (type
)), expr
);
5442 if (expr
!= error_mark_node
)
5443 expr
= build_indirect_ref (expr
, 0);
5446 else if (same_type_p (TYPE_MAIN_VARIANT (intype
),
5447 TYPE_MAIN_VARIANT (type
)))
5448 return build_static_cast (type
, expr
);
5450 if (TYPE_PTR_P (type
) && (TREE_CODE (intype
) == INTEGER_TYPE
5451 || TREE_CODE (intype
) == ENUMERAL_TYPE
))
5453 else if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_PTR_P (intype
))
5455 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
5456 cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5459 else if ((TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
5460 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
5462 if (TREE_READONLY_DECL_P (expr
))
5463 expr
= decl_constant_value (expr
);
5464 return fold (build1 (NOP_EXPR
, type
, expr
));
5466 else if ((TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
5467 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
5469 if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type
), TREE_TYPE (intype
)))
5470 cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5473 if (TREE_READONLY_DECL_P (expr
))
5474 expr
= decl_constant_value (expr
);
5475 return fold (build1 (NOP_EXPR
, type
, expr
));
5477 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
5478 || (TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
)))
5480 pedwarn ("ANSI C++ forbids casting between pointers to functions and objects");
5481 if (TREE_READONLY_DECL_P (expr
))
5482 expr
= decl_constant_value (expr
);
5483 return fold (build1 (NOP_EXPR
, type
, expr
));
5487 cp_error ("reinterpret_cast from `%T' to `%T'", intype
, type
);
5488 return error_mark_node
;
5491 return cp_convert (type
, expr
);
5495 build_const_cast (type
, expr
)
5500 if (type
== error_mark_node
|| expr
== error_mark_node
)
5501 return error_mark_node
;
5503 if (TREE_CODE (expr
) == OFFSET_REF
)
5504 expr
= resolve_offset_ref (expr
);
5506 if (processing_template_decl
)
5508 tree t
= build_min (CONST_CAST_EXPR
, copy_to_permanent (type
),
5513 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5515 expr
= decay_conversion (expr
);
5517 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5518 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5519 if (TREE_CODE (expr
) == NOP_EXPR
5520 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
5521 expr
= TREE_OPERAND (expr
, 0);
5524 intype
= TREE_TYPE (expr
);
5526 if (same_type_p (TYPE_MAIN_VARIANT (intype
), TYPE_MAIN_VARIANT (type
)))
5527 return build_static_cast (type
, expr
);
5528 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5530 if (! real_lvalue_p (expr
))
5532 cp_error ("const_cast from `%T' rvalue to `%T'", intype
, type
);
5533 return error_mark_node
;
5536 if (comp_ptr_ttypes_const (TREE_TYPE (type
), intype
))
5538 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5539 expr
= build1 (NOP_EXPR
, type
, expr
);
5540 return convert_from_reference (expr
);
5543 else if (TREE_CODE (type
) == POINTER_TYPE
5544 && TREE_CODE (intype
) == POINTER_TYPE
5545 && comp_ptr_ttypes_const (TREE_TYPE (type
), TREE_TYPE (intype
)))
5546 return cp_convert (type
, expr
);
5548 cp_error ("const_cast from `%T' to `%T'", intype
, type
);
5549 return error_mark_node
;
5552 /* Build an expression representing a cast to type TYPE of expression EXPR.
5554 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5555 when doing the cast. */
5558 build_c_cast (type
, expr
)
5561 register tree value
= expr
;
5564 if (type
== error_mark_node
|| expr
== error_mark_node
)
5565 return error_mark_node
;
5567 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5568 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5569 if (TREE_CODE (type
) != REFERENCE_TYPE
5570 && TREE_CODE (value
) == NOP_EXPR
5571 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5572 value
= TREE_OPERAND (value
, 0);
5574 if (TREE_TYPE (expr
)
5575 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
5576 && TREE_CODE (type
) != OFFSET_TYPE
)
5577 value
= resolve_offset_ref (value
);
5579 if (TREE_CODE (type
) == ARRAY_TYPE
)
5581 /* Allow casting from T1* to T2[] because Cfront allows it.
5582 NIHCL uses it. It is not valid ANSI C however, and hence, not
5584 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5587 pedwarn ("ANSI C++ forbids casting to an array type");
5588 type
= build_pointer_type (TREE_TYPE (type
));
5592 error ("ANSI C++ forbids casting to an array type");
5593 return error_mark_node
;
5597 if (TREE_CODE (type
) == FUNCTION_TYPE
5598 || TREE_CODE (type
) == METHOD_TYPE
)
5600 cp_error ("casting to function type `%T'", type
);
5601 return error_mark_node
;
5604 if (IS_SIGNATURE (type
))
5606 error ("cast specifies signature type");
5607 return error_mark_node
;
5610 if (processing_template_decl
)
5612 tree t
= build_min (CAST_EXPR
, type
,
5613 min_tree_cons (NULL_TREE
, value
, NULL_TREE
));
5617 /* Convert functions and arrays to pointers and
5618 convert references to their expanded types,
5619 but don't convert any other types. If, however, we are
5620 casting to a class type, there's no reason to do this: the
5621 cast will only succeed if there is a converting constructor,
5622 and the default conversions will be done at that point. In
5623 fact, doing the default conversion here is actually harmful
5627 struct S { S(const A&); };
5629 since we don't want the array-to-pointer conversion done. */
5630 if (!IS_AGGR_TYPE (type
))
5632 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5633 || (TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
5634 /* Don't do the default conversion if we want a
5635 pointer to a function. */
5636 && ! (TREE_CODE (type
) == POINTER_TYPE
5637 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
5638 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5639 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5640 value
= default_conversion (value
);
5642 else if (TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5643 /* However, even for class types, we still need to strip away
5644 the reference type, since the call to convert_force below
5645 does not expect the input expression to be of reference
5647 value
= convert_from_reference (value
);
5649 otype
= TREE_TYPE (value
);
5651 /* Optionally warn about potentially worrisome casts. */
5654 && TREE_CODE (type
) == POINTER_TYPE
5655 && TREE_CODE (otype
) == POINTER_TYPE
5656 && !at_least_as_qualified_p (TREE_TYPE (type
),
5658 cp_warning ("cast discards qualifiers from pointer target type");
5660 /* Warn about possible alignment problems. */
5661 if (STRICT_ALIGNMENT
&& warn_cast_align
5662 && TREE_CODE (type
) == POINTER_TYPE
5663 && TREE_CODE (otype
) == POINTER_TYPE
5664 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5665 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5666 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5667 warning ("cast increases required alignment of target type");
5670 /* We should see about re-enabling these, they seem useful to
5672 if (TREE_CODE (type
) == INTEGER_TYPE
5673 && TREE_CODE (otype
) == POINTER_TYPE
5674 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5675 warning ("cast from pointer to integer of different size");
5677 if (TREE_CODE (type
) == POINTER_TYPE
5678 && TREE_CODE (otype
) == INTEGER_TYPE
5679 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5680 /* Don't warn about converting 0 to pointer,
5681 provided the 0 was explicit--not cast or made by folding. */
5682 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5683 warning ("cast to pointer from integer of different size");
5686 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5687 value
= (convert_from_reference
5688 (convert_to_reference (type
, value
, CONV_C_CAST
,
5689 LOOKUP_COMPLAIN
, NULL_TREE
)));
5694 if (TREE_READONLY_DECL_P (value
))
5695 value
= decl_constant_value (value
);
5698 value
= convert_force (type
, value
, CONV_C_CAST
);
5700 /* Ignore any integer overflow caused by the cast. */
5701 if (TREE_CODE (value
) == INTEGER_CST
)
5703 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5704 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5708 /* Always produce some operator for an explicit cast,
5709 so we can tell (for -pedantic) that the cast is no lvalue. */
5710 if (TREE_CODE (type
) != REFERENCE_TYPE
&& value
== expr
5711 && real_lvalue_p (value
))
5712 value
= non_lvalue (value
);
5717 /* Build an assignment expression of lvalue LHS from value RHS.
5718 MODIFYCODE is the code for a binary operator that we use
5719 to combine the old value of LHS with RHS to get the new value.
5720 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5722 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
5725 build_modify_expr (lhs
, modifycode
, rhs
)
5727 enum tree_code modifycode
;
5730 register tree result
;
5732 tree lhstype
= TREE_TYPE (lhs
);
5733 tree olhstype
= lhstype
;
5736 /* Avoid duplicate error messages from operands that had errors. */
5737 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
5738 return error_mark_node
;
5740 /* Types that aren't fully specified cannot be used in assignments. */
5741 lhs
= require_complete_type (lhs
);
5745 /* Handle assignment to signature pointers/refs. */
5747 if (TYPE_LANG_SPECIFIC (lhstype
)
5748 && (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5750 return build_signature_pointer_constructor (lhs
, rhs
);
5753 /* Handle control structure constructs used as "lvalues". */
5755 switch (TREE_CODE (lhs
))
5757 /* Handle --foo = 5; as these are valid constructs in C++ */
5758 case PREDECREMENT_EXPR
:
5759 case PREINCREMENT_EXPR
:
5760 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5761 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5762 stabilize_reference (TREE_OPERAND (lhs
, 0)),
5763 TREE_OPERAND (lhs
, 1));
5764 return build (COMPOUND_EXPR
, lhstype
,
5766 build_modify_expr (TREE_OPERAND (lhs
, 0),
5769 /* Handle (a, b) used as an "lvalue". */
5771 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5773 if (newrhs
== error_mark_node
)
5774 return error_mark_node
;
5775 return build (COMPOUND_EXPR
, lhstype
,
5776 TREE_OPERAND (lhs
, 0), newrhs
);
5779 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5780 if (newrhs
== error_mark_node
)
5781 return error_mark_node
;
5782 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5784 /* Handle (a ? b : c) used as an "lvalue". */
5786 rhs
= save_expr (rhs
);
5788 /* Produce (a ? (b = rhs) : (c = rhs))
5789 except that the RHS goes through a save-expr
5790 so the code to compute it is only emitted once. */
5792 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5793 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5795 build_modify_expr (cp_convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5797 if (cond
== error_mark_node
)
5799 /* Make sure the code to compute the rhs comes out
5800 before the split. */
5801 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5802 /* Case to void to suppress warning
5803 from warn_if_unused_value. */
5804 cp_convert (void_type_node
, rhs
), cond
);
5811 if (TREE_CODE (lhs
) == OFFSET_REF
)
5813 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5815 /* Static class member? */
5816 tree member
= TREE_OPERAND (lhs
, 1);
5817 if (TREE_CODE (member
) == VAR_DECL
)
5821 compiler_error ("invalid static class member");
5822 return error_mark_node
;
5826 lhs
= resolve_offset_ref (lhs
);
5828 olhstype
= lhstype
= TREE_TYPE (lhs
);
5831 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5832 && modifycode
!= INIT_EXPR
)
5834 lhs
= convert_from_reference (lhs
);
5835 olhstype
= lhstype
= TREE_TYPE (lhs
);
5838 /* If a binary op has been requested, combine the old LHS value with the RHS
5839 producing the value we should actually store into the LHS. */
5841 if (modifycode
== INIT_EXPR
)
5843 if (! IS_AGGR_TYPE (lhstype
))
5844 /* Do the default thing */;
5847 result
= build_method_call (lhs
, ctor_identifier
,
5848 build_expr_list (NULL_TREE
, rhs
),
5849 TYPE_BINFO (lhstype
), LOOKUP_NORMAL
);
5850 if (result
== NULL_TREE
)
5851 return error_mark_node
;
5855 else if (modifycode
== NOP_EXPR
)
5857 /* `operator=' is not an inheritable operator. */
5858 if (! IS_AGGR_TYPE (lhstype
))
5859 /* Do the default thing */;
5862 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5863 lhs
, rhs
, make_node (NOP_EXPR
));
5864 if (result
== NULL_TREE
)
5865 return error_mark_node
;
5870 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5872 my_friendly_abort (978652);
5876 lhs
= stabilize_reference (lhs
);
5877 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5878 if (newrhs
== error_mark_node
)
5880 cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode
,
5881 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
5882 return error_mark_node
;
5886 /* Handle a cast used as an "lvalue".
5887 We have already performed any binary operator using the value as cast.
5888 Now convert the result to the cast type of the lhs,
5889 and then true type of the lhs and store it there;
5890 then convert result back to the cast type to be the value
5891 of the assignment. */
5893 switch (TREE_CODE (lhs
))
5898 case FIX_TRUNC_EXPR
:
5899 case FIX_FLOOR_EXPR
:
5900 case FIX_ROUND_EXPR
:
5902 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5903 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5904 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5905 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5906 newrhs
= default_conversion (newrhs
);
5908 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5911 /* WP 5.4.1: The result is an lvalue if T is a reference type,
5912 otherwise the result is an rvalue. */
5913 if (! lvalue_p (lhs
))
5914 pedwarn ("ANSI C++ forbids cast to non-reference type used as lvalue");
5916 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5917 cp_convert (TREE_TYPE (inner_lhs
),
5918 cp_convert (lhstype
, newrhs
)));
5919 if (result
== error_mark_node
)
5921 return cp_convert (TREE_TYPE (lhs
), result
);
5928 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5929 Reject anything strange now. */
5931 if (!lvalue_or_else (lhs
, "assignment"))
5932 return error_mark_node
;
5934 GNU_xref_assign (lhs
);
5936 /* Warn about storing in something that is `const'. */
5937 /* For C++, don't warn if this is initialization. */
5938 if (modifycode
!= INIT_EXPR
5939 /* For assignment to `const' signature pointer/reference fields,
5940 don't warn either, we already printed a better message before. */
5941 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5942 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5943 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5944 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
5945 /* Functions are not modifiable, even though they are
5947 || TREE_CODE (TREE_TYPE (lhs
)) == FUNCTION_TYPE
5948 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5949 || TREE_CODE (lhstype
) == UNION_TYPE
)
5950 && C_TYPE_FIELDS_READONLY (lhstype
))
5951 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5952 && CP_TYPE_CONST_P (TREE_TYPE (lhstype
)))))
5953 readonly_error (lhs
, "assignment", 0);
5955 /* If storing into a structure or union member,
5956 it has probably been given type `int'.
5957 Compute the type that would go with
5958 the actual amount of storage the member occupies. */
5960 if (TREE_CODE (lhs
) == COMPONENT_REF
5961 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5962 || TREE_CODE (lhstype
) == REAL_TYPE
5963 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5965 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5967 /* If storing in a field that is in actuality a short or narrower
5968 than one, we must store in the field in its actual type. */
5970 if (lhstype
!= TREE_TYPE (lhs
))
5972 lhs
= copy_node (lhs
);
5973 TREE_TYPE (lhs
) = lhstype
;
5977 /* check to see if there is an assignment to `this' */
5978 if (lhs
== current_class_ptr
)
5980 if (flag_this_is_variable
> 0
5981 && DECL_NAME (current_function_decl
) != NULL_TREE
5982 && (DECL_NAME (current_function_decl
)
5983 != constructor_name (current_class_type
)))
5984 warning ("assignment to `this' not in constructor or destructor");
5985 current_function_just_assigned_this
= 1;
5988 if (modifycode
!= INIT_EXPR
)
5990 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5991 modifycode
= NOP_EXPR
;
5992 /* Reference-bashing */
5993 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5995 tree tmp
= convert_from_reference (lhs
);
5996 lhstype
= TREE_TYPE (tmp
);
5997 if (TYPE_SIZE (lhstype
) == 0)
5999 incomplete_type_error (lhs
, lhstype
);
6000 return error_mark_node
;
6005 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
6007 tree tmp
= convert_from_reference (newrhs
);
6008 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
6010 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
6011 return error_mark_node
;
6017 if (TREE_SIDE_EFFECTS (lhs
))
6018 lhs
= stabilize_reference (lhs
);
6019 if (TREE_SIDE_EFFECTS (newrhs
))
6020 newrhs
= stabilize_reference (newrhs
);
6022 /* Convert new value to destination type. */
6024 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
6028 if (!same_or_base_type_p (lhstype
, TREE_TYPE (rhs
)))
6030 cp_error ("incompatible types in assignment of `%T' to `%T'",
6031 TREE_TYPE (rhs
), lhstype
);
6032 return error_mark_node
;
6035 /* Allow array assignment in compiler-generated code. */
6036 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
6037 pedwarn ("ANSI C++ forbids assignment of arrays");
6039 /* Have to wrap this in RTL_EXPR for two cases:
6040 in base or member initialization and if we
6041 are a branch of a ?: operator. Since we
6042 can't easily know the latter, just do it always. */
6044 result
= make_node (RTL_EXPR
);
6046 TREE_TYPE (result
) = void_type_node
;
6047 do_pending_stack_adjust ();
6048 start_sequence_for_rtl_expr (result
);
6050 /* As a matter of principle, `start_sequence' should do this. */
6053 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6054 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6055 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
6058 do_pending_stack_adjust ();
6060 TREE_SIDE_EFFECTS (result
) = 1;
6061 RTL_EXPR_SEQUENCE (result
) = get_insns ();
6062 RTL_EXPR_RTL (result
) = const0_rtx
;
6067 if (modifycode
== INIT_EXPR
)
6069 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
6070 "assignment", NULL_TREE
, 0);
6071 if (lhs
== DECL_RESULT (current_function_decl
))
6073 if (DECL_INITIAL (lhs
))
6074 warning ("return value from function receives multiple initializations");
6075 DECL_INITIAL (lhs
) = newrhs
;
6080 /* Avoid warnings on enum bit fields. */
6081 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
6082 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
6084 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6086 newrhs
= convert_force (lhstype
, newrhs
, 0);
6089 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
6091 if (TREE_CODE (newrhs
) == CALL_EXPR
6092 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6093 newrhs
= build_cplus_new (lhstype
, newrhs
);
6095 /* Can't initialize directly from a TARGET_EXPR, since that would
6096 cause the lhs to be constructed twice, and possibly result in
6097 accidental self-initialization. So we force the TARGET_EXPR to be
6098 expanded without a target. */
6099 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6100 newrhs
= build (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
6101 TREE_OPERAND (newrhs
, 0));
6104 if (newrhs
== error_mark_node
)
6105 return error_mark_node
;
6107 if (TREE_CODE (newrhs
) == COND_EXPR
)
6110 tree cond
= TREE_OPERAND (newrhs
, 0);
6112 if (TREE_SIDE_EFFECTS (lhs
))
6113 cond
= build_compound_expr (tree_cons
6115 build_expr_list (NULL_TREE
, cond
)));
6117 /* Cannot have two identical lhs on this one tree (result) as preexpand
6118 calls will rip them out and fill in RTL for them, but when the
6119 rtl is generated, the calls will only be in the first side of the
6120 condition, not on both, or before the conditional jump! (mrs) */
6121 lhs1
= break_out_calls (lhs
);
6124 /* If there's no change, the COND_EXPR behaves like any other rhs. */
6125 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6126 lhstype
, lhs
, newrhs
);
6129 tree result_type
= TREE_TYPE (newrhs
);
6130 /* We have to convert each arm to the proper type because the
6131 types may have been munged by constant folding. */
6133 = build (COND_EXPR
, result_type
, cond
,
6134 build_modify_expr (lhs
, modifycode
,
6135 cp_convert (result_type
,
6136 TREE_OPERAND (newrhs
, 1))),
6137 build_modify_expr (lhs1
, modifycode
,
6138 cp_convert (result_type
,
6139 TREE_OPERAND (newrhs
, 2))));
6143 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6144 lhstype
, lhs
, newrhs
);
6146 TREE_SIDE_EFFECTS (result
) = 1;
6148 /* If we got the LHS in a different type for storing in,
6149 convert the result back to the nominal type of LHS
6150 so that the value we return always has the same type
6151 as the LHS argument. */
6153 if (olhstype
== TREE_TYPE (result
))
6155 /* Avoid warnings converting integral types back into enums
6156 for enum bit fields. */
6157 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
6158 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
6160 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
6161 TREE_NO_UNUSED_WARNING (result
) = 1;
6164 return convert_for_assignment (olhstype
, result
, "assignment",
6169 build_x_modify_expr (lhs
, modifycode
, rhs
)
6171 enum tree_code modifycode
;
6174 if (processing_template_decl
)
6175 return build_min_nt (MODOP_EXPR
, lhs
,
6176 build_min_nt (modifycode
, NULL_TREE
, NULL_TREE
), rhs
);
6178 if (modifycode
!= NOP_EXPR
)
6180 tree rval
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
, lhs
, rhs
,
6181 make_node (modifycode
));
6185 return build_modify_expr (lhs
, modifycode
, rhs
);
6189 /* Get difference in deltas for different pointer to member function
6190 types. Return integer_zero_node, if FROM cannot be converted to a
6191 TO type. If FORCE is true, then allow reverse conversions as well. */
6194 get_delta_difference (from
, to
, force
)
6198 tree delta
= integer_zero_node
;
6204 /* Should get_base_distance here, so we can check if any thing along the
6205 path is virtual, and we need to make sure we stay
6206 inside the real binfos when going through virtual bases.
6207 Maybe we should replace virtual bases with
6208 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6209 binfo
= get_binfo (from
, to
, 1);
6210 if (binfo
== error_mark_node
)
6212 error (" in pointer to member function conversion");
6219 error_not_base_type (from
, to
);
6220 error (" in pointer to member conversion");
6223 binfo
= get_binfo (to
, from
, 1);
6224 if (binfo
== 0 || binfo
== error_mark_node
)
6226 if (TREE_VIA_VIRTUAL (binfo
))
6228 binfo
= binfo_member (BINFO_TYPE (binfo
),
6229 CLASSTYPE_VBASECLASSES (from
));
6230 cp_warning ("pointer to member cast to virtual base `%T'",
6231 BINFO_TYPE (binfo
));
6232 warning (" will only work if you are very careful");
6234 delta
= BINFO_OFFSET (binfo
);
6235 delta
= cp_convert (ptrdiff_type_node
, delta
);
6237 return build_binary_op (MINUS_EXPR
,
6242 if (TREE_VIA_VIRTUAL (binfo
))
6246 cp_warning ("pointer to member cast from virtual base `%T'",
6247 BINFO_TYPE (binfo
));
6248 warning (" will only work if you are very careful");
6251 cp_error ("pointer to member conversion from virtual base `%T'",
6252 BINFO_TYPE (binfo
));
6255 return BINFO_OFFSET (binfo
);
6259 build_ptrmemfunc1 (type
, delta
, idx
, pfn
, delta2
)
6260 tree type
, delta
, idx
, pfn
, delta2
;
6265 /* This is the old way we did it. We want to avoid calling
6266 digest_init, so that it can give an error if we use { } when
6267 initializing a pointer to member function. */
6271 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6272 expr_tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6276 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6277 expr_tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6280 u
= build_nt (CONSTRUCTOR
, NULL_TREE
,
6281 expr_tree_cons (NULL_TREE
, delta
,
6282 expr_tree_cons (NULL_TREE
, idx
,
6283 expr_tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6285 return digest_init (type
, u
, (tree
*)0);
6287 tree delta_field
, idx_field
, pfn_or_delta2_field
, pfn_field
, delta2_field
;
6289 int allconstant
, allsimple
;
6291 delta_field
= TYPE_FIELDS (type
);
6292 idx_field
= TREE_CHAIN (delta_field
);
6293 pfn_or_delta2_field
= TREE_CHAIN (idx_field
);
6294 subtype
= TREE_TYPE (pfn_or_delta2_field
);
6295 pfn_field
= TYPE_FIELDS (subtype
);
6296 delta2_field
= TREE_CHAIN (pfn_field
);
6300 allconstant
= TREE_CONSTANT (pfn
);
6301 allsimple
= !! initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
));
6302 u
= expr_tree_cons (pfn_field
, pfn
, NULL_TREE
);
6306 delta2
= convert_and_check (delta_type_node
, delta2
);
6307 allconstant
= TREE_CONSTANT (delta2
);
6308 allsimple
= !! initializer_constant_valid_p (delta2
, TREE_TYPE (delta2
));
6309 u
= expr_tree_cons (delta2_field
, delta2
, NULL_TREE
);
6312 delta
= convert_and_check (delta_type_node
, delta
);
6313 idx
= convert_and_check (delta_type_node
, idx
);
6315 allconstant
= allconstant
&& TREE_CONSTANT (delta
) && TREE_CONSTANT (idx
);
6316 allsimple
= allsimple
6317 && initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
6318 && initializer_constant_valid_p (idx
, TREE_TYPE (idx
));
6320 u
= build (CONSTRUCTOR
, subtype
, NULL_TREE
, u
);
6321 u
= expr_tree_cons (delta_field
, delta
,
6322 expr_tree_cons (idx_field
, idx
,
6323 expr_tree_cons (pfn_or_delta2_field
, u
, NULL_TREE
)));
6324 u
= build (CONSTRUCTOR
, type
, NULL_TREE
, u
);
6325 TREE_CONSTANT (u
) = allconstant
;
6326 TREE_STATIC (u
) = allconstant
&& allsimple
;
6331 /* Build a constructor for a pointer to member function. It can be
6332 used to initialize global variables, local variable, or used
6333 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6336 If FORCE is non-zero, then force this conversion, even if
6337 we would rather not do it. Usually set when using an explicit
6340 Return error_mark_node, if something goes wrong. */
6343 build_ptrmemfunc (type
, pfn
, force
)
6347 tree idx
= integer_zero_node
;
6348 tree delta
= integer_zero_node
;
6349 tree delta2
= integer_zero_node
;
6351 tree npfn
= NULL_TREE
;
6353 /* Handle multiple conversions of pointer to member functions. */
6354 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6356 tree ndelta
, ndelta2
;
6360 /* Is is already the right type? */
6361 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6364 pfn_type
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
));
6366 && comp_target_types (type
, pfn_type
, 1) != 1)
6367 cp_error ("conversion to `%T' from `%T'", type
, pfn_type
);
6369 ndelta
= cp_convert (ptrdiff_type_node
, build_component_ref (pfn
, delta_identifier
, NULL_TREE
, 0));
6370 ndelta2
= cp_convert (ptrdiff_type_node
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6371 idx
= build_component_ref (pfn
, index_identifier
, NULL_TREE
, 0);
6373 n
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (pfn_type
)),
6374 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6377 delta
= build_binary_op (PLUS_EXPR
, ndelta
, n
, 1);
6378 delta2
= build_binary_op (PLUS_EXPR
, ndelta2
, n
, 1);
6379 e1
= fold (build (GT_EXPR
, boolean_type_node
, idx
, integer_zero_node
));
6381 e2
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
,
6384 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6385 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6386 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6388 e3
= build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
,
6390 return build_conditional_expr (e1
, e2
, e3
);
6393 /* Handle null pointer to member function conversions. */
6394 if (integer_zerop (pfn
))
6396 pfn
= build_c_cast (type
, integer_zero_node
);
6397 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
),
6398 integer_zero_node
, integer_zero_node
,
6402 if (type_unknown_p (pfn
))
6403 return instantiate_type (type
, pfn
, 1);
6406 && comp_target_types (type
, TREE_TYPE (pfn
), 0) != 1)
6407 cp_error ("conversion to `%T' from `%T'", type
, TREE_TYPE (pfn
));
6409 /* Allow pointer to member conversions here. */
6410 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6411 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6413 delta2
= build_binary_op (PLUS_EXPR
, delta2
, delta
, 1);
6415 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6416 warning ("assuming pointer to member function is non-virtual");
6418 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6419 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6421 /* Find the offset to the vfield pointer in the object. */
6422 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6423 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6425 vfield_offset
= get_vfield_offset (vfield_offset
);
6426 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6428 /* Map everything down one to make room for the null pointer to member. */
6429 idx
= size_binop (PLUS_EXPR
,
6430 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6435 idx
= size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
6437 if (type
== TREE_TYPE (pfn
))
6443 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6444 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6448 return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type
), delta
, idx
, npfn
, delta2
);
6451 /* Convert value RHS to type TYPE as preparation for an assignment
6452 to an lvalue of type TYPE.
6453 The real work of conversion is done by `convert'.
6454 The purpose of this function is to generate error messages
6455 for assignments that are not allowed in C.
6456 ERRTYPE is a string to use in error messages:
6457 "assignment", "return", etc.
6459 C++: attempts to allow `convert' to find conversions involving
6460 implicit type conversion between aggregate and scalar types
6461 as per 8.5.6 of C++ manual. Does not randomly dereference
6462 pointers to aggregates! */
6465 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6471 register enum tree_code codel
= TREE_CODE (type
);
6472 register tree rhstype
;
6473 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6475 /* Issue warnings about peculiar, but legal, uses of NULL. */
6476 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
6477 cp_warning ("converting NULL to non-pointer type");
6479 if (coder
== ERROR_MARK
)
6480 return error_mark_node
;
6482 if (codel
== OFFSET_TYPE
)
6484 type
= TREE_TYPE (type
);
6485 codel
= TREE_CODE (type
);
6488 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6489 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6490 rhs
= TREE_OPERAND (rhs
, 0);
6492 if (rhs
== error_mark_node
)
6493 return error_mark_node
;
6495 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
6496 return error_mark_node
;
6498 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6500 rhs
= resolve_offset_ref (rhs
);
6501 if (rhs
== error_mark_node
)
6502 return error_mark_node
;
6503 rhstype
= TREE_TYPE (rhs
);
6504 coder
= TREE_CODE (rhstype
);
6507 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6508 || is_overloaded_fn (rhs
))
6509 rhs
= default_conversion (rhs
);
6510 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6511 rhs
= convert_from_reference (rhs
);
6513 /* If rhs is some sort of overloaded function, ocp_convert will either
6514 do the right thing or complain; we don't need to check anything else.
6515 So just hand off. */
6516 if (type_unknown_p (rhs
))
6517 return ocp_convert (type
, rhs
, CONV_IMPLICIT
, LOOKUP_NORMAL
);
6519 rhstype
= TREE_TYPE (rhs
);
6520 coder
= TREE_CODE (rhstype
);
6522 /* This should no longer change types on us. */
6523 if (TREE_CODE (rhs
) == CONST_DECL
)
6524 rhs
= DECL_INITIAL (rhs
);
6525 else if (TREE_READONLY_DECL_P (rhs
))
6526 rhs
= decl_constant_value (rhs
);
6528 if (same_type_p (type
, rhstype
))
6530 overflow_warning (rhs
);
6534 if (coder
== VOID_TYPE
)
6536 error ("void value not ignored as it ought to be");
6537 return error_mark_node
;
6539 /* Arithmetic types all interconvert. */
6540 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
6541 || codel
== COMPLEX_TYPE
)
6542 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
6543 || coder
== COMPLEX_TYPE
))
6545 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6546 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6549 cp_warning ("`%T' used for argument %P of `%D'",
6550 rhstype
, parmnum
, fndecl
);
6552 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6554 /* And we should warn if assigning a negative value to
6555 an unsigned variable. */
6556 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6558 if (TREE_CODE (rhs
) == INTEGER_CST
6559 && TREE_NEGATED_INT (rhs
))
6562 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6563 rhs
, parmnum
, fndecl
);
6565 cp_warning ("%s of negative value `%E' to `%T'",
6566 errtype
, rhs
, type
);
6568 overflow_warning (rhs
);
6569 if (TREE_CONSTANT (rhs
))
6573 return convert_and_check (type
, rhs
);
6575 /* Conversions involving enums. */
6576 else if ((codel
== ENUMERAL_TYPE
6577 && (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
))
6578 || (coder
== ENUMERAL_TYPE
6579 && (INTEGRAL_CODE_P (codel
) || codel
== REAL_TYPE
)))
6581 return ocp_convert (type
, rhs
, CONV_IMPLICIT
, LOOKUP_NORMAL
);
6583 /* Conversions among pointers */
6584 else if (codel
== POINTER_TYPE
6585 && (coder
== POINTER_TYPE
6586 || (coder
== RECORD_TYPE
6587 && (IS_SIGNATURE_POINTER (rhstype
)
6588 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6590 register tree ttl
= TREE_TYPE (type
);
6594 if (coder
== RECORD_TYPE
)
6596 rhs
= build_optr_ref (rhs
);
6597 rhstype
= TREE_TYPE (rhs
);
6599 ttr
= TREE_TYPE (rhstype
);
6601 /* If both pointers are of aggregate type, then we
6602 can give better error messages, and save some work
6604 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6608 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6609 || type
== class_star_type_node
6610 || rhstype
== class_star_type_node
)
6611 binfo
= TYPE_BINFO (ttl
);
6613 binfo
= get_binfo (ttl
, ttr
, 1);
6615 if (binfo
== error_mark_node
)
6616 return error_mark_node
;
6618 return error_not_base_type (ttl
, ttr
);
6620 if (!at_least_as_qualified_p (ttl
, ttr
))
6623 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6624 rhstype
, parmnum
, fndecl
);
6626 cp_error ("%s to `%T' from `%T' discards qualifiers",
6627 errtype
, type
, rhstype
);
6631 /* Any non-function converts to a [const][volatile] void *
6632 and vice versa; otherwise, targets must be the same.
6633 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6634 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6635 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6636 || (ctt
= comp_target_types (type
, rhstype
, 1))
6637 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6638 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6640 /* ARM $4.8, commentary on p39. */
6641 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6642 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6644 cp_error ("no standard conversion from `%T' to `void *'", ttr
);
6645 return error_mark_node
;
6648 if (ctt
< 0 && TYPE_MAIN_VARIANT (ttl
) != TYPE_MAIN_VARIANT (ttr
))
6649 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6652 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6653 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6654 && ! null_ptr_cst_p (rhs
))
6656 if (coder
== RECORD_TYPE
)
6657 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6660 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6663 /* Const and volatile mean something different for function types,
6664 so the usual warnings are not appropriate. */
6665 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6666 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6668 if (TREE_CODE (ttl
) == OFFSET_TYPE
6669 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6670 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6672 error ("%s between pointer to members converting across virtual baseclasses", errtype
);
6673 return error_mark_node
;
6675 else if (!at_least_as_qualified_p (ttl
, ttr
))
6677 if (string_conv_p (type
, rhs
, 1))
6678 /* converting from string constant to char *, OK. */;
6680 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6681 rhstype
, parmnum
, fndecl
);
6683 cp_error ("%s to `%T' from `%T' discards qualifiers",
6684 errtype
, type
, rhstype
);
6686 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6687 && ! comp_target_types (type
, rhstype
, 1))
6690 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6691 rhstype
, parmnum
, fndecl
);
6693 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6694 errtype
, type
, rhstype
);
6701 int drops_quals
= 0;
6703 int unsigned_parity
;
6706 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6707 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6710 drops_quals
|= !at_least_as_qualified_p (ttl
, ttr
);
6713 && !at_least_as_qualified_p (ttr
, ttl
))
6715 left_const
&= TYPE_READONLY (ttl
);
6717 if (TREE_CODE (ttl
) != POINTER_TYPE
6718 || TREE_CODE (ttr
) != POINTER_TYPE
)
6721 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6722 if (unsigned_parity
)
6724 if (TREE_UNSIGNED (ttl
))
6725 ttr
= unsigned_type (ttr
);
6727 ttl
= unsigned_type (ttl
);
6730 if (comp_target_types (ttl
, ttr
, nptrs
) > 0)
6735 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6736 rhstype
, parmnum
, fndecl
);
6738 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6739 errtype
, type
, rhstype
);
6744 cp_error ("passing `%T' as argument %P of `%D' discards qualifiers",
6745 rhstype
, parmnum
, fndecl
);
6747 cp_error ("%s to `%T' from `%T' discards qualifiers",
6748 errtype
, type
, rhstype
);
6750 if (unsigned_parity
> 0)
6753 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6754 rhstype
, parmnum
, fndecl
);
6756 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6757 errtype
, type
, rhstype
);
6759 else if (unsigned_parity
< 0)
6762 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6763 rhstype
, parmnum
, fndecl
);
6765 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6766 errtype
, type
, rhstype
);
6769 /* C++ is not so friendly about converting function and
6770 member function pointers as C. Emit warnings here. */
6771 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6772 || TREE_CODE (ttl
) == METHOD_TYPE
)
6773 if (!same_or_base_type_p (ttl
, ttr
))
6775 warning ("conflicting function types in %s:", errtype
);
6776 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6782 cp_error ("passing `%T' as argument %P of `%D'",
6783 rhstype
, parmnum
, fndecl
);
6785 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6786 return error_mark_node
;
6789 return cp_convert (type
, rhs
);
6791 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6793 /* An explicit constant 0 can convert to a pointer,
6794 but not a 0 that results from casting or folding. */
6795 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6798 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6799 rhstype
, parmnum
, fndecl
);
6801 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6802 errtype
, type
, rhstype
);
6804 return cp_convert (type
, rhs
);
6806 else if (codel
== INTEGER_TYPE
6807 && (coder
== POINTER_TYPE
6808 || (coder
== RECORD_TYPE
6809 && (IS_SIGNATURE_POINTER (rhstype
)
6810 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6811 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6814 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6815 rhstype
, parmnum
, fndecl
);
6817 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6818 errtype
, type
, rhstype
);
6819 return cp_convert (type
, rhs
);
6821 else if (codel
== BOOLEAN_TYPE
6822 && (coder
== POINTER_TYPE
6823 || (coder
== RECORD_TYPE
6824 && (IS_SIGNATURE_POINTER (rhstype
)
6825 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6826 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6827 return cp_convert (type
, rhs
);
6830 else if (((coder
== POINTER_TYPE
6831 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6832 || integer_zerop (rhs
)
6833 || TYPE_PTRMEMFUNC_P (rhstype
))
6834 && TYPE_PTRMEMFUNC_P (type
))
6836 tree ttl
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
6837 tree ttr
= (TYPE_PTRMEMFUNC_P (rhstype
)
6838 ? TYPE_PTRMEMFUNC_FN_TYPE (rhstype
)
6840 int ctt
= (TREE_CODE (rhstype
) == INTEGER_TYPE
? 1
6841 : comp_target_types (ttl
, ttr
, 1));
6844 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6847 cp_error ("%s to `%T' from `%T'", errtype
, ttl
, ttr
);
6849 /* compatible pointer to member functions. */
6850 return build_ptrmemfunc (ttl
, rhs
, 0);
6852 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6853 return error_mark_node
;
6855 /* This should no longer happen. References are initialized via
6856 `convert_for_initialization'. They should otherwise be
6857 bashed before coming here. */
6858 else if (codel
== REFERENCE_TYPE
)
6859 my_friendly_abort (317);
6860 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6862 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6863 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6866 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6867 return cp_convert (type
, rhs
);
6868 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
6869 else if (TREE_CODE (type
) == POINTER_TYPE
6870 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
6871 || TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
6873 && TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6874 return cp_convert (type
, rhs
);
6876 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6877 return error_mark_node
;
6880 /* Convert RHS to be of type TYPE.
6881 If EXP is non-zero, it is the target of the initialization.
6882 ERRTYPE is a string to use in error messages.
6884 Two major differences between the behavior of
6885 `convert_for_assignment' and `convert_for_initialization'
6886 are that references are bashed in the former, while
6887 copied in the latter, and aggregates are assigned in
6888 the former (operator=) while initialized in the
6891 If using constructor make sure no conversion operator exists, if one does
6892 exist, an ambiguity exists.
6894 If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */
6897 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6898 tree exp
, type
, rhs
;
6904 register enum tree_code codel
= TREE_CODE (type
);
6905 register tree rhstype
;
6906 register enum tree_code coder
;
6908 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6909 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6910 if (TREE_CODE (rhs
) == NOP_EXPR
6911 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6912 && codel
!= REFERENCE_TYPE
)
6913 rhs
= TREE_OPERAND (rhs
, 0);
6915 if (rhs
== error_mark_node
6916 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6917 return error_mark_node
;
6919 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6921 rhs
= resolve_offset_ref (rhs
);
6922 if (rhs
== error_mark_node
)
6923 return error_mark_node
;
6926 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6927 rhs
= convert_from_reference (rhs
);
6929 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6930 && TREE_CODE (type
) != ARRAY_TYPE
6931 && (TREE_CODE (type
) != REFERENCE_TYPE
6932 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6933 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6934 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6935 rhs
= default_conversion (rhs
);
6937 rhstype
= TREE_TYPE (rhs
);
6938 coder
= TREE_CODE (rhstype
);
6940 if (coder
== ERROR_MARK
)
6941 return error_mark_node
;
6943 /* We accept references to incomplete types, so we can
6944 return here before checking if RHS is of complete type. */
6946 if (codel
== REFERENCE_TYPE
)
6948 /* This should eventually happen in convert_arguments. */
6949 extern int warningcount
, errorcount
;
6950 int savew
= 0, savee
= 0;
6953 savew
= warningcount
, savee
= errorcount
;
6954 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6955 exp
? exp
: error_mark_node
);
6958 if (warningcount
> savew
)
6959 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6960 else if (errorcount
> savee
)
6961 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6966 rhs
= require_complete_type (rhs
);
6967 if (rhs
== error_mark_node
)
6968 return error_mark_node
;
6970 if (exp
!= 0) exp
= require_complete_type (exp
);
6971 if (exp
== error_mark_node
)
6972 return error_mark_node
;
6974 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6975 rhstype
= TREE_TYPE (rhstype
);
6977 type
= complete_type (type
);
6979 if (TYPE_LANG_SPECIFIC (type
)
6980 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6981 return build_signature_pointer_constructor (type
, rhs
);
6983 if (IS_AGGR_TYPE (type
))
6984 return ocp_convert (type
, rhs
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
6986 if (type
== TREE_TYPE (rhs
))
6988 /* Issue warnings about peculiar, but legal, uses of NULL. We
6989 do this *before* the call to decl_constant_value so as to
6990 avoid duplicate warnings on code like `const int I = NULL;
6992 if (ARITHMETIC_TYPE_P (type
) && rhs
== null_node
)
6993 cp_warning ("converting NULL to non-pointer type");
6995 if (TREE_READONLY_DECL_P (rhs
))
6996 rhs
= decl_constant_value (rhs
);
7001 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
7004 /* Expand an ASM statement with operands, handling output operands
7005 that are not variables or INDIRECT_REFS by transforming such
7006 cases into cases that expand_asm_operands can handle.
7008 Arguments are same as for expand_asm_operands.
7010 We don't do default conversions on all inputs, because it can screw
7011 up operands that are expected to be in memory. */
7014 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
7015 tree string
, outputs
, inputs
, clobbers
;
7020 int noutputs
= list_length (outputs
);
7022 /* o[I] is the place that output number I should be written. */
7023 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
7026 /* Record the contents of OUTPUTS before it is modified. */
7027 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7028 o
[i
] = TREE_VALUE (tail
);
7030 /* Generate the ASM_OPERANDS insn;
7031 store into the TREE_VALUEs of OUTPUTS some trees for
7032 where the values were actually stored. */
7033 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
7035 /* Copy all the intermediate outputs into the specified outputs. */
7036 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7038 if (o
[i
] != TREE_VALUE (tail
))
7040 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
7041 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
7044 /* Detect modification of read-only values.
7045 (Otherwise done by build_modify_expr.) */
7048 tree type
= TREE_TYPE (o
[i
]);
7049 if (CP_TYPE_CONST_P (type
)
7050 || ((TREE_CODE (type
) == RECORD_TYPE
7051 || TREE_CODE (type
) == UNION_TYPE
)
7052 && C_TYPE_FIELDS_READONLY (type
)))
7053 readonly_error (o
[i
], "modification by `asm'", 1);
7057 /* Those MODIFY_EXPRs could do autoincrements. */
7061 /* Expand a C `return' statement.
7062 RETVAL is the expression for what to return,
7063 or a null pointer for `return;' with no value.
7065 C++: upon seeing a `return', we must call destructors on all
7066 variables in scope which had constructors called on them.
7067 This means that if in a destructor, the base class destructors
7068 must be called before returning.
7070 The RETURN statement in C++ has initialization semantics. */
7073 c_expand_return (retval
)
7076 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
7077 extern tree dtor_label
, ctor_label
;
7078 tree result
= DECL_RESULT (current_function_decl
);
7079 tree valtype
= TREE_TYPE (result
);
7081 if (TREE_THIS_VOLATILE (current_function_decl
))
7082 warning ("function declared `noreturn' has a `return' statement");
7084 if (retval
== error_mark_node
)
7086 current_function_returns_null
= 1;
7090 if (processing_template_decl
)
7092 add_tree (build_min_nt (RETURN_STMT
, retval
));
7099 error ("returning a value from a destructor");
7101 /* Can't just return from a destructor. */
7102 expand_goto (dtor_label
);
7106 if (retval
== NULL_TREE
)
7108 /* A non-named return value does not count. */
7110 if (DECL_CONSTRUCTOR_P (current_function_decl
))
7111 retval
= current_class_ptr
;
7112 else if (DECL_NAME (result
) != NULL_TREE
7113 && TREE_CODE (valtype
) != VOID_TYPE
)
7117 current_function_returns_null
= 1;
7119 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
7121 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
7123 pedwarn ("`return' with no value, in function returning non-void");
7124 /* Clear this, so finish_function won't say that we
7125 reach the end of a non-void function (which we don't,
7126 we gave a return!). */
7127 current_function_returns_null
= 0;
7131 expand_null_return ();
7135 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
7137 if (flag_this_is_variable
)
7138 error ("return from a constructor: use `this = ...' instead");
7140 error ("returning a value from a constructor");
7141 retval
= current_class_ptr
;
7144 /* Effective C++ rule 15. See also start_function. */
7146 && DECL_NAME (current_function_decl
) == ansi_opname
[(int) MODIFY_EXPR
]
7147 && retval
!= current_class_ref
)
7148 cp_warning ("`operator=' should return a reference to `*this'");
7150 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
7152 current_function_returns_null
= 1;
7153 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
7154 pedwarn ("`return' with a value, in function returning void");
7155 expand_return (retval
);
7159 /* Now deal with possible C++ hair:
7160 (1) Compute the return value.
7161 (2) If there are aggregate values with destructors which
7162 must be cleaned up, clean them (taking care
7163 not to clobber the return value).
7164 (3) If an X(X&) constructor is defined, the return
7165 value must be returned via that. */
7167 if (retval
== result
7168 || DECL_CONSTRUCTOR_P (current_function_decl
))
7169 /* It's already done for us. */;
7170 else if (TREE_TYPE (retval
) == void_type_node
)
7172 pedwarn ("return of void value in function returning non-void");
7173 expand_expr_stmt (retval
);
7178 tree functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7180 /* First convert the value to the function's return type, then
7181 to the type of return value's location to handle the
7182 case that functype is thiner than the valtype. */
7184 retval
= convert_for_initialization
7185 (NULL_TREE
, functype
, retval
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
7186 "return", NULL_TREE
, 0);
7188 retval
= convert (valtype
, retval
);
7190 if (retval
== error_mark_node
)
7192 /* Avoid warning about control reaching end of function. */
7193 expand_null_return ();
7197 /* We can't initialize a register from a AGGR_INIT_EXPR. */
7198 else if (! current_function_returns_struct
7199 && TREE_CODE (retval
) == TARGET_EXPR
7200 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
7201 retval
= build (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
7202 TREE_OPERAND (retval
, 0));
7204 /* Add some useful error checking for C++. */
7205 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
7207 tree whats_returned
;
7209 /* Sort through common things to see what it is
7210 we are returning. */
7211 whats_returned
= retval
;
7212 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
7214 whats_returned
= TREE_OPERAND (whats_returned
, 1);
7215 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7216 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7218 while (TREE_CODE (whats_returned
) == CONVERT_EXPR
7219 || TREE_CODE (whats_returned
) == NOP_EXPR
)
7220 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7221 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7223 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7224 while (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
7225 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
7227 /* Get the target. */
7228 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7229 warning ("returning reference to temporary");
7233 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
7235 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
7236 warning ("reference to non-lvalue returned");
7237 else if (TREE_CODE (TREE_TYPE (whats_returned
)) != REFERENCE_TYPE
7238 && ! TREE_STATIC (whats_returned
)
7239 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7240 && !TREE_PUBLIC (whats_returned
))
7241 cp_warning_at ("reference to local variable `%D' returned", whats_returned
);
7244 else if (TREE_CODE (retval
) == ADDR_EXPR
)
7246 tree whats_returned
= TREE_OPERAND (retval
, 0);
7248 if (TREE_CODE (whats_returned
) == VAR_DECL
7249 && DECL_NAME (whats_returned
)
7250 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned
))
7251 && !TREE_STATIC (whats_returned
)
7252 && !TREE_PUBLIC (whats_returned
))
7253 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7257 if (retval
!= NULL_TREE
7258 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7259 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7260 current_function_return_value
= retval
;
7262 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7264 /* Here RETVAL is CURRENT_CLASS_PTR, so there's nothing to do. */
7265 expand_goto (ctor_label
);
7268 if (retval
&& retval
!= result
)
7270 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7271 TREE_SIDE_EFFECTS (result
) = 1;
7274 expand_start_target_temps ();
7276 expand_return (result
);
7278 expand_end_target_temps ();
7280 current_function_returns_value
= 1;
7283 /* Start a C switch statement, testing expression EXP.
7284 Return EXP if it is valid, an error node otherwise. */
7287 c_expand_start_case (exp
)
7292 exp
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, exp
, 1);
7293 if (exp
== NULL_TREE
)
7295 error ("switch quantity not an integer");
7296 exp
= error_mark_node
;
7298 if (exp
== error_mark_node
)
7299 return error_mark_node
;
7301 exp
= default_conversion (exp
);
7302 type
= TREE_TYPE (exp
);
7303 idx
= get_unwidened (exp
, 0);
7304 /* We can't strip a conversion from a signed type to an unsigned,
7305 because if we did, int_fits_type_p would do the wrong thing
7306 when checking case values for being in range,
7307 and it's too hard to do the right thing. */
7308 if (TREE_UNSIGNED (TREE_TYPE (exp
)) == TREE_UNSIGNED (TREE_TYPE (idx
)))
7312 (1, fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
)),
7313 type
, "switch statement");
7318 /* Returns non-zero if the pointer-type FROM can be converted to the
7319 pointer-type TO via a qualification conversion. If CONSTP is -1,
7320 then we return non-zero if the pointers are similar, and the
7321 cv-qualification signature of FROM is a proper subset of that of TO.
7323 If CONSTP is positive, then all outer pointers have been
7327 comp_ptr_ttypes_real (to
, from
, constp
)
7331 int to_more_cv_qualified
= 0;
7333 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7335 if (TREE_CODE (to
) != TREE_CODE (from
))
7338 if (TREE_CODE (from
) == OFFSET_TYPE
7339 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7340 TYPE_OFFSET_BASETYPE (to
)))
7343 /* Const and volatile mean something different for function types,
7344 so the usual checks are not appropriate. */
7345 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7347 if (!at_least_as_qualified_p (to
, from
))
7350 if (!at_least_as_qualified_p (from
, to
))
7355 ++to_more_cv_qualified
;
7359 constp
&= TYPE_READONLY (to
);
7362 if (TREE_CODE (to
) != POINTER_TYPE
)
7364 same_type_p (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
))
7365 && (constp
>= 0 || to_more_cv_qualified
);
7369 /* When comparing, say, char ** to char const **, this function takes the
7370 'char *' and 'char const *'. Do not pass non-pointer types to this
7374 comp_ptr_ttypes (to
, from
)
7377 return comp_ptr_ttypes_real (to
, from
, 1);
7380 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7381 type or inheritance-related types, regardless of cv-quals. */
7384 ptr_reasonably_similar (to
, from
)
7387 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7389 if (TREE_CODE (to
) != TREE_CODE (from
))
7392 if (TREE_CODE (from
) == OFFSET_TYPE
7393 && comptypes (TYPE_OFFSET_BASETYPE (to
),
7394 TYPE_OFFSET_BASETYPE (from
),
7395 COMPARE_BASE
| COMPARE_RELAXED
))
7398 if (TREE_CODE (to
) != POINTER_TYPE
)
7400 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
7401 COMPARE_BASE
| COMPARE_RELAXED
);
7405 /* Like comp_ptr_ttypes, for const_cast. */
7408 comp_ptr_ttypes_const (to
, from
)
7411 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7413 if (TREE_CODE (to
) != TREE_CODE (from
))
7416 if (TREE_CODE (from
) == OFFSET_TYPE
7417 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
7418 TYPE_OFFSET_BASETYPE (to
)))
7421 if (TREE_CODE (to
) != POINTER_TYPE
)
7422 return same_type_p (TYPE_MAIN_VARIANT (to
),
7423 TYPE_MAIN_VARIANT (from
));
7427 /* Like comp_ptr_ttypes, for reinterpret_cast. */
7430 comp_ptr_ttypes_reinterpret (to
, from
)
7435 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7437 if (TREE_CODE (from
) == OFFSET_TYPE
)
7438 from
= TREE_TYPE (from
);
7439 if (TREE_CODE (to
) == OFFSET_TYPE
)
7440 to
= TREE_TYPE (to
);
7442 if (TREE_CODE (to
) != TREE_CODE (from
))
7445 /* Const and volatile mean something different for function types,
7446 so the usual checks are not appropriate. */
7447 if (TREE_CODE (to
) != FUNCTION_TYPE
&& TREE_CODE (to
) != METHOD_TYPE
)
7449 if (!at_least_as_qualified_p (to
, from
))
7453 && !at_least_as_qualified_p (from
, to
))
7455 constp
&= TYPE_READONLY (to
);
7458 if (TREE_CODE (to
) != POINTER_TYPE
)
7463 /* Returns the type-qualifier set corresponding to TYPE. */
7466 cp_type_quals (type
)
7469 while (TREE_CODE (type
) == ARRAY_TYPE
)
7470 type
= TREE_TYPE (type
);
7472 return TYPE_QUALS (type
);