OSDN Git Service

* class.c (layout_class_type): Do not issue C++ ABI warnings
[pf3gnuchains/gcc-fork.git] / gcc / cp / typeck.c
1 /* Build expressions with type checking for C++ compiler.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC 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 GCC 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 GCC; 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 is part of the C++ front end.
25    It contains routines to build C++ expressions given their operands,
26    including computing the types of the result, C and C++ specific error
27    checks, and some optimization.  */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include "tree.h"
34 #include "rtl.h"
35 #include "expr.h"
36 #include "cp-tree.h"
37 #include "tm_p.h"
38 #include "flags.h"
39 #include "output.h"
40 #include "toplev.h"
41 #include "diagnostic.h"
42 #include "target.h"
43 #include "convert.h"
44 #include "c-common.h"
45
46 static tree convert_for_assignment (tree, tree, const char *, tree, int);
47 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
48 static tree rationalize_conditional_expr (enum tree_code, tree);
49 static int comp_ptr_ttypes_real (tree, tree, int);
50 static int comp_ptr_ttypes_const (tree, tree);
51 static bool comp_except_types (tree, tree, bool);
52 static bool comp_array_types (tree, tree, bool);
53 static tree common_base_type (tree, tree);
54 static tree pointer_diff (tree, tree, tree);
55 static tree get_delta_difference (tree, tree, bool, bool);
56 static void casts_away_constness_r (tree *, tree *);
57 static bool casts_away_constness (tree, tree);
58 static void maybe_warn_about_returning_address_of_local (tree);
59 static tree lookup_destructor (tree, tree, tree);
60 static tree convert_arguments (tree, tree, tree, int);
61
62 /* Do `exp = require_complete_type (exp);' to make sure exp
63    does not have an incomplete type.  (That includes void types.)
64    Returns the error_mark_node if the VALUE does not have
65    complete type when this function returns.  */
66
67 tree
68 require_complete_type (tree value)
69 {
70   tree type;
71
72   if (processing_template_decl || value == error_mark_node)
73     return value;
74
75   if (TREE_CODE (value) == OVERLOAD)
76     type = unknown_type_node;
77   else
78     type = TREE_TYPE (value);
79
80   if (type == error_mark_node)
81     return error_mark_node;
82
83   /* First, detect a valid value with a complete type.  */
84   if (COMPLETE_TYPE_P (type))
85     return value;
86
87   if (complete_type_or_else (type, value))
88     return value;
89   else
90     return error_mark_node;
91 }
92
93 /* Try to complete TYPE, if it is incomplete.  For example, if TYPE is
94    a template instantiation, do the instantiation.  Returns TYPE,
95    whether or not it could be completed, unless something goes
96    horribly wrong, in which case the error_mark_node is returned.  */
97
98 tree
99 complete_type (tree type)
100 {
101   if (type == NULL_TREE)
102     /* Rather than crash, we return something sure to cause an error
103        at some point.  */
104     return error_mark_node;
105
106   if (type == error_mark_node || COMPLETE_TYPE_P (type))
107     ;
108   else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
109     {
110       tree t = complete_type (TREE_TYPE (type));
111       if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
112         layout_type (type);
113       TYPE_NEEDS_CONSTRUCTING (type)
114         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
115       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
116         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
117     }
118   else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
119     instantiate_class_template (TYPE_MAIN_VARIANT (type));
120
121   return type;
122 }
123
124 /* Like complete_type, but issue an error if the TYPE cannot be completed.
125    VALUE is used for informative diagnostics.
126    Returns NULL_TREE if the type cannot be made complete.  */
127
128 tree
129 complete_type_or_else (tree type, tree value)
130 {
131   type = complete_type (type);
132   if (type == error_mark_node)
133     /* We already issued an error.  */
134     return NULL_TREE;
135   else if (!COMPLETE_TYPE_P (type))
136     {
137       cxx_incomplete_type_diagnostic (value, type, 0);
138       return NULL_TREE;
139     }
140   else
141     return type;
142 }
143
144 /* Return truthvalue of whether type of EXP is instantiated.  */
145
146 int
147 type_unknown_p (tree exp)
148 {
149   return (TREE_CODE (exp) == TREE_LIST
150           || TREE_TYPE (exp) == unknown_type_node);
151 }
152
153 \f
154 /* Return the common type of two parameter lists.
155    We assume that comptypes has already been done and returned 1;
156    if that isn't so, this may crash.
157
158    As an optimization, free the space we allocate if the parameter
159    lists are already common.  */
160
161 static tree
162 commonparms (tree p1, tree p2)
163 {
164   tree oldargs = p1, newargs, n;
165   int i, len;
166   int any_change = 0;
167
168   len = list_length (p1);
169   newargs = tree_last (p1);
170
171   if (newargs == void_list_node)
172     i = 1;
173   else
174     {
175       i = 0;
176       newargs = 0;
177     }
178
179   for (; i < len; i++)
180     newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
181
182   n = newargs;
183
184   for (i = 0; p1;
185        p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
186     {
187       if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
188         {
189           TREE_PURPOSE (n) = TREE_PURPOSE (p1);
190           any_change = 1;
191         }
192       else if (! TREE_PURPOSE (p1))
193         {
194           if (TREE_PURPOSE (p2))
195             {
196               TREE_PURPOSE (n) = TREE_PURPOSE (p2);
197               any_change = 1;
198             }
199         }
200       else
201         {
202           if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
203             any_change = 1;
204           TREE_PURPOSE (n) = TREE_PURPOSE (p2);
205         }
206       if (TREE_VALUE (p1) != TREE_VALUE (p2))
207         {
208           any_change = 1;
209           TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
210         }
211       else
212         TREE_VALUE (n) = TREE_VALUE (p1);
213     }
214   if (! any_change)
215     return oldargs;
216
217   return newargs;
218 }
219
220 /* Given a type, perhaps copied for a typedef,
221    find the "original" version of it.  */
222 tree
223 original_type (tree t)
224 {
225   while (TYPE_NAME (t) != NULL_TREE)
226     {
227       tree x = TYPE_NAME (t);
228       if (TREE_CODE (x) != TYPE_DECL)
229         break;
230       x = DECL_ORIGINAL_TYPE (x);
231       if (x == NULL_TREE)
232         break;
233       t = x;
234     }
235   return t;
236 }
237
238 /* T1 and T2 are arithmetic or enumeration types.  Return the type
239    that will result from the "usual arithmetic conversions" on T1 and
240    T2 as described in [expr].  */
241
242 tree
243 type_after_usual_arithmetic_conversions (tree t1, tree t2)
244 {
245   enum tree_code code1 = TREE_CODE (t1);
246   enum tree_code code2 = TREE_CODE (t2);
247   tree attributes;
248
249   /* FIXME: Attributes.  */
250   gcc_assert (ARITHMETIC_TYPE_P (t1) 
251               || TREE_CODE (t1) == COMPLEX_TYPE
252               || TREE_CODE (t1) == ENUMERAL_TYPE);
253   gcc_assert (ARITHMETIC_TYPE_P (t2) 
254               || TREE_CODE (t2) == COMPLEX_TYPE
255               || TREE_CODE (t2) == ENUMERAL_TYPE);
256
257   /* In what follows, we slightly generalize the rules given in [expr] so
258      as to deal with `long long' and `complex'.  First, merge the
259      attributes.  */
260   attributes = (*targetm.merge_type_attributes) (t1, t2);
261
262   /* If one type is complex, form the common type of the non-complex
263      components, then make that complex.  Use T1 or T2 if it is the
264      required type.  */
265   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
266     {
267       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
268       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
269       tree subtype
270         = type_after_usual_arithmetic_conversions (subtype1, subtype2);
271
272       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
273         return build_type_attribute_variant (t1, attributes);
274       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
275         return build_type_attribute_variant (t2, attributes);
276       else
277         return build_type_attribute_variant (build_complex_type (subtype),
278                                              attributes);
279     }
280
281   /* If only one is real, use it as the result.  */
282   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
283     return build_type_attribute_variant (t1, attributes);
284   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
285     return build_type_attribute_variant (t2, attributes);
286
287   /* Perform the integral promotions.  */
288   if (code1 != REAL_TYPE)
289     {
290       t1 = type_promotes_to (t1);
291       t2 = type_promotes_to (t2);
292     }
293
294   /* Both real or both integers; use the one with greater precision.  */
295   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
296     return build_type_attribute_variant (t1, attributes);
297   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
298     return build_type_attribute_variant (t2, attributes);
299
300   /* The types are the same; no need to do anything fancy.  */
301   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
302     return build_type_attribute_variant (t1, attributes);
303
304   if (code1 != REAL_TYPE)
305     {
306       /* If one is a sizetype, use it so size_binop doesn't blow up.  */
307       if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
308         return build_type_attribute_variant (t1, attributes);
309       if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
310         return build_type_attribute_variant (t2, attributes);
311
312       /* If one is unsigned long long, then convert the other to unsigned
313          long long.  */
314       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
315           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
316         return build_type_attribute_variant (long_long_unsigned_type_node,
317                                              attributes);
318       /* If one is a long long, and the other is an unsigned long, and
319          long long can represent all the values of an unsigned long, then
320          convert to a long long.  Otherwise, convert to an unsigned long
321          long.  Otherwise, if either operand is long long, convert the
322          other to long long.
323          
324          Since we're here, we know the TYPE_PRECISION is the same;
325          therefore converting to long long cannot represent all the values
326          of an unsigned long, so we choose unsigned long long in that
327          case.  */
328       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
329           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
330         {
331           tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
332                     ? long_long_unsigned_type_node 
333                     : long_long_integer_type_node);
334           return build_type_attribute_variant (t, attributes);
335         }
336       
337       /* Go through the same procedure, but for longs.  */
338       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
339           || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
340         return build_type_attribute_variant (long_unsigned_type_node,
341                                              attributes);
342       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
343           || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
344         {
345           tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
346                     ? long_unsigned_type_node : long_integer_type_node);
347           return build_type_attribute_variant (t, attributes);
348         }
349       /* Otherwise prefer the unsigned one.  */
350       if (TYPE_UNSIGNED (t1))
351         return build_type_attribute_variant (t1, attributes);
352       else
353         return build_type_attribute_variant (t2, attributes);
354     }
355   else
356     {
357       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
358           || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
359         return build_type_attribute_variant (long_double_type_node,
360                                              attributes);
361       if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
362           || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
363         return build_type_attribute_variant (double_type_node,
364                                              attributes);
365       if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
366           || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
367         return build_type_attribute_variant (float_type_node,
368                                              attributes);
369       
370       /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
371          the standard C++ floating-point types.  Logic earlier in this
372          function has already eliminated the possibility that
373          TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
374          compelling reason to choose one or the other.  */
375       return build_type_attribute_variant (t1, attributes);
376     }
377 }
378
379 /* Subroutine of composite_pointer_type to implement the recursive
380    case.  See that function for documentation fo the parameters.  */
381
382 static tree
383 composite_pointer_type_r (tree t1, tree t2, const char* location)
384 {
385   tree pointee1;
386   tree pointee2;
387   tree result_type;
388   tree attributes;
389
390   /* Determine the types pointed to by T1 and T2.  */
391   if (TREE_CODE (t1) == POINTER_TYPE)
392     {
393       pointee1 = TREE_TYPE (t1);
394       pointee2 = TREE_TYPE (t2);
395     }
396   else
397     {
398       pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
399       pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
400     }
401
402   /* [expr.rel]
403
404      Otherwise, the composite pointer type is a pointer type
405      similar (_conv.qual_) to the type of one of the operands,
406      with a cv-qualification signature (_conv.qual_) that is the
407      union of the cv-qualification signatures of the operand
408      types.  */
409   if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
410     result_type = pointee1;
411   else if ((TREE_CODE (pointee1) == POINTER_TYPE
412             && TREE_CODE (pointee2) == POINTER_TYPE)
413            || (TYPE_PTR_TO_MEMBER_P (pointee1)
414                && TYPE_PTR_TO_MEMBER_P (pointee2)))
415     result_type = composite_pointer_type_r (pointee1, pointee2, location);
416   else
417     {
418       pedwarn ("%s between distinct pointer types %qT and %qT "
419                "lacks a cast",
420                location, t1, t2);
421       result_type = void_type_node;
422     }
423   result_type = cp_build_qualified_type (result_type,
424                                          (cp_type_quals (pointee1)
425                                           | cp_type_quals (pointee2)));
426   /* If the original types were pointers to members, so is the
427      result.  */
428   if (TYPE_PTR_TO_MEMBER_P (t1))
429     {
430       if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
431                         TYPE_PTRMEM_CLASS_TYPE (t2)))
432         pedwarn ("%s between distinct pointer types %qT and %qT "
433                  "lacks a cast",
434                  location, t1, t2);
435       result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
436                                        result_type);
437     }
438   else
439     result_type = build_pointer_type (result_type);
440
441   /* Merge the attributes.  */
442   attributes = (*targetm.merge_type_attributes) (t1, t2);
443   return build_type_attribute_variant (result_type, attributes);
444 }
445
446 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
447    ARG1 and ARG2 are the values with those types.  The LOCATION is a
448    string describing the current location, in case an error occurs. 
449
450    This routine also implements the computation of a common type for
451    pointers-to-members as per [expr.eq].  */
452
453 tree 
454 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
455                         const char* location)
456 {
457   tree class1;
458   tree class2;
459
460   /* [expr.rel]
461
462      If one operand is a null pointer constant, the composite pointer
463      type is the type of the other operand.  */
464   if (null_ptr_cst_p (arg1))
465     return t2;
466   if (null_ptr_cst_p (arg2))
467     return t1;
468  
469   /* We have:
470
471        [expr.rel]
472
473        If one of the operands has type "pointer to cv1 void*", then
474        the other has type "pointer to cv2T", and the composite pointer
475        type is "pointer to cv12 void", where cv12 is the union of cv1
476        and cv2.
477
478     If either type is a pointer to void, make sure it is T1.  */
479   if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
480     {
481       tree t;
482       t = t1;
483       t1 = t2;
484       t2 = t;
485     }
486
487   /* Now, if T1 is a pointer to void, merge the qualifiers.  */
488   if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
489     {
490       tree attributes;
491       tree result_type;
492
493       if (pedantic && TYPE_PTRFN_P (t2))
494         pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> "
495                  "and pointer-to-function", location);
496       result_type 
497         = cp_build_qualified_type (void_type_node,
498                                    (cp_type_quals (TREE_TYPE (t1))
499                                     | cp_type_quals (TREE_TYPE (t2))));
500       result_type = build_pointer_type (result_type);
501       /* Merge the attributes.  */
502       attributes = (*targetm.merge_type_attributes) (t1, t2);
503       return build_type_attribute_variant (result_type, attributes);
504     }
505
506   if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE
507       && TREE_CODE (t2) == POINTER_TYPE)
508     {
509       if (objc_compare_types (t1, t2, -3, NULL_TREE))
510         return t1;
511     }
512
513   /* [expr.eq] permits the application of a pointer conversion to
514      bring the pointers to a common type.  */
515   if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
516       && CLASS_TYPE_P (TREE_TYPE (t1))
517       && CLASS_TYPE_P (TREE_TYPE (t2))
518       && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
519                                                      TREE_TYPE (t2)))
520     {
521       class1 = TREE_TYPE (t1);
522       class2 = TREE_TYPE (t2);
523
524       if (DERIVED_FROM_P (class1, class2))
525         t2 = (build_pointer_type 
526               (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
527       else if (DERIVED_FROM_P (class2, class1))
528         t1 = (build_pointer_type 
529               (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
530       else
531         {
532           error ("%s between distinct pointer types %qT and %qT "
533                  "lacks a cast", location, t1, t2);
534           return error_mark_node;
535         }
536     }
537   /* [expr.eq] permits the application of a pointer-to-member
538      conversion to change the class type of one of the types.  */
539   else if (TYPE_PTR_TO_MEMBER_P (t1)
540            && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
541                             TYPE_PTRMEM_CLASS_TYPE (t2)))
542     {
543       class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
544       class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
545
546       if (DERIVED_FROM_P (class1, class2))
547         t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
548       else if (DERIVED_FROM_P (class2, class1))
549         t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
550       else
551         {
552           error ("%s between distinct pointer-to-member types %qT and %qT "
553                  "lacks a cast", location, t1, t2);
554           return error_mark_node;
555         }
556     }
557
558   return composite_pointer_type_r (t1, t2, location);
559 }
560
561 /* Return the merged type of two types.
562    We assume that comptypes has already been done and returned 1;
563    if that isn't so, this may crash.
564
565    This just combines attributes and default arguments; any other
566    differences would cause the two types to compare unalike.  */
567
568 tree
569 merge_types (tree t1, tree t2)
570 {
571   enum tree_code code1;
572   enum tree_code code2;
573   tree attributes;
574
575   /* Save time if the two types are the same.  */
576   if (t1 == t2)
577     return t1;
578   if (original_type (t1) == original_type (t2))
579     return t1;
580
581   /* If one type is nonsense, use the other.  */
582   if (t1 == error_mark_node)
583     return t2;
584   if (t2 == error_mark_node)
585     return t1;
586
587   /* Merge the attributes.  */
588   attributes = (*targetm.merge_type_attributes) (t1, t2);
589
590   if (TYPE_PTRMEMFUNC_P (t1))
591     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
592   if (TYPE_PTRMEMFUNC_P (t2))
593     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
594
595   code1 = TREE_CODE (t1);
596   code2 = TREE_CODE (t2);
597
598   switch (code1)
599     {
600     case POINTER_TYPE:
601     case REFERENCE_TYPE:
602       /* For two pointers, do this recursively on the target type.  */
603       {
604         tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
605         int quals = cp_type_quals (t1);
606
607         if (code1 == POINTER_TYPE)
608           t1 = build_pointer_type (target);
609         else
610           t1 = build_reference_type (target);
611         t1 = build_type_attribute_variant (t1, attributes);
612         t1 = cp_build_qualified_type (t1, quals);
613
614         if (TREE_CODE (target) == METHOD_TYPE)
615           t1 = build_ptrmemfunc_type (t1);
616
617         return t1;
618       }
619
620     case OFFSET_TYPE:
621       {
622         int quals;
623         tree pointee;
624         quals = cp_type_quals (t1);
625         pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
626                                TYPE_PTRMEM_POINTED_TO_TYPE (t2));
627         t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
628                                 pointee);
629         t1 = cp_build_qualified_type (t1, quals);
630         break;
631       }
632
633     case ARRAY_TYPE:
634       {
635         tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
636         /* Save space: see if the result is identical to one of the args.  */
637         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
638           return build_type_attribute_variant (t1, attributes);
639         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
640           return build_type_attribute_variant (t2, attributes);
641         /* Merge the element types, and have a size if either arg has one.  */
642         t1 = build_cplus_array_type
643           (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
644         break;
645       }
646
647     case FUNCTION_TYPE:
648       /* Function types: prefer the one that specified arg types.
649          If both do, merge the arg types.  Also merge the return types.  */
650       {
651         tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
652         tree p1 = TYPE_ARG_TYPES (t1);
653         tree p2 = TYPE_ARG_TYPES (t2);
654         tree rval, raises;
655
656         /* Save space: see if the result is identical to one of the args.  */
657         if (valtype == TREE_TYPE (t1) && ! p2)
658           return cp_build_type_attribute_variant (t1, attributes);
659         if (valtype == TREE_TYPE (t2) && ! p1)
660           return cp_build_type_attribute_variant (t2, attributes);
661
662         /* Simple way if one arg fails to specify argument types.  */
663         if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
664           {
665             rval = build_function_type (valtype, p2);
666             if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
667               rval = build_exception_variant (rval, raises);
668             return cp_build_type_attribute_variant (rval, attributes);
669           }
670         raises = TYPE_RAISES_EXCEPTIONS (t1);
671         if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
672           {
673             rval = build_function_type (valtype, p1);
674             if (raises)
675               rval = build_exception_variant (rval, raises);
676             return cp_build_type_attribute_variant (rval, attributes);
677           }
678
679         rval = build_function_type (valtype, commonparms (p1, p2));
680         t1 = build_exception_variant (rval, raises);
681         break;
682       }
683
684     case METHOD_TYPE:
685       {
686         /* Get this value the long way, since TYPE_METHOD_BASETYPE
687            is just the main variant of this.  */
688         tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
689         tree raises = TYPE_RAISES_EXCEPTIONS (t1);
690         tree t3;
691
692         /* If this was a member function type, get back to the
693            original type of type member function (i.e., without
694            the class instance variable up front.  */
695         t1 = build_function_type (TREE_TYPE (t1),
696                                   TREE_CHAIN (TYPE_ARG_TYPES (t1)));
697         t2 = build_function_type (TREE_TYPE (t2),
698                                   TREE_CHAIN (TYPE_ARG_TYPES (t2)));
699         t3 = merge_types (t1, t2);
700         t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
701                                          TYPE_ARG_TYPES (t3));
702         t1 = build_exception_variant (t3, raises);
703         break;
704       }
705
706     case TYPENAME_TYPE:
707       /* There is no need to merge attributes into a TYPENAME_TYPE.
708          When the type is instantiated it will have whatever
709          attributes result from the instantiation.  */
710       return t1;
711
712     default:;
713     }
714   return cp_build_type_attribute_variant (t1, attributes);
715 }
716
717 /* Return the common type of two types.
718    We assume that comptypes has already been done and returned 1;
719    if that isn't so, this may crash.
720
721    This is the type for the result of most arithmetic operations
722    if the operands have the given two types.  */
723
724 tree
725 common_type (tree t1, tree t2)
726 {
727   enum tree_code code1;
728   enum tree_code code2;
729
730   /* If one type is nonsense, bail.  */
731   if (t1 == error_mark_node || t2 == error_mark_node)
732     return error_mark_node;
733
734   code1 = TREE_CODE (t1);
735   code2 = TREE_CODE (t2);
736
737   if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
738        || code1 == COMPLEX_TYPE)
739       && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
740           || code2 == COMPLEX_TYPE))
741     return type_after_usual_arithmetic_conversions (t1, t2);
742
743   else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
744            || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
745            || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
746     return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
747                                    "conversion");
748   else
749     gcc_unreachable ();
750 }
751 \f
752 /* Compare two exception specifier types for exactness or subsetness, if
753    allowed. Returns false for mismatch, true for match (same, or
754    derived and !exact).
755  
756    [except.spec] "If a class X ... objects of class X or any class publicly
757    and unambiguously derived from X. Similarly, if a pointer type Y * ...
758    exceptions of type Y * or that are pointers to any type publicly and
759    unambiguously derived from Y. Otherwise a function only allows exceptions
760    that have the same type ..."
761    This does not mention cv qualifiers and is different to what throw
762    [except.throw] and catch [except.catch] will do. They will ignore the
763    top level cv qualifiers, and allow qualifiers in the pointer to class
764    example.
765    
766    We implement the letter of the standard.  */
767
768 static bool
769 comp_except_types (tree a, tree b, bool exact)
770 {
771   if (same_type_p (a, b))
772     return true;
773   else if (!exact)
774     {
775       if (cp_type_quals (a) || cp_type_quals (b))
776         return false;
777       
778       if (TREE_CODE (a) == POINTER_TYPE
779           && TREE_CODE (b) == POINTER_TYPE)
780         {
781           a = TREE_TYPE (a);
782           b = TREE_TYPE (b);
783           if (cp_type_quals (a) || cp_type_quals (b))
784             return false;
785         }
786       
787       if (TREE_CODE (a) != RECORD_TYPE
788           || TREE_CODE (b) != RECORD_TYPE)
789         return false;
790       
791       if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
792         return true;
793     }
794   return false;
795 }
796
797 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
798    If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
799    otherwise it must be exact. Exception lists are unordered, but
800    we've already filtered out duplicates. Most lists will be in order,
801    we should try to make use of that.  */
802
803 bool
804 comp_except_specs (tree t1, tree t2, bool exact)
805 {
806   tree probe;
807   tree base;
808   int  length = 0;
809
810   if (t1 == t2)
811     return true;
812   
813   if (t1 == NULL_TREE)              /* T1 is ...  */
814     return t2 == NULL_TREE || !exact;
815   if (!TREE_VALUE (t1)) /* t1 is EMPTY */
816     return t2 != NULL_TREE && !TREE_VALUE (t2);
817   if (t2 == NULL_TREE)              /* T2 is ...  */
818     return false;
819   if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
820     return !exact;
821   
822   /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
823      Count how many we find, to determine exactness. For exact matching and
824      ordered T1, T2, this is an O(n) operation, otherwise its worst case is
825      O(nm).  */
826   for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
827     {
828       for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
829         {
830           tree a = TREE_VALUE (probe);
831           tree b = TREE_VALUE (t2);
832           
833           if (comp_except_types (a, b, exact))
834             {
835               if (probe == base && exact)
836                 base = TREE_CHAIN (probe);
837               length++;
838               break;
839             }
840         }
841       if (probe == NULL_TREE)
842         return false;
843     }
844   return !exact || base == NULL_TREE || length == list_length (t1);
845 }
846
847 /* Compare the array types T1 and T2.  ALLOW_REDECLARATION is true if
848    [] can match [size].  */
849
850 static bool
851 comp_array_types (tree t1, tree t2, bool allow_redeclaration)
852 {
853   tree d1;
854   tree d2;
855   tree max1, max2;
856
857   if (t1 == t2)
858     return true;
859
860   /* The type of the array elements must be the same.  */
861   if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
862     return false;
863
864   d1 = TYPE_DOMAIN (t1);
865   d2 = TYPE_DOMAIN (t2);
866
867   if (d1 == d2)
868     return true;
869
870   /* If one of the arrays is dimensionless, and the other has a
871      dimension, they are of different types.  However, it is valid to
872      write:
873
874        extern int a[];
875        int a[3];
876
877      by [basic.link]: 
878
879        declarations for an array object can specify
880        array types that differ by the presence or absence of a major
881        array bound (_dcl.array_).  */
882   if (!d1 || !d2)
883     return allow_redeclaration;
884
885   /* Check that the dimensions are the same.  */
886
887   if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
888     return false;
889   max1 = TYPE_MAX_VALUE (d1);
890   max2 = TYPE_MAX_VALUE (d2);
891   if (processing_template_decl && !abi_version_at_least (2)
892       && !value_dependent_expression_p (max1)
893       && !value_dependent_expression_p (max2))
894     {
895       /* With abi-1 we do not fold non-dependent array bounds, (and
896          consequently mangle them incorrectly).  We must therefore
897          fold them here, to verify the domains have the same
898          value.  */
899       max1 = fold (max1);
900       max2 = fold (max2);
901     }
902
903   if (!cp_tree_equal (max1, max2))
904     return false;
905
906   return true;
907 }
908
909 /* Return true if T1 and T2 are related as allowed by STRICT.  STRICT
910    is a bitwise-or of the COMPARE_* flags.  */
911
912 bool
913 comptypes (tree t1, tree t2, int strict)
914 {
915   if (t1 == t2)
916     return true;
917
918   /* Suppress errors caused by previously reported errors.  */
919   if (t1 == error_mark_node || t2 == error_mark_node)
920     return false;
921   
922   gcc_assert (TYPE_P (t1) && TYPE_P (t2));
923   
924   /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
925      current instantiation.  */
926   if (TREE_CODE (t1) == TYPENAME_TYPE)
927     {
928       tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
929
930       if (resolved != error_mark_node)
931         t1 = resolved;
932     }
933   
934   if (TREE_CODE (t2) == TYPENAME_TYPE)
935     {
936       tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
937
938       if (resolved != error_mark_node)
939         t2 = resolved;
940     }
941
942   /* If either type is the internal version of sizetype, use the
943      language version.  */
944   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
945       && TYPE_ORIG_SIZE_TYPE (t1))
946     t1 = TYPE_ORIG_SIZE_TYPE (t1);
947
948   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
949       && TYPE_ORIG_SIZE_TYPE (t2))
950     t2 = TYPE_ORIG_SIZE_TYPE (t2);
951
952   if (TYPE_PTRMEMFUNC_P (t1))
953     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
954   if (TYPE_PTRMEMFUNC_P (t2))
955     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
956
957   /* Different classes of types can't be compatible.  */
958   if (TREE_CODE (t1) != TREE_CODE (t2))
959     return false;
960
961   /* Qualifiers must match.  For array types, we will check when we
962      recur on the array element types.  */
963   if (TREE_CODE (t1) != ARRAY_TYPE
964       && TYPE_QUALS (t1) != TYPE_QUALS (t2))
965     return false;
966   if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
967     return false;
968
969   /* Allow for two different type nodes which have essentially the same
970      definition.  Note that we already checked for equality of the type
971      qualifiers (just above).  */
972
973   if (TREE_CODE (t1) != ARRAY_TYPE
974       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
975     return true;
976
977   /* Compare the types.  Break out if they could be the same.  */
978   switch (TREE_CODE (t1))
979     {
980     case TEMPLATE_TEMPLATE_PARM:
981     case BOUND_TEMPLATE_TEMPLATE_PARM:
982       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
983           || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
984         return false;
985       if (!comp_template_parms
986           (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
987            DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
988         return false;
989       if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
990         break;
991       /* Don't check inheritance.  */
992       strict = COMPARE_STRICT;
993       /* Fall through.  */
994
995     case RECORD_TYPE:
996     case UNION_TYPE:
997       if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
998           && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
999               || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1000           && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1001         break;
1002       
1003       if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1004         break;
1005       else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1006         break;
1007       
1008       return false;
1009
1010     case OFFSET_TYPE:
1011       if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1012                       strict & ~COMPARE_REDECLARATION))
1013         return false;
1014       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1015         return false;
1016       break;
1017
1018     case POINTER_TYPE:
1019     case REFERENCE_TYPE:
1020       if (TYPE_MODE (t1) != TYPE_MODE (t2)
1021           || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1022           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1023         return false;
1024       break;
1025
1026     case METHOD_TYPE:
1027     case FUNCTION_TYPE:
1028       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1029         return false;
1030       if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1031         return false;
1032       break;
1033
1034     case ARRAY_TYPE:
1035       /* Target types must match incl. qualifiers.  */
1036       if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1037         return false;
1038       break;
1039
1040     case TEMPLATE_TYPE_PARM:
1041       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1042           || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
1043         return false;
1044       break;
1045
1046     case TYPENAME_TYPE:
1047       if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1048                           TYPENAME_TYPE_FULLNAME (t2)))
1049         return false;
1050       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1051         return false;
1052       break;
1053
1054     case UNBOUND_CLASS_TEMPLATE:
1055       if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1056         return false;
1057       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1058         return false;
1059       break;
1060
1061     case COMPLEX_TYPE:
1062       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1063         return false;
1064       break;
1065
1066     case VECTOR_TYPE:
1067       if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1068           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1069         return false;
1070       break;
1071
1072     default:
1073       return false;
1074     }
1075
1076   /* If we get here, we know that from a target independent POV the
1077      types are the same.  Make sure the target attributes are also
1078      the same.  */
1079   return targetm.comp_type_attributes (t1, t2);
1080 }
1081
1082 /* Returns 1 if TYPE1 is at least as qualified as TYPE2.  */
1083
1084 bool
1085 at_least_as_qualified_p (tree type1, tree type2)
1086 {
1087   int q1 = cp_type_quals (type1);
1088   int q2 = cp_type_quals (type2);
1089   
1090   /* All qualifiers for TYPE2 must also appear in TYPE1.  */
1091   return (q1 & q2) == q2;
1092 }
1093
1094 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1095    more cv-qualified that TYPE1, and 0 otherwise.  */
1096
1097 int
1098 comp_cv_qualification (tree type1, tree type2)
1099 {
1100   int q1 = cp_type_quals (type1);
1101   int q2 = cp_type_quals (type2);
1102
1103   if (q1 == q2)
1104     return 0;
1105
1106   if ((q1 & q2) == q2)
1107     return 1;
1108   else if ((q1 & q2) == q1)
1109     return -1;
1110
1111   return 0;
1112 }
1113
1114 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1115    subset of the cv-qualification signature of TYPE2, and the types
1116    are similar.  Returns -1 if the other way 'round, and 0 otherwise.  */
1117
1118 int
1119 comp_cv_qual_signature (tree type1, tree type2)
1120 {
1121   if (comp_ptr_ttypes_real (type2, type1, -1))
1122     return 1;
1123   else if (comp_ptr_ttypes_real (type1, type2, -1))
1124     return -1;
1125   else
1126     return 0;
1127 }
1128
1129 /* If two types share a common base type, return that basetype.
1130    If there is not a unique most-derived base type, this function
1131    returns ERROR_MARK_NODE.  */
1132
1133 static tree
1134 common_base_type (tree tt1, tree tt2)
1135 {
1136   tree best = NULL_TREE;
1137   int i;
1138
1139   /* If one is a baseclass of another, that's good enough.  */
1140   if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1141     return tt1;
1142   if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1143     return tt2;
1144
1145   /* Otherwise, try to find a unique baseclass of TT1
1146      that is shared by TT2, and follow that down.  */
1147   for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt1))-1; i >= 0; i--)
1148     {
1149       tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt1), i));
1150       tree trial = common_base_type (basetype, tt2);
1151       
1152       if (trial)
1153         {
1154           if (trial == error_mark_node)
1155             return trial;
1156           if (best == NULL_TREE)
1157             best = trial;
1158           else if (best != trial)
1159             return error_mark_node;
1160         }
1161     }
1162
1163   /* Same for TT2.  */
1164   for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt2))-1; i >= 0; i--)
1165     {
1166       tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt2), i));
1167       tree trial = common_base_type (tt1, basetype);
1168       
1169       if (trial)
1170         {
1171           if (trial == error_mark_node)
1172             return trial;
1173           if (best == NULL_TREE)
1174             best = trial;
1175           else if (best != trial)
1176             return error_mark_node;
1177         }
1178     }
1179   return best;
1180 }
1181 \f
1182 /* Subroutines of `comptypes'.  */
1183
1184 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1185    equivalent in the sense that functions with those parameter types
1186    can have equivalent types.  The two lists must be equivalent,
1187    element by element.  */
1188
1189 bool
1190 compparms (tree parms1, tree parms2)
1191 {
1192   tree t1, t2;
1193
1194   /* An unspecified parmlist matches any specified parmlist
1195      whose argument types don't need default promotions.  */
1196
1197   for (t1 = parms1, t2 = parms2;
1198        t1 || t2;
1199        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1200     {
1201       /* If one parmlist is shorter than the other,
1202          they fail to match.  */
1203       if (!t1 || !t2)
1204         return false;
1205       if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1206         return false;
1207     }
1208   return true;
1209 }
1210
1211 \f
1212 /* Process a sizeof or alignof expression where the operand is a
1213    type.  */
1214
1215 tree
1216 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1217 {
1218   enum tree_code type_code;
1219   tree value;
1220   const char *op_name;
1221
1222   gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1223   if (type == error_mark_node)
1224     return error_mark_node;
1225   
1226   if (dependent_type_p (type))
1227     {
1228       value = build_min (op, size_type_node, type);
1229       TREE_READONLY (value) = 1;
1230       return value;
1231     }
1232   
1233   op_name = operator_name_info[(int) op].name;
1234
1235   type = non_reference (type);
1236   type_code = TREE_CODE (type);
1237
1238   if (type_code == METHOD_TYPE)
1239     {
1240       if (complain && (pedantic || warn_pointer_arith))
1241         pedwarn ("invalid application of %qs to a member function", op_name);
1242       value = size_one_node;
1243     }
1244   else
1245     value = c_sizeof_or_alignof_type (complete_type (type),
1246                                       op == SIZEOF_EXPR,
1247                                       complain);
1248
1249   return value;
1250 }
1251
1252 /* Process a sizeof or alignof expression where the operand is an
1253    expression.  */
1254
1255 tree
1256 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
1257 {
1258   const char *op_name = operator_name_info[(int) op].name;
1259   
1260   if (e == error_mark_node)
1261     return error_mark_node;
1262   
1263   if (processing_template_decl)
1264     {
1265       e = build_min (op, size_type_node, e);
1266       TREE_SIDE_EFFECTS (e) = 0;
1267       TREE_READONLY (e) = 1;
1268       
1269       return e;
1270     }
1271   
1272   if (TREE_CODE (e) == COMPONENT_REF
1273       && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1274       && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1275     {
1276       error ("invalid application of %qs to a bit-field", op_name);
1277       e = char_type_node;
1278     }
1279   else if (is_overloaded_fn (e))
1280     {
1281       pedwarn ("ISO C++ forbids applying %qs to an expression of "
1282                "function type", op_name);
1283       e = char_type_node;
1284     }
1285   else if (type_unknown_p (e))
1286     {
1287       cxx_incomplete_type_error (e, TREE_TYPE (e));
1288       e = char_type_node;
1289     }
1290   else
1291     e = TREE_TYPE (e);
1292   
1293   return cxx_sizeof_or_alignof_type (e, op, true);
1294 }
1295   
1296 \f
1297 /* EXPR is being used in a context that is not a function call.
1298    Enforce:
1299
1300      [expr.ref] 
1301
1302      The expression can be used only as the left-hand operand of a
1303      member function call.  
1304
1305      [expr.mptr.operator]
1306
1307      If the result of .* or ->* is a function, then that result can be
1308      used only as the operand for the function call operator ().  
1309
1310    by issuing an error message if appropriate.  Returns true iff EXPR
1311    violates these rules.  */
1312
1313 bool
1314 invalid_nonstatic_memfn_p (tree expr)
1315 {
1316   if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
1317     {
1318       error ("invalid use of non-static member function");
1319       return true;
1320     }
1321   return false;
1322 }
1323
1324 /* Perform the conversions in [expr] that apply when an lvalue appears
1325    in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1326    function-to-pointer conversions.
1327
1328    In addition manifest constants are replaced by their values.  */
1329
1330 tree
1331 decay_conversion (tree exp)
1332 {
1333   tree type;
1334   enum tree_code code;
1335
1336   type = TREE_TYPE (exp);
1337   code = TREE_CODE (type);
1338
1339   if (type == error_mark_node)
1340     return error_mark_node;
1341
1342   if (type_unknown_p (exp))
1343     {
1344       cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1345       return error_mark_node;
1346     }
1347
1348   exp = integral_constant_value (exp);
1349   
1350   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1351      Leave such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
1352
1353   if (code == VOID_TYPE)
1354     {
1355       error ("void value not ignored as it ought to be");
1356       return error_mark_node;
1357     }
1358   if (invalid_nonstatic_memfn_p (exp))
1359     return error_mark_node;
1360   if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1361     return build_unary_op (ADDR_EXPR, exp, 0);
1362   if (code == ARRAY_TYPE)
1363     {
1364       tree adr;
1365       tree ptrtype;
1366
1367       if (TREE_CODE (exp) == INDIRECT_REF)
1368         return build_nop (build_pointer_type (TREE_TYPE (type)), 
1369                           TREE_OPERAND (exp, 0));
1370
1371       if (TREE_CODE (exp) == COMPOUND_EXPR)
1372         {
1373           tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1374           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1375                          TREE_OPERAND (exp, 0), op1);
1376         }
1377
1378       if (!lvalue_p (exp)
1379           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1380         {
1381           error ("invalid use of non-lvalue array");
1382           return error_mark_node;
1383         }
1384
1385       ptrtype = build_pointer_type (TREE_TYPE (type));
1386
1387       if (TREE_CODE (exp) == VAR_DECL)
1388         {
1389           if (!cxx_mark_addressable (exp))
1390             return error_mark_node;
1391           adr = build_nop (ptrtype, build_address (exp));
1392           return adr;
1393         }
1394       /* This way is better for a COMPONENT_REF since it can
1395          simplify the offset for a component.  */
1396       adr = build_unary_op (ADDR_EXPR, exp, 1);
1397       return cp_convert (ptrtype, adr);
1398     }
1399
1400   /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1401      rvalues always have cv-unqualified types.  */
1402   if (! CLASS_TYPE_P (type))
1403     exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1404
1405   return exp;
1406 }
1407
1408 tree
1409 default_conversion (tree exp)
1410 {
1411   exp = decay_conversion (exp);
1412
1413   if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1414     exp = perform_integral_promotions (exp);
1415
1416   return exp;
1417 }
1418
1419 /* EXPR is an expression with an integral or enumeration type.
1420    Perform the integral promotions in [conv.prom], and return the
1421    converted value.  */
1422
1423 tree
1424 perform_integral_promotions (tree expr)
1425 {
1426   tree type;
1427   tree promoted_type;
1428
1429   type = TREE_TYPE (expr);
1430   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1431   promoted_type = type_promotes_to (type);
1432   if (type != promoted_type)
1433     expr = cp_convert (promoted_type, expr);
1434   return expr;
1435 }
1436
1437 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1438    or TREE_USED.  */
1439
1440 tree
1441 inline_conversion (tree exp)
1442 {
1443   if (TREE_CODE (exp) == FUNCTION_DECL)
1444     exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1445
1446   return exp;
1447 }
1448
1449 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1450    decay_conversion to one.  */
1451
1452 int
1453 string_conv_p (tree totype, tree exp, int warn)
1454 {
1455   tree t;
1456
1457   if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1458     return 0;
1459
1460   t = TREE_TYPE (totype);
1461   if (!same_type_p (t, char_type_node)
1462       && !same_type_p (t, wchar_type_node))
1463     return 0;
1464
1465   if (TREE_CODE (exp) == STRING_CST)
1466     {
1467       /* Make sure that we don't try to convert between char and wchar_t.  */
1468       if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1469         return 0;
1470     }
1471   else
1472     {
1473       /* Is this a string constant which has decayed to 'const char *'?  */
1474       t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1475       if (!same_type_p (TREE_TYPE (exp), t))
1476         return 0;
1477       STRIP_NOPS (exp);
1478       if (TREE_CODE (exp) != ADDR_EXPR
1479           || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1480         return 0;
1481     }
1482
1483   /* This warning is not very useful, as it complains about printf.  */
1484   if (warn && warn_write_strings)
1485     warning (0, "deprecated conversion from string constant to %qT'", totype);
1486
1487   return 1;
1488 }
1489
1490 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1491    can, for example, use as an lvalue.  This code used to be in
1492    unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1493    expressions, where we're dealing with aggregates.  But now it's again only
1494    called from unary_complex_lvalue.  The case (in particular) that led to
1495    this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1496    get it there.  */
1497
1498 static tree
1499 rationalize_conditional_expr (enum tree_code code, tree t)
1500 {
1501   /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1502      the first operand is always the one to be used if both operands
1503      are equal, so we know what conditional expression this used to be.  */
1504   if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1505     {
1506       /* The following code is incorrect if either operand side-effects.  */
1507       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
1508                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)));
1509       return
1510         build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1511                                                     ? LE_EXPR : GE_EXPR),
1512                                                    TREE_OPERAND (t, 0),
1513                                                    TREE_OPERAND (t, 1),
1514                                                    /*overloaded_p=*/NULL),
1515                             build_unary_op (code, TREE_OPERAND (t, 0), 0),
1516                             build_unary_op (code, TREE_OPERAND (t, 1), 0));
1517     }
1518
1519   return
1520     build_conditional_expr (TREE_OPERAND (t, 0),
1521                             build_unary_op (code, TREE_OPERAND (t, 1), 0),
1522                             build_unary_op (code, TREE_OPERAND (t, 2), 0));
1523 }
1524
1525 /* Given the TYPE of an anonymous union field inside T, return the
1526    FIELD_DECL for the field.  If not found return NULL_TREE.  Because
1527    anonymous unions can nest, we must also search all anonymous unions
1528    that are directly reachable.  */
1529
1530 tree
1531 lookup_anon_field (tree t, tree type)
1532 {
1533   tree field;
1534
1535   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1536     {
1537       if (TREE_STATIC (field))
1538         continue;
1539       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1540         continue;
1541
1542       /* If we find it directly, return the field.  */
1543       if (DECL_NAME (field) == NULL_TREE
1544           && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1545         {
1546           return field;
1547         }
1548
1549       /* Otherwise, it could be nested, search harder.  */
1550       if (DECL_NAME (field) == NULL_TREE
1551           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1552         {
1553           tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1554           if (subfield)
1555             return subfield;
1556         }
1557     }
1558   return NULL_TREE;
1559 }
1560
1561 /* Build an expression representing OBJECT.MEMBER.  OBJECT is an
1562    expression; MEMBER is a DECL or baselink.  If ACCESS_PATH is
1563    non-NULL, it indicates the path to the base used to name MEMBER.
1564    If PRESERVE_REFERENCE is true, the expression returned will have
1565    REFERENCE_TYPE if the MEMBER does.  Otherwise, the expression
1566    returned will have the type referred to by the reference. 
1567
1568    This function does not perform access control; that is either done
1569    earlier by the parser when the name of MEMBER is resolved to MEMBER
1570    itself, or later when overload resolution selects one of the
1571    functions indicated by MEMBER.  */
1572
1573 tree
1574 build_class_member_access_expr (tree object, tree member, 
1575                                 tree access_path, bool preserve_reference)
1576 {
1577   tree object_type;
1578   tree member_scope;
1579   tree result = NULL_TREE;
1580
1581   if (object == error_mark_node || member == error_mark_node)
1582     return error_mark_node;
1583
1584   gcc_assert (DECL_P (member) || BASELINK_P (member));
1585
1586   /* [expr.ref]
1587
1588      The type of the first expression shall be "class object" (of a
1589      complete type).  */
1590   object_type = TREE_TYPE (object);
1591   if (!currently_open_class (object_type) 
1592       && !complete_type_or_else (object_type, object))
1593     return error_mark_node;
1594   if (!CLASS_TYPE_P (object_type))
1595     {
1596       error ("request for member %qD in %qE, which is of non-class type %qT", 
1597              member, object, object_type);
1598       return error_mark_node;
1599     }
1600
1601   /* The standard does not seem to actually say that MEMBER must be a
1602      member of OBJECT_TYPE.  However, that is clearly what is
1603      intended.  */
1604   if (DECL_P (member))
1605     {
1606       member_scope = DECL_CLASS_CONTEXT (member);
1607       mark_used (member);
1608       if (TREE_DEPRECATED (member))
1609         warn_deprecated_use (member);
1610     }
1611   else
1612     member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1613   /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1614      presently be the anonymous union.  Go outwards until we find a
1615      type related to OBJECT_TYPE.  */
1616   while (ANON_AGGR_TYPE_P (member_scope)
1617          && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1618                                                         object_type))
1619     member_scope = TYPE_CONTEXT (member_scope);
1620   if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1621     {
1622       if (TREE_CODE (member) == FIELD_DECL)
1623         error ("invalid use of nonstatic data member %qE", member);
1624       else
1625         error ("%qD is not a member of %qT", member, object_type);
1626       return error_mark_node;
1627     }
1628
1629   /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1630      `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only an lvalue
1631      in the frontend; only _DECLs and _REFs are lvalues in the backend.  */
1632   {
1633     tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1634     if (temp)
1635       object = build_indirect_ref (temp, NULL);
1636   }
1637
1638   /* In [expr.ref], there is an explicit list of the valid choices for
1639      MEMBER.  We check for each of those cases here.  */
1640   if (TREE_CODE (member) == VAR_DECL)
1641     {
1642       /* A static data member.  */
1643       result = member;
1644       /* If OBJECT has side-effects, they are supposed to occur.  */
1645       if (TREE_SIDE_EFFECTS (object))
1646         result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1647     }
1648   else if (TREE_CODE (member) == FIELD_DECL)
1649     {
1650       /* A non-static data member.  */
1651       bool null_object_p;
1652       int type_quals;
1653       tree member_type;
1654
1655       null_object_p = (TREE_CODE (object) == INDIRECT_REF
1656                        && integer_zerop (TREE_OPERAND (object, 0)));
1657
1658       /* Convert OBJECT to the type of MEMBER.  */
1659       if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1660                         TYPE_MAIN_VARIANT (member_scope)))
1661         {
1662           tree binfo;
1663           base_kind kind;
1664
1665           binfo = lookup_base (access_path ? access_path : object_type,
1666                                member_scope, ba_unique,  &kind);
1667           if (binfo == error_mark_node)
1668             return error_mark_node;
1669
1670           /* It is invalid to try to get to a virtual base of a
1671              NULL object.  The most common cause is invalid use of
1672              offsetof macro.  */
1673           if (null_object_p && kind == bk_via_virtual)
1674             {
1675               error ("invalid access to non-static data member %qD of "
1676                      "NULL object",
1677                      member);
1678               error ("(perhaps the %<offsetof%> macro was used incorrectly)");
1679               return error_mark_node;
1680             }
1681
1682           /* Convert to the base.  */
1683           object = build_base_path (PLUS_EXPR, object, binfo, 
1684                                     /*nonnull=*/1);
1685           /* If we found the base successfully then we should be able
1686              to convert to it successfully.  */
1687           gcc_assert (object != error_mark_node);
1688         }
1689
1690       /* Complain about other invalid uses of offsetof, even though they will
1691          give the right answer.  Note that we complain whether or not they
1692          actually used the offsetof macro, since there's no way to know at this
1693          point.  So we just give a warning, instead of a pedwarn.  */
1694       /* Do not produce this warning for base class field references, because
1695          we know for a fact that didn't come from offsetof.  This does occur
1696          in various testsuite cases where a null object is passed where a
1697          vtable access is required.  */
1698       if (null_object_p && warn_invalid_offsetof
1699           && CLASSTYPE_NON_POD_P (object_type)
1700           && !DECL_FIELD_IS_BASE (member)
1701           && !skip_evaluation)
1702         {
1703           warning (0, "invalid access to non-static data member %qD of NULL object", 
1704                    member);
1705           warning (0, "(perhaps the %<offsetof%> macro was used incorrectly)");
1706         }
1707
1708       /* If MEMBER is from an anonymous aggregate, we have converted
1709          OBJECT so that it refers to the class containing the
1710          anonymous union.  Generate a reference to the anonymous union
1711          itself, and recur to find MEMBER.  */
1712       if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1713           /* When this code is called from build_field_call, the
1714              object already has the type of the anonymous union.
1715              That is because the COMPONENT_REF was already
1716              constructed, and was then disassembled before calling
1717              build_field_call.  After the function-call code is
1718              cleaned up, this waste can be eliminated.  */
1719           && (!same_type_ignoring_top_level_qualifiers_p 
1720               (TREE_TYPE (object), DECL_CONTEXT (member))))
1721         {
1722           tree anonymous_union;
1723
1724           anonymous_union = lookup_anon_field (TREE_TYPE (object),
1725                                                DECL_CONTEXT (member));
1726           object = build_class_member_access_expr (object,
1727                                                    anonymous_union,
1728                                                    /*access_path=*/NULL_TREE,
1729                                                    preserve_reference);
1730         }
1731
1732       /* Compute the type of the field, as described in [expr.ref].  */
1733       type_quals = TYPE_UNQUALIFIED;
1734       member_type = TREE_TYPE (member);
1735       if (TREE_CODE (member_type) != REFERENCE_TYPE)
1736         {
1737           type_quals = (cp_type_quals (member_type)  
1738                         | cp_type_quals (object_type));
1739           
1740           /* A field is const (volatile) if the enclosing object, or the
1741              field itself, is const (volatile).  But, a mutable field is
1742              not const, even within a const object.  */
1743           if (DECL_MUTABLE_P (member))
1744             type_quals &= ~TYPE_QUAL_CONST;
1745           member_type = cp_build_qualified_type (member_type, type_quals);
1746         }
1747
1748       result = build3 (COMPONENT_REF, member_type, object, member,
1749                        NULL_TREE);
1750       result = fold_if_not_in_template (result);
1751
1752       /* Mark the expression const or volatile, as appropriate.  Even
1753          though we've dealt with the type above, we still have to mark the
1754          expression itself.  */
1755       if (type_quals & TYPE_QUAL_CONST)
1756         TREE_READONLY (result) = 1;
1757       if (type_quals & TYPE_QUAL_VOLATILE)
1758         TREE_THIS_VOLATILE (result) = 1;
1759     }
1760   else if (BASELINK_P (member))
1761     {
1762       /* The member is a (possibly overloaded) member function.  */
1763       tree functions;
1764       tree type;
1765
1766       /* If the MEMBER is exactly one static member function, then we
1767          know the type of the expression.  Otherwise, we must wait
1768          until overload resolution has been performed.  */
1769       functions = BASELINK_FUNCTIONS (member);
1770       if (TREE_CODE (functions) == FUNCTION_DECL
1771           && DECL_STATIC_FUNCTION_P (functions))
1772         type = TREE_TYPE (functions);
1773       else
1774         type = unknown_type_node;
1775       /* Note that we do not convert OBJECT to the BASELINK_BINFO
1776          base.  That will happen when the function is called.  */
1777       result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
1778     }
1779   else if (TREE_CODE (member) == CONST_DECL)
1780     {
1781       /* The member is an enumerator.  */
1782       result = member;
1783       /* If OBJECT has side-effects, they are supposed to occur.  */
1784       if (TREE_SIDE_EFFECTS (object))
1785         result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
1786                          object, result);
1787     }
1788   else
1789     {
1790       error ("invalid use of %qD", member);
1791       return error_mark_node;
1792     }
1793
1794   if (!preserve_reference)
1795     /* [expr.ref]
1796        
1797        If E2 is declared to have type "reference to T", then ... the
1798        type of E1.E2 is T.  */
1799     result = convert_from_reference (result);
1800
1801   return result;
1802 }
1803
1804 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
1805    SCOPE is NULL, by OBJECT.~DTOR_NAME.  */
1806
1807 static tree
1808 lookup_destructor (tree object, tree scope, tree dtor_name)
1809 {
1810   tree object_type = TREE_TYPE (object);
1811   tree dtor_type = TREE_OPERAND (dtor_name, 0);
1812   tree expr;
1813
1814   if (scope && !check_dtor_name (scope, dtor_name))
1815     {
1816       error ("qualified type %qT does not match destructor name ~%qT",
1817              scope, dtor_type);
1818       return error_mark_node;
1819     }
1820   if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
1821     {
1822       error ("the type being destroyed is %qT, but the destructor refers to %qT",
1823              TYPE_MAIN_VARIANT (object_type), dtor_type);
1824       return error_mark_node;
1825     }
1826   expr = lookup_member (dtor_type, complete_dtor_identifier,
1827                         /*protect=*/1, /*want_type=*/false);
1828   expr = (adjust_result_of_qualified_name_lookup
1829           (expr, dtor_type, object_type));
1830   return expr;
1831 }
1832
1833 /* This function is called by the parser to process a class member
1834    access expression of the form OBJECT.NAME.  NAME is a node used by
1835    the parser to represent a name; it is not yet a DECL.  It may,
1836    however, be a BASELINK where the BASELINK_FUNCTIONS is a
1837    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
1838    there is no reason to do the lookup twice, so the parser keeps the
1839    BASELINK.  */
1840
1841 tree
1842 finish_class_member_access_expr (tree object, tree name)
1843 {
1844   tree expr;
1845   tree object_type;
1846   tree member;
1847   tree access_path = NULL_TREE;
1848   tree orig_object = object;
1849   tree orig_name = name;
1850
1851   if (object == error_mark_node || name == error_mark_node)
1852     return error_mark_node;
1853
1854   /* If OBJECT is an ObjC class instance, we must obey ObjC access rules.  */
1855   if (!objc_is_public (object, name))
1856     return error_mark_node;
1857
1858   object_type = TREE_TYPE (object);
1859
1860   if (processing_template_decl)
1861     {
1862       if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME.  */
1863           dependent_type_p (object_type)
1864           /* If NAME is just an IDENTIFIER_NODE, then the expression
1865              is dependent.  */
1866           || TREE_CODE (object) == IDENTIFIER_NODE
1867           /* If NAME is "f<args>", where either 'f' or 'args' is
1868              dependent, then the expression is dependent.  */
1869           || (TREE_CODE (name) == TEMPLATE_ID_EXPR
1870               && dependent_template_id_p (TREE_OPERAND (name, 0),
1871                                           TREE_OPERAND (name, 1)))
1872           /* If NAME is "T::X" where "T" is dependent, then the
1873              expression is dependent.  */
1874           || (TREE_CODE (name) == SCOPE_REF
1875               && TYPE_P (TREE_OPERAND (name, 0))
1876               && dependent_type_p (TREE_OPERAND (name, 0))))
1877         return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
1878       object = build_non_dependent_expr (object);
1879     }
1880   
1881   /* [expr.ref]
1882
1883      The type of the first expression shall be "class object" (of a
1884      complete type).  */
1885   if (!currently_open_class (object_type) 
1886       && !complete_type_or_else (object_type, object))
1887     return error_mark_node;
1888   if (!CLASS_TYPE_P (object_type))
1889     {
1890       error ("request for member %qD in %qE, which is of non-class type %qT", 
1891              name, object, object_type);
1892       return error_mark_node;
1893     }
1894
1895   if (BASELINK_P (name))
1896     {
1897       /* A member function that has already been looked up.  */
1898       gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name)) == TEMPLATE_ID_EXPR);
1899       member = name;
1900     }
1901   else
1902     {
1903       bool is_template_id = false;
1904       tree template_args = NULL_TREE;
1905       tree scope;
1906
1907       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1908         {
1909           is_template_id = true;
1910           template_args = TREE_OPERAND (name, 1);
1911           name = TREE_OPERAND (name, 0);
1912
1913           if (TREE_CODE (name) == OVERLOAD)
1914             name = DECL_NAME (get_first_fn (name));
1915           else if (DECL_P (name))
1916             name = DECL_NAME (name);
1917         }
1918
1919       if (TREE_CODE (name) == SCOPE_REF)
1920         {
1921           /* A qualified name.  The qualifying class or namespace `S' has
1922              already been looked up; it is either a TYPE or a
1923              NAMESPACE_DECL.  The member name is either an IDENTIFIER_NODE
1924              or a BIT_NOT_EXPR.  */
1925           scope = TREE_OPERAND (name, 0);
1926           name = TREE_OPERAND (name, 1);
1927           gcc_assert (CLASS_TYPE_P (scope)
1928                       || TREE_CODE (scope) == NAMESPACE_DECL);
1929           gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
1930                       || TREE_CODE (name) == BIT_NOT_EXPR);
1931
1932           /* If SCOPE is a namespace, then the qualified name does not
1933              name a member of OBJECT_TYPE.  */
1934           if (TREE_CODE (scope) == NAMESPACE_DECL)
1935             {
1936               error ("%<%D::%D%> is not a member of %qT", 
1937                      scope, name, object_type);
1938               return error_mark_node;
1939             }
1940
1941           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
1942           access_path = lookup_base (object_type, scope, ba_check, NULL);
1943           if (access_path == error_mark_node)
1944             return error_mark_node;
1945           if (!access_path)
1946             {
1947               error ("%qT is not a base of %qT", scope, object_type);
1948               return error_mark_node;
1949             }
1950         }
1951       else
1952         {
1953           scope = NULL_TREE;
1954           access_path = object_type;
1955         }
1956
1957       if (TREE_CODE (name) == BIT_NOT_EXPR)
1958         member = lookup_destructor (object, scope, name);
1959       else
1960         {
1961           /* Look up the member.  */
1962           member = lookup_member (access_path, name, /*protect=*/1, 
1963                                   /*want_type=*/false);
1964           if (member == NULL_TREE)
1965             {
1966               error ("%qD has no member named %qE", object_type, name);
1967               return error_mark_node;
1968             }
1969           if (member == error_mark_node)
1970             return error_mark_node;
1971         }
1972       
1973       if (is_template_id)
1974         {
1975           tree template = member;
1976           
1977           if (BASELINK_P (template))
1978             template = lookup_template_function (template, template_args);
1979           else
1980             {
1981               error ("%qD is not a member template function", name);
1982               return error_mark_node;
1983             }
1984         }
1985     }
1986
1987   if (TREE_DEPRECATED (member))
1988     warn_deprecated_use (member);
1989
1990   expr = build_class_member_access_expr (object, member, access_path,
1991                                          /*preserve_reference=*/false);
1992   if (processing_template_decl && expr != error_mark_node)
1993     return build_min_non_dep (COMPONENT_REF, expr,
1994                               orig_object, orig_name, NULL_TREE);
1995   return expr;
1996 }
1997
1998 /* Return an expression for the MEMBER_NAME field in the internal
1999    representation of PTRMEM, a pointer-to-member function.  (Each
2000    pointer-to-member function type gets its own RECORD_TYPE so it is
2001    more convenient to access the fields by name than by FIELD_DECL.)
2002    This routine converts the NAME to a FIELD_DECL and then creates the
2003    node for the complete expression.  */
2004
2005 tree
2006 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2007 {
2008   tree ptrmem_type;
2009   tree member;
2010   tree member_type;
2011
2012   /* This code is a stripped down version of
2013      build_class_member_access_expr.  It does not work to use that
2014      routine directly because it expects the object to be of class
2015      type.  */
2016   ptrmem_type = TREE_TYPE (ptrmem);
2017   gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2018   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2019                           /*want_type=*/false);
2020   member_type = cp_build_qualified_type (TREE_TYPE (member),
2021                                          cp_type_quals (ptrmem_type));
2022   return fold_build3 (COMPONENT_REF, member_type,
2023                       ptrmem, member, NULL_TREE);
2024 }
2025
2026 /* Given an expression PTR for a pointer, return an expression
2027    for the value pointed to.
2028    ERRORSTRING is the name of the operator to appear in error messages.
2029
2030    This function may need to overload OPERATOR_FNNAME.
2031    Must also handle REFERENCE_TYPEs for C++.  */
2032
2033 tree
2034 build_x_indirect_ref (tree expr, const char *errorstring)
2035 {
2036   tree orig_expr = expr;
2037   tree rval;
2038
2039   if (processing_template_decl)
2040     {
2041       if (type_dependent_expression_p (expr))
2042         return build_min_nt (INDIRECT_REF, expr);
2043       expr = build_non_dependent_expr (expr);
2044     }
2045
2046   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2047                        NULL_TREE, /*overloaded_p=*/NULL);
2048   if (!rval)
2049     rval = build_indirect_ref (expr, errorstring);
2050
2051   if (processing_template_decl && rval != error_mark_node)
2052     return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2053   else
2054     return rval;
2055 }
2056
2057 tree
2058 build_indirect_ref (tree ptr, const char *errorstring)
2059 {
2060   tree pointer, type;
2061
2062   if (ptr == error_mark_node)
2063     return error_mark_node;
2064
2065   if (ptr == current_class_ptr)
2066     return current_class_ref;
2067
2068   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2069              ? ptr : decay_conversion (ptr));
2070   type = TREE_TYPE (pointer);
2071
2072   if (POINTER_TYPE_P (type))
2073     {
2074       /* [expr.unary.op]
2075          
2076          If the type of the expression is "pointer to T," the type
2077          of  the  result  is  "T."   
2078
2079          We must use the canonical variant because certain parts of
2080          the back end, like fold, do pointer comparisons between
2081          types.  */
2082       tree t = canonical_type_variant (TREE_TYPE (type));
2083
2084       if (VOID_TYPE_P (t))
2085         {
2086           /* A pointer to incomplete type (other than cv void) can be
2087              dereferenced [expr.unary.op]/1  */
2088           error ("%qT is not a pointer-to-object type", type);
2089           return error_mark_node;
2090         }
2091       else if (TREE_CODE (pointer) == ADDR_EXPR
2092                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2093         /* The POINTER was something like `&x'.  We simplify `*&x' to
2094            `x'.  */
2095         return TREE_OPERAND (pointer, 0);
2096       else
2097         {
2098           tree ref = build1 (INDIRECT_REF, t, pointer);
2099
2100           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2101              so that we get the proper error message if the result is used
2102              to assign to.  Also, &* is supposed to be a no-op.  */
2103           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2104           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2105           TREE_SIDE_EFFECTS (ref)
2106             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2107           return ref;
2108         }
2109     }
2110   /* `pointer' won't be an error_mark_node if we were given a
2111      pointer to member, so it's cool to check for this here.  */
2112   else if (TYPE_PTR_TO_MEMBER_P (type))
2113     error ("invalid use of %qs on pointer to member", errorstring);
2114   else if (pointer != error_mark_node)
2115     {
2116       if (errorstring)
2117         error ("invalid type argument of %qs", errorstring);
2118       else
2119         error ("invalid type argument");
2120     }
2121   return error_mark_node;
2122 }
2123
2124 /* This handles expressions of the form "a[i]", which denotes
2125    an array reference.
2126
2127    This is logically equivalent in C to *(a+i), but we may do it differently.
2128    If A is a variable or a member, we generate a primitive ARRAY_REF.
2129    This avoids forcing the array out of registers, and can work on
2130    arrays that are not lvalues (for example, members of structures returned
2131    by functions).
2132
2133    If INDEX is of some user-defined type, it must be converted to
2134    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2135    will inherit the type of the array, which will be some pointer type.  */
2136
2137 tree
2138 build_array_ref (tree array, tree idx)
2139 {
2140   if (idx == 0)
2141     {
2142       error ("subscript missing in array reference");
2143       return error_mark_node;
2144     }
2145
2146   if (TREE_TYPE (array) == error_mark_node
2147       || TREE_TYPE (idx) == error_mark_node)
2148     return error_mark_node;
2149
2150   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2151      inside it.  */
2152   switch (TREE_CODE (array))
2153     {
2154     case COMPOUND_EXPR:
2155       {
2156         tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2157         return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2158                        TREE_OPERAND (array, 0), value);
2159       }
2160
2161     case COND_EXPR:
2162       return build_conditional_expr
2163         (TREE_OPERAND (array, 0),
2164          build_array_ref (TREE_OPERAND (array, 1), idx),
2165          build_array_ref (TREE_OPERAND (array, 2), idx));
2166
2167     default:
2168       break;
2169     }
2170
2171   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2172     {
2173       tree rval, type;
2174
2175       /* Subscripting with type char is likely to lose
2176          on a machine where chars are signed.
2177          So warn on any machine, but optionally.
2178          Don't warn for unsigned char since that type is safe.
2179          Don't warn for signed char because anyone who uses that
2180          must have done so deliberately.  */
2181       if (warn_char_subscripts
2182           && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2183         warning (0, "array subscript has type %<char%>");
2184
2185       if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2186         {
2187           error ("array subscript is not an integer");
2188           return error_mark_node;
2189         }
2190
2191       /* Apply integral promotions *after* noticing character types.
2192          (It is unclear why we do these promotions -- the standard
2193          does not say that we should.  In fact, the natural thing would
2194          seem to be to convert IDX to ptrdiff_t; we're performing
2195          pointer arithmetic.)  */
2196       idx = perform_integral_promotions (idx);
2197
2198       /* An array that is indexed by a non-constant
2199          cannot be stored in a register; we must be able to do
2200          address arithmetic on its address.
2201          Likewise an array of elements of variable size.  */
2202       if (TREE_CODE (idx) != INTEGER_CST
2203           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2204               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2205                   != INTEGER_CST)))
2206         {
2207           if (!cxx_mark_addressable (array))
2208             return error_mark_node;
2209         }
2210
2211       /* An array that is indexed by a constant value which is not within
2212          the array bounds cannot be stored in a register either; because we
2213          would get a crash in store_bit_field/extract_bit_field when trying
2214          to access a non-existent part of the register.  */
2215       if (TREE_CODE (idx) == INTEGER_CST
2216           && TYPE_DOMAIN (TREE_TYPE (array))
2217           && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2218         {
2219           if (!cxx_mark_addressable (array))
2220             return error_mark_node;
2221         }
2222
2223       if (pedantic && !lvalue_p (array))
2224         pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2225
2226       /* Note in C++ it is valid to subscript a `register' array, since
2227          it is valid to take the address of something with that
2228          storage specification.  */
2229       if (extra_warnings)
2230         {
2231           tree foo = array;
2232           while (TREE_CODE (foo) == COMPONENT_REF)
2233             foo = TREE_OPERAND (foo, 0);
2234           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2235             warning (0, "subscripting array declared %<register%>");
2236         }
2237
2238       type = TREE_TYPE (TREE_TYPE (array));
2239       rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2240       /* Array ref is const/volatile if the array elements are
2241          or if the array is..  */
2242       TREE_READONLY (rval)
2243         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2244       TREE_SIDE_EFFECTS (rval)
2245         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2246       TREE_THIS_VOLATILE (rval)
2247         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2248       return require_complete_type (fold_if_not_in_template (rval));
2249     }
2250
2251   {
2252     tree ar = default_conversion (array);
2253     tree ind = default_conversion (idx);
2254
2255     /* Put the integer in IND to simplify error checking.  */
2256     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2257       {
2258         tree temp = ar;
2259         ar = ind;
2260         ind = temp;
2261       }
2262
2263     if (ar == error_mark_node)
2264       return ar;
2265
2266     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2267       {
2268         error ("subscripted value is neither array nor pointer");
2269         return error_mark_node;
2270       }
2271     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2272       {
2273         error ("array subscript is not an integer");
2274         return error_mark_node;
2275       }
2276
2277     return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2278                                "array indexing");
2279   }
2280 }
2281 \f
2282 /* Resolve a pointer to member function.  INSTANCE is the object
2283    instance to use, if the member points to a virtual member.
2284
2285    This used to avoid checking for virtual functions if basetype
2286    has no virtual functions, according to an earlier ANSI draft.
2287    With the final ISO C++ rules, such an optimization is
2288    incorrect: A pointer to a derived member can be static_cast
2289    to pointer-to-base-member, as long as the dynamic object
2290    later has the right member.  */
2291
2292 tree
2293 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2294 {
2295   if (TREE_CODE (function) == OFFSET_REF)
2296     function = TREE_OPERAND (function, 1);
2297
2298   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2299     {
2300       tree idx, delta, e1, e2, e3, vtbl, basetype;
2301       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2302
2303       tree instance_ptr = *instance_ptrptr;
2304       tree instance_save_expr = 0;
2305       if (instance_ptr == error_mark_node)
2306         {
2307           if (TREE_CODE (function) == PTRMEM_CST)
2308             {
2309               /* Extracting the function address from a pmf is only
2310                  allowed with -Wno-pmf-conversions. It only works for
2311                  pmf constants.  */
2312               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2313               e1 = convert (fntype, e1);
2314               return e1;
2315             }
2316           else
2317             {
2318               error ("object missing in use of %qE", function);
2319               return error_mark_node;
2320             }
2321         }
2322
2323       if (TREE_SIDE_EFFECTS (instance_ptr))
2324         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2325
2326       if (TREE_SIDE_EFFECTS (function))
2327         function = save_expr (function);
2328
2329       /* Start by extracting all the information from the PMF itself.  */
2330       e3 = pfn_from_ptrmemfunc (function);
2331       delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2332       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2333       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2334         {
2335         case ptrmemfunc_vbit_in_pfn:
2336           e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2337           idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2338           break;
2339
2340         case ptrmemfunc_vbit_in_delta:
2341           e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2342           delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2343           break;
2344
2345         default:
2346           gcc_unreachable ();
2347         }
2348
2349       /* Convert down to the right base before using the instance.  First
2350          use the type...  */
2351       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2352       basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2353                               basetype, ba_check, NULL);
2354       instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2355       if (instance_ptr == error_mark_node)
2356         return error_mark_node;
2357       /* ...and then the delta in the PMF.  */
2358       instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr),
2359                              instance_ptr, delta);
2360
2361       /* Hand back the adjusted 'this' argument to our caller.  */
2362       *instance_ptrptr = instance_ptr;
2363
2364       /* Next extract the vtable pointer from the object.  */
2365       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2366                      instance_ptr);
2367       vtbl = build_indirect_ref (vtbl, NULL);
2368
2369       /* Finally, extract the function pointer from the vtable.  */
2370       e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx);
2371       e2 = build_indirect_ref (e2, NULL);
2372       TREE_CONSTANT (e2) = 1;
2373       TREE_INVARIANT (e2) = 1;
2374
2375       /* When using function descriptors, the address of the
2376          vtable entry is treated as a function pointer.  */
2377       if (TARGET_VTABLE_USES_DESCRIPTORS)
2378         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2379                      build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2380
2381       TREE_TYPE (e2) = TREE_TYPE (e3);
2382       e1 = build_conditional_expr (e1, e2, e3);
2383       
2384       /* Make sure this doesn't get evaluated first inside one of the
2385          branches of the COND_EXPR.  */
2386       if (instance_save_expr)
2387         e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
2388                      instance_save_expr, e1);
2389
2390       function = e1;
2391     }
2392   return function;
2393 }
2394
2395 tree
2396 build_function_call (tree function, tree params)
2397 {
2398   tree fntype, fndecl;
2399   tree coerced_params;
2400   tree name = NULL_TREE;
2401   int is_method;
2402   tree original = function;
2403
2404   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2405      expressions, like those used for ObjC messenger dispatches.  */
2406   function = objc_rewrite_function_call (function, params);
2407
2408   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2409      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2410   if (TREE_CODE (function) == NOP_EXPR
2411       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2412     function = TREE_OPERAND (function, 0);
2413
2414   if (TREE_CODE (function) == FUNCTION_DECL)
2415     {
2416       name = DECL_NAME (function);
2417
2418       mark_used (function);
2419       fndecl = function;
2420
2421       /* Convert anything with function type to a pointer-to-function.  */
2422       if (pedantic && DECL_MAIN_P (function))
2423         pedwarn ("ISO C++ forbids calling %<::main%> from within program");
2424
2425       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2426          (because calling an inline function does not mean the function
2427          needs to be separately compiled).  */
2428       
2429       if (DECL_INLINE (function))
2430         function = inline_conversion (function);
2431       else
2432         function = build_addr_func (function);
2433     }
2434   else
2435     {
2436       fndecl = NULL_TREE;
2437
2438       function = build_addr_func (function);
2439     }
2440
2441   if (function == error_mark_node)
2442     return error_mark_node;
2443
2444   fntype = TREE_TYPE (function);
2445
2446   if (TYPE_PTRMEMFUNC_P (fntype))
2447     {
2448       error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2449              "function in %<%E (...)%>",
2450              original);
2451       return error_mark_node;
2452     }
2453
2454   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2455                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2456
2457   if (!((TREE_CODE (fntype) == POINTER_TYPE
2458          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2459         || is_method
2460         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2461     {
2462       error ("%qE cannot be used as a function", original);
2463       return error_mark_node;
2464     }
2465
2466   /* fntype now gets the type of function pointed to.  */
2467   fntype = TREE_TYPE (fntype);
2468
2469   /* Convert the parameters to the types declared in the
2470      function prototype, or apply default promotions.  */
2471
2472   coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2473                                       params, fndecl, LOOKUP_NORMAL);
2474   if (coerced_params == error_mark_node)
2475     return error_mark_node;
2476
2477   /* Check for errors in format strings and inappropriately
2478      null parameters.  */
2479
2480   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
2481
2482   return build_cxx_call (function, coerced_params);
2483 }
2484 \f
2485 /* Convert the actual parameter expressions in the list VALUES
2486    to the types in the list TYPELIST.
2487    If parmdecls is exhausted, or when an element has NULL as its type,
2488    perform the default conversions.
2489
2490    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2491
2492    This is also where warnings about wrong number of args are generated.
2493    
2494    Return a list of expressions for the parameters as converted.
2495
2496    Both VALUES and the returned value are chains of TREE_LIST nodes
2497    with the elements of the list in the TREE_VALUE slots of those nodes.
2498
2499    In C++, unspecified trailing parameters can be filled in with their
2500    default arguments, if such were specified.  Do so here.  */
2501
2502 static tree
2503 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2504 {
2505   tree typetail, valtail;
2506   tree result = NULL_TREE;
2507   const char *called_thing = 0;
2508   int i = 0;
2509
2510   /* Argument passing is always copy-initialization.  */
2511   flags |= LOOKUP_ONLYCONVERTING;
2512
2513   if (fndecl)
2514     {
2515       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2516         {
2517           if (DECL_NAME (fndecl) == NULL_TREE
2518               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2519             called_thing = "constructor";
2520           else
2521             called_thing = "member function";
2522         }
2523       else
2524         called_thing = "function";
2525     }
2526
2527   for (valtail = values, typetail = typelist;
2528        valtail;
2529        valtail = TREE_CHAIN (valtail), i++)
2530     {
2531       tree type = typetail ? TREE_VALUE (typetail) : 0;
2532       tree val = TREE_VALUE (valtail);
2533
2534       if (val == error_mark_node)
2535         return error_mark_node;
2536
2537       if (type == void_type_node)
2538         {
2539           if (fndecl)
2540             {
2541               cp_error_at ("too many arguments to %s %q+#D", called_thing,
2542                            fndecl);
2543               error ("at this point in file");
2544             }
2545           else
2546             error ("too many arguments to function");
2547           /* In case anybody wants to know if this argument
2548              list is valid.  */
2549           if (result)
2550             TREE_TYPE (tree_last (result)) = error_mark_node;
2551           break;
2552         }
2553
2554       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2555          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
2556       if (TREE_CODE (val) == NOP_EXPR
2557           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2558           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2559         val = TREE_OPERAND (val, 0);
2560
2561       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2562         {
2563           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2564               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2565               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2566             val = decay_conversion (val);
2567         }
2568
2569       if (val == error_mark_node)
2570         return error_mark_node;
2571
2572       if (type != 0)
2573         {
2574           /* Formal parm type is specified by a function prototype.  */
2575           tree parmval;
2576
2577           if (!COMPLETE_TYPE_P (complete_type (type)))
2578             {
2579               if (fndecl)
2580                 error ("parameter %P of %qD has incomplete type %qT",
2581                        i, fndecl, type);
2582               else
2583                 error ("parameter %P has incomplete type %qT", i, type);
2584               parmval = error_mark_node;
2585             }
2586           else
2587             {
2588               parmval = convert_for_initialization
2589                 (NULL_TREE, type, val, flags,
2590                  "argument passing", fndecl, i);
2591               parmval = convert_for_arg_passing (type, parmval);
2592             }
2593
2594           if (parmval == error_mark_node)
2595             return error_mark_node;
2596
2597           result = tree_cons (NULL_TREE, parmval, result);
2598         }
2599       else
2600         {
2601           if (fndecl && DECL_BUILT_IN (fndecl)
2602               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2603             /* Don't do ellipsis conversion for __built_in_constant_p
2604                as this will result in spurious warnings for non-POD
2605                types.  */
2606             val = require_complete_type (val);
2607           else
2608             val = convert_arg_to_ellipsis (val);
2609
2610           result = tree_cons (NULL_TREE, val, result);
2611         }
2612
2613       if (typetail)
2614         typetail = TREE_CHAIN (typetail);
2615     }
2616
2617   if (typetail != 0 && typetail != void_list_node)
2618     {
2619       /* See if there are default arguments that can be used.  */
2620       if (TREE_PURPOSE (typetail) 
2621           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2622         {
2623           for (; typetail != void_list_node; ++i)
2624             {
2625               tree parmval 
2626                 = convert_default_arg (TREE_VALUE (typetail), 
2627                                        TREE_PURPOSE (typetail), 
2628                                        fndecl, i);
2629
2630               if (parmval == error_mark_node)
2631                 return error_mark_node;
2632
2633               result = tree_cons (0, parmval, result);
2634               typetail = TREE_CHAIN (typetail);
2635               /* ends with `...'.  */
2636               if (typetail == NULL_TREE)
2637                 break;
2638             }
2639         }
2640       else
2641         {
2642           if (fndecl)
2643             {
2644               cp_error_at ("too few arguments to %s %q+#D",
2645                            called_thing, fndecl);
2646               error ("at this point in file");
2647             }
2648           else
2649             error ("too few arguments to function");
2650           return error_mark_list;
2651         }
2652     }
2653
2654   return nreverse (result);
2655 }
2656 \f
2657 /* Build a binary-operation expression, after performing default
2658    conversions on the operands.  CODE is the kind of expression to build.  */
2659
2660 tree
2661 build_x_binary_op (enum tree_code code, tree arg1, tree arg2, 
2662                    bool *overloaded_p)
2663 {
2664   tree orig_arg1;
2665   tree orig_arg2;
2666   tree expr;
2667
2668   orig_arg1 = arg1;
2669   orig_arg2 = arg2;
2670
2671   if (processing_template_decl)
2672     {
2673       if (type_dependent_expression_p (arg1)
2674           || type_dependent_expression_p (arg2))
2675         return build_min_nt (code, arg1, arg2);
2676       arg1 = build_non_dependent_expr (arg1);
2677       arg2 = build_non_dependent_expr (arg2);
2678     }
2679
2680   if (code == DOTSTAR_EXPR)
2681     expr = build_m_component_ref (arg1, arg2);
2682   else
2683     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE, 
2684                          overloaded_p);
2685
2686   if (processing_template_decl && expr != error_mark_node)
2687     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
2688   
2689   return expr;
2690 }
2691
2692 /* Build a binary-operation expression without default conversions.
2693    CODE is the kind of expression to build.
2694    This function differs from `build' in several ways:
2695    the data type of the result is computed and recorded in it,
2696    warnings are generated if arg data types are invalid,
2697    special handling for addition and subtraction of pointers is known,
2698    and some optimization is done (operations on narrow ints
2699    are done in the narrower type when that gives the same result).
2700    Constant folding is also done before the result is returned.
2701
2702    Note that the operands will never have enumeral types
2703    because either they have just had the default conversions performed
2704    or they have both just been converted to some other type in which
2705    the arithmetic is to be done.
2706
2707    C++: must do special pointer arithmetic when implementing
2708    multiple inheritance, and deal with pointer to member functions.  */
2709
2710 tree
2711 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2712                  int convert_p ATTRIBUTE_UNUSED)
2713 {
2714   tree op0, op1;
2715   enum tree_code code0, code1;
2716   tree type0, type1;
2717
2718   /* Expression code to give to the expression when it is built.
2719      Normally this is CODE, which is what the caller asked for,
2720      but in some special cases we change it.  */
2721   enum tree_code resultcode = code;
2722
2723   /* Data type in which the computation is to be performed.
2724      In the simplest cases this is the common type of the arguments.  */
2725   tree result_type = NULL;
2726
2727   /* Nonzero means operands have already been type-converted
2728      in whatever way is necessary.
2729      Zero means they need to be converted to RESULT_TYPE.  */
2730   int converted = 0;
2731
2732   /* Nonzero means create the expression with this type, rather than
2733      RESULT_TYPE.  */
2734   tree build_type = 0;
2735
2736   /* Nonzero means after finally constructing the expression
2737      convert it to this type.  */
2738   tree final_type = 0;
2739
2740   tree result;
2741
2742   /* Nonzero if this is an operation like MIN or MAX which can
2743      safely be computed in short if both args are promoted shorts.
2744      Also implies COMMON.
2745      -1 indicates a bitwise operation; this makes a difference
2746      in the exact conditions for when it is safe to do the operation
2747      in a narrower mode.  */
2748   int shorten = 0;
2749
2750   /* Nonzero if this is a comparison operation;
2751      if both args are promoted shorts, compare the original shorts.
2752      Also implies COMMON.  */
2753   int short_compare = 0;
2754
2755   /* Nonzero if this is a right-shift operation, which can be computed on the
2756      original short and then promoted if the operand is a promoted short.  */
2757   int short_shift = 0;
2758
2759   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
2760   int common = 0;
2761
2762   /* True if both operands have arithmetic type.  */
2763   bool arithmetic_types_p;
2764
2765   /* Apply default conversions.  */
2766   op0 = orig_op0;
2767   op1 = orig_op1;
2768   
2769   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2770       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2771       || code == TRUTH_XOR_EXPR)
2772     {
2773       if (!really_overloaded_fn (op0))
2774         op0 = decay_conversion (op0);
2775       if (!really_overloaded_fn (op1))
2776         op1 = decay_conversion (op1);
2777     }
2778   else
2779     {
2780       if (!really_overloaded_fn (op0))
2781         op0 = default_conversion (op0);
2782       if (!really_overloaded_fn (op1))
2783         op1 = default_conversion (op1);
2784     }
2785
2786   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
2787   STRIP_TYPE_NOPS (op0);
2788   STRIP_TYPE_NOPS (op1);
2789
2790   /* DTRT if one side is an overloaded function, but complain about it.  */
2791   if (type_unknown_p (op0))
2792     {
2793       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2794       if (t != error_mark_node)
2795         {
2796           pedwarn ("assuming cast to type %qT from overloaded function",
2797                    TREE_TYPE (t));
2798           op0 = t;
2799         }
2800     }
2801   if (type_unknown_p (op1))
2802     {
2803       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2804       if (t != error_mark_node)
2805         {
2806           pedwarn ("assuming cast to type %qT from overloaded function",
2807                    TREE_TYPE (t));
2808           op1 = t;
2809         }
2810     }
2811
2812   type0 = TREE_TYPE (op0);
2813   type1 = TREE_TYPE (op1);
2814
2815   /* The expression codes of the data types of the arguments tell us
2816      whether the arguments are integers, floating, pointers, etc.  */
2817   code0 = TREE_CODE (type0);
2818   code1 = TREE_CODE (type1);
2819
2820   /* If an error was already reported for one of the arguments,
2821      avoid reporting another error.  */
2822
2823   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2824     return error_mark_node;
2825
2826   switch (code)
2827     {
2828     case PLUS_EXPR:
2829       /* Handle the pointer + int case.  */
2830       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2831         return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
2832       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2833         return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
2834       else
2835         common = 1;
2836       break;
2837
2838     case MINUS_EXPR:
2839       /* Subtraction of two similar pointers.
2840          We must subtract them as integers, then divide by object size.  */
2841       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2842           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
2843                                                         TREE_TYPE (type1)))
2844         return pointer_diff (op0, op1, common_type (type0, type1));
2845       /* Handle pointer minus int.  Just like pointer plus int.  */
2846       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2847         return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
2848       else
2849         common = 1;
2850       break;
2851
2852     case MULT_EXPR:
2853       common = 1;
2854       break;
2855
2856     case TRUNC_DIV_EXPR:
2857     case CEIL_DIV_EXPR:
2858     case FLOOR_DIV_EXPR:
2859     case ROUND_DIV_EXPR:
2860     case EXACT_DIV_EXPR:
2861       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2862            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2863           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2864               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
2865         {
2866           if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
2867             warning (0, "division by zero in %<%E / 0%>", op0);
2868           else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
2869             warning (0, "division by zero in %<%E / 0.%>", op0);
2870               
2871           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2872             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
2873           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
2874             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
2875
2876           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2877             resultcode = RDIV_EXPR;
2878           else
2879             /* When dividing two signed integers, we have to promote to int.
2880                unless we divide by a constant != -1.  Note that default
2881                conversion will have been performed on the operands at this
2882                point, so we have to dig out the original type to find out if
2883                it was unsigned.  */
2884             shorten = ((TREE_CODE (op0) == NOP_EXPR
2885                         && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2886                        || (TREE_CODE (op1) == INTEGER_CST
2887                            && ! integer_all_onesp (op1)));
2888
2889           common = 1;
2890         }
2891       break;
2892
2893     case BIT_AND_EXPR:
2894     case BIT_IOR_EXPR:
2895     case BIT_XOR_EXPR:
2896       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2897         shorten = -1;
2898       break;
2899
2900     case TRUNC_MOD_EXPR:
2901     case FLOOR_MOD_EXPR:
2902       if (code1 == INTEGER_TYPE && integer_zerop (op1))
2903         warning (0, "division by zero in %<%E %% 0%>", op0);
2904       else if (code1 == REAL_TYPE && real_zerop (op1))
2905         warning (0, "division by zero in %<%E %% 0.%>", op0);
2906       
2907       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2908         {
2909           /* Although it would be tempting to shorten always here, that loses
2910              on some targets, since the modulo instruction is undefined if the
2911              quotient can't be represented in the computation mode.  We shorten
2912              only if unsigned or if dividing by something we know != -1.  */
2913           shorten = ((TREE_CODE (op0) == NOP_EXPR
2914                       && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2915                      || (TREE_CODE (op1) == INTEGER_CST
2916                          && ! integer_all_onesp (op1)));
2917           common = 1;
2918         }
2919       break;
2920
2921     case TRUTH_ANDIF_EXPR:
2922     case TRUTH_ORIF_EXPR:
2923     case TRUTH_AND_EXPR:
2924     case TRUTH_OR_EXPR:
2925       result_type = boolean_type_node;
2926       break;
2927
2928       /* Shift operations: result has same type as first operand;
2929          always convert second operand to int.
2930          Also set SHORT_SHIFT if shifting rightward.  */
2931
2932     case RSHIFT_EXPR:
2933       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2934         {
2935           result_type = type0;
2936           if (TREE_CODE (op1) == INTEGER_CST)
2937             {
2938               if (tree_int_cst_lt (op1, integer_zero_node))
2939                 warning (0, "right shift count is negative");
2940               else
2941                 {
2942                   if (! integer_zerop (op1))
2943                     short_shift = 1;
2944                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2945                     warning (0, "right shift count >= width of type");
2946                 }
2947             }
2948           /* Convert the shift-count to an integer, regardless of
2949              size of value being shifted.  */
2950           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2951             op1 = cp_convert (integer_type_node, op1);
2952           /* Avoid converting op1 to result_type later.  */
2953           converted = 1;
2954         }
2955       break;
2956
2957     case LSHIFT_EXPR:
2958       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2959         {
2960           result_type = type0;
2961           if (TREE_CODE (op1) == INTEGER_CST)
2962             {
2963               if (tree_int_cst_lt (op1, integer_zero_node))
2964                 warning (0, "left shift count is negative");
2965               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2966                 warning (0, "left shift count >= width of type");
2967             }
2968           /* Convert the shift-count to an integer, regardless of
2969              size of value being shifted.  */
2970           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2971             op1 = cp_convert (integer_type_node, op1);
2972           /* Avoid converting op1 to result_type later.  */
2973           converted = 1;
2974         }
2975       break;
2976
2977     case RROTATE_EXPR:
2978     case LROTATE_EXPR:
2979       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2980         {
2981           result_type = type0;
2982           if (TREE_CODE (op1) == INTEGER_CST)
2983             {
2984               if (tree_int_cst_lt (op1, integer_zero_node))
2985                 warning (0, "%s rotate count is negative",
2986                          (code == LROTATE_EXPR) ? "left" : "right");
2987               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2988                 warning (0, "%s rotate count >= width of type",
2989                          (code == LROTATE_EXPR) ? "left" : "right");
2990             }
2991           /* Convert the shift-count to an integer, regardless of
2992              size of value being shifted.  */
2993           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2994             op1 = cp_convert (integer_type_node, op1);
2995         }
2996       break;
2997
2998     case EQ_EXPR:
2999     case NE_EXPR:
3000       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3001         warning (0, "comparing floating point with == or != is unsafe");
3002
3003       build_type = boolean_type_node; 
3004       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3005            || code0 == COMPLEX_TYPE)
3006           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3007               || code1 == COMPLEX_TYPE))
3008         short_compare = 1;
3009       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3010                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3011         result_type = composite_pointer_type (type0, type1, op0, op1,
3012                                               "comparison");
3013       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3014                && null_ptr_cst_p (op1))
3015         result_type = type0;
3016       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3017                && null_ptr_cst_p (op0))
3018         result_type = type1;
3019       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3020         {
3021           result_type = type0;
3022           error ("ISO C++ forbids comparison between pointer and integer");
3023         }
3024       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3025         {
3026           result_type = type1;
3027           error ("ISO C++ forbids comparison between pointer and integer");
3028         }
3029       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3030         {
3031           op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3032           op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3033           result_type = TREE_TYPE (op0);
3034         }
3035       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3036         return cp_build_binary_op (code, op1, op0);
3037       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3038                && same_type_p (type0, type1))
3039         {
3040           /* E will be the final comparison.  */
3041           tree e;
3042           /* E1 and E2 are for scratch.  */
3043           tree e1;
3044           tree e2;
3045           tree pfn0;
3046           tree pfn1;
3047           tree delta0;
3048           tree delta1;
3049
3050           if (TREE_SIDE_EFFECTS (op0))
3051             op0 = save_expr (op0);
3052           if (TREE_SIDE_EFFECTS (op1))
3053             op1 = save_expr (op1);
3054
3055           /* We generate:
3056
3057              (op0.pfn == op1.pfn 
3058               && (!op0.pfn || op0.delta == op1.delta))
3059              
3060              The reason for the `!op0.pfn' bit is that a NULL
3061              pointer-to-member is any member with a zero PFN; the
3062              DELTA field is unspecified.  */
3063           pfn0 = pfn_from_ptrmemfunc (op0);
3064           pfn1 = pfn_from_ptrmemfunc (op1);
3065           delta0 = build_ptrmemfunc_access_expr (op0,
3066                                                  delta_identifier);
3067           delta1 = build_ptrmemfunc_access_expr (op1,
3068                                                  delta_identifier);
3069           e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3070           e2 = cp_build_binary_op (EQ_EXPR, 
3071                                    pfn0,
3072                                    cp_convert (TREE_TYPE (pfn0),
3073                                                integer_zero_node));
3074           e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3075           e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3076           e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3077           if (code == EQ_EXPR)
3078             return e;
3079           return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3080         }
3081       else
3082         {
3083           gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3084                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3085                                        type1));
3086           gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3087                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3088                                        type0));
3089         }
3090       
3091       break;
3092
3093     case MAX_EXPR:
3094     case MIN_EXPR:
3095       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3096            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3097         shorten = 1;
3098       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3099         result_type = composite_pointer_type (type0, type1, op0, op1,
3100                                               "comparison");
3101       break;
3102
3103     case LE_EXPR:
3104     case GE_EXPR:
3105     case LT_EXPR:
3106     case GT_EXPR:
3107       build_type = boolean_type_node;
3108       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3109            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3110         short_compare = 1;
3111       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3112         result_type = composite_pointer_type (type0, type1, op0, op1,
3113                                               "comparison");
3114       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3115                && integer_zerop (op1))
3116         result_type = type0;
3117       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3118                && integer_zerop (op0))
3119         result_type = type1;
3120       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3121         {
3122           result_type = type0;
3123           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3124         }
3125       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3126         {
3127           result_type = type1;
3128           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3129         }
3130       break;
3131
3132     case UNORDERED_EXPR:
3133     case ORDERED_EXPR:
3134     case UNLT_EXPR:
3135     case UNLE_EXPR:
3136     case UNGT_EXPR:
3137     case UNGE_EXPR:
3138     case UNEQ_EXPR:
3139       build_type = integer_type_node;
3140       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3141         {
3142           error ("unordered comparison on non-floating point argument");
3143           return error_mark_node;
3144         }
3145       common = 1;
3146       break;
3147
3148     default:
3149       break;
3150     }
3151
3152   arithmetic_types_p = 
3153     ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3154      && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 
3155          || code1 == COMPLEX_TYPE));
3156   /* Determine the RESULT_TYPE, if it is not already known.  */
3157   if (!result_type
3158       && arithmetic_types_p 
3159       && (shorten || common || short_compare))
3160     result_type = common_type (type0, type1);
3161
3162   if (!result_type)
3163     {
3164       error ("invalid operands of types %qT and %qT to binary %qO",
3165              TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3166       return error_mark_node;
3167     }
3168
3169   /* If we're in a template, the only thing we need to know is the
3170      RESULT_TYPE.  */
3171   if (processing_template_decl)
3172     return build2 (resultcode, 
3173                    build_type ? build_type : result_type, 
3174                    op0, op1);
3175
3176   if (arithmetic_types_p)
3177     {
3178       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3179
3180       /* For certain operations (which identify themselves by shorten != 0)
3181          if both args were extended from the same smaller type,
3182          do the arithmetic in that type and then extend.
3183
3184          shorten !=0 and !=1 indicates a bitwise operation.
3185          For them, this optimization is safe only if
3186          both args are zero-extended or both are sign-extended.
3187          Otherwise, we might change the result.
3188          Eg, (short)-1 | (unsigned short)-1 is (int)-1
3189          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3190
3191       if (shorten && none_complex)
3192         {
3193           int unsigned0, unsigned1;
3194           tree arg0 = get_narrower (op0, &unsigned0);
3195           tree arg1 = get_narrower (op1, &unsigned1);
3196           /* UNS is 1 if the operation to be done is an unsigned one.  */
3197           int uns = TYPE_UNSIGNED (result_type);
3198           tree type;
3199
3200           final_type = result_type;
3201
3202           /* Handle the case that OP0 does not *contain* a conversion
3203              but it *requires* conversion to FINAL_TYPE.  */
3204
3205           if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3206             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3207           if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3208             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3209
3210           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
3211
3212           /* For bitwise operations, signedness of nominal type
3213              does not matter.  Consider only how operands were extended.  */
3214           if (shorten == -1)
3215             uns = unsigned0;
3216
3217           /* Note that in all three cases below we refrain from optimizing
3218              an unsigned operation on sign-extended args.
3219              That would not be valid.  */
3220
3221           /* Both args variable: if both extended in same way
3222              from same width, do it in that width.
3223              Do it unsigned if args were zero-extended.  */
3224           if ((TYPE_PRECISION (TREE_TYPE (arg0))
3225                < TYPE_PRECISION (result_type))
3226               && (TYPE_PRECISION (TREE_TYPE (arg1))
3227                   == TYPE_PRECISION (TREE_TYPE (arg0)))
3228               && unsigned0 == unsigned1
3229               && (unsigned0 || !uns))
3230             result_type = c_common_signed_or_unsigned_type
3231               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3232           else if (TREE_CODE (arg0) == INTEGER_CST
3233                    && (unsigned1 || !uns)
3234                    && (TYPE_PRECISION (TREE_TYPE (arg1))
3235                        < TYPE_PRECISION (result_type))
3236                    && (type = c_common_signed_or_unsigned_type
3237                        (unsigned1, TREE_TYPE (arg1)),
3238                        int_fits_type_p (arg0, type)))
3239             result_type = type;
3240           else if (TREE_CODE (arg1) == INTEGER_CST
3241                    && (unsigned0 || !uns)
3242                    && (TYPE_PRECISION (TREE_TYPE (arg0))
3243                        < TYPE_PRECISION (result_type))
3244                    && (type = c_common_signed_or_unsigned_type
3245                        (unsigned0, TREE_TYPE (arg0)),
3246                        int_fits_type_p (arg1, type)))
3247             result_type = type;
3248         }
3249
3250       /* Shifts can be shortened if shifting right.  */
3251
3252       if (short_shift)
3253         {
3254           int unsigned_arg;
3255           tree arg0 = get_narrower (op0, &unsigned_arg);
3256
3257           final_type = result_type;
3258
3259           if (arg0 == op0 && final_type == TREE_TYPE (op0))
3260             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
3261
3262           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3263               /* We can shorten only if the shift count is less than the
3264                  number of bits in the smaller type size.  */
3265               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3266               /* If arg is sign-extended and then unsigned-shifted,
3267                  we can simulate this with a signed shift in arg's type
3268                  only if the extended result is at least twice as wide
3269                  as the arg.  Otherwise, the shift could use up all the
3270                  ones made by sign-extension and bring in zeros.
3271                  We can't optimize that case at all, but in most machines
3272                  it never happens because available widths are 2**N.  */
3273               && (!TYPE_UNSIGNED (final_type)
3274                   || unsigned_arg
3275                   || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3276                       <= TYPE_PRECISION (result_type))))
3277             {
3278               /* Do an unsigned shift if the operand was zero-extended.  */
3279               result_type
3280                 = c_common_signed_or_unsigned_type (unsigned_arg,
3281                                                     TREE_TYPE (arg0));
3282               /* Convert value-to-be-shifted to that type.  */
3283               if (TREE_TYPE (op0) != result_type)
3284                 op0 = cp_convert (result_type, op0);
3285               converted = 1;
3286             }
3287         }
3288
3289       /* Comparison operations are shortened too but differently.
3290          They identify themselves by setting short_compare = 1.  */
3291
3292       if (short_compare)
3293         {
3294           /* Don't write &op0, etc., because that would prevent op0
3295              from being kept in a register.
3296              Instead, make copies of the our local variables and
3297              pass the copies by reference, then copy them back afterward.  */
3298           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3299           enum tree_code xresultcode = resultcode;
3300           tree val 
3301             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3302           if (val != 0)
3303             return cp_convert (boolean_type_node, val);
3304           op0 = xop0, op1 = xop1;
3305           converted = 1;
3306           resultcode = xresultcode;
3307         }
3308
3309       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3310           && warn_sign_compare
3311           /* Do not warn until the template is instantiated; we cannot
3312              bound the ranges of the arguments until that point.  */
3313           && !processing_template_decl)
3314         {
3315           int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
3316           int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3317
3318           int unsignedp0, unsignedp1;
3319           tree primop0 = get_narrower (op0, &unsignedp0);
3320           tree primop1 = get_narrower (op1, &unsignedp1);
3321
3322           /* Check for comparison of different enum types.  */
3323           if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE 
3324               && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE 
3325               && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3326                  != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3327             {
3328               warning (0, "comparison between types %q#T and %q#T", 
3329                        TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3330             }
3331
3332           /* Give warnings for comparisons between signed and unsigned
3333              quantities that may fail.  */
3334           /* Do the checking based on the original operand trees, so that
3335              casts will be considered, but default promotions won't be.  */
3336
3337           /* Do not warn if the comparison is being done in a signed type,
3338              since the signed type will only be chosen if it can represent
3339              all the values of the unsigned type.  */
3340           if (!TYPE_UNSIGNED (result_type))
3341             /* OK */;
3342           /* Do not warn if both operands are unsigned.  */
3343           else if (op0_signed == op1_signed)
3344             /* OK */;
3345           /* Do not warn if the signed quantity is an unsuffixed
3346              integer literal (or some static constant expression
3347              involving such literals or a conditional expression
3348              involving such literals) and it is non-negative.  */
3349           else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3350                    || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3351             /* OK */;
3352           /* Do not warn if the comparison is an equality operation,
3353              the unsigned quantity is an integral constant and it does
3354              not use the most significant bit of result_type.  */
3355           else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3356                    && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3357                         && int_fits_type_p (orig_op1, c_common_signed_type
3358                                             (result_type)))
3359                         || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3360                             && int_fits_type_p (orig_op0, c_common_signed_type
3361                                                 (result_type)))))
3362             /* OK */;
3363           else
3364             warning (0, "comparison between signed and unsigned integer expressions");
3365
3366           /* Warn if two unsigned values are being compared in a size
3367              larger than their original size, and one (and only one) is the
3368              result of a `~' operator.  This comparison will always fail.
3369
3370              Also warn if one operand is a constant, and the constant does not
3371              have all bits set that are set in the ~ operand when it is
3372              extended.  */
3373
3374           if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3375               ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3376             {
3377               if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3378                 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3379               if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3380                 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3381               
3382               if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3383                 {
3384                   tree primop;
3385                   HOST_WIDE_INT constant, mask;
3386                   int unsignedp;
3387                   unsigned int bits;
3388
3389                   if (host_integerp (primop0, 0))
3390                     {
3391                       primop = primop1;
3392                       unsignedp = unsignedp1;
3393                       constant = tree_low_cst (primop0, 0);
3394                     }
3395                   else
3396                     {
3397                       primop = primop0;
3398                       unsignedp = unsignedp0;
3399                       constant = tree_low_cst (primop1, 0);
3400                     }
3401
3402                   bits = TYPE_PRECISION (TREE_TYPE (primop));
3403                   if (bits < TYPE_PRECISION (result_type)
3404                       && bits < HOST_BITS_PER_LONG && unsignedp)
3405                     {
3406                       mask = (~ (HOST_WIDE_INT) 0) << bits;
3407                       if ((mask & constant) != mask)
3408                         warning (0, "comparison of promoted ~unsigned with constant");
3409                     }
3410                 }
3411               else if (unsignedp0 && unsignedp1
3412                        && (TYPE_PRECISION (TREE_TYPE (primop0))
3413                            < TYPE_PRECISION (result_type))
3414                        && (TYPE_PRECISION (TREE_TYPE (primop1))
3415                            < TYPE_PRECISION (result_type)))
3416                 warning (0, "comparison of promoted ~unsigned with unsigned");
3417             }
3418         }
3419     }
3420
3421   /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3422      Then the expression will be built.
3423      It will be given type FINAL_TYPE if that is nonzero;
3424      otherwise, it will be given type RESULT_TYPE.  */
3425
3426   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3427   if (/* It's reasonable to use pointer values as operands of &&
3428          and ||, so NULL is no exception.  */
3429       !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3430       && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
3431           (orig_op0 == null_node
3432            && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3433           /* Or vice versa.  */
3434           || (orig_op1 == null_node
3435               && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3436           /* Or, both are NULL and the operation was not a comparison.  */
3437           || (orig_op0 == null_node && orig_op1 == null_node 
3438               && code != EQ_EXPR && code != NE_EXPR)))
3439     /* Some sort of arithmetic operation involving NULL was
3440