OSDN Git Service

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