OSDN Git Service

b357084b681e2422ff91b9008d6fec407bbf5a18
[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
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   if (expr == error_mark_node
826       || TREE_TYPE (expr) == error_mark_node)
827     return error_mark_node;
828   if (!TREE_TYPE (expr))
829     return expr;
830   if (invalid_nonstatic_memfn_p (expr, complain))
831     return error_mark_node;
832   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
833     {
834       if (complain & tf_error)
835         error ("pseudo-destructor is not called");
836       return error_mark_node;
837     }
838   if (VOID_TYPE_P (TREE_TYPE (expr)))
839     return expr;
840   switch (TREE_CODE (expr))
841     {
842     case COND_EXPR:
843       {
844         /* The two parts of a cond expr might be separate lvalues.  */
845         tree op1 = TREE_OPERAND (expr,1);
846         tree op2 = TREE_OPERAND (expr,2);
847         bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
848         tree new_op1 = convert_to_void
849           (op1, (implicit && !side_effects
850                  ? "second operand of conditional" : NULL), complain);
851         tree new_op2 = convert_to_void
852           (op2, (implicit && !side_effects
853                  ? "third operand of conditional" : NULL), complain);
854
855         expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
856                        TREE_OPERAND (expr, 0), new_op1, new_op2);
857         break;
858       }
859
860     case COMPOUND_EXPR:
861       {
862         /* The second part of a compound expr contains the value.  */
863         tree op1 = TREE_OPERAND (expr,1);
864         tree new_op1 = convert_to_void
865           (op1, (implicit && !TREE_NO_WARNING (expr)
866                  ? "right-hand operand of comma" : NULL), complain);
867
868         if (new_op1 != op1)
869           {
870             tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
871                              TREE_OPERAND (expr, 0), new_op1);
872             expr = t;
873           }
874
875         break;
876       }
877
878     case NON_LVALUE_EXPR:
879     case NOP_EXPR:
880       /* These have already decayed to rvalue.  */
881       break;
882
883     case CALL_EXPR:   /* We have a special meaning for volatile void fn().  */
884       break;
885
886     case INDIRECT_REF:
887       {
888         tree type = TREE_TYPE (expr);
889         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
890                            == REFERENCE_TYPE;
891         int is_volatile = TYPE_VOLATILE (type);
892         int is_complete = COMPLETE_TYPE_P (complete_type (type));
893
894         /* Can't load the value if we don't know the type.  */
895         if (is_volatile && !is_complete)
896           {
897             if (complain & tf_warning)
898               warning (0, "object of incomplete type %qT will not be accessed in %s",
899                        type, implicit ? implicit : "void context");
900           }
901         /* Don't load the value if this is an implicit dereference, or if
902            the type needs to be handled by ctors/dtors.  */
903         else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
904           {
905             if (complain & tf_warning)
906               warning (0, "object of type %qT will not be accessed in %s",
907                        TREE_TYPE (TREE_OPERAND (expr, 0)),
908                        implicit ? implicit : "void context");
909           }
910         if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
911           {
912             /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
913                operation is stripped off. Note that we don't warn about
914                - an expression with TREE_NO_WARNING set. (For an example of
915                  such expressions, see build_over_call in call.c.)
916                - automatic dereferencing of references, since the user cannot
917                  control it. (See also warn_if_unused_value() in stmt.c.)  */
918             if (warn_unused_value
919                 && implicit
920                 && (complain & tf_warning)
921                 && !TREE_NO_WARNING (expr)
922                 && !is_reference)
923               warning (OPT_Wunused_value, "value computed is not used");
924             expr = TREE_OPERAND (expr, 0);
925           }
926
927         break;
928       }
929
930     case VAR_DECL:
931       {
932         /* External variables might be incomplete.  */
933         tree type = TREE_TYPE (expr);
934         int is_complete = COMPLETE_TYPE_P (complete_type (type));
935
936         if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
937           warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
938                    expr, type, implicit ? implicit : "void context");
939         break;
940       }
941
942     case TARGET_EXPR:
943       /* Don't bother with the temporary object returned from a function if
944          we don't use it and don't need to destroy it.  We'll still
945          allocate space for it in expand_call or declare_return_variable,
946          but we don't need to track it through all the tree phases.  */
947       if (TARGET_EXPR_IMPLICIT_P (expr)
948           && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr)))
949         {
950           tree init = TARGET_EXPR_INITIAL (expr);
951           if (TREE_CODE (init) == AGGR_INIT_EXPR
952               && !AGGR_INIT_VIA_CTOR_P (init))
953             {
954               tree fn = AGGR_INIT_EXPR_FN (init);
955               expr = build_call_array_loc (input_location,
956                                            TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
957                                            fn,
958                                            aggr_init_expr_nargs (init),
959                                            AGGR_INIT_EXPR_ARGP (init));
960             }
961         }
962       break;
963
964     default:;
965     }
966   expr = resolve_nondeduced_context (expr);
967   {
968     tree probe = expr;
969
970     if (TREE_CODE (probe) == ADDR_EXPR)
971       probe = TREE_OPERAND (expr, 0);
972     if (type_unknown_p (probe))
973       {
974         /* [over.over] enumerates the places where we can take the address
975            of an overloaded function, and this is not one of them.  */
976         if (complain & tf_error)
977           error ("%s cannot resolve address of overloaded function",
978                  implicit ? implicit : "void cast");
979         else
980           return error_mark_node;
981         expr = void_zero_node;
982       }
983     else if (implicit && probe == expr && is_overloaded_fn (probe))
984       {
985         /* Only warn when there is no &.  */
986         if (complain & tf_warning)
987           warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
988                    implicit, expr);
989         if (TREE_CODE (expr) == COMPONENT_REF)
990           expr = TREE_OPERAND (expr, 0);
991       }
992   }
993
994   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
995     {
996       if (implicit
997           && warn_unused_value
998           && !TREE_NO_WARNING (expr)
999           && !processing_template_decl)
1000         {
1001           /* The middle end does not warn about expressions that have
1002              been explicitly cast to void, so we must do so here.  */
1003           if (!TREE_SIDE_EFFECTS (expr)) {
1004             if (complain & tf_warning)
1005               warning (OPT_Wunused_value, "%s has no effect", implicit);
1006           }
1007           else
1008             {
1009               tree e;
1010               enum tree_code code;
1011               enum tree_code_class tclass;
1012
1013               e = expr;
1014               /* We might like to warn about (say) "(int) f()", as the
1015                  cast has no effect, but the compiler itself will
1016                  generate implicit conversions under some
1017                  circumstances.  (For example a block copy will be
1018                  turned into a call to "__builtin_memcpy", with a
1019                  conversion of the return value to an appropriate
1020                  type.)  So, to avoid false positives, we strip
1021                  conversions.  Do not use STRIP_NOPs because it will
1022                  not strip conversions to "void", as that is not a
1023                  mode-preserving conversion.  */
1024               while (TREE_CODE (e) == NOP_EXPR)
1025                 e = TREE_OPERAND (e, 0);
1026
1027               code = TREE_CODE (e);
1028               tclass = TREE_CODE_CLASS (code);
1029               if ((tclass == tcc_comparison
1030                    || tclass == tcc_unary
1031                    || (tclass == tcc_binary
1032                        && !(code == MODIFY_EXPR
1033                             || code == INIT_EXPR
1034                             || code == PREDECREMENT_EXPR
1035                             || code == PREINCREMENT_EXPR
1036                             || code == POSTDECREMENT_EXPR
1037                             || code == POSTINCREMENT_EXPR)))
1038                   && (complain & tf_warning))
1039                 warning (OPT_Wunused_value, "value computed is not used");
1040             }
1041         }
1042       expr = build1 (CONVERT_EXPR, void_type_node, expr);
1043     }
1044   if (! TREE_SIDE_EFFECTS (expr))
1045     expr = void_zero_node;
1046   return expr;
1047 }
1048
1049 /* Create an expression whose value is that of EXPR,
1050    converted to type TYPE.  The TREE_TYPE of the value
1051    is always TYPE.  This function implements all reasonable
1052    conversions; callers should filter out those that are
1053    not permitted by the language being compiled.
1054
1055    Most of this routine is from build_reinterpret_cast.
1056
1057    The back end cannot call cp_convert (what was convert) because
1058    conversions to/from basetypes may involve memory references
1059    (vbases) and adding or subtracting small values (multiple
1060    inheritance), but it calls convert from the constant folding code
1061    on subtrees of already built trees after it has ripped them apart.
1062
1063    Also, if we ever support range variables, we'll probably also have to
1064    do a little bit more work.  */
1065
1066 tree
1067 convert (tree type, tree expr)
1068 {
1069   tree intype;
1070
1071   if (type == error_mark_node || expr == error_mark_node)
1072     return error_mark_node;
1073
1074   intype = TREE_TYPE (expr);
1075
1076   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
1077     return fold_if_not_in_template (build_nop (type, expr));
1078
1079   return ocp_convert (type, expr, CONV_OLD_CONVERT,
1080                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1081 }
1082
1083 /* Like cp_convert, except permit conversions to take place which
1084    are not normally allowed due to access restrictions
1085    (such as conversion from sub-type to private super-type).  */
1086
1087 tree
1088 convert_force (tree type, tree expr, int convtype)
1089 {
1090   tree e = expr;
1091   enum tree_code code = TREE_CODE (type);
1092
1093   if (code == REFERENCE_TYPE)
1094     return (fold_if_not_in_template
1095             (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1096                                    NULL_TREE)));
1097
1098   if (code == POINTER_TYPE)
1099     return fold_if_not_in_template (convert_to_pointer_force (type, e));
1100
1101   /* From typeck.c convert_for_assignment */
1102   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1103         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1104         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1105        || integer_zerop (e)
1106        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1107       && TYPE_PTRMEMFUNC_P (type))
1108     /* compatible pointer to member functions.  */
1109     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
1110                              /*c_cast_p=*/1);
1111
1112   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1113 }
1114
1115 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1116    exists, return the attempted conversion.  This may
1117    return ERROR_MARK_NODE if the conversion is not
1118    allowed (references private members, etc).
1119    If no conversion exists, NULL_TREE is returned.
1120
1121    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1122    object parameter, or by the second standard conversion sequence if
1123    that doesn't do it.  This will probably wait for an overloading rewrite.
1124    (jason 8/9/95)  */
1125
1126 static tree
1127 build_type_conversion (tree xtype, tree expr)
1128 {
1129   /* C++: check to see if we can convert this aggregate type
1130      into the required type.  */
1131   return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL);
1132 }
1133
1134 /* Convert the given EXPR to one of a group of types suitable for use in an
1135    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1136    which indicates which types are suitable.  If COMPLAIN is true, complain
1137    about ambiguity; otherwise, the caller will deal with it.  */
1138
1139 tree
1140 build_expr_type_conversion (int desires, tree expr, bool complain)
1141 {
1142   tree basetype = TREE_TYPE (expr);
1143   tree conv = NULL_TREE;
1144   tree winner = NULL_TREE;
1145
1146   if (expr == null_node
1147       && (desires & WANT_INT)
1148       && !(desires & WANT_NULL))
1149     warning_at (input_location, OPT_Wconversion_null,
1150                 "converting NULL to non-pointer type");
1151
1152   basetype = TREE_TYPE (expr);
1153
1154   if (basetype == error_mark_node)
1155     return error_mark_node;
1156
1157   if (! MAYBE_CLASS_TYPE_P (basetype))
1158     switch (TREE_CODE (basetype))
1159       {
1160       case INTEGER_TYPE:
1161         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1162           return expr;
1163         /* else fall through...  */
1164
1165       case BOOLEAN_TYPE:
1166         return (desires & WANT_INT) ? expr : NULL_TREE;
1167       case ENUMERAL_TYPE:
1168         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1169       case REAL_TYPE:
1170         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1171       case POINTER_TYPE:
1172         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1173
1174       case FUNCTION_TYPE:
1175       case ARRAY_TYPE:
1176         return (desires & WANT_POINTER) ? decay_conversion (expr)
1177                                         : NULL_TREE;
1178
1179       case COMPLEX_TYPE:
1180       case VECTOR_TYPE:
1181         if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1182           return NULL_TREE;
1183         switch (TREE_CODE (TREE_TYPE (basetype)))
1184           {
1185           case INTEGER_TYPE:
1186           case BOOLEAN_TYPE:
1187             return (desires & WANT_INT) ? expr : NULL_TREE;
1188           case ENUMERAL_TYPE:
1189             return (desires & WANT_ENUM) ? expr : NULL_TREE;
1190           case REAL_TYPE:
1191             return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1192           default:
1193             return NULL_TREE;
1194           }
1195
1196       default:
1197         return NULL_TREE;
1198       }
1199
1200   /* The code for conversions from class type is currently only used for
1201      delete expressions.  Other expressions are handled by build_new_op.  */
1202   if (!complete_type_or_else (basetype, expr))
1203     return error_mark_node;
1204   if (!TYPE_HAS_CONVERSION (basetype))
1205     return NULL_TREE;
1206
1207   for (conv = lookup_conversions (basetype, /*lookup_template_convs_p=*/true);
1208        conv;
1209        conv = TREE_CHAIN (conv))
1210     {
1211       int win = 0;
1212       tree candidate;
1213       tree cand = TREE_VALUE (conv);
1214       cand = OVL_CURRENT (cand);
1215
1216       if (winner && winner == cand)
1217         continue;
1218
1219       if (DECL_NONCONVERTING_P (cand))
1220         continue;
1221
1222       candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
1223
1224       switch (TREE_CODE (candidate))
1225         {
1226         case BOOLEAN_TYPE:
1227         case INTEGER_TYPE:
1228           win = (desires & WANT_INT); break;
1229         case ENUMERAL_TYPE:
1230           win = (desires & WANT_ENUM); break;
1231         case REAL_TYPE:
1232           win = (desires & WANT_FLOAT); break;
1233         case POINTER_TYPE:
1234           win = (desires & WANT_POINTER); break;
1235
1236         case COMPLEX_TYPE:
1237         case VECTOR_TYPE:
1238           if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1239             break;
1240           switch (TREE_CODE (TREE_TYPE (candidate)))
1241             {
1242             case BOOLEAN_TYPE:
1243             case INTEGER_TYPE:
1244               win = (desires & WANT_INT); break;
1245             case ENUMERAL_TYPE:
1246               win = (desires & WANT_ENUM); break;
1247             case REAL_TYPE:
1248               win = (desires & WANT_FLOAT); break;
1249             default:
1250               break;
1251             }
1252           break;
1253
1254         default:
1255           break;
1256         }
1257
1258       if (win)
1259         {
1260           if (winner)
1261             {
1262               if (complain)
1263                 {
1264                   error ("ambiguous default type conversion from %qT",
1265                          basetype);
1266                   error ("  candidate conversions include %qD and %qD",
1267                          winner, cand);
1268                 }
1269               return error_mark_node;
1270             }
1271           else
1272             winner = cand;
1273         }
1274     }
1275
1276   if (winner)
1277     {
1278       tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1279       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1280     }
1281
1282   return NULL_TREE;
1283 }
1284
1285 /* Implements integral promotion (4.1) and float->double promotion.  */
1286
1287 tree
1288 type_promotes_to (tree type)
1289 {
1290   tree promoted_type;
1291
1292   if (type == error_mark_node)
1293     return error_mark_node;
1294
1295   type = TYPE_MAIN_VARIANT (type);
1296
1297   /* Check for promotions of target-defined types first.  */
1298   promoted_type = targetm.promoted_type (type);
1299   if (promoted_type)
1300     return promoted_type;
1301
1302   /* bool always promotes to int (not unsigned), even if it's the same
1303      size.  */
1304   if (TREE_CODE (type) == BOOLEAN_TYPE)
1305     type = integer_type_node;
1306
1307   /* Normally convert enums to int, but convert wide enums to something
1308      wider.  */
1309   else if (TREE_CODE (type) == ENUMERAL_TYPE
1310            || type == char16_type_node
1311            || type == char32_type_node
1312            || type == wchar_type_node)
1313     {
1314       int precision = MAX (TYPE_PRECISION (type),
1315                            TYPE_PRECISION (integer_type_node));
1316       tree totype = c_common_type_for_size (precision, 0);
1317       if (TREE_CODE (type) == ENUMERAL_TYPE)
1318         type = ENUM_UNDERLYING_TYPE (type);
1319       if (TYPE_UNSIGNED (type)
1320           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1321         type = c_common_type_for_size (precision, 1);
1322       else
1323         type = totype;
1324     }
1325   else if (c_promoting_integer_type_p (type))
1326     {
1327       /* Retain unsignedness if really not getting bigger.  */
1328       if (TYPE_UNSIGNED (type)
1329           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1330         type = unsigned_type_node;
1331       else
1332         type = integer_type_node;
1333     }
1334   else if (type == float_type_node)
1335     type = double_type_node;
1336
1337   return type;
1338 }
1339
1340 /* The routines below this point are carefully written to conform to
1341    the standard.  They use the same terminology, and follow the rules
1342    closely.  Although they are used only in pt.c at the moment, they
1343    should presumably be used everywhere in the future.  */
1344
1345 /* Attempt to perform qualification conversions on EXPR to convert it
1346    to TYPE.  Return the resulting expression, or error_mark_node if
1347    the conversion was impossible.  */
1348
1349 tree
1350 perform_qualification_conversions (tree type, tree expr)
1351 {
1352   tree expr_type;
1353
1354   expr_type = TREE_TYPE (expr);
1355
1356   if (same_type_p (type, expr_type))
1357     return expr;
1358   else if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type)
1359            && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type)))
1360     return build_nop (type, expr);
1361   else if (TYPE_PTR_TO_MEMBER_P (type)
1362            && TYPE_PTR_TO_MEMBER_P (expr_type)
1363            && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
1364                            TYPE_PTRMEM_CLASS_TYPE (expr_type))
1365            && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
1366                                TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)))
1367     return build_nop (type, expr);
1368   else
1369     return error_mark_node;
1370 }