1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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));
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 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 cp_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 cp_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 cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
128 return build1 (NOP_EXPR, type, expr);
130 intype = TREE_TYPE (expr);
133 form = TREE_CODE (intype);
135 if (POINTER_TYPE_P (intype))
137 intype = TYPE_MAIN_VARIANT (intype);
139 if (TYPE_MAIN_VARIANT (type) != intype
140 && TREE_CODE (type) == POINTER_TYPE
141 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
142 && IS_AGGR_TYPE (TREE_TYPE (type))
143 && IS_AGGR_TYPE (TREE_TYPE (intype))
144 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
145 /* If EXPR is NULL, then we don't need to do any arithmetic
150 The null pointer value is converted to the null pointer
151 value of the destination type. */
152 && !integer_zerop (expr))
154 enum tree_code code = PLUS_EXPR;
155 tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
156 if (binfo == error_mark_node)
157 return error_mark_node;
158 if (binfo == NULL_TREE)
160 binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
161 if (binfo == error_mark_node)
162 return error_mark_node;
167 if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
168 || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
169 || ! BINFO_OFFSET_ZEROP (binfo))
171 /* Need to get the path we took. */
174 if (code == PLUS_EXPR)
175 get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
178 get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
180 return build_vbase_path (code, type, expr, path, 0);
185 if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
193 b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
194 b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
195 binfo = get_binfo (b2, b1, 1);
197 if (binfo == NULL_TREE)
199 binfo = get_binfo (b1, b2, 1);
205 if (binfo == error_mark_node)
206 return error_mark_node;
208 virt_binfo = binfo_from_vbase (binfo);
212 cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
213 BINFO_TYPE (virt_binfo),
214 BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
217 cp_error ("pointer to member cast via virtual base `%T' of `%T'",
218 BINFO_TYPE (virt_binfo),
219 BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
220 return error_mark_node;
222 /* This is a reinterpret cast, whose result is unspecified.
223 We choose to do nothing. */
224 return build1 (NOP_EXPR, type, expr);
227 if (TREE_CODE (expr) == PTRMEM_CST)
228 expr = cplus_expand_constant (expr);
231 expr = size_binop (code, convert (sizetype, expr),
232 BINFO_OFFSET (binfo));
234 else if (TYPE_PTRMEMFUNC_P (type))
236 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
238 return error_mark_node;
241 rval = build1 (NOP_EXPR, type, expr);
242 TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
245 else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
246 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
247 else if (TYPE_PTRMEMFUNC_P (intype))
249 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
251 return error_mark_node;
254 my_friendly_assert (form != OFFSET_TYPE, 186);
256 if (integer_zerop (expr))
258 if (TYPE_PTRMEMFUNC_P (type))
259 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
261 if (flag_new_abi && TYPE_PTRMEM_P (type))
262 /* Under the new ABI, a NULL pointer-to-member is represented
263 by -1, not by zero. */
264 expr = build_int_2 (-1, -1);
266 expr = build_int_2 (0, 0);
267 TREE_TYPE (expr) = type;
271 if (INTEGRAL_CODE_P (form))
273 if (TYPE_PRECISION (intype) == POINTER_SIZE)
274 return build1 (CONVERT_EXPR, type, expr);
275 expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr);
276 /* Modes may be different but sizes should be the same. */
277 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
278 != GET_MODE_SIZE (TYPE_MODE (type)))
279 /* There is supposed to be some integral type
280 that is the same width as a pointer. */
282 return convert_to_pointer (type, expr);
285 if (type_unknown_p (expr))
286 return instantiate_type (type, expr, itf_complain);
288 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
290 return error_mark_node;
293 /* Like convert, except permit conversions to take place which
294 are not normally allowed due to access restrictions
295 (such as conversion from sub-type to private super-type). */
298 convert_to_pointer_force (type, expr)
301 register tree intype = TREE_TYPE (expr);
302 register enum tree_code form = TREE_CODE (intype);
304 if (integer_zerop (expr))
306 expr = build_int_2 (0, 0);
307 TREE_TYPE (expr) = type;
311 if (form == POINTER_TYPE)
313 intype = TYPE_MAIN_VARIANT (intype);
315 if (TYPE_MAIN_VARIANT (type) != intype
316 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
317 && IS_AGGR_TYPE (TREE_TYPE (type))
318 && IS_AGGR_TYPE (TREE_TYPE (intype))
319 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
321 enum tree_code code = PLUS_EXPR;
323 int distance = get_base_distance (TREE_TYPE (type),
324 TREE_TYPE (intype), 0, &path);
327 cp_error ("type `%T' is ambiguous base of `%T'",
330 return error_mark_node;
334 distance = get_base_distance (TREE_TYPE (intype),
335 TREE_TYPE (type), 0, &path);
338 cp_error ("type `%T' is ambiguous base of `%T'",
341 return error_mark_node;
344 /* Doesn't need any special help from us. */
345 return build1 (NOP_EXPR, type, expr);
349 return build_vbase_path (code, type, expr, path, 0);
353 return cp_convert_to_pointer (type, expr, 1);
356 /* We are passing something to a function which requires a reference.
357 The type we are interested in is in TYPE. The initial
358 value we have to begin with is in ARG.
360 FLAGS controls how we manage access checking.
361 DIRECT_BIND in FLAGS controls how any temporaries are generated. */
364 build_up_reference (type, arg, flags)
369 tree argtype = TREE_TYPE (arg);
370 tree target_type = TREE_TYPE (type);
371 tree stmt_expr = NULL_TREE;
373 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
375 if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
377 /* Create a new temporary variable. */
379 if (toplevel_bindings_p ())
380 arg = get_temp_name (argtype);
383 arg = pushdecl (build_decl (VAR_DECL, NULL_TREE, argtype));
384 DECL_ARTIFICIAL (arg) = 1;
387 /* Process the initializer for the declaration. */
388 DECL_INITIAL (arg) = targ;
389 cp_finish_decl (arg, targ, NULL_TREE,
390 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
392 else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
393 return get_target_expr (arg);
395 /* If we had a way to wrap this up, and say, if we ever needed it's
396 address, transform all occurrences of the register, into a memory
397 reference we could win better. */
398 rval = build_unary_op (ADDR_EXPR, arg, 1);
399 if (rval == error_mark_node)
400 return error_mark_node;
402 if ((flags & LOOKUP_PROTECT)
403 && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
404 && IS_AGGR_TYPE (argtype)
405 && IS_AGGR_TYPE (target_type))
407 /* We go through get_binfo for the access control. */
408 tree binfo = get_binfo (target_type, argtype, 1);
409 if (binfo == error_mark_node)
410 return error_mark_node;
411 if (binfo == NULL_TREE)
412 return error_not_base_type (target_type, argtype);
413 rval = convert_pointer_to_real (binfo, rval);
417 = convert_to_pointer_force (build_pointer_type (target_type), rval);
418 rval = build1 (NOP_EXPR, type, rval);
419 TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
421 /* If we created and initialized a new temporary variable, add the
422 representation of that initialization to the RVAL. */
424 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), stmt_expr, rval);
426 /* And return the result. */
430 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
431 INTYPE is the original rvalue type and DECL is an optional _DECL node
434 [dcl.init.ref] says that if an rvalue is used to
435 initialize a reference, then the reference must be to a
436 non-volatile const type. */
439 warn_ref_binding (reftype, intype, decl)
440 tree reftype, intype, decl;
442 tree ttl = TREE_TYPE (reftype);
444 if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl))
448 if (CP_TYPE_VOLATILE_P (ttl) && decl)
449 msg = "initialization of volatile reference type `%#T' from rvalue of type `%T'";
450 else if (CP_TYPE_VOLATILE_P (ttl))
451 msg = "conversion to volatile reference type `%#T' from rvalue of type `%T'";
453 msg = "initialization of non-const reference type `%#T' from rvalue of type `%T'";
455 msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'";
457 cp_pedwarn (msg, reftype, intype);
461 /* For C++: Only need to do one-level references, but cannot
462 get tripped up on signed/unsigned differences.
464 DECL is either NULL_TREE or the _DECL node for a reference that is being
465 initialized. It can be error_mark_node if we don't know the _DECL but
466 we know it's an initialization. */
469 convert_to_reference (reftype, expr, convtype, flags, decl)
474 register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
475 register tree intype = TREE_TYPE (expr);
476 tree rval = NULL_TREE;
477 tree rval_as_conversion = NULL_TREE;
480 if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
482 expr = instantiate_type (type, expr,
483 (flags & LOOKUP_COMPLAIN)
484 ? itf_complain : itf_none);
485 if (expr == error_mark_node)
486 return error_mark_node;
488 intype = TREE_TYPE (expr);
491 if (TREE_CODE (intype) == REFERENCE_TYPE)
492 my_friendly_abort (364);
494 intype = TYPE_MAIN_VARIANT (intype);
496 i = comp_target_types (type, intype, 0);
498 if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
499 && ! (flags & LOOKUP_NO_CONVERSION))
501 /* Look for a user-defined conversion to lvalue that we can use. */
504 = build_type_conversion (reftype, expr, 1);
506 if (rval_as_conversion && rval_as_conversion != error_mark_node
507 && real_lvalue_p (rval_as_conversion))
509 expr = rval_as_conversion;
510 rval_as_conversion = NULL_TREE;
516 if (((convtype & CONV_STATIC) && i == -1)
517 || ((convtype & CONV_IMPLICIT) && i == 1))
519 if (flags & LOOKUP_COMPLAIN)
521 tree ttl = TREE_TYPE (reftype);
522 tree ttr = lvalue_type (expr);
524 if (! real_lvalue_p (expr))
525 warn_ref_binding (reftype, intype, decl);
527 if (! (convtype & CONV_CONST)
528 && !at_least_as_qualified_p (ttl, ttr))
529 cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
533 return build_up_reference (reftype, expr, flags);
535 else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
537 /* When casting an lvalue to a reference type, just convert into
538 a pointer to the new type and deference it. This is allowed
539 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
540 should be done directly (jason). (int &)ri ---> *(int*)&ri */
542 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
544 if (TREE_CODE (intype) == POINTER_TYPE
545 && (comptypes (TREE_TYPE (intype), type,
546 COMPARE_BASE | COMPARE_RELAXED )))
547 cp_warning ("casting `%T' to `%T' does not dereference pointer",
550 rval = build_unary_op (ADDR_EXPR, expr, 0);
551 if (rval != error_mark_node)
552 rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
554 if (rval != error_mark_node)
555 rval = build1 (NOP_EXPR, reftype, rval);
559 rval = convert_for_initialization (NULL_TREE, type, expr, flags,
561 if (rval == NULL_TREE || rval == error_mark_node)
563 warn_ref_binding (reftype, intype, decl);
564 rval = build_up_reference (reftype, rval, flags);
569 /* If we found a way to convert earlier, then use it. */
573 my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
575 if (flags & LOOKUP_COMPLAIN)
576 cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
578 if (flags & LOOKUP_SPECULATIVELY)
581 return error_mark_node;
584 /* We are using a reference VAL for its value. Bash that reference all the
585 way down to its lowest form. */
588 convert_from_reference (val)
591 tree type = TREE_TYPE (val);
593 if (TREE_CODE (type) == OFFSET_TYPE)
594 type = TREE_TYPE (type);
595 if (TREE_CODE (type) == REFERENCE_TYPE)
596 return build_indirect_ref (val, NULL_PTR);
600 /* Call this when we know (for any reason) that expr is not, in fact,
601 zero. This routine is like convert_pointer_to, but it pays
602 attention to which specific instance of what type we want to
603 convert to. This routine should eventually become
604 convert_to_pointer after all references to convert_to_pointer
608 convert_pointer_to_real (binfo, expr)
611 register tree intype = TREE_TYPE (expr);
615 if (intype == error_mark_node)
616 return error_mark_node;
618 if (TREE_CODE (binfo) == TREE_VEC)
619 type = BINFO_TYPE (binfo);
620 else if (IS_AGGR_TYPE (binfo))
630 ptr_type = cp_build_qualified_type (type,
631 CP_TYPE_QUALS (TREE_TYPE (intype)));
632 ptr_type = build_pointer_type (ptr_type);
633 if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
636 my_friendly_assert (!integer_zerop (expr), 191);
638 intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
639 if (TREE_CODE (type) == RECORD_TYPE
640 && TREE_CODE (intype) == RECORD_TYPE
645 = get_base_distance (binfo, intype, 0, &path);
647 /* This function shouldn't be called with unqualified arguments
648 but if it is, give them an error message that they can read. */
651 cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
655 cp_error ("because `%T' is an ambiguous base class", type);
656 return error_mark_node;
659 return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
661 rval = build1 (NOP_EXPR, ptr_type,
662 TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
663 TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
667 /* Call this when we know (for any reason) that expr is
668 not, in fact, zero. This routine gets a type out of the first
669 argument and uses it to search for the type to convert to. If there
670 is more than one instance of that type in the expr, the conversion is
671 ambiguous. This routine should eventually go away, and all
672 callers should use convert_to_pointer_real. */
675 convert_pointer_to (binfo, expr)
678 return convert_pointer_to_real (binfo, expr);
681 /* C++ conversions, preference to static cast conversions. */
684 cp_convert (type, expr)
687 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
692 FLAGS indicates how we should behave. */
695 ocp_convert (type, expr, convtype, flags)
699 register tree e = expr;
700 register enum tree_code code = TREE_CODE (type);
702 if (e == error_mark_node
703 || TREE_TYPE (e) == error_mark_node)
704 return error_mark_node;
706 complete_type (type);
707 complete_type (TREE_TYPE (expr));
709 e = decl_constant_value (e);
711 if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
712 /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
713 don't go through finish_struct, so they don't have the synthesized
714 constructors. So don't force a temporary. */
715 && TYPE_HAS_CONSTRUCTOR (type))
716 /* We need a new temporary; don't take this shortcut. */;
717 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
719 if (same_type_p (type, TREE_TYPE (e)))
720 /* The call to fold will not always remove the NOP_EXPR as
721 might be expected, since if one of the types is a typedef;
722 the comparsion in fold is just equality of pointers, not a
723 call to comptypes. We don't call fold in this case because
724 that can result in infinite recursion; fold will call
725 convert, which will call ocp_convert, etc. */
727 /* For complex data types, we need to perform componentwise
729 else if (TREE_CODE (type) == COMPLEX_TYPE)
730 return fold (convert_to_complex (type, e));
732 return fold (build1 (NOP_EXPR, type, e));
735 if (code == VOID_TYPE && (convtype & CONV_STATIC))
737 e = convert_to_void (e, /*implicit=*/NULL);
741 /* Just convert to the type of the member. */
742 if (code == OFFSET_TYPE)
744 type = TREE_TYPE (type);
745 code = TREE_CODE (type);
748 if (TREE_CODE (e) == OFFSET_REF)
749 e = resolve_offset_ref (e);
751 if (INTEGRAL_CODE_P (code))
753 tree intype = TREE_TYPE (e);
754 /* enum = enum, enum = int, enum = float, (enum)pointer are all
756 if (TREE_CODE (type) == ENUMERAL_TYPE
757 && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
758 || (TREE_CODE (intype) == POINTER_TYPE)))
760 cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
762 if (flag_pedantic_errors)
763 return error_mark_node;
765 if (IS_AGGR_TYPE (intype))
768 rval = build_type_conversion (type, e, 1);
771 if (flags & LOOKUP_COMPLAIN)
772 cp_error ("`%#T' used where a `%T' was expected", intype, type);
773 if (flags & LOOKUP_SPECULATIVELY)
775 return error_mark_node;
777 if (code == BOOLEAN_TYPE)
781 /* Common Ada/Pascal programmer's mistake. We always warn
782 about this since it is so bad. */
783 if (TREE_CODE (expr) == FUNCTION_DECL)
785 else if (TREE_CODE (expr) == ADDR_EXPR
786 && TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL)
787 fn = TREE_OPERAND (expr, 0);
789 cp_warning ("the address of `%D', will always be `true'", fn);
790 return cp_truthvalue_conversion (e);
792 return fold (convert_to_integer (type, e));
794 if (code == POINTER_TYPE || code == REFERENCE_TYPE
795 || TYPE_PTRMEMFUNC_P (type))
796 return fold (cp_convert_to_pointer (type, e, 0));
797 if (code == REAL_TYPE || code == COMPLEX_TYPE)
799 if (IS_AGGR_TYPE (TREE_TYPE (e)))
802 rval = build_type_conversion (type, e, 1);
806 if (flags & LOOKUP_COMPLAIN)
807 cp_error ("`%#T' used where a floating point value was expected",
810 if (code == REAL_TYPE)
811 return fold (convert_to_real (type, e));
812 else if (code == COMPLEX_TYPE)
813 return fold (convert_to_complex (type, e));
816 /* New C++ semantics: since assignment is now based on
817 memberwise copying, if the rhs type is derived from the
818 lhs type, then we may still do a conversion. */
819 if (IS_AGGR_TYPE_CODE (code))
821 tree dtype = TREE_TYPE (e);
822 tree ctor = NULL_TREE;
824 dtype = TYPE_MAIN_VARIANT (dtype);
826 /* Conversion between aggregate types. New C++ semantics allow
827 objects of derived type to be cast to objects of base type.
828 Old semantics only allowed this between pointers.
830 There may be some ambiguity between using a constructor
831 vs. using a type conversion operator when both apply. */
835 if (abstract_virtuals_error (NULL_TREE, type))
836 return error_mark_node;
838 if ((flags & LOOKUP_ONLYCONVERTING)
839 && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
840 /* For copy-initialization, first we create a temp of the proper type
841 with a user-defined conversion sequence, then we direct-initialize
842 the target with the temp (see [dcl.init]). */
843 ctor = build_user_type_conversion (type, ctor, flags);
845 ctor = build_method_call (NULL_TREE,
846 complete_ctor_identifier,
847 build_tree_list (NULL_TREE, ctor),
848 TYPE_BINFO (type), flags);
850 return build_cplus_new (type, ctor);
853 /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
854 then it won't be hashed and hence compare as not equal,
856 if (code == ARRAY_TYPE
857 && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
858 && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
861 if (flags & LOOKUP_COMPLAIN)
862 cp_error ("conversion from `%T' to non-scalar type `%T' requested",
863 TREE_TYPE (expr), type);
864 if (flags & LOOKUP_SPECULATIVELY)
866 return error_mark_node;
869 /* When an expression is used in a void context, its value is discarded and
870 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
871 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
872 in a void context. The C++ standard does not define what an `access' to an
873 object is, but there is reason to beleive that it is the lvalue to rvalue
874 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
875 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
876 indicates that volatile semantics should be the same between C and C++
877 where ever possible. C leaves it implementation defined as to what
878 constitutes an access to a volatile. So, we interpret `*vp' as a read of
879 the volatile object `vp' points to, unless that is an incomplete type. For
880 volatile references we do not do this interpretation, because that would
881 make it impossible to ignore the reference return value from functions. We
882 issue warnings in the confusing cases.
884 IMPLICIT is tells us the context of an implicit void conversion. */
887 convert_to_void (expr, implicit)
889 const char *implicit;
891 if (expr == error_mark_node
892 || TREE_TYPE (expr) == error_mark_node)
893 return error_mark_node;
894 if (!TREE_TYPE (expr))
896 if (VOID_TYPE_P (TREE_TYPE (expr)))
898 switch (TREE_CODE (expr))
902 /* The two parts of a cond expr might be separate lvalues. */
903 tree op1 = TREE_OPERAND (expr,1);
904 tree op2 = TREE_OPERAND (expr,2);
905 tree new_op1 = convert_to_void (op1, implicit);
906 tree new_op2 = convert_to_void (op2, implicit);
908 if (new_op1 != op1 || new_op2 != op2)
909 expr = build (COND_EXPR,
910 implicit ? TREE_TYPE (expr) : void_type_node,
911 TREE_OPERAND (expr, 0), new_op1, new_op2);
917 /* The second part of a compound expr contains the value. */
918 tree op1 = TREE_OPERAND (expr,1);
919 tree new_op1 = convert_to_void (op1, implicit);
922 expr = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
923 TREE_OPERAND (expr, 0), new_op1);
927 case NON_LVALUE_EXPR:
929 /* These have already decayed to rvalue. */
932 case CALL_EXPR: /* we have a special meaning for volatile void fn() */
937 tree type = TREE_TYPE (expr);
938 int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
940 int is_volatile = TYPE_VOLATILE (type);
941 int is_complete = COMPLETE_TYPE_P (complete_type (type));
943 if (is_volatile && !is_complete)
944 cp_warning ("object of incomplete type `%T' will not be accessed in %s",
945 type, implicit ? implicit : "void context");
946 else if (is_reference && is_volatile)
947 cp_warning ("object of type `%T' will not be accessed in %s",
948 TREE_TYPE (TREE_OPERAND (expr, 0)),
949 implicit ? implicit : "void context");
950 if (is_reference || !is_volatile || !is_complete)
951 expr = TREE_OPERAND (expr, 0);
958 /* External variables might be incomplete. */
959 tree type = TREE_TYPE (expr);
960 int is_complete = COMPLETE_TYPE_P (complete_type (type));
962 if (TYPE_VOLATILE (type) && !is_complete)
963 cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
964 expr, type, implicit ? implicit : "void context");
969 expr = resolve_offset_ref (expr);
977 if (TREE_CODE (probe) == ADDR_EXPR)
978 probe = TREE_OPERAND (expr, 0);
979 if (type_unknown_p (probe))
981 /* [over.over] enumerates the places where we can take the address
982 of an overloaded function, and this is not one of them. */
983 cp_pedwarn ("%s cannot resolve address of overloaded function",
984 implicit ? implicit : "void cast");
986 else if (implicit && probe == expr && is_overloaded_fn (probe))
987 /* Only warn when there is no &. */
988 cp_warning ("%s is a reference, not call, to function `%E'",
992 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
994 /* FIXME: This is where we should check for expressions with no
995 effects. At the moment we do that in both build_x_component_expr
996 and expand_expr_stmt -- inconsistently too. For the moment
997 leave implicit void conversions unadorned so that expand_expr_stmt
998 has a chance of detecting some of the cases. */
1000 expr = build1 (CONVERT_EXPR, void_type_node, expr);
1005 /* Create an expression whose value is that of EXPR,
1006 converted to type TYPE. The TREE_TYPE of the value
1007 is always TYPE. This function implements all reasonable
1008 conversions; callers should filter out those that are
1009 not permitted by the language being compiled.
1011 Most of this routine is from build_reinterpret_cast.
1013 The backend cannot call cp_convert (what was convert) because
1014 conversions to/from basetypes may involve memory references
1015 (vbases) and adding or subtracting small values (multiple
1016 inheritance), but it calls convert from the constant folding code
1017 on subtrees of already built trees after it has ripped them apart.
1019 Also, if we ever support range variables, we'll probably also have to
1020 do a little bit more work. */
1023 convert (type, expr)
1028 if (type == error_mark_node || expr == error_mark_node)
1029 return error_mark_node;
1031 intype = TREE_TYPE (expr);
1033 if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
1035 expr = decl_constant_value (expr);
1036 return fold (build1 (NOP_EXPR, type, expr));
1039 return ocp_convert (type, expr, CONV_OLD_CONVERT,
1040 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1043 /* Like cp_convert, except permit conversions to take place which
1044 are not normally allowed due to access restrictions
1045 (such as conversion from sub-type to private super-type). */
1048 convert_force (type, expr, convtype)
1053 register tree e = expr;
1054 register enum tree_code code = TREE_CODE (type);
1056 if (code == REFERENCE_TYPE)
1057 return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1059 else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1060 e = convert_from_reference (e);
1062 if (code == POINTER_TYPE)
1063 return fold (convert_to_pointer_force (type, e));
1065 /* From typeck.c convert_for_assignment */
1066 if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1067 && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1068 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1069 || integer_zerop (e)
1070 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1071 && TYPE_PTRMEMFUNC_P (type))
1073 /* compatible pointer to member functions. */
1074 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1077 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1080 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1081 exists, return the attempted conversion. This may
1082 return ERROR_MARK_NODE if the conversion is not
1083 allowed (references private members, etc).
1084 If no conversion exists, NULL_TREE is returned.
1086 If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1087 to take place immediately. Otherwise, we build a SAVE_EXPR
1088 which can be evaluated if the results are ever needed.
1090 Changes to this functions should be mirrored in user_harshness.
1092 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1093 object parameter, or by the second standard conversion sequence if
1094 that doesn't do it. This will probably wait for an overloading rewrite.
1098 build_type_conversion (xtype, expr, for_sure)
1102 /* C++: check to see if we can convert this aggregate type
1103 into the required type. */
1104 return build_user_type_conversion
1105 (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
1108 /* Convert the given EXPR to one of a group of types suitable for use in an
1109 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1110 which indicates which types are suitable. If COMPLAIN is 1, complain
1111 about ambiguity; otherwise, the caller will deal with it. */
1114 build_expr_type_conversion (desires, expr, complain)
1119 tree basetype = TREE_TYPE (expr);
1120 tree conv = NULL_TREE;
1121 tree winner = NULL_TREE;
1123 if (expr == null_node
1124 && (desires & WANT_INT)
1125 && !(desires & WANT_NULL))
1126 cp_warning ("converting NULL to non-pointer type");
1128 if (TREE_CODE (expr) == OFFSET_REF)
1129 expr = resolve_offset_ref (expr);
1130 expr = convert_from_reference (expr);
1131 basetype = TREE_TYPE (expr);
1133 if (basetype == error_mark_node)
1134 return error_mark_node;
1136 if (! IS_AGGR_TYPE (basetype))
1137 switch (TREE_CODE (basetype))
1140 if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1142 /* else fall through... */
1145 return (desires & WANT_INT) ? expr : NULL_TREE;
1147 return (desires & WANT_ENUM) ? expr : NULL_TREE;
1149 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1151 return (desires & WANT_POINTER) ? expr : NULL_TREE;
1155 return (desires & WANT_POINTER) ? default_conversion (expr)
1161 /* The code for conversions from class type is currently only used for
1162 delete expressions. Other expressions are handled by build_new_op. */
1164 if (! TYPE_HAS_CONVERSION (basetype))
1167 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1171 tree cand = TREE_VALUE (conv);
1173 if (winner && winner == cand)
1176 candidate = TREE_TYPE (TREE_TYPE (cand));
1177 if (TREE_CODE (candidate) == REFERENCE_TYPE)
1178 candidate = TREE_TYPE (candidate);
1180 switch (TREE_CODE (candidate))
1184 win = (desires & WANT_INT); break;
1186 win = (desires & WANT_ENUM); break;
1188 win = (desires & WANT_FLOAT); break;
1190 win = (desires & WANT_POINTER); break;
1202 cp_error ("ambiguous default type conversion from `%T'",
1204 cp_error (" candidate conversions include `%D' and `%D'",
1207 return error_mark_node;
1216 tree type = TREE_TYPE (TREE_TYPE (winner));
1217 if (TREE_CODE (type) == REFERENCE_TYPE)
1218 type = TREE_TYPE (type);
1219 return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1225 /* Implements integral promotion (4.1) and float->double promotion. */
1228 type_promotes_to (type)
1233 if (type == error_mark_node)
1234 return error_mark_node;
1236 type_quals = CP_TYPE_QUALS (type);
1237 type = TYPE_MAIN_VARIANT (type);
1239 /* bool always promotes to int (not unsigned), even if it's the same
1241 if (type == boolean_type_node)
1242 type = integer_type_node;
1244 /* Normally convert enums to int, but convert wide enums to something
1246 else if (TREE_CODE (type) == ENUMERAL_TYPE
1247 || type == wchar_type_node)
1249 int precision = MAX (TYPE_PRECISION (type),
1250 TYPE_PRECISION (integer_type_node));
1251 tree totype = type_for_size (precision, 0);
1252 if (TREE_UNSIGNED (type)
1253 && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1254 type = type_for_size (precision, 1);
1258 else if (C_PROMOTING_INTEGER_TYPE_P (type))
1260 /* Retain unsignedness if really not getting bigger. */
1261 if (TREE_UNSIGNED (type)
1262 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1263 type = unsigned_type_node;
1265 type = integer_type_node;
1267 else if (type == float_type_node)
1268 type = double_type_node;
1270 return cp_build_qualified_type (type, type_quals);
1273 /* The routines below this point are carefully written to conform to
1274 the standard. They use the same terminology, and follow the rules
1275 closely. Although they are used only in pt.c at the moment, they
1276 should presumably be used everywhere in the future. */
1278 /* Attempt to perform qualification conversions on EXPR to convert it
1279 to TYPE. Return the resulting expression, or error_mark_node if
1280 the conversion was impossible. */
1283 perform_qualification_conversions (type, expr)
1287 if (TREE_CODE (type) == POINTER_TYPE
1288 && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1289 && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1290 return build1 (NOP_EXPR, type, expr);
1292 return error_mark_node;