OSDN Git Service

PR c++/44062
[pf3gnuchains/gcc-fork.git] / gcc / cp / cvt.c
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, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Hacked by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23
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.  */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include "tree.h"
34 #include "flags.h"
35 #include "cp-tree.h"
36 #include "intl.h"
37 #include "convert.h"
38 #include "toplev.h"
39 #include "decl.h"
40 #include "target.h"
41
42 static tree cp_convert_to_pointer (tree, tree);
43 static tree convert_to_pointer_force (tree, tree);
44 static tree build_type_conversion (tree, tree);
45 static tree build_up_reference (tree, tree, int, tree);
46 static void warn_ref_binding (tree, tree, tree);
47
48 /* Change of width--truncation and extension of integers or reals--
49    is represented with NOP_EXPR.  Proper functioning of many things
50    assumes that no other conversions can be NOP_EXPRs.
51
52    Conversion between integer and pointer is represented with CONVERT_EXPR.
53    Converting integer to real uses FLOAT_EXPR
54    and real to integer uses FIX_TRUNC_EXPR.
55
56    Here is a list of all the functions that assume that widening and
57    narrowing is always done with a NOP_EXPR:
58      In convert.c, convert_to_integer.
59      In c-typeck.c, build_binary_op_nodefault (boolean ops),
60         and c_common_truthvalue_conversion.
61      In expr.c: expand_expr, for operands of a MULT_EXPR.
62      In fold-const.c: fold.
63      In tree.c: get_narrower and get_unwidened.
64
65    C++: in multiple-inheritance, converting between pointers may involve
66    adjusting them by a delta stored within the class definition.  */
67 \f
68 /* Subroutines of `convert'.  */
69
70 /* if converting pointer to pointer
71      if dealing with classes, check for derived->base or vice versa
72      else if dealing with method pointers, delegate
73      else convert blindly
74    else if converting class, pass off to build_type_conversion
75    else try C-style pointer conversion.  */
76
77 static tree
78 cp_convert_to_pointer (tree type, tree expr)
79 {
80   tree intype = TREE_TYPE (expr);
81   enum tree_code form;
82   tree rval;
83   if (intype == error_mark_node)
84     return error_mark_node;
85
86   if (MAYBE_CLASS_TYPE_P (intype))
87     {
88       intype = complete_type (intype);
89       if (!COMPLETE_TYPE_P (intype))
90         {
91           error ("can't convert from incomplete type %qT to %qT",
92                  intype, type);
93           return error_mark_node;
94         }
95
96       rval = build_type_conversion (type, expr);
97       if (rval)
98         {
99           if (rval == error_mark_node)
100             error ("conversion of %qE from %qT to %qT is ambiguous",
101                    expr, intype, type);
102           return rval;
103         }
104     }
105
106   /* Handle anachronistic conversions from (::*)() to cv void* or (*)().  */
107   if (TREE_CODE (type) == POINTER_TYPE
108       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
109           || VOID_TYPE_P (TREE_TYPE (type))))
110     {
111       if (TYPE_PTRMEMFUNC_P (intype)
112           || TREE_CODE (intype) == METHOD_TYPE)
113         return convert_member_func_to_ptr (type, expr);
114       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
115         return build_nop (type, expr);
116       intype = TREE_TYPE (expr);
117     }
118
119   if (expr == error_mark_node)
120     return error_mark_node;
121
122   form = TREE_CODE (intype);
123
124   if (POINTER_TYPE_P (intype))
125     {
126       intype = TYPE_MAIN_VARIANT (intype);
127
128       if (TYPE_MAIN_VARIANT (type) != intype
129           && TREE_CODE (type) == POINTER_TYPE
130           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
131           && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
132           && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
133           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
134         {
135           enum tree_code code = PLUS_EXPR;
136           tree binfo;
137           tree intype_class;
138           tree type_class;
139           bool same_p;
140
141           intype_class = TREE_TYPE (intype);
142           type_class = TREE_TYPE (type);
143
144           same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
145                                 TYPE_MAIN_VARIANT (type_class));
146           binfo = NULL_TREE;
147           /* Try derived to base conversion.  */
148           if (!same_p)
149             binfo = lookup_base (intype_class, type_class, ba_check, NULL);
150           if (!same_p && !binfo)
151             {
152               /* Try base to derived conversion.  */
153               binfo = lookup_base (type_class, intype_class, ba_check, NULL);
154               code = MINUS_EXPR;
155             }
156           if (binfo == error_mark_node)
157             return error_mark_node;
158           if (binfo || same_p)
159             {
160               if (binfo)
161                 expr = build_base_path (code, expr, binfo, 0);
162               /* Add any qualifier conversions.  */
163               return build_nop (type, expr);
164             }
165         }
166
167       if (TYPE_PTRMEMFUNC_P (type))
168         {
169           error ("cannot convert %qE from type %qT to type %qT",
170                  expr, intype, type);
171           return error_mark_node;
172         }
173
174       return build_nop (type, expr);
175     }
176   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
177            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
178     return convert_ptrmem (type, expr, /*allow_inverse_p=*/false,
179                            /*c_cast_p=*/false);
180   else if (TYPE_PTRMEMFUNC_P (intype))
181     {
182       if (!warn_pmf2ptr)
183         {
184           if (TREE_CODE (expr) == PTRMEM_CST)
185             return cp_convert_to_pointer (type,
186                                           PTRMEM_CST_MEMBER (expr));
187           else if (TREE_CODE (expr) == OFFSET_REF)
188             {
189               tree object = TREE_OPERAND (expr, 0);
190               return get_member_function_from_ptrfunc (&object,
191                                                        TREE_OPERAND (expr, 1));
192             }
193         }
194       error ("cannot convert %qE from type %qT to type %qT",
195              expr, intype, type);
196       return error_mark_node;
197     }
198
199   if (integer_zerop (expr))
200     {
201       if (TYPE_PTRMEMFUNC_P (type))
202         return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0,
203                                  /*c_cast_p=*/false);
204
205       if (TYPE_PTRMEM_P (type))
206         {
207           /* A NULL pointer-to-member is represented by -1, not by
208              zero.  */
209           expr = build_int_cst_type (type, -1);
210         }
211       else
212         expr = build_int_cst (type, 0);
213
214       return expr;
215     }
216   else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form))
217     {
218       error ("invalid conversion from %qT to %qT", intype, type);
219       return error_mark_node;
220     }
221
222   if (INTEGRAL_CODE_P (form))
223     {
224       if (TYPE_PRECISION (intype) == POINTER_SIZE)
225         return build1 (CONVERT_EXPR, type, expr);
226       expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr);
227       /* Modes may be different but sizes should be the same.  There
228          is supposed to be some integral type that is the same width
229          as a pointer.  */
230       gcc_assert (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
231                   == GET_MODE_SIZE (TYPE_MODE (type)));
232
233       return convert_to_pointer (type, expr);
234     }
235
236   if (type_unknown_p (expr))
237     return instantiate_type (type, expr, tf_warning_or_error);
238
239   error ("cannot convert %qE from type %qT to type %qT",
240          expr, intype, type);
241   return error_mark_node;
242 }
243
244 /* Like convert, except permit conversions to take place which
245    are not normally allowed due to access restrictions
246    (such as conversion from sub-type to private super-type).  */
247
248 static tree
249 convert_to_pointer_force (tree type, tree expr)
250 {
251   tree intype = TREE_TYPE (expr);
252   enum tree_code form = TREE_CODE (intype);
253
254   if (form == POINTER_TYPE)
255     {
256       intype = TYPE_MAIN_VARIANT (intype);
257
258       if (TYPE_MAIN_VARIANT (type) != intype
259           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
260           && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
261           && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
262           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
263         {
264           enum tree_code code = PLUS_EXPR;
265           tree binfo;
266
267           binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type),
268                                ba_unique, NULL);
269           if (!binfo)
270             {
271               binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
272                                    ba_unique, NULL);
273               code = MINUS_EXPR;
274             }
275           if (binfo == error_mark_node)
276             return error_mark_node;
277           if (binfo)
278             {
279               expr = build_base_path (code, expr, binfo, 0);
280               if (expr == error_mark_node)
281                  return error_mark_node;
282               /* Add any qualifier conversions.  */
283               if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
284                                 TREE_TYPE (type)))
285                 expr = build_nop (type, expr);
286               return expr;
287             }
288         }
289     }
290
291   return cp_convert_to_pointer (type, expr);
292 }
293
294 /* We are passing something to a function which requires a reference.
295    The type we are interested in is in TYPE. The initial
296    value we have to begin with is in ARG.
297
298    FLAGS controls how we manage access checking.
299    DIRECT_BIND in FLAGS controls how any temporaries are generated.
300      If DIRECT_BIND is set, DECL is the reference we're binding to.  */
301
302 static tree
303 build_up_reference (tree type, tree arg, int flags, tree decl)
304 {
305   tree rval;
306   tree argtype = TREE_TYPE (arg);
307   tree target_type = TREE_TYPE (type);
308
309   gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
310
311   if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
312     {
313       /* Create a new temporary variable.  We can't just use a TARGET_EXPR
314          here because it needs to live as long as DECL.  */
315       tree targ = arg;
316
317       arg = make_temporary_var_for_ref_to_temp (decl, TREE_TYPE (arg));
318
319       /* Process the initializer for the declaration.  */
320       DECL_INITIAL (arg) = targ;
321       cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE,
322                       LOOKUP_ONLYCONVERTING|DIRECT_BIND);
323     }
324   else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
325     return get_target_expr (arg);
326
327   /* If we had a way to wrap this up, and say, if we ever needed its
328      address, transform all occurrences of the register, into a memory
329      reference we could win better.  */
330   rval = cp_build_unary_op (ADDR_EXPR, arg, 1, tf_warning_or_error);
331   if (rval == error_mark_node)
332     return error_mark_node;
333
334   if ((flags & LOOKUP_PROTECT)
335       && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
336       && MAYBE_CLASS_TYPE_P (argtype)
337       && MAYBE_CLASS_TYPE_P (target_type))
338     {
339       /* We go through lookup_base for the access control.  */
340       tree binfo = lookup_base (argtype, target_type, ba_check, NULL);
341       if (binfo == error_mark_node)
342         return error_mark_node;
343       if (binfo == NULL_TREE)
344         return error_not_base_type (target_type, argtype);
345       rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
346     }
347   else
348     rval
349       = convert_to_pointer_force (build_pointer_type (target_type), rval);
350   return build_nop (type, rval);
351 }
352
353 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
354    INTYPE is the original rvalue type and DECL is an optional _DECL node
355    for diagnostics.
356
357    [dcl.init.ref] says that if an rvalue is used to
358    initialize a reference, then the reference must be to a
359    non-volatile const type.  */
360
361 static void
362 warn_ref_binding (tree reftype, tree intype, tree decl)
363 {
364   tree ttl = TREE_TYPE (reftype);
365
366   if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl))
367     {
368       const char *msg;
369
370       if (CP_TYPE_VOLATILE_P (ttl) && decl)
371         msg = G_("initialization of volatile reference type %q#T from "
372                  "rvalue of type %qT");
373       else if (CP_TYPE_VOLATILE_P (ttl))
374         msg = G_("conversion to volatile reference type %q#T "
375                  "from rvalue of type %qT");
376       else if (decl)
377         msg = G_("initialization of non-const reference type %q#T from "
378                  "rvalue of type %qT");
379       else
380         msg = G_("conversion to non-const reference type %q#T from "
381                  "rvalue of type %qT");
382
383       permerror (input_location, msg, reftype, intype);
384     }
385 }
386
387 /* For C++: Only need to do one-level references, but cannot
388    get tripped up on signed/unsigned differences.
389
390    DECL is either NULL_TREE or the _DECL node for a reference that is being
391    initialized.  It can be error_mark_node if we don't know the _DECL but
392    we know it's an initialization.  */
393
394 tree
395 convert_to_reference (tree reftype, tree expr, int convtype,
396                       int flags, tree decl)
397 {
398   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
399   tree intype;
400   tree rval = NULL_TREE;
401   tree rval_as_conversion = NULL_TREE;
402   bool can_convert_intype_to_type;
403
404   if (TREE_CODE (type) == FUNCTION_TYPE
405       && TREE_TYPE (expr) == unknown_type_node)
406     expr = instantiate_type (type, expr,
407                              (flags & LOOKUP_COMPLAIN)
408                              ? tf_warning_or_error : tf_none);
409
410   if (expr == error_mark_node)
411     return error_mark_node;
412
413   intype = TREE_TYPE (expr);
414
415   gcc_assert (TREE_CODE (intype) != REFERENCE_TYPE);
416   gcc_assert (TREE_CODE (reftype) == REFERENCE_TYPE);
417
418   intype = TYPE_MAIN_VARIANT (intype);
419
420   can_convert_intype_to_type = can_convert (type, intype);
421   if (!can_convert_intype_to_type
422       && (convtype & CONV_IMPLICIT) && MAYBE_CLASS_TYPE_P (intype)
423       && ! (flags & LOOKUP_NO_CONVERSION))
424     {
425       /* Look for a user-defined conversion to lvalue that we can use.  */
426
427       rval_as_conversion
428         = build_type_conversion (reftype, expr);
429
430       if (rval_as_conversion && rval_as_conversion != error_mark_node
431           && real_lvalue_p (rval_as_conversion))
432         {
433           expr = rval_as_conversion;
434           rval_as_conversion = NULL_TREE;
435           intype = type;
436           can_convert_intype_to_type = 1;
437         }
438     }
439
440   if (((convtype & CONV_STATIC) && can_convert (intype, type))
441       || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type))
442     {
443       if (flags & LOOKUP_COMPLAIN)
444         {
445           tree ttl = TREE_TYPE (reftype);
446           tree ttr = lvalue_type (expr);
447
448           if (! real_lvalue_p (expr))
449             warn_ref_binding (reftype, intype, decl);
450
451           if (! (convtype & CONV_CONST)
452                    && !at_least_as_qualified_p (ttl, ttr))
453             permerror (input_location, "conversion from %qT to %qT discards qualifiers",
454                        ttr, reftype);
455         }
456
457       return build_up_reference (reftype, expr, flags, decl);
458     }
459   else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
460     {
461       /* When casting an lvalue to a reference type, just convert into
462          a pointer to the new type and deference it.  This is allowed
463          by San Diego WP section 5.2.9 paragraph 12, though perhaps it
464          should be done directly (jason).  (int &)ri ---> *(int*)&ri */
465
466       /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
467          meant.  */
468       if (TREE_CODE (intype) == POINTER_TYPE
469           && (comptypes (TREE_TYPE (intype), type,
470                          COMPARE_BASE | COMPARE_DERIVED)))
471         warning (0, "casting %qT to %qT does not dereference pointer",
472                  intype, reftype);
473
474       rval = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
475       if (rval != error_mark_node)
476         rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
477                               rval, 0);
478       if (rval != error_mark_node)
479         rval = build1 (NOP_EXPR, reftype, rval);
480     }
481   else
482     {
483       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
484                                          "converting", 0, 0,
485                                          tf_warning_or_error);
486       if (rval == NULL_TREE || rval == error_mark_node)
487         return rval;
488       warn_ref_binding (reftype, intype, decl);
489       rval = build_up_reference (reftype, rval, flags, decl);
490     }
491
492   if (rval)
493     {
494       /* If we found a way to convert earlier, then use it.  */
495       return rval;
496     }
497
498   if (flags & LOOKUP_COMPLAIN)
499     error ("cannot convert type %qT to type %qT", intype, reftype);
500
501   return error_mark_node;
502 }
503
504 /* We are using a reference VAL for its value. Bash that reference all the
505    way down to its lowest form.  */
506
507 tree
508 convert_from_reference (tree val)
509 {
510   if (TREE_TYPE (val)
511       && TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
512     {
513       tree t = TREE_TYPE (TREE_TYPE (val));
514       tree ref = build1 (INDIRECT_REF, t, val);
515
516        /* We *must* set TREE_READONLY when dereferencing a pointer to const,
517           so that we get the proper error message if the result is used
518           to assign to.  Also, &* is supposed to be a no-op.  */
519       TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
520       TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
521       TREE_SIDE_EFFECTS (ref)
522         = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val));
523       REFERENCE_REF_P (ref) = 1;
524       val = ref;
525     }
526
527   return val;
528 }
529
530 /* Really perform an lvalue-to-rvalue conversion, including copying an
531    argument of class type into a temporary.  */
532
533 tree
534 force_rvalue (tree expr)
535 {
536   if (MAYBE_CLASS_TYPE_P (TREE_TYPE (expr)) && TREE_CODE (expr) != TARGET_EXPR)
537     expr = ocp_convert (TREE_TYPE (expr), expr,
538                         CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL);
539   else
540     expr = decay_conversion (expr);
541
542   return expr;
543 }
544
545 \f
546 /* Fold away simple conversions, but make sure the result is an rvalue.  */
547
548 tree
549 cp_fold_convert (tree type, tree expr)
550 {
551   return rvalue (fold_convert (type, expr));
552 }
553
554 /* C++ conversions, preference to static cast conversions.  */
555
556 tree
557 cp_convert (tree type, tree expr)
558 {
559   return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
560 }
561
562 /* C++ equivalent of convert_and_check but using cp_convert as the
563    conversion function.
564
565    Convert EXPR to TYPE, warning about conversion problems with constants.
566    Invoke this function on every expression that is converted implicitly,
567    i.e. because of language rules and not because of an explicit cast.  */
568
569 tree
570 cp_convert_and_check (tree type, tree expr)
571 {
572   tree result;
573
574   if (TREE_TYPE (expr) == type)
575     return expr;
576   
577   result = cp_convert (type, expr);
578
579   if (c_inhibit_evaluation_warnings == 0
580       && !TREE_OVERFLOW_P (expr)
581       && result != error_mark_node)
582     warnings_for_convert_and_check (type, expr, result);
583
584   return result;
585 }
586
587 /* Conversion...
588
589    FLAGS indicates how we should behave.  */
590
591 tree
592 ocp_convert (tree type, tree expr, int convtype, int flags)
593 {
594   tree e = expr;
595   enum tree_code code = TREE_CODE (type);
596   const char *invalid_conv_diag;
597   tree e1;
598
599   if (error_operand_p (e) || type == error_mark_node)
600     return error_mark_node;
601
602   complete_type (type);
603   complete_type (TREE_TYPE (expr));
604
605   if ((invalid_conv_diag
606        = targetm.invalid_conversion (TREE_TYPE (expr), type)))
607     {
608       error (invalid_conv_diag);
609       return error_mark_node;
610     }
611
612   e = integral_constant_value (e);
613   if (error_operand_p (e))
614     return error_mark_node;
615
616   if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
617     /* We need a new temporary; don't take this shortcut.  */;
618   else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
619     {
620       if (same_type_p (type, TREE_TYPE (e)))
621         /* The call to fold will not always remove the NOP_EXPR as
622            might be expected, since if one of the types is a typedef;
623            the comparison in fold is just equality of pointers, not a
624            call to comptypes.  We don't call fold in this case because
625            that can result in infinite recursion; fold will call
626            convert, which will call ocp_convert, etc.  */
627         return e;
628       /* For complex data types, we need to perform componentwise
629          conversion.  */
630       else if (TREE_CODE (type) == COMPLEX_TYPE)
631         return fold_if_not_in_template (convert_to_complex (type, e));
632       else if (TREE_CODE (e) == TARGET_EXPR)
633         {
634           /* Don't build a NOP_EXPR of class type.  Instead, change the
635              type of the temporary.  */
636           TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
637           return e;
638         }
639       else
640         {
641           /* We shouldn't be treating objects of ADDRESSABLE type as
642              rvalues.  */
643           gcc_assert (!TREE_ADDRESSABLE (type));
644           return fold_if_not_in_template (build_nop (type, e));
645         }
646     }
647
648   e1 = targetm.convert_to_type (type, e);
649   if (e1)
650     return e1;
651
652   if (code == VOID_TYPE && (convtype & CONV_STATIC))
653     {
654       e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error);
655       return e;
656     }
657
658   if (INTEGRAL_CODE_P (code))
659     {
660       tree intype = TREE_TYPE (e);
661
662       if (TREE_CODE (type) == ENUMERAL_TYPE)
663         {
664           /* enum = enum, enum = int, enum = float, (enum)pointer are all
665              errors.  */
666           if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
667                 || TREE_CODE (intype) == REAL_TYPE)
668                && ! (convtype & CONV_STATIC))
669               || TREE_CODE (intype) == POINTER_TYPE)
670             {
671               if (flags & LOOKUP_COMPLAIN)
672                 permerror (input_location, "conversion from %q#T to %q#T", intype, type);
673
674               if (!flag_permissive)
675                 return error_mark_node;
676             }
677
678           /* [expr.static.cast]
679
680              8. A value of integral or enumeration type can be explicitly
681              converted to an enumeration type. The value is unchanged if
682              the original value is within the range of the enumeration
683              values. Otherwise, the resulting enumeration value is
684              unspecified.  */
685           if (TREE_CODE (expr) == INTEGER_CST
686               && !int_fits_type_p (expr, ENUM_UNDERLYING_TYPE (type)))
687             warning (OPT_Wconversion, 
688                      "the result of the conversion is unspecified because "
689                      "%qE is outside the range of type %qT",
690                      expr, type);
691         }
692       if (MAYBE_CLASS_TYPE_P (intype))
693         {
694           tree rval;
695           rval = build_type_conversion (type, e);
696           if (rval)
697             return rval;
698           if (flags & LOOKUP_COMPLAIN)
699             error ("%q#T used where a %qT was expected", intype, type);
700           return error_mark_node;
701         }
702       if (code == BOOLEAN_TYPE)
703         return cp_truthvalue_conversion (e);
704
705       return fold_if_not_in_template (convert_to_integer (type, e));
706     }
707   if (code == NULLPTR_TYPE && e && null_ptr_cst_p (e))
708     return nullptr_node;
709   if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type))
710     return fold_if_not_in_template (cp_convert_to_pointer (type, e));
711   if (code == VECTOR_TYPE)
712     {
713       tree in_vtype = TREE_TYPE (e);
714       if (MAYBE_CLASS_TYPE_P (in_vtype))
715         {
716           tree ret_val;
717           ret_val = build_type_conversion (type, e);
718           if (ret_val)
719             return ret_val;
720           if (flags & LOOKUP_COMPLAIN)
721             error ("%q#T used where a %qT was expected", in_vtype, type);
722           return error_mark_node;
723         }
724       return fold_if_not_in_template (convert_to_vector (type, e));
725     }
726   if (code == REAL_TYPE || code == COMPLEX_TYPE)
727     {
728       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
729         {
730           tree rval;
731           rval = build_type_conversion (type, e);
732           if (rval)
733             return rval;
734           else
735             if (flags & LOOKUP_COMPLAIN)
736               error ("%q#T used where a floating point value was expected",
737                         TREE_TYPE (e));
738         }
739       if (code == REAL_TYPE)
740         return fold_if_not_in_template (convert_to_real (type, e));
741       else if (code == COMPLEX_TYPE)
742         return fold_if_not_in_template (convert_to_complex (type, e));
743     }
744
745   /* New C++ semantics:  since assignment is now based on
746      memberwise copying,  if the rhs type is derived from the
747      lhs type, then we may still do a conversion.  */
748   if (RECORD_OR_UNION_CODE_P (code))
749     {
750       tree dtype = TREE_TYPE (e);
751       tree ctor = NULL_TREE;
752
753       dtype = TYPE_MAIN_VARIANT (dtype);
754
755       /* Conversion between aggregate types.  New C++ semantics allow
756          objects of derived type to be cast to objects of base type.
757          Old semantics only allowed this between pointers.
758
759          There may be some ambiguity between using a constructor
760          vs. using a type conversion operator when both apply.  */
761
762       ctor = e;
763
764       if (abstract_virtuals_error (NULL_TREE, type))
765         return error_mark_node;
766
767       if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
768         ctor = perform_implicit_conversion (type, ctor, tf_warning_or_error);
769       else if ((flags & LOOKUP_ONLYCONVERTING)
770                && ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
771         /* For copy-initialization, first we create a temp of the proper type
772            with a user-defined conversion sequence, then we direct-initialize
773            the target with the temp (see [dcl.init]).  */
774         ctor = build_user_type_conversion (type, ctor, flags);
775       else
776         {
777           VEC(tree,gc) *ctor_vec = make_tree_vector_single (ctor);
778           ctor = build_special_member_call (NULL_TREE,
779                                             complete_ctor_identifier,
780                                             &ctor_vec,
781                                             type, flags,
782                                             tf_warning_or_error);
783           release_tree_vector (ctor_vec);
784         }
785       if (ctor)
786         return build_cplus_new (type, ctor);
787     }
788
789   if (flags & LOOKUP_COMPLAIN)
790     {
791       /* If the conversion failed and expr was an invalid use of pointer to
792          member function, try to report a meaningful error.  */
793       if (invalid_nonstatic_memfn_p (expr, tf_warning_or_error))
794         /* We displayed the error message.  */;
795       else
796         error ("conversion from %qT to non-scalar type %qT requested",
797                TREE_TYPE (expr), type);
798     }
799   return error_mark_node;
800 }
801
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 believe 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.
816
817    IMPLICIT is non-NULL iff an expression is being implicitly converted; it
818    is NULL when the user is explicitly converting an expression to void via
819    a cast.  When non-NULL, IMPLICIT is a string indicating the context of
820    the implicit conversion.  */
821
822 tree
823 convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
824 {
825   tree exprv;
826
827   if (expr == error_mark_node
828       || TREE_TYPE (expr) == error_mark_node)
829     return error_mark_node;
830
831   exprv = expr;
832   while (TREE_CODE (exprv) == COMPOUND_EXPR)
833     exprv = TREE_OPERAND (exprv, 1);
834   if (DECL_P (exprv) || handled_component_p (exprv))
835     /* Expr is not being 'used' here, otherwise we whould have
836        called mark_{rl}value_use use here, which would have in turn
837        called mark_exp_read.  Rather, we call mark_exp_read directly
838        to avoid some warnings when
839        -Wunused-but-set-{variable,parameter} is in effect.  */
840     mark_exp_read (exprv);
841
842   if (!TREE_TYPE (expr))
843     return expr;
844   if (invalid_nonstatic_memfn_p (expr, complain))
845     return error_mark_node;
846   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
847     {
848       if (complain & tf_error)
849         error ("pseudo-destructor is not called");
850       return error_mark_node;
851     }
852   if (VOID_TYPE_P (TREE_TYPE (expr)))
853     return expr;
854   switch (TREE_CODE (expr))
855     {
856     case COND_EXPR:
857       {
858         /* The two parts of a cond expr might be separate lvalues.  */
859         tree op1 = TREE_OPERAND (expr,1);
860         tree op2 = TREE_OPERAND (expr,2);
861         bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
862         tree new_op1 = convert_to_void
863           (op1, (implicit && !side_effects
864                  ? "second operand of conditional" : NULL), complain);
865         tree new_op2 = convert_to_void
866           (op2, (implicit && !side_effects
867                  ? "third operand of conditional" : NULL), complain);
868
869         expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
870                        TREE_OPERAND (expr, 0), new_op1, new_op2);
871         break;
872       }
873
874     case COMPOUND_EXPR:
875       {
876         /* The second part of a compound expr contains the value.  */
877         tree op1 = TREE_OPERAND (expr,1);
878         tree new_op1 = convert_to_void
879           (op1, (implicit && !TREE_NO_WARNING (expr)
880                  ? "right-hand operand of comma" : NULL), complain);
881
882         if (new_op1 != op1)
883           {
884             tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
885                              TREE_OPERAND (expr, 0), new_op1);
886             expr = t;
887           }
888
889         break;
890       }
891
892     case NON_LVALUE_EXPR:
893     case NOP_EXPR:
894       /* These have already decayed to rvalue.  */
895       break;
896
897     case CALL_EXPR:   /* We have a special meaning for volatile void fn().  */
898       break;
899
900     case INDIRECT_REF:
901       {
902         tree type = TREE_TYPE (expr);
903         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
904                            == REFERENCE_TYPE;
905         int is_volatile = TYPE_VOLATILE (type);
906         int is_complete = COMPLETE_TYPE_P (complete_type (type));
907
908         /* Can't load the value if we don't know the type.  */
909         if (is_volatile && !is_complete)
910           {
911             if (complain & tf_warning)
912               warning (0, "object of incomplete type %qT will not be accessed in %s",
913                        type, implicit ? implicit : "void context");
914           }
915         /* Don't load the value if this is an implicit dereference, or if
916            the type needs to be handled by ctors/dtors.  */
917         else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
918           {
919             if (complain & tf_warning)
920               warning (0, "object of type %qT will not be accessed in %s",
921                        TREE_TYPE (TREE_OPERAND (expr, 0)),
922                        implicit ? implicit : "void context");
923           }
924         if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
925           {
926             /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
927                operation is stripped off. Note that we don't warn about
928                - an expression with TREE_NO_WARNING set. (For an example of
929                  such expressions, see build_over_call in call.c.)
930                - automatic dereferencing of references, since the user cannot
931                  control it. (See also warn_if_unused_value() in stmt.c.)  */
932             if (warn_unused_value
933                 && implicit
934                 && (complain & tf_warning)
935                 && !TREE_NO_WARNING (expr)
936                 && !is_reference)
937               warning (OPT_Wunused_value, "value computed is not used");
938             expr = TREE_OPERAND (expr, 0);
939           }
940
941         break;
942       }
943
944     case VAR_DECL:
945       {
946         /* External variables might be incomplete.  */
947         tree type = TREE_TYPE (expr);
948         int is_complete = COMPLETE_TYPE_P (complete_type (type));
949
950         if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
951           warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
952                    expr, type, implicit ? implicit : "void context");
953         break;
954       }
955
956     case TARGET_EXPR:
957       /* Don't bother with the temporary object returned from a function if
958          we don't use it and don't need to destroy it.  We'll still
959          allocate space for it in expand_call or declare_return_variable,
960          but we don't need to track it through all the tree phases.  */
961       if (TARGET_EXPR_IMPLICIT_P (expr)
962           && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr)))
963         {
964           tree init = TARGET_EXPR_INITIAL (expr);
965           if (TREE_CODE (init) == AGGR_INIT_EXPR
966               && !AGGR_INIT_VIA_CTOR_P (init))
967             {
968               tree fn = AGGR_INIT_EXPR_FN (init);
969               expr = build_call_array_loc (input_location,
970                                            TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
971                                            fn,
972                                            aggr_init_expr_nargs (init),
973                                            AGGR_INIT_EXPR_ARGP (init));
974             }
975         }
976       break;
977
978     default:;
979     }
980   expr = resolve_nondeduced_context (expr);
981   {
982     tree probe = expr;
983
984     if (TREE_CODE (probe) == ADDR_EXPR)
985       probe = TREE_OPERAND (expr, 0);
986     if (type_unknown_p (probe))
987       {
988         /* [over.over] enumerates the places where we can take the address
989            of an overloaded function, and this is not one of them.  */
990         if (complain & tf_error)
991           error ("%s cannot resolve address of overloaded function",
992                  implicit ? implicit : "void cast");
993         else
994           return error_mark_node;
995         expr = void_zero_node;
996       }
997     else if (implicit && probe == expr && is_overloaded_fn (probe))
998       {
999         /* Only warn when there is no &.  */
1000         if (complain & tf_warning)
1001           warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
1002                    implicit, expr);
1003         if (TREE_CODE (expr) == COMPONENT_REF)
1004           expr = TREE_OPERAND (expr, 0);
1005       }
1006   }
1007
1008   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
1009     {
1010       if (implicit
1011           && warn_unused_value
1012           && !TREE_NO_WARNING (expr)
1013           && !processing_template_decl)
1014         {
1015           /* The middle end does not warn about expressions that have
1016              been explicitly cast to void, so we must do so here.  */
1017           if (!TREE_SIDE_EFFECTS (expr)) {
1018             if (complain & tf_warning)
1019               warning (OPT_Wunused_value, "%s has no effect", implicit);
1020           }
1021           else
1022             {
1023               tree e;
1024               enum tree_code code;
1025               enum tree_code_class tclass;
1026
1027               e = expr;
1028               /* We might like to warn about (say) "(int) f()", as the
1029                  cast has no effect, but the compiler itself will
1030                  generate implicit conversions under some
1031                  circumstances.  (For example a block copy will be
1032                  turned into a call to "__builtin_memcpy", with a
1033                  conversion of the return value to an appropriate
1034                  type.)  So, to avoid false positives, we strip
1035                  conversions.  Do not use STRIP_NOPs because it will
1036                  not strip conversions to "void", as that is not a
1037                  mode-preserving conversion.  */
1038               while (TREE_CODE (e) == NOP_EXPR)
1039                 e = TREE_OPERAND (e, 0);
1040
1041               code = TREE_CODE (e);
1042               tclass = TREE_CODE_CLASS (code);
1043               if ((tclass == tcc_comparison
1044                    || tclass == tcc_unary
1045                    || (tclass == tcc_binary
1046                        && !(code == MODIFY_EXPR
1047                             || code == INIT_EXPR
1048                             || code == PREDECREMENT_EXPR
1049                             || code == PREINCREMENT_EXPR
1050                             || code == POSTDECREMENT_EXPR
1051                             || code == POSTINCREMENT_EXPR)))
1052                   && (complain & tf_warning))
1053                 warning (OPT_Wunused_value, "value computed is not used");
1054             }
1055         }
1056       expr = build1 (CONVERT_EXPR, void_type_node, expr);
1057     }
1058   if (! TREE_SIDE_EFFECTS (expr))
1059     expr = void_zero_node;
1060   return expr;
1061 }
1062
1063 /* Create an expression whose value is that of EXPR,
1064    converted to type TYPE.  The TREE_TYPE of the value
1065    is always TYPE.  This function implements all reasonable
1066    conversions; callers should filter out those that are
1067    not permitted by the language being compiled.
1068
1069    Most of this routine is from build_reinterpret_cast.
1070
1071    The back end cannot call cp_convert (what was convert) because
1072    conversions to/from basetypes may involve memory references
1073    (vbases) and adding or subtracting small values (multiple
1074    inheritance), but it calls convert from the constant folding code
1075    on subtrees of already built trees after it has ripped them apart.
1076
1077    Also, if we ever support range variables, we'll probably also have to
1078    do a little bit more work.  */
1079
1080 tree
1081 convert (tree type, tree expr)
1082 {
1083   tree intype;
1084
1085   if (type == error_mark_node || expr == error_mark_node)
1086     return error_mark_node;
1087
1088   intype = TREE_TYPE (expr);
1089
1090   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
1091     return fold_if_not_in_template (build_nop (type, expr));
1092
1093   return ocp_convert (type, expr, CONV_OLD_CONVERT,
1094                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1095 }
1096
1097 /* Like cp_convert, except permit conversions to take place which
1098    are not normally allowed due to access restrictions
1099    (such as conversion from sub-type to private super-type).  */
1100
1101 tree
1102 convert_force (tree type, tree expr, int convtype)
1103 {
1104   tree e = expr;
1105   enum tree_code code = TREE_CODE (type);
1106
1107   if (code == REFERENCE_TYPE)
1108     return (fold_if_not_in_template
1109             (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1110                                    NULL_TREE)));
1111
1112   if (code == POINTER_TYPE)
1113     return fold_if_not_in_template (convert_to_pointer_force (type, e));
1114
1115   /* From typeck.c convert_for_assignment */
1116   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1117         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1118         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1119        || integer_zerop (e)
1120        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1121       && TYPE_PTRMEMFUNC_P (type))
1122     /* compatible pointer to member functions.  */
1123     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
1124                              /*c_cast_p=*/1);
1125
1126   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1127 }
1128
1129 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1130    exists, return the attempted conversion.  This may
1131    return ERROR_MARK_NODE if the conversion is not
1132    allowed (references private members, etc).
1133    If no conversion exists, NULL_TREE is returned.
1134
1135    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1136    object parameter, or by the second standard conversion sequence if
1137    that doesn't do it.  This will probably wait for an overloading rewrite.
1138    (jason 8/9/95)  */
1139
1140 static tree
1141 build_type_conversion (tree xtype, tree expr)
1142 {
1143   /* C++: check to see if we can convert this aggregate type
1144      into the required type.  */
1145   return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL);
1146 }
1147
1148 /* Convert the given EXPR to one of a group of types suitable for use in an
1149    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1150    which indicates which types are suitable.  If COMPLAIN is true, complain
1151    about ambiguity; otherwise, the caller will deal with it.  */
1152
1153 tree
1154 build_expr_type_conversion (int desires, tree expr, bool complain)
1155 {
1156   tree basetype = TREE_TYPE (expr);
1157   tree conv = NULL_TREE;
1158   tree winner = NULL_TREE;
1159
1160   if (expr == null_node
1161       && (desires & WANT_INT)
1162       && !(desires & WANT_NULL))
1163     warning_at (input_location, OPT_Wconversion_null,
1164                 "converting NULL to non-pointer type");
1165
1166   basetype = TREE_TYPE (expr);
1167
1168   if (basetype == error_mark_node)
1169     return error_mark_node;
1170
1171   if (! MAYBE_CLASS_TYPE_P (basetype))
1172     switch (TREE_CODE (basetype))
1173       {
1174       case INTEGER_TYPE:
1175         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1176           return expr;
1177         /* else fall through...  */
1178
1179       case BOOLEAN_TYPE:
1180         return (desires & WANT_INT) ? expr : NULL_TREE;
1181       case ENUMERAL_TYPE:
1182         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1183       case REAL_TYPE:
1184         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1185       case POINTER_TYPE:
1186         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1187
1188       case FUNCTION_TYPE:
1189       case ARRAY_TYPE:
1190         return (desires & WANT_POINTER) ? decay_conversion (expr)
1191                                         : NULL_TREE;
1192
1193       case COMPLEX_TYPE:
1194       case VECTOR_TYPE:
1195         if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1196           return NULL_TREE;
1197         switch (TREE_CODE (TREE_TYPE (basetype)))
1198           {
1199           case INTEGER_TYPE:
1200           case BOOLEAN_TYPE:
1201             return (desires & WANT_INT) ? expr : NULL_TREE;
1202           case ENUMERAL_TYPE:
1203             return (desires & WANT_ENUM) ? expr : NULL_TREE;
1204           case REAL_TYPE:
1205             return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1206           default:
1207             return NULL_TREE;
1208           }
1209
1210       default:
1211         return NULL_TREE;
1212       }
1213
1214   /* The code for conversions from class type is currently only used for
1215      delete expressions.  Other expressions are handled by build_new_op.  */
1216   if (!complete_type_or_else (basetype, expr))
1217     return error_mark_node;
1218   if (!TYPE_HAS_CONVERSION (basetype))
1219     return NULL_TREE;
1220
1221   for (conv = lookup_conversions (basetype, /*lookup_template_convs_p=*/true);
1222        conv;
1223        conv = TREE_CHAIN (conv))
1224     {
1225       int win = 0;
1226       tree candidate;
1227       tree cand = TREE_VALUE (conv);
1228       cand = OVL_CURRENT (cand);
1229
1230       if (winner && winner == cand)
1231         continue;
1232
1233       if (DECL_NONCONVERTING_P (cand))
1234         continue;
1235
1236       candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
1237
1238       switch (TREE_CODE (candidate))
1239         {
1240         case BOOLEAN_TYPE:
1241         case INTEGER_TYPE:
1242           win = (desires & WANT_INT); break;
1243         case ENUMERAL_TYPE:
1244           win = (desires & WANT_ENUM); break;
1245         case REAL_TYPE:
1246           win = (desires & WANT_FLOAT); break;
1247         case POINTER_TYPE:
1248           win = (desires & WANT_POINTER); break;
1249
1250         case COMPLEX_TYPE:
1251         case VECTOR_TYPE:
1252           if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1253             break;
1254           switch (TREE_CODE (TREE_TYPE (candidate)))
1255             {
1256             case BOOLEAN_TYPE:
1257             case INTEGER_TYPE:
1258               win = (desires & WANT_INT); break;
1259             case ENUMERAL_TYPE:
1260               win = (desires & WANT_ENUM); break;
1261             case REAL_TYPE:
1262               win = (desires & WANT_FLOAT); break;
1263             default:
1264               break;
1265             }
1266           break;
1267
1268         default:
1269           break;
1270         }
1271
1272       if (win)
1273         {
1274           if (winner)
1275             {
1276               if (complain)
1277                 {
1278                   error ("ambiguous default type conversion from %qT",
1279                          basetype);
1280                   error ("  candidate conversions include %qD and %qD",
1281                          winner, cand);
1282                 }
1283               return error_mark_node;
1284             }
1285           else
1286             winner = cand;
1287         }
1288     }
1289
1290   if (winner)
1291     {
1292       tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1293       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1294     }
1295
1296   return NULL_TREE;
1297 }
1298
1299 /* Implements integral promotion (4.1) and float->double promotion.  */
1300
1301 tree
1302 type_promotes_to (tree type)
1303 {
1304   tree promoted_type;
1305
1306   if (type == error_mark_node)
1307     return error_mark_node;
1308
1309   type = TYPE_MAIN_VARIANT (type);
1310
1311   /* Check for promotions of target-defined types first.  */
1312   promoted_type = targetm.promoted_type (type);
1313   if (promoted_type)
1314     return promoted_type;
1315
1316   /* bool always promotes to int (not unsigned), even if it's the same
1317      size.  */
1318   if (TREE_CODE (type) == BOOLEAN_TYPE)
1319     type = integer_type_node;
1320
1321   /* Normally convert enums to int, but convert wide enums to something
1322      wider.  */
1323   else if (TREE_CODE (type) == ENUMERAL_TYPE
1324            || type == char16_type_node
1325            || type == char32_type_node
1326            || type == wchar_type_node)
1327     {
1328       int precision = MAX (TYPE_PRECISION (type),
1329                            TYPE_PRECISION (integer_type_node));
1330       tree totype = c_common_type_for_size (precision, 0);
1331       if (TREE_CODE (type) == ENUMERAL_TYPE)
1332         type = ENUM_UNDERLYING_TYPE (type);
1333       if (TYPE_UNSIGNED (type)
1334           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1335         type = c_common_type_for_size (precision, 1);
1336       else
1337         type = totype;
1338     }
1339   else if (c_promoting_integer_type_p (type))
1340     {
1341       /* Retain unsignedness if really not getting bigger.  */
1342       if (TYPE_UNSIGNED (type)
1343           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1344         type = unsigned_type_node;
1345       else
1346         type = integer_type_node;
1347     }
1348   else if (type == float_type_node)
1349     type = double_type_node;
1350
1351   return type;
1352 }
1353
1354 /* The routines below this point are carefully written to conform to
1355    the standard.  They use the same terminology, and follow the rules
1356    closely.  Although they are used only in pt.c at the moment, they
1357    should presumably be used everywhere in the future.  */
1358
1359 /* Attempt to perform qualification conversions on EXPR to convert it
1360    to TYPE.  Return the resulting expression, or error_mark_node if
1361    the conversion was impossible.  */
1362
1363 tree
1364 perform_qualification_conversions (tree type, tree expr)
1365 {
1366   tree expr_type;
1367
1368   expr_type = TREE_TYPE (expr);
1369
1370   if (same_type_p (type, expr_type))
1371     return expr;
1372   else if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type)
1373            && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type)))
1374     return build_nop (type, expr);
1375   else if (TYPE_PTR_TO_MEMBER_P (type)
1376            && TYPE_PTR_TO_MEMBER_P (expr_type)
1377            && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
1378                            TYPE_PTRMEM_CLASS_TYPE (expr_type))
1379            && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
1380                                TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)))
1381     return build_nop (type, expr);
1382   else
1383     return error_mark_node;
1384 }