OSDN Git Service

2001-11-12 H.J. Lu <hjl@gnu.org>
[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 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
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 "tree.h"
32 #include "flags.h"
33 #include "cp-tree.h"
34 #include "convert.h"
35 #include "toplev.h"
36 #include "decl.h"
37
38 static tree cp_convert_to_pointer PARAMS ((tree, tree, int));
39 static tree convert_to_pointer_force PARAMS ((tree, tree));
40 static tree build_up_reference PARAMS ((tree, tree, int, tree));
41 static void warn_ref_binding PARAMS ((tree, tree, tree));
42
43 /* Change of width--truncation and extension of integers or reals--
44    is represented with NOP_EXPR.  Proper functioning of many things
45    assumes that no other conversions can be NOP_EXPRs.
46
47    Conversion between integer and pointer is represented with CONVERT_EXPR.
48    Converting integer to real uses FLOAT_EXPR
49    and real to integer uses FIX_TRUNC_EXPR.
50
51    Here is a list of all the functions that assume that widening and
52    narrowing is always done with a NOP_EXPR:
53      In convert.c, convert_to_integer.
54      In c-typeck.c, build_binary_op_nodefault (boolean ops),
55         and truthvalue_conversion.
56      In expr.c: expand_expr, for operands of a MULT_EXPR.
57      In fold-const.c: fold.
58      In tree.c: get_narrower and get_unwidened.
59
60    C++: in multiple-inheritance, converting between pointers may involve
61    adjusting them by a delta stored within the class definition.  */
62 \f
63 /* Subroutines of `convert'.  */
64
65 /* if converting pointer to pointer
66      if dealing with classes, check for derived->base or vice versa
67      else if dealing with method pointers, delegate
68      else convert blindly
69    else if converting class, pass off to build_type_conversion
70    else try C-style pointer conversion.  If FORCE is true then allow
71    conversions via virtual bases (these are permitted by reinterpret_cast,
72    but not static_cast).  */
73
74 static tree
75 cp_convert_to_pointer (type, expr, force)
76      tree type, expr;
77      int force;
78 {
79   register tree intype = TREE_TYPE (expr);
80   register enum tree_code form;
81   tree rval;
82
83   if (IS_AGGR_TYPE (intype))
84     {
85       intype = complete_type (intype);
86       if (!COMPLETE_TYPE_P (intype))
87         {
88           cp_error ("can't convert from incomplete type `%T' to `%T'",
89                     intype, type);
90           return error_mark_node;
91         }
92
93       rval = build_type_conversion (type, expr, 1);
94       if (rval)
95         {
96           if (rval == error_mark_node)
97             cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
98                       expr, intype, type);
99           return rval;
100         }
101     }
102
103   /* Handle anachronistic conversions from (::*)() to cv void* or (*)().  */
104   if (TREE_CODE (type) == POINTER_TYPE
105       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
106           || VOID_TYPE_P (TREE_TYPE (type))))
107     {
108       /* Allow an implicit this pointer for pointer to member
109          functions.  */
110       if (TYPE_PTRMEMFUNC_P (intype))
111         {
112           tree fntype = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype));
113           tree decl = maybe_dummy_object (TYPE_METHOD_BASETYPE (fntype), 0);
114           expr = build (OFFSET_REF, fntype, decl, expr);
115         }
116
117       if (TREE_CODE (expr) == OFFSET_REF
118           && TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
119         expr = resolve_offset_ref (expr);
120       if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
121         expr = build_addr_func (expr);
122       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
123         {
124           if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
125             if (pedantic || warn_pmf2ptr)
126               cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
127                           type);
128           return build1 (NOP_EXPR, type, expr);
129         }
130       intype = TREE_TYPE (expr);
131     }
132
133   form = TREE_CODE (intype);
134
135   if (POINTER_TYPE_P (intype))
136     {
137       intype = TYPE_MAIN_VARIANT (intype);
138
139       if (TYPE_MAIN_VARIANT (type) != intype
140           && TREE_CODE (type) == POINTER_TYPE
141           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
142           && IS_AGGR_TYPE (TREE_TYPE (type))
143           && IS_AGGR_TYPE (TREE_TYPE (intype))
144           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
145           /* If EXPR is NULL, then we don't need to do any arithmetic
146              to convert it:
147
148                [conv.ptr]
149
150                The null pointer value is converted to the null pointer
151                value of the destination type.  */
152           && !integer_zerop (expr))
153         {
154           enum tree_code code = PLUS_EXPR;
155           tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
156           if (binfo == error_mark_node)
157             return error_mark_node;
158           if (binfo == NULL_TREE)
159             {
160               binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
161               if (binfo == error_mark_node)
162                 return error_mark_node;
163               code = MINUS_EXPR;
164             }
165           if (binfo)
166             {
167               if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
168                   || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
169                   || ! BINFO_OFFSET_ZEROP (binfo))
170                 {
171                   /* Need to get the path we took.  */
172                   tree path;
173
174                   if (code == PLUS_EXPR)
175                     get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
176                                        0, &path);
177                   else
178                     get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
179                                        0, &path);
180                   return build_vbase_path (code, type, expr, path, 0);
181                 }
182             }
183         }
184
185       if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
186         {
187           tree b1; 
188           tree b2;
189           tree binfo;
190           tree virt_binfo;
191           enum tree_code code;
192
193           b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
194           b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
195           binfo = get_binfo (b2, b1, 1);
196
197           if (binfo == NULL_TREE)
198             {
199               binfo = get_binfo (b1, b2, 1);
200               code = MINUS_EXPR;
201             }
202           else
203             code = PLUS_EXPR;
204
205           if (binfo == error_mark_node)
206             return error_mark_node;
207
208           virt_binfo = binfo_from_vbase (binfo);
209           if (virt_binfo)
210             {
211               if (force)
212                 cp_warning ("pointer to member cast via virtual base `%T' of `%T'",
213                             BINFO_TYPE (virt_binfo),
214                             BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
215               else
216                 {
217                   cp_error ("pointer to member cast via virtual base `%T' of `%T'",
218                             BINFO_TYPE (virt_binfo),
219                             BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
220                   return error_mark_node;
221                 }
222               /* This is a reinterpret cast, whose result is unspecified.
223                  We choose to do nothing.  */
224               return build1 (NOP_EXPR, type, expr);
225             }
226               
227           if (TREE_CODE (expr) == PTRMEM_CST)
228             expr = cplus_expand_constant (expr);
229
230           if (binfo)
231             expr = size_binop (code, convert (sizetype, expr),
232                                BINFO_OFFSET (binfo));
233         }
234       else if (TYPE_PTRMEMFUNC_P (type))
235         {
236           cp_error ("cannot convert `%E' from type `%T' to type `%T'",
237                     expr, intype, type);
238           return error_mark_node;
239         }
240
241       rval = build1 (NOP_EXPR, type, expr);
242       TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
243       return rval;
244     }
245   else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
246     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
247   else if (TYPE_PTRMEMFUNC_P (intype))
248     {
249       cp_error ("cannot convert `%E' from type `%T' to type `%T'",
250                 expr, intype, type);
251       return error_mark_node;
252     }
253
254   my_friendly_assert (form != OFFSET_TYPE, 186);
255
256   if (integer_zerop (expr))
257     {
258       if (TYPE_PTRMEMFUNC_P (type))
259         return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
260
261       if (TYPE_PTRMEM_P (type))
262         /* A NULL pointer-to-member is represented by -1, not by
263            zero.  */
264         expr = build_int_2 (-1, -1);
265       else
266         expr = build_int_2 (0, 0);
267       TREE_TYPE (expr) = type;
268       return expr;
269     }
270
271   if (INTEGRAL_CODE_P (form))
272     {
273       if (TYPE_PRECISION (intype) == POINTER_SIZE)
274         return build1 (CONVERT_EXPR, type, expr);
275       expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr);
276       /* Modes may be different but sizes should be the same.  */
277       if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
278           != GET_MODE_SIZE (TYPE_MODE (type)))
279         /* There is supposed to be some integral type
280            that is the same width as a pointer.  */
281         abort ();
282       return convert_to_pointer (type, expr);
283     }
284
285   if (type_unknown_p (expr))
286     return instantiate_type (type, expr, itf_complain);
287
288   cp_error ("cannot convert `%E' from type `%T' to type `%T'",
289             expr, intype, type);
290   return error_mark_node;
291 }
292
293 /* Like convert, except permit conversions to take place which
294    are not normally allowed due to access restrictions
295    (such as conversion from sub-type to private super-type).  */
296
297 static tree
298 convert_to_pointer_force (type, expr)
299      tree type, expr;
300 {
301   register tree intype = TREE_TYPE (expr);
302   register enum tree_code form = TREE_CODE (intype);
303   
304   if (integer_zerop (expr))
305     {
306       expr = build_int_2 (0, 0);
307       TREE_TYPE (expr) = type;
308       return expr;
309     }
310
311   if (form == POINTER_TYPE)
312     {
313       intype = TYPE_MAIN_VARIANT (intype);
314
315       if (TYPE_MAIN_VARIANT (type) != intype
316           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
317           && IS_AGGR_TYPE (TREE_TYPE (type))
318           && IS_AGGR_TYPE (TREE_TYPE (intype))
319           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
320         {
321           enum tree_code code = PLUS_EXPR;
322           tree path;
323           int distance = get_base_distance (TREE_TYPE (type),
324                                             TREE_TYPE (intype), 0, &path);
325           if (distance == -2)
326             {
327               cp_error ("type `%T' is ambiguous base of `%T'",
328                         TREE_TYPE (type),
329                         TREE_TYPE (intype));
330               return error_mark_node;
331             }
332           if (distance == -1)
333             {
334               distance = get_base_distance (TREE_TYPE (intype),
335                                             TREE_TYPE (type), 0, &path);
336               if (distance == -2)
337                 {
338                   cp_error ("type `%T' is ambiguous base of `%T'",
339                             TREE_TYPE (intype),
340                             TREE_TYPE (type));
341                   return error_mark_node;
342                 }
343               if (distance < 0)
344                 /* Doesn't need any special help from us.  */
345                 return build1 (NOP_EXPR, type, expr);
346
347               code = MINUS_EXPR;
348             }
349           return build_vbase_path (code, type, expr, path, 0);
350         }
351     }
352
353   return cp_convert_to_pointer (type, expr, 1);
354 }
355
356 /* We are passing something to a function which requires a reference.
357    The type we are interested in is in TYPE. The initial
358    value we have to begin with is in ARG.
359
360    FLAGS controls how we manage access checking.
361    DIRECT_BIND in FLAGS controls how any temporaries are generated.
362      If DIRECT_BIND is set, DECL is the reference we're binding to.  */
363
364 static tree
365 build_up_reference (type, arg, flags, decl)
366      tree type, arg, decl;
367      int flags;
368 {
369   tree rval;
370   tree argtype = TREE_TYPE (arg);
371   tree target_type = TREE_TYPE (type);
372   tree stmt_expr = NULL_TREE;
373
374   my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
375
376   if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
377     {
378       /* Create a new temporary variable.  We can't just use a TARGET_EXPR
379          here because it needs to live as long as DECL.  */
380       tree targ = arg;
381
382       arg = build_decl (VAR_DECL, NULL_TREE, argtype);
383       DECL_ARTIFICIAL (arg) = 1;
384       TREE_USED (arg) = 1;
385       TREE_STATIC (arg) = TREE_STATIC (decl);
386
387       if (TREE_STATIC (decl))
388         {
389           /* Namespace-scope or local static; give it a mangled name.  */
390           tree name = mangle_ref_init_variable (decl);
391           DECL_NAME (arg) = name;
392           SET_DECL_ASSEMBLER_NAME (arg, name);
393           arg = pushdecl_top_level (arg);
394         }
395       else
396         {
397           /* Automatic; make sure we handle the cleanup properly.  */
398           maybe_push_cleanup_level (argtype);
399           arg = pushdecl (arg);
400         }
401
402       /* Process the initializer for the declaration.  */
403       DECL_INITIAL (arg) = targ;
404       cp_finish_decl (arg, targ, NULL_TREE, 
405                       LOOKUP_ONLYCONVERTING|DIRECT_BIND);
406     }
407   else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
408     return get_target_expr (arg);
409
410   /* If we had a way to wrap this up, and say, if we ever needed its
411      address, transform all occurrences of the register, into a memory
412      reference we could win better.  */
413   rval = build_unary_op (ADDR_EXPR, arg, 1);
414   if (rval == error_mark_node)
415     return error_mark_node;
416
417   if ((flags & LOOKUP_PROTECT)
418       && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
419       && IS_AGGR_TYPE (argtype)
420       && IS_AGGR_TYPE (target_type))
421     {
422       /* We go through get_binfo for the access control.  */
423       tree binfo = get_binfo (target_type, argtype, 1);
424       if (binfo == error_mark_node)
425         return error_mark_node;
426       if (binfo == NULL_TREE)
427         return error_not_base_type (target_type, argtype);
428       rval = convert_pointer_to_real (binfo, rval);
429     }
430   else
431     rval
432       = convert_to_pointer_force (build_pointer_type (target_type), rval);
433   rval = build1 (NOP_EXPR, type, rval);
434   TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
435
436   /* If we created and initialized a new temporary variable, add the
437      representation of that initialization to the RVAL.  */
438   if (stmt_expr)
439     rval = build (COMPOUND_EXPR, TREE_TYPE (rval), stmt_expr, rval);
440
441   /* And return the result.  */
442   return rval;
443 }
444
445 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
446    INTYPE is the original rvalue type and DECL is an optional _DECL node
447    for diagnostics.
448    
449    [dcl.init.ref] says that if an rvalue is used to
450    initialize a reference, then the reference must be to a
451    non-volatile const type.  */
452
453 static void
454 warn_ref_binding (reftype, intype, decl)
455      tree reftype, intype, decl;
456 {
457   tree ttl = TREE_TYPE (reftype);
458   
459   if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl))
460     {
461       const char *msg;
462
463       if (CP_TYPE_VOLATILE_P (ttl) && decl)
464           msg = "initialization of volatile reference type `%#T' from rvalue of type `%T'";
465       else if (CP_TYPE_VOLATILE_P (ttl))
466           msg = "conversion to volatile reference type `%#T' from rvalue of type `%T'";
467       else if (decl)
468           msg = "initialization of non-const reference type `%#T' from rvalue of type `%T'";
469       else
470           msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'";
471
472       cp_pedwarn (msg, reftype, intype);
473     }
474 }
475
476 /* For C++: Only need to do one-level references, but cannot
477    get tripped up on signed/unsigned differences.
478
479    DECL is either NULL_TREE or the _DECL node for a reference that is being
480    initialized.  It can be error_mark_node if we don't know the _DECL but
481    we know it's an initialization.  */
482
483 tree
484 convert_to_reference (reftype, expr, convtype, flags, decl)
485      tree reftype, expr;
486      int convtype, flags;
487      tree decl;
488 {
489   register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
490   register tree intype = TREE_TYPE (expr);
491   tree rval = NULL_TREE;
492   tree rval_as_conversion = NULL_TREE;
493   int i;
494
495   if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
496     {
497       expr = instantiate_type (type, expr, 
498                                (flags & LOOKUP_COMPLAIN)
499                                ? itf_complain : itf_none);
500       if (expr == error_mark_node)
501         return error_mark_node;
502
503       intype = TREE_TYPE (expr);
504     }
505
506   if (TREE_CODE (intype) == REFERENCE_TYPE)
507     my_friendly_abort (364);
508
509   intype = TYPE_MAIN_VARIANT (intype);
510
511   i = comp_target_types (type, intype, 0);
512
513   if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
514       && ! (flags & LOOKUP_NO_CONVERSION))
515     {
516       /* Look for a user-defined conversion to lvalue that we can use.  */
517
518       rval_as_conversion
519         = build_type_conversion (reftype, expr, 1);
520
521       if (rval_as_conversion && rval_as_conversion != error_mark_node
522           && real_lvalue_p (rval_as_conversion))
523         {
524           expr = rval_as_conversion;
525           rval_as_conversion = NULL_TREE;
526           intype = type;
527           i = 1;
528         }
529     }
530
531   if (((convtype & CONV_STATIC) && i == -1)
532       || ((convtype & CONV_IMPLICIT) && i == 1))
533     {
534       if (flags & LOOKUP_COMPLAIN)
535         {
536           tree ttl = TREE_TYPE (reftype);
537           tree ttr = lvalue_type (expr);
538
539           if (! real_lvalue_p (expr))
540             warn_ref_binding (reftype, intype, decl);
541           
542           if (! (convtype & CONV_CONST)
543                    && !at_least_as_qualified_p (ttl, ttr))
544             cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
545                         ttr, reftype);
546         }
547
548       return build_up_reference (reftype, expr, flags, decl);
549     }
550   else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
551     {
552       /* When casting an lvalue to a reference type, just convert into
553          a pointer to the new type and deference it.  This is allowed
554          by San Diego WP section 5.2.9 paragraph 12, though perhaps it
555          should be done directly (jason).  (int &)ri ---> *(int*)&ri */
556
557       /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
558          meant.  */
559       if (TREE_CODE (intype) == POINTER_TYPE
560           && (comptypes (TREE_TYPE (intype), type, 
561                          COMPARE_BASE | COMPARE_RELAXED )))
562         cp_warning ("casting `%T' to `%T' does not dereference pointer",
563                     intype, reftype);
564           
565       rval = build_unary_op (ADDR_EXPR, expr, 0);
566       if (rval != error_mark_node)
567         rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
568                               rval, 0);
569       if (rval != error_mark_node)
570         rval = build1 (NOP_EXPR, reftype, rval);
571     }
572   else
573     {
574       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
575                                          "converting", 0, 0);
576       if (rval == NULL_TREE || rval == error_mark_node)
577         return rval;
578       warn_ref_binding (reftype, intype, decl);
579       rval = build_up_reference (reftype, rval, flags, decl);
580     }
581
582   if (rval)
583     {
584       /* If we found a way to convert earlier, then use it.  */
585       return rval;
586     }
587
588   my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
589
590   if (flags & LOOKUP_COMPLAIN)
591     cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
592
593   if (flags & LOOKUP_SPECULATIVELY)
594     return NULL_TREE;
595
596   return error_mark_node;
597 }
598
599 /* We are using a reference VAL for its value. Bash that reference all the
600    way down to its lowest form.  */
601
602 tree
603 convert_from_reference (val)
604      tree val;
605 {
606   tree type = TREE_TYPE (val);
607
608   if (TREE_CODE (type) == OFFSET_TYPE)
609     type = TREE_TYPE (type);
610   if (TREE_CODE (type) == REFERENCE_TYPE)
611     return build_indirect_ref (val, NULL);
612   return val;
613 }
614
615 /* Implicitly convert the lvalue EXPR to another lvalue of type TOTYPE,
616    preserving cv-qualification.  */
617
618 tree
619 convert_lvalue (totype, expr)
620      tree totype, expr;
621 {
622   totype = cp_build_qualified_type (totype, TYPE_QUALS (TREE_TYPE (expr)));
623   totype = build_reference_type (totype);
624   expr = convert_to_reference (totype, expr, CONV_IMPLICIT, LOOKUP_NORMAL,
625                                NULL_TREE);
626   return convert_from_reference (expr);
627 }
628 \f
629 /* Call this when we know (for any reason) that expr is not, in fact,
630    zero.  This routine is like convert_pointer_to, but it pays
631    attention to which specific instance of what type we want to
632    convert to.  This routine should eventually become
633    convert_to_pointer after all references to convert_to_pointer
634    are removed.  */
635
636 tree
637 convert_pointer_to_real (binfo, expr)
638      tree binfo, expr;
639 {
640   register tree intype = TREE_TYPE (expr);
641   tree ptr_type;
642   tree type, rval;
643
644   if (intype == error_mark_node)
645     return error_mark_node;
646
647   if (TREE_CODE (binfo) == TREE_VEC)
648     type = BINFO_TYPE (binfo);
649   else if (IS_AGGR_TYPE (binfo))
650     {
651       type = binfo;
652     }
653   else
654     {
655       type = binfo;
656       binfo = NULL_TREE;
657     }
658
659   ptr_type = cp_build_qualified_type (type,
660                                       CP_TYPE_QUALS (TREE_TYPE (intype)));
661   ptr_type = build_pointer_type (ptr_type);
662   if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
663     return expr;
664
665   my_friendly_assert (!integer_zerop (expr), 191);
666
667   intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
668   if (TREE_CODE (type) == RECORD_TYPE
669       && TREE_CODE (intype) == RECORD_TYPE
670       && type != intype)
671     {
672       tree path;
673       int distance
674         = get_base_distance (binfo, intype, 0, &path);
675
676       /* This function shouldn't be called with unqualified arguments
677          but if it is, give them an error message that they can read.  */
678       if (distance < 0)
679         {
680           cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
681                     intype, type);
682
683           if (distance == -2)
684             cp_error ("because `%T' is an ambiguous base class", type);
685           return error_mark_node;
686         }
687
688       return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
689     }
690   rval = build1 (NOP_EXPR, ptr_type,
691                  TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
692   TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
693   return rval;
694 }
695
696 /* Call this when we know (for any reason) that expr is
697    not, in fact, zero.  This routine gets a type out of the first
698    argument and uses it to search for the type to convert to.  If there
699    is more than one instance of that type in the expr, the conversion is
700    ambiguous.  This routine should eventually go away, and all
701    callers should use convert_to_pointer_real.  */
702
703 tree
704 convert_pointer_to (binfo, expr)
705      tree binfo, expr;
706 {
707   return convert_pointer_to_real (binfo, expr);
708 }
709 \f
710 /* C++ conversions, preference to static cast conversions.  */
711
712 tree
713 cp_convert (type, expr)
714      tree type, expr;
715 {
716   return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
717 }
718
719 /* Conversion...
720
721    FLAGS indicates how we should behave.  */
722
723 tree
724 ocp_convert (type, expr, convtype, flags)
725      tree type, expr;
726      int convtype, flags;
727 {
728   register tree e = expr;
729   register enum tree_code code = TREE_CODE (type);
730
731   if (e == error_mark_node
732       || TREE_TYPE (e) == error_mark_node)
733     return error_mark_node;
734
735   complete_type (type);
736   complete_type (TREE_TYPE (expr));
737
738   e = decl_constant_value (e);
739
740   if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
741       /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
742          don't go through finish_struct, so they don't have the synthesized
743          constructors.  So don't force a temporary.  */
744       && TYPE_HAS_CONSTRUCTOR (type))
745     /* We need a new temporary; don't take this shortcut.  */;
746   else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
747     {
748       if (same_type_p (type, TREE_TYPE (e)))
749         /* The call to fold will not always remove the NOP_EXPR as
750            might be expected, since if one of the types is a typedef;
751            the comparsion in fold is just equality of pointers, not a
752            call to comptypes.  We don't call fold in this case because
753            that can result in infinite recursion; fold will call
754            convert, which will call ocp_convert, etc.  */
755         return e;
756       /* For complex data types, we need to perform componentwise
757          conversion.  */
758       else if (TREE_CODE (type) == COMPLEX_TYPE)
759         return fold (convert_to_complex (type, e));
760       else
761         return fold (build1 (NOP_EXPR, type, e));
762     }
763
764   if (code == VOID_TYPE && (convtype & CONV_STATIC))
765     {
766       e = convert_to_void (e, /*implicit=*/NULL);
767       return e;
768     }
769
770   /* Just convert to the type of the member.  */
771   if (code == OFFSET_TYPE)
772     {
773       type = TREE_TYPE (type);
774       code = TREE_CODE (type);
775     }
776
777   if (TREE_CODE (e) == OFFSET_REF)
778     e = resolve_offset_ref (e);
779
780   if (INTEGRAL_CODE_P (code))
781     {
782       tree intype = TREE_TYPE (e);
783       /* enum = enum, enum = int, enum = float, (enum)pointer are all
784          errors.  */
785       if (TREE_CODE (type) == ENUMERAL_TYPE
786           && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
787               || (TREE_CODE (intype) == POINTER_TYPE)))
788         {
789           cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
790
791           if (flag_pedantic_errors)
792             return error_mark_node;
793         }
794       if (IS_AGGR_TYPE (intype))
795         {
796           tree rval;
797           rval = build_type_conversion (type, e, 1);
798           if (rval)
799             return rval;
800           if (flags & LOOKUP_COMPLAIN)
801             cp_error ("`%#T' used where a `%T' was expected", intype, type);
802           if (flags & LOOKUP_SPECULATIVELY)
803             return NULL_TREE;
804           return error_mark_node;
805         }
806       if (code == BOOLEAN_TYPE)
807         {
808           tree fn = NULL_TREE;
809
810           /* Common Ada/Pascal programmer's mistake.  We always warn
811              about this since it is so bad.  */
812           if (TREE_CODE (expr) == FUNCTION_DECL)
813             fn = expr;
814           else if (TREE_CODE (expr) == ADDR_EXPR 
815                    && TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL)
816             fn = TREE_OPERAND (expr, 0);
817           if (fn && !DECL_WEAK (fn))
818             cp_warning ("the address of `%D', will always be `true'", fn);
819           return cp_truthvalue_conversion (e);
820         }
821       return fold (convert_to_integer (type, e));
822     }
823   if (code == POINTER_TYPE || code == REFERENCE_TYPE
824       || TYPE_PTRMEMFUNC_P (type))
825     return fold (cp_convert_to_pointer (type, e, 0));
826   if (code == VECTOR_TYPE)
827     return fold (convert_to_vector (type, e));
828   if (code == REAL_TYPE || code == COMPLEX_TYPE)
829     {
830       if (IS_AGGR_TYPE (TREE_TYPE (e)))
831         {
832           tree rval;
833           rval = build_type_conversion (type, e, 1);
834           if (rval)
835             return rval;
836           else
837             if (flags & LOOKUP_COMPLAIN)
838               cp_error ("`%#T' used where a floating point value was expected",
839                         TREE_TYPE (e));
840         }
841       if (code == REAL_TYPE)
842         return fold (convert_to_real (type, e));
843       else if (code == COMPLEX_TYPE)
844         return fold (convert_to_complex (type, e));
845     }
846
847   /* New C++ semantics:  since assignment is now based on
848      memberwise copying,  if the rhs type is derived from the
849      lhs type, then we may still do a conversion.  */
850   if (IS_AGGR_TYPE_CODE (code))
851     {
852       tree dtype = TREE_TYPE (e);
853       tree ctor = NULL_TREE;
854
855       dtype = TYPE_MAIN_VARIANT (dtype);
856
857       /* Conversion between aggregate types.  New C++ semantics allow
858          objects of derived type to be cast to objects of base type.
859          Old semantics only allowed this between pointers.
860
861          There may be some ambiguity between using a constructor
862          vs. using a type conversion operator when both apply.  */
863
864       ctor = e;
865
866       if (abstract_virtuals_error (NULL_TREE, type))
867         return error_mark_node;
868
869       if ((flags & LOOKUP_ONLYCONVERTING)
870           && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
871         /* For copy-initialization, first we create a temp of the proper type
872            with a user-defined conversion sequence, then we direct-initialize
873            the target with the temp (see [dcl.init]).  */
874         ctor = build_user_type_conversion (type, ctor, flags);
875       else
876         ctor = build_method_call (NULL_TREE, 
877                                   complete_ctor_identifier,
878                                   build_tree_list (NULL_TREE, ctor),
879                                   TYPE_BINFO (type), flags);
880       if (ctor)
881         return build_cplus_new (type, ctor);
882     }
883
884   /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
885      then it won't be hashed and hence compare as not equal,
886      even when it is.  */
887   if (code == ARRAY_TYPE
888       && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
889       && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
890     return e;
891
892   if (flags & LOOKUP_COMPLAIN)
893     cp_error ("conversion from `%T' to non-scalar type `%T' requested",
894               TREE_TYPE (expr), type);
895   if (flags & LOOKUP_SPECULATIVELY)
896     return NULL_TREE;
897   return error_mark_node;
898 }
899
900 /* When an expression is used in a void context, its value is discarded and
901    no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
902    stmt.expr/1, expr.comma/1].  This permits dereferencing an incomplete type
903    in a void context. The C++ standard does not define what an `access' to an
904    object is, but there is reason to beleive that it is the lvalue to rvalue
905    conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
906    accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
907    indicates that volatile semantics should be the same between C and C++
908    where ever possible. C leaves it implementation defined as to what
909    constitutes an access to a volatile. So, we interpret `*vp' as a read of
910    the volatile object `vp' points to, unless that is an incomplete type. For
911    volatile references we do not do this interpretation, because that would
912    make it impossible to ignore the reference return value from functions. We
913    issue warnings in the confusing cases.
914    
915    IMPLICIT is tells us the context of an implicit void conversion.  */
916
917 tree
918 convert_to_void (expr, implicit)
919      tree expr;
920      const char *implicit;
921 {
922   if (expr == error_mark_node 
923       || TREE_TYPE (expr) == error_mark_node)
924     return error_mark_node;
925   if (!TREE_TYPE (expr))
926     return expr;
927   if (VOID_TYPE_P (TREE_TYPE (expr)))
928     return expr;
929   switch (TREE_CODE (expr))
930     {
931     case COND_EXPR:
932       {
933         /* The two parts of a cond expr might be separate lvalues.  */
934         tree op1 = TREE_OPERAND (expr,1);
935         tree op2 = TREE_OPERAND (expr,2);
936         tree new_op1 = convert_to_void (op1, implicit);
937         tree new_op2 = convert_to_void (op2, implicit);
938         
939         if (new_op1 != op1 || new_op2 != op2)
940           expr = build (COND_EXPR,
941                         implicit ? TREE_TYPE (expr) : void_type_node,
942                         TREE_OPERAND (expr, 0), new_op1, new_op2);
943         break;
944       }
945     
946     case COMPOUND_EXPR:
947       {
948         /* The second part of a compound expr contains the value.  */
949         tree op1 = TREE_OPERAND (expr,1);
950         tree new_op1 = convert_to_void (op1, implicit);
951         
952         if (new_op1 != op1)
953           {
954             tree t = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
955                             TREE_OPERAND (expr, 0), new_op1);
956             TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
957             expr = t;
958           }
959
960         break;
961       }
962     
963     case NON_LVALUE_EXPR:
964     case NOP_EXPR:
965       /* These have already decayed to rvalue. */
966       break;
967     
968     case CALL_EXPR:   /* we have a special meaning for volatile void fn() */
969       break;
970     
971     case INDIRECT_REF:
972       {
973         tree type = TREE_TYPE (expr);
974         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
975                            == REFERENCE_TYPE;
976         int is_volatile = TYPE_VOLATILE (type);
977         int is_complete = COMPLETE_TYPE_P (complete_type (type));
978         
979         if (is_volatile && !is_complete)
980           cp_warning ("object of incomplete type `%T' will not be accessed in %s",
981                       type, implicit ? implicit : "void context");
982         else if (is_reference && is_volatile)
983           cp_warning ("object of type `%T' will not be accessed in %s",
984                       TREE_TYPE (TREE_OPERAND (expr, 0)),
985                       implicit ? implicit : "void context");
986         if (is_reference || !is_volatile || !is_complete)
987           expr = TREE_OPERAND (expr, 0);
988       
989         break;
990       }
991     
992     case VAR_DECL:
993       {
994         /* External variables might be incomplete.  */
995         tree type = TREE_TYPE (expr);
996         int is_complete = COMPLETE_TYPE_P (complete_type (type));
997         
998         if (TYPE_VOLATILE (type) && !is_complete)
999           cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
1000                       expr, type, implicit ? implicit : "void context");
1001         break;
1002       }
1003
1004     case OFFSET_REF:
1005       expr = resolve_offset_ref (expr);
1006       break;
1007
1008     default:;
1009     }
1010   {
1011     tree probe = expr;
1012   
1013     if (TREE_CODE (probe) == ADDR_EXPR)
1014       probe = TREE_OPERAND (expr, 0);
1015     if (type_unknown_p (probe))
1016       {
1017         /* [over.over] enumerates the places where we can take the address
1018            of an overloaded function, and this is not one of them.  */
1019         cp_pedwarn ("%s cannot resolve address of overloaded function",
1020                     implicit ? implicit : "void cast");
1021       }
1022     else if (implicit && probe == expr && is_overloaded_fn (probe))
1023       /* Only warn when there is no &.  */
1024       cp_warning ("%s is a reference, not call, to function `%E'",
1025                   implicit, expr);
1026   }
1027   
1028   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
1029     {
1030       /* FIXME: This is where we should check for expressions with no
1031          effects.  At the moment we do that in both build_x_component_expr
1032          and expand_expr_stmt -- inconsistently too.  For the moment
1033          leave implicit void conversions unadorned so that expand_expr_stmt
1034          has a chance of detecting some of the cases.  */
1035       if (!implicit)
1036         expr = build1 (CONVERT_EXPR, void_type_node, expr);
1037     }
1038   return expr;
1039 }
1040
1041 /* Create an expression whose value is that of EXPR,
1042    converted to type TYPE.  The TREE_TYPE of the value
1043    is always TYPE.  This function implements all reasonable
1044    conversions; callers should filter out those that are
1045    not permitted by the language being compiled.
1046
1047    Most of this routine is from build_reinterpret_cast.
1048
1049    The backend cannot call cp_convert (what was convert) because
1050    conversions to/from basetypes may involve memory references
1051    (vbases) and adding or subtracting small values (multiple
1052    inheritance), but it calls convert from the constant folding code
1053    on subtrees of already built trees after it has ripped them apart.
1054
1055    Also, if we ever support range variables, we'll probably also have to
1056    do a little bit more work.  */
1057
1058 tree
1059 convert (type, expr)
1060      tree type, expr;
1061 {
1062   tree intype;
1063
1064   if (type == error_mark_node || expr == error_mark_node)
1065     return error_mark_node;
1066
1067   intype = TREE_TYPE (expr);
1068
1069   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
1070     {
1071       expr = decl_constant_value (expr);
1072       return fold (build1 (NOP_EXPR, type, expr));
1073     }
1074
1075   return ocp_convert (type, expr, CONV_OLD_CONVERT,
1076                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1077 }
1078
1079 /* Like cp_convert, except permit conversions to take place which
1080    are not normally allowed due to access restrictions
1081    (such as conversion from sub-type to private super-type).  */
1082
1083 tree
1084 convert_force (type, expr, convtype)
1085      tree type;
1086      tree expr;
1087      int convtype;
1088 {
1089   register tree e = expr;
1090   register enum tree_code code = TREE_CODE (type);
1091
1092   if (code == REFERENCE_TYPE)
1093     return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1094                                        NULL_TREE));
1095   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1096     e = convert_from_reference (e);
1097
1098   if (code == POINTER_TYPE)
1099     return fold (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     {
1109       /* compatible pointer to member functions.  */
1110       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1111     }
1112
1113   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1114 }
1115
1116 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1117    exists, return the attempted conversion.  This may
1118    return ERROR_MARK_NODE if the conversion is not
1119    allowed (references private members, etc).
1120    If no conversion exists, NULL_TREE is returned.
1121
1122    If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1123    to take place immediately.  Otherwise, we build a SAVE_EXPR
1124    which can be evaluated if the results are ever needed.
1125
1126    Changes to this functions should be mirrored in user_harshness.
1127
1128    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1129    object parameter, or by the second standard conversion sequence if
1130    that doesn't do it.  This will probably wait for an overloading rewrite.
1131    (jason 8/9/95)  */
1132
1133 tree
1134 build_type_conversion (xtype, expr, for_sure)
1135      tree xtype, expr;
1136      int for_sure;
1137 {
1138   /* C++: check to see if we can convert this aggregate type
1139      into the required type.  */
1140   return build_user_type_conversion
1141     (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
1142 }
1143
1144 /* Convert the given EXPR to one of a group of types suitable for use in an
1145    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1146    which indicates which types are suitable.  If COMPLAIN is 1, complain
1147    about ambiguity; otherwise, the caller will deal with it.  */
1148
1149 tree
1150 build_expr_type_conversion (desires, expr, complain)
1151      int desires;
1152      tree expr;
1153      int complain;
1154 {
1155   tree basetype = TREE_TYPE (expr);
1156   tree conv = NULL_TREE;
1157   tree winner = NULL_TREE;
1158
1159   if (expr == null_node 
1160       && (desires & WANT_INT) 
1161       && !(desires & WANT_NULL))
1162     cp_warning ("converting NULL to non-pointer type");
1163     
1164   if (TREE_CODE (expr) == OFFSET_REF)
1165     expr = resolve_offset_ref (expr);
1166   expr = convert_from_reference (expr);
1167   basetype = TREE_TYPE (expr);
1168
1169   if (basetype == error_mark_node)
1170     return error_mark_node;
1171
1172   if (! IS_AGGR_TYPE (basetype))
1173     switch (TREE_CODE (basetype))
1174       {
1175       case INTEGER_TYPE:
1176         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1177           return expr;
1178         /* else fall through...  */
1179
1180       case BOOLEAN_TYPE:
1181         return (desires & WANT_INT) ? expr : NULL_TREE;
1182       case ENUMERAL_TYPE:
1183         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1184       case REAL_TYPE:
1185         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1186       case POINTER_TYPE:
1187         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1188         
1189       case FUNCTION_TYPE:
1190       case ARRAY_TYPE:
1191         return (desires & WANT_POINTER) ? default_conversion (expr)
1192                                         : NULL_TREE;
1193       default:
1194         return NULL_TREE;
1195       }
1196
1197   /* The code for conversions from class type is currently only used for
1198      delete expressions.  Other expressions are handled by build_new_op.  */
1199
1200   if (! TYPE_HAS_CONVERSION (basetype))
1201     return NULL_TREE;
1202
1203   for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1204     {
1205       int win = 0;
1206       tree candidate;
1207       tree cand = TREE_VALUE (conv);
1208
1209       if (winner && winner == cand)
1210         continue;
1211
1212       candidate = TREE_TYPE (TREE_TYPE (cand));
1213       if (TREE_CODE (candidate) == REFERENCE_TYPE)
1214         candidate = TREE_TYPE (candidate);
1215
1216       switch (TREE_CODE (candidate))
1217         {
1218         case BOOLEAN_TYPE:
1219         case INTEGER_TYPE:
1220           win = (desires & WANT_INT); break;
1221         case ENUMERAL_TYPE:
1222           win = (desires & WANT_ENUM); break;
1223         case REAL_TYPE:
1224           win = (desires & WANT_FLOAT); break;
1225         case POINTER_TYPE:
1226           win = (desires & WANT_POINTER); break;
1227
1228         default:
1229           break;
1230         }
1231
1232       if (win)
1233         {
1234           if (winner)
1235             {
1236               if (complain)
1237                 {
1238                   cp_error ("ambiguous default type conversion from `%T'",
1239                             basetype);
1240                   cp_error ("  candidate conversions include `%D' and `%D'",
1241                             winner, cand);
1242                 }
1243               return error_mark_node;
1244             }
1245           else
1246             winner = cand;
1247         }
1248     }
1249
1250   if (winner)
1251     {
1252       tree type = TREE_TYPE (TREE_TYPE (winner));
1253       if (TREE_CODE (type) == REFERENCE_TYPE)
1254         type = TREE_TYPE (type);
1255       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1256     }
1257
1258   return NULL_TREE;
1259 }
1260
1261 /* Implements integral promotion (4.1) and float->double promotion.  */
1262
1263 tree
1264 type_promotes_to (type)
1265      tree type;
1266 {
1267   int type_quals;
1268
1269   if (type == error_mark_node)
1270     return error_mark_node;
1271
1272   type_quals = CP_TYPE_QUALS (type);
1273   type = TYPE_MAIN_VARIANT (type);
1274
1275   /* bool always promotes to int (not unsigned), even if it's the same
1276      size.  */
1277   if (type == boolean_type_node)
1278     type = integer_type_node;
1279
1280   /* Normally convert enums to int, but convert wide enums to something
1281      wider.  */
1282   else if (TREE_CODE (type) == ENUMERAL_TYPE
1283            || type == wchar_type_node)
1284     {
1285       int precision = MAX (TYPE_PRECISION (type),
1286                            TYPE_PRECISION (integer_type_node));
1287       tree totype = type_for_size (precision, 0);
1288       if (TREE_UNSIGNED (type)
1289           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1290         type = type_for_size (precision, 1);
1291       else
1292         type = totype;
1293     }
1294   else if (c_promoting_integer_type_p (type))
1295     {
1296       /* Retain unsignedness if really not getting bigger.  */
1297       if (TREE_UNSIGNED (type)
1298           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1299         type = unsigned_type_node;
1300       else
1301         type = integer_type_node;
1302     }
1303   else if (type == float_type_node)
1304     type = double_type_node;
1305
1306   return cp_build_qualified_type (type, type_quals);
1307 }
1308
1309 /* The routines below this point are carefully written to conform to
1310    the standard.  They use the same terminology, and follow the rules
1311    closely.  Although they are used only in pt.c at the moment, they
1312    should presumably be used everywhere in the future.  */
1313
1314 /* Attempt to perform qualification conversions on EXPR to convert it
1315    to TYPE.  Return the resulting expression, or error_mark_node if
1316    the conversion was impossible.  */
1317
1318 tree 
1319 perform_qualification_conversions (type, expr)
1320      tree type;
1321      tree expr;
1322 {
1323   if (TREE_CODE (type) == POINTER_TYPE
1324       && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1325       && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1326     return build1 (NOP_EXPR, type, expr);
1327   else
1328     return error_mark_node;
1329 }