OSDN Git Service

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