1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987, 88, 92-96, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file contains the functions for converting C expressions
24 to different data types. The only entry point is `convert'.
25 Every language front end must have a `convert' function
26 but what kind of conversions it does will depend on the language. */
35 extern tree static_aggregates;
37 static tree cp_convert_to_pointer PROTO((tree, tree));
38 static tree convert_to_pointer_force PROTO((tree, tree));
39 static tree build_up_reference PROTO((tree, tree, int));
41 /* Change of width--truncation and extension of integers or reals--
42 is represented with NOP_EXPR. Proper functioning of many things
43 assumes that no other conversions can be NOP_EXPRs.
45 Conversion between integer and pointer is represented with CONVERT_EXPR.
46 Converting integer to real uses FLOAT_EXPR
47 and real to integer uses FIX_TRUNC_EXPR.
49 Here is a list of all the functions that assume that widening and
50 narrowing is always done with a NOP_EXPR:
51 In convert.c, convert_to_integer.
52 In c-typeck.c, build_binary_op_nodefault (boolean ops),
53 and truthvalue_conversion.
54 In expr.c: expand_expr, for operands of a MULT_EXPR.
55 In fold-const.c: fold.
56 In tree.c: get_narrower and get_unwidened.
58 C++: in multiple-inheritance, converting between pointers may involve
59 adjusting them by a delta stored within the class definition. */
61 /* Subroutines of `convert'. */
63 /* if converting pointer to pointer
64 if dealing with classes, check for derived->base or vice versa
65 else if dealing with method pointers, delegate
67 else if converting class, pass off to build_type_conversion
68 else try C-style pointer conversion */
71 cp_convert_to_pointer (type, expr)
74 register tree intype = TREE_TYPE (expr);
75 register enum tree_code form;
78 if (IS_AGGR_TYPE (intype))
80 intype = complete_type (intype);
81 if (TYPE_SIZE (intype) == NULL_TREE)
83 cp_error ("can't convert from incomplete type `%T' to `%T'",
85 return error_mark_node;
88 rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
91 if (rval == error_mark_node)
92 cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
98 if (TYPE_PTRMEMFUNC_P (type))
99 type = TYPE_PTRMEMFUNC_FN_TYPE (type);
101 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
102 if (TREE_CODE (type) == POINTER_TYPE
103 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
104 || TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node))
106 /* Allow an implicit this pointer for pointer to member
108 if (TYPE_PTRMEMFUNC_P (intype))
110 tree decl, basebinfo;
111 tree fntype = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype));
112 tree t = TYPE_METHOD_BASETYPE (fntype);
114 if (current_class_type == 0
115 || get_base_distance (t, current_class_type, 0, &basebinfo)
118 decl = build1 (NOP_EXPR, t, error_mark_node);
120 else if (current_class_ptr == 0)
121 decl = build1 (NOP_EXPR, t, error_mark_node);
123 decl = current_class_ref;
125 expr = build (OFFSET_REF, fntype, decl, expr);
128 if (TREE_CODE (expr) == OFFSET_REF
129 && TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
130 expr = resolve_offset_ref (expr);
131 if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
132 expr = build_addr_func (expr);
133 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
135 if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
136 if (pedantic || warn_pmf2ptr)
137 cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
139 return build1 (NOP_EXPR, type, expr);
141 intype = TREE_TYPE (expr);
144 if (TYPE_PTRMEMFUNC_P (intype))
145 intype = TYPE_PTRMEMFUNC_FN_TYPE (intype);
147 form = TREE_CODE (intype);
149 if (form == POINTER_TYPE || form == REFERENCE_TYPE)
151 intype = TYPE_MAIN_VARIANT (intype);
153 if (TYPE_MAIN_VARIANT (type) != intype
154 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
155 && IS_AGGR_TYPE (TREE_TYPE (type))
156 && IS_AGGR_TYPE (TREE_TYPE (intype))
157 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
158 /* If EXPR is NULL, then we don't need to do any arithmetic
163 The null pointer value is converted to the null pointer
164 value of the destination type. */
165 && !integer_zerop (expr))
167 enum tree_code code = PLUS_EXPR;
168 tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
169 if (binfo == error_mark_node)
170 return error_mark_node;
171 if (binfo == NULL_TREE)
173 binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
174 if (binfo == error_mark_node)
175 return error_mark_node;
180 if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
181 || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
182 || ! BINFO_OFFSET_ZEROP (binfo))
184 /* Need to get the path we took. */
187 if (code == PLUS_EXPR)
188 get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
191 get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
193 return build_vbase_path (code, type, expr, path, 0);
197 if (TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE
198 && TREE_CODE (type) == POINTER_TYPE
199 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
200 return build_ptrmemfunc (type, expr, 1);
202 if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
203 && TREE_CODE (TREE_TYPE (intype)) == OFFSET_TYPE)
205 tree b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
206 tree b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
207 tree binfo = get_binfo (b2, b1, 1);
208 enum tree_code code = PLUS_EXPR;
210 if (binfo == NULL_TREE)
212 binfo = get_binfo (b1, b2, 1);
216 if (binfo == error_mark_node)
217 return error_mark_node;
218 if (binfo && ! TREE_VIA_VIRTUAL (binfo))
219 expr = size_binop (code, expr, BINFO_OFFSET (binfo));
222 if (TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE
223 || (TREE_CODE (type) == POINTER_TYPE
224 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
226 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
228 return error_mark_node;
231 rval = build1 (NOP_EXPR, type, expr);
232 TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
236 my_friendly_assert (form != OFFSET_TYPE, 186);
238 if (TYPE_LANG_SPECIFIC (intype)
239 && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
240 return convert_to_pointer (type, build_optr_ref (expr));
242 if (integer_zerop (expr))
244 if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
245 return build_ptrmemfunc (type, expr, 0);
246 expr = build_int_2 (0, 0);
247 TREE_TYPE (expr) = type;
251 if (INTEGRAL_CODE_P (form))
253 if (TYPE_PRECISION (intype) == POINTER_SIZE)
254 return build1 (CONVERT_EXPR, type, expr);
255 expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr);
256 /* Modes may be different but sizes should be the same. */
257 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
258 != GET_MODE_SIZE (TYPE_MODE (type)))
259 /* There is supposed to be some integral type
260 that is the same width as a pointer. */
262 return convert_to_pointer (type, expr);
265 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
267 return error_mark_node;
270 /* Like convert, except permit conversions to take place which
271 are not normally allowed due to access restrictions
272 (such as conversion from sub-type to private super-type). */
275 convert_to_pointer_force (type, expr)
278 register tree intype = TREE_TYPE (expr);
279 register enum tree_code form = TREE_CODE (intype);
281 if (integer_zerop (expr))
283 expr = build_int_2 (0, 0);
284 TREE_TYPE (expr) = type;
288 /* Convert signature pointer/reference to `void *' first. */
289 if (form == RECORD_TYPE
290 && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
292 expr = build_optr_ref (expr);
293 intype = TREE_TYPE (expr);
294 form = TREE_CODE (intype);
297 if (form == POINTER_TYPE)
299 intype = TYPE_MAIN_VARIANT (intype);
301 if (TYPE_MAIN_VARIANT (type) != intype
302 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
303 && IS_AGGR_TYPE (TREE_TYPE (type))
304 && IS_AGGR_TYPE (TREE_TYPE (intype))
305 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
307 enum tree_code code = PLUS_EXPR;
309 int distance = get_base_distance (TREE_TYPE (type),
310 TREE_TYPE (intype), 0, &path);
314 cp_error ("type `%T' is ambiguous baseclass of `%s'",
316 TYPE_NAME_STRING (TREE_TYPE (intype)));
317 return error_mark_node;
321 distance = get_base_distance (TREE_TYPE (intype),
322 TREE_TYPE (type), 0, &path);
326 /* Doesn't need any special help from us. */
327 return build1 (NOP_EXPR, type, expr);
331 return build_vbase_path (code, type, expr, path, 0);
335 return cp_convert_to_pointer (type, expr);
338 /* We are passing something to a function which requires a reference.
339 The type we are interested in is in TYPE. The initial
340 value we have to begin with is in ARG.
342 FLAGS controls how we manage access checking.
343 DIRECT_BIND in FLAGS controls how any temporaries are generated. */
346 build_up_reference (type, arg, flags)
351 tree argtype = TREE_TYPE (arg);
352 tree target_type = TREE_TYPE (type);
354 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
356 if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
359 if (toplevel_bindings_p ())
360 arg = get_temp_name (argtype, 1);
363 arg = pushdecl (build_decl (VAR_DECL, NULL_TREE, argtype));
364 DECL_ARTIFICIAL (arg) = 1;
366 DECL_INITIAL (arg) = targ;
367 cp_finish_decl (arg, targ, NULL_TREE, 0, LOOKUP_ONLYCONVERTING);
369 else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
371 tree slot = build_decl (VAR_DECL, NULL_TREE, argtype);
372 arg = build (TARGET_EXPR, argtype, slot, arg, NULL_TREE, NULL_TREE);
373 TREE_SIDE_EFFECTS (arg) = 1;
376 /* If we had a way to wrap this up, and say, if we ever needed it's
377 address, transform all occurrences of the register, into a memory
378 reference we could win better. */
379 rval = build_unary_op (ADDR_EXPR, arg, 1);
380 if ((flags & LOOKUP_PROTECT)
381 && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
382 && IS_AGGR_TYPE (argtype)
383 && IS_AGGR_TYPE (target_type))
385 /* We go through get_binfo for the access control. */
386 tree binfo = get_binfo (target_type, argtype, 1);
387 if (binfo == error_mark_node)
388 return error_mark_node;
389 if (binfo == NULL_TREE)
390 return error_not_base_type (target_type, argtype);
391 rval = convert_pointer_to_real (binfo, rval);
395 = convert_to_pointer_force (build_pointer_type (target_type), rval);
396 rval = build1 (NOP_EXPR, type, rval);
397 TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
401 /* For C++: Only need to do one-level references, but cannot
402 get tripped up on signed/unsigned differences.
404 DECL is either NULL_TREE or the _DECL node for a reference that is being
405 initialized. It can be error_mark_node if we don't know the _DECL but
406 we know it's an initialization. */
409 convert_to_reference (reftype, expr, convtype, flags, decl)
414 register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
415 register tree intype = TREE_TYPE (expr);
416 tree rval = NULL_TREE;
417 tree rval_as_conversion = NULL_TREE;
420 if (TREE_CODE (intype) == REFERENCE_TYPE)
421 my_friendly_abort (364);
423 intype = TYPE_MAIN_VARIANT (intype);
425 i = comp_target_types (type, intype, 0);
427 if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
428 && ! (flags & LOOKUP_NO_CONVERSION))
430 /* Look for a user-defined conversion to lvalue that we can use. */
433 = build_type_conversion (CONVERT_EXPR, reftype, expr, 1);
435 if (rval_as_conversion && rval_as_conversion != error_mark_node
436 && real_lvalue_p (rval_as_conversion))
438 expr = rval_as_conversion;
439 rval_as_conversion = NULL_TREE;
445 if (((convtype & CONV_STATIC) && i == -1)
446 || ((convtype & CONV_IMPLICIT) && i == 1))
448 if (flags & LOOKUP_COMPLAIN)
450 tree ttl = TREE_TYPE (reftype);
451 tree ttr = lvalue_type (expr);
453 /* [dcl.init.ref] says that if an rvalue is used to
454 initialize a reference, then the reference must be to a
455 non-volatile const type. */
456 if (! real_lvalue_p (expr)
457 && (!TYPE_READONLY (ttl) || TYPE_VOLATILE (ttl)))
461 if (TYPE_VOLATILE (ttl) && decl)
462 msg = "initialization of volatile reference type `%#T'";
463 else if (TYPE_VOLATILE (ttl))
464 msg = "conversion to volatile reference type `%#T'";
466 msg = "initialization of non-const reference type `%#T'";
468 msg = "conversion to non-const reference type `%#T'";
470 cp_error (msg, reftype);
471 cp_error ("from rvalue of type `%T'", intype);
473 else if (! (convtype & CONV_CONST))
475 if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
476 cp_error ("conversion from `%T' to `%T' discards const",
478 else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
479 cp_error ("conversion from `%T' to `%T' discards volatile",
484 return build_up_reference (reftype, expr, flags);
486 else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
488 /* When casting an lvalue to a reference type, just convert into
489 a pointer to the new type and deference it. This is allowed
490 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
491 should be done directly (jason). (int &)ri ---> *(int*)&ri */
493 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
495 if (TREE_CODE (intype) == POINTER_TYPE
496 && (comptypes (TREE_TYPE (intype), type, -1)))
497 cp_warning ("casting `%T' to `%T' does not dereference pointer",
500 rval = build_unary_op (ADDR_EXPR, expr, 0);
501 if (rval != error_mark_node)
502 rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
504 if (rval != error_mark_node)
505 rval = build1 (NOP_EXPR, reftype, rval);
509 rval = convert_for_initialization (NULL_TREE, type, expr, flags,
511 if (rval == error_mark_node)
512 return error_mark_node;
513 rval = build_up_reference (reftype, rval, flags);
515 if (rval && ! TYPE_READONLY (TREE_TYPE (reftype)))
516 cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
522 /* If we found a way to convert earlier, then use it. */
526 my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
528 if (flags & LOOKUP_COMPLAIN)
529 cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
531 if (flags & LOOKUP_SPECULATIVELY)
534 return error_mark_node;
537 /* We are using a reference VAL for its value. Bash that reference all the
538 way down to its lowest form. */
541 convert_from_reference (val)
544 tree type = TREE_TYPE (val);
546 if (TREE_CODE (type) == OFFSET_TYPE)
547 type = TREE_TYPE (type);
548 if (TREE_CODE (type) == REFERENCE_TYPE)
549 return build_indirect_ref (val, NULL_PTR);
553 /* Call this when we know (for any reason) that expr is not, in fact,
554 zero. This routine is like convert_pointer_to, but it pays
555 attention to which specific instance of what type we want to
556 convert to. This routine should eventually become
557 convert_to_pointer after all references to convert_to_pointer
561 convert_pointer_to_real (binfo, expr)
564 register tree intype = TREE_TYPE (expr);
568 if (intype == error_mark_node)
569 return error_mark_node;
571 if (TREE_CODE (binfo) == TREE_VEC)
572 type = BINFO_TYPE (binfo);
573 else if (IS_AGGR_TYPE (binfo))
583 ptr_type = cp_build_type_variant (type, TYPE_READONLY (TREE_TYPE (intype)),
584 TYPE_VOLATILE (TREE_TYPE (intype)));
585 ptr_type = build_pointer_type (ptr_type);
586 if (ptr_type == TYPE_MAIN_VARIANT (intype))
589 my_friendly_assert (!integer_zerop (expr), 191);
591 intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
592 if (TREE_CODE (type) == RECORD_TYPE
593 && TREE_CODE (intype) == RECORD_TYPE
598 = get_base_distance (binfo, intype, 0, &path);
600 /* This function shouldn't be called with unqualified arguments
601 but if it is, give them an error message that they can read. */
604 cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
608 cp_error ("because `%T' is an ambiguous base class", type);
609 return error_mark_node;
612 return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
614 rval = build1 (NOP_EXPR, ptr_type,
615 TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
616 TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
620 /* Call this when we know (for any reason) that expr is
621 not, in fact, zero. This routine gets a type out of the first
622 argument and uses it to search for the type to convert to. If there
623 is more than one instance of that type in the expr, the conversion is
624 ambiguous. This routine should eventually go away, and all
625 callers should use convert_to_pointer_real. */
628 convert_pointer_to (binfo, expr)
633 if (TREE_CODE (binfo) == TREE_VEC)
634 type = BINFO_TYPE (binfo);
635 else if (IS_AGGR_TYPE (binfo))
639 return convert_pointer_to_real (type, expr);
642 /* C++ conversions, preference to static cast conversions. */
645 cp_convert (type, expr)
648 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
653 FLAGS indicates how we should behave. */
656 ocp_convert (type, expr, convtype, flags)
660 register tree e = expr;
661 register enum tree_code code = TREE_CODE (type);
663 if (e == error_mark_node
664 || TREE_TYPE (e) == error_mark_node)
665 return error_mark_node;
667 if (TREE_READONLY_DECL_P (e))
668 e = decl_constant_value (e);
670 if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
671 /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
672 don't go through finish_struct, so they don't have the synthesized
673 constructors. So don't force a temporary. */
674 && TYPE_HAS_CONSTRUCTOR (type))
675 /* We need a new temporary; don't take this shortcut. */;
676 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
678 if (comptypes (type, TREE_TYPE (e), 1))
679 /* The call to fold will not always remove the NOP_EXPR as
680 might be expected, since if one of the types is a typedef;
681 the comparsion in fold is just equality of pointers, not a
682 call to comptypes. */
685 e = build1 (NOP_EXPR, type, e);
690 if (code == VOID_TYPE && (convtype & CONV_STATIC))
691 return build1 (CONVERT_EXPR, type, e);
694 /* This is incorrect. A truncation can't be stripped this way.
695 Extensions will be stripped by the use of get_unwidened. */
696 if (TREE_CODE (e) == NOP_EXPR)
697 return cp_convert (type, TREE_OPERAND (e, 0));
700 /* Just convert to the type of the member. */
701 if (code == OFFSET_TYPE)
703 type = TREE_TYPE (type);
704 code = TREE_CODE (type);
708 if (code == REFERENCE_TYPE)
709 return fold (convert_to_reference (type, e, convtype, flags, NULL_TREE));
710 else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
711 e = convert_from_reference (e);
714 if (TREE_CODE (e) == OFFSET_REF)
715 e = resolve_offset_ref (e);
717 if (INTEGRAL_CODE_P (code))
719 tree intype = TREE_TYPE (e);
720 /* enum = enum, enum = int, enum = float, (enum)pointer are all
722 if (TREE_CODE (type) == ENUMERAL_TYPE
723 && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
724 || (TREE_CODE (intype) == POINTER_TYPE)))
726 cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
728 if (flag_pedantic_errors)
729 return error_mark_node;
731 if (IS_AGGR_TYPE (intype))
734 rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
737 if (flags & LOOKUP_COMPLAIN)
738 cp_error ("`%#T' used where a `%T' was expected", intype, type);
739 if (flags & LOOKUP_SPECULATIVELY)
741 return error_mark_node;
743 if (code == BOOLEAN_TYPE)
745 /* Common Ada/Pascal programmer's mistake. We always warn
746 about this since it is so bad. */
747 if (TREE_CODE (expr) == FUNCTION_DECL)
748 cp_warning ("the address of `%D', will always be `true'", expr);
749 return truthvalue_conversion (e);
751 return fold (convert_to_integer (type, e));
753 if (code == POINTER_TYPE || code == REFERENCE_TYPE
754 || TYPE_PTRMEMFUNC_P (type))
755 return fold (cp_convert_to_pointer (type, e));
756 if (code == REAL_TYPE || code == COMPLEX_TYPE)
758 if (IS_AGGR_TYPE (TREE_TYPE (e)))
761 rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
765 if (flags & LOOKUP_COMPLAIN)
766 cp_error ("`%#T' used where a floating point value was expected",
769 if (code == REAL_TYPE)
770 return fold (convert_to_real (type, e));
771 else if (code == COMPLEX_TYPE)
772 return fold (convert_to_complex (type, e));
775 /* New C++ semantics: since assignment is now based on
776 memberwise copying, if the rhs type is derived from the
777 lhs type, then we may still do a conversion. */
778 if (IS_AGGR_TYPE_CODE (code))
780 tree dtype = TREE_TYPE (e);
781 tree ctor = NULL_TREE;
783 dtype = TYPE_MAIN_VARIANT (dtype);
785 /* Conversion of object pointers or signature pointers/references
786 to signature pointers/references. */
788 if (TYPE_LANG_SPECIFIC (type)
789 && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
791 tree constructor = build_signature_pointer_constructor (type, expr);
792 tree sig_ty = SIGNATURE_TYPE (type);
795 if (constructor == error_mark_node)
796 return error_mark_node;
798 sig_ptr = get_temp_name (type, 1);
799 DECL_INITIAL (sig_ptr) = constructor;
800 CLEAR_SIGNATURE (sig_ty);
801 cp_finish_decl (sig_ptr, constructor, NULL_TREE, 0, 0);
802 SET_SIGNATURE (sig_ty);
803 TREE_READONLY (sig_ptr) = 1;
808 /* Conversion between aggregate types. New C++ semantics allow
809 objects of derived type to be cast to objects of base type.
810 Old semantics only allowed this between pointers.
812 There may be some ambiguity between using a constructor
813 vs. using a type conversion operator when both apply. */
817 if ((flags & LOOKUP_ONLYCONVERTING)
818 && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
819 /* For copy-initialization, first we create a temp of the proper type
820 with a user-defined conversion sequence, then we direct-initialize
821 the target with the temp (see [dcl.init]). */
822 ctor = build_user_type_conversion (type, ctor, flags);
824 ctor = build_method_call (NULL_TREE, ctor_identifier,
825 build_expr_list (NULL_TREE, ctor),
826 TYPE_BINFO (type), flags);
828 return build_cplus_new (type, ctor);
831 /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
832 then it won't be hashed and hence compare as not equal,
834 if (code == ARRAY_TYPE
835 && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
836 && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
839 if (flags & LOOKUP_COMPLAIN)
840 cp_error ("conversion from `%T' to non-scalar type `%T' requested",
841 TREE_TYPE (expr), type);
842 if (flags & LOOKUP_SPECULATIVELY)
844 return error_mark_node;
847 /* Create an expression whose value is that of EXPR,
848 converted to type TYPE. The TREE_TYPE of the value
849 is always TYPE. This function implements all reasonable
850 conversions; callers should filter out those that are
851 not permitted by the language being compiled.
853 Most of this routine is from build_reinterpret_cast.
855 The backend cannot call cp_convert (what was convert) because
856 conversions to/from basetypes may involve memory references
857 (vbases) and adding or subtracting small values (multiple
858 inheritance), but it calls convert from the constant folding code
859 on subtrees of already build trees after it has ripped them apart.
861 Also, if we ever support range variables, we'll probably also have to
862 do a little bit more work. */
870 if (type == error_mark_node || expr == error_mark_node)
871 return error_mark_node;
873 intype = TREE_TYPE (expr);
875 if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
877 if (TREE_READONLY_DECL_P (expr))
878 expr = decl_constant_value (expr);
879 return fold (build1 (NOP_EXPR, type, expr));
882 return ocp_convert (type, expr, CONV_OLD_CONVERT,
883 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
886 /* Like cp_convert, except permit conversions to take place which
887 are not normally allowed due to access restrictions
888 (such as conversion from sub-type to private super-type). */
891 convert_force (type, expr, convtype)
896 register tree e = expr;
897 register enum tree_code code = TREE_CODE (type);
899 if (code == REFERENCE_TYPE)
900 return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
902 else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
903 e = convert_from_reference (e);
905 if (code == POINTER_TYPE)
906 return fold (convert_to_pointer_force (type, e));
908 /* From typeck.c convert_for_assignment */
909 if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
910 && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
911 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
913 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
914 && TYPE_PTRMEMFUNC_P (type))
916 /* compatible pointer to member functions. */
917 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
920 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
923 /* Convert an aggregate EXPR to type XTYPE. If a conversion
924 exists, return the attempted conversion. This may
925 return ERROR_MARK_NODE if the conversion is not
926 allowed (references private members, etc).
927 If no conversion exists, NULL_TREE is returned.
929 If (FOR_SURE & 1) is non-zero, then we allow this type conversion
930 to take place immediately. Otherwise, we build a SAVE_EXPR
931 which can be evaluated if the results are ever needed.
933 Changes to this functions should be mirrored in user_harshness.
935 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
936 object parameter, or by the second standard conversion sequence if
937 that doesn't do it. This will probably wait for an overloading rewrite.
941 build_type_conversion (code, xtype, expr, for_sure)
942 enum tree_code code ATTRIBUTE_UNUSED;
946 /* C++: check to see if we can convert this aggregate type
947 into the required type. */
948 return build_user_type_conversion
949 (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
952 /* Convert the given EXPR to one of a group of types suitable for use in an
953 expression. DESIRES is a combination of various WANT_* flags (q.v.)
954 which indicates which types are suitable. If COMPLAIN is 1, complain
955 about ambiguity; otherwise, the caller will deal with it. */
958 build_expr_type_conversion (desires, expr, complain)
963 tree basetype = TREE_TYPE (expr);
964 tree conv = NULL_TREE;
965 tree winner = NULL_TREE;
967 if (expr == null_node
968 && (desires & WANT_INT)
969 && !(desires & WANT_NULL))
970 cp_warning ("converting NULL to non-pointer type");
972 if (TREE_CODE (basetype) == OFFSET_TYPE)
973 expr = resolve_offset_ref (expr);
974 expr = convert_from_reference (expr);
975 basetype = TREE_TYPE (expr);
977 if (! IS_AGGR_TYPE (basetype))
978 switch (TREE_CODE (basetype))
981 if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
983 /* else fall through... */
986 return (desires & WANT_INT) ? expr : NULL_TREE;
988 return (desires & WANT_ENUM) ? expr : NULL_TREE;
990 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
992 return (desires & WANT_POINTER) ? expr : NULL_TREE;
996 return (desires & WANT_POINTER) ? default_conversion (expr)
1002 /* The code for conversions from class type is currently only used for
1003 delete expressions. Other expressions are handled by build_new_op. */
1005 if (! TYPE_HAS_CONVERSION (basetype))
1008 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1012 tree cand = TREE_VALUE (conv);
1014 if (winner && winner == cand)
1017 candidate = TREE_TYPE (TREE_TYPE (cand));
1018 if (TREE_CODE (candidate) == REFERENCE_TYPE)
1019 candidate = TREE_TYPE (candidate);
1021 switch (TREE_CODE (candidate))
1025 win = (desires & WANT_INT); break;
1027 win = (desires & WANT_ENUM); break;
1029 win = (desires & WANT_FLOAT); break;
1031 win = (desires & WANT_POINTER); break;
1043 cp_error ("ambiguous default type conversion from `%T'",
1045 cp_error (" candidate conversions include `%D' and `%D'",
1048 return error_mark_node;
1057 tree type = TREE_TYPE (TREE_TYPE (winner));
1058 if (TREE_CODE (type) == REFERENCE_TYPE)
1059 type = TREE_TYPE (type);
1060 return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1066 /* Implements integral promotion (4.1) and float->double promotion. */
1069 type_promotes_to (type)
1072 int constp, volatilep;
1074 if (type == error_mark_node)
1075 return error_mark_node;
1077 constp = TYPE_READONLY (type);
1078 volatilep = TYPE_VOLATILE (type);
1079 type = TYPE_MAIN_VARIANT (type);
1081 /* bool always promotes to int (not unsigned), even if it's the same
1083 if (type == boolean_type_node)
1084 type = integer_type_node;
1086 /* Normally convert enums to int, but convert wide enums to something
1088 else if (TREE_CODE (type) == ENUMERAL_TYPE
1089 || type == wchar_type_node)
1091 int precision = MAX (TYPE_PRECISION (type),
1092 TYPE_PRECISION (integer_type_node));
1093 tree totype = type_for_size (precision, 0);
1094 if (TREE_UNSIGNED (type)
1095 && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1096 type = type_for_size (precision, 1);
1100 else if (C_PROMOTING_INTEGER_TYPE_P (type))
1102 /* Retain unsignedness if really not getting bigger. */
1103 if (TREE_UNSIGNED (type)
1104 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1105 type = unsigned_type_node;
1107 type = integer_type_node;
1109 else if (type == float_type_node)
1110 type = double_type_node;
1112 return cp_build_type_variant (type, constp, volatilep);
1115 /* The routines below this point are carefully written to conform to
1116 the standard. They use the same terminology, and follow the rules
1117 closely. Although they are used only in pt.c at the moment, they
1118 should presumably be used everywhere in the future. */
1120 /* Attempt to perform qualification conversions on EXPR to convert it
1121 to TYPE. Return the resulting expression, or error_mark_node if
1122 the conversion was impossible. */
1125 perform_qualification_conversions (type, expr)
1129 if (TREE_CODE (type) == POINTER_TYPE
1130 && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1131 && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1132 return build1 (NOP_EXPR, type, expr);
1134 return error_mark_node;