1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This file is part of the C++ front end.
23 It contains routines to build C++ expressions given their operands,
24 including computing the types of the result, C and C++ specific error
25 checks, and some optimization.
27 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
28 and to process initializations in declarations (since they work
29 like a strange sort of assignment). */
32 extern void warning ();
42 int mark_addressable ();
43 static tree
convert_for_assignment ();
44 /* static */ tree
convert_for_initialization ();
45 extern tree
shorten_compare ();
46 extern void binary_op_error ();
47 static tree
pointer_int_sum ();
48 static tree
pointer_diff ();
49 static tree
convert_sequence ();
50 /* static */ tree
unary_complex_lvalue ();
51 static tree get_delta_difference
PROTO((tree
, tree
, int));
53 extern rtx original_result_rtx
;
54 extern int warn_synth
;
56 /* Return the target type of TYPE, which meas return T for:
57 T*, T&, T[], T (...), and otherwise, just T. */
63 if (TREE_CODE (type
) == REFERENCE_TYPE
)
64 type
= TREE_TYPE (type
);
65 while (TREE_CODE (type
) == POINTER_TYPE
66 || TREE_CODE (type
) == ARRAY_TYPE
67 || TREE_CODE (type
) == FUNCTION_TYPE
68 || TREE_CODE (type
) == METHOD_TYPE
69 || TREE_CODE (type
) == OFFSET_TYPE
)
70 type
= TREE_TYPE (type
);
74 /* Do `exp = require_complete_type (exp);' to make sure exp
75 does not have an incomplete type. (That includes void types.) */
78 require_complete_type (value
)
81 tree type
= TREE_TYPE (value
);
83 /* First, detect a valid value with a complete type. */
84 if (TYPE_SIZE (type
) != 0
85 && type
!= void_type_node
86 && ! (TYPE_LANG_SPECIFIC (type
)
87 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
))
88 && TYPE_SIZE (SIGNATURE_TYPE (type
)) == 0))
91 /* If we see X::Y, we build an OFFSET_TYPE which has
92 not been laid out. Try to avoid an error by interpreting
93 it as this->X::Y, if reasonable. */
94 if (TREE_CODE (value
) == OFFSET_REF
96 && TREE_OPERAND (value
, 0) == C_C_D
)
98 tree base
, member
= TREE_OPERAND (value
, 1);
99 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
100 my_friendly_assert (TREE_CODE (member
) == FIELD_DECL
, 305);
101 base
= convert_pointer_to (basetype
, current_class_decl
);
102 value
= build (COMPONENT_REF
, TREE_TYPE (member
),
103 build_indirect_ref (base
, NULL_PTR
), member
);
104 return require_complete_type (value
);
107 incomplete_type_error (value
, type
);
108 return error_mark_node
;
111 /* Return truthvalue of whether type of EXP is instantiated. */
116 return (TREE_CODE (exp
) == TREE_LIST
117 || TREE_TYPE (exp
) == unknown_type_node
118 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
119 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
));
122 /* Return truthvalue of whether T is function (or pfn) type. */
127 return (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
128 || (TREE_CODE (t
) == POINTER_TYPE
129 && (TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
130 || TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)));
133 /* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
134 does not have an uninstantiated type.
135 TYPE is type to instantiate with, if uninstantiated. */
137 require_instantiated_type (type
, exp
, errval
)
138 tree type
, exp
, errval
;
140 if (TREE_TYPE (exp
) == NULL_TREE
)
142 error ("argument list may not have an initializer list");
146 if (TREE_TYPE (exp
) == unknown_type_node
147 || (TREE_CODE (TREE_TYPE (exp
)) == OFFSET_TYPE
148 && TREE_TYPE (TREE_TYPE (exp
)) == unknown_type_node
))
150 exp
= instantiate_type (type
, exp
, 1);
151 if (TREE_TYPE (exp
) == error_mark_node
)
157 /* Return a variant of TYPE which has all the type qualifiers of LIKE
158 as well as those of TYPE. */
161 qualify_type (type
, like
)
164 int constflag
= TYPE_READONLY (type
) || TYPE_READONLY (like
);
165 int volflag
= TYPE_VOLATILE (type
) || TYPE_VOLATILE (like
);
166 /* @@ Must do member pointers here. */
167 return cp_build_type_variant (type
, constflag
, volflag
);
170 /* Return the common type of two parameter lists.
171 We assume that comptypes has already been done and returned 1;
172 if that isn't so, this may crash.
174 As an optimization, free the space we allocate if the parameter
175 lists are already common. */
181 tree oldargs
= p1
, newargs
, n
;
184 char *first_obj
= (char *) oballoc (0);
186 len
= list_length (p1
);
187 newargs
= tree_last (p1
);
189 if (newargs
== void_list_node
)
198 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
203 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
205 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
207 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
210 else if (! TREE_PURPOSE (p1
))
212 if (TREE_PURPOSE (p2
))
214 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
220 int cmp
= simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
));
222 my_friendly_abort (111);
225 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
227 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
230 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
233 TREE_VALUE (n
) = TREE_VALUE (p1
);
244 /* Return the common type of two types.
245 We assume that comptypes has already been done and returned 1;
246 if that isn't so, this may crash.
248 This is the type for the result of most arithmetic operations
249 if the operands have the given two types.
251 We do not deal with enumeral types here because they have already been
252 converted to integer types. */
258 register enum tree_code code1
;
259 register enum tree_code code2
;
262 /* Save time if the two types are the same. */
264 if (t1
== t2
) return t1
;
266 /* If one type is nonsense, use the other. */
267 if (t1
== error_mark_node
)
269 if (t2
== error_mark_node
)
272 /* Merge the attributes */
274 { register tree a1
, a2
;
275 a1
= TYPE_ATTRIBUTES (t1
);
276 a2
= TYPE_ATTRIBUTES (t2
);
278 /* Either one unset? Take the set one. */
280 if (!(attributes
= a1
))
283 /* One that completely contains the other? Take it. */
285 else if (a2
&& !attribute_list_contained (a1
, a2
))
286 if (attribute_list_contained (a2
, a1
))
290 /* Pick the longest list, and hang on the other list. */
291 /* ??? For the moment we punt on the issue of attrs with args. */
293 if (list_length (a1
) < list_length (a2
))
294 attributes
= a2
, a2
= a1
;
296 for (; a2
; a2
= TREE_CHAIN (a2
))
297 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
298 attributes
) == NULL_TREE
)
301 TREE_CHAIN (a1
) = attributes
;
307 /* Treat an enum type as the unsigned integer type of the same width. */
309 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
310 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
311 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
312 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
314 code1
= TREE_CODE (t1
);
315 code2
= TREE_CODE (t2
);
321 /* If only one is real, use it as the result. */
323 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
324 return build_type_attribute_variant (t1
, attributes
);
326 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
327 return build_type_attribute_variant (t2
, attributes
);
329 /* Both real or both integers; use the one with greater precision. */
331 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
332 return build_type_attribute_variant (t1
, attributes
);
333 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
334 return build_type_attribute_variant (t2
, attributes
);
336 /* Same precision. Prefer longs to ints even when same size. */
338 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
339 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
340 return build_type_attribute_variant (long_unsigned_type_node
,
343 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
344 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
346 /* But preserve unsignedness from the other type,
347 since long cannot hold all the values of an unsigned int. */
348 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
349 t1
= long_unsigned_type_node
;
351 t1
= long_integer_type_node
;
352 return build_type_attribute_variant (t1
, attributes
);
355 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
356 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
357 return build_type_attribute_variant (long_double_type_node
,
360 /* Otherwise prefer the unsigned one. */
362 if (TREE_UNSIGNED (t1
))
363 return build_type_attribute_variant (t1
, attributes
);
365 return build_type_attribute_variant (t2
, attributes
);
369 /* For two pointers, do this recursively on the target type,
370 and combine the qualifiers of the two types' targets. */
371 /* This code was turned off; I don't know why.
372 But ANSI C++ specifies doing this with the qualifiers.
373 So I turned it on again. */
375 tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (t1
));
376 tree tt2
= TYPE_MAIN_VARIANT (TREE_TYPE (t2
));
378 = TYPE_READONLY (TREE_TYPE (t1
)) || TYPE_READONLY (TREE_TYPE (t2
));
380 = TYPE_VOLATILE (TREE_TYPE (t1
)) || TYPE_VOLATILE (TREE_TYPE (t2
));
385 else if (tt1
== void_type_node
|| tt2
== void_type_node
)
386 target
= void_type_node
;
388 target
= common_type (tt1
, tt2
);
390 target
= cp_build_type_variant (target
, constp
, volatilep
);
391 if (code1
== POINTER_TYPE
)
392 t1
= build_pointer_type (target
);
394 t1
= build_reference_type (target
);
395 t1
= build_type_attribute_variant (t1
, attributes
);
397 if (TREE_CODE (target
) == METHOD_TYPE
)
398 t1
= build_ptrmemfunc_type (t1
);
404 t1
= build_pointer_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
405 return build_type_attribute_variant (t1
, attributes
);
408 t1
= build_reference_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
409 return build_type_attribute_variant (t1
, attributes
);
414 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
415 /* Save space: see if the result is identical to one of the args. */
416 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
417 return build_type_attribute_variant (t1
, attributes
);
418 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
419 return build_type_attribute_variant (t2
, attributes
);
420 /* Merge the element types, and have a size if either arg has one. */
421 t1
= build_array_type (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
422 return build_type_attribute_variant (t1
, attributes
);
426 /* Function types: prefer the one that specified arg types.
427 If both do, merge the arg types. Also merge the return types. */
429 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
430 tree p1
= TYPE_ARG_TYPES (t1
);
431 tree p2
= TYPE_ARG_TYPES (t2
);
434 /* Save space: see if the result is identical to one of the args. */
435 if (valtype
== TREE_TYPE (t1
) && ! p2
)
436 return build_type_attribute_variant (t1
, attributes
);
437 if (valtype
== TREE_TYPE (t2
) && ! p1
)
438 return build_type_attribute_variant (t2
, attributes
);
440 /* Simple way if one arg fails to specify argument types. */
441 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
443 rval
= build_function_type (valtype
, p2
);
444 if ((raises
= TYPE_RAISES_EXCEPTIONS (t2
)))
445 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
446 return build_type_attribute_variant (rval
, attributes
);
448 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
449 if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
451 rval
= build_function_type (valtype
, p1
);
453 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
454 return build_type_attribute_variant (rval
, attributes
);
457 rval
= build_function_type (valtype
, commonparms (p1
, p2
));
458 rval
= build_exception_variant (NULL_TREE
, rval
, raises
);
459 return build_type_attribute_variant (rval
, attributes
);
464 my_friendly_assert (TYPE_MAIN_VARIANT (t1
) == t1
465 && TYPE_MAIN_VARIANT (t2
) == t2
, 306);
467 if (DERIVED_FROM_P (t1
, t2
) && binfo_or_else (t1
, t2
))
468 return build_type_attribute_variant (t1
, attributes
);
469 else if (binfo_or_else (t2
, t1
))
470 return build_type_attribute_variant (t2
, attributes
);
472 compiler_error ("common_type called with uncommon aggregate types");
475 if (TREE_CODE (TREE_TYPE (t1
)) == TREE_CODE (TREE_TYPE (t2
)))
477 /* Get this value the long way, since TYPE_METHOD_BASETYPE
478 is just the main variant of this. */
482 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
483 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
485 if (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
))
486 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2
)));
489 if (binfo_or_else (b2
, b1
) == NULL_TREE
)
490 compiler_error ("common_type called with uncommon method types");
491 basetype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1
)));
494 raises
= TYPE_RAISES_EXCEPTIONS (t1
);
496 /* If this was a member function type, get back to the
497 original type of type member function (i.e., without
498 the class instance variable up front. */
499 t1
= build_function_type (TREE_TYPE (t1
), TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
500 t2
= build_function_type (TREE_TYPE (t2
), TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
501 t3
= common_type (t1
, t2
);
502 t3
= build_cplus_method_type (basetype
, TREE_TYPE (t3
), TYPE_ARG_TYPES (t3
));
503 t1
= build_exception_variant (basetype
, t3
, raises
);
506 compiler_error ("common_type called with uncommon method types");
508 return build_type_attribute_variant (t1
, attributes
);
511 if (TREE_TYPE (t1
) == TREE_TYPE (t2
))
513 tree b1
= TYPE_OFFSET_BASETYPE (t1
);
514 tree b2
= TYPE_OFFSET_BASETYPE (t2
);
516 if (DERIVED_FROM_P (b1
, b2
) && binfo_or_else (b1
, b2
))
517 return build_type_attribute_variant (t2
, attributes
);
518 else if (binfo_or_else (b2
, b1
))
519 return build_type_attribute_variant (t1
, attributes
);
521 compiler_error ("common_type called with uncommon member types");
524 return build_type_attribute_variant (t1
, attributes
);
528 /* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */
530 compexcepttypes (t1
, t2
, strict
)
534 return TYPE_RAISES_EXCEPTIONS (t1
) == TYPE_RAISES_EXCEPTIONS (t2
);
538 comp_array_types (cmp
, t1
, t2
, strict
)
539 register int (*cmp
)();
543 tree d1
= TYPE_DOMAIN (t1
);
544 tree d2
= TYPE_DOMAIN (t2
);
546 /* Target types must match incl. qualifiers. */
547 if (!(TREE_TYPE (t1
) == TREE_TYPE (t2
)
548 || (*cmp
) (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)))
551 /* Sizes must match unless one is missing or variable. */
552 if (d1
== 0 || d2
== 0 || d1
== d2
553 || TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
554 || TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
555 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
556 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
)
559 return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1
))
560 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2
)))
561 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1
))
562 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2
)))
563 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1
))
564 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2
)))
565 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1
))
566 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2
))));
569 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
570 or various other operations. This is what ANSI C++ speaks of as
573 For C++: argument STRICT says we should be strict about this
576 2 : strict, except that if one type is a reference and
577 the other is not, compare the target type of the
578 reference to the type that's not a reference (ARM, p308).
579 This is used for checking for invalid overloading.
580 1 : strict (compared according to ANSI C)
581 This is used for checking whether two function decls match.
582 0 : <= (compared according to C++)
583 -1: <= or >= (relaxed)
585 Otherwise, pointers involving base classes and derived classes
586 can be mixed as valid: i.e. a pointer to a base class may be assigned
587 to a pointer to one of its derived classes, as per C++. A pointer to
588 a derived class may be passed as a parameter to a function expecting a
589 pointer to a base classes. These allowances do not commute. In this
590 case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
591 be the derived class. */
593 comptypes (type1
, type2
, strict
)
597 register tree t1
= type1
;
598 register tree t2
= type2
;
601 /* Suppress errors caused by previously reported errors */
606 /* This should never happen. */
607 my_friendly_assert (t1
!= error_mark_node
, 307);
609 if (t2
== error_mark_node
)
614 /* Treat an enum type as the unsigned integer type of the same width. */
616 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
617 t1
= type_for_size (TYPE_PRECISION (t1
), 1);
618 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
619 t2
= type_for_size (TYPE_PRECISION (t2
), 1);
625 /* Different classes of types can't be compatible. */
627 if (TREE_CODE (t1
) != TREE_CODE (t2
))
630 && ((TREE_CODE (t1
) == REFERENCE_TYPE
)
631 ^ (TREE_CODE (t2
) == REFERENCE_TYPE
)))
633 if (TREE_CODE (t1
) == REFERENCE_TYPE
)
634 return comptypes (TREE_TYPE (t1
), t2
, 1);
635 return comptypes (t1
, TREE_TYPE (t2
), 1);
643 /* Qualifiers must match. */
645 if (TYPE_READONLY (t1
) != TYPE_READONLY (t2
))
647 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
650 /* Allow for two different type nodes which have essentially the same
651 definition. Note that we already checked for equality of the type
652 type qualifiers (just above). */
654 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
657 #ifdef COMP_TYPE_ATTRIBUTES
658 if (! (attrval
= COMP_TYPE_ATTRIBUTES (t1
, t2
)))
661 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
665 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
668 switch (TREE_CODE (t1
))
677 val
= (comptypes (TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t1
)),
678 TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t2
)), strict
)
679 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
));
683 if (! compexcepttypes (t1
, t2
, strict
))
686 /* This case is anti-symmetrical!
687 One can pass a base member (or member function)
688 to something expecting a derived member (or member function),
689 but not vice-versa! */
691 val
= (comptypes (TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t2
)),
692 TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t1
)), strict
)
693 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
)
694 && compparms (TREE_CHAIN (TYPE_ARG_TYPES (t1
)),
695 TREE_CHAIN (TYPE_ARG_TYPES (t2
)), strict
));
709 if (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
)
713 rval
= t1
== t2
|| UNIQUELY_DERIVED_FROM_P (t1
, t2
);
722 val
= UNIQUELY_DERIVED_FROM_P (t2
, t1
);
729 val
= comptypes (t1
, t2
, strict
);
733 if (! compexcepttypes (t1
, t2
, strict
))
736 val
= ((TREE_TYPE (t1
) == TREE_TYPE (t2
)
737 || comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), strict
))
738 && compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
), strict
));
742 /* Target types must match incl. qualifiers. */
743 val
= comp_array_types (comptypes
, t1
, t2
, strict
);
746 case TEMPLATE_TYPE_PARM
:
749 case UNINSTANTIATED_P_TYPE
:
750 if (UPT_TEMPLATE (t1
) != UPT_TEMPLATE (t2
))
753 int i
= TREE_VEC_LENGTH (UPT_PARMS (t1
));
754 tree
*p1
= &TREE_VEC_ELT (UPT_PARMS (t1
), 0);
755 tree
*p2
= &TREE_VEC_ELT (UPT_PARMS (t2
), 0);
759 if (TREE_CODE_CLASS (TREE_CODE (p1
[i
])) == 't')
761 if (! comptypes (p1
[i
], p2
[i
], 1))
766 if (simple_cst_equal (p1
[i
], p2
[i
]) <= 0)
773 return attrval
== 2 && val
== 1 ? 2 : val
;
776 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
777 ignoring their qualifiers.
779 NPTRS is the number of pointers we can strip off and keep cool.
780 This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
781 but to not permit B** to convert to A**. */
784 comp_target_types (ttl
, ttr
, nptrs
)
788 ttl
= TYPE_MAIN_VARIANT (ttl
);
789 ttr
= TYPE_MAIN_VARIANT (ttr
);
793 if (TREE_CODE (ttr
) != TREE_CODE (ttl
))
796 if (TREE_CODE (ttr
) == POINTER_TYPE
)
798 ttl
= TREE_TYPE (ttl
);
799 ttr
= TREE_TYPE (ttr
);
803 if (TREE_CODE (ttl
) == VOID_TYPE
804 && TREE_CODE (ttr
) != FUNCTION_TYPE
805 && TREE_CODE (ttr
) != METHOD_TYPE
806 && TREE_CODE (ttr
) != OFFSET_TYPE
)
808 else if (TREE_CODE (ttr
) == VOID_TYPE
809 && TREE_CODE (ttl
) != FUNCTION_TYPE
810 && TREE_CODE (ttl
) != METHOD_TYPE
811 && TREE_CODE (ttl
) != OFFSET_TYPE
)
813 else if (TREE_CODE (ttl
) == POINTER_TYPE
814 || TREE_CODE (ttl
) == ARRAY_TYPE
)
815 return comp_ptr_ttypes (ttl
, ttr
);
818 return comp_target_types (ttl
, ttr
, nptrs
- 1);
821 if (TREE_CODE (ttr
) == REFERENCE_TYPE
)
822 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
823 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
824 return comp_array_types (comp_target_types
, ttl
, ttr
, 0);
825 else if (TREE_CODE (ttr
) == FUNCTION_TYPE
|| TREE_CODE (ttr
) == METHOD_TYPE
)
826 if (comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
827 switch (comp_target_parms (TYPE_ARG_TYPES (ttl
), TYPE_ARG_TYPES (ttr
), 1))
836 my_friendly_abort (112);
842 else if (TREE_CODE (ttr
) == OFFSET_TYPE
)
844 /* Contravariance: we can assign a pointer to base member to a pointer
845 to derived member. Note difference from simple pointer case, where
846 we can pass a pointer to derived to a pointer to base. */
847 if (comptypes (TYPE_OFFSET_BASETYPE (ttr
), TYPE_OFFSET_BASETYPE (ttl
), 0))
848 return comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
);
849 else if (comptypes (TYPE_OFFSET_BASETYPE (ttl
), TYPE_OFFSET_BASETYPE (ttr
), 0)
850 && comp_target_types (TREE_TYPE (ttl
), TREE_TYPE (ttr
), nptrs
))
853 else if (IS_AGGR_TYPE (ttl
))
857 if (comptypes (TYPE_POINTER_TO (ttl
), TYPE_POINTER_TO (ttr
), 0))
859 if (comptypes (TYPE_POINTER_TO (ttr
), TYPE_POINTER_TO (ttl
), 0))
867 /* If two types share a common base type, return that basetype.
868 If there is not a unique most-derived base type, this function
869 returns ERROR_MARK_NODE. */
871 common_base_type (tt1
, tt2
)
874 tree best
= NULL_TREE
, tmp
;
877 /* If one is a baseclass of another, that's good enough. */
878 if (UNIQUELY_DERIVED_FROM_P (tt1
, tt2
))
880 if (UNIQUELY_DERIVED_FROM_P (tt2
, tt1
))
884 /* If they share a virtual baseclass, that's good enough. */
885 for (tmp
= CLASSTYPE_VBASECLASSES (tt1
); tmp
; tmp
= TREE_CHAIN (tmp
))
887 if (binfo_member (BINFO_TYPE (tmp
), CLASSTYPE_VBASECLASSES (tt2
)))
888 return BINFO_TYPE (tmp
);
892 /* Otherwise, try to find a unique baseclass of TT1
893 that is shared by TT2, and follow that down. */
894 for (i
= CLASSTYPE_N_BASECLASSES (tt1
)-1; i
>= 0; i
--)
896 tree basetype
= TYPE_BINFO_BASETYPE (tt1
, i
);
897 tree trial
= common_base_type (basetype
, tt2
);
900 if (trial
== error_mark_node
)
902 if (best
== NULL_TREE
)
904 else if (best
!= trial
)
905 return error_mark_node
;
910 for (i
= CLASSTYPE_N_BASECLASSES (tt2
)-1; i
>= 0; i
--)
912 tree basetype
= TYPE_BINFO_BASETYPE (tt2
, i
);
913 tree trial
= common_base_type (tt1
, basetype
);
916 if (trial
== error_mark_node
)
918 if (best
== NULL_TREE
)
920 else if (best
!= trial
)
921 return error_mark_node
;
927 /* Subroutines of `comptypes'. */
929 /* Return 1 if two parameter type lists PARMS1 and PARMS2
930 are equivalent in the sense that functions with those parameter types
931 can have equivalent types.
932 If either list is empty, we win.
933 Otherwise, the two lists must be equivalent, element by element.
935 C++: See comment above about TYPE1, TYPE2, STRICT.
936 If STRICT == 3, it means checking is strict, but do not compare
937 default parameter values. */
939 compparms (parms1
, parms2
, strict
)
943 register tree t1
= parms1
, t2
= parms2
;
945 /* An unspecified parmlist matches any specified parmlist
946 whose argument types don't need default promotions. */
948 if (strict
<= 0 && t1
== 0)
949 return self_promoting_args_p (t2
);
950 if (strict
< 0 && t2
== 0)
951 return self_promoting_args_p (t1
);
955 if (t1
== 0 && t2
== 0)
957 /* If one parmlist is shorter than the other,
958 they fail to match, unless STRICT is <= 0. */
959 if (t1
== 0 || t2
== 0)
966 return t1
&& TREE_PURPOSE (t1
);
968 if (! comptypes (TREE_VALUE (t2
), TREE_VALUE (t1
), strict
))
973 return t2
== void_list_node
&& TREE_PURPOSE (t1
);
974 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
977 /* Default parms are not part of the type of a function. */
978 if (strict
!= 3 && TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
980 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
982 my_friendly_abort (113);
988 t1
= TREE_CHAIN (t1
);
989 t2
= TREE_CHAIN (t2
);
993 /* This really wants return whether or not parameter type lists
994 would make their owning functions assignment compatible or not. */
996 comp_target_parms (parms1
, parms2
, strict
)
1000 register tree t1
= parms1
, t2
= parms2
;
1001 int warn_contravariance
= 0;
1003 /* An unspecified parmlist matches any specified parmlist
1004 whose argument types don't need default promotions.
1005 @@@ see 13.3.3 for a counterexample... */
1007 if (t1
== 0 && t2
!= 0)
1009 cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
1011 return self_promoting_args_p (t2
);
1014 return self_promoting_args_p (t1
);
1016 for (; t1
|| t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1020 /* If one parmlist is shorter than the other,
1021 they fail to match, unless STRICT is <= 0. */
1022 if (t1
== 0 || t2
== 0)
1027 return 1 + warn_contravariance
;
1028 return ((t1
&& TREE_PURPOSE (t1
)) + warn_contravariance
);
1030 p1
= TREE_VALUE (t1
);
1031 p2
= TREE_VALUE (t2
);
1035 if ((TREE_CODE (p1
) == POINTER_TYPE
&& TREE_CODE (p2
) == POINTER_TYPE
)
1036 || (TREE_CODE (p1
) == REFERENCE_TYPE
&& TREE_CODE (p2
) == REFERENCE_TYPE
))
1039 && (TYPE_MAIN_VARIANT (TREE_TYPE (p1
))
1040 == TYPE_MAIN_VARIANT (TREE_TYPE (p2
))))
1043 /* The following is wrong for contravariance,
1044 but many programs depend on it. */
1045 if (TREE_TYPE (p1
) == void_type_node
)
1047 if (TREE_TYPE (p2
) == void_type_node
)
1049 warn_contravariance
= 1;
1052 if (IS_AGGR_TYPE (TREE_TYPE (p1
)))
1054 if (comptypes (p2
, p1
, 0) == 0)
1056 if (comptypes (p1
, p2
, 0) != 0)
1057 warn_contravariance
= 1;
1064 /* Note backwards order due to contravariance. */
1065 if (comp_target_types (p2
, p1
, 1) == 0)
1067 if (comp_target_types (p1
, p2
, 1))
1069 warn_contravariance
= 1;
1075 /* What good do these cases do? */
1077 return p2
== void_type_node
&& TREE_PURPOSE (t1
);
1078 return TREE_PURPOSE (t1
) || TREE_PURPOSE (t2
);
1081 /* Target types are compatible--just make sure that if
1082 we use parameter lists, that they are ok as well. */
1083 if (TREE_CODE (p1
) == FUNCTION_TYPE
|| TREE_CODE (p1
) == METHOD_TYPE
)
1084 switch (comp_target_parms (TYPE_ARG_TYPES (p1
),
1085 TYPE_ARG_TYPES (p2
),
1093 warn_contravariance
= 1;
1096 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1098 int cmp
= simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1100 my_friendly_abort (114);
1105 return 1 + warn_contravariance
;
1108 /* Return 1 if PARMS specifies a fixed number of parameters
1109 and none of their types is affected by default promotions. */
1112 self_promoting_args_p (parms
)
1116 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
1118 register tree type
= TREE_VALUE (t
);
1120 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1123 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1129 if (C_PROMOTING_INTEGER_TYPE_P (type
))
1135 /* Return an unsigned type the same as TYPE in other respects.
1137 C++: must make these work for type variants as well. */
1140 unsigned_type (type
)
1143 tree type1
= TYPE_MAIN_VARIANT (type
);
1144 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1145 return unsigned_char_type_node
;
1146 if (type1
== integer_type_node
)
1147 return unsigned_type_node
;
1148 if (type1
== short_integer_type_node
)
1149 return short_unsigned_type_node
;
1150 if (type1
== long_integer_type_node
)
1151 return long_unsigned_type_node
;
1152 if (type1
== long_long_integer_type_node
)
1153 return long_long_unsigned_type_node
;
1157 /* Return a signed type the same as TYPE in other respects. */
1163 tree type1
= TYPE_MAIN_VARIANT (type
);
1164 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1165 return signed_char_type_node
;
1166 if (type1
== unsigned_type_node
)
1167 return integer_type_node
;
1168 if (type1
== short_unsigned_type_node
)
1169 return short_integer_type_node
;
1170 if (type1
== long_unsigned_type_node
)
1171 return long_integer_type_node
;
1172 if (type1
== long_long_unsigned_type_node
)
1173 return long_long_integer_type_node
;
1177 /* Return a type the same as TYPE except unsigned or
1178 signed according to UNSIGNEDP. */
1181 signed_or_unsigned_type (unsignedp
, type
)
1185 if (! INTEGRAL_TYPE_P (type
))
1187 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1188 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1189 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1190 return unsignedp
? unsigned_type_node
: integer_type_node
;
1191 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1192 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1193 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1194 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1195 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1196 return (unsignedp
? long_long_unsigned_type_node
1197 : long_long_integer_type_node
);
1205 enum tree_code code
= TREE_CODE (type
);
1208 if (code
== FUNCTION_TYPE
)
1210 if (pedantic
|| warn_pointer_arith
)
1211 pedwarn ("ANSI C++ forbids taking the sizeof a function type");
1212 return size_int (1);
1214 if (code
== METHOD_TYPE
)
1216 if (pedantic
|| warn_pointer_arith
)
1217 pedwarn ("ANSI C++ forbids taking the sizeof a method type");
1218 return size_int (1);
1220 if (code
== VOID_TYPE
)
1222 if (pedantic
|| warn_pointer_arith
)
1223 pedwarn ("ANSI C++ forbids taking the sizeof a void type");
1224 return size_int (1);
1226 if (code
== ERROR_MARK
)
1227 return size_int (1);
1229 /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
1230 referenced object.'' */
1231 if (code
== REFERENCE_TYPE
)
1232 type
= TREE_TYPE (type
);
1234 /* We couldn't find anything in the ARM or the draft standard that says,
1235 one way or the other, if doing sizeof on something that doesn't have
1236 an object associated with it is correct or incorrect. For example, if
1237 you declare `struct S { char str[16]; };', and in your program do
1238 a `sizeof (S::str)', should we flag that as an error or should we give
1239 the size of it? Since it seems like a reasonable thing to do, we'll go
1240 with giving the value. */
1241 if (code
== OFFSET_TYPE
)
1242 type
= TREE_TYPE (type
);
1244 /* @@ This also produces an error for a signature ref.
1245 In that case we should be able to do better. */
1246 if (IS_SIGNATURE (type
))
1248 error ("`sizeof' applied to a signature type");
1249 return size_int (0);
1252 if (TYPE_SIZE (type
) == 0)
1254 error ("`sizeof' applied to an incomplete type");
1255 return size_int (0);
1258 /* Convert in case a char is more than one unit. */
1259 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1260 size_int (TYPE_PRECISION (char_type_node
)));
1261 /* size_binop does not put the constant in range, so do it now. */
1262 if (TREE_CODE (t
) == INTEGER_CST
&& force_fit_type (t
, 0))
1263 TREE_CONSTANT_OVERFLOW (t
) = TREE_OVERFLOW (t
) = 1;
1268 c_sizeof_nowarn (type
)
1271 enum tree_code code
= TREE_CODE (type
);
1274 if (code
== FUNCTION_TYPE
1275 || code
== METHOD_TYPE
1276 || code
== VOID_TYPE
1277 || code
== ERROR_MARK
)
1278 return size_int (1);
1279 if (code
== REFERENCE_TYPE
)
1280 type
= TREE_TYPE (type
);
1282 if (TYPE_SIZE (type
) == 0)
1285 /* ??? Tiemann, why have any diagnostic here?
1286 There is none in the corresponding function for C. */
1287 warning ("sizeof applied to an incomplete type");
1289 return size_int (0);
1292 /* Convert in case a char is more than one unit. */
1293 t
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE (type
),
1294 size_int (TYPE_PRECISION (char_type_node
)));
1295 force_fit_type (t
, 0);
1299 /* Implement the __alignof keyword: Return the minimum required
1300 alignment of TYPE, measured in bytes. */
1306 enum tree_code code
= TREE_CODE (type
);
1309 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
1310 return size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1312 if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
1313 return size_int (1);
1315 /* C++: this is really correct! */
1316 if (code
== REFERENCE_TYPE
)
1317 type
= TREE_TYPE (type
);
1319 /* @@ This also produces an error for a signature ref.
1320 In that case we should be able to do better. */
1321 if (IS_SIGNATURE (type
))
1323 error ("`__alignof' applied to a signature type");
1324 return size_int (1);
1327 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1328 force_fit_type (t
, 0);
1332 /* Perform default promotions for C data used in expressions.
1333 Arrays and functions are converted to pointers;
1334 enumeral types or short or char, to int.
1335 In addition, manifest constants symbols are replaced by their values.
1337 C++: this will automatically bash references to their target type. */
1340 default_conversion (exp
)
1343 register tree type
= TREE_TYPE (exp
);
1344 register enum tree_code code
= TREE_CODE (type
);
1346 if (code
== OFFSET_TYPE
/* || TREE_CODE (exp) == OFFSET_REF */ )
1348 if (TREE_CODE (exp
) == OFFSET_REF
)
1349 return default_conversion (resolve_offset_ref (exp
));
1351 type
= TREE_TYPE (type
);
1352 code
= TREE_CODE (type
);
1355 if (code
== REFERENCE_TYPE
)
1357 exp
= convert_from_reference (exp
);
1358 type
= TREE_TYPE (exp
);
1359 code
= TREE_CODE (type
);
1362 /* Constants can be used directly unless they're not loadable. */
1363 if (TREE_CODE (exp
) == CONST_DECL
)
1364 exp
= DECL_INITIAL (exp
);
1365 /* Replace a nonvolatile const static variable with its value. */
1366 else if (TREE_READONLY_DECL_P (exp
) && DECL_MODE (exp
) != BLKmode
)
1368 exp
= decl_constant_value (exp
);
1369 type
= TREE_TYPE (exp
);
1372 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1373 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
1375 if (INTEGRAL_CODE_P (code
))
1377 tree t
= type_promotes_to (type
);
1379 return convert (t
, exp
);
1381 if (flag_traditional
1382 && TYPE_MAIN_VARIANT (type
) == float_type_node
)
1383 return convert (double_type_node
, exp
);
1384 if (code
== VOID_TYPE
)
1386 error ("void value not ignored as it ought to be");
1387 return error_mark_node
;
1389 if (code
== FUNCTION_TYPE
)
1391 return build_unary_op (ADDR_EXPR
, exp
, 0);
1393 if (code
== METHOD_TYPE
)
1395 if (TREE_CODE (exp
) == OFFSET_REF
)
1397 my_friendly_assert (TREE_CODE (TREE_OPERAND (exp
, 1)) == FUNCTION_DECL
,
1399 return build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 1), 0);
1401 return build_unary_op (ADDR_EXPR
, exp
, 0);
1403 if (code
== ARRAY_TYPE
)
1408 int constp
, volatilep
;
1410 if (TREE_CODE (exp
) == INDIRECT_REF
)
1412 /* Stripping away the INDIRECT_REF is not the right
1413 thing to do for references... */
1414 tree inner
= TREE_OPERAND (exp
, 0);
1415 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
)
1417 inner
= build1 (CONVERT_EXPR
,
1418 build_pointer_type (TREE_TYPE (TREE_TYPE (inner
))),
1420 TREE_REFERENCE_EXPR (inner
) = 1;
1422 return convert (TYPE_POINTER_TO (TREE_TYPE (type
)), inner
);
1425 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1427 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1428 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
1429 TREE_OPERAND (exp
, 0), op1
);
1433 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
1435 error ("invalid use of non-lvalue array");
1436 return error_mark_node
;
1439 constp
= volatilep
= 0;
1440 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r'
1441 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
1443 constp
= TREE_READONLY (exp
);
1444 volatilep
= TREE_THIS_VOLATILE (exp
);
1447 restype
= TREE_TYPE (type
);
1448 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)
1449 || constp
|| volatilep
)
1450 restype
= cp_build_type_variant (restype
,
1451 TYPE_READONLY (type
) || constp
,
1452 TYPE_VOLATILE (type
) || volatilep
);
1453 ptrtype
= build_pointer_type (restype
);
1455 if (TREE_CODE (exp
) == VAR_DECL
)
1457 /* ??? This is not really quite correct
1458 in that the type of the operand of ADDR_EXPR
1459 is not the target type of the type of the ADDR_EXPR itself.
1460 Question is, can this lossage be avoided? */
1461 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1462 if (mark_addressable (exp
) == 0)
1463 return error_mark_node
;
1464 TREE_CONSTANT (adr
) = staticp (exp
);
1465 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1468 /* This way is better for a COMPONENT_REF since it can
1469 simplify the offset for a component. */
1470 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1471 return convert (ptrtype
, adr
);
1477 build_object_ref (datum
, basetype
, field
)
1478 tree datum
, basetype
, field
;
1481 if (datum
== error_mark_node
)
1482 return error_mark_node
;
1484 dtype
= TREE_TYPE (datum
);
1485 if (TREE_CODE (dtype
) == REFERENCE_TYPE
)
1486 dtype
= TREE_TYPE (dtype
);
1487 if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype
)))
1489 cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'",
1490 basetype
, field
, dtype
);
1491 return error_mark_node
;
1493 else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype
)))
1495 warning ("signature name in scope resolution ignored");
1496 return build_component_ref (datum
, field
, NULL_TREE
, 1);
1498 else if (is_aggr_typedef (basetype
, 1))
1500 tree real_basetype
= IDENTIFIER_TYPE_VALUE (basetype
);
1501 tree binfo
= binfo_or_else (real_basetype
, TREE_TYPE (datum
));
1503 return build_component_ref (build_scoped_ref (datum
, basetype
),
1506 return error_mark_node
;
1509 /* Like `build_component_ref, but uses an already found field.
1510 Must compute access for C_C_D. Otherwise, ok. */
1512 build_component_ref_1 (datum
, field
, protect
)
1516 register tree basetype
= TREE_TYPE (datum
);
1517 register enum tree_code code
= TREE_CODE (basetype
);
1520 if (code
== REFERENCE_TYPE
)
1522 datum
= convert_from_reference (datum
);
1523 basetype
= TREE_TYPE (datum
);
1524 code
= TREE_CODE (basetype
);
1527 if (! IS_AGGR_TYPE_CODE (code
))
1529 if (code
!= ERROR_MARK
)
1530 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1531 field
, datum
, basetype
);
1532 return error_mark_node
;
1535 if (TYPE_SIZE (basetype
) == 0)
1537 incomplete_type_error (0, basetype
);
1538 return error_mark_node
;
1541 /* Look up component name in the structure type definition. */
1543 if (field
== error_mark_node
)
1544 my_friendly_abort (115);
1546 if (TREE_STATIC (field
))
1551 enum access_type access
1552 = compute_access (TYPE_BINFO (current_class_type
), field
);
1554 if (access
== access_private
)
1556 cp_error ("field `%D' is private", field
);
1557 return error_mark_node
;
1559 else if (access
== access_protected
)
1561 cp_error ("field `%D' is protected", field
);
1562 return error_mark_node
;
1566 ref
= build (COMPONENT_REF
, TREE_TYPE (field
), datum
, field
);
1568 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1569 TREE_READONLY (ref
) = 1;
1570 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1571 TREE_THIS_VOLATILE (ref
) = 1;
1572 if (DECL_MUTABLE_P (field
))
1573 TREE_READONLY (ref
) = 0;
1578 /* Given a COND_EXPR in T, return it in a form that we can, for
1579 example, use as an lvalue. This code used to be in unary_complex_lvalue,
1580 but we needed it to deal with `a = (d == c) ? b : c' expressions, where
1581 we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
1582 and in build_modify_expr. The case (in particular) that led to this was
1583 with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
1585 rationalize_conditional_expr (code
, t
)
1586 enum tree_code code
;
1590 build_conditional_expr (TREE_OPERAND (t
, 0),
1591 build_unary_op (code
, TREE_OPERAND (t
, 1), 0),
1592 build_unary_op (code
, TREE_OPERAND (t
, 2), 0));
1596 build_component_ref (datum
, component
, basetype_path
, protect
)
1597 tree datum
, component
, basetype_path
;
1600 register tree basetype
= TREE_TYPE (datum
);
1601 register enum tree_code code
= TREE_CODE (basetype
);
1602 register tree field
= NULL
;
1605 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it. */
1606 switch (TREE_CODE (datum
))
1610 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
,
1611 basetype_path
, protect
);
1612 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1613 TREE_OPERAND (datum
, 0), value
);
1616 return build_conditional_expr
1617 (TREE_OPERAND (datum
, 0),
1618 build_component_ref (TREE_OPERAND (datum
, 1), component
,
1619 basetype_path
, protect
),
1620 build_component_ref (TREE_OPERAND (datum
, 2), component
,
1621 basetype_path
, protect
));
1624 if (code
== REFERENCE_TYPE
)
1627 /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
1628 @@ Maybe that is not right. */
1629 if (TREE_REFERENCE_EXPR (datum
))
1630 datum
= build1 (INDIRECT_REF
, TREE_TYPE (basetype
), datum
);
1633 datum
= convert_from_reference (datum
);
1634 basetype
= TREE_TYPE (datum
);
1635 code
= TREE_CODE (basetype
);
1638 /* First, see if there is a field or component with name COMPONENT. */
1639 if (TREE_CODE (component
) == TREE_LIST
)
1641 my_friendly_assert (!(TREE_CHAIN (component
) == NULL_TREE
1642 && DECL_CHAIN (TREE_VALUE (component
)) == NULL_TREE
), 309);
1643 return build (COMPONENT_REF
, TREE_TYPE (component
), datum
, component
);
1646 if (TREE_CODE (component
) == TYPE_EXPR
)
1647 return build_component_type_expr (datum
, component
, NULL_TREE
, protect
);
1650 if (! IS_AGGR_TYPE_CODE (code
))
1652 if (code
!= ERROR_MARK
)
1653 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1654 component
, datum
, basetype
);
1655 return error_mark_node
;
1658 if (TYPE_SIZE (basetype
) == 0)
1660 incomplete_type_error (0, basetype
);
1661 return error_mark_node
;
1664 if (TREE_CODE (component
) == BIT_NOT_EXPR
)
1666 if (TYPE_IDENTIFIER (basetype
) != TREE_OPERAND (component
, 0))
1668 cp_error ("destructor specifier `%T::~%T' must have matching names",
1669 basetype
, TREE_OPERAND (component
, 0));
1670 return error_mark_node
;
1672 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1674 cp_error ("type `%T' has no destructor", basetype
);
1675 return error_mark_node
;
1677 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
1680 /* Look up component name in the structure type definition. */
1681 if (CLASSTYPE_VFIELD (basetype
)
1682 && DECL_NAME (CLASSTYPE_VFIELD (basetype
)) == component
)
1683 /* Special-case this because if we use normal lookups in an ambiguous
1684 hierarchy, the compiler will abort (because vptr lookups are
1685 not supposed to be ambiguous. */
1686 field
= CLASSTYPE_VFIELD (basetype
);
1689 if (basetype_path
== NULL_TREE
)
1690 basetype_path
= TYPE_BINFO (basetype
);
1691 field
= lookup_field (basetype_path
, component
,
1692 protect
&& ! VFIELD_NAME_P (component
), 0);
1693 if (field
== error_mark_node
)
1694 return error_mark_node
;
1696 if (field
== NULL_TREE
)
1698 /* Not found as a data field, look for it as a method. If found,
1699 then if this is the only possible one, return it, else
1700 report ambiguity error. */
1701 tree fndecls
= lookup_fnfields (basetype_path
, component
, 1);
1702 if (fndecls
== error_mark_node
)
1703 return error_mark_node
;
1706 if (TREE_CHAIN (fndecls
) == NULL_TREE
1707 && DECL_CHAIN (TREE_VALUE (fndecls
)) == NULL_TREE
)
1709 enum access_type access
;
1712 /* Unique, so use this one now. */
1713 basetype
= TREE_PURPOSE (fndecls
);
1714 fndecl
= TREE_VALUE (fndecls
);
1715 access
= compute_access (TREE_PURPOSE (fndecls
), fndecl
);
1716 if (access
== access_public
)
1718 if (DECL_VINDEX (fndecl
)
1719 && ! resolves_to_fixed_type_p (datum
, 0))
1721 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1722 addr
= convert_pointer_to (DECL_CONTEXT (fndecl
), addr
);
1723 datum
= build_indirect_ref (addr
, NULL_PTR
);
1724 my_friendly_assert (datum
!= error_mark_node
, 310);
1725 fndecl
= build_vfn_ref (&addr
, datum
, DECL_VINDEX (fndecl
));
1727 assemble_external (fndecl
);
1730 if (access
== access_protected
)
1731 cp_error ("member function `%D' is protected", fndecl
);
1733 cp_error ("member function `%D' is private", fndecl
);
1734 return error_mark_node
;
1738 /* Just act like build_offset_ref, since the object does
1739 not matter unless we're actually calling the function. */
1742 for (t
= TREE_VALUE (fndecls
); t
; t
= DECL_CHAIN (t
))
1743 assemble_external (t
);
1745 t
= build_tree_list (error_mark_node
, fndecls
);
1746 TREE_TYPE (t
) = build_offset_type (basetype
,
1753 if (component
== ansi_opname
[(int) TYPE_EXPR
])
1754 cp_error ("`%#T' has no such type conversion operator", basetype
);
1757 cp_error ("`%#T' has no member named `%D'", basetype
, component
);
1758 return error_mark_node
;
1760 else if (TREE_TYPE (field
) == error_mark_node
)
1761 return error_mark_node
;
1763 if (TREE_CODE (field
) != FIELD_DECL
)
1765 if (TREE_CODE (field
) == TYPE_DECL
)
1767 cp_error ("invalid use of type decl `%#D' as expression", field
);
1768 return error_mark_node
;
1770 if (DECL_RTL (field
) != 0)
1771 assemble_external (field
);
1772 TREE_USED (field
) = 1;
1777 if (DECL_FIELD_CONTEXT (field
) != basetype
1778 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
1780 tree addr
= build_unary_op (ADDR_EXPR
, datum
, 0);
1781 if (integer_zerop (addr
))
1783 error ("invalid reference to NULL ptr, use ptr-to-member instead");
1784 return error_mark_node
;
1786 addr
= convert_pointer_to (DECL_FIELD_CONTEXT (field
), addr
);
1787 datum
= build_indirect_ref (addr
, NULL_PTR
);
1788 my_friendly_assert (datum
!= error_mark_node
, 311);
1790 ref
= fold (build (COMPONENT_REF
, TREE_TYPE (field
),
1791 break_out_cleanups (datum
), field
));
1793 if (TREE_READONLY (datum
) || TREE_READONLY (field
))
1794 TREE_READONLY (ref
) = 1;
1795 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (field
))
1796 TREE_THIS_VOLATILE (ref
) = 1;
1797 if (DECL_MUTABLE_P (field
))
1798 TREE_READONLY (ref
) = 0;
1803 /* Given an expression PTR for a pointer, return an expression
1804 for the value pointed to.
1805 ERRORSTRING is the name of the operator to appear in error messages.
1807 This function may need to overload OPERATOR_FNNAME.
1808 Must also handle REFERENCE_TYPEs for C++. */
1811 build_x_indirect_ref (ptr
, errorstring
)
1815 tree rval
= build_opfncall (INDIRECT_REF
, LOOKUP_NORMAL
, ptr
, NULL_TREE
, NULL_TREE
);
1818 return build_indirect_ref (ptr
, errorstring
);
1822 build_indirect_ref (ptr
, errorstring
)
1826 register tree pointer
= default_conversion (ptr
);
1827 register tree type
= TREE_TYPE (pointer
);
1829 if (ptr
== current_class_decl
)
1832 ptr
= build_expr_type_conversion (WANT_POINTER
, pointer
, 1);
1836 type
= TREE_TYPE (pointer
);
1839 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
1841 if (TREE_CODE (pointer
) == ADDR_EXPR
1842 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1843 == TREE_TYPE (type
)))
1844 return TREE_OPERAND (pointer
, 0);
1847 tree t
= TREE_TYPE (type
);
1848 register tree ref
= build1 (INDIRECT_REF
,
1849 TYPE_MAIN_VARIANT (t
), pointer
);
1851 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1852 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1853 TREE_SIDE_EFFECTS (ref
)
1854 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1858 /* `pointer' won't be an error_mark_node if we were given a
1859 pointer to member, so it's cool to check for this here. */
1860 else if (TYPE_PTRMEMFUNC_P (type
))
1861 error ("invalid use of `%s' on pointer to member function", errorstring
);
1862 else if (TREE_CODE (type
) == RECORD_TYPE
1863 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1864 error ("cannot dereference signature pointer/reference");
1865 else if (pointer
!= error_mark_node
)
1868 error ("invalid type argument of `%s'", errorstring
);
1870 error ("invalid type argument");
1872 return error_mark_node
;
1875 /* This handles expressions of the form "a[i]", which denotes
1878 This is logically equivalent in C to *(a+i), but we may do it differently.
1879 If A is a variable or a member, we generate a primitive ARRAY_REF.
1880 This avoids forcing the array out of registers, and can work on
1881 arrays that are not lvalues (for example, members of structures returned
1884 If INDEX is of some user-defined type, it must be converted to
1885 integer type. Otherwise, to make a compatible PLUS_EXPR, it
1886 will inherit the type of the array, which will be some pointer type. */
1889 build_x_array_ref (array
, index
)
1892 tree rval
= build_opfncall (ARRAY_REF
, LOOKUP_NORMAL
, array
, index
, NULL_TREE
);
1895 return build_array_ref (array
, index
);
1899 build_array_ref (array
, idx
)
1906 error ("subscript missing in array reference");
1907 return error_mark_node
;
1910 if (TREE_TYPE (array
) == error_mark_node
1911 || TREE_TYPE (idx
) == error_mark_node
)
1912 return error_mark_node
;
1914 itype
= TREE_TYPE (idx
);
1916 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
1917 && TREE_CODE (array
) != INDIRECT_REF
)
1921 /* Subscripting with type char is likely to lose
1922 on a machine where chars are signed.
1923 So warn on any machine, but optionally.
1924 Don't warn for unsigned char since that type is safe.
1925 Don't warn for signed char because anyone who uses that
1926 must have done so deliberately. */
1927 if (warn_char_subscripts
1928 && TYPE_MAIN_VARIANT (TREE_TYPE (idx
)) == char_type_node
)
1929 warning ("array subscript has type `char'");
1931 /* Apply default promotions *after* noticing character types. */
1932 idx
= default_conversion (idx
);
1934 if (TREE_CODE (TREE_TYPE (idx
)) != INTEGER_TYPE
)
1936 error ("array subscript is not an integer");
1937 return error_mark_node
;
1940 /* An array that is indexed by a non-constant
1941 cannot be stored in a register; we must be able to do
1942 address arithmetic on its address.
1943 Likewise an array of elements of variable size. */
1944 if (TREE_CODE (idx
) != INTEGER_CST
1945 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))) != 0
1946 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1948 if (mark_addressable (array
) == 0)
1949 return error_mark_node
;
1951 /* An array that is indexed by a constant value which is not within
1952 the array bounds cannot be stored in a register either; because we
1953 would get a crash in store_bit_field/extract_bit_field when trying
1954 to access a non-existent part of the register. */
1955 if (TREE_CODE (idx
) == INTEGER_CST
1956 && TYPE_VALUES (TREE_TYPE (array
))
1957 && ! int_fits_type_p (idx
, TYPE_VALUES (TREE_TYPE (array
))))
1959 if (mark_addressable (array
) == 0)
1960 return error_mark_node
;
1963 if (pedantic
&& !lvalue_p (array
))
1964 pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
1966 /* Note in C++ it is valid to subscript a `register' array, since
1967 it is valid to take the address of something with that
1968 storage specification. */
1972 while (TREE_CODE (foo
) == COMPONENT_REF
)
1973 foo
= TREE_OPERAND (foo
, 0);
1974 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
1975 warning ("subscripting array declared `register'");
1978 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1979 rval
= build (ARRAY_REF
, type
, array
, idx
);
1980 /* Array ref is const/volatile if the array elements are
1981 or if the array is.. */
1982 TREE_READONLY (rval
)
1983 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1984 | TREE_READONLY (array
));
1985 TREE_SIDE_EFFECTS (rval
)
1986 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1987 | TREE_SIDE_EFFECTS (array
));
1988 TREE_THIS_VOLATILE (rval
)
1989 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1990 /* This was added by rms on 16 Nov 91.
1991 It fixes vol struct foo *a; a->elts[1]
1992 in an inline function.
1993 Hope it doesn't break something else. */
1994 | TREE_THIS_VOLATILE (array
));
1995 return require_complete_type (fold (rval
));
1999 tree ar
= default_conversion (array
);
2000 tree ind
= default_conversion (idx
);
2002 /* Put the integer in IND to simplify error checking. */
2003 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
2010 if (ar
== error_mark_node
)
2013 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
)
2015 error ("subscripted value is neither array nor pointer");
2016 return error_mark_node
;
2018 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
2020 error ("array subscript is not an integer");
2021 return error_mark_node
;
2024 return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR
, ar
, ind
, PLUS_EXPR
),
2029 /* Build a function call to function FUNCTION with parameters PARAMS.
2030 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2031 TREE_VALUE of each node is a parameter-expression.
2032 FUNCTION's data type may be a function type or a pointer-to-function.
2034 For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
2035 is the list of possible methods that FUNCTION could conceivably
2036 be. If the list of methods comes from a class, then it will be
2037 a list of lists (where each element is associated with the class
2038 that produced it), otherwise it will be a simple list (for
2039 functions overloaded in global scope).
2041 In the first case, TREE_VALUE (function) is the head of one of those
2042 lists, and TREE_PURPOSE is the name of the function.
2044 In the second case, TREE_PURPOSE (function) is the function's
2047 DECL is the class instance variable, usually CURRENT_CLASS_DECL. */
2050 * [eichin:19911015.1726EST] actually return a possibly incomplete
2054 build_x_function_call (function
, params
, decl
)
2055 tree function
, params
, decl
;
2060 if (function
== error_mark_node
)
2061 return error_mark_node
;
2063 type
= TREE_TYPE (function
);
2064 is_method
= ((TREE_CODE (function
) == TREE_LIST
2065 && current_class_type
!= NULL_TREE
2066 && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function
)) == function
)
2067 || TREE_CODE (function
) == IDENTIFIER_NODE
2068 || TREE_CODE (type
) == METHOD_TYPE
2069 || TYPE_PTRMEMFUNC_P (type
));
2071 /* Handle methods, friends, and overloaded functions, respectively. */
2074 if (TREE_CODE (function
) == FUNCTION_DECL
)
2076 if (DECL_NAME (function
))
2077 function
= DECL_NAME (function
);
2079 function
= TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
));
2081 else if (TREE_CODE (function
) == TREE_LIST
)
2084 if (TREE_CODE (TREE_VALUE (function
)) == TREE_LIST
)
2085 function
= TREE_PURPOSE (TREE_VALUE (function
));
2087 function
= TREE_PURPOSE (function
);
2089 my_friendly_assert (TREE_CODE (TREE_VALUE (function
)) == FUNCTION_DECL
, 312);
2090 function
= TREE_PURPOSE (function
);
2093 else if (TREE_CODE (function
) != IDENTIFIER_NODE
)
2095 if (TREE_CODE (function
) == OFFSET_REF
)
2097 if (TREE_OPERAND (function
, 0))
2098 decl
= TREE_OPERAND (function
, 0);
2100 /* Call via a pointer to member function. */
2101 if (decl
== NULL_TREE
)
2103 error ("pointer to member function called, but not in class scope");
2104 return error_mark_node
;
2106 /* What other type of POINTER_TYPE could this be? */
2107 if (TREE_CODE (TREE_TYPE (function
)) != POINTER_TYPE
2108 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function
))
2109 && TREE_CODE (function
) != OFFSET_REF
)
2110 function
= build (OFFSET_REF
, TREE_TYPE (type
), NULL_TREE
, function
);
2114 /* this is an abbreviated method call.
2115 must go through here in case it is a virtual function.
2116 @@ Perhaps this could be optimized. */
2118 if (decl
== NULL_TREE
)
2120 if (current_class_type
== NULL_TREE
)
2122 error ("object missing in call to method `%s'",
2123 IDENTIFIER_POINTER (function
));
2124 return error_mark_node
;
2126 /* Yow: call from a static member function. */
2127 decl
= build1 (NOP_EXPR
, TYPE_POINTER_TO (current_class_type
),
2129 decl
= build_indirect_ref (decl
, NULL_PTR
);
2132 return build_method_call (decl
, function
, params
,
2133 NULL_TREE
, LOOKUP_NORMAL
);
2135 else if (TREE_CODE (function
) == COMPONENT_REF
2136 && type
== unknown_type_node
)
2138 /* Should we undo what was done in build_component_ref? */
2139 if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function
, 1))) == TREE_VEC
)
2140 /* Get the name that build_component_ref hid. */
2141 function
= DECL_NAME (TREE_VALUE (TREE_OPERAND (function
, 1)));
2143 function
= TREE_PURPOSE (TREE_OPERAND (function
, 1));
2144 return build_method_call (decl
, function
, params
,
2145 NULL_TREE
, LOOKUP_NORMAL
);
2147 else if (TREE_CODE (function
) == TREE_LIST
)
2149 if (TREE_VALUE (function
) == NULL_TREE
)
2151 cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
2152 TREE_PURPOSE (function
));
2153 return error_mark_node
;
2157 tree val
= TREE_VALUE (function
);
2159 if (TREE_CODE (val
) == TEMPLATE_DECL
)
2160 return build_overload_call_maybe
2161 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2162 else if (DECL_CHAIN (val
) != NULL_TREE
)
2163 return build_overload_call
2164 (function
, params
, LOOKUP_COMPLAIN
, (struct candidate
*)0);
2166 my_friendly_abort (360);
2171 if (TREE_CODE (function
) == OFFSET_REF
)
2173 /* If the component is a data element (or a virtual function), we play
2174 games here to make things work. */
2177 if (TREE_OPERAND (function
, 0))
2178 decl
= TREE_OPERAND (function
, 0);
2182 decl_addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
2183 function
= get_member_function_from_ptrfunc (&decl_addr
,
2184 TREE_OPERAND (function
, 1));
2185 params
= tree_cons (NULL_TREE
, decl_addr
, params
);
2186 return build_function_call (function
, params
);
2189 type
= TREE_TYPE (function
);
2190 if (type
!= error_mark_node
)
2192 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2193 type
= TREE_TYPE (type
);
2195 if (TYPE_LANG_SPECIFIC (type
) && TYPE_OVERLOADS_CALL_EXPR (type
))
2196 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, function
, params
, NULL_TREE
);
2201 tree fntype
= TREE_TYPE (function
);
2204 /* Explicitly named method? */
2205 if (TREE_CODE (function
) == FUNCTION_DECL
)
2206 ctypeptr
= TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function
));
2207 /* Expression with ptr-to-method type? It could either be a plain
2208 usage, or it might be a case where the ptr-to-method is being
2209 passed in as an argument. */
2210 else if (TYPE_PTRMEMFUNC_P (fntype
))
2212 tree rec
= TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype
)));
2213 ctypeptr
= TYPE_POINTER_TO (rec
);
2215 /* Unexpected node type? */
2217 my_friendly_abort (116);
2218 if (decl
== NULL_TREE
)
2220 if (current_function_decl
2221 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2222 error ("invalid call to member function needing `this' in static member function scope");
2224 error ("pointer to member function called, but not in class scope");
2225 return error_mark_node
;
2227 if (TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
2228 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2230 decl
= build_unary_op (ADDR_EXPR
, decl
, 0);
2231 decl
= convert_pointer_to (TREE_TYPE (ctypeptr
), decl
);
2234 decl
= build_c_cast (ctypeptr
, decl
, 0);
2235 params
= tree_cons (NULL_TREE
, decl
, params
);
2238 return build_function_call (function
, params
);
2241 /* Resolve a pointer to member function. INSTANCE is the object
2242 instance to use, if the member points to a virtual member. */
2245 get_member_function_from_ptrfunc (instance_ptrptr
, function
)
2246 tree
*instance_ptrptr
;
2249 if (TREE_CODE (function
) == OFFSET_REF
)
2251 function
= TREE_OPERAND (function
, 1);
2254 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
2256 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
2257 tree index
= save_expr (build_component_ref (function
,
2260 tree e1
= build (GT_EXPR
, boolean_type_node
, index
,
2261 convert (delta_type_node
, integer_zero_node
));
2262 tree delta
= convert (ptrdiff_type_node
,
2263 build_component_ref (function
, delta_identifier
, 0, 0));
2264 tree delta2
= DELTA2_FROM_PTRMEMFUNC (function
);
2270 tree instance_ptr
= *instance_ptrptr
;
2272 if (TREE_SIDE_EFFECTS (instance_ptr
))
2273 instance_ptr
= save_expr (instance_ptr
);
2275 /* convert down to the right base, before using the instance. */
2277 = convert_pointer_to_real (TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
)),
2279 if (instance
== error_mark_node
)
2282 vtbl
= convert_pointer_to (ptr_type_node
, instance
);
2285 build_pointer_type (build_pointer_type (vtable_entry_type
)),
2286 vtbl
, convert (ptrdiff_type_node
, delta2
));
2287 vtbl
= build_indirect_ref (vtbl
, NULL_PTR
);
2288 aref
= build_array_ref (vtbl
, build_binary_op (MINUS_EXPR
,
2290 integer_one_node
, 1));
2291 if (! flag_vtable_thunks
)
2293 aref
= save_expr (aref
);
2295 /* Save the intermediate result in a SAVE_EXPR so we don't have to
2296 compute each component of the virtual function pointer twice. */
2297 if (/* !building_cleanup && */ TREE_CODE (aref
) == INDIRECT_REF
)
2298 TREE_OPERAND (aref
, 0) = save_expr (TREE_OPERAND (aref
, 0));
2300 delta
= build_binary_op (PLUS_EXPR
,
2301 build_conditional_expr (e1
, build_component_ref (aref
, delta_identifier
, 0, 0), integer_zero_node
),
2305 *instance_ptrptr
= build (PLUS_EXPR
, TREE_TYPE (instance_ptr
),
2306 instance_ptr
, delta
);
2307 if (flag_vtable_thunks
)
2310 e2
= build_component_ref (aref
, pfn_identifier
, 0, 0);
2312 e3
= PFN_FROM_PTRMEMFUNC (function
);
2313 TREE_TYPE (e2
) = TREE_TYPE (e3
);
2314 function
= build_conditional_expr (e1
, e2
, e3
);
2316 /* Make sure this doesn't get evaluated first inside one of the
2317 branches of the COND_EXPR. */
2318 if (TREE_CODE (instance_ptr
) == SAVE_EXPR
)
2319 function
= build (COMPOUND_EXPR
, TREE_TYPE (function
),
2320 instance_ptr
, function
);
2326 build_function_call_real (function
, params
, require_complete
, flags
)
2327 tree function
, params
;
2328 int require_complete
, flags
;
2330 register tree fntype
, fndecl
;
2331 register tree value_type
;
2332 register tree coerced_params
;
2333 tree name
= NULL_TREE
, assembler_name
= NULL_TREE
;
2336 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2337 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
2338 if (TREE_CODE (function
) == NOP_EXPR
2339 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
2340 function
= TREE_OPERAND (function
, 0);
2342 if (TREE_CODE (function
) == FUNCTION_DECL
)
2344 name
= DECL_NAME (function
);
2345 assembler_name
= DECL_ASSEMBLER_NAME (function
);
2347 GNU_xref_call (current_function_decl
,
2348 IDENTIFIER_POINTER (name
? name
2349 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function
))));
2350 assemble_external (function
);
2353 /* Convert anything with function type to a pointer-to-function. */
2356 && IDENTIFIER_LENGTH (name
) == 4
2357 && ! strcmp (IDENTIFIER_POINTER (name
), "main")
2358 && DECL_CONTEXT (function
) == NULL_TREE
)
2360 pedwarn ("ANSI C++ forbids calling `main' from within program");
2363 if (pedantic
&& DECL_THIS_INLINE (function
) && ! DECL_INITIAL (function
)
2364 && ! DECL_ARTIFICIAL (function
)
2365 && ! DECL_PENDING_INLINE_INFO (function
))
2366 cp_pedwarn ("inline function `%#D' called before definition",
2369 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2370 (because calling an inline function does not mean the function
2371 needs to be separately compiled). */
2373 if (DECL_INLINE (function
))
2375 fntype
= build_type_variant (TREE_TYPE (function
),
2376 TREE_READONLY (function
),
2377 TREE_THIS_VOLATILE (function
));
2378 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2382 assemble_external (function
);
2383 TREE_USED (function
) = 1;
2384 function
= default_conversion (function
);
2391 /* Convert anything with function type to a pointer-to-function. */
2392 if (function
== error_mark_node
)
2393 return error_mark_node
;
2394 function
= default_conversion (function
);
2397 fntype
= TREE_TYPE (function
);
2399 if (TYPE_PTRMEMFUNC_P (fntype
))
2401 tree instance_ptr
= build_unary_op (ADDR_EXPR
, C_C_D
, 0);
2402 fntype
= TYPE_PTRMEMFUNC_FN_TYPE (fntype
);
2403 function
= get_member_function_from_ptrfunc (&instance_ptr
, function
);
2406 is_method
= (TREE_CODE (fntype
) == POINTER_TYPE
2407 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
2409 if (!((TREE_CODE (fntype
) == POINTER_TYPE
2410 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
)
2413 cp_error ("`%E' cannot be used as a function", function
);
2414 return error_mark_node
;
2417 /* fntype now gets the type of function pointed to. */
2418 fntype
= TREE_TYPE (fntype
);
2420 /* Convert the parameters to the types declared in the
2421 function prototype, or apply default promotions. */
2423 if (flags
& LOOKUP_COMPLAIN
)
2424 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2425 params
, fndecl
, LOOKUP_NORMAL
);
2427 coerced_params
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2430 /* Check for errors in format strings. */
2432 if (warn_format
&& (name
|| assembler_name
))
2433 check_function_format (name
, assembler_name
, coerced_params
);
2435 /* Recognize certain built-in functions so we can make tree-codes
2436 other than CALL_EXPR. We do this when it enables fold-const.c
2437 to do something useful. */
2439 if (TREE_CODE (function
) == ADDR_EXPR
2440 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
2441 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
2442 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function
, 0)))
2447 if (coerced_params
== 0)
2448 return integer_zero_node
;
2449 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2453 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2455 register tree result
=
2456 build (CALL_EXPR
, value_type
,
2457 function
, coerced_params
, NULL_TREE
);
2459 TREE_SIDE_EFFECTS (result
) = 1;
2461 if (! require_complete
)
2462 return convert_from_reference (result
);
2463 if (value_type
== void_type_node
)
2465 result
= require_complete_type (result
);
2466 return convert_from_reference (result
);
2471 build_function_call (function
, params
)
2472 tree function
, params
;
2474 return build_function_call_real (function
, params
, 1, LOOKUP_NORMAL
);
2478 build_function_call_maybe (function
, params
)
2479 tree function
, params
;
2481 return build_function_call_real (function
, params
, 0, 0);
2485 /* Convert the actual parameter expressions in the list VALUES
2486 to the types in the list TYPELIST.
2487 If parmdecls is exhausted, or when an element has NULL as its type,
2488 perform the default conversions.
2490 RETURN_LOC is the location of the return value, if known, NULL_TREE
2491 otherwise. This is useful in the case where we can avoid creating
2492 a temporary variable in the case where we can initialize the return
2493 value directly. If we are not eliding constructors, then we set this
2494 to NULL_TREE to avoid this avoidance.
2496 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
2498 This is also where warnings about wrong number of args are generated.
2500 Return a list of expressions for the parameters as converted.
2502 Both VALUES and the returned value are chains of TREE_LIST nodes
2503 with the elements of the list in the TREE_VALUE slots of those nodes.
2505 In C++, unspecified trailing parameters can be filled in with their
2506 default arguments, if such were specified. Do so here. */
2509 convert_arguments (return_loc
, typelist
, values
, fndecl
, flags
)
2510 tree return_loc
, typelist
, values
, fndecl
;
2513 extern tree gc_protect_fndecl
;
2514 register tree typetail
, valtail
;
2515 register tree result
= NULL_TREE
;
2519 if (! flag_elide_constructors
)
2524 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
2526 if (DECL_NAME (fndecl
) == NULL_TREE
2527 || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl
)))
2528 called_thing
= "constructor";
2530 called_thing
= "member function";
2533 called_thing
= "function";
2536 for (valtail
= values
, typetail
= typelist
;
2538 valtail
= TREE_CHAIN (valtail
), i
++)
2540 register tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2541 register tree val
= TREE_VALUE (valtail
);
2543 if (val
== error_mark_node
)
2546 if (type
== void_type_node
)
2550 char *buf
= (char *)alloca (40 + strlen (called_thing
));
2551 sprintf (buf
, "too many arguments to %s `%%s'", called_thing
);
2552 error_with_decl (fndecl
, buf
);
2553 error ("at this point in file");
2556 error ("too many arguments to function");
2557 /* In case anybody wants to know if this argument
2560 TREE_TYPE (tree_last (result
)) = error_mark_node
;
2564 /* The tree type of the parameter being passed may not yet be
2565 known. In this case, its type is TYPE_UNKNOWN, and will
2566 be instantiated by the type given by TYPE. If TYPE
2567 is also NULL, the tree type of VAL is ERROR_MARK_NODE. */
2568 if (type
&& type_unknown_p (val
))
2569 val
= require_instantiated_type (type
, val
, integer_zero_node
);
2570 else if (type_unknown_p (val
))
2572 /* Strip the `&' from an overloaded FUNCTION_DECL. */
2573 if (TREE_CODE (val
) == ADDR_EXPR
)
2574 val
= TREE_OPERAND (val
, 0);
2575 if (TREE_CODE (val
) == TREE_LIST
2576 && TREE_CHAIN (val
) == NULL_TREE
2577 && TREE_TYPE (TREE_VALUE (val
)) != NULL_TREE
2578 && (TREE_TYPE (val
) == unknown_type_node
2579 || DECL_CHAIN (TREE_VALUE (val
)) == NULL_TREE
))
2580 /* Instantiates automatically. */
2581 val
= TREE_VALUE (val
);
2584 error ("insufficient type information in parameter list");
2585 val
= integer_zero_node
;
2588 else if (TREE_CODE (val
) == OFFSET_REF
2589 && TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2591 /* This is unclean. Should be handled elsewhere. */
2592 val
= build_unary_op (ADDR_EXPR
, val
, 0);
2594 else if (TREE_CODE (val
) == OFFSET_REF
)
2595 val
= resolve_offset_ref (val
);
2599 /* This code forces the assumption that if we have a ptr-to-func
2600 type in an arglist, that every routine that wants to check
2601 its validity has done so, and thus we need not do any
2602 more conversion. I don't remember why this is necessary. */
2603 else if (TREE_CODE (ttype
) == FUNCTION_TYPE
2605 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
2606 || TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
))
2608 type
= build_pointer_type (ttype
);
2613 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2614 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
2615 if (TREE_CODE (val
) == NOP_EXPR
2616 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
2617 && (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
))
2618 val
= TREE_OPERAND (val
, 0);
2620 if (type
== 0 || TREE_CODE (type
) != REFERENCE_TYPE
)
2622 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
2623 || TREE_CODE (TREE_TYPE (val
)) == FUNCTION_TYPE
2624 || TREE_CODE (TREE_TYPE (val
)) == METHOD_TYPE
)
2625 val
= default_conversion (val
);
2627 val
= require_complete_type (val
);
2630 if (val
== error_mark_node
)
2635 /* Formal parm type is specified by a function prototype. */
2638 if (TYPE_SIZE (type
) == 0)
2640 error ("parameter type of called function is incomplete");
2645 #if 0 && defined (PROMOTE_PROTOTYPES)
2646 /* This breaks user-defined conversions. */
2647 /* Rather than truncating and then reextending,
2648 convert directly to int, if that's the type we will want. */
2649 if (! flag_traditional
2650 && (TREE_CODE (type
) == INTEGER_TYPE
2651 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2652 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2653 type
= integer_type_node
;
2655 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2656 "argument passing", fndecl
, i
);
2657 #ifdef PROMOTE_PROTOTYPES
2658 if ((TREE_CODE (type
) == INTEGER_TYPE
2659 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2660 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2661 parmval
= default_conversion (parmval
);
2664 result
= tree_cons (NULL_TREE
, parmval
, result
);
2668 if (TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
2669 val
= convert_from_reference (val
);
2671 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2672 && (TYPE_PRECISION (TREE_TYPE (val
))
2673 < TYPE_PRECISION (double_type_node
)))
2674 /* Convert `float' to `double'. */
2675 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2676 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
2677 && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val
)))
2679 cp_warning ("cannot pass objects of type `%T' through `...'",
2681 result
= tree_cons (NULL_TREE
, val
, result
);
2684 /* Convert `short' and `char' to full-size `int'. */
2685 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2689 /* There are certain functions for which we don't need
2690 to protect our arguments. GC_PROTECT_FNDECL is one. */
2691 && fndecl
!= gc_protect_fndecl
2692 && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result
)))
2693 && ! value_safe_from_gc (NULL_TREE
, TREE_VALUE (result
)))
2694 /* This will build a temporary variable whose cleanup is
2695 to clear the obstack entry. */
2696 TREE_VALUE (result
) = protect_value_from_gc (NULL_TREE
,
2697 TREE_VALUE (result
));
2700 typetail
= TREE_CHAIN (typetail
);
2703 if (typetail
!= 0 && typetail
!= void_list_node
)
2705 /* See if there are default arguments that can be used */
2706 if (TREE_PURPOSE (typetail
))
2708 for (; typetail
!= void_list_node
; ++i
)
2710 tree type
= TREE_VALUE (typetail
);
2711 tree val
= TREE_PURPOSE (typetail
);
2714 if (val
== NULL_TREE
)
2715 parmval
= error_mark_node
;
2716 else if (TREE_CODE (val
) == CONSTRUCTOR
)
2718 parmval
= digest_init (type
, val
, (tree
*)0);
2719 parmval
= convert_for_initialization (return_loc
, type
, parmval
, flags
,
2720 "default constructor", fndecl
, i
);
2724 /* This could get clobbered by the following call. */
2725 if (TREE_HAS_CONSTRUCTOR (val
))
2726 val
= copy_node (val
);
2728 parmval
= convert_for_initialization (return_loc
, type
, val
, flags
,
2729 "default argument", fndecl
, i
);
2730 #ifdef PROMOTE_PROTOTYPES
2731 if ((TREE_CODE (type
) == INTEGER_TYPE
2732 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2733 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2734 parmval
= default_conversion (parmval
);
2739 && type_needs_gc_entry (TREE_TYPE (parmval
))
2740 && ! value_safe_from_gc (NULL_TREE
, parmval
))
2741 parmval
= protect_value_from_gc (NULL_TREE
, parmval
);
2743 result
= tree_cons (0, parmval
, result
);
2744 typetail
= TREE_CHAIN (typetail
);
2745 /* ends with `...'. */
2746 if (typetail
== NULL_TREE
)
2754 char *buf
= (char *)alloca (32 + strlen (called_thing
));
2755 sprintf (buf
, "too few arguments to %s `%%#D'", called_thing
);
2756 cp_error_at (buf
, fndecl
);
2757 error ("at this point in file");
2760 error ("too few arguments to function");
2761 return error_mark_list
;
2765 return nreverse (result
);
2768 /* Build a binary-operation expression, after performing default
2769 conversions on the operands. CODE is the kind of expression to build. */
2772 build_x_binary_op (code
, arg1
, arg2
)
2773 enum tree_code code
;
2776 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
,
2777 arg1
, arg2
, NULL_TREE
);
2779 return build_opfncall (code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
);
2780 if (code
== MEMBER_REF
)
2781 return build_m_component_ref (build_indirect_ref (arg1
, NULL_PTR
),
2783 return build_binary_op (code
, arg1
, arg2
, 1);
2787 build_binary_op (code
, arg1
, arg2
, convert_p
)
2788 enum tree_code code
;
2801 args
[0] = args_save
[0] = default_conversion (args
[0]);
2802 args
[1] = args_save
[1] = default_conversion (args
[1]);
2804 if (args
[0] == error_mark_node
|| args
[1] == error_mark_node
)
2805 return error_mark_node
;
2807 type0
= TREE_TYPE (args
[0]);
2808 type1
= TREE_TYPE (args
[1]);
2810 if (type_unknown_p (args
[0]))
2812 args
[0] = instantiate_type (type1
, args
[0], 1);
2813 args
[0] = default_conversion (args
[0]);
2815 else if (type_unknown_p (args
[1]))
2817 args
[1] = require_instantiated_type (type0
, args
[1],
2819 args
[1] = default_conversion (args
[1]);
2822 if (IS_AGGR_TYPE (type0
) || IS_AGGR_TYPE (type1
))
2824 /* Try to convert this to something reasonable. */
2825 if (! build_default_binary_type_conversion(code
, &args
[0], &args
[1]))
2827 cp_error ("no match for `%O(%#T, %#T)'", code
,
2828 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
2829 return error_mark_node
;
2833 if (args
[0] == args_save
[0])
2835 if (args
[1] == args_save
[1])
2838 return build_binary_op_nodefault (code
, args
[0], args
[1], code
);
2841 /* Build a binary-operation expression without default conversions.
2842 CODE is the kind of expression to build.
2843 This function differs from `build' in several ways:
2844 the data type of the result is computed and recorded in it,
2845 warnings are generated if arg data types are invalid,
2846 special handling for addition and subtraction of pointers is known,
2847 and some optimization is done (operations on narrow ints
2848 are done in the narrower type when that gives the same result).
2849 Constant folding is also done before the result is returned.
2851 ERROR_CODE is the code that determines what to say in error messages.
2852 It is usually, but not always, the same as CODE.
2854 Note that the operands will never have enumeral types
2855 because either they have just had the default conversions performed
2856 or they have both just been converted to some other type in which
2857 the arithmetic is to be done.
2859 C++: must do special pointer arithmetic when implementing
2860 multiple inheritance, and deal with pointer to member functions. */
2863 build_binary_op_nodefault (code
, orig_op0
, orig_op1
, error_code
)
2864 enum tree_code code
;
2865 tree orig_op0
, orig_op1
;
2866 enum tree_code error_code
;
2869 register enum tree_code code0
, code1
;
2872 /* Expression code to give to the expression when it is built.
2873 Normally this is CODE, which is what the caller asked for,
2874 but in some special cases we change it. */
2875 register enum tree_code resultcode
= code
;
2877 /* Data type in which the computation is to be performed.
2878 In the simplest cases this is the common type of the arguments. */
2879 register tree result_type
= NULL
;
2881 /* Nonzero means operands have already been type-converted
2882 in whatever way is necessary.
2883 Zero means they need to be converted to RESULT_TYPE. */
2886 /* Nonzero means create the expression with this type, rather than
2888 tree build_type
= 0;
2890 /* Nonzero means after finally constructing the expression
2891 convert it to this type. */
2892 tree final_type
= 0;
2894 /* Nonzero if this is an operation like MIN or MAX which can
2895 safely be computed in short if both args are promoted shorts.
2896 Also implies COMMON.
2897 -1 indicates a bitwise operation; this makes a difference
2898 in the exact conditions for when it is safe to do the operation
2899 in a narrower mode. */
2902 /* Nonzero if this is a comparison operation;
2903 if both args are promoted shorts, compare the original shorts.
2904 Also implies COMMON. */
2905 int short_compare
= 0;
2907 /* Nonzero if this is a right-shift operation, which can be computed on the
2908 original short and then promoted if the operand is a promoted short. */
2909 int short_shift
= 0;
2911 /* Nonzero means set RESULT_TYPE to the common type of the args. */
2914 /* Apply default conversions. */
2915 op0
= default_conversion (orig_op0
);
2916 op1
= default_conversion (orig_op1
);
2918 type0
= TREE_TYPE (op0
);
2919 type1
= TREE_TYPE (op1
);
2921 /* The expression codes of the data types of the arguments tell us
2922 whether the arguments are integers, floating, pointers, etc. */
2923 code0
= TREE_CODE (type0
);
2924 code1
= TREE_CODE (type1
);
2926 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2927 STRIP_TYPE_NOPS (op0
);
2928 STRIP_TYPE_NOPS (op1
);
2930 /* If an error was already reported for one of the arguments,
2931 avoid reporting another error. */
2933 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
2934 return error_mark_node
;
2939 /* Handle the pointer + int case. */
2940 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2941 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
2942 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
2943 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
2949 /* Subtraction of two similar pointers.
2950 We must subtract them as integers, then divide by object size. */
2951 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
2952 && comp_target_types (type0
, type1
, 1))
2953 return pointer_diff (op0
, op1
);
2954 /* Handle pointer minus int. Just like pointer plus int. */
2955 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2956 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
2965 case TRUNC_DIV_EXPR
:
2967 case FLOOR_DIV_EXPR
:
2968 case ROUND_DIV_EXPR
:
2969 case EXACT_DIV_EXPR
:
2970 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2971 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2973 if (TREE_CODE (op1
) == INTEGER_CST
&& integer_zerop (op1
))
2974 cp_warning ("division by zero in `%E / 0'", op0
);
2975 else if (TREE_CODE (op1
) == REAL_CST
&& real_zerop (op1
))
2976 cp_warning ("division by zero in `%E / 0.'", op0
);
2978 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
2979 resultcode
= RDIV_EXPR
;
2981 /* When dividing two signed integers, we have to promote to int.
2982 unless we divide by a conatant != -1. Note that default
2983 conversion will have been performed on the operands at this
2984 point, so we have to dig out the original type to find out if
2986 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
2987 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
2988 || (TREE_CODE (op1
) == INTEGER_CST
2989 && (TREE_INT_CST_LOW (op1
) != -1
2990 || TREE_INT_CST_HIGH (op1
) != -1)));
2996 case BIT_ANDTC_EXPR
:
2999 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3001 /* If one operand is a constant, and the other is a short type
3002 that has been converted to an int,
3003 really do the work in the short type and then convert the
3004 result to int. If we are lucky, the constant will be 0 or 1
3005 in the short type, making the entire operation go away. */
3006 if (TREE_CODE (op0
) == INTEGER_CST
3007 && TREE_CODE (op1
) == NOP_EXPR
3008 && TYPE_PRECISION (type1
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))
3009 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1
, 0))))
3011 final_type
= result_type
;
3012 op1
= TREE_OPERAND (op1
, 0);
3013 result_type
= TREE_TYPE (op1
);
3015 if (TREE_CODE (op1
) == INTEGER_CST
3016 && TREE_CODE (op0
) == NOP_EXPR
3017 && TYPE_PRECISION (type0
) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))
3018 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3020 final_type
= result_type
;
3021 op0
= TREE_OPERAND (op0
, 0);
3022 result_type
= TREE_TYPE (op0
);
3026 case TRUNC_MOD_EXPR
:
3027 case FLOOR_MOD_EXPR
:
3028 if (code1
== INTEGER_TYPE
&& integer_zerop (op1
))
3029 cp_warning ("division by zero in `%E % 0'", op0
);
3030 else if (code1
== REAL_TYPE
&& real_zerop (op1
))
3031 cp_warning ("division by zero in `%E % 0.'", op0
);
3033 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3035 /* Although it would be tempting to shorten always here, that loses
3036 on some targets, since the modulo instruction is undefined if the
3037 quotient can't be represented in the computation mode. We shorten
3038 only if unsigned or if dividing by something we know != -1. */
3039 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
3040 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
3041 || (TREE_CODE (op1
) == INTEGER_CST
3042 && (TREE_INT_CST_LOW (op1
) != -1
3043 || TREE_INT_CST_HIGH (op1
) != -1)));
3048 case TRUTH_ANDIF_EXPR
:
3049 case TRUTH_ORIF_EXPR
:
3050 case TRUTH_AND_EXPR
:
3052 result_type
= boolean_type_node
;
3055 /* Shift operations: result has same type as first operand;
3056 always convert second operand to int.
3057 Also set SHORT_SHIFT if shifting rightward. */
3060 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3062 result_type
= type0
;
3063 if (TREE_CODE (op1
) == INTEGER_CST
)
3065 if (tree_int_cst_lt (op1
, integer_zero_node
))
3066 warning ("right shift count is negative");
3069 if (TREE_INT_CST_LOW (op1
) | TREE_INT_CST_HIGH (op1
))
3071 if (TREE_INT_CST_HIGH (op1
) != 0
3072 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3073 >= TYPE_PRECISION (type0
)))
3074 warning ("right shift count >= width of type");
3077 /* Convert the shift-count to an integer, regardless of
3078 size of value being shifted. */
3079 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3080 op1
= convert (integer_type_node
, op1
);
3081 /* Avoid converting op1 to result_type later. */
3087 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3089 result_type
= type0
;
3090 if (TREE_CODE (op1
) == INTEGER_CST
)
3092 if (tree_int_cst_lt (op1
, integer_zero_node
))
3093 warning ("left shift count is negative");
3094 else if (TREE_INT_CST_HIGH (op1
) != 0
3095 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3096 >= TYPE_PRECISION (type0
)))
3097 warning ("left shift count >= width of type");
3099 /* Convert the shift-count to an integer, regardless of
3100 size of value being shifted. */
3101 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3102 op1
= convert (integer_type_node
, op1
);
3103 /* Avoid converting op1 to result_type later. */
3110 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
3112 result_type
= type0
;
3113 if (TREE_CODE (op1
) == INTEGER_CST
)
3115 if (tree_int_cst_lt (op1
, integer_zero_node
))
3116 warning ("%s rotate count is negative",
3117 (code
== LROTATE_EXPR
) ? "left" : "right");
3118 else if (TREE_INT_CST_HIGH (op1
) != 0
3119 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (op1
)
3120 >= TYPE_PRECISION (type0
)))
3121 warning ("%s rotate count >= width of type",
3122 (code
== LROTATE_EXPR
) ? "left" : "right");
3124 /* Convert the shift-count to an integer, regardless of
3125 size of value being shifted. */
3126 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
3127 op1
= convert (integer_type_node
, op1
);
3133 build_type
= boolean_type_node
;
3134 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3135 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3137 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3139 register tree tt0
= TYPE_MAIN_VARIANT (TREE_TYPE (type0
));
3140 register tree tt1
= TYPE_MAIN_VARIANT (TREE_TYPE (type1
));
3142 if (comp_target_types (type0
, type1
, 1))
3143 result_type
= common_type (type0
, type1
);
3144 else if (tt0
== void_type_node
)
3146 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
3147 && tree_int_cst_lt (TYPE_SIZE (type0
), TYPE_SIZE (type1
)))
3148 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3149 else if (TREE_CODE (tt1
) == OFFSET_TYPE
)
3150 pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'");
3152 else if (tt1
== void_type_node
)
3154 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
3155 && tree_int_cst_lt (TYPE_SIZE (type1
), TYPE_SIZE (type0
)))
3156 pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
3159 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3162 if (result_type
== NULL_TREE
)
3163 result_type
= ptr_type_node
;
3165 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3166 && integer_zerop (op1
))
3167 result_type
= type0
;
3168 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3169 && integer_zerop (op0
))
3170 result_type
= type1
;
3171 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3173 result_type
= type0
;
3174 error ("ANSI C++ forbids comparison between pointer and integer");
3176 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3178 result_type
= type1
;
3179 error ("ANSI C++ forbids comparison between pointer and integer");
3181 else if (TYPE_PTRMEMFUNC_P (type0
) && TREE_CODE (op1
) == INTEGER_CST
3182 && integer_zerop (op1
))
3184 op0
= build_component_ref (op0
, index_identifier
, 0, 0);
3185 op1
= integer_zero_node
;
3186 result_type
= TREE_TYPE (op0
);
3188 else if (TYPE_PTRMEMFUNC_P (type1
) && TREE_CODE (op0
) == INTEGER_CST
3189 && integer_zerop (op0
))
3191 op0
= build_component_ref (op1
, index_identifier
, 0, 0);
3192 op1
= integer_zero_node
;
3193 result_type
= TREE_TYPE (op0
);
3195 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
)
3196 && (TYPE_PTRMEMFUNC_FN_TYPE (type0
)
3197 == TYPE_PTRMEMFUNC_FN_TYPE (type1
)))
3199 /* The code we generate for the test is:
3201 (op0.index == op1.index
3202 && ((op1.index != -1 && op0.delta2 == op1.delta2)
3203 || op0.pfn == op1.pfn)) */
3205 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3206 tree index1
= save_expr (build_component_ref (op1
, index_identifier
, 0, 0));
3207 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3208 tree pfn1
= PFN_FROM_PTRMEMFUNC (op1
);
3209 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3210 tree delta21
= DELTA2_FROM_PTRMEMFUNC (op1
);
3212 tree integer_neg_one_node
3213 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3214 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3215 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3216 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3217 e3
= build_binary_op (EQ_EXPR
, pfn0
, pfn1
, 1);
3218 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3219 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3220 if (code
== EQ_EXPR
)
3222 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3224 else if (TYPE_PTRMEMFUNC_P (type0
)
3225 && TYPE_PTRMEMFUNC_FN_TYPE (type0
) == type1
)
3227 tree index0
= build_component_ref (op0
, index_identifier
, 0, 0);
3229 tree pfn0
= PFN_FROM_PTRMEMFUNC (op0
);
3230 tree delta20
= DELTA2_FROM_PTRMEMFUNC (op0
);
3231 tree delta21
= integer_zero_node
;
3233 tree integer_neg_one_node
3234 = build_binary_op (MINUS_EXPR
, integer_zero_node
, integer_one_node
, 1);
3235 if (TREE_CODE (TREE_OPERAND (op1
, 0)) == FUNCTION_DECL
3236 && DECL_VINDEX (TREE_OPERAND (op1
, 0)))
3238 /* Map everything down one to make room for the null pointer to member. */
3239 index1
= size_binop (PLUS_EXPR
,
3240 DECL_VINDEX (TREE_OPERAND (op1
, 0)),
3242 op1
= integer_zero_node
;
3243 delta21
= CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1
)));
3244 delta21
= DECL_FIELD_BITPOS (delta21
);
3245 delta21
= size_binop (FLOOR_DIV_EXPR
, delta21
, size_int (BITS_PER_UNIT
));
3248 index1
= integer_neg_one_node
;
3250 tree nop1
= build1 (NOP_EXPR
, TYPE_PTRMEMFUNC_FN_TYPE (type0
), op1
);
3251 TREE_CONSTANT (nop1
) = TREE_CONSTANT (op1
);
3254 e1
= build_binary_op (EQ_EXPR
, index0
, index1
, 1);
3255 e2
= build_binary_op (NE_EXPR
, index1
, integer_neg_one_node
, 1);
3256 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e2
, build_binary_op (EQ_EXPR
, delta20
, delta21
, 1), 1);
3257 e3
= build_binary_op (EQ_EXPR
, pfn0
, op1
, 1);
3258 e2
= build_binary_op (TRUTH_ORIF_EXPR
, e2
, e3
, 1);
3259 e2
= build_binary_op (TRUTH_ANDIF_EXPR
, e1
, e2
, 1);
3260 if (code
== EQ_EXPR
)
3262 return build_binary_op (EQ_EXPR
, e2
, integer_zero_node
, 1);
3264 else if (TYPE_PTRMEMFUNC_P (type1
)
3265 && TYPE_PTRMEMFUNC_FN_TYPE (type1
) == type0
)
3267 return build_binary_op (code
, op1
, op0
, 1);
3273 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3274 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3276 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3278 if (comp_target_types (type0
, type1
, 1))
3279 result_type
= common_type (type0
, type1
);
3282 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3284 result_type
= ptr_type_node
;
3293 build_type
= boolean_type_node
;
3294 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3295 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3297 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
3299 if (comp_target_types (type0
, type1
, 1))
3300 result_type
= common_type (type0
, type1
);
3303 cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast",
3305 result_type
= ptr_type_node
;
3308 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
3309 && integer_zerop (op1
))
3310 result_type
= type0
;
3311 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
3312 && integer_zerop (op0
))
3313 result_type
= type1
;
3314 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3316 result_type
= type0
;
3318 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3319 else if (! flag_traditional
)
3320 warning ("comparison between pointer and integer");
3322 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
3324 result_type
= type1
;
3326 pedwarn ("ANSI C++ forbids comparison between pointer and integer");
3327 else if (! flag_traditional
)
3328 warning ("comparison between pointer and integer");
3333 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3334 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3336 if (shorten
|| common
|| short_compare
)
3337 result_type
= common_type (type0
, type1
);
3339 /* For certain operations (which identify themselves by shorten != 0)
3340 if both args were extended from the same smaller type,
3341 do the arithmetic in that type and then extend.
3343 shorten !=0 and !=1 indicates a bitwise operation.
3344 For them, this optimization is safe only if
3345 both args are zero-extended or both are sign-extended.
3346 Otherwise, we might change the result.
3347 Eg, (short)-1 | (unsigned short)-1 is (int)-1
3348 but calculated in (unsigned short) it would be (unsigned short)-1. */
3352 int unsigned0
, unsigned1
;
3353 tree arg0
= get_narrower (op0
, &unsigned0
);
3354 tree arg1
= get_narrower (op1
, &unsigned1
);
3355 /* UNS is 1 if the operation to be done is an unsigned one. */
3356 int uns
= TREE_UNSIGNED (result_type
);
3359 final_type
= result_type
;
3361 /* Handle the case that OP0 does not *contain* a conversion
3362 but it *requires* conversion to FINAL_TYPE. */
3364 if (op0
== arg0
&& TREE_TYPE (op0
) != final_type
)
3365 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3366 if (op1
== arg1
&& TREE_TYPE (op1
) != final_type
)
3367 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3369 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
3371 /* For bitwise operations, signedness of nominal type
3372 does not matter. Consider only how operands were extended. */
3376 /* Note that in all three cases below we refrain from optimizing
3377 an unsigned operation on sign-extended args.
3378 That would not be valid. */
3380 /* Both args variable: if both extended in same way
3381 from same width, do it in that width.
3382 Do it unsigned if args were zero-extended. */
3383 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
3384 < TYPE_PRECISION (result_type
))
3385 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3386 == TYPE_PRECISION (TREE_TYPE (arg0
)))
3387 && unsigned0
== unsigned1
3388 && (unsigned0
|| !uns
))
3390 = signed_or_unsigned_type (unsigned0
,
3391 common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
3392 else if (TREE_CODE (arg0
) == INTEGER_CST
3393 && (unsigned1
|| !uns
)
3394 && (TYPE_PRECISION (TREE_TYPE (arg1
))
3395 < TYPE_PRECISION (result_type
))
3396 && (type
= signed_or_unsigned_type (unsigned1
,
3398 int_fits_type_p (arg0
, type
)))
3400 else if (TREE_CODE (arg1
) == INTEGER_CST
3401 && (unsigned0
|| !uns
)
3402 && (TYPE_PRECISION (TREE_TYPE (arg0
))
3403 < TYPE_PRECISION (result_type
))
3404 && (type
= signed_or_unsigned_type (unsigned0
,
3406 int_fits_type_p (arg1
, type
)))
3410 /* Shifts can be shortened if shifting right. */
3415 tree arg0
= get_narrower (op0
, &unsigned_arg
);
3417 final_type
= result_type
;
3419 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
3420 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
3422 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
3423 /* We can shorten only if the shift count is less than the
3424 number of bits in the smaller type size. */
3425 && TREE_INT_CST_HIGH (op1
) == 0
3426 && TYPE_PRECISION (TREE_TYPE (arg0
)) > TREE_INT_CST_LOW (op1
)
3427 /* If arg is sign-extended and then unsigned-shifted,
3428 we can simulate this with a signed shift in arg's type
3429 only if the extended result is at least twice as wide
3430 as the arg. Otherwise, the shift could use up all the
3431 ones made by sign-extension and bring in zeros.
3432 We can't optimize that case at all, but in most machines
3433 it never happens because available widths are 2**N. */
3434 && (!TREE_UNSIGNED (final_type
)
3436 || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0
))
3437 <= TYPE_PRECISION (result_type
))))
3439 /* Do an unsigned shift if the operand was zero-extended. */
3441 = signed_or_unsigned_type (unsigned_arg
,
3443 /* Convert value-to-be-shifted to that type. */
3444 if (TREE_TYPE (op0
) != result_type
)
3445 op0
= convert (result_type
, op0
);
3450 /* Comparison operations are shortened too but differently.
3451 They identify themselves by setting short_compare = 1. */
3455 /* Don't write &op0, etc., because that would prevent op0
3456 from being kept in a register.
3457 Instead, make copies of the our local variables and
3458 pass the copies by reference, then copy them back afterward. */
3459 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
3460 enum tree_code xresultcode
= resultcode
;
3462 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
3464 return convert (boolean_type_node
, val
);
3465 op0
= xop0
, op1
= xop1
;
3467 resultcode
= xresultcode
;
3470 if (short_compare
&& extra_warnings
)
3472 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
3473 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3475 int unsignedp0
, unsignedp1
;
3476 tree primop0
= get_narrower (op0
, &unsignedp0
);
3477 tree primop1
= get_narrower (op1
, &unsignedp1
);
3479 /* Give warnings for comparisons between signed and unsigned
3480 quantities that may fail. */
3481 /* Do the checking based on the original operand trees, so that
3482 casts will be considered, but default promotions won't be. */
3484 /* Do not warn if the comparison is being done in a signed type,
3485 since the signed type will only be chosen if it can represent
3486 all the values of the unsigned type. */
3487 if (! TREE_UNSIGNED (result_type
))
3489 /* Do not warn if both operands are unsigned. */
3490 else if (op0_signed
== op1_signed
)
3492 /* Do not warn if the signed quantity is an unsuffixed
3493 integer literal (or some static constant expression
3494 involving such literals) and it is non-negative. */
3495 else if ((op0_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3496 && tree_int_cst_sgn (orig_op0
) >= 0)
3497 || (op1_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3498 && tree_int_cst_sgn (orig_op1
) >= 0))
3500 /* Do not warn if the comparison is an equality operation,
3501 the unsigned quantity is an integral constant and it does
3502 not use the most significant bit of result_type. */
3503 else if ((resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
3504 && ((op0_signed
&& TREE_CODE (orig_op1
) == INTEGER_CST
3505 && int_fits_type_p (orig_op1
, signed_type (result_type
))
3506 || (op1_signed
&& TREE_CODE (orig_op0
) == INTEGER_CST
3507 && int_fits_type_p (orig_op0
, signed_type (result_type
))))))
3510 warning ("comparison between signed and unsigned");
3512 /* Warn if two unsigned values are being compared in a size
3513 larger than their original size, and one (and only one) is the
3514 result of a `~' operator. This comparison will always fail.
3516 Also warn if one operand is a constant, and the constant does not
3517 have all bits set that are set in the ~ operand when it is
3520 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
3521 ^ TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3523 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
3524 primop0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
3525 if (TREE_CODE (primop1
) == BIT_NOT_EXPR
)
3526 primop1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
3528 if (TREE_CODE (primop0
) == INTEGER_CST
3529 || TREE_CODE (primop1
) == INTEGER_CST
)
3532 HOST_WIDE_INT constant
, mask
;
3536 if (TREE_CODE (primop0
) == INTEGER_CST
)
3539 unsignedp
= unsignedp1
;
3540 constant
= TREE_INT_CST_LOW (primop0
);
3545 unsignedp
= unsignedp0
;
3546 constant
= TREE_INT_CST_LOW (primop1
);
3549 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
3550 if (bits
< TYPE_PRECISION (result_type
)
3551 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
3553 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
3554 if ((mask
& constant
) != mask
)
3555 warning ("comparison of promoted ~unsigned with constant");
3558 else if (unsignedp0
&& unsignedp1
3559 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3560 < TYPE_PRECISION (result_type
))
3561 && (TYPE_PRECISION (TREE_TYPE (primop1
))
3562 < TYPE_PRECISION (result_type
)))
3563 warning ("comparison of promoted ~unsigned with unsigned");
3568 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3569 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3570 Then the expression will be built.
3571 It will be given type FINAL_TYPE if that is nonzero;
3572 otherwise, it will be given type RESULT_TYPE. */
3576 cp_error ("invalid operands `%T' and `%T' to binary `%O'",
3577 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), error_code
);
3578 return error_mark_node
;
3583 if (TREE_TYPE (op0
) != result_type
)
3584 op0
= convert (result_type
, op0
);
3585 if (TREE_TYPE (op1
) != result_type
)
3586 op1
= convert (result_type
, op1
);
3589 if (build_type
== NULL_TREE
)
3590 build_type
= result_type
;
3593 register tree result
= build (resultcode
, build_type
, op0
, op1
);
3594 register tree folded
;
3596 folded
= fold (result
);
3597 if (folded
== result
)
3598 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3599 if (final_type
!= 0)
3600 return convert (final_type
, folded
);
3605 /* Return a tree for the sum or difference (RESULTCODE says which)
3606 of pointer PTROP and integer INTOP. */
3609 pointer_int_sum (resultcode
, ptrop
, intop
)
3610 enum tree_code resultcode
;
3611 register tree ptrop
, intop
;
3615 register tree result
;
3616 register tree folded
= fold (intop
);
3618 /* The result is a pointer of the same type that is being added. */
3620 register tree result_type
= TREE_TYPE (ptrop
);
3622 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3624 if (pedantic
|| warn_pointer_arith
)
3625 pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
3626 size_exp
= integer_one_node
;
3628 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3630 if (pedantic
|| warn_pointer_arith
)
3631 pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
3632 size_exp
= integer_one_node
;
3634 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3636 if (pedantic
|| warn_pointer_arith
)
3637 pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
3638 size_exp
= integer_one_node
;
3640 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
3643 pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
3644 size_exp
= integer_one_node
;
3647 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3649 /* Needed to make OOPS V2R3 work. */
3651 if (TREE_CODE (intop
) == INTEGER_CST
3652 && TREE_INT_CST_LOW (intop
) == 0
3653 && TREE_INT_CST_HIGH (intop
) == 0)
3656 /* If what we are about to multiply by the size of the elements
3657 contains a constant term, apply distributive law
3658 and multiply that constant term separately.
3659 This helps produce common subexpressions. */
3661 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3662 && ! TREE_CONSTANT (intop
)
3663 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3664 && TREE_CONSTANT (size_exp
))
3666 enum tree_code subcode
= resultcode
;
3667 if (TREE_CODE (intop
) == MINUS_EXPR
)
3668 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3669 ptrop
= build_binary_op (subcode
, ptrop
, TREE_OPERAND (intop
, 1), 1);
3670 intop
= TREE_OPERAND (intop
, 0);
3673 /* Convert the integer argument to a type the same size as a pointer
3674 so the multiply won't overflow spuriously. */
3676 if (TYPE_PRECISION (TREE_TYPE (intop
)) != POINTER_SIZE
)
3677 intop
= convert (type_for_size (POINTER_SIZE
, 0), intop
);
3679 /* Replace the integer argument with a suitable product by the object size.
3680 Do this multiplication as signed, then convert to the appropriate
3681 pointer type (actually unsigned integral). */
3683 intop
= convert (result_type
,
3684 build_binary_op (MULT_EXPR
, intop
,
3685 convert (TREE_TYPE (intop
), size_exp
), 1));
3687 /* Create the sum or difference. */
3689 result
= build (resultcode
, result_type
, ptrop
, intop
);
3691 folded
= fold (result
);
3692 if (folded
== result
)
3693 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
3697 /* Return a tree for the difference of pointers OP0 and OP1.
3698 The resulting tree has type int. */
3701 pointer_diff (op0
, op1
)
3702 register tree op0
, op1
;
3704 register tree result
, folded
;
3705 tree restype
= ptrdiff_type_node
;
3706 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3710 if (TREE_CODE (target_type
) == VOID_TYPE
)
3711 pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
3712 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3713 pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
3714 if (TREE_CODE (target_type
) == METHOD_TYPE
)
3715 pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
3716 if (TREE_CODE (target_type
) == OFFSET_TYPE
)
3717 pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
3720 /* First do the subtraction as integers;
3721 then drop through to build the divide operator. */
3723 op0
= build_binary_op (MINUS_EXPR
,
3724 convert (restype
, op0
), convert (restype
, op1
), 1);
3726 /* This generates an error if op1 is a pointer to an incomplete type. */
3727 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1
))) == 0)
3728 error ("arithmetic on pointer to an incomplete type");
3730 op1
= ((TREE_CODE (target_type
) == VOID_TYPE
3731 || TREE_CODE (target_type
) == FUNCTION_TYPE
3732 || TREE_CODE (target_type
) == METHOD_TYPE
3733 || TREE_CODE (target_type
) == OFFSET_TYPE
)
3735 : size_in_bytes (target_type
));
3737 /* Do the division. */
3739 result
= build (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
));
3741 folded
= fold (result
);
3742 if (folded
== result
)
3743 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
3747 /* Handle the case of taking the address of a COMPONENT_REF.
3748 Called by `build_unary_op' and `build_up_reference'.
3750 ARG is the COMPONENT_REF whose address we want.
3751 ARGTYPE is the pointer type that this address should have.
3752 MSG is an error message to print if this COMPONENT_REF is not
3753 addressable (such as a bitfield). */
3756 build_component_addr (arg
, argtype
, msg
)
3760 tree field
= TREE_OPERAND (arg
, 1);
3761 tree basetype
= decl_type_context (field
);
3762 tree rval
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), 0);
3764 if (DECL_BIT_FIELD (field
))
3766 error (msg
, IDENTIFIER_POINTER (DECL_NAME (field
)));
3767 return error_mark_node
;
3771 cp_warning ("address of `%T::%D' taken", basetype
, field
);
3773 if (TREE_CODE (field
) == FIELD_DECL
3774 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
3776 /* Can't convert directly to ARGTYPE, since that
3777 may have the same pointer type as one of our
3779 rval
= build1 (NOP_EXPR
, argtype
,
3780 convert_pointer_to (basetype
, rval
));
3781 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
3784 /* This conversion is harmless. */
3785 rval
= convert_force (argtype
, rval
, 0);
3787 if (! integer_zerop (DECL_FIELD_BITPOS (field
)))
3789 tree offset
= size_binop (EASY_DIV_EXPR
, DECL_FIELD_BITPOS (field
),
3790 size_int (BITS_PER_UNIT
));
3791 int flag
= TREE_CONSTANT (rval
);
3792 rval
= fold (build (PLUS_EXPR
, argtype
,
3793 rval
, convert (argtype
, offset
)));
3794 TREE_CONSTANT (rval
) = flag
;
3799 /* Construct and perhaps optimize a tree representation
3800 for a unary operation. CODE, a tree_code, specifies the operation
3801 and XARG is the operand. */
3804 build_x_unary_op (code
, xarg
)
3805 enum tree_code code
;
3808 /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3810 if (code
== ADDR_EXPR
3811 && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg
)))
3812 && TYPE_SIZE (TREE_TYPE (xarg
)) == NULL_TREE
)
3813 || (TREE_CODE (xarg
) == OFFSET_REF
)))
3814 /* don't look for a function */;
3817 tree rval
= build_opfncall (code
, LOOKUP_SPECULATIVELY
, xarg
,
3818 NULL_TREE
, NULL_TREE
);
3820 return build_opfncall (code
, LOOKUP_NORMAL
, xarg
,
3821 NULL_TREE
, NULL_TREE
);
3823 return build_unary_op (code
, xarg
, 0);
3826 /* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */
3829 condition_conversion (expr
)
3832 tree t
= convert (boolean_type_node
, expr
);
3833 t
= fold (build1 (CLEANUP_POINT_EXPR
, boolean_type_node
, t
));
3837 /* C++: Must handle pointers to members.
3839 Perhaps type instantiation should be extended to handle conversion
3840 from aggregates to types we don't yet know we want? (Or are those
3841 cases typically errors which should be reported?)
3843 NOCONVERT nonzero suppresses the default promotions
3844 (such as from short to int). */
3846 build_unary_op (code
, xarg
, noconvert
)
3847 enum tree_code code
;
3851 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3852 register tree arg
= xarg
;
3853 register tree argtype
= 0;
3854 char *errstring
= NULL
;
3857 if (arg
== error_mark_node
)
3858 return error_mark_node
;
3863 /* This is used for unary plus, because a CONVERT_EXPR
3864 is enough to prevent anybody from looking inside for
3865 associativity, but won't generate any code. */
3866 if (!(arg
= build_expr_type_conversion
3867 (WANT_ARITH
| WANT_ENUM
| WANT_POINTER
, arg
, 1)))
3868 errstring
= "wrong type argument to unary plus";
3872 arg
= default_conversion (arg
);
3873 arg
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (arg
), arg
);
3878 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
3879 errstring
= "wrong type argument to unary minus";
3880 else if (!noconvert
)
3881 arg
= default_conversion (arg
);
3885 if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, arg
, 1)))
3886 errstring
= "wrong type argument to bit-complement";
3887 else if (!noconvert
)
3888 arg
= default_conversion (arg
);
3892 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, 1)))
3893 errstring
= "wrong type argument to abs";
3894 else if (!noconvert
)
3895 arg
= default_conversion (arg
);
3898 case TRUTH_NOT_EXPR
:
3899 arg
= convert (boolean_type_node
, arg
);
3900 val
= invert_truthvalue (arg
);
3901 if (arg
!= error_mark_node
)
3903 errstring
= "in argument to unary !";
3909 case PREINCREMENT_EXPR
:
3910 case POSTINCREMENT_EXPR
:
3911 case PREDECREMENT_EXPR
:
3912 case POSTDECREMENT_EXPR
:
3913 /* Handle complex lvalues (when permitted)
3914 by reduction to simpler cases. */
3916 val
= unary_complex_lvalue (code
, arg
);
3920 /* Report invalid types. */
3922 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
3925 if (code
== PREINCREMENT_EXPR
)
3926 errstring
="no pre-increment operator for type";
3927 else if (code
== POSTINCREMENT_EXPR
)
3928 errstring
="no post-increment operator for type";
3929 else if (code
== PREDECREMENT_EXPR
)
3930 errstring
="no pre-decrement operator for type";
3932 errstring
="no post-decrement operator for type";
3936 /* Report something read-only. */
3938 if (TYPE_READONLY (TREE_TYPE (arg
))
3939 || TREE_READONLY (arg
))
3940 readonly_error (arg
, ((code
== PREINCREMENT_EXPR
3941 || code
== POSTINCREMENT_EXPR
)
3942 ? "increment" : "decrement"),
3947 tree result_type
= TREE_TYPE (arg
);
3949 arg
= get_unwidened (arg
, 0);
3950 argtype
= TREE_TYPE (arg
);
3952 /* ARM $5.2.5 last annotation says this should be forbidden. */
3953 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
3954 pedwarn ("ANSI C++ forbids %sing an enum",
3955 (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3956 ? "increment" : "decrement");
3958 /* Compute the increment. */
3960 if (TREE_CODE (argtype
) == POINTER_TYPE
)
3962 enum tree_code tmp
= TREE_CODE (TREE_TYPE (argtype
));
3963 if (TYPE_SIZE (TREE_TYPE (argtype
)) == 0)
3964 cp_error ("cannot %s a pointer to incomplete type `%T'",
3965 ((code
== PREINCREMENT_EXPR
3966 || code
== POSTINCREMENT_EXPR
)
3967 ? "increment" : "decrement"), TREE_TYPE (argtype
));
3968 else if (tmp
== FUNCTION_TYPE
|| tmp
== METHOD_TYPE
3969 || tmp
== VOID_TYPE
|| tmp
== OFFSET_TYPE
)
3970 cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
3971 ((code
== PREINCREMENT_EXPR
3972 || code
== POSTINCREMENT_EXPR
)
3973 ? "increment" : "decrement"), argtype
);
3974 inc
= c_sizeof_nowarn (TREE_TYPE (argtype
));
3977 inc
= integer_one_node
;
3979 inc
= convert (argtype
, inc
);
3981 /* Handle incrementing a cast-expression. */
3983 switch (TREE_CODE (arg
))
3988 case FIX_TRUNC_EXPR
:
3989 case FIX_FLOOR_EXPR
:
3990 case FIX_ROUND_EXPR
:
3993 tree incremented
, modify
, value
;
3994 if (! lvalue_p (arg
) && pedantic
)
3995 pedwarn ("cast to non-reference type used as lvalue");
3996 arg
= stabilize_reference (arg
);
3997 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4000 value
= save_expr (arg
);
4001 incremented
= build (((code
== PREINCREMENT_EXPR
4002 || code
== POSTINCREMENT_EXPR
)
4003 ? PLUS_EXPR
: MINUS_EXPR
),
4004 argtype
, value
, inc
);
4005 TREE_SIDE_EFFECTS (incremented
) = 1;
4006 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
4007 return build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
4011 /* Complain about anything else that is not a true lvalue. */
4012 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
4013 || code
== POSTINCREMENT_EXPR
)
4014 ? "increment" : "decrement")))
4015 return error_mark_node
;
4017 /* Forbid using -- on `bool'. */
4018 if (TREE_TYPE (arg
) == boolean_type_node
)
4020 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
4022 cp_error ("invalid use of `--' on bool variable `%D'", arg
);
4023 return error_mark_node
;
4026 /* This will only work if someone can convince Kenner to accept
4027 my patch to expand_increment. (jason) */
4028 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4030 if (code
== POSTINCREMENT_EXPR
)
4032 arg
= stabilize_reference (arg
);
4033 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4035 TREE_SIDE_EFFECTS (val
) = 1;
4036 arg
= save_expr (arg
);
4037 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4038 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4041 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4046 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
4048 TREE_SIDE_EFFECTS (val
) = 1;
4049 return convert (result_type
, val
);
4053 /* Note that this operation never does default_conversion
4054 regardless of NOCONVERT. */
4056 argtype
= TREE_TYPE (arg
);
4057 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
4059 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4060 TREE_REFERENCE_EXPR (arg
) = 1;
4064 && TREE_CODE (arg
) == FUNCTION_DECL
4066 && DECL_CONTEXT (arg
) == NULL_TREE
4067 && IDENTIFIER_LENGTH (DECL_NAME (arg
)) == 4
4068 && IDENTIFIER_POINTER (DECL_NAME (arg
))[0] == 'm'
4069 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg
)), "main"))
4071 pedwarn ("taking address of function `main'");
4073 /* Let &* cancel out to simplify resulting code. */
4074 if (TREE_CODE (arg
) == INDIRECT_REF
)
4076 /* We don't need to have `current_class_decl' wrapped in a
4077 NON_LVALUE_EXPR node. */
4079 return current_class_decl
;
4081 /* Keep `default_conversion' from converting if
4082 ARG is of REFERENCE_TYPE. */
4083 arg
= TREE_OPERAND (arg
, 0);
4084 if (TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
)
4086 if (TREE_CODE (arg
) == VAR_DECL
&& DECL_INITIAL (arg
)
4087 && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg
)))
4088 arg
= DECL_INITIAL (arg
);
4089 arg
= build1 (CONVERT_EXPR
, build_pointer_type (TREE_TYPE (TREE_TYPE (arg
))), arg
);
4090 TREE_REFERENCE_EXPR (arg
) = 1;
4091 TREE_CONSTANT (arg
) = TREE_CONSTANT (TREE_OPERAND (arg
, 0));
4093 else if (lvalue_p (arg
))
4094 /* Don't let this be an lvalue. */
4095 return non_lvalue (arg
);
4099 /* For &x[y], return x+y */
4100 if (TREE_CODE (arg
) == ARRAY_REF
)
4102 if (mark_addressable (TREE_OPERAND (arg
, 0)) == 0)
4103 return error_mark_node
;
4104 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
4105 TREE_OPERAND (arg
, 1), 1);
4108 /* Uninstantiated types are all functions. Taking the
4109 address of a function is a no-op, so just return the
4112 if (TREE_CODE (arg
) == IDENTIFIER_NODE
4113 && IDENTIFIER_OPNAME_P (arg
))
4115 my_friendly_abort (117);
4116 /* We don't know the type yet, so just work around the problem.
4117 We know that this will resolve to an lvalue. */
4118 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4121 if (TREE_CODE (arg
) == TREE_LIST
)
4123 if (TREE_CODE (TREE_VALUE (arg
)) == FUNCTION_DECL
4124 && DECL_CHAIN (TREE_VALUE (arg
)) == NULL_TREE
)
4125 /* Unique overloaded non-member function. */
4126 return build_unary_op (ADDR_EXPR
, TREE_VALUE (arg
), 0);
4127 if (TREE_CHAIN (arg
) == NULL_TREE
4128 && TREE_CODE (TREE_VALUE (arg
)) == TREE_LIST
4129 && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg
))) == NULL_TREE
)
4130 /* Unique overloaded member function. */
4131 return build_unary_op (ADDR_EXPR
, TREE_VALUE (TREE_VALUE (arg
)),
4133 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
4136 /* Handle complex lvalues (when permitted)
4137 by reduction to simpler cases. */
4138 val
= unary_complex_lvalue (code
, arg
);
4142 switch (TREE_CODE (arg
))
4147 case FIX_TRUNC_EXPR
:
4148 case FIX_FLOOR_EXPR
:
4149 case FIX_ROUND_EXPR
:
4151 if (! lvalue_p (arg
) && pedantic
)
4152 pedwarn ("taking the address of a cast to non-reference type");
4155 /* Allow the address of a constructor if all the elements
4157 if (TREE_CODE (arg
) == CONSTRUCTOR
&& TREE_CONSTANT (arg
))
4159 /* Anything not already handled and not a true memory reference
4161 else if (TREE_CODE (argtype
) != FUNCTION_TYPE
4162 && TREE_CODE (argtype
) != METHOD_TYPE
4163 && !lvalue_or_else (arg
, "unary `&'"))
4164 return error_mark_node
;
4166 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4167 /* If the lvalue is const or volatile,
4168 merge that into the type that the address will point to. */
4169 if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'd'
4170 || TREE_CODE_CLASS (TREE_CODE (arg
)) == 'r')
4172 if (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4173 argtype
= cp_build_type_variant (argtype
,
4174 TREE_READONLY (arg
),
4175 TREE_THIS_VOLATILE (arg
));
4178 argtype
= build_pointer_type (argtype
);
4180 if (mark_addressable (arg
) == 0)
4181 return error_mark_node
;
4186 if (TREE_CODE (arg
) == COMPONENT_REF
)
4187 addr
= build_component_addr (arg
, argtype
,
4188 "attempt to take address of bit-field structure member `%s'");
4190 addr
= build1 (code
, argtype
, arg
);
4192 /* Address of a static or external variable or
4193 function counts as a constant */
4195 TREE_CONSTANT (addr
) = 1;
4203 argtype
= TREE_TYPE (arg
);
4204 return fold (build1 (code
, argtype
, arg
));
4208 return error_mark_node
;
4211 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
4212 convert ARG with the same conversions in the same order
4213 and return the result. */
4216 convert_sequence (conversions
, arg
)
4220 switch (TREE_CODE (conversions
))
4225 case FIX_TRUNC_EXPR
:
4226 case FIX_FLOOR_EXPR
:
4227 case FIX_ROUND_EXPR
:
4229 return convert (TREE_TYPE (conversions
),
4230 convert_sequence (TREE_OPERAND (conversions
, 0),
4238 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4239 for certain kinds of expressions which are not really lvalues
4240 but which we can accept as lvalues.
4242 If ARG is not a kind of expression we can handle, return zero. */
4245 unary_complex_lvalue (code
, arg
)
4246 enum tree_code code
;
4249 /* Handle (a, b) used as an "lvalue". */
4250 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
4252 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
4253 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
4254 TREE_OPERAND (arg
, 0), real_result
);
4257 /* Handle (a ? b : c) used as an "lvalue". */
4258 if (TREE_CODE (arg
) == COND_EXPR
)
4259 return rationalize_conditional_expr (code
, arg
);
4261 if (TREE_CODE (arg
) == MODIFY_EXPR
4262 || TREE_CODE (arg
) == PREINCREMENT_EXPR
4263 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
4264 return unary_complex_lvalue
4265 (code
, build (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (arg
, 0)),
4266 arg
, TREE_OPERAND (arg
, 0)));
4268 if (code
!= ADDR_EXPR
)
4271 /* Handle (a = b) used as an "lvalue" for `&'. */
4272 if (TREE_CODE (arg
) == MODIFY_EXPR
4273 || TREE_CODE (arg
) == INIT_EXPR
)
4275 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4276 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
), arg
, real_result
);
4279 if (TREE_CODE (arg
) == WITH_CLEANUP_EXPR
)
4281 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 0), 0);
4282 real_result
= build (WITH_CLEANUP_EXPR
, TREE_TYPE (real_result
),
4283 real_result
, 0, TREE_OPERAND (arg
, 2));
4287 if (TREE_CODE (TREE_TYPE (arg
)) == FUNCTION_TYPE
4288 || TREE_CODE (TREE_TYPE (arg
)) == METHOD_TYPE
4289 || TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
4291 /* The representation of something of type OFFSET_TYPE
4292 is really the representation of a pointer to it.
4293 Here give the representation its true type. */
4297 my_friendly_assert (TREE_CODE (arg
) != SCOPE_REF
, 313);
4299 if (TREE_CODE (arg
) != OFFSET_REF
)
4302 t
= TREE_OPERAND (arg
, 1);
4304 if (TREE_CODE (t
) == FUNCTION_DECL
) /* Check all this code for right semantics. */
4305 return build_unary_op (ADDR_EXPR
, t
, 0);
4306 if (TREE_CODE (t
) == VAR_DECL
)
4307 return build_unary_op (ADDR_EXPR
, t
, 0);
4310 if (TREE_OPERAND (arg
, 0)
4311 && (TREE_CODE (TREE_OPERAND (arg
, 0)) != NOP_EXPR
4312 || TREE_OPERAND (TREE_OPERAND (arg
, 0), 0) != error_mark_node
))
4313 if (TREE_CODE (t
) != FIELD_DECL
)
4315 /* Don't know if this should return address to just
4316 _DECL, or actual address resolved in this expression. */
4317 sorry ("address of bound pointer-to-member expression");
4318 return error_mark_node
;
4321 offset
= get_delta_difference (DECL_FIELD_CONTEXT (t
),
4322 TREE_TYPE (TREE_OPERAND (arg
, 0)),
4324 offset
= size_binop (PLUS_EXPR
, offset
,
4325 size_binop (EASY_DIV_EXPR
,
4326 DECL_FIELD_BITPOS (t
),
4327 size_int (BITS_PER_UNIT
)));
4328 return convert (build_pointer_type (TREE_TYPE (arg
)), offset
);
4332 if (TREE_CODE (arg
) == OFFSET_REF
)
4334 tree left
= TREE_OPERAND (arg
, 0), left_addr
;
4335 tree right_addr
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 1), 0);
4338 if (current_class_decl
)
4339 left_addr
= current_class_decl
;
4342 error ("no `this' for pointer to member");
4343 return error_mark_node
;
4346 left_addr
= build_unary_op (ADDR_EXPR
, left
, 0);
4348 return build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
4349 build1 (NOP_EXPR
, integer_type_node
, left_addr
),
4350 build1 (NOP_EXPR
, integer_type_node
, right_addr
));
4353 /* We permit compiler to make function calls returning
4354 objects of aggregate type look like lvalues. */
4358 if (TREE_CODE (targ
) == SAVE_EXPR
)
4359 targ
= TREE_OPERAND (targ
, 0);
4361 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (TREE_TYPE (targ
)))
4363 if (TREE_CODE (arg
) == SAVE_EXPR
)
4366 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, 1);
4367 return build1 (ADDR_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)), targ
);
4370 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == INDIRECT_REF
)
4371 return build (SAVE_EXPR
, TYPE_POINTER_TO (TREE_TYPE (arg
)),
4372 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
4374 /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
4375 we do, here's how to handle it. */
4376 if (TREE_CODE (arg
) == SAVE_EXPR
&& TREE_CODE (targ
) == WITH_CLEANUP_EXPR
)
4379 /* Not really a bug, but something to turn on when testing. */
4380 compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
4382 return unary_complex_lvalue (ADDR_EXPR
, targ
);
4386 /* Don't let anything else be handled specially. */
4390 /* Mark EXP saying that we need to be able to take the
4391 address of it; it should not be allocated in a register.
4392 Value is 1 if successful.
4394 C++: we do not allow `current_class_decl' to be addressable. */
4397 mark_addressable (exp
)
4400 register tree x
= exp
;
4402 if (TREE_ADDRESSABLE (x
) == 1)
4406 switch (TREE_CODE (x
))
4411 x
= TREE_OPERAND (x
, 0);
4415 if (x
== current_class_decl
)
4417 error ("address of `this' not available");
4418 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later */
4419 put_var_into_stack (x
);
4424 && TREE_READONLY (x
)
4425 && DECL_RTL (x
) != 0
4426 && ! decl_in_memory_p (x
))
4428 /* We thought this would make a good constant variable,
4429 but we were wrong. */
4430 push_obstacks_nochange ();
4431 end_temporary_allocation ();
4433 TREE_ASM_WRITTEN (x
) = 0;
4435 rest_of_decl_compilation (x
, 0, IDENTIFIER_LOCAL_VALUE (x
) == 0, 0);
4436 TREE_ADDRESSABLE (x
) = 1;
4442 /* Caller should not be trying to mark initialized
4443 constant fields addressable. */
4444 my_friendly_assert (DECL_LANG_SPECIFIC (x
) == 0
4445 || DECL_IN_AGGR_P (x
) == 0
4447 || DECL_EXTERNAL (x
), 314);
4451 /* For C++, we don't warn about taking the address of a register
4452 variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
4453 put_var_into_stack (x
);
4454 TREE_ADDRESSABLE (x
) = 1;
4458 /* We have to test both conditions here. The first may
4459 be non-zero in the case of processing a default function.
4460 The second may be non-zero in the case of a template function. */
4461 x
= DECL_MAIN_VARIANT (x
);
4462 if ((DECL_THIS_INLINE (x
) || DECL_PENDING_INLINE_INFO (x
))
4463 && (DECL_CONTEXT (x
) == NULL_TREE
4464 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x
))) != 't'
4465 || ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x
))))
4467 mark_inline_for_output (x
);
4468 if (x
== current_function_decl
)
4469 DECL_EXTERNAL (x
) = 0;
4471 TREE_ADDRESSABLE (x
) = 1;
4473 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
4481 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
4484 build_x_conditional_expr (ifexp
, op1
, op2
)
4485 tree ifexp
, op1
, op2
;
4487 tree rval
= NULL_TREE
;
4489 /* See comments in `build_x_binary_op'. */
4491 rval
= build_opfncall (COND_EXPR
, LOOKUP_SPECULATIVELY
, ifexp
, op1
, op2
);
4493 return build_opfncall (COND_EXPR
, LOOKUP_NORMAL
, ifexp
, op1
, op2
);
4495 return build_conditional_expr (ifexp
, op1
, op2
);
4499 build_conditional_expr (ifexp
, op1
, op2
)
4500 tree ifexp
, op1
, op2
;
4502 register tree type1
;
4503 register tree type2
;
4504 register enum tree_code code1
;
4505 register enum tree_code code2
;
4506 register tree result_type
= NULL_TREE
;
4507 tree orig_op1
= op1
, orig_op2
= op2
;
4509 /* If second operand is omitted, it is the same as the first one;
4510 make sure it is calculated only once. */
4514 pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
4515 ifexp
= op1
= save_expr (ifexp
);
4518 ifexp
= truthvalue_conversion (ifexp
);
4520 if (TREE_CODE (ifexp
) == ERROR_MARK
)
4521 return error_mark_node
;
4523 op1
= require_instantiated_type (TREE_TYPE (op2
), op1
, error_mark_node
);
4524 if (op1
== error_mark_node
)
4525 return error_mark_node
;
4526 op2
= require_instantiated_type (TREE_TYPE (op1
), op2
, error_mark_node
);
4527 if (op2
== error_mark_node
)
4528 return error_mark_node
;
4530 /* C++: REFERENCE_TYPES must be dereferenced. */
4531 type1
= TREE_TYPE (op1
);
4532 code1
= TREE_CODE (type1
);
4533 type2
= TREE_TYPE (op2
);
4534 code2
= TREE_CODE (type2
);
4536 if (code1
== REFERENCE_TYPE
)
4538 op1
= convert_from_reference (op1
);
4539 type1
= TREE_TYPE (op1
);
4540 code1
= TREE_CODE (type1
);
4542 if (code2
== REFERENCE_TYPE
)
4544 op2
= convert_from_reference (op2
);
4545 type2
= TREE_TYPE (op2
);
4546 code2
= TREE_CODE (type2
);
4549 #if 1 /* Produces wrong result if within sizeof. Sorry. */
4550 /* Don't promote the operands separately if they promote
4551 the same way. Return the unpromoted type and let the combined
4552 value get promoted if necessary. */
4554 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
)
4555 && code2
!= ARRAY_TYPE
4557 /* For C++, let the enumeral type come through. */
4558 && code2
!= ENUMERAL_TYPE
4560 && code2
!= FUNCTION_TYPE
4561 && code2
!= METHOD_TYPE
)
4565 if (TREE_CONSTANT (ifexp
)
4566 && (TREE_CODE (ifexp
) == INTEGER_CST
4567 || TREE_CODE (ifexp
) == ADDR_EXPR
))
4568 return (integer_zerop (ifexp
) ? op2
: op1
);
4570 if (TREE_CODE (op1
) == CONST_DECL
)
4571 op1
= DECL_INITIAL (op1
);
4572 else if (TREE_READONLY_DECL_P (op1
))
4573 op1
= decl_constant_value (op1
);
4574 if (TREE_CODE (op2
) == CONST_DECL
)
4575 op2
= DECL_INITIAL (op2
);
4576 else if (TREE_READONLY_DECL_P (op2
))
4577 op2
= decl_constant_value (op2
);
4579 type1
= cp_build_type_variant
4581 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4582 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4583 /* ??? This is a kludge to deal with the fact that
4584 we don't sort out integers and enums properly, yet. */
4585 result
= fold (build (COND_EXPR
, type1
, ifexp
, op1
, op2
));
4586 if (TREE_TYPE (result
) != type1
)
4587 result
= build1 (NOP_EXPR
, type1
, result
);
4592 /* They don't match; promote them both and then try to reconcile them.
4593 But don't permit mismatching enum types. */
4594 if (code1
== ENUMERAL_TYPE
)
4596 if (code2
== ENUMERAL_TYPE
)
4598 cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'", type1
, type2
);
4599 return error_mark_node
;
4601 else if (extra_warnings
&& ! IS_AGGR_TYPE_CODE (code2
)
4602 && type2
!= type_promotes_to (type1
))
4603 warning ("enumeral and non-enumeral type in conditional expression");
4605 else if (extra_warnings
4606 && code2
== ENUMERAL_TYPE
&& ! IS_AGGR_TYPE_CODE (code1
)
4607 && type1
!= type_promotes_to (type2
))
4608 warning ("enumeral and non-enumeral type in conditional expression");
4610 if (code1
!= VOID_TYPE
)
4612 op1
= default_conversion (op1
);
4613 type1
= TREE_TYPE (op1
);
4614 if (TYPE_PTRMEMFUNC_P (type1
))
4615 type1
= TYPE_PTRMEMFUNC_FN_TYPE (type1
);
4616 code1
= TREE_CODE (type1
);
4618 if (code2
!= VOID_TYPE
)
4620 op2
= default_conversion (op2
);
4621 type2
= TREE_TYPE (op2
);
4622 if (TYPE_PTRMEMFUNC_P (type2
))
4623 type2
= TYPE_PTRMEMFUNC_FN_TYPE (type2
);
4624 code2
= TREE_CODE (type2
);
4627 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
4628 && real_lvalue_p (op1
) && real_lvalue_p (op2
)
4629 && comptypes (type1
, type2
, -1))
4631 type1
= build_reference_type (type1
);
4632 type2
= build_reference_type (type2
);
4633 result_type
= common_type (type1
, type2
);
4634 op1
= convert_to_reference (result_type
, op1
, CONV_IMPLICIT
,
4635 LOOKUP_NORMAL
, NULL_TREE
);
4636 op2
= convert_to_reference (result_type
, op2
, CONV_IMPLICIT
,
4637 LOOKUP_NORMAL
, NULL_TREE
);
4639 /* Quickly detect the usual case where op1 and op2 have the same type
4641 else if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4644 result_type
= type1
;
4646 result_type
= cp_build_type_variant
4648 TREE_READONLY (op1
) || TREE_READONLY (op2
),
4649 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
4651 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
)
4652 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
))
4654 result_type
= common_type (type1
, type2
);
4656 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4658 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
4659 pedwarn ("ANSI C++ forbids conditional expr with only one void side");
4660 result_type
= void_type_node
;
4662 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4664 if (comp_target_types (type1
, type2
, 1))
4665 result_type
= common_type (type1
, type2
);
4666 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
4667 && TREE_CODE (orig_op1
) != NOP_EXPR
)
4668 result_type
= qualify_type (type2
, type1
);
4669 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
4670 && TREE_CODE (orig_op2
) != NOP_EXPR
)
4671 result_type
= qualify_type (type1
, type2
);
4672 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1
)) == void_type_node
)
4674 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4675 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4676 result_type
= qualify_type (type1
, type2
);
4678 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2
)) == void_type_node
)
4680 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4681 pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
4682 result_type
= qualify_type (type2
, type1
);
4685 else if (comptypes (type2
, type1
, 0))
4686 result_type
= type2
;
4687 else if (IS_AGGR_TYPE (TREE_TYPE (type1
))
4688 && IS_AGGR_TYPE (TREE_TYPE (type2
))
4689 && (result_type
= common_base_type (TREE_TYPE (type1
), TREE_TYPE (type2
))))
4691 if (result_type
== error_mark_node
)
4693 cp_error ("common base type of types `%T' and `%T' is ambiguous",
4694 TREE_TYPE (type1
), TREE_TYPE (type2
));
4695 result_type
= ptr_type_node
;
4700 && result_type
!= TREE_TYPE (type1
)
4701 && result_type
!= TREE_TYPE (type2
))
4702 cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression",
4703 type1
, type2
, result_type
);
4705 result_type
= TYPE_POINTER_TO (result_type
);
4710 pedwarn ("pointer type mismatch in conditional expression");
4711 result_type
= ptr_type_node
;
4714 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4716 if (!integer_zerop (op2
))
4717 pedwarn ("pointer/integer type mismatch in conditional expression");
4720 op2
= null_pointer_node
;
4721 #if 0 /* Sez who? */
4722 if (pedantic
&& TREE_CODE (type1
) == FUNCTION_TYPE
)
4723 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4726 result_type
= type1
;
4728 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4730 if (!integer_zerop (op1
))
4731 pedwarn ("pointer/integer type mismatch in conditional expression");
4734 op1
= null_pointer_node
;
4735 #if 0 /* Sez who? */
4736 if (pedantic
&& TREE_CODE (type2
) == FUNCTION_TYPE
)
4737 pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
4740 result_type
= type2
;
4745 /* The match does not look good. If either is
4746 an aggregate value, try converting to a scalar type. */
4747 if (code1
== RECORD_TYPE
&& code2
== RECORD_TYPE
)
4749 cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'", type1
, type2
);
4750 return error_mark_node
;
4752 if (code1
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type1
))
4754 tree tmp
= build_type_conversion (CONVERT_EXPR
, type2
, op1
, 0);
4755 if (tmp
== NULL_TREE
)
4757 cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1
);
4758 return error_mark_node
;
4760 if (tmp
== error_mark_node
)
4761 error ("ambiguous pointer conversion");
4762 result_type
= type2
;
4765 else if (code2
== RECORD_TYPE
&& TYPE_HAS_CONVERSION (type2
))
4767 tree tmp
= build_type_conversion (CONVERT_EXPR
, type1
, op2
, 0);
4768 if (tmp
== NULL_TREE
)
4770 cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2
);
4771 return error_mark_node
;
4773 if (tmp
== error_mark_node
)
4774 error ("ambiguous pointer conversion");
4775 result_type
= type1
;
4778 else if (flag_cond_mismatch
)
4779 result_type
= void_type_node
;
4782 error ("type mismatch in conditional expression");
4783 return error_mark_node
;
4787 if (TREE_CODE (result_type
) == POINTER_TYPE
4788 && TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
4789 result_type
= build_ptrmemfunc_type (result_type
);
4791 if (result_type
!= TREE_TYPE (op1
))
4792 op1
= convert_and_check (result_type
, op1
);
4793 if (result_type
!= TREE_TYPE (op2
))
4794 op2
= convert_and_check (result_type
, op2
);
4797 /* XXX delete me, I've been here for years. */
4798 if (IS_AGGR_TYPE_CODE (code1
))
4800 result_type
= TREE_TYPE (op1
);
4801 if (TREE_CONSTANT (ifexp
))
4802 return (integer_zerop (ifexp
) ? op2
: op1
);
4804 if (TYPE_MODE (result_type
) == BLKmode
)
4806 register tree tempvar
4807 = build_decl (VAR_DECL
, NULL_TREE
, result_type
);
4808 register tree xop1
= build_modify_expr (tempvar
, NOP_EXPR
, op1
);
4809 register tree xop2
= build_modify_expr (tempvar
, NOP_EXPR
, op2
);
4810 register tree result
= fold (build (COND_EXPR
, result_type
,
4811 ifexp
, xop1
, xop2
));
4813 layout_decl (tempvar
, 0);
4814 /* No way to handle variable-sized objects here.
4815 I fear that the entire handling of BLKmode conditional exprs
4816 needs to be redone. */
4817 my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar
)), 315);
4819 = assign_stack_local (DECL_MODE (tempvar
),
4820 (TREE_INT_CST_LOW (DECL_SIZE (tempvar
))
4821 + BITS_PER_UNIT
- 1)
4825 TREE_SIDE_EFFECTS (result
)
4826 = TREE_SIDE_EFFECTS (ifexp
) | TREE_SIDE_EFFECTS (op1
)
4827 | TREE_SIDE_EFFECTS (op2
);
4828 return build (COMPOUND_EXPR
, result_type
, result
, tempvar
);
4833 if (TREE_CONSTANT (ifexp
))
4834 return integer_zerop (ifexp
) ? op2
: op1
;
4836 return convert_from_reference
4837 (fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
)));
4840 /* Handle overloading of the ',' operator when needed. Otherwise,
4841 this function just builds an expression list. */
4843 build_x_compound_expr (list
)
4846 tree rest
= TREE_CHAIN (list
);
4849 if (rest
== NULL_TREE
)
4850 return build_compound_expr (list
);
4852 result
= build_opfncall (COMPOUND_EXPR
, LOOKUP_NORMAL
,
4853 TREE_VALUE (list
), TREE_VALUE (rest
), NULL_TREE
);
4855 return build_x_compound_expr (tree_cons (NULL_TREE
, result
, TREE_CHAIN (rest
)));
4857 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
4859 /* the left-hand operand of a comma expression is like an expression
4860 statement: we should warn if it doesn't have any side-effects,
4861 unless it was explicitly cast to (void). */
4862 if ((extra_warnings
|| warn_unused
)
4863 && !(TREE_CODE (TREE_VALUE(list
)) == CONVERT_EXPR
4864 && TREE_TYPE (TREE_VALUE(list
)) == void_type_node
))
4865 warning("left-hand operand of comma expression has no effect");
4867 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
4868 else if (warn_unused
)
4869 warn_if_unused_value (TREE_VALUE(list
));
4872 return build_compound_expr (tree_cons (NULL_TREE
, TREE_VALUE (list
),
4873 build_tree_list (NULL_TREE
, build_x_compound_expr (rest
))));
4876 /* Given a list of expressions, return a compound expression
4877 that performs them all and returns the value of the last of them. */
4880 build_compound_expr (list
)
4885 if (TREE_READONLY_DECL_P (TREE_VALUE (list
)))
4886 TREE_VALUE (list
) = decl_constant_value (TREE_VALUE (list
));
4888 if (TREE_CHAIN (list
) == 0)
4890 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4891 Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */
4892 if (TREE_CODE (list
) == NOP_EXPR
4893 && TREE_TYPE (list
) == TREE_TYPE (TREE_OPERAND (list
, 0)))
4894 list
= TREE_OPERAND (list
, 0);
4896 /* Convert arrays to pointers. */
4897 if (TREE_CODE (TREE_TYPE (TREE_VALUE (list
))) == ARRAY_TYPE
)
4898 return default_conversion (TREE_VALUE (list
));
4900 return TREE_VALUE (list
);
4903 rest
= build_compound_expr (TREE_CHAIN (list
));
4905 /* When pedantic, a compound expression cannot be a constant expression. */
4906 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)) && ! pedantic
)
4909 return build (COMPOUND_EXPR
, TREE_TYPE (rest
),
4910 break_out_cleanups (TREE_VALUE (list
)), rest
);
4920 return (TREE_CODE (t
) == INTEGER_CST
&& integer_zerop (t
));
4923 tree
build_static_cast (type
, expr
)
4926 return build_c_cast (type
, expr
, 0);
4929 tree
build_reinterpret_cast (type
, expr
)
4932 tree intype
= TREE_TYPE (expr
);
4934 if (TYPE_PTRMEMFUNC_P (type
))
4935 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
4936 if (TYPE_PTRMEMFUNC_P (intype
))
4937 intype
= TYPE_PTRMEMFUNC_FN_TYPE (intype
);
4939 if (! POINTER_TYPE_P (type
) && ! TREE_CODE (type
) == INTEGER_TYPE
)
4941 cp_error ("reinterpret_cast cannot convert to type `%T'", type
);
4942 return error_mark_node
;
4944 if (! POINTER_TYPE_P (intype
) && ! TREE_CODE (intype
) == INTEGER_TYPE
)
4946 cp_error ("reinterpret_cast cannot convert from type `%T'", type
);
4947 return error_mark_node
;
4949 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_CODE (intype
) != POINTER_TYPE
)
4951 cp_error ("reinterpret_cast cannot convert non-pointer type `%T' to `%T'",
4953 return error_mark_node
;
4955 if (TREE_CODE (intype
) == INTEGER_TYPE
&& TREE_CODE (type
) != POINTER_TYPE
)
4957 cp_error ("reinterpret_cast cannot convert `%T' to non-pointer type `%T'",
4959 return error_mark_node
;
4962 if (TREE_CODE (type
) == POINTER_TYPE
&& TREE_CODE (intype
) == POINTER_TYPE
)
4963 expr
= convert (ptr_type_node
, expr
);
4965 return build_c_cast (type
, expr
, 0);
4968 tree
build_const_cast (type
, expr
)
4971 tree intype
= TREE_TYPE (expr
);
4974 if (TYPE_PTRMEMFUNC_P (type
))
4975 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
4976 if (TYPE_PTRMEMFUNC_P (intype
))
4977 intype
= TYPE_PTRMEMFUNC_FN_TYPE (intype
);
4979 if (! POINTER_TYPE_P (type
))
4981 cp_error ("const_cast cannot convert to non-pointer type `%T'", type
);
4982 return error_mark_node
;
4984 if (TREE_CODE (type
) == REFERENCE_TYPE
&& ! real_lvalue_p (expr
))
4986 cp_error ("const_cast cannot convert rvalue to type `%T'", type
);
4987 return error_mark_node
;
4989 if (TREE_CODE (type
) == POINTER_TYPE
&& TREE_CODE (intype
) != POINTER_TYPE
)
4991 cp_error ("const_cast cannot convert non-pointer type `%T' to type `%T'",
4993 return error_mark_node
;
4996 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4998 t1
= TREE_TYPE (type
);
5003 t1
= TREE_TYPE (type
);
5004 t2
= TREE_TYPE (intype
);
5006 for (; TREE_CODE (t1
) == POINTER_TYPE
&& TREE_CODE (t2
) == POINTER_TYPE
;
5007 t1
= TREE_TYPE (t1
), t2
= TREE_TYPE (t2
))
5011 if (TREE_CODE (t1
) == OFFSET_TYPE
&& TREE_CODE (t2
) == OFFSET_TYPE
)
5013 if (TYPE_OFFSET_BASETYPE (t1
) != TYPE_OFFSET_BASETYPE (t2
))
5015 cp_error ("const_cast cannot convert between pointers to members of different types `%T' and `%T'",
5016 TYPE_OFFSET_BASETYPE (t2
), TYPE_OFFSET_BASETYPE (t1
));
5017 return error_mark_node
;
5019 t1
= TREE_TYPE (t1
);
5020 t2
= TREE_TYPE (t2
);
5023 if (TYPE_MAIN_VARIANT (t1
) != TYPE_MAIN_VARIANT (t2
))
5025 cp_error ("const_cast cannot convert unrelated type `%T' to `%T'",
5027 return error_mark_node
;
5030 return build_c_cast (type
, expr
, 0);
5033 /* Build an expression representing a cast to type TYPE of expression EXPR.
5035 ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5036 when doing the cast. */
5039 build_c_cast (type
, expr
, allow_nonconverting
)
5042 int allow_nonconverting
;
5044 register tree value
= expr
;
5046 if (type
== error_mark_node
|| expr
== error_mark_node
)
5047 return error_mark_node
;
5049 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5050 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
5051 if (TREE_CODE (type
) != REFERENCE_TYPE
5052 && TREE_CODE (value
) == NOP_EXPR
5053 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
5054 value
= TREE_OPERAND (value
, 0);
5056 if (TREE_TYPE (expr
)
5057 && TREE_CODE (TREE_TYPE (expr
)) == OFFSET_TYPE
5058 && TREE_CODE (type
) != OFFSET_TYPE
)
5059 value
= resolve_offset_ref (value
);
5061 if (TREE_CODE (type
) == ARRAY_TYPE
)
5063 /* Allow casting from T1* to T2[] because Cfront allows it.
5064 NIHCL uses it. It is not valid ANSI C however, and hence, not
5066 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
5069 pedwarn ("ANSI C++ forbids casting to an array type");
5070 type
= build_pointer_type (TREE_TYPE (type
));
5074 error ("ANSI C++ forbids casting to an array type");
5075 return error_mark_node
;
5079 if (TREE_CODE (type
) == FUNCTION_TYPE
5080 || TREE_CODE (type
) == METHOD_TYPE
)
5082 cp_error ("casting to function type `%T'", type
);
5083 return error_mark_node
;
5086 if (IS_SIGNATURE (type
))
5088 error ("cast specifies signature type");
5089 return error_mark_node
;
5092 /* If there's only one function in the overloaded space,
5094 if (TREE_CODE (value
) == TREE_LIST
5095 && TREE_CHAIN (value
) == NULL_TREE
)
5096 value
= TREE_VALUE (value
);
5098 if (TREE_CODE (type
) == VOID_TYPE
)
5099 value
= build1 (CONVERT_EXPR
, type
, value
);
5100 else if (TREE_TYPE (value
) == NULL_TREE
5101 || type_unknown_p (value
))
5103 value
= instantiate_type (type
, value
, 1);
5105 if (value
== error_mark_node
)
5106 return error_mark_node
;
5113 /* Convert functions and arrays to pointers and
5114 convert references to their expanded types,
5115 but don't convert any other types. */
5116 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5117 || TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
5118 || TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5119 || TREE_CODE (TREE_TYPE (value
)) == REFERENCE_TYPE
)
5120 value
= default_conversion (value
);
5121 otype
= TREE_TYPE (value
);
5123 /* Optionally warn about potentially worrisome casts. */
5126 && TREE_CODE (type
) == POINTER_TYPE
5127 && TREE_CODE (otype
) == POINTER_TYPE
)
5129 /* For C++ we make these regular warnings, rather than
5130 softening them into pedwarns. */
5131 if (TYPE_VOLATILE (TREE_TYPE (otype
))
5132 && ! TYPE_VOLATILE (TREE_TYPE (type
)))
5133 warning ("cast discards `volatile' from pointer target type");
5134 if (TYPE_READONLY (TREE_TYPE (otype
))
5135 && ! TYPE_READONLY (TREE_TYPE (type
)))
5136 warning ("cast discards `const' from pointer target type");
5139 /* Warn about possible alignment problems. */
5140 if (STRICT_ALIGNMENT
&& warn_cast_align
5141 && TREE_CODE (type
) == POINTER_TYPE
5142 && TREE_CODE (otype
) == POINTER_TYPE
5143 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5144 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5145 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5146 warning ("cast increases required alignment of target type");
5149 if (TREE_CODE (type
) == INTEGER_TYPE
5150 && TREE_CODE (otype
) == POINTER_TYPE
5151 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5152 warning ("cast from pointer to integer of different size");
5154 if (TREE_CODE (type
) == POINTER_TYPE
5155 && TREE_CODE (otype
) == INTEGER_TYPE
5156 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5157 /* Don't warn about converting 0 to pointer,
5158 provided the 0 was explicit--not cast or made by folding. */
5159 && !(TREE_CODE (value
) == INTEGER_CST
&& integer_zerop (value
)))
5160 warning ("cast to pointer from integer of different size");
5163 flag
= allow_nonconverting
? CONV_NONCONVERTING
: 0;
5165 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5166 value
= (convert_from_reference
5167 (convert_to_reference (type
, value
, CONV_OLD_CONVERT
|flag
,
5168 LOOKUP_COMPLAIN
, NULL_TREE
)));
5173 if (TREE_READONLY_DECL_P (value
))
5174 value
= decl_constant_value (value
);
5177 value
= convert_force (type
, value
, flag
);
5179 /* Ignore any integer overflow caused by the cast. */
5180 if (TREE_CODE (value
) == INTEGER_CST
)
5182 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5183 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
5188 /* Always produce some operator for an explicit cast,
5189 so we can tell (for -pedantic) that the cast is no lvalue.
5190 Also, pedantically, don't let (void *) (FOO *) 0 be a null
5191 pointer constant. */
5194 && TREE_CODE (value
) == INTEGER_CST
5195 && TREE_CODE (expr
) == INTEGER_CST
5196 && TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
))
5197 value
= non_lvalue (value
);
5203 /* Build an assignment expression of lvalue LHS from value RHS.
5205 In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
5206 that reference becomes deferenced down to it base type. */
5208 /* Return a reference to the BASE_INDEX part of EXPR. TYPE is
5209 the type to which BASE_INDEX applies. */
5211 get_base_ref (type
, base_index
, expr
)
5216 tree binfos
= TYPE_BINFO_BASETYPES (type
);
5217 tree base_binfo
= TREE_VEC_ELT (binfos
, base_index
);
5220 if (TREE_CODE (expr
) == ARRAY_REF
5221 || ! BINFO_OFFSET_ZEROP (base_binfo
)
5222 || TREE_VIA_VIRTUAL (base_binfo
)
5223 || TYPE_MODE (type
) != TYPE_MODE (BINFO_TYPE (base_binfo
)))
5225 tree addr
= build_unary_op (ADDR_EXPR
, expr
, 0);
5226 ref
= build_indirect_ref (convert_pointer_to (base_binfo
, addr
),
5231 ref
= copy_node (expr
);
5232 TREE_TYPE (ref
) = BINFO_TYPE (base_binfo
);
5237 /* Build an assignment expression of lvalue LHS from value RHS.
5238 MODIFYCODE is the code for a binary operator that we use
5239 to combine the old value of LHS with RHS to get the new value.
5240 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5242 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5244 `build_modify_expr_1' implements recursive part of memberwise
5245 assignment operation. */
5247 build_modify_expr_1 (lhs
, modifycode
, rhs
, basetype_path
)
5249 enum tree_code modifycode
;
5252 register tree result
;
5254 tree lhstype
= TREE_TYPE (lhs
);
5255 tree olhstype
= lhstype
;
5257 /* Avoid duplicate error messages from operands that had errors. */
5258 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5259 return error_mark_node
;
5261 /* If a binary op has been requested, combine the old LHS value with the RHS
5262 producing the value we should actually store into the LHS. */
5264 if (modifycode
== INIT_EXPR
)
5266 else if (modifycode
== NOP_EXPR
)
5268 /* must deal with overloading of `operator=' here. */
5269 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5270 lhstype
= TREE_TYPE (lhstype
);
5276 lhs
= stabilize_reference (lhs
);
5277 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5278 modifycode
= NOP_EXPR
;
5281 /* If storing into a structure or union member,
5282 it has probably been given type `int'.
5283 Compute the type that would go with
5284 the actual amount of storage the member occupies. */
5286 if (TREE_CODE (lhs
) == COMPONENT_REF
5287 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5288 || TREE_CODE (lhstype
) == REAL_TYPE
5289 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5290 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5292 /* C++: The semantics of C++ differ from those of C when an
5293 assignment of an aggregate is desired. Assignment in C++ is
5294 now defined as memberwise assignment of non-static members
5295 and base class objects. This rule applies recursively
5296 until a member of a built-in type is found.
5298 Also, we cannot do a bit-wise copy of aggregates which
5299 contain virtual function table pointers. Those
5300 pointer values must be preserved through the copy.
5301 However, this is handled in expand_expr, and not here.
5302 This is because much better code can be generated at
5303 that stage than this one. */
5304 if (TREE_CODE (lhstype
) == RECORD_TYPE
5305 && TYPE_LANG_SPECIFIC (lhstype
)
5306 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5311 /* Perform operation on object. */
5312 if (modifycode
== INIT_EXPR
&& TYPE_HAS_INIT_REF (lhstype
))
5314 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5315 build_tree_list (NULL_TREE
, rhs
),
5316 basetype_path
, LOOKUP_NORMAL
);
5317 return build_indirect_ref (result
, NULL_PTR
);
5319 else if (modifycode
== NOP_EXPR
)
5321 /* `operator=' is not an inheritable operator; see 13.4.3. */
5322 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_HAS_ASSIGNMENT (lhstype
))
5324 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5325 lhs
, rhs
, make_node (NOP_EXPR
));
5326 if (result
== NULL_TREE
)
5327 return error_mark_node
;
5332 if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype
)
5333 || (modifycode
== NOP_EXPR
&& TYPE_GETS_ASSIGNMENT (lhstype
))
5334 || (modifycode
== INIT_EXPR
&& TYPE_GETS_INIT_REF (lhstype
)))
5336 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (lhstype
));
5339 if (binfos
!= NULL_TREE
)
5340 /* Perform operation on each member, depth-first, left-right. */
5341 for (i
= 0; i
<= TREE_VEC_LENGTH (binfos
)-1; i
++)
5343 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
5344 tree base_lhs
, base_rhs
;
5347 /* Assignments from virtual baseclasses handled elsewhere. */
5348 if (TREE_VIA_VIRTUAL (base_binfo
))
5351 base_lhs
= get_base_ref (lhstype
, i
, lhs
);
5352 base_rhs
= get_base_ref (lhstype
, i
, newrhs
);
5354 BINFO_INHERITANCE_CHAIN (base_binfo
) = basetype_path
;
5356 = build_modify_expr_1 (base_lhs
, modifycode
, base_rhs
,
5359 /* We either get back a compound stmt, or a simple one. */
5360 if (new_result
&& TREE_CODE (new_result
) == TREE_LIST
)
5361 new_result
= build_compound_expr (new_result
);
5362 result
= tree_cons (NULL_TREE
, new_result
, result
);
5365 for (elt
= TYPE_FIELDS (lhstype
); elt
; elt
= TREE_CHAIN (elt
))
5367 tree vbases
= NULL_TREE
;
5368 tree elt_lhs
, elt_rhs
;
5370 if (TREE_CODE (elt
) != FIELD_DECL
)
5373 && (VFIELD_NAME_P (DECL_NAME (elt
))
5374 || VBASE_NAME_P (DECL_NAME (elt
))))
5377 if (TREE_READONLY (elt
)
5378 || TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5380 cp_error ("cannot generate default `%T::operator ='",
5382 if (TREE_CODE (TREE_TYPE (elt
)) == REFERENCE_TYPE
)
5383 cp_error_at ("because member `%#D' is a reference", elt
);
5385 cp_error_at ("because member `%#D' is const", elt
);
5387 return error_mark_node
;
5390 if (IS_AGGR_TYPE (TREE_TYPE (elt
))
5391 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5392 vbases
= CLASSTYPE_VBASECLASSES (TREE_TYPE (elt
));
5394 elt_lhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), lhs
, elt
);
5395 elt_rhs
= build (COMPONENT_REF
, TREE_TYPE (elt
), newrhs
, elt
);
5396 /* It is not always safe to go through `build_modify_expr_1'
5397 when performing element-wise copying. This is because
5398 an element may be of ARRAY_TYPE, which will not
5399 be properly copied as a naked element. */
5400 if (TREE_CODE (TREE_TYPE (elt
)) == RECORD_TYPE
5401 && TYPE_LANG_SPECIFIC (TREE_TYPE (elt
)))
5402 basetype_path
= TYPE_BINFO (TREE_TYPE (elt
));
5406 tree elt_lhs_addr
= build_unary_op (ADDR_EXPR
, elt_lhs
, 0);
5407 tree elt_rhs_addr
= build_unary_op (ADDR_EXPR
, elt_rhs
, 0);
5409 elt_lhs_addr
= convert_pointer_to (vbases
, elt_lhs_addr
);
5410 elt_rhs_addr
= convert_pointer_to (vbases
, elt_rhs_addr
);
5412 = tree_cons (NULL_TREE
,
5414 (build_indirect_ref (elt_lhs_addr
, NULL_PTR
),
5416 build_indirect_ref (elt_rhs_addr
, NULL_PTR
),
5419 if (TREE_VALUE (result
) == error_mark_node
)
5420 return error_mark_node
;
5421 vbases
= TREE_CHAIN (vbases
);
5423 elt_lhs
= build_modify_expr_1 (elt_lhs
, modifycode
, elt_rhs
,
5425 result
= tree_cons (NULL_TREE
, elt_lhs
, result
);
5429 return build_compound_expr (result
);
5430 /* No fields to move. */
5431 return integer_zero_node
;
5435 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
5436 void_type_node
, lhs
, rhs
);
5437 TREE_SIDE_EFFECTS (result
) = 1;
5442 result
= build_modify_expr (lhs
, modifycode
, newrhs
);
5443 /* ARRAY_TYPEs cannot be converted to anything meaningful,
5444 and leaving it there screws up `build_compound_expr' when
5445 it tries to defaultly convert everything. */
5446 if (TREE_CODE (TREE_TYPE (result
)) == ARRAY_TYPE
)
5447 TREE_TYPE (result
) = void_type_node
;
5452 /* Taken from expr.c:
5453 Subroutine of expand_expr:
5454 record the non-copied parts (LIST) of an expr (LHS), and return a list
5455 which specifies the initial values of these parts. */
5458 init_noncopied_parts (lhs
, list
)
5465 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5466 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5467 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5470 tree part
= TREE_VALUE (tail
);
5471 tree part_type
= TREE_TYPE (part
);
5472 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5473 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
5479 expand_target_expr (t
)
5482 tree xval
= make_node (RTL_EXPR
);
5485 do_pending_stack_adjust ();
5486 start_sequence_for_rtl_expr (xval
);
5488 rtxval
= expand_expr (t
, NULL
, VOIDmode
, 0);
5489 do_pending_stack_adjust ();
5490 TREE_SIDE_EFFECTS (xval
) = 1;
5491 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
5493 RTL_EXPR_RTL (xval
) = rtxval
;
5494 TREE_TYPE (xval
) = TREE_TYPE (t
);
5498 /* Build an assignment expression of lvalue LHS from value RHS.
5499 MODIFYCODE is the code for a binary operator that we use
5500 to combine the old value of LHS with RHS to get the new value.
5501 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5503 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
5506 build_modify_expr (lhs
, modifycode
, rhs
)
5508 enum tree_code modifycode
;
5511 register tree result
;
5513 tree lhstype
= TREE_TYPE (lhs
);
5514 tree olhstype
= lhstype
;
5517 /* Avoid duplicate error messages from operands that had errors. */
5518 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5519 return error_mark_node
;
5521 /* Types that aren't fully specified cannot be used in assignments. */
5522 lhs
= require_complete_type (lhs
);
5524 /* Decide early if we are going to protect RHS from GC
5525 before assigning it to LHS. */
5526 if (type_needs_gc_entry (TREE_TYPE (rhs
))
5527 && ! value_safe_from_gc (lhs
, rhs
))
5528 rhs
= protect_value_from_gc (lhs
, rhs
);
5532 /* Handle assignment to signature pointers/refs. */
5534 if (TYPE_LANG_SPECIFIC (lhstype
) &&
5535 (IS_SIGNATURE_POINTER (lhstype
) || IS_SIGNATURE_REFERENCE (lhstype
)))
5537 return build_signature_pointer_constructor (lhs
, rhs
);
5540 /* Handle control structure constructs used as "lvalues". */
5542 switch (TREE_CODE (lhs
))
5544 /* Handle --foo = 5; as these are valid constructs in C++ */
5545 case PREDECREMENT_EXPR
:
5546 case PREINCREMENT_EXPR
:
5547 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
5548 lhs
= build (TREE_CODE (lhs
), TREE_TYPE (lhs
),
5549 stabilize_reference (TREE_OPERAND (lhs
, 0)));
5550 return build (COMPOUND_EXPR
, lhstype
,
5552 build_modify_expr (TREE_OPERAND (lhs
, 0),
5555 /* Handle (a, b) used as an "lvalue". */
5557 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1),
5559 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5560 return error_mark_node
;
5561 return build (COMPOUND_EXPR
, lhstype
,
5562 TREE_OPERAND (lhs
, 0), newrhs
);
5565 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 0), modifycode
, rhs
);
5566 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5567 return error_mark_node
;
5568 return build (COMPOUND_EXPR
, lhstype
, lhs
, newrhs
);
5570 /* Handle (a ? b : c) used as an "lvalue". */
5572 rhs
= save_expr (rhs
);
5574 /* Produce (a ? (b = rhs) : (c = rhs))
5575 except that the RHS goes through a save-expr
5576 so the code to compute it is only emitted once. */
5578 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
5579 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 1)),
5581 build_modify_expr (convert (TREE_TYPE (lhs
), TREE_OPERAND (lhs
, 2)),
5583 if (TREE_CODE (cond
) == ERROR_MARK
)
5585 /* Make sure the code to compute the rhs comes out
5586 before the split. */
5587 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
5588 /* Case to void to suppress warning
5589 from warn_if_unused_value. */
5590 convert (void_type_node
, rhs
), cond
);
5594 if (TREE_CODE (lhs
) == OFFSET_REF
)
5596 if (TREE_OPERAND (lhs
, 0) == NULL_TREE
)
5598 /* Static class member? */
5599 tree member
= TREE_OPERAND (lhs
, 1);
5600 if (TREE_CODE (member
) == VAR_DECL
)
5604 compiler_error ("invalid static class member");
5605 return error_mark_node
;
5609 lhs
= resolve_offset_ref (lhs
);
5611 olhstype
= lhstype
= TREE_TYPE (lhs
);
5614 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
5615 && modifycode
!= INIT_EXPR
)
5617 lhs
= convert_from_reference (lhs
);
5618 olhstype
= lhstype
= TREE_TYPE (lhs
);
5621 /* If a binary op has been requested, combine the old LHS value with the RHS
5622 producing the value we should actually store into the LHS. */
5624 if (modifycode
== INIT_EXPR
)
5626 if (! IS_AGGR_TYPE (lhstype
))
5627 /* Do the default thing */;
5628 else if (! TYPE_HAS_CONSTRUCTOR (lhstype
))
5629 cp_error ("`%T' has no constructors", lhstype
);
5630 else if (TYPE_HAS_TRIVIAL_INIT_REF (lhstype
)
5631 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5632 /* Do the default thing */;
5635 result
= build_method_call (lhs
, constructor_name_full (lhstype
),
5636 build_tree_list (NULL_TREE
, rhs
),
5637 NULL_TREE
, LOOKUP_NORMAL
);
5638 if (result
== NULL_TREE
)
5639 return error_mark_node
;
5643 else if (modifycode
== NOP_EXPR
)
5646 /* `operator=' is not an inheritable operator. */
5647 if (! IS_AGGR_TYPE (lhstype
))
5648 /* Do the default thing */;
5649 else if (! TYPE_HAS_ASSIGNMENT (lhstype
))
5650 cp_error ("`%T' does not define operator=", lhstype
);
5651 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (lhstype
)
5652 && TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
)))
5655 /* If we care about this, do overload resolution. */
5656 build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5657 lhs
, rhs
, make_node (NOP_EXPR
));
5659 /* Do the default thing */;
5663 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5664 lhs
, rhs
, make_node (NOP_EXPR
));
5665 if (result
== NULL_TREE
)
5666 return error_mark_node
;
5670 /* Treat `operator=' as an inheritable operator. */
5671 if (TYPE_LANG_SPECIFIC (lhstype
) && TYPE_GETS_ASSIGNMENT (lhstype
))
5673 tree orig_lhstype
= lhstype
;
5674 while (! TYPE_HAS_ASSIGNMENT (lhstype
))
5676 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (lhstype
);
5677 tree basetype
= NULL_TREE
;
5678 for (i
= 0; i
< n_baseclasses
; i
++)
5679 if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype
, i
)))
5681 if (basetype
!= NULL_TREE
)
5683 message_2_types (error
, "base classes `%s' and `%s' both have operator ='",
5685 TYPE_BINFO_BASETYPE (lhstype
, i
));
5686 return error_mark_node
;
5688 basetype
= TYPE_BINFO_BASETYPE (lhstype
, i
);
5692 if (orig_lhstype
!= lhstype
)
5694 lhs
= build_indirect_ref (convert_pointer_to (lhstype
,
5695 build_unary_op (ADDR_EXPR
, lhs
, 0)), NULL_PTR
);
5696 if (lhs
== error_mark_node
)
5698 cp_error ("conversion to private basetype `%T'", lhstype
);
5699 return error_mark_node
;
5702 result
= build_opfncall (MODIFY_EXPR
, LOOKUP_NORMAL
,
5703 lhs
, rhs
, make_node (NOP_EXPR
));
5704 if (result
== NULL_TREE
)
5705 return error_mark_node
;
5711 else if (PROMOTES_TO_AGGR_TYPE (lhstype
, REFERENCE_TYPE
))
5713 /* This case must convert to some sort of lvalue that
5714 can participate in an op= operation. */
5717 if (build_default_binary_type_conversion (modifycode
, &lhs_tmp
, &rhs_tmp
))
5719 lhs
= stabilize_reference (lhs_tmp
);
5720 /* Forget is was ever anything else. */
5721 olhstype
= lhstype
= TREE_TYPE (lhs
);
5722 newrhs
= build_binary_op (modifycode
, lhs
, rhs_tmp
, 1);
5726 cp_error ("no match for `%O(%#T, %#T)'", modifycode
,
5727 TREE_TYPE (lhs
), TREE_TYPE (rhs
));
5728 return error_mark_node
;
5733 lhs
= stabilize_reference (lhs
);
5734 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
5737 /* Handle a cast used as an "lvalue".
5738 We have already performed any binary operator using the value as cast.
5739 Now convert the result to the cast type of the lhs,
5740 and then true type of the lhs and store it there;
5741 then convert result back to the cast type to be the value
5742 of the assignment. */
5744 switch (TREE_CODE (lhs
))
5749 case FIX_TRUNC_EXPR
:
5750 case FIX_FLOOR_EXPR
:
5751 case FIX_ROUND_EXPR
:
5753 if (TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
5754 || TREE_CODE (TREE_TYPE (newrhs
)) == FUNCTION_TYPE
5755 || TREE_CODE (TREE_TYPE (newrhs
)) == METHOD_TYPE
5756 || TREE_CODE (TREE_TYPE (newrhs
)) == OFFSET_TYPE
)
5757 newrhs
= default_conversion (newrhs
);
5759 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
5761 if (! lvalue_p (lhs
) && pedantic
)
5762 pedwarn ("cast to non-reference type used as lvalue");
5764 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
5765 convert (TREE_TYPE (inner_lhs
),
5766 convert (lhstype
, newrhs
)));
5767 if (TREE_CODE (result
) == ERROR_MARK
)
5769 return convert (TREE_TYPE (lhs
), result
);
5773 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5774 Reject anything strange now. */
5776 if (!lvalue_or_else (lhs
, "assignment"))
5777 return error_mark_node
;
5779 GNU_xref_assign (lhs
);
5781 /* Warn about storing in something that is `const'. */
5782 /* For C++, don't warn if this is initialization. */
5783 if (modifycode
!= INIT_EXPR
5784 /* For assignment to `const' signature pointer/reference fields,
5785 don't warn either, we already printed a better message before. */
5786 && ! (TREE_CODE (lhs
) == COMPONENT_REF
5787 && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
5788 || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
5789 && (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
5790 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5791 || TREE_CODE (lhstype
) == UNION_TYPE
)
5792 && C_TYPE_FIELDS_READONLY (lhstype
))
5793 || (TREE_CODE (lhstype
) == REFERENCE_TYPE
5794 && TYPE_READONLY (TREE_TYPE (lhstype
)))))
5795 readonly_error (lhs
, "assignment", 0);
5797 /* If storing into a structure or union member,
5798 it has probably been given type `int'.
5799 Compute the type that would go with
5800 the actual amount of storage the member occupies. */
5802 if (TREE_CODE (lhs
) == COMPONENT_REF
5803 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5804 || TREE_CODE (lhstype
) == REAL_TYPE
5805 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5807 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5809 /* If storing in a field that is in actuality a short or narrower
5810 than one, we must store in the field in its actual type. */
5812 if (lhstype
!= TREE_TYPE (lhs
))
5814 lhs
= copy_node (lhs
);
5815 TREE_TYPE (lhs
) = lhstype
;
5819 /* check to see if there is an assignment to `this' */
5820 if (lhs
== current_class_decl
)
5822 if (flag_this_is_variable
> 0
5823 && DECL_NAME (current_function_decl
) != NULL_TREE
5824 && (DECL_NAME (current_function_decl
)
5825 != constructor_name (current_class_type
)))
5826 warning ("assignment to `this' not in constructor or destructor");
5827 current_function_just_assigned_this
= 1;
5830 /* The TREE_TYPE of RHS may be TYPE_UNKNOWN. This can happen
5831 when the type of RHS is not yet known, i.e. its type
5832 is inherited from LHS. */
5833 rhs
= require_instantiated_type (lhstype
, newrhs
, error_mark_node
);
5834 if (rhs
== error_mark_node
)
5835 return error_mark_node
;
5838 if (modifycode
!= INIT_EXPR
)
5840 /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */
5841 modifycode
= NOP_EXPR
;
5842 /* Reference-bashing */
5843 if (TREE_CODE (lhstype
) == REFERENCE_TYPE
)
5845 tree tmp
= convert_from_reference (lhs
);
5846 lhstype
= TREE_TYPE (tmp
);
5847 if (TYPE_SIZE (lhstype
) == 0)
5849 incomplete_type_error (lhs
, lhstype
);
5850 return error_mark_node
;
5855 if (TREE_CODE (TREE_TYPE (newrhs
)) == REFERENCE_TYPE
)
5857 tree tmp
= convert_from_reference (newrhs
);
5858 if (TYPE_SIZE (TREE_TYPE (tmp
)) == 0)
5860 incomplete_type_error (newrhs
, TREE_TYPE (tmp
));
5861 return error_mark_node
;
5867 if (TREE_SIDE_EFFECTS (lhs
))
5868 lhs
= stabilize_reference (lhs
);
5869 if (TREE_SIDE_EFFECTS (newrhs
))
5870 newrhs
= stabilize_reference (newrhs
);
5873 /* This is now done by generating X(X&) and operator=(X&). */
5874 /* C++: The semantics of C++ differ from those of C when an
5875 assignment of an aggregate is desired. Assignment in C++ is
5876 now defined as memberwise assignment of non-static members
5877 and base class objects. This rule applies recursively
5878 until a member of a built-in type is found.
5880 Also, we cannot do a bit-wise copy of aggregates which
5881 contain virtual function table pointers. Those
5882 pointer values must be preserved through the copy.
5883 However, this is handled in expand_expr, and not here.
5884 This is because much better code can be generated at
5885 that stage than this one. */
5886 if (TREE_CODE (lhstype
) == RECORD_TYPE
5887 && ! TYPE_PTRMEMFUNC_P (lhstype
)
5888 && (TYPE_MAIN_VARIANT (lhstype
) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))
5889 || (TREE_CODE (TREE_TYPE (newrhs
)) == RECORD_TYPE
5890 && UNIQUELY_DERIVED_FROM_P (lhstype
, TREE_TYPE (newrhs
)))))
5892 tree vbases
= CLASSTYPE_VBASECLASSES (lhstype
);
5893 tree lhs_addr
= build_unary_op (ADDR_EXPR
, lhs
, 0);
5896 /* Memberwise assignment would cause NEWRHS to be
5897 evaluated for every member that gets assigned.
5898 By wrapping side-effecting exprs in a SAVE_EXPR,
5899 NEWRHS will only be evaluated once. */
5900 if (IS_AGGR_TYPE (TREE_TYPE (newrhs
))
5901 && TREE_SIDE_EFFECTS (newrhs
)
5902 /* This are things we don't have to save. */
5903 && TREE_CODE (newrhs
) != COND_EXPR
5904 && TREE_CODE (newrhs
) != TARGET_EXPR
5905 && TREE_CODE (newrhs
) != WITH_CLEANUP_EXPR
)
5906 /* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
5907 If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
5908 will result in expand_expr expanding the call without knowing
5909 that it should run the cleanup. */
5910 newrhs
= save_expr (break_out_cleanups (newrhs
));
5912 if (TREE_CODE (newrhs
) == COND_EXPR
)
5913 rhs_addr
= rationalize_conditional_expr (ADDR_EXPR
, newrhs
);
5915 rhs_addr
= build_unary_op (ADDR_EXPR
, newrhs
, 0);
5917 result
= tree_cons (NULL_TREE
,
5918 convert (build_reference_type (lhstype
), lhs
),
5921 if (! comptypes (TREE_TYPE (lhs_addr
), TREE_TYPE (rhs_addr
), 1))
5922 rhs_addr
= convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr
)), rhs_addr
);
5924 tree noncopied_parts
= NULL_TREE
;
5926 if (TYPE_NONCOPIED_PARTS (lhstype
) != 0)
5927 noncopied_parts
= init_noncopied_parts (lhs
,
5928 TYPE_NONCOPIED_PARTS (lhstype
));
5929 while (noncopied_parts
!= 0)
5931 result
= tree_cons (NULL_TREE
,
5932 build_modify_expr (convert (ptr_type_node
, TREE_VALUE (noncopied_parts
)),
5934 TREE_PURPOSE (noncopied_parts
)),
5936 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
5939 /* Once we have our hands on an address, we must change NEWRHS
5940 to work from there. Otherwise we can get multiple evaluations
5942 if (TREE_CODE (newrhs
) != SAVE_EXPR
)
5943 newrhs
= build_indirect_ref (rhs_addr
, NULL_PTR
);
5947 tree elt_lhs
= convert_pointer_to (vbases
, lhs_addr
);
5948 tree elt_rhs
= convert_pointer_to (vbases
, rhs_addr
);
5950 = tree_cons (NULL_TREE
,
5951 build_modify_expr_1 (build_indirect_ref (elt_lhs
, NULL_PTR
),
5953 build_indirect_ref (elt_rhs
, NULL_PTR
),
5954 TYPE_BINFO (lhstype
)),
5956 if (TREE_VALUE (result
) == error_mark_node
)
5957 return error_mark_node
;
5958 vbases
= TREE_CHAIN (vbases
);
5960 result
= tree_cons (NULL_TREE
,
5961 build_modify_expr_1 (lhs
,
5964 TYPE_BINFO (lhstype
)),
5966 return build_compound_expr (result
);
5970 /* Convert new value to destination type. */
5972 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5976 if (! comptypes (lhstype
, TREE_TYPE (rhs
), 0))
5978 cp_error ("incompatible types in assignment of `%T' to `%T'",
5979 TREE_TYPE (rhs
), lhstype
);
5980 return error_mark_node
;
5983 /* Allow array assignment in compiler-generated code. */
5984 if (pedantic
&& ! DECL_ARTIFICIAL (current_function_decl
))
5985 pedwarn ("ANSI C++ forbids assignment of arrays");
5987 /* Have to wrap this in RTL_EXPR for two cases:
5988 in base or member initialization and if we
5989 are a branch of a ?: operator. Since we
5990 can't easily know the latter, just do it always. */
5992 result
= make_node (RTL_EXPR
);
5994 TREE_TYPE (result
) = void_type_node
;
5995 do_pending_stack_adjust ();
5996 start_sequence_for_rtl_expr (result
);
5998 /* As a matter of principle, `start_sequence' should do this. */
6001 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
6002 ? 1 + (modifycode
!= INIT_EXPR
): 0;
6003 expand_vec_init (lhs
, lhs
, array_type_nelts (lhstype
), newrhs
,
6006 do_pending_stack_adjust ();
6008 TREE_SIDE_EFFECTS (result
) = 1;
6009 RTL_EXPR_SEQUENCE (result
) = get_insns ();
6010 RTL_EXPR_RTL (result
) = const0_rtx
;
6015 if (modifycode
== INIT_EXPR
)
6017 newrhs
= convert_for_initialization (lhs
, lhstype
, newrhs
, LOOKUP_NORMAL
,
6018 "assignment", NULL_TREE
, 0);
6019 if (lhs
== DECL_RESULT (current_function_decl
))
6021 if (DECL_INITIAL (lhs
))
6022 warning ("return value from function receives multiple initializations");
6023 DECL_INITIAL (lhs
) = newrhs
;
6029 if (IS_AGGR_TYPE (lhstype
))
6031 if (result
= build_opfncall (MODIFY_EXPR
,
6032 LOOKUP_NORMAL
, lhs
, newrhs
,
6033 make_node (NOP_EXPR
)))
6037 /* Avoid warnings on enum bit fields. */
6038 if (TREE_CODE (olhstype
) == ENUMERAL_TYPE
6039 && TREE_CODE (lhstype
) == INTEGER_TYPE
)
6041 newrhs
= convert_for_assignment (olhstype
, newrhs
, "assignment",
6043 newrhs
= convert_force (lhstype
, newrhs
, 0);
6046 newrhs
= convert_for_assignment (lhstype
, newrhs
, "assignment",
6048 if (TREE_CODE (newrhs
) == CALL_EXPR
6049 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
6050 newrhs
= build_cplus_new (lhstype
, newrhs
, 0);
6052 /* Can't initialize directly from a TARGET_EXPR, since that would
6053 cause the lhs to be constructed twice. So we force the
6054 TARGET_EXPR to be expanded. expand_expr should really do this
6056 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6057 newrhs
= expand_target_expr (newrhs
);
6060 if (TREE_CODE (newrhs
) == ERROR_MARK
)
6061 return error_mark_node
;
6063 if (TREE_CODE (newrhs
) == COND_EXPR
)
6066 tree cond
= TREE_OPERAND (newrhs
, 0);
6068 if (TREE_SIDE_EFFECTS (lhs
))
6069 cond
= build_compound_expr (tree_cons
6071 build_tree_list (NULL_TREE
, cond
)));
6073 /* Cannot have two identical lhs on this one tree (result) as preexpand
6074 calls will rip them out and fill in RTL for them, but when the
6075 rtl is generated, the calls will only be in the first side of the
6076 condition, not on both, or before the conditional jump! (mrs) */
6077 lhs1
= break_out_calls (lhs
);
6080 /* If there's no change, the COND_EXPR behaves like any other rhs. */
6081 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6082 lhstype
, lhs
, newrhs
);
6085 tree result_type
= TREE_TYPE (newrhs
);
6086 /* We have to convert each arm to the proper type because the
6087 types may have been munged by constant folding. */
6089 = build (COND_EXPR
, result_type
, cond
,
6090 build_modify_expr (lhs
, modifycode
,
6091 convert (result_type
,
6092 TREE_OPERAND (newrhs
, 1))),
6093 build_modify_expr (lhs1
, modifycode
,
6094 convert (result_type
,
6095 TREE_OPERAND (newrhs
, 2))));
6098 else if (modifycode
!= INIT_EXPR
&& TREE_CODE (newrhs
) == WITH_CLEANUP_EXPR
)
6100 tree cleanup
= TREE_OPERAND (newrhs
, 2);
6103 /* Finish up by running cleanups and having the "value" of the lhs. */
6104 tree exprlist
= tree_cons (NULL_TREE
, cleanup
,
6105 build_tree_list (NULL_TREE
, lhs
));
6106 newrhs
= TREE_OPERAND (newrhs
, 0);
6107 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
6108 slot
= TREE_OPERAND (newrhs
, 0);
6109 else if (TREE_CODE (newrhs
) == ADDR_EXPR
)
6111 /* Bad but valid. */
6113 warning ("address taken of temporary object");
6116 my_friendly_abort (118);
6118 /* Copy the value computed in SLOT into LHS. */
6119 exprlist
= tree_cons (NULL_TREE
,
6120 build_modify_expr (lhs
, modifycode
, slot
),
6122 /* Evaluate the expression that needs CLEANUP. This will
6123 compute the value into SLOT. */
6124 exprlist
= tree_cons (NULL_TREE
, newrhs
, exprlist
);
6125 result
= convert (lhstype
, build_compound_expr (exprlist
));
6128 result
= build (modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
6129 lhstype
, lhs
, newrhs
);
6130 TREE_SIDE_EFFECTS (result
) = 1;
6132 /* If we got the LHS in a different type for storing in,
6133 convert the result back to the nominal type of LHS
6134 so that the value we return always has the same type
6135 as the LHS argument. */
6137 if (olhstype
== TREE_TYPE (result
))
6139 /* Avoid warnings converting integral types back into enums
6140 for enum bit fields. */
6141 if (TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
6142 && TREE_CODE (olhstype
) == ENUMERAL_TYPE
)
6144 result
= build (COMPOUND_EXPR
, olhstype
, result
, olhs
);
6145 TREE_NO_UNUSED_WARNING (result
) = 1;
6148 return convert_for_assignment (olhstype
, result
, "assignment",
6153 /* Return 0 if EXP is not a valid lvalue in this language
6154 even though `lvalue_or_else' would accept it. */
6157 language_lvalue_valid (exp
)
6163 /* Get differnce in deltas for different pointer to member function
6164 types. Return inetger_zero_node, if FROM cannot be converted to a
6165 TO type. If FORCE is true, then allow reverse conversions as well. */
6167 get_delta_difference (from
, to
, force
)
6171 tree delta
= integer_zero_node
;
6177 /* Should get_base_distance here, so we can check if any thing along the
6178 path is virtual, and we need to make sure we stay
6179 inside the real binfos when going through virtual bases.
6180 Maybe we should replace virtual bases with
6181 binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */
6182 binfo
= get_binfo (from
, to
, 1);
6183 if (binfo
== error_mark_node
)
6185 error (" in pointer to member function conversion");
6192 error_not_base_type (from
, to
);
6193 error (" in pointer to member function conversion");
6196 binfo
= get_binfo (to
, from
, 1);
6197 if (binfo
== error_mark_node
)
6199 error (" in pointer to member function conversion");
6204 error ("cannot convert pointer to member of type %T to unrelated pointer to member of type %T", from
, to
);
6207 if (TREE_VIA_VIRTUAL (binfo
))
6209 warning ("pointer to member conversion to virtual base class will only work if you are very careful");
6211 return build_binary_op (MINUS_EXPR
,
6213 BINFO_OFFSET (binfo
), 1);
6215 if (TREE_VIA_VIRTUAL (binfo
))
6217 warning ("pointer to member conversion from virtual base class will only work if you are very careful");
6219 return BINFO_OFFSET (binfo
);
6222 /* Build a constructor for a pointer to member function. It can be
6223 used to initialize global variables, local variable, or used
6224 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
6227 If FORCE is non-zero, then force this conversion, even if
6228 we would rather not do it. Usually set when using an explicit
6231 Return error_mark_node, if something goes wrong. */
6234 build_ptrmemfunc (type
, pfn
, force
)
6238 tree index
= integer_zero_node
;
6239 tree delta
= integer_zero_node
;
6240 tree delta2
= integer_zero_node
;
6245 /* Handle multiple conversions of pointer to member fucntions. */
6246 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn
)))
6248 tree ndelta
, ndelta2
, nindex
;
6249 /* Is is already the right type? */
6251 /* Sorry, can't do this, the backend is too stupid. */
6252 if (TYPE_METHOD_BASETYPE (TREE_TYPE (type
))
6253 == TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))))
6255 if (type
!= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6257 npfn
= build1 (NOP_EXPR
, TYPE_GET_PTRMEMFUNC_TYPE (type
), pfn
);
6258 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6263 if (type
== TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))
6267 if (TREE_CODE (pfn
) != CONSTRUCTOR
)
6270 ndelta
= convert (ptrdiff_type_node
, build_component_ref (pfn
, delta_identifier
, 0, 0));
6271 ndelta2
= convert (ptrdiff_type_node
, DELTA2_FROM_PTRMEMFUNC (pfn
));
6272 index
= build_component_ref (pfn
, index_identifier
, 0, 0);
6273 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn
)))),
6274 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6276 delta
= build_binary_op (PLUS_EXPR
, delta
, ndelta
, 1);
6277 delta2
= build_binary_op (PLUS_EXPR
, ndelta2
, delta2
, 1);
6278 e1
= fold (build (GT_EXPR
, boolean_type_node
, index
, integer_zero_node
));
6280 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6281 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6282 tree_cons (NULL_TREE
, index
,
6283 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6284 e2
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6286 pfn
= PFN_FROM_PTRMEMFUNC (pfn
);
6287 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6288 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6290 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6291 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6292 tree_cons (NULL_TREE
, index
,
6293 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6294 e3
= digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6295 return build_conditional_expr (e1
, e2
, e3
);
6298 ndelta
= TREE_VALUE (CONSTRUCTOR_ELTS (pfn
));
6299 nindex
= TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
)));
6300 npfn
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (pfn
))));
6301 npfn
= TREE_VALUE (CONSTRUCTOR_ELTS (npfn
));
6302 if (integer_zerop (nindex
))
6303 pfn
= integer_zero_node
;
6306 sorry ("value casting of varible nonnull pointer to member functions not supported");
6307 return error_mark_node
;
6311 /* Handle null pointer to member function conversions. */
6312 if (integer_zerop (pfn
))
6314 pfn
= build_c_cast (type
, integer_zero_node
, 0);
6315 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, pfn
, NULL_TREE
));
6316 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, integer_zero_node
,
6317 tree_cons (NULL_TREE
, integer_zero_node
,
6318 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6319 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6322 if (TREE_CODE (pfn
) == TREE_LIST
6323 || (TREE_CODE (pfn
) == ADDR_EXPR
6324 && TREE_CODE (TREE_OPERAND (pfn
, 0)) == TREE_LIST
))
6326 pfn
= instantiate_type (type
, pfn
, 1);
6327 if (pfn
== error_mark_node
)
6328 return error_mark_node
;
6329 if (TREE_CODE (pfn
) != ADDR_EXPR
)
6330 pfn
= build_unary_op (ADDR_EXPR
, pfn
, 0);
6333 /* Allow pointer to member conversions here. */
6334 delta
= get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn
))),
6335 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
6337 delta2
= build_binary_op (PLUS_EXPR
, delta2
, delta
, 1);
6339 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) != FUNCTION_DECL
)
6340 warning ("assuming pointer to member function is non-virtual");
6342 if (TREE_CODE (TREE_OPERAND (pfn
, 0)) == FUNCTION_DECL
6343 && DECL_VINDEX (TREE_OPERAND (pfn
, 0)))
6345 /* Find the offset to the vfield pointer in the object. */
6346 vfield_offset
= get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn
, 0)),
6347 DECL_CLASS_CONTEXT (TREE_OPERAND (pfn
, 0)),
6349 vfield_offset
= get_vfield_offset (vfield_offset
);
6350 delta2
= size_binop (PLUS_EXPR
, vfield_offset
, delta2
);
6352 /* Map everything down one to make room for the null pointer to member. */
6353 index
= size_binop (PLUS_EXPR
,
6354 DECL_VINDEX (TREE_OPERAND (pfn
, 0)),
6356 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (delta2_identifier
, delta2
, NULL_TREE
));
6360 index
= size_binop (MINUS_EXPR
, integer_zero_node
, integer_one_node
);
6362 npfn
= build1 (NOP_EXPR
, type
, pfn
);
6363 TREE_CONSTANT (npfn
) = TREE_CONSTANT (pfn
);
6365 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (pfn_identifier
, npfn
, NULL_TREE
));
6368 u
= build_nt (CONSTRUCTOR
, 0, tree_cons (NULL_TREE
, delta
,
6369 tree_cons (NULL_TREE
, index
,
6370 tree_cons (NULL_TREE
, u
, NULL_TREE
))));
6371 return digest_init (TYPE_GET_PTRMEMFUNC_TYPE (type
), u
, (tree
*)0);
6374 /* Convert value RHS to type TYPE as preparation for an assignment
6375 to an lvalue of type TYPE.
6376 The real work of conversion is done by `convert'.
6377 The purpose of this function is to generate error messages
6378 for assignments that are not allowed in C.
6379 ERRTYPE is a string to use in error messages:
6380 "assignment", "return", etc.
6382 C++: attempts to allow `convert' to find conversions involving
6383 implicit type conversion between aggregate and scalar types
6384 as per 8.5.6 of C++ manual. Does not randomly dereference
6385 pointers to aggregates! */
6388 convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
)
6394 register enum tree_code codel
= TREE_CODE (type
);
6395 register tree rhstype
;
6396 register enum tree_code coder
= TREE_CODE (TREE_TYPE (rhs
));
6398 if (coder
== UNKNOWN_TYPE
)
6399 rhs
= instantiate_type (type
, rhs
, 1);
6401 if (coder
== ERROR_MARK
)
6402 return error_mark_node
;
6404 if (codel
== OFFSET_TYPE
)
6406 type
= TREE_TYPE (type
);
6407 codel
= TREE_CODE (type
);
6410 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
6411 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
6412 rhs
= TREE_OPERAND (rhs
, 0);
6414 if (rhs
== error_mark_node
)
6415 return error_mark_node
;
6417 if (TREE_VALUE (rhs
) == error_mark_node
)
6418 return error_mark_node
;
6420 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6422 rhs
= resolve_offset_ref (rhs
);
6423 if (rhs
== error_mark_node
)
6424 return error_mark_node
;
6425 rhstype
= TREE_TYPE (rhs
);
6426 coder
= TREE_CODE (rhstype
);
6429 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6430 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6431 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6432 rhs
= default_conversion (rhs
);
6433 else if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6434 rhs
= convert_from_reference (rhs
);
6436 rhstype
= TREE_TYPE (rhs
);
6437 coder
= TREE_CODE (rhstype
);
6439 /* This should no longer change types on us. */
6440 if (TREE_CODE (rhs
) == CONST_DECL
)
6441 rhs
= DECL_INITIAL (rhs
);
6442 else if (TREE_READONLY_DECL_P (rhs
))
6443 rhs
= decl_constant_value (rhs
);
6445 if (type
== rhstype
)
6447 overflow_warning (rhs
);
6451 if (coder
== VOID_TYPE
)
6453 error ("void value not ignored as it ought to be");
6454 return error_mark_node
;
6456 /* Arithmetic types all interconvert. */
6457 if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
|| codel
== BOOLEAN_TYPE
)
6458 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
|| coder
== BOOLEAN_TYPE
))
6460 /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */
6461 if (coder
== REAL_TYPE
&& codel
== INTEGER_TYPE
)
6464 cp_warning ("`%T' used for argument %P of `%D'",
6465 rhstype
, parmnum
, fndecl
);
6467 cp_warning ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6469 /* And we should warn if assigning a negative value to
6470 an unsigned variable. */
6471 else if (TREE_UNSIGNED (type
) && codel
!= BOOLEAN_TYPE
)
6473 if (TREE_CODE (rhs
) == INTEGER_CST
6474 && TREE_NEGATED_INT (rhs
))
6477 cp_warning ("negative value `%E' passed as argument %P of `%D'",
6478 rhs
, parmnum
, fndecl
);
6480 cp_warning ("%s of negative value `%E' to `%T'",
6481 errtype
, rhs
, type
);
6483 overflow_warning (rhs
);
6484 if (TREE_CONSTANT (rhs
))
6488 return convert_and_check (type
, rhs
);
6490 /* Conversions involving enums. */
6491 else if ((codel
== ENUMERAL_TYPE
6492 && (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
))
6493 || (coder
== ENUMERAL_TYPE
6494 && (INTEGRAL_CODE_P (codel
) || codel
== REAL_TYPE
)))
6496 return cp_convert (type
, rhs
, CONV_IMPLICIT
, 0);
6498 /* Conversions among pointers */
6499 else if (codel
== POINTER_TYPE
6500 && (coder
== POINTER_TYPE
6501 || (coder
== RECORD_TYPE
6502 && (IS_SIGNATURE_POINTER (rhstype
)
6503 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6505 register tree ttl
= TREE_TYPE (type
);
6509 if (coder
== RECORD_TYPE
)
6511 rhs
= build_optr_ref (rhs
);
6512 rhstype
= TREE_TYPE (rhs
);
6514 ttr
= TREE_TYPE (rhstype
);
6516 /* If both pointers are of aggregate type, then we
6517 can give better error messages, and save some work
6519 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
6523 if (TYPE_MAIN_VARIANT (ttl
) == TYPE_MAIN_VARIANT (ttr
)
6524 || type
== class_star_type_node
6525 || rhstype
== class_star_type_node
)
6526 binfo
= TYPE_BINFO (ttl
);
6528 binfo
= get_binfo (ttl
, ttr
, 1);
6530 if (binfo
== error_mark_node
)
6531 return error_mark_node
;
6533 return error_not_base_type (ttl
, ttr
);
6535 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6538 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6539 rhstype
, parmnum
, fndecl
);
6541 cp_pedwarn ("%s to `%T' from `%T' discards const",
6542 errtype
, type
, rhstype
);
6544 if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6547 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6548 rhstype
, parmnum
, fndecl
);
6550 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6551 errtype
, type
, rhstype
);
6555 /* Any non-function converts to a [const][volatile] void *
6556 and vice versa; otherwise, targets must be the same.
6557 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6558 else if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6559 || TYPE_MAIN_VARIANT (ttr
) == void_type_node
6560 || (ctt
= comp_target_types (type
, rhstype
, 1))
6561 || (unsigned_type (TYPE_MAIN_VARIANT (ttl
))
6562 == unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
6564 /* ARM $4.8, commentary on p39. */
6565 if (TYPE_MAIN_VARIANT (ttl
) == void_type_node
6566 && TREE_CODE (ttr
) == OFFSET_TYPE
)
6568 cp_error ("no standard conversion from `%T' to `void *'", ttr
);
6569 return error_mark_node
;
6573 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6576 if (TYPE_MAIN_VARIANT (ttl
) != void_type_node
6577 && TYPE_MAIN_VARIANT (ttr
) == void_type_node
6578 && rhs
!= null_pointer_node
)
6580 if (coder
== RECORD_TYPE
)
6581 cp_pedwarn ("implicit conversion of signature pointer to type `%T'",
6584 pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
6587 /* Const and volatile mean something different for function types,
6588 so the usual warnings are not appropriate. */
6589 else if ((TREE_CODE (ttr
) != FUNCTION_TYPE
&& TREE_CODE (ttr
) != METHOD_TYPE
)
6590 || (TREE_CODE (ttl
) != FUNCTION_TYPE
&& TREE_CODE (ttl
) != METHOD_TYPE
))
6592 if (TREE_CODE (ttl
) == OFFSET_TYPE
6593 && binfo_member (TYPE_OFFSET_BASETYPE (ttr
),
6594 CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl
))))
6596 sorry ("%s between pointer to members converting across virtual baseclasses", errtype
);
6597 return error_mark_node
;
6599 else if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
6602 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6603 rhstype
, parmnum
, fndecl
);
6605 cp_pedwarn ("%s to `%T' from `%T' discards const",
6606 errtype
, type
, rhstype
);
6608 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
6611 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6612 rhstype
, parmnum
, fndecl
);
6614 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6615 errtype
, type
, rhstype
);
6617 else if (TREE_CODE (ttl
) == TREE_CODE (ttr
)
6618 && ! comp_target_types (type
, rhstype
, 1))
6621 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness",
6622 rhstype
, parmnum
, fndecl
);
6624 cp_pedwarn ("%s to `%T' from `%T' changes signedness",
6625 errtype
, type
, rhstype
);
6629 else if (TREE_CODE (ttr
) == OFFSET_TYPE
6630 && TREE_CODE (ttl
) != OFFSET_TYPE
)
6632 /* Normally, pointers to different type codes (other
6633 than void) are not compatible, but we perform
6634 some type instantiation if that resolves the
6635 ambiguity of (X Y::*) and (X *). */
6637 if (current_class_decl
)
6639 if (TREE_CODE (rhs
) == INTEGER_CST
)
6641 rhs
= build (PLUS_EXPR
, build_pointer_type (TREE_TYPE (ttr
)),
6642 current_class_decl
, rhs
);
6643 return convert_for_assignment (type
, rhs
,
6644 errtype
, fndecl
, parmnum
);
6647 if (TREE_CODE (ttl
) == METHOD_TYPE
)
6648 error ("%s between pointer-to-method and pointer-to-member types",
6651 error ("%s between pointer and pointer-to-member types", errtype
);
6652 return error_mark_node
;
6656 int add_quals
= 0, const_parity
= 0, volatile_parity
= 0;
6658 int unsigned_parity
;
6661 /* This code is basically a duplicate of comp_ptr_ttypes_real. */
6662 for (; ; ttl
= TREE_TYPE (ttl
), ttr
= TREE_TYPE (ttr
))
6665 const_parity
|= TYPE_READONLY (ttl
) < TYPE_READONLY (ttr
);
6666 volatile_parity
|= TYPE_VOLATILE (ttl
) < TYPE_VOLATILE (ttr
);
6669 && (TYPE_READONLY (ttl
) > TYPE_READONLY (ttr
)
6670 || TYPE_VOLATILE (ttl
) > TYPE_VOLATILE (ttr
)))
6672 left_const
&= TYPE_READONLY (ttl
);
6674 if (TREE_CODE (ttl
) != POINTER_TYPE
6675 || TREE_CODE (ttr
) != POINTER_TYPE
)
6678 unsigned_parity
= TREE_UNSIGNED (ttl
) - TREE_UNSIGNED (ttr
);
6679 if (unsigned_parity
)
6681 if (TREE_UNSIGNED (ttl
))
6682 ttr
= unsigned_type (ttr
);
6684 ttl
= unsigned_type (ttl
);
6687 if (comp_target_types (ttl
, ttr
, nptrs
) > 0)
6692 cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'",
6693 rhstype
, parmnum
, fndecl
);
6695 cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'",
6696 errtype
, type
, rhstype
);
6701 cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
6702 rhstype
, parmnum
, fndecl
);
6704 cp_pedwarn ("%s to `%T' from `%T' discards const",
6705 errtype
, type
, rhstype
);
6707 if (volatile_parity
)
6710 cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
6711 rhstype
, parmnum
, fndecl
);
6713 cp_pedwarn ("%s to `%T' from `%T' discards volatile",
6714 errtype
, type
, rhstype
);
6716 if (unsigned_parity
> 0)
6719 cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
6720 rhstype
, parmnum
, fndecl
);
6722 cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
6723 errtype
, type
, rhstype
);
6725 else if (unsigned_parity
< 0)
6728 cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
6729 rhstype
, parmnum
, fndecl
);
6731 cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
6732 errtype
, type
, rhstype
);
6735 /* C++ is not so friendly about converting function and
6736 member function pointers as C. Emit warnings here. */
6737 if (TREE_CODE (ttl
) == FUNCTION_TYPE
6738 || TREE_CODE (ttl
) == METHOD_TYPE
)
6739 if (! comptypes (ttl
, ttr
, 0))
6741 warning ("conflicting function types in %s:", errtype
);
6742 cp_warning ("\t`%T' != `%T'", type
, rhstype
);
6745 else if (TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6747 /* When does this happen? */
6748 my_friendly_abort (119);
6749 /* Conversion of a pointer-to-member type to void *. */
6750 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6751 TREE_TYPE (rhs
) = type
;
6754 else if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6756 /* When does this happen? */
6757 my_friendly_abort (120);
6758 /* Conversion of a pointer-to-member type to void *. */
6759 rhs
= build_unary_op (ADDR_EXPR
, rhs
, 0);
6760 TREE_TYPE (rhs
) = type
;
6766 cp_error ("passing `%T' as argument %P of `%D'",
6767 rhstype
, parmnum
, fndecl
);
6769 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6770 return error_mark_node
;
6773 return convert (type
, rhs
);
6775 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6777 /* An explicit constant 0 can convert to a pointer,
6778 but not a 0 that results from casting or folding. */
6779 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
)))
6782 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6783 rhstype
, parmnum
, fndecl
);
6785 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6786 errtype
, type
, rhstype
);
6787 return convert (type
, rhs
);
6789 return null_pointer_node
;
6791 else if (codel
== INTEGER_TYPE
6792 && (coder
== POINTER_TYPE
6793 || (coder
== RECORD_TYPE
6794 && (IS_SIGNATURE_POINTER (rhstype
)
6795 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6796 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6799 cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
6800 rhstype
, parmnum
, fndecl
);
6802 cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
6803 errtype
, type
, rhstype
);
6804 return convert (type
, rhs
);
6806 else if (codel
== BOOLEAN_TYPE
6807 && (coder
== POINTER_TYPE
6808 || (coder
== RECORD_TYPE
6809 && (IS_SIGNATURE_POINTER (rhstype
)
6810 || TYPE_PTRMEMFUNC_FLAG (rhstype
)
6811 || IS_SIGNATURE_REFERENCE (rhstype
)))))
6812 return convert (type
, rhs
);
6815 else if (((coder
== POINTER_TYPE
6816 && TREE_CODE (TREE_TYPE (rhstype
)) == METHOD_TYPE
)
6817 || integer_zerop (rhs
)
6818 || TYPE_PTRMEMFUNC_P (rhstype
))
6819 && TYPE_PTRMEMFUNC_P (type
))
6821 tree ttl
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
6822 tree ttr
= (TREE_CODE (rhstype
) == POINTER_TYPE
? rhstype
6823 : TYPE_PTRMEMFUNC_FN_TYPE (type
));
6824 int ctt
= comp_target_types (ttl
, ttr
, 1);
6827 cp_pedwarn ("converting `%T' to `%T' is a contravariance violation",
6830 cp_error ("%s to `%T' from `%T'", errtype
, ttl
, ttr
);
6832 /* compatible pointer to member functions. */
6833 return build_ptrmemfunc (ttl
, rhs
, 0);
6835 else if (codel
== ERROR_MARK
|| coder
== ERROR_MARK
)
6836 return error_mark_node
;
6838 /* This should no longer happen. References are initialized via
6839 `convert_for_initialization'. They should otherwise be
6840 bashed before coming here. */
6841 else if (codel
== REFERENCE_TYPE
)
6842 my_friendly_abort (317);
6843 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs
)))
6845 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
6846 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
6849 else if (TYPE_HAS_CONSTRUCTOR (type
) || IS_AGGR_TYPE (TREE_TYPE (rhs
)))
6850 return convert (type
, rhs
);
6852 cp_error ("%s to `%T' from `%T'", errtype
, type
, rhstype
);
6853 return error_mark_node
;
6856 /* Convert RHS to be of type TYPE. If EXP is non-zero,
6857 it is the target of the initialization.
6858 ERRTYPE is a string to use in error messages.
6860 Two major differences between the behavior of
6861 `convert_for_assignment' and `convert_for_initialization'
6862 are that references are bashed in the former, while
6863 copied in the latter, and aggregates are assigned in
6864 the former (operator=) while initialized in the
6867 If using constructor make sure no conversion operator exists, if one does
6868 exist, an ambiguity exists. */
6870 convert_for_initialization (exp
, type
, rhs
, flags
, errtype
, fndecl
, parmnum
)
6871 tree exp
, type
, rhs
;
6877 register enum tree_code codel
= TREE_CODE (type
);
6878 register tree rhstype
;
6879 register enum tree_code coder
;
6881 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6882 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
6883 if (TREE_CODE (rhs
) == NOP_EXPR
6884 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
6885 && codel
!= REFERENCE_TYPE
)
6886 rhs
= TREE_OPERAND (rhs
, 0);
6888 if (rhs
== error_mark_node
6889 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
6890 return error_mark_node
;
6892 if (TREE_CODE (TREE_TYPE (rhs
)) == OFFSET_TYPE
)
6894 rhs
= resolve_offset_ref (rhs
);
6895 if (rhs
== error_mark_node
)
6896 return error_mark_node
;
6899 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
6900 rhs
= convert_from_reference (rhs
);
6902 if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
6903 && TREE_CODE (type
) != ARRAY_TYPE
6904 && (TREE_CODE (type
) != REFERENCE_TYPE
6905 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
6906 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
6907 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
6908 rhs
= default_conversion (rhs
);
6910 rhstype
= TREE_TYPE (rhs
);
6911 coder
= TREE_CODE (rhstype
);
6913 if (coder
== UNKNOWN_TYPE
)
6915 rhs
= instantiate_type (type
, rhs
, 1);
6916 rhstype
= TREE_TYPE (rhs
);
6917 coder
= TREE_CODE (rhstype
);
6920 if (coder
== ERROR_MARK
)
6921 return error_mark_node
;
6924 /* This is *not* the quick way out! It is the way to disaster. */
6925 if (type
== rhstype
)
6929 /* We accept references to incomplete types, so we can
6930 return here before checking if RHS is of complete type. */
6932 if (codel
== REFERENCE_TYPE
)
6934 /* This should eventually happen in convert_arguments. */
6935 extern int warningcount
, errorcount
;
6939 savew
= warningcount
, savee
= errorcount
;
6940 rhs
= convert_to_reference (type
, rhs
, CONV_IMPLICIT
, flags
,
6941 exp
? exp
: error_mark_node
);
6944 if (warningcount
> savew
)
6945 cp_warning_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6946 else if (errorcount
> savee
)
6947 cp_error_at ("in passing argument %P of `%+D'", parmnum
, fndecl
);
6952 rhs
= require_complete_type (rhs
);
6953 if (rhs
== error_mark_node
)
6954 return error_mark_node
;
6956 if (exp
!= 0) exp
= require_complete_type (exp
);
6957 if (exp
== error_mark_node
)
6958 return error_mark_node
;
6960 if (TREE_CODE (rhstype
) == REFERENCE_TYPE
)
6961 rhstype
= TREE_TYPE (rhstype
);
6963 if (TYPE_LANG_SPECIFIC (type
)
6964 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
6965 return build_signature_pointer_constructor (type
, rhs
);
6967 if (IS_AGGR_TYPE (type
)
6968 && (TYPE_NEEDS_CONSTRUCTING (type
) || TREE_HAS_CONSTRUCTOR (rhs
)))
6970 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
6972 /* This is sufficient to perform initialization. No need,
6973 apparently, to go through X(X&) to do first-cut
6974 initialization. Return through a TARGET_EXPR so that we get
6975 cleanups if it is used. */
6976 if (TREE_CODE (rhs
) == CALL_EXPR
)
6978 rhs
= build_cplus_new (type
, rhs
, 0);
6981 /* Handle the case of default parameter initialization and
6982 initialization of static variables. */
6983 else if (TREE_CODE (rhs
) == TARGET_EXPR
)
6985 else if (TREE_CODE (rhs
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (rhs
))
6987 my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs
, 0)) == CALL_EXPR
, 318);
6990 my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1)) == NULL_TREE
, 316);
6991 TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs
, 0), 1))
6992 = build_unary_op (ADDR_EXPR
, exp
, 0);
6995 rhs
= build_cplus_new (type
, TREE_OPERAND (rhs
, 0), 0);
6998 else if (TYPE_HAS_TRIVIAL_INIT_REF (type
))
7001 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
)
7002 || (IS_AGGR_TYPE (rhstype
) && UNIQUELY_DERIVED_FROM_P (type
, rhstype
)))
7004 if (TYPE_HAS_INIT_REF (type
))
7006 tree init
= build_method_call (exp
, constructor_name_full (type
),
7007 build_tree_list (NULL_TREE
, rhs
),
7008 TYPE_BINFO (type
), LOOKUP_NORMAL
);
7010 if (init
== error_mark_node
)
7011 return error_mark_node
;
7015 exp
= build_cplus_new (type
, init
, 0);
7019 return build (COMPOUND_EXPR
, type
, init
, exp
);
7022 /* ??? The following warnings are turned off because
7023 this is another place where the default X(X&) constructor
7025 if (TYPE_HAS_ASSIGNMENT (type
))
7026 cp_warning ("bitwise copy: `%T' defines operator=", type
);
7028 if (TREE_CODE (TREE_TYPE (rhs
)) == REFERENCE_TYPE
)
7029 rhs
= convert_from_reference (rhs
);
7030 if (type
!= rhstype
)
7032 tree nrhs
= build1 (NOP_EXPR
, type
, rhs
);
7033 TREE_CONSTANT (nrhs
) = TREE_CONSTANT (rhs
);
7039 return convert (type
, rhs
);
7042 if (type
== TREE_TYPE (rhs
))
7044 if (TREE_READONLY_DECL_P (rhs
))
7045 rhs
= decl_constant_value (rhs
);
7049 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
);
7052 /* Expand an ASM statement with operands, handling output operands
7053 that are not variables or INDIRECT_REFS by transforming such
7054 cases into cases that expand_asm_operands can handle.
7056 Arguments are same as for expand_asm_operands.
7058 We don't do default conversions on all inputs, because it can screw
7059 up operands that are expected to be in memory. */
7062 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
7063 tree string
, outputs
, inputs
, clobbers
;
7068 int noutputs
= list_length (outputs
);
7070 /* o[I] is the place that output number I should be written. */
7071 register tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
7074 /* Record the contents of OUTPUTS before it is modified. */
7075 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7076 o
[i
] = TREE_VALUE (tail
);
7078 /* Generate the ASM_OPERANDS insn;
7079 store into the TREE_VALUEs of OUTPUTS some trees for
7080 where the values were actually stored. */
7081 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
7083 /* Copy all the intermediate outputs into the specified outputs. */
7084 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
7086 if (o
[i
] != TREE_VALUE (tail
))
7088 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
7089 const0_rtx
, VOIDmode
, 0);
7092 /* Detect modification of read-only values.
7093 (Otherwise done by build_modify_expr.) */
7096 tree type
= TREE_TYPE (o
[i
]);
7097 if (TYPE_READONLY (type
)
7098 || ((TREE_CODE (type
) == RECORD_TYPE
7099 || TREE_CODE (type
) == UNION_TYPE
)
7100 && C_TYPE_FIELDS_READONLY (type
)))
7101 readonly_error (o
[i
], "modification by `asm'", 1);
7105 /* Those MODIFY_EXPRs could do autoincrements. */
7109 /* Expand a C `return' statement.
7110 RETVAL is the expression for what to return,
7111 or a null pointer for `return;' with no value.
7113 C++: upon seeing a `return', we must call destructors on all
7114 variables in scope which had constructors called on them.
7115 This means that if in a destructor, the base class destructors
7116 must be called before returning.
7118 The RETURN statement in C++ has initialization semantics. */
7121 c_expand_return (retval
)
7124 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
7125 extern tree dtor_label
, ctor_label
;
7126 tree result
= DECL_RESULT (current_function_decl
);
7127 tree valtype
= TREE_TYPE (result
);
7128 register int use_temp
= 0;
7129 int returns_value
= 1;
7131 if (TREE_THIS_VOLATILE (current_function_decl
))
7132 warning ("function declared `noreturn' has a `return' statement");
7134 if (retval
== error_mark_node
)
7136 current_function_returns_null
= 1;
7140 if (retval
== NULL_TREE
)
7142 /* A non-named return value does not count. */
7144 /* Can't just return from a destructor. */
7147 expand_goto (dtor_label
);
7151 if (DECL_CONSTRUCTOR_P (current_function_decl
))
7152 retval
= current_class_decl
;
7153 else if (DECL_NAME (result
) != NULL_TREE
7154 && TREE_CODE (valtype
) != VOID_TYPE
)
7158 current_function_returns_null
= 1;
7160 if (valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
7162 if (DECL_NAME (DECL_RESULT (current_function_decl
)) == NULL_TREE
)
7164 pedwarn ("`return' with no value, in function returning non-void");
7165 /* Clear this, so finish_function won't say that we
7166 reach the end of a non-void function (which we don't,
7167 we gave a return!). */
7168 current_function_returns_null
= 0;
7172 expand_null_return ();
7176 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
7177 && retval
!= current_class_decl
)
7179 error ("return from a constructor: use `this = ...' instead");
7180 retval
= current_class_decl
;
7183 if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
7185 current_function_returns_null
= 1;
7186 /* We do this here so we'll avoid a warning about how the function
7187 "may or may not return a value" in finish_function. */
7191 pedwarn ("`return' with a value, in function returning void");
7192 expand_return (retval
);
7194 /* Add some useful error checking for C++. */
7195 else if (TREE_CODE (valtype
) == REFERENCE_TYPE
)
7197 tree whats_returned
;
7198 tree tmp_result
= result
;
7200 /* Don't initialize directly into a non-BLKmode retval, since that
7201 could lose when being inlined by another caller. (GCC can't
7202 read the function return register in an inline function when
7203 the return value is being ignored). */
7204 if (result
&& TYPE_MODE (TREE_TYPE (tmp_result
)) != BLKmode
)
7207 /* convert to reference now, so we can give error if we
7208 return an reference to a non-lvalue. */
7209 retval
= convert_for_initialization (tmp_result
, valtype
, retval
,
7210 LOOKUP_NORMAL
, "return",
7213 /* Sort through common things to see what it is
7214 we are returning. */
7215 whats_returned
= retval
;
7216 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
7218 whats_returned
= TREE_OPERAND (whats_returned
, 1);
7219 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7220 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7222 if (TREE_CODE (whats_returned
) == ADDR_EXPR
)
7224 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7225 while (TREE_CODE (whats_returned
) == NEW_EXPR
7226 || TREE_CODE (whats_returned
) == TARGET_EXPR
7227 || TREE_CODE (whats_returned
) == WITH_CLEANUP_EXPR
)
7229 /* Get the target. */
7230 whats_returned
= TREE_OPERAND (whats_returned
, 0);
7231 warning ("returning reference to temporary");
7235 if (TREE_CODE (whats_returned
) == VAR_DECL
&& DECL_NAME (whats_returned
))
7237 if (TEMP_NAME_P (DECL_NAME (whats_returned
)))
7238 warning ("reference to non-lvalue returned");
7239 else if (! TREE_STATIC (whats_returned
)
7240 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (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 cp_warning_at ("address of local variable `%D' returned", whats_returned
);
7255 /* Now deal with possible C++ hair:
7256 (1) Compute the return value.
7257 (2) If there are aggregate values with destructors which
7258 must be cleaned up, clean them (taking care
7259 not to clobber the return value).
7260 (3) If an X(X&) constructor is defined, the return
7261 value must be returned via that. */
7263 /* If we're returning in a register, we can't initialize the
7264 return value from a TARGET_EXPR. */
7265 if (TREE_CODE (retval
) == TARGET_EXPR
7266 && TYPE_MAIN_VARIANT (TREE_TYPE (retval
)) == TYPE_MAIN_VARIANT (valtype
)
7267 && ! current_function_returns_struct
)
7268 retval
= expand_target_expr (retval
);
7270 if (retval
== result
7271 /* Watch out for constructors, which "return" aggregates
7272 via initialization, but which otherwise "return" a pointer. */
7273 || DECL_CONSTRUCTOR_P (current_function_decl
))
7275 /* This is just an error--it's already been reported. */
7276 if (TYPE_SIZE (valtype
) == NULL_TREE
)
7279 if (TYPE_MODE (valtype
) != BLKmode
7280 && any_pending_cleanups (1))
7282 retval
= get_temp_regvar (valtype
, retval
);
7283 use_temp
= obey_regdecls
;
7286 else if (IS_AGGR_TYPE (valtype
) && current_function_returns_struct
)
7288 expand_aggr_init (result
, retval
, 0, LOOKUP_ONLYCONVERTING
);
7289 expand_cleanups_to (NULL_TREE
);
7290 DECL_INITIAL (result
) = NULL_TREE
;
7295 if (TYPE_MODE (valtype
) == VOIDmode
)
7297 if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
7298 && warn_return_type
)
7299 warning ("return of void value in function returning non-void");
7300 expand_expr_stmt (retval
);
7304 else if (TYPE_MODE (valtype
) != BLKmode
7305 && any_pending_cleanups (1))
7307 retval
= get_temp_regvar (valtype
, retval
);
7308 expand_cleanups_to (NULL_TREE
);
7309 use_temp
= obey_regdecls
;
7314 retval
= convert_for_initialization (result
, valtype
, retval
,
7316 "return", NULL_TREE
, 0);
7317 DECL_INITIAL (result
) = NULL_TREE
;
7319 if (retval
== error_mark_node
)
7325 if (retval
!= NULL_TREE
7326 && TREE_CODE_CLASS (TREE_CODE (retval
)) == 'd'
7327 && cond_stack
== 0 && loop_stack
== 0 && case_stack
== 0)
7328 current_function_return_value
= retval
;
7332 /* Everything's great--RETVAL is in RESULT. */
7333 if (original_result_rtx
)
7335 store_expr (result
, original_result_rtx
, 0);
7336 expand_cleanups_to (NULL_TREE
);
7338 else if (retval
&& retval
!= result
)
7340 /* Clear this out so the later call to decl_function_context
7341 won't end up bombing on us. */
7342 if (DECL_CONTEXT (result
) == error_mark_node
)
7343 DECL_CONTEXT (result
) = NULL_TREE
;
7344 /* Here is where we finally get RETVAL into RESULT.
7345 `expand_return' does the magic of protecting
7346 RESULT from cleanups. */
7347 retval
= fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (result
),
7349 /* This part _must_ come second, because expand_return looks for
7350 the INIT_EXPR as the toplevel node only. :-( */
7351 retval
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7352 TREE_SIDE_EFFECTS (retval
) = 1;
7353 expand_return (retval
);
7356 expand_return (result
);
7358 use_variable (DECL_RTL (result
));
7359 if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7360 expand_goto (ctor_label
);
7362 expand_null_return ();
7366 /* We may still need to put RETVAL into RESULT. */
7367 result
= DECL_RESULT (current_function_decl
);
7368 if (original_result_rtx
)
7370 /* Here we have a named return value that went
7371 into memory. We can compute RETVAL into that. */
7373 expand_assignment (result
, retval
, 0, 0);
7375 store_expr (result
, original_result_rtx
, 0);
7376 result
= make_tree (TREE_TYPE (result
), original_result_rtx
);
7378 else if (ctor_label
&& TREE_CODE (ctor_label
) != ERROR_MARK
)
7380 /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do. */
7381 expand_goto (ctor_label
);
7385 /* Here is where we finally get RETVAL into RESULT.
7386 `expand_return' does the magic of protecting
7387 RESULT from cleanups. */
7388 result
= build (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
7389 TREE_SIDE_EFFECTS (result
) = 1;
7390 expand_return (result
);
7392 else if (TYPE_MODE (TREE_TYPE (result
)) != VOIDmode
)
7393 expand_return (result
);
7396 current_function_returns_value
= returns_value
;
7398 /* These wind up after the BARRIER, which causes problems for
7399 expand_end_binding. What purpose were they supposed to serve? */
7400 if (original_result_rtx
)
7401 use_variable (original_result_rtx
);
7403 use_variable (DECL_RTL (DECL_RESULT (current_function_decl
)));
7406 /* One way to clear out cleanups that EXPR might
7407 generate. Note that this code will really be
7408 dead code, but that is ok--cleanups that were
7409 needed were handled by the magic of `return'. */
7410 expand_cleanups_to (NULL_TREE
);
7413 /* Start a C switch statement, testing expression EXP.
7414 Return EXP if it is valid, an error node otherwise. */
7417 c_expand_start_case (exp
)
7421 register enum tree_code code
;
7423 /* Convert from references, etc. */
7424 exp
= default_conversion (exp
);
7425 type
= TREE_TYPE (exp
);
7426 code
= TREE_CODE (type
);
7428 if (IS_AGGR_TYPE_CODE (code
))
7429 exp
= build_type_conversion (CONVERT_EXPR
, integer_type_node
, exp
, 1);
7431 if (exp
== NULL_TREE
)
7433 error ("switch quantity not an integer");
7434 exp
= error_mark_node
;
7436 type
= TREE_TYPE (exp
);
7437 code
= TREE_CODE (type
);
7439 if (code
!= INTEGER_TYPE
&& code
!= ENUMERAL_TYPE
&& code
!= ERROR_MARK
)
7441 error ("switch quantity not an integer");
7442 exp
= error_mark_node
;
7448 exp
= default_conversion (exp
);
7449 type
= TREE_TYPE (exp
);
7450 index
= get_unwidened (exp
, 0);
7451 /* We can't strip a conversion from a signed type to an unsigned,
7452 because if we did, int_fits_type_p would do the wrong thing
7453 when checking case values for being in range,
7454 and it's too hard to do the right thing. */
7455 if (TREE_UNSIGNED (TREE_TYPE (exp
))
7456 == TREE_UNSIGNED (TREE_TYPE (index
)))
7461 (1, fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
)),
7462 type
, "switch statement");
7467 /* CONSTP remembers whether or not all the intervening pointers in the `to'
7468 type have been const. */
7470 comp_ptr_ttypes_real (to
, from
, constp
)
7474 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
7476 if (TREE_CODE (to
) != TREE_CODE (from
))
7479 if (TYPE_READONLY (from
) > TYPE_READONLY (to
)
7480 || TYPE_VOLATILE (from
) > TYPE_VOLATILE (to
))
7484 && (TYPE_READONLY (to
) > TYPE_READONLY (from
)
7485 || TYPE_VOLATILE (to
) > TYPE_READONLY (from
)))
7487 constp
&= TYPE_READONLY (to
);
7489 if (TREE_CODE (to
) != POINTER_TYPE
)
7490 return comptypes (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
), 1);
7494 /* When comparing, say, char ** to char const **, this function takes the
7495 'char *' and 'char const *'. Do not pass non-pointer types to this
7498 comp_ptr_ttypes (to
, from
)
7501 return comp_ptr_ttypes_real (to
, from
, 1);