1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file contains the functions for converting C expressions
25 to different data types. The only entry point is `convert'.
26 Every language front end must have a `convert' function
27 but what kind of conversions it does will depend on the language. */
38 static tree cp_convert_to_pointer
PARAMS ((tree
, tree
, int));
39 static tree convert_to_pointer_force
PARAMS ((tree
, tree
));
40 static tree build_up_reference
PARAMS ((tree
, tree
, int, tree
));
41 static void warn_ref_binding
PARAMS ((tree
, tree
, tree
));
43 /* Change of width--truncation and extension of integers or reals--
44 is represented with NOP_EXPR. Proper functioning of many things
45 assumes that no other conversions can be NOP_EXPRs.
47 Conversion between integer and pointer is represented with CONVERT_EXPR.
48 Converting integer to real uses FLOAT_EXPR
49 and real to integer uses FIX_TRUNC_EXPR.
51 Here is a list of all the functions that assume that widening and
52 narrowing is always done with a NOP_EXPR:
53 In convert.c, convert_to_integer.
54 In c-typeck.c, build_binary_op_nodefault (boolean ops),
55 and c_common_truthvalue_conversion.
56 In expr.c: expand_expr, for operands of a MULT_EXPR.
57 In fold-const.c: fold.
58 In tree.c: get_narrower and get_unwidened.
60 C++: in multiple-inheritance, converting between pointers may involve
61 adjusting them by a delta stored within the class definition. */
63 /* Subroutines of `convert'. */
65 /* if converting pointer to pointer
66 if dealing with classes, check for derived->base or vice versa
67 else if dealing with method pointers, delegate
69 else if converting class, pass off to build_type_conversion
70 else try C-style pointer conversion. If FORCE is true then allow
71 conversions via virtual bases (these are permitted by reinterpret_cast,
72 but not static_cast). */
75 cp_convert_to_pointer (type
, expr
, force
)
79 register tree intype
= TREE_TYPE (expr
);
80 register enum tree_code form
;
83 if (IS_AGGR_TYPE (intype
))
85 intype
= complete_type (intype
);
86 if (!COMPLETE_TYPE_P (intype
))
88 error ("can't convert from incomplete type `%T' to `%T'",
90 return error_mark_node
;
93 rval
= build_type_conversion (type
, expr
, 1);
96 if (rval
== error_mark_node
)
97 error ("conversion of `%E' from `%T' to `%T' is ambiguous",
103 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
104 if (TREE_CODE (type
) == POINTER_TYPE
105 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
106 || VOID_TYPE_P (TREE_TYPE (type
))))
108 /* Allow an implicit this pointer for pointer to member
110 if (TYPE_PTRMEMFUNC_P (intype
))
112 tree fntype
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype
));
113 tree decl
= maybe_dummy_object (TYPE_METHOD_BASETYPE (fntype
), 0);
114 expr
= build (OFFSET_REF
, fntype
, decl
, expr
);
117 if (TREE_CODE (expr
) == OFFSET_REF
118 && TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
)
119 expr
= resolve_offset_ref (expr
);
120 if (TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
)
121 expr
= build_addr_func (expr
);
122 if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
124 if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr
))) == METHOD_TYPE
)
125 if (pedantic
|| warn_pmf2ptr
)
126 pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr
),
128 return build1 (NOP_EXPR
, type
, expr
);
130 intype
= TREE_TYPE (expr
);
133 if (expr
== error_mark_node
)
134 return error_mark_node
;
136 form
= TREE_CODE (intype
);
138 if (POINTER_TYPE_P (intype
))
140 intype
= TYPE_MAIN_VARIANT (intype
);
142 if (TYPE_MAIN_VARIANT (type
) != intype
143 && TREE_CODE (type
) == POINTER_TYPE
144 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
145 && IS_AGGR_TYPE (TREE_TYPE (type
))
146 && IS_AGGR_TYPE (TREE_TYPE (intype
))
147 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
149 enum tree_code code
= PLUS_EXPR
;
152 /* Try derived to base conversion. */
153 binfo
= lookup_base (TREE_TYPE (intype
), TREE_TYPE (type
),
157 /* Try base to derived conversion. */
158 binfo
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
162 if (binfo
== error_mark_node
)
163 return error_mark_node
;
166 expr
= build_base_path (code
, expr
, binfo
, 0);
167 /* Add any qualifier conversions. */
168 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr
)),
171 expr
= build1 (NOP_EXPR
, type
, expr
);
172 TREE_CONSTANT (expr
) =
173 TREE_CONSTANT (TREE_OPERAND (expr
, 0));
179 if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (intype
))
184 enum tree_code code
= PLUS_EXPR
;
187 b1
= TYPE_OFFSET_BASETYPE (TREE_TYPE (type
));
188 b2
= TYPE_OFFSET_BASETYPE (TREE_TYPE (intype
));
189 binfo
= lookup_base (b1
, b2
, ba_check
, &bk
);
192 binfo
= lookup_base (b2
, b1
, ba_check
, &bk
);
195 if (binfo
== error_mark_node
)
196 return error_mark_node
;
198 if (bk
== bk_via_virtual
)
201 warning ("pointer to member cast from `%T' to `%T' is via virtual base",
202 TREE_TYPE (intype
), TREE_TYPE (type
));
205 error ("pointer to member cast from `%T' to `%T' is via virtual base",
206 TREE_TYPE (intype
), TREE_TYPE (type
));
207 return error_mark_node
;
209 /* This is a reinterpret cast, whose result is unspecified.
210 We choose to do nothing. */
211 return build1 (NOP_EXPR
, type
, expr
);
214 if (TREE_CODE (expr
) == PTRMEM_CST
)
215 expr
= cplus_expand_constant (expr
);
218 expr
= size_binop (code
, convert (sizetype
, expr
),
219 BINFO_OFFSET (binfo
));
221 else if (TYPE_PTRMEMFUNC_P (type
))
223 error ("cannot convert `%E' from type `%T' to type `%T'",
225 return error_mark_node
;
228 rval
= build1 (NOP_EXPR
, type
, expr
);
229 TREE_CONSTANT (rval
) = TREE_CONSTANT (expr
);
232 else if (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
))
233 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
, 0);
234 else if (TYPE_PTRMEMFUNC_P (intype
))
236 error ("cannot convert `%E' from type `%T' to type `%T'",
238 return error_mark_node
;
241 my_friendly_assert (form
!= OFFSET_TYPE
, 186);
243 if (integer_zerop (expr
))
245 if (TYPE_PTRMEMFUNC_P (type
))
246 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
, 0);
248 if (TYPE_PTRMEM_P (type
))
249 /* A NULL pointer-to-member is represented by -1, not by
251 expr
= build_int_2 (-1, -1);
253 expr
= build_int_2 (0, 0);
254 TREE_TYPE (expr
) = type
;
255 /* Fix up the representation of -1 if appropriate. */
256 force_fit_type (expr
, 0);
259 else if ((TYPE_PTRMEM_P (type
) || TYPE_PTRMEMFUNC_P (type
))
260 && INTEGRAL_CODE_P (form
))
262 error ("invalid conversion from '%T' to '%T'", intype
, type
);
263 return error_mark_node
;
266 if (INTEGRAL_CODE_P (form
))
268 if (TYPE_PRECISION (intype
) == POINTER_SIZE
)
269 return build1 (CONVERT_EXPR
, type
, expr
);
270 expr
= cp_convert (c_common_type_for_size (POINTER_SIZE
, 0), expr
);
271 /* Modes may be different but sizes should be the same. */
272 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr
)))
273 != GET_MODE_SIZE (TYPE_MODE (type
)))
274 /* There is supposed to be some integral type
275 that is the same width as a pointer. */
277 return convert_to_pointer (type
, expr
);
280 if (type_unknown_p (expr
))
281 return instantiate_type (type
, expr
, tf_error
| tf_warning
);
283 error ("cannot convert `%E' from type `%T' to type `%T'",
285 return error_mark_node
;
288 /* Like convert, except permit conversions to take place which
289 are not normally allowed due to access restrictions
290 (such as conversion from sub-type to private super-type). */
293 convert_to_pointer_force (type
, expr
)
296 register tree intype
= TREE_TYPE (expr
);
297 register enum tree_code form
= TREE_CODE (intype
);
299 if (form
== POINTER_TYPE
)
301 intype
= TYPE_MAIN_VARIANT (intype
);
303 if (TYPE_MAIN_VARIANT (type
) != intype
304 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
305 && IS_AGGR_TYPE (TREE_TYPE (type
))
306 && IS_AGGR_TYPE (TREE_TYPE (intype
))
307 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
309 enum tree_code code
= PLUS_EXPR
;
312 binfo
= lookup_base (TREE_TYPE (intype
), TREE_TYPE (type
),
316 binfo
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
320 if (binfo
== error_mark_node
)
321 return error_mark_node
;
324 expr
= build_base_path (code
, expr
, binfo
, 0);
325 /* Add any qualifier conversions. */
326 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr
)),
329 expr
= build1 (NOP_EXPR
, type
, expr
);
330 TREE_CONSTANT (expr
) =
331 TREE_CONSTANT (TREE_OPERAND (expr
, 0));
339 return cp_convert_to_pointer (type
, expr
, 1);
342 /* We are passing something to a function which requires a reference.
343 The type we are interested in is in TYPE. The initial
344 value we have to begin with is in ARG.
346 FLAGS controls how we manage access checking.
347 DIRECT_BIND in FLAGS controls how any temporaries are generated.
348 If DIRECT_BIND is set, DECL is the reference we're binding to. */
351 build_up_reference (type
, arg
, flags
, decl
)
352 tree type
, arg
, decl
;
356 tree argtype
= TREE_TYPE (arg
);
357 tree target_type
= TREE_TYPE (type
);
358 tree stmt_expr
= NULL_TREE
;
360 my_friendly_assert (TREE_CODE (type
) == REFERENCE_TYPE
, 187);
362 if ((flags
& DIRECT_BIND
) && ! real_lvalue_p (arg
))
364 /* Create a new temporary variable. We can't just use a TARGET_EXPR
365 here because it needs to live as long as DECL. */
368 arg
= build_decl (VAR_DECL
, NULL_TREE
, argtype
);
369 DECL_ARTIFICIAL (arg
) = 1;
371 TREE_STATIC (arg
) = TREE_STATIC (decl
);
373 if (TREE_STATIC (decl
))
375 /* Namespace-scope or local static; give it a mangled name. */
376 tree name
= mangle_ref_init_variable (decl
);
377 DECL_NAME (arg
) = name
;
378 SET_DECL_ASSEMBLER_NAME (arg
, name
);
379 arg
= pushdecl_top_level (arg
);
383 /* Automatic; make sure we handle the cleanup properly. */
384 maybe_push_cleanup_level (argtype
);
385 arg
= pushdecl (arg
);
388 /* Process the initializer for the declaration. */
389 DECL_INITIAL (arg
) = targ
;
390 cp_finish_decl (arg
, targ
, NULL_TREE
,
391 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
393 else if (!(flags
& DIRECT_BIND
) && ! lvalue_p (arg
))
394 return get_target_expr (arg
);
396 /* If we had a way to wrap this up, and say, if we ever needed its
397 address, transform all occurrences of the register, into a memory
398 reference we could win better. */
399 rval
= build_unary_op (ADDR_EXPR
, arg
, 1);
400 if (rval
== error_mark_node
)
401 return error_mark_node
;
403 if ((flags
& LOOKUP_PROTECT
)
404 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
405 && IS_AGGR_TYPE (argtype
)
406 && IS_AGGR_TYPE (target_type
))
408 /* We go through lookup_base for the access control. */
409 tree binfo
= lookup_base (argtype
, target_type
, ba_check
, NULL
);
410 if (binfo
== error_mark_node
)
411 return error_mark_node
;
412 if (binfo
== NULL_TREE
)
413 return error_not_base_type (target_type
, argtype
);
414 rval
= build_base_path (PLUS_EXPR
, rval
, binfo
, 1);
418 = convert_to_pointer_force (build_pointer_type (target_type
), rval
);
419 rval
= build1 (NOP_EXPR
, type
, rval
);
420 TREE_CONSTANT (rval
) = TREE_CONSTANT (TREE_OPERAND (rval
, 0));
422 /* If we created and initialized a new temporary variable, add the
423 representation of that initialization to the RVAL. */
425 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), stmt_expr
, rval
);
427 /* And return the result. */
431 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
432 INTYPE is the original rvalue type and DECL is an optional _DECL node
435 [dcl.init.ref] says that if an rvalue is used to
436 initialize a reference, then the reference must be to a
437 non-volatile const type. */
440 warn_ref_binding (reftype
, intype
, decl
)
441 tree reftype
, intype
, decl
;
443 tree ttl
= TREE_TYPE (reftype
);
445 if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl
))
449 if (CP_TYPE_VOLATILE_P (ttl
) && decl
)
450 msg
= "initialization of volatile reference type `%#T' from rvalue of type `%T'";
451 else if (CP_TYPE_VOLATILE_P (ttl
))
452 msg
= "conversion to volatile reference type `%#T' from rvalue of type `%T'";
454 msg
= "initialization of non-const reference type `%#T' from rvalue of type `%T'";
456 msg
= "conversion to non-const reference type `%#T' from rvalue of type `%T'";
458 pedwarn (msg
, reftype
, intype
);
462 /* For C++: Only need to do one-level references, but cannot
463 get tripped up on signed/unsigned differences.
465 DECL is either NULL_TREE or the _DECL node for a reference that is being
466 initialized. It can be error_mark_node if we don't know the _DECL but
467 we know it's an initialization. */
470 convert_to_reference (reftype
, expr
, convtype
, flags
, decl
)
475 register tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
476 register tree intype
;
477 tree rval
= NULL_TREE
;
478 tree rval_as_conversion
= NULL_TREE
;
481 if (TREE_CODE (type
) == FUNCTION_TYPE
482 && TREE_TYPE (expr
) == unknown_type_node
)
484 expr
= instantiate_type (type
, expr
,
485 (flags
& LOOKUP_COMPLAIN
)
486 ? tf_error
| tf_warning
: tf_none
);
487 if (expr
== error_mark_node
)
488 return error_mark_node
;
490 intype
= TREE_TYPE (expr
);
494 expr
= convert_from_reference (expr
);
495 intype
= TREE_TYPE (expr
);
498 my_friendly_assert (TREE_CODE (intype
) != REFERENCE_TYPE
, 364);
500 intype
= TYPE_MAIN_VARIANT (intype
);
502 i
= comp_target_types (type
, intype
, 0);
504 if (i
<= 0 && (convtype
& CONV_IMPLICIT
) && IS_AGGR_TYPE (intype
)
505 && ! (flags
& LOOKUP_NO_CONVERSION
))
507 /* Look for a user-defined conversion to lvalue that we can use. */
510 = build_type_conversion (reftype
, expr
, 1);
512 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
513 && real_lvalue_p (rval_as_conversion
))
515 expr
= rval_as_conversion
;
516 rval_as_conversion
= NULL_TREE
;
522 if (((convtype
& CONV_STATIC
) && i
== -1)
523 || ((convtype
& CONV_IMPLICIT
) && i
== 1))
525 if (flags
& LOOKUP_COMPLAIN
)
527 tree ttl
= TREE_TYPE (reftype
);
528 tree ttr
= lvalue_type (expr
);
530 if (! real_lvalue_p (expr
))
531 warn_ref_binding (reftype
, intype
, decl
);
533 if (! (convtype
& CONV_CONST
)
534 && !at_least_as_qualified_p (ttl
, ttr
))
535 pedwarn ("conversion from `%T' to `%T' discards qualifiers",
539 return build_up_reference (reftype
, expr
, flags
, decl
);
541 else if ((convtype
& CONV_REINTERPRET
) && lvalue_p (expr
))
543 /* When casting an lvalue to a reference type, just convert into
544 a pointer to the new type and deference it. This is allowed
545 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
546 should be done directly (jason). (int &)ri ---> *(int*)&ri */
548 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
550 if (TREE_CODE (intype
) == POINTER_TYPE
551 && (comptypes (TREE_TYPE (intype
), type
,
552 COMPARE_BASE
| COMPARE_RELAXED
)))
553 warning ("casting `%T' to `%T' does not dereference pointer",
556 rval
= build_unary_op (ADDR_EXPR
, expr
, 0);
557 if (rval
!= error_mark_node
)
558 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)),
560 if (rval
!= error_mark_node
)
561 rval
= build1 (NOP_EXPR
, reftype
, rval
);
565 rval
= convert_for_initialization (NULL_TREE
, type
, expr
, flags
,
567 if (rval
== NULL_TREE
|| rval
== error_mark_node
)
569 warn_ref_binding (reftype
, intype
, decl
);
570 rval
= build_up_reference (reftype
, rval
, flags
, decl
);
575 /* If we found a way to convert earlier, then use it. */
579 my_friendly_assert (TREE_CODE (intype
) != OFFSET_TYPE
, 189);
581 if (flags
& LOOKUP_COMPLAIN
)
582 error ("cannot convert type `%T' to type `%T'", intype
, reftype
);
584 if (flags
& LOOKUP_SPECULATIVELY
)
587 return error_mark_node
;
590 /* We are using a reference VAL for its value. Bash that reference all the
591 way down to its lowest form. */
594 convert_from_reference (val
)
597 tree type
= TREE_TYPE (val
);
599 if (TREE_CODE (type
) == OFFSET_TYPE
)
600 type
= TREE_TYPE (type
);
601 if (TREE_CODE (type
) == REFERENCE_TYPE
)
602 return build_indirect_ref (val
, NULL
);
606 /* Implicitly convert the lvalue EXPR to another lvalue of type TOTYPE,
607 preserving cv-qualification. */
610 convert_lvalue (totype
, expr
)
613 totype
= cp_build_qualified_type (totype
, TYPE_QUALS (TREE_TYPE (expr
)));
614 totype
= build_reference_type (totype
);
615 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
, LOOKUP_NORMAL
,
617 return convert_from_reference (expr
);
620 /* C++ conversions, preference to static cast conversions. */
623 cp_convert (type
, expr
)
626 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
);
631 FLAGS indicates how we should behave. */
634 ocp_convert (type
, expr
, convtype
, flags
)
638 register tree e
= expr
;
639 register enum tree_code code
= TREE_CODE (type
);
641 if (e
== error_mark_node
642 || TREE_TYPE (e
) == error_mark_node
)
643 return error_mark_node
;
645 complete_type (type
);
646 complete_type (TREE_TYPE (expr
));
648 e
= decl_constant_value (e
);
650 if (IS_AGGR_TYPE (type
) && (convtype
& CONV_FORCE_TEMP
)
651 /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
652 don't go through finish_struct, so they don't have the synthesized
653 constructors. So don't force a temporary. */
654 && TYPE_HAS_CONSTRUCTOR (type
))
655 /* We need a new temporary; don't take this shortcut. */;
656 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (e
)))
658 if (same_type_p (type
, TREE_TYPE (e
)))
659 /* The call to fold will not always remove the NOP_EXPR as
660 might be expected, since if one of the types is a typedef;
661 the comparsion in fold is just equality of pointers, not a
662 call to comptypes. We don't call fold in this case because
663 that can result in infinite recursion; fold will call
664 convert, which will call ocp_convert, etc. */
666 /* For complex data types, we need to perform componentwise
668 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
669 return fold (convert_to_complex (type
, e
));
671 return fold (build1 (NOP_EXPR
, type
, e
));
674 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
676 e
= convert_to_void (e
, /*implicit=*/NULL
);
680 /* Just convert to the type of the member. */
681 if (code
== OFFSET_TYPE
)
683 type
= TREE_TYPE (type
);
684 code
= TREE_CODE (type
);
687 if (TREE_CODE (e
) == OFFSET_REF
)
688 e
= resolve_offset_ref (e
);
690 if (INTEGRAL_CODE_P (code
))
692 tree intype
= TREE_TYPE (e
);
693 /* enum = enum, enum = int, enum = float, (enum)pointer are all
695 if (TREE_CODE (type
) == ENUMERAL_TYPE
696 && ((ARITHMETIC_TYPE_P (intype
) && ! (convtype
& CONV_STATIC
))
697 || (TREE_CODE (intype
) == POINTER_TYPE
)))
699 pedwarn ("conversion from `%#T' to `%#T'", intype
, type
);
701 if (flag_pedantic_errors
)
702 return error_mark_node
;
704 if (IS_AGGR_TYPE (intype
))
707 rval
= build_type_conversion (type
, e
, 1);
710 if (flags
& LOOKUP_COMPLAIN
)
711 error ("`%#T' used where a `%T' was expected", intype
, type
);
712 if (flags
& LOOKUP_SPECULATIVELY
)
714 return error_mark_node
;
716 if (code
== BOOLEAN_TYPE
)
720 /* Common Ada/Pascal programmer's mistake. We always warn
721 about this since it is so bad. */
722 if (TREE_CODE (expr
) == FUNCTION_DECL
)
724 else if (TREE_CODE (expr
) == ADDR_EXPR
725 && TREE_CODE (TREE_OPERAND (expr
, 0)) == FUNCTION_DECL
)
726 fn
= TREE_OPERAND (expr
, 0);
727 if (fn
&& !DECL_WEAK (fn
))
728 warning ("the address of `%D', will always be `true'", fn
);
729 return cp_truthvalue_conversion (e
);
731 return fold (convert_to_integer (type
, e
));
733 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
734 || TYPE_PTRMEMFUNC_P (type
))
735 return fold (cp_convert_to_pointer (type
, e
, 0));
736 if (code
== VECTOR_TYPE
)
737 return fold (convert_to_vector (type
, e
));
738 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
740 if (IS_AGGR_TYPE (TREE_TYPE (e
)))
743 rval
= build_type_conversion (type
, e
, 1);
747 if (flags
& LOOKUP_COMPLAIN
)
748 error ("`%#T' used where a floating point value was expected",
751 if (code
== REAL_TYPE
)
752 return fold (convert_to_real (type
, e
));
753 else if (code
== COMPLEX_TYPE
)
754 return fold (convert_to_complex (type
, e
));
757 /* New C++ semantics: since assignment is now based on
758 memberwise copying, if the rhs type is derived from the
759 lhs type, then we may still do a conversion. */
760 if (IS_AGGR_TYPE_CODE (code
))
762 tree dtype
= TREE_TYPE (e
);
763 tree ctor
= NULL_TREE
;
765 dtype
= TYPE_MAIN_VARIANT (dtype
);
767 /* Conversion between aggregate types. New C++ semantics allow
768 objects of derived type to be cast to objects of base type.
769 Old semantics only allowed this between pointers.
771 There may be some ambiguity between using a constructor
772 vs. using a type conversion operator when both apply. */
776 if (abstract_virtuals_error (NULL_TREE
, type
))
777 return error_mark_node
;
779 if ((flags
& LOOKUP_ONLYCONVERTING
)
780 && ! (IS_AGGR_TYPE (dtype
) && DERIVED_FROM_P (type
, dtype
)))
781 /* For copy-initialization, first we create a temp of the proper type
782 with a user-defined conversion sequence, then we direct-initialize
783 the target with the temp (see [dcl.init]). */
784 ctor
= build_user_type_conversion (type
, ctor
, flags
);
786 ctor
= build_special_member_call (NULL_TREE
,
787 complete_ctor_identifier
,
788 build_tree_list (NULL_TREE
, ctor
),
789 TYPE_BINFO (type
), flags
);
791 return build_cplus_new (type
, ctor
);
794 if (flags
& LOOKUP_COMPLAIN
)
795 error ("conversion from `%T' to non-scalar type `%T' requested",
796 TREE_TYPE (expr
), type
);
797 if (flags
& LOOKUP_SPECULATIVELY
)
799 return error_mark_node
;
802 /* When an expression is used in a void context, its value is discarded and
803 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
804 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
805 in a void context. The C++ standard does not define what an `access' to an
806 object is, but there is reason to beleive that it is the lvalue to rvalue
807 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
808 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
809 indicates that volatile semantics should be the same between C and C++
810 where ever possible. C leaves it implementation defined as to what
811 constitutes an access to a volatile. So, we interpret `*vp' as a read of
812 the volatile object `vp' points to, unless that is an incomplete type. For
813 volatile references we do not do this interpretation, because that would
814 make it impossible to ignore the reference return value from functions. We
815 issue warnings in the confusing cases.
817 IMPLICIT is tells us the context of an implicit void conversion. */
820 convert_to_void (expr
, implicit
)
822 const char *implicit
;
824 if (expr
== error_mark_node
825 || TREE_TYPE (expr
) == error_mark_node
)
826 return error_mark_node
;
827 if (!TREE_TYPE (expr
))
829 if (VOID_TYPE_P (TREE_TYPE (expr
)))
831 switch (TREE_CODE (expr
))
835 /* The two parts of a cond expr might be separate lvalues. */
836 tree op1
= TREE_OPERAND (expr
,1);
837 tree op2
= TREE_OPERAND (expr
,2);
838 tree new_op1
= convert_to_void (op1
, implicit
);
839 tree new_op2
= convert_to_void (op2
, implicit
);
841 expr
= build (COND_EXPR
, TREE_TYPE (new_op1
),
842 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
848 /* The second part of a compound expr contains the value. */
849 tree op1
= TREE_OPERAND (expr
,1);
850 tree new_op1
= convert_to_void (op1
, implicit
);
854 tree t
= build (COMPOUND_EXPR
, TREE_TYPE (new_op1
),
855 TREE_OPERAND (expr
, 0), new_op1
);
856 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (expr
);
857 TREE_NO_UNUSED_WARNING (t
) = TREE_NO_UNUSED_WARNING (expr
);
864 case NON_LVALUE_EXPR
:
866 /* These have already decayed to rvalue. */
869 case CALL_EXPR
: /* we have a special meaning for volatile void fn() */
874 tree type
= TREE_TYPE (expr
);
875 int is_reference
= TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))
877 int is_volatile
= TYPE_VOLATILE (type
);
878 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
880 if (is_volatile
&& !is_complete
)
881 warning ("object of incomplete type `%T' will not be accessed in %s",
882 type
, implicit
? implicit
: "void context");
883 else if (is_reference
&& is_volatile
)
884 warning ("object of type `%T' will not be accessed in %s",
885 TREE_TYPE (TREE_OPERAND (expr
, 0)),
886 implicit
? implicit
: "void context");
887 if (is_reference
|| !is_volatile
|| !is_complete
)
888 expr
= TREE_OPERAND (expr
, 0);
895 /* External variables might be incomplete. */
896 tree type
= TREE_TYPE (expr
);
897 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
899 if (TYPE_VOLATILE (type
) && !is_complete
)
900 warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
901 expr
, type
, implicit
? implicit
: "void context");
906 expr
= resolve_offset_ref (expr
);
914 if (TREE_CODE (probe
) == ADDR_EXPR
)
915 probe
= TREE_OPERAND (expr
, 0);
916 if (type_unknown_p (probe
))
918 /* [over.over] enumerates the places where we can take the address
919 of an overloaded function, and this is not one of them. */
920 pedwarn ("%s cannot resolve address of overloaded function",
921 implicit
? implicit
: "void cast");
923 else if (implicit
&& probe
== expr
&& is_overloaded_fn (probe
))
924 /* Only warn when there is no &. */
925 warning ("%s is a reference, not call, to function `%E'",
929 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
931 /* FIXME: This is where we should check for expressions with no
932 effects. At the moment we do that in both build_x_component_expr
933 and expand_expr_stmt -- inconsistently too. For the moment
934 leave implicit void conversions unadorned so that expand_expr_stmt
935 has a chance of detecting some of the cases. */
937 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
942 /* Create an expression whose value is that of EXPR,
943 converted to type TYPE. The TREE_TYPE of the value
944 is always TYPE. This function implements all reasonable
945 conversions; callers should filter out those that are
946 not permitted by the language being compiled.
948 Most of this routine is from build_reinterpret_cast.
950 The backend cannot call cp_convert (what was convert) because
951 conversions to/from basetypes may involve memory references
952 (vbases) and adding or subtracting small values (multiple
953 inheritance), but it calls convert from the constant folding code
954 on subtrees of already built trees after it has ripped them apart.
956 Also, if we ever support range variables, we'll probably also have to
957 do a little bit more work. */
965 if (type
== error_mark_node
|| expr
== error_mark_node
)
966 return error_mark_node
;
968 intype
= TREE_TYPE (expr
);
970 if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (intype
))
972 expr
= decl_constant_value (expr
);
973 return fold (build1 (NOP_EXPR
, type
, expr
));
976 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
,
977 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
);
980 /* Like cp_convert, except permit conversions to take place which
981 are not normally allowed due to access restrictions
982 (such as conversion from sub-type to private super-type). */
985 convert_force (type
, expr
, convtype
)
990 register tree e
= expr
;
991 register enum tree_code code
= TREE_CODE (type
);
993 if (code
== REFERENCE_TYPE
)
994 return fold (convert_to_reference (type
, e
, CONV_C_CAST
, LOOKUP_COMPLAIN
,
996 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
997 e
= convert_from_reference (e
);
999 if (code
== POINTER_TYPE
)
1000 return fold (convert_to_pointer_force (type
, e
));
1002 /* From typeck.c convert_for_assignment */
1003 if (((TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
&& TREE_CODE (e
) == ADDR_EXPR
1004 && TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
1005 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1006 || integer_zerop (e
)
1007 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1008 && TYPE_PTRMEMFUNC_P (type
))
1010 /* compatible pointer to member functions. */
1011 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1);
1014 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
);
1017 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1018 exists, return the attempted conversion. This may
1019 return ERROR_MARK_NODE if the conversion is not
1020 allowed (references private members, etc).
1021 If no conversion exists, NULL_TREE is returned.
1023 If (FOR_SURE & 1) is nonzero, then we allow this type conversion
1024 to take place immediately. Otherwise, we build a SAVE_EXPR
1025 which can be evaluated if the results are ever needed.
1027 Changes to this functions should be mirrored in user_harshness.
1029 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1030 object parameter, or by the second standard conversion sequence if
1031 that doesn't do it. This will probably wait for an overloading rewrite.
1035 build_type_conversion (xtype
, expr
, for_sure
)
1039 /* C++: check to see if we can convert this aggregate type
1040 into the required type. */
1041 return build_user_type_conversion
1042 (xtype
, expr
, for_sure
? LOOKUP_NORMAL
: 0);
1045 /* Convert the given EXPR to one of a group of types suitable for use in an
1046 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1047 which indicates which types are suitable. If COMPLAIN is 1, complain
1048 about ambiguity; otherwise, the caller will deal with it. */
1051 build_expr_type_conversion (desires
, expr
, complain
)
1056 tree basetype
= TREE_TYPE (expr
);
1057 tree conv
= NULL_TREE
;
1058 tree winner
= NULL_TREE
;
1060 if (expr
== null_node
1061 && (desires
& WANT_INT
)
1062 && !(desires
& WANT_NULL
))
1063 warning ("converting NULL to non-pointer type");
1065 if (TREE_CODE (expr
) == OFFSET_REF
)
1066 expr
= resolve_offset_ref (expr
);
1067 expr
= convert_from_reference (expr
);
1068 basetype
= TREE_TYPE (expr
);
1070 if (basetype
== error_mark_node
)
1071 return error_mark_node
;
1073 if (! IS_AGGR_TYPE (basetype
))
1074 switch (TREE_CODE (basetype
))
1077 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1079 /* else fall through... */
1082 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1084 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1086 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1088 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1092 return (desires
& WANT_POINTER
) ? default_conversion (expr
)
1098 /* The code for conversions from class type is currently only used for
1099 delete expressions. Other expressions are handled by build_new_op. */
1101 if (! TYPE_HAS_CONVERSION (basetype
))
1104 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1108 tree cand
= TREE_VALUE (conv
);
1110 if (winner
&& winner
== cand
)
1113 candidate
= TREE_TYPE (TREE_TYPE (cand
));
1114 if (TREE_CODE (candidate
) == REFERENCE_TYPE
)
1115 candidate
= TREE_TYPE (candidate
);
1117 switch (TREE_CODE (candidate
))
1121 win
= (desires
& WANT_INT
); break;
1123 win
= (desires
& WANT_ENUM
); break;
1125 win
= (desires
& WANT_FLOAT
); break;
1127 win
= (desires
& WANT_POINTER
); break;
1139 error ("ambiguous default type conversion from `%T'",
1141 error (" candidate conversions include `%D' and `%D'",
1144 return error_mark_node
;
1153 tree type
= TREE_TYPE (TREE_TYPE (winner
));
1154 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1155 type
= TREE_TYPE (type
);
1156 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
);
1162 /* Implements integral promotion (4.1) and float->double promotion. */
1165 type_promotes_to (type
)
1170 if (type
== error_mark_node
)
1171 return error_mark_node
;
1173 type_quals
= cp_type_quals (type
);
1174 type
= TYPE_MAIN_VARIANT (type
);
1176 /* bool always promotes to int (not unsigned), even if it's the same
1178 if (type
== boolean_type_node
)
1179 type
= integer_type_node
;
1181 /* Normally convert enums to int, but convert wide enums to something
1183 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1184 || type
== wchar_type_node
)
1186 int precision
= MAX (TYPE_PRECISION (type
),
1187 TYPE_PRECISION (integer_type_node
));
1188 tree totype
= c_common_type_for_size (precision
, 0);
1189 if (TREE_UNSIGNED (type
)
1190 && ! int_fits_type_p (TYPE_MAX_VALUE (type
), totype
))
1191 type
= c_common_type_for_size (precision
, 1);
1195 else if (c_promoting_integer_type_p (type
))
1197 /* Retain unsignedness if really not getting bigger. */
1198 if (TREE_UNSIGNED (type
)
1199 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1200 type
= unsigned_type_node
;
1202 type
= integer_type_node
;
1204 else if (type
== float_type_node
)
1205 type
= double_type_node
;
1207 return cp_build_qualified_type (type
, type_quals
);
1210 /* The routines below this point are carefully written to conform to
1211 the standard. They use the same terminology, and follow the rules
1212 closely. Although they are used only in pt.c at the moment, they
1213 should presumably be used everywhere in the future. */
1215 /* Attempt to perform qualification conversions on EXPR to convert it
1216 to TYPE. Return the resulting expression, or error_mark_node if
1217 the conversion was impossible. */
1220 perform_qualification_conversions (type
, expr
)
1224 if (TREE_CODE (type
) == POINTER_TYPE
1225 && TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
1226 && comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (TREE_TYPE (expr
))))
1227 return build1 (NOP_EXPR
, type
, expr
);
1229 return error_mark_node
;