OSDN Git Service

402f9e4ce819c3b860648cc6fe7489d4aa080cd7
[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 structural_comptypes.
1100    Compare the template type parameters T1 and T2.
1101    Return TRUE if we are sure they can't be equal, FALSE otherwise.  */
1102
1103 static bool
1104 incompatible_template_type_parms_p (tree t1, tree t2)
1105 {
1106   tree decl1, tparms1 = NULL_TREE,
1107        decl2, tparms2 = NULL_TREE;
1108
1109   gcc_assert (t1 && TREE_CODE (t1) == TEMPLATE_TYPE_PARM
1110               && t2 && TREE_CODE (t2) == TEMPLATE_TYPE_PARM);
1111
1112   /* If T1 and T2 don't have the same relative position in their
1113      template parameters set, they can't be equal.  */
1114   if (!comp_template_parms_position (t1, t2))
1115     return true;
1116
1117   if (!typedef_variant_p (t1) && !typedef_variant_p (t2))
1118     /* If neither T1 nor T2 is a typedef we cannot know more
1119        about their incompatibility than what comp_template_parms_position
1120        told us above. If we try to keep going nonetheless, the call to
1121        comp_template_parms at the end of this function might lead to an
1122        infinite recursion.  */
1123     return false;
1124
1125   decl1 = TYPE_NAME (t1);
1126   decl2 = TYPE_NAME (t2);
1127   if (decl1 == NULL_TREE || decl2 == NULL_TREE || decl1 == decl2)
1128     return false ;
1129
1130   /* So if we reach this point, it means either T1 or T2 is a typedef variant.
1131      Let's compare their template parameters.  */
1132
1133   /* If T1 is not a typedef, there possibly is a delay between the
1134      creation of DECL1 and the setting of DECL_CONTEXT (DECL1) to its
1135      template decl so DECL_CONTEXT (DECL1) can be empty for
1136      a little while.  */
1137   if (DECL_CONTEXT (decl1))
1138     {
1139       if (TREE_CODE (DECL_CONTEXT (decl1)) == TEMPLATE_DECL)
1140         tparms1 = DECL_TEMPLATE_PARMS (DECL_CONTEXT (decl1));
1141       else
1142         /* T1 is a typedef variant type. Get the parms of its context.  */
1143         tparms1 =
1144           DECL_TEMPLATE_PARMS (TI_TEMPLATE
1145                                  (get_template_info (DECL_CONTEXT (decl1))));
1146     }
1147
1148   /* Do the same thing for DECL2.  */
1149   if (DECL_CONTEXT (decl2))
1150     {
1151       if (TREE_CODE (DECL_CONTEXT (decl2)) == TEMPLATE_DECL)
1152         tparms2 = DECL_TEMPLATE_PARMS (DECL_CONTEXT (decl2));
1153       else
1154         tparms2 =
1155           DECL_TEMPLATE_PARMS (TI_TEMPLATE
1156                                 (get_template_info (DECL_CONTEXT (decl2))));
1157     }
1158
1159   if (tparms1 == NULL_TREE
1160       || tparms2 == NULL_TREE
1161       || tparms1 == tparms2)
1162     return false;
1163
1164   /* And now compare the mighty template parms!  */
1165   return !comp_template_parms (tparms1, tparms2);
1166 }
1167
1168 /* Subroutine in comptypes.  */
1169
1170 static bool
1171 structural_comptypes (tree t1, tree t2, int strict)
1172 {
1173   if (t1 == t2)
1174     return true;
1175
1176   /* Suppress errors caused by previously reported errors.  */
1177   if (t1 == error_mark_node || t2 == error_mark_node)
1178     return false;
1179
1180   gcc_assert (TYPE_P (t1) && TYPE_P (t2));
1181
1182   /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1183      current instantiation.  */
1184   if (TREE_CODE (t1) == TYPENAME_TYPE)
1185     t1 = resolve_typename_type (t1, /*only_current_p=*/true);
1186
1187   if (TREE_CODE (t2) == TYPENAME_TYPE)
1188     t2 = resolve_typename_type (t2, /*only_current_p=*/true);
1189
1190   if (TYPE_PTRMEMFUNC_P (t1))
1191     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
1192   if (TYPE_PTRMEMFUNC_P (t2))
1193     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
1194
1195   /* Different classes of types can't be compatible.  */
1196   if (TREE_CODE (t1) != TREE_CODE (t2))
1197     return false;
1198
1199   /* Qualifiers must match.  For array types, we will check when we
1200      recur on the array element types.  */
1201   if (TREE_CODE (t1) != ARRAY_TYPE
1202       && TYPE_QUALS (t1) != TYPE_QUALS (t2))
1203     return false;
1204   if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
1205     return false;
1206
1207   /* Allow for two different type nodes which have essentially the same
1208      definition.  Note that we already checked for equality of the type
1209      qualifiers (just above).  */
1210
1211   if (TREE_CODE (t1) != ARRAY_TYPE
1212       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1213     return true;
1214
1215   /* Compare the types.  Break out if they could be the same.  */
1216   switch (TREE_CODE (t1))
1217     {
1218     case VOID_TYPE:
1219     case BOOLEAN_TYPE:
1220       /* All void and bool types are the same.  */
1221       break;
1222
1223     case INTEGER_TYPE:
1224     case FIXED_POINT_TYPE:
1225     case REAL_TYPE:
1226       /* With these nodes, we can't determine type equivalence by
1227          looking at what is stored in the nodes themselves, because
1228          two nodes might have different TYPE_MAIN_VARIANTs but still
1229          represent the same type.  For example, wchar_t and int could
1230          have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1231          TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1232          and are distinct types. On the other hand, int and the
1233          following typedef
1234
1235            typedef int INT __attribute((may_alias));
1236
1237          have identical properties, different TYPE_MAIN_VARIANTs, but
1238          represent the same type.  The canonical type system keeps
1239          track of equivalence in this case, so we fall back on it.  */
1240       return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1241
1242     case TEMPLATE_TEMPLATE_PARM:
1243     case BOUND_TEMPLATE_TEMPLATE_PARM:
1244       if (!comp_template_parms_position (t1, t2))
1245         return false;
1246       if (!comp_template_parms
1247           (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1248            DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1249         return false;
1250       if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1251         break;
1252       /* Don't check inheritance.  */
1253       strict = COMPARE_STRICT;
1254       /* Fall through.  */
1255
1256     case RECORD_TYPE:
1257     case UNION_TYPE:
1258       if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1259           && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1260               || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1261           && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1262         break;
1263
1264       if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1265         break;
1266       else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1267         break;
1268
1269       return false;
1270
1271     case OFFSET_TYPE:
1272       if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1273                       strict & ~COMPARE_REDECLARATION))
1274         return false;
1275       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1276         return false;
1277       break;
1278
1279     case REFERENCE_TYPE:
1280       if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
1281         return false;
1282       /* fall through to checks for pointer types */
1283
1284     case POINTER_TYPE:
1285       if (TYPE_MODE (t1) != TYPE_MODE (t2)
1286           || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1287           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1288         return false;
1289       break;
1290
1291     case METHOD_TYPE:
1292     case FUNCTION_TYPE:
1293       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1294         return false;
1295       if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1296         return false;
1297       break;
1298
1299     case ARRAY_TYPE:
1300       /* Target types must match incl. qualifiers.  */
1301       if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1302         return false;
1303       break;
1304
1305     case TEMPLATE_TYPE_PARM:
1306       if (incompatible_template_type_parms_p (t1, t2))
1307         return false;
1308       break;
1309
1310     case TYPENAME_TYPE:
1311       if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1312                           TYPENAME_TYPE_FULLNAME (t2)))
1313         return false;
1314       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1315         return false;
1316       break;
1317
1318     case UNBOUND_CLASS_TEMPLATE:
1319       if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1320         return false;
1321       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1322         return false;
1323       break;
1324
1325     case COMPLEX_TYPE:
1326       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1327         return false;
1328       break;
1329
1330     case VECTOR_TYPE:
1331       if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1332           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1333         return false;
1334       break;
1335
1336     case TYPE_PACK_EXPANSION:
1337       return same_type_p (PACK_EXPANSION_PATTERN (t1), 
1338                           PACK_EXPANSION_PATTERN (t2));
1339
1340     case DECLTYPE_TYPE:
1341       if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1)
1342           != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2)
1343           || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1)
1344               != DECLTYPE_FOR_LAMBDA_CAPTURE (t2))
1345           || (DECLTYPE_FOR_LAMBDA_RETURN (t1)
1346               != DECLTYPE_FOR_LAMBDA_RETURN (t2))
1347           || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1), 
1348                              DECLTYPE_TYPE_EXPR (t2)))
1349         return false;
1350       break;
1351
1352     default:
1353       return false;
1354     }
1355
1356   /* If we get here, we know that from a target independent POV the
1357      types are the same.  Make sure the target attributes are also
1358      the same.  */
1359   return targetm.comp_type_attributes (t1, t2);
1360 }
1361
1362 /* Return true if T1 and T2 are related as allowed by STRICT.  STRICT
1363    is a bitwise-or of the COMPARE_* flags.  */
1364
1365 bool
1366 comptypes (tree t1, tree t2, int strict)
1367 {
1368   if (strict == COMPARE_STRICT)
1369     {
1370       if (t1 == t2)
1371         return true;
1372
1373       if (t1 == error_mark_node || t2 == error_mark_node)
1374         return false;
1375
1376       if (TYPE_STRUCTURAL_EQUALITY_P (t1) || TYPE_STRUCTURAL_EQUALITY_P (t2))
1377         /* At least one of the types requires structural equality, so
1378            perform a deep check. */
1379         return structural_comptypes (t1, t2, strict);
1380
1381 #ifdef ENABLE_CHECKING
1382       if (USE_CANONICAL_TYPES)
1383         {
1384           bool result = structural_comptypes (t1, t2, strict);
1385           
1386           if (result && TYPE_CANONICAL (t1) != TYPE_CANONICAL (t2))
1387             /* The two types are structurally equivalent, but their
1388                canonical types were different. This is a failure of the
1389                canonical type propagation code.*/
1390             internal_error 
1391               ("canonical types differ for identical types %T and %T", 
1392                t1, t2);
1393           else if (!result && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
1394             /* Two types are structurally different, but the canonical
1395                types are the same. This means we were over-eager in
1396                assigning canonical types. */
1397             internal_error 
1398               ("same canonical type node for different types %T and %T",
1399                t1, t2);
1400           
1401           return result;
1402         }
1403 #else
1404       if (USE_CANONICAL_TYPES)
1405         return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1406 #endif
1407       else
1408         return structural_comptypes (t1, t2, strict);
1409     }
1410   else if (strict == COMPARE_STRUCTURAL)
1411     return structural_comptypes (t1, t2, COMPARE_STRICT);
1412   else
1413     return structural_comptypes (t1, t2, strict);
1414 }
1415
1416 /* Returns 1 if TYPE1 is at least as qualified as TYPE2.  */
1417
1418 bool
1419 at_least_as_qualified_p (const_tree type1, const_tree type2)
1420 {
1421   int q1 = cp_type_quals (type1);
1422   int q2 = cp_type_quals (type2);
1423
1424   /* All qualifiers for TYPE2 must also appear in TYPE1.  */
1425   return (q1 & q2) == q2;
1426 }
1427
1428 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1429    more cv-qualified that TYPE1, and 0 otherwise.  */
1430
1431 int
1432 comp_cv_qualification (const_tree type1, const_tree type2)
1433 {
1434   int q1 = cp_type_quals (type1);
1435   int q2 = cp_type_quals (type2);
1436
1437   if (q1 == q2)
1438     return 0;
1439
1440   if ((q1 & q2) == q2)
1441     return 1;
1442   else if ((q1 & q2) == q1)
1443     return -1;
1444
1445   return 0;
1446 }
1447
1448 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1449    subset of the cv-qualification signature of TYPE2, and the types
1450    are similar.  Returns -1 if the other way 'round, and 0 otherwise.  */
1451
1452 int
1453 comp_cv_qual_signature (tree type1, tree type2)
1454 {
1455   if (comp_ptr_ttypes_real (type2, type1, -1))
1456     return 1;
1457   else if (comp_ptr_ttypes_real (type1, type2, -1))
1458     return -1;
1459   else
1460     return 0;
1461 }
1462 \f
1463 /* Subroutines of `comptypes'.  */
1464
1465 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1466    equivalent in the sense that functions with those parameter types
1467    can have equivalent types.  The two lists must be equivalent,
1468    element by element.  */
1469
1470 bool
1471 compparms (const_tree parms1, const_tree parms2)
1472 {
1473   const_tree t1, t2;
1474
1475   /* An unspecified parmlist matches any specified parmlist
1476      whose argument types don't need default promotions.  */
1477
1478   for (t1 = parms1, t2 = parms2;
1479        t1 || t2;
1480        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1481     {
1482       /* If one parmlist is shorter than the other,
1483          they fail to match.  */
1484       if (!t1 || !t2)
1485         return false;
1486       if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1487         return false;
1488     }
1489   return true;
1490 }
1491
1492 \f
1493 /* Process a sizeof or alignof expression where the operand is a
1494    type.  */
1495
1496 tree
1497 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1498 {
1499   tree value;
1500   bool dependent_p;
1501
1502   gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1503   if (type == error_mark_node)
1504     return error_mark_node;
1505
1506   type = non_reference (type);
1507   if (TREE_CODE (type) == METHOD_TYPE)
1508     {
1509       if (complain)
1510         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
1511                  "invalid application of %qs to a member function", 
1512                  operator_name_info[(int) op].name);
1513       value = size_one_node;
1514     }
1515
1516   dependent_p = dependent_type_p (type);
1517   if (!dependent_p)
1518     complete_type (type);
1519   if (dependent_p
1520       /* VLA types will have a non-constant size.  In the body of an
1521          uninstantiated template, we don't need to try to compute the
1522          value, because the sizeof expression is not an integral
1523          constant expression in that case.  And, if we do try to
1524          compute the value, we'll likely end up with SAVE_EXPRs, which
1525          the template substitution machinery does not expect to see.  */
1526       || (processing_template_decl 
1527           && COMPLETE_TYPE_P (type)
1528           && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
1529     {
1530       value = build_min (op, size_type_node, type);
1531       TREE_READONLY (value) = 1;
1532       return value;
1533     }
1534
1535   return c_sizeof_or_alignof_type (input_location, complete_type (type),
1536                                    op == SIZEOF_EXPR,
1537                                    complain);
1538 }
1539
1540 /* Return the size of the type, without producing any warnings for
1541    types whose size cannot be taken.  This routine should be used only
1542    in some other routine that has already produced a diagnostic about
1543    using the size of such a type.  */
1544 tree 
1545 cxx_sizeof_nowarn (tree type)
1546 {
1547   if (TREE_CODE (type) == FUNCTION_TYPE
1548       || TREE_CODE (type) == VOID_TYPE
1549       || TREE_CODE (type) == ERROR_MARK)
1550     return size_one_node;
1551   else if (!COMPLETE_TYPE_P (type))
1552     return size_zero_node;
1553   else
1554     return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false);
1555 }
1556
1557 /* Process a sizeof expression where the operand is an expression.  */
1558
1559 static tree
1560 cxx_sizeof_expr (tree e, tsubst_flags_t complain)
1561 {
1562   if (e == error_mark_node)
1563     return error_mark_node;
1564
1565   if (processing_template_decl)
1566     {
1567       e = build_min (SIZEOF_EXPR, size_type_node, e);
1568       TREE_SIDE_EFFECTS (e) = 0;
1569       TREE_READONLY (e) = 1;
1570
1571       return e;
1572     }
1573
1574   if (TREE_CODE (e) == COMPONENT_REF
1575       && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1576       && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1577     {
1578       if (complain & tf_error)
1579         error ("invalid application of %<sizeof%> to a bit-field");
1580       else
1581         return error_mark_node;
1582       e = char_type_node;
1583     }
1584   else if (is_overloaded_fn (e))
1585     {
1586       if (complain & tf_error)
1587         permerror (input_location, "ISO C++ forbids applying %<sizeof%> to an expression of "
1588                    "function type");
1589       else
1590         return error_mark_node;
1591       e = char_type_node;
1592     }
1593   else if (type_unknown_p (e))
1594     {
1595       if (complain & tf_error)
1596         cxx_incomplete_type_error (e, TREE_TYPE (e));
1597       else
1598         return error_mark_node;
1599       e = char_type_node;
1600     }
1601   else
1602     e = TREE_TYPE (e);
1603
1604   return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error);
1605 }
1606
1607 /* Implement the __alignof keyword: Return the minimum required
1608    alignment of E, measured in bytes.  For VAR_DECL's and
1609    FIELD_DECL's return DECL_ALIGN (which can be set from an
1610    "aligned" __attribute__ specification).  */
1611
1612 static tree
1613 cxx_alignof_expr (tree e, tsubst_flags_t complain)
1614 {
1615   tree t;
1616
1617   if (e == error_mark_node)
1618     return error_mark_node;
1619
1620   if (processing_template_decl)
1621     {
1622       e = build_min (ALIGNOF_EXPR, size_type_node, e);
1623       TREE_SIDE_EFFECTS (e) = 0;
1624       TREE_READONLY (e) = 1;
1625
1626       return e;
1627     }
1628
1629   if (TREE_CODE (e) == VAR_DECL)
1630     t = size_int (DECL_ALIGN_UNIT (e));
1631   else if (TREE_CODE (e) == COMPONENT_REF
1632            && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1633            && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1634     {
1635       if (complain & tf_error)
1636         error ("invalid application of %<__alignof%> to a bit-field");
1637       else
1638         return error_mark_node;
1639       t = size_one_node;
1640     }
1641   else if (TREE_CODE (e) == COMPONENT_REF
1642            && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL)
1643     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1)));
1644   else if (is_overloaded_fn (e))
1645     {
1646       if (complain & tf_error)
1647         permerror (input_location, "ISO C++ forbids applying %<__alignof%> to an expression of "
1648                    "function type");
1649       else
1650         return error_mark_node;
1651       if (TREE_CODE (e) == FUNCTION_DECL)
1652         t = size_int (DECL_ALIGN_UNIT (e));
1653       else
1654         t = size_one_node;
1655     }
1656   else if (type_unknown_p (e))
1657     {
1658       if (complain & tf_error)
1659         cxx_incomplete_type_error (e, TREE_TYPE (e));
1660       else
1661         return error_mark_node;
1662       t = size_one_node;
1663     }
1664   else
1665     return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR, 
1666                                        complain & tf_error);
1667
1668   return fold_convert (size_type_node, t);
1669 }
1670
1671 /* Process a sizeof or alignof expression E with code OP where the operand
1672    is an expression.  */
1673
1674 tree
1675 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain)
1676 {
1677   if (op == SIZEOF_EXPR)
1678     return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none);
1679   else
1680     return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none);
1681 }
1682 \f
1683 /* EXPR is being used in a context that is not a function call.
1684    Enforce:
1685
1686      [expr.ref]
1687
1688      The expression can be used only as the left-hand operand of a
1689      member function call.
1690
1691      [expr.mptr.operator]
1692
1693      If the result of .* or ->* is a function, then that result can be
1694      used only as the operand for the function call operator ().
1695
1696    by issuing an error message if appropriate.  Returns true iff EXPR
1697    violates these rules.  */
1698
1699 bool
1700 invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
1701 {
1702   if (expr && DECL_NONSTATIC_MEMBER_FUNCTION_P (expr))
1703     {
1704       if (complain & tf_error)
1705         error ("invalid use of non-static member function");
1706       return true;
1707     }
1708   return false;
1709 }
1710
1711 /* If EXP is a reference to a bitfield, and the type of EXP does not
1712    match the declared type of the bitfield, return the declared type
1713    of the bitfield.  Otherwise, return NULL_TREE.  */
1714
1715 tree
1716 is_bitfield_expr_with_lowered_type (const_tree exp)
1717 {
1718   switch (TREE_CODE (exp))
1719     {
1720     case COND_EXPR:
1721       if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)
1722                                                ? TREE_OPERAND (exp, 1)
1723                                                : TREE_OPERAND (exp, 0)))
1724         return NULL_TREE;
1725       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2));
1726
1727     case COMPOUND_EXPR:
1728       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1));
1729
1730     case MODIFY_EXPR:
1731     case SAVE_EXPR:
1732       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1733
1734     case COMPONENT_REF:
1735       {
1736         tree field;
1737         
1738         field = TREE_OPERAND (exp, 1);
1739         if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
1740           return NULL_TREE;
1741         if (same_type_ignoring_top_level_qualifiers_p
1742             (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
1743           return NULL_TREE;
1744         return DECL_BIT_FIELD_TYPE (field);
1745       }
1746
1747     CASE_CONVERT:
1748       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
1749           == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
1750         return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1751       /* Fallthrough.  */
1752
1753     default:
1754       return NULL_TREE;
1755     }
1756 }
1757
1758 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1759    bitfield with a lowered type, the type of EXP is returned, rather
1760    than NULL_TREE.  */
1761
1762 tree
1763 unlowered_expr_type (const_tree exp)
1764 {
1765   tree type;
1766
1767   type = is_bitfield_expr_with_lowered_type (exp);
1768   if (!type)
1769     type = TREE_TYPE (exp);
1770
1771   return type;
1772 }
1773
1774 /* Perform the conversions in [expr] that apply when an lvalue appears
1775    in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1776    function-to-pointer conversions.  In addition, manifest constants
1777    are replaced by their values, and bitfield references are converted
1778    to their declared types.
1779
1780    Although the returned value is being used as an rvalue, this
1781    function does not wrap the returned expression in a
1782    NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1783    that the return value is no longer an lvalue.  */
1784
1785 tree
1786 decay_conversion (tree exp)
1787 {
1788   tree type;
1789   enum tree_code code;
1790
1791   type = TREE_TYPE (exp);
1792   if (type == error_mark_node)
1793     return error_mark_node;
1794
1795   exp = resolve_nondeduced_context (exp);
1796   if (type_unknown_p (exp))
1797     {
1798       cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1799       return error_mark_node;
1800     }
1801
1802   exp = decl_constant_value (exp);
1803   if (error_operand_p (exp))
1804     return error_mark_node;
1805
1806   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1807      Leave such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
1808   code = TREE_CODE (type);
1809   if (code == VOID_TYPE)
1810     {
1811       error ("void value not ignored as it ought to be");
1812       return error_mark_node;
1813     }
1814   if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error))
1815     return error_mark_node;
1816   if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1817     return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error);
1818   if (code == ARRAY_TYPE)
1819     {
1820       tree adr;
1821       tree ptrtype;
1822
1823       if (TREE_CODE (exp) == INDIRECT_REF)
1824         return build_nop (build_pointer_type (TREE_TYPE (type)),
1825                           TREE_OPERAND (exp, 0));
1826
1827       if (TREE_CODE (exp) == COMPOUND_EXPR)
1828         {
1829           tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1830           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1831                          TREE_OPERAND (exp, 0), op1);
1832         }
1833
1834       if (!lvalue_p (exp)
1835           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1836         {
1837           error ("invalid use of non-lvalue array");
1838           return error_mark_node;
1839         }
1840
1841       ptrtype = build_pointer_type (TREE_TYPE (type));
1842
1843       if (TREE_CODE (exp) == VAR_DECL)
1844         {
1845           if (!cxx_mark_addressable (exp))
1846             return error_mark_node;
1847           adr = build_nop (ptrtype, build_address (exp));
1848           return adr;
1849         }
1850       /* This way is better for a COMPONENT_REF since it can
1851          simplify the offset for a component.  */
1852       adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
1853       return cp_convert (ptrtype, adr);
1854     }
1855
1856   /* If a bitfield is used in a context where integral promotion
1857      applies, then the caller is expected to have used
1858      default_conversion.  That function promotes bitfields correctly
1859      before calling this function.  At this point, if we have a
1860      bitfield referenced, we may assume that is not subject to
1861      promotion, and that, therefore, the type of the resulting rvalue
1862      is the declared type of the bitfield.  */
1863   exp = convert_bitfield_to_declared_type (exp);
1864
1865   /* We do not call rvalue() here because we do not want to wrap EXP
1866      in a NON_LVALUE_EXPR.  */
1867
1868   /* [basic.lval]
1869
1870      Non-class rvalues always have cv-unqualified types.  */
1871   type = TREE_TYPE (exp);
1872   if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
1873     exp = build_nop (cv_unqualified (type), exp);
1874
1875   return exp;
1876 }
1877
1878 /* Perform preparatory conversions, as part of the "usual arithmetic
1879    conversions".  In particular, as per [expr]:
1880
1881      Whenever an lvalue expression appears as an operand of an
1882      operator that expects the rvalue for that operand, the
1883      lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1884      standard conversions are applied to convert the expression to an
1885      rvalue.
1886
1887    In addition, we perform integral promotions here, as those are
1888    applied to both operands to a binary operator before determining
1889    what additional conversions should apply.  */
1890
1891 tree
1892 default_conversion (tree exp)
1893 {
1894   /* Check for target-specific promotions.  */
1895   tree promoted_type = targetm.promoted_type (TREE_TYPE (exp));
1896   if (promoted_type)
1897     exp = cp_convert (promoted_type, exp);
1898   /* Perform the integral promotions first so that bitfield
1899      expressions (which may promote to "int", even if the bitfield is
1900      declared "unsigned") are promoted correctly.  */
1901   else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1902     exp = perform_integral_promotions (exp);
1903   /* Perform the other conversions.  */
1904   exp = decay_conversion (exp);
1905
1906   return exp;
1907 }
1908
1909 /* EXPR is an expression with an integral or enumeration type.
1910    Perform the integral promotions in [conv.prom], and return the
1911    converted value.  */
1912
1913 tree
1914 perform_integral_promotions (tree expr)
1915 {
1916   tree type;
1917   tree promoted_type;
1918
1919   /* [conv.prom]
1920
1921      If the bitfield has an enumerated type, it is treated as any
1922      other value of that type for promotion purposes.  */
1923   type = is_bitfield_expr_with_lowered_type (expr);
1924   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
1925     type = TREE_TYPE (expr);
1926   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1927   promoted_type = type_promotes_to (type);
1928   if (type != promoted_type)
1929     expr = cp_convert (promoted_type, expr);
1930   return expr;
1931 }
1932
1933 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1934    decay_conversion to one.  */
1935
1936 int
1937 string_conv_p (const_tree totype, const_tree exp, int warn)
1938 {
1939   tree t;
1940
1941   if (TREE_CODE (totype) != POINTER_TYPE)
1942     return 0;
1943
1944   t = TREE_TYPE (totype);
1945   if (!same_type_p (t, char_type_node)
1946       && !same_type_p (t, char16_type_node)
1947       && !same_type_p (t, char32_type_node)
1948       && !same_type_p (t, wchar_type_node))
1949     return 0;
1950
1951   if (TREE_CODE (exp) == STRING_CST)
1952     {
1953       /* Make sure that we don't try to convert between char and wide chars.  */
1954       if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1955         return 0;
1956     }
1957   else
1958     {
1959       /* Is this a string constant which has decayed to 'const char *'?  */
1960       t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1961       if (!same_type_p (TREE_TYPE (exp), t))
1962         return 0;
1963       STRIP_NOPS (exp);
1964       if (TREE_CODE (exp) != ADDR_EXPR
1965           || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1966         return 0;
1967     }
1968
1969   /* This warning is not very useful, as it complains about printf.  */
1970   if (warn)
1971     warning (OPT_Wwrite_strings,
1972              "deprecated conversion from string constant to %qT",
1973              totype);
1974
1975   return 1;
1976 }
1977
1978 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1979    can, for example, use as an lvalue.  This code used to be in
1980    unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1981    expressions, where we're dealing with aggregates.  But now it's again only
1982    called from unary_complex_lvalue.  The case (in particular) that led to
1983    this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1984    get it there.  */
1985
1986 static tree
1987 rationalize_conditional_expr (enum tree_code code, tree t,
1988                               tsubst_flags_t complain)
1989 {
1990   /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1991      the first operand is always the one to be used if both operands
1992      are equal, so we know what conditional expression this used to be.  */
1993   if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1994     {
1995       tree op0 = TREE_OPERAND (t, 0);
1996       tree op1 = TREE_OPERAND (t, 1);
1997
1998       /* The following code is incorrect if either operand side-effects.  */
1999       gcc_assert (!TREE_SIDE_EFFECTS (op0)
2000                   && !TREE_SIDE_EFFECTS (op1));
2001       return
2002         build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
2003                                                     ? LE_EXPR : GE_EXPR),
2004                                                    op0, TREE_CODE (op0),
2005                                                    op1, TREE_CODE (op1),
2006                                                    /*overloaded_p=*/NULL,
2007                                                    complain),
2008                                 cp_build_unary_op (code, op0, 0, complain),
2009                                 cp_build_unary_op (code, op1, 0, complain),
2010                                 complain);
2011     }
2012
2013   return
2014     build_conditional_expr (TREE_OPERAND (t, 0),
2015                             cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
2016                                                complain),
2017                             cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
2018                                                complain),
2019                             complain);
2020 }
2021
2022 /* Given the TYPE of an anonymous union field inside T, return the
2023    FIELD_DECL for the field.  If not found return NULL_TREE.  Because
2024    anonymous unions can nest, we must also search all anonymous unions
2025    that are directly reachable.  */
2026
2027 tree
2028 lookup_anon_field (tree t, tree type)
2029 {
2030   tree field;
2031
2032   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2033     {
2034       if (TREE_STATIC (field))
2035         continue;
2036       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
2037         continue;
2038
2039       /* If we find it directly, return the field.  */
2040       if (DECL_NAME (field) == NULL_TREE
2041           && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
2042         {
2043           return field;
2044         }
2045
2046       /* Otherwise, it could be nested, search harder.  */
2047       if (DECL_NAME (field) == NULL_TREE
2048           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2049         {
2050           tree subfield = lookup_anon_field (TREE_TYPE (field), type);
2051           if (subfield)
2052             return subfield;
2053         }
2054     }
2055   return NULL_TREE;
2056 }
2057
2058 /* Build an expression representing OBJECT.MEMBER.  OBJECT is an
2059    expression; MEMBER is a DECL or baselink.  If ACCESS_PATH is
2060    non-NULL, it indicates the path to the base used to name MEMBER.
2061    If PRESERVE_REFERENCE is true, the expression returned will have
2062    REFERENCE_TYPE if the MEMBER does.  Otherwise, the expression
2063    returned will have the type referred to by the reference.
2064
2065    This function does not perform access control; that is either done
2066    earlier by the parser when the name of MEMBER is resolved to MEMBER
2067    itself, or later when overload resolution selects one of the
2068    functions indicated by MEMBER.  */
2069
2070 tree
2071 build_class_member_access_expr (tree object, tree member,
2072                                 tree access_path, bool preserve_reference,
2073                                 tsubst_flags_t complain)
2074 {
2075   tree object_type;
2076   tree member_scope;
2077   tree result = NULL_TREE;
2078
2079   if (error_operand_p (object) || error_operand_p (member))
2080     return error_mark_node;
2081
2082   gcc_assert (DECL_P (member) || BASELINK_P (member));
2083
2084   /* [expr.ref]
2085
2086      The type of the first expression shall be "class object" (of a
2087      complete type).  */
2088   object_type = TREE_TYPE (object);
2089   if (!currently_open_class (object_type)
2090       && !complete_type_or_else (object_type, object))
2091     return error_mark_node;
2092   if (!CLASS_TYPE_P (object_type))
2093     {
2094       if (complain & tf_error)
2095         error ("request for member %qD in %qE, which is of non-class type %qT",
2096                member, object, object_type);
2097       return error_mark_node;
2098     }
2099
2100   /* The standard does not seem to actually say that MEMBER must be a
2101      member of OBJECT_TYPE.  However, that is clearly what is
2102      intended.  */
2103   if (DECL_P (member))
2104     {
2105       member_scope = DECL_CLASS_CONTEXT (member);
2106       mark_used (member);
2107       if (TREE_DEPRECATED (member))
2108         warn_deprecated_use (member, NULL_TREE);
2109     }
2110   else
2111     member_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (member));
2112   /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2113      presently be the anonymous union.  Go outwards until we find a
2114      type related to OBJECT_TYPE.  */
2115   while (ANON_AGGR_TYPE_P (member_scope)
2116          && !same_type_ignoring_top_level_qualifiers_p (member_scope,
2117                                                         object_type))
2118     member_scope = TYPE_CONTEXT (member_scope);
2119   if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
2120     {
2121       if (complain & tf_error)
2122         {
2123           if (TREE_CODE (member) == FIELD_DECL)
2124             error ("invalid use of nonstatic data member %qE", member);
2125           else
2126             error ("%qD is not a member of %qT", member, object_type);
2127         }
2128       return error_mark_node;
2129     }
2130
2131   /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2132      `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only an lvalue
2133      in the front end; only _DECLs and _REFs are lvalues in the back end.  */
2134   {
2135     tree temp = unary_complex_lvalue (ADDR_EXPR, object);
2136     if (temp)
2137       object = cp_build_indirect_ref (temp, RO_NULL, complain);
2138   }
2139
2140   /* In [expr.ref], there is an explicit list of the valid choices for
2141      MEMBER.  We check for each of those cases here.  */
2142   if (TREE_CODE (member) == VAR_DECL)
2143     {
2144       /* A static data member.  */
2145       result = member;
2146       /* If OBJECT has side-effects, they are supposed to occur.  */
2147       if (TREE_SIDE_EFFECTS (object))
2148         result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
2149     }
2150   else if (TREE_CODE (member) == FIELD_DECL)
2151     {
2152       /* A non-static data member.  */
2153       bool null_object_p;
2154       int type_quals;
2155       tree member_type;
2156
2157       null_object_p = (TREE_CODE (object) == INDIRECT_REF
2158                        && integer_zerop (TREE_OPERAND (object, 0)));
2159
2160       /* Convert OBJECT to the type of MEMBER.  */
2161       if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
2162                         TYPE_MAIN_VARIANT (member_scope)))
2163         {
2164           tree binfo;
2165           base_kind kind;
2166
2167           binfo = lookup_base (access_path ? access_path : object_type,
2168                                member_scope, ba_unique,  &kind);
2169           if (binfo == error_mark_node)
2170             return error_mark_node;
2171
2172           /* It is invalid to try to get to a virtual base of a
2173              NULL object.  The most common cause is invalid use of
2174              offsetof macro.  */
2175           if (null_object_p && kind == bk_via_virtual)
2176             {
2177               if (complain & tf_error)
2178                 {
2179                   error ("invalid access to non-static data member %qD of "
2180                          "NULL object",
2181                          member);
2182                   error ("(perhaps the %<offsetof%> macro was used incorrectly)");
2183                 }
2184               return error_mark_node;
2185             }
2186
2187           /* Convert to the base.  */
2188           object = build_base_path (PLUS_EXPR, object, binfo,
2189                                     /*nonnull=*/1);
2190           /* If we found the base successfully then we should be able
2191              to convert to it successfully.  */
2192           gcc_assert (object != error_mark_node);
2193         }
2194
2195       /* Complain about other invalid uses of offsetof, even though they will
2196          give the right answer.  Note that we complain whether or not they
2197          actually used the offsetof macro, since there's no way to know at this
2198          point.  So we just give a warning, instead of a pedwarn.  */
2199       /* Do not produce this warning for base class field references, because
2200          we know for a fact that didn't come from offsetof.  This does occur
2201          in various testsuite cases where a null object is passed where a
2202          vtable access is required.  */
2203       if (null_object_p && warn_invalid_offsetof
2204           && CLASSTYPE_NON_STD_LAYOUT (object_type)
2205           && !DECL_FIELD_IS_BASE (member)
2206           && cp_unevaluated_operand == 0
2207           && (complain & tf_warning))
2208         {
2209           warning (OPT_Winvalid_offsetof, 
2210                    "invalid access to non-static data member %qD "
2211                    " of NULL object", member);
2212           warning (OPT_Winvalid_offsetof, 
2213                    "(perhaps the %<offsetof%> macro was used incorrectly)");
2214         }
2215
2216       /* If MEMBER is from an anonymous aggregate, we have converted
2217          OBJECT so that it refers to the class containing the
2218          anonymous union.  Generate a reference to the anonymous union
2219          itself, and recur to find MEMBER.  */
2220       if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
2221           /* When this code is called from build_field_call, the
2222              object already has the type of the anonymous union.
2223              That is because the COMPONENT_REF was already
2224              constructed, and was then disassembled before calling
2225              build_field_call.  After the function-call code is
2226              cleaned up, this waste can be eliminated.  */
2227           && (!same_type_ignoring_top_level_qualifiers_p
2228               (TREE_TYPE (object), DECL_CONTEXT (member))))
2229         {
2230           tree anonymous_union;
2231
2232           anonymous_union = lookup_anon_field (TREE_TYPE (object),
2233                                                DECL_CONTEXT (member));
2234           object = build_class_member_access_expr (object,
2235                                                    anonymous_union,
2236                                                    /*access_path=*/NULL_TREE,
2237                                                    preserve_reference,
2238                                                    complain);
2239         }
2240
2241       /* Compute the type of the field, as described in [expr.ref].  */
2242       type_quals = TYPE_UNQUALIFIED;
2243       member_type = TREE_TYPE (member);
2244       if (TREE_CODE (member_type) != REFERENCE_TYPE)
2245         {
2246           type_quals = (cp_type_quals (member_type)
2247                         | cp_type_quals (object_type));
2248
2249           /* A field is const (volatile) if the enclosing object, or the
2250              field itself, is const (volatile).  But, a mutable field is
2251              not const, even within a const object.  */
2252           if (DECL_MUTABLE_P (member))
2253             type_quals &= ~TYPE_QUAL_CONST;
2254           member_type = cp_build_qualified_type (member_type, type_quals);
2255         }
2256
2257       result = build3 (COMPONENT_REF, member_type, object, member,
2258                        NULL_TREE);
2259       result = fold_if_not_in_template (result);
2260
2261       /* Mark the expression const or volatile, as appropriate.  Even
2262          though we've dealt with the type above, we still have to mark the
2263          expression itself.  */
2264       if (type_quals & TYPE_QUAL_CONST)
2265         TREE_READONLY (result) = 1;
2266       if (type_quals & TYPE_QUAL_VOLATILE)
2267         TREE_THIS_VOLATILE (result) = 1;
2268     }
2269   else if (BASELINK_P (member))
2270     {
2271       /* The member is a (possibly overloaded) member function.  */
2272       tree functions;
2273       tree type;
2274
2275       /* If the MEMBER is exactly one static member function, then we
2276          know the type of the expression.  Otherwise, we must wait
2277          until overload resolution has been performed.  */
2278       functions = BASELINK_FUNCTIONS (member);
2279       if (TREE_CODE (functions) == FUNCTION_DECL
2280           && DECL_STATIC_FUNCTION_P (functions))
2281         type = TREE_TYPE (functions);
2282       else
2283         type = unknown_type_node;
2284       /* Note that we do not convert OBJECT to the BASELINK_BINFO
2285          base.  That will happen when the function is called.  */
2286       result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
2287     }
2288   else if (TREE_CODE (member) == CONST_DECL)
2289     {
2290       /* The member is an enumerator.  */
2291       result = member;
2292       /* If OBJECT has side-effects, they are supposed to occur.  */
2293       if (TREE_SIDE_EFFECTS (object))
2294         result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
2295                          object, result);
2296     }
2297   else
2298     {
2299       if (complain & tf_error)
2300         error ("invalid use of %qD", member);
2301       return error_mark_node;
2302     }
2303
2304   if (!preserve_reference)
2305     /* [expr.ref]
2306
2307        If E2 is declared to have type "reference to T", then ... the
2308        type of E1.E2 is T.  */
2309     result = convert_from_reference (result);
2310
2311   return result;
2312 }
2313
2314 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2315    SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type.  */
2316
2317 static tree
2318 lookup_destructor (tree object, tree scope, tree dtor_name)
2319 {
2320   tree object_type = TREE_TYPE (object);
2321   tree dtor_type = TREE_OPERAND (dtor_name, 0);
2322   tree expr;
2323
2324   if (scope && !check_dtor_name (scope, dtor_type))
2325     {
2326       error ("qualified type %qT does not match destructor name ~%qT",
2327              scope, dtor_type);
2328       return error_mark_node;
2329     }
2330   if (TREE_CODE (dtor_type) == IDENTIFIER_NODE)
2331     {
2332       /* In a template, names we can't find a match for are still accepted
2333          destructor names, and we check them here.  */
2334       if (check_dtor_name (object_type, dtor_type))
2335         dtor_type = object_type;
2336       else
2337         {
2338           error ("object type %qT does not match destructor name ~%qT",
2339                  object_type, dtor_type);
2340           return error_mark_node;
2341         }
2342       
2343     }
2344   else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2345     {
2346       error ("the type being destroyed is %qT, but the destructor refers to %qT",
2347              TYPE_MAIN_VARIANT (object_type), dtor_type);
2348       return error_mark_node;
2349     }
2350   expr = lookup_member (dtor_type, complete_dtor_identifier,
2351                         /*protect=*/1, /*want_type=*/false);
2352   expr = (adjust_result_of_qualified_name_lookup
2353           (expr, dtor_type, object_type));
2354   return expr;
2355 }
2356
2357 /* An expression of the form "A::template B" has been resolved to
2358    DECL.  Issue a diagnostic if B is not a template or template
2359    specialization.  */
2360
2361 void
2362 check_template_keyword (tree decl)
2363 {
2364   /* The standard says:
2365
2366       [temp.names]
2367
2368       If a name prefixed by the keyword template is not a member
2369       template, the program is ill-formed.
2370
2371      DR 228 removed the restriction that the template be a member
2372      template.
2373
2374      DR 96, if accepted would add the further restriction that explicit
2375      template arguments must be provided if the template keyword is
2376      used, but, as of 2005-10-16, that DR is still in "drafting".  If
2377      this DR is accepted, then the semantic checks here can be
2378      simplified, as the entity named must in fact be a template
2379      specialization, rather than, as at present, a set of overloaded
2380      functions containing at least one template function.  */
2381   if (TREE_CODE (decl) != TEMPLATE_DECL
2382       && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2383     {
2384       if (!is_overloaded_fn (decl))
2385         permerror (input_location, "%qD is not a template", decl);
2386       else
2387         {
2388           tree fns;
2389           fns = decl;
2390           if (BASELINK_P (fns))
2391             fns = BASELINK_FUNCTIONS (fns);
2392           while (fns)
2393             {
2394               tree fn = OVL_CURRENT (fns);
2395               if (TREE_CODE (fn) == TEMPLATE_DECL
2396                   || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2397                 break;
2398               if (TREE_CODE (fn) == FUNCTION_DECL
2399                   && DECL_USE_TEMPLATE (fn)
2400                   && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2401                 break;
2402               fns = OVL_NEXT (fns);
2403             }
2404           if (!fns)
2405             permerror (input_location, "%qD is not a template", decl);
2406         }
2407     }
2408 }
2409
2410 /* This function is called by the parser to process a class member
2411    access expression of the form OBJECT.NAME.  NAME is a node used by
2412    the parser to represent a name; it is not yet a DECL.  It may,
2413    however, be a BASELINK where the BASELINK_FUNCTIONS is a
2414    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
2415    there is no reason to do the lookup twice, so the parser keeps the
2416    BASELINK.  TEMPLATE_P is true iff NAME was explicitly declared to
2417    be a template via the use of the "A::template B" syntax.  */
2418
2419 tree
2420 finish_class_member_access_expr (tree object, tree name, bool template_p,
2421                                  tsubst_flags_t complain)
2422 {
2423   tree expr;
2424   tree object_type;
2425   tree member;
2426   tree access_path = NULL_TREE;
2427   tree orig_object = object;
2428   tree orig_name = name;
2429
2430   if (object == error_mark_node || name == error_mark_node)
2431     return error_mark_node;
2432
2433   /* If OBJECT is an ObjC class instance, we must obey ObjC access rules.  */
2434   if (!objc_is_public (object, name))
2435     return error_mark_node;
2436
2437   object_type = TREE_TYPE (object);
2438
2439   if (processing_template_decl)
2440     {
2441       if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME.  */
2442           dependent_type_p (object_type)
2443           /* If NAME is just an IDENTIFIER_NODE, then the expression
2444              is dependent.  */
2445           || TREE_CODE (object) == IDENTIFIER_NODE
2446           /* If NAME is "f<args>", where either 'f' or 'args' is
2447              dependent, then the expression is dependent.  */
2448           || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2449               && dependent_template_id_p (TREE_OPERAND (name, 0),
2450                                           TREE_OPERAND (name, 1)))
2451           /* If NAME is "T::X" where "T" is dependent, then the
2452              expression is dependent.  */
2453           || (TREE_CODE (name) == SCOPE_REF
2454               && TYPE_P (TREE_OPERAND (name, 0))
2455               && dependent_type_p (TREE_OPERAND (name, 0))))
2456         return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2457       object = build_non_dependent_expr (object);
2458     }
2459
2460   /* [expr.ref]
2461
2462      The type of the first expression shall be "class object" (of a
2463      complete type).  */
2464   if (!currently_open_class (object_type)
2465       && !complete_type_or_else (object_type, object))
2466     return error_mark_node;
2467   if (!CLASS_TYPE_P (object_type))
2468     {
2469       if (complain & tf_error)
2470         error ("request for member %qD in %qE, which is of non-class type %qT",
2471                name, object, object_type);
2472       return error_mark_node;
2473     }
2474
2475   if (BASELINK_P (name))
2476     /* A member function that has already been looked up.  */
2477     member = name;
2478   else
2479     {
2480       bool is_template_id = false;
2481       tree template_args = NULL_TREE;
2482       tree scope;
2483
2484       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2485         {
2486           is_template_id = true;
2487           template_args = TREE_OPERAND (name, 1);
2488           name = TREE_OPERAND (name, 0);
2489
2490           if (TREE_CODE (name) == OVERLOAD)
2491             name = DECL_NAME (get_first_fn (name));
2492           else if (DECL_P (name))
2493             name = DECL_NAME (name);
2494         }
2495
2496       if (TREE_CODE (name) == SCOPE_REF)
2497         {
2498           /* A qualified name.  The qualifying class or namespace `S'
2499              has already been looked up; it is either a TYPE or a
2500              NAMESPACE_DECL.  */
2501           scope = TREE_OPERAND (name, 0);
2502           name = TREE_OPERAND (name, 1);
2503
2504           /* If SCOPE is a namespace, then the qualified name does not
2505              name a member of OBJECT_TYPE.  */
2506           if (TREE_CODE (scope) == NAMESPACE_DECL)
2507             {
2508               if (complain & tf_error)
2509                 error ("%<%D::%D%> is not a member of %qT",
2510                        scope, name, object_type);
2511               return error_mark_node;
2512             }
2513
2514           gcc_assert (CLASS_TYPE_P (scope));
2515           gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2516                       || TREE_CODE (name) == BIT_NOT_EXPR);
2517
2518           if (constructor_name_p (name, scope))
2519             {
2520               if (complain & tf_error)
2521                 error ("cannot call constructor %<%T::%D%> directly",
2522                        scope, name);
2523               return error_mark_node;
2524             }
2525
2526           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
2527           access_path = lookup_base (object_type, scope, ba_check, NULL);
2528           if (access_path == error_mark_node)
2529             return error_mark_node;
2530           if (!access_path)
2531             {
2532               if (complain & tf_error)
2533                 error ("%qT is not a base of %qT", scope, object_type);
2534               return error_mark_node;
2535             }
2536         }
2537       else
2538         {
2539           scope = NULL_TREE;
2540           access_path = object_type;
2541         }
2542
2543       if (TREE_CODE (name) == BIT_NOT_EXPR)
2544         member = lookup_destructor (object, scope, name);
2545       else
2546         {
2547           /* Look up the member.  */
2548           member = lookup_member (access_path, name, /*protect=*/1,
2549                                   /*want_type=*/false);
2550           if (member == NULL_TREE)
2551             {
2552               if (complain & tf_error)
2553                 error ("%qD has no member named %qE", object_type, name);
2554               return error_mark_node;
2555             }
2556           if (member == error_mark_node)
2557             return error_mark_node;
2558         }
2559
2560       if (is_template_id)
2561         {
2562           tree templ = member;
2563
2564           if (BASELINK_P (templ))
2565             templ = lookup_template_function (templ, template_args);
2566           else
2567             {
2568               if (complain & tf_error)
2569                 error ("%qD is not a member template function", name);
2570               return error_mark_node;
2571             }
2572         }
2573     }
2574
2575   if (TREE_DEPRECATED (member))
2576     warn_deprecated_use (member, NULL_TREE);
2577
2578   if (template_p)
2579     check_template_keyword (member);
2580
2581   expr = build_class_member_access_expr (object, member, access_path,
2582                                          /*preserve_reference=*/false,
2583                                          complain);
2584   if (processing_template_decl && expr != error_mark_node)
2585     {
2586       if (BASELINK_P (member))
2587         {
2588           if (TREE_CODE (orig_name) == SCOPE_REF)
2589             BASELINK_QUALIFIED_P (member) = 1;
2590           orig_name = member;
2591         }
2592       return build_min_non_dep (COMPONENT_REF, expr,
2593                                 orig_object, orig_name,
2594                                 NULL_TREE);
2595     }
2596
2597   return expr;
2598 }
2599
2600 /* Return an expression for the MEMBER_NAME field in the internal
2601    representation of PTRMEM, a pointer-to-member function.  (Each
2602    pointer-to-member function type gets its own RECORD_TYPE so it is
2603    more convenient to access the fields by name than by FIELD_DECL.)
2604    This routine converts the NAME to a FIELD_DECL and then creates the
2605    node for the complete expression.  */
2606
2607 tree
2608 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2609 {
2610   tree ptrmem_type;
2611   tree member;
2612   tree member_type;
2613
2614   /* This code is a stripped down version of
2615      build_class_member_access_expr.  It does not work to use that
2616      routine directly because it expects the object to be of class
2617      type.  */
2618   ptrmem_type = TREE_TYPE (ptrmem);
2619   gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2620   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2621                           /*want_type=*/false);
2622   member_type = cp_build_qualified_type (TREE_TYPE (member),
2623                                          cp_type_quals (ptrmem_type));
2624   return fold_build3_loc (input_location,
2625                       COMPONENT_REF, member_type,
2626                       ptrmem, member, NULL_TREE);
2627 }
2628
2629 /* Given an expression PTR for a pointer, return an expression
2630    for the value pointed to.
2631    ERRORSTRING is the name of the operator to appear in error messages.
2632
2633    This function may need to overload OPERATOR_FNNAME.
2634    Must also handle REFERENCE_TYPEs for C++.  */
2635
2636 tree
2637 build_x_indirect_ref (tree expr, ref_operator errorstring, 
2638                       tsubst_flags_t complain)
2639 {
2640   tree orig_expr = expr;
2641   tree rval;
2642
2643   if (processing_template_decl)
2644     {
2645       /* Retain the type if we know the operand is a pointer so that
2646          describable_type doesn't make auto deduction break.  */
2647       if (TREE_TYPE (expr) && POINTER_TYPE_P (TREE_TYPE (expr)))
2648         return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
2649       if (type_dependent_expression_p (expr))
2650         return build_min_nt (INDIRECT_REF, expr);
2651       expr = build_non_dependent_expr (expr);
2652     }
2653
2654   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2655                        NULL_TREE, /*overloaded_p=*/NULL, complain);
2656   if (!rval)
2657     rval = cp_build_indirect_ref (expr, errorstring, complain);
2658
2659   if (processing_template_decl && rval != error_mark_node)
2660     return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2661   else
2662     return rval;
2663 }
2664
2665 /* Helper function called from c-common.  */
2666 tree
2667 build_indirect_ref (location_t loc __attribute__ ((__unused__)),
2668                     tree ptr, ref_operator errorstring)
2669 {
2670   return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2671 }
2672
2673 tree
2674 cp_build_indirect_ref (tree ptr, ref_operator errorstring, 
2675                        tsubst_flags_t complain)
2676 {
2677   tree pointer, type;
2678
2679   if (ptr == error_mark_node)
2680     return error_mark_node;
2681
2682   if (ptr == current_class_ptr)
2683     return current_class_ref;
2684
2685   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2686              ? ptr : decay_conversion (ptr));
2687   type = TREE_TYPE (pointer);
2688
2689   if (POINTER_TYPE_P (type))
2690     {
2691       /* [expr.unary.op]
2692
2693          If the type of the expression is "pointer to T," the type
2694          of  the  result  is  "T."  */
2695       tree t = TREE_TYPE (type);
2696
2697       if (CONVERT_EXPR_P (ptr)
2698           || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2699         {
2700           /* If a warning is issued, mark it to avoid duplicates from
2701              the backend.  This only needs to be done at
2702              warn_strict_aliasing > 2.  */
2703           if (warn_strict_aliasing > 2)
2704             if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2705                                          type, TREE_OPERAND (ptr, 0)))
2706               TREE_NO_WARNING (ptr) = 1;
2707         }
2708
2709       if (VOID_TYPE_P (t))
2710         {
2711           /* A pointer to incomplete type (other than cv void) can be
2712              dereferenced [expr.unary.op]/1  */
2713           if (complain & tf_error)
2714             error ("%qT is not a pointer-to-object type", type);
2715           return error_mark_node;
2716         }
2717       else if (TREE_CODE (pointer) == ADDR_EXPR
2718                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2719         /* The POINTER was something like `&x'.  We simplify `*&x' to
2720            `x'.  */
2721         return TREE_OPERAND (pointer, 0);
2722       else
2723         {
2724           tree ref = build1 (INDIRECT_REF, t, pointer);
2725
2726           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2727              so that we get the proper error message if the result is used
2728              to assign to.  Also, &* is supposed to be a no-op.  */
2729           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2730           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2731           TREE_SIDE_EFFECTS (ref)
2732             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2733           return ref;
2734         }
2735     }
2736   else if (!(complain & tf_error))
2737     /* Don't emit any errors; we'll just return ERROR_MARK_NODE later.  */
2738     ;
2739   /* `pointer' won't be an error_mark_node if we were given a
2740      pointer to member, so it's cool to check for this here.  */
2741   else if (TYPE_PTR_TO_MEMBER_P (type))
2742     switch (errorstring)
2743       {
2744          case RO_ARRAY_INDEXING:
2745            error ("invalid use of array indexing on pointer to member");
2746            break;
2747          case RO_UNARY_STAR:
2748            error ("invalid use of unary %<*%> on pointer to member");
2749            break;
2750          case RO_IMPLICIT_CONVERSION:
2751            error ("invalid use of implicit conversion on pointer to member");
2752            break;
2753          default:
2754            gcc_unreachable ();
2755       }
2756   else if (pointer != error_mark_node)
2757     switch (errorstring)
2758       {
2759          case RO_NULL:
2760            error ("invalid type argument");
2761            break;
2762          case RO_ARRAY_INDEXING:
2763            error ("invalid type argument of array indexing");
2764            break;
2765          case RO_UNARY_STAR:
2766            error ("invalid type argument of unary %<*%>");
2767            break;
2768          case RO_IMPLICIT_CONVERSION:
2769            error ("invalid type argument of implicit conversion");
2770            break;
2771          default:
2772            gcc_unreachable ();
2773       }
2774   return error_mark_node;
2775 }
2776
2777 /* This handles expressions of the form "a[i]", which denotes
2778    an array reference.
2779
2780    This is logically equivalent in C to *(a+i), but we may do it differently.
2781    If A is a variable or a member, we generate a primitive ARRAY_REF.
2782    This avoids forcing the array out of registers, and can work on
2783    arrays that are not lvalues (for example, members of structures returned
2784    by functions).
2785
2786    If INDEX is of some user-defined type, it must be converted to
2787    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2788    will inherit the type of the array, which will be some pointer type.
2789    
2790    LOC is the location to use in building the array reference.  */
2791
2792 tree
2793 build_array_ref (location_t loc, tree array, tree idx)
2794 {
2795   tree ret;
2796
2797   if (idx == 0)
2798     {
2799       error_at (loc, "subscript missing in array reference");
2800       return error_mark_node;
2801     }
2802
2803   if (TREE_TYPE (array) == error_mark_node
2804       || TREE_TYPE (idx) == error_mark_node)
2805     return error_mark_node;
2806
2807   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2808      inside it.  */
2809   switch (TREE_CODE (array))
2810     {
2811     case COMPOUND_EXPR:
2812       {
2813         tree value = build_array_ref (loc, TREE_OPERAND (array, 1), idx);
2814         ret = build2 (COMPOUND_EXPR, TREE_TYPE (value),
2815                       TREE_OPERAND (array, 0), value);
2816         SET_EXPR_LOCATION (ret, loc);
2817         return ret;
2818       }
2819
2820     case COND_EXPR:
2821       ret = build_conditional_expr
2822               (TREE_OPERAND (array, 0),
2823                build_array_ref (loc, TREE_OPERAND (array, 1), idx),
2824                build_array_ref (loc, TREE_OPERAND (array, 2), idx),
2825                tf_warning_or_error);
2826       protected_set_expr_location (ret, loc);
2827       return ret;
2828
2829     default:
2830       break;
2831     }
2832
2833   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2834     {
2835       tree rval, type;
2836
2837       warn_array_subscript_with_type_char (idx);
2838
2839       if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2840         {
2841           error_at (loc, "array subscript is not an integer");
2842           return error_mark_node;
2843         }
2844
2845       /* Apply integral promotions *after* noticing character types.
2846          (It is unclear why we do these promotions -- the standard
2847          does not say that we should.  In fact, the natural thing would
2848          seem to be to convert IDX to ptrdiff_t; we're performing
2849          pointer arithmetic.)  */
2850       idx = perform_integral_promotions (idx);
2851
2852       /* An array that is indexed by a non-constant
2853          cannot be stored in a register; we must be able to do
2854          address arithmetic on its address.
2855          Likewise an array of elements of variable size.  */
2856       if (TREE_CODE (idx) != INTEGER_CST
2857           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2858               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2859                   != INTEGER_CST)))
2860         {
2861           if (!cxx_mark_addressable (array))
2862             return error_mark_node;
2863         }
2864
2865       /* An array that is indexed by a constant value which is not within
2866          the array bounds cannot be stored in a register either; because we
2867          would get a crash in store_bit_field/extract_bit_field when trying
2868          to access a non-existent part of the register.  */
2869       if (TREE_CODE (idx) == INTEGER_CST
2870           && TYPE_DOMAIN (TREE_TYPE (array))
2871           && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2872         {
2873           if (!cxx_mark_addressable (array))
2874             return error_mark_node;
2875         }
2876
2877       if (!lvalue_p (array))
2878         pedwarn (loc, OPT_pedantic, 
2879                  "ISO C++ forbids subscripting non-lvalue array");
2880
2881       /* Note in C++ it is valid to subscript a `register' array, since
2882          it is valid to take the address of something with that
2883          storage specification.  */
2884       if (extra_warnings)
2885         {
2886           tree foo = array;
2887           while (TREE_CODE (foo) == COMPONENT_REF)
2888             foo = TREE_OPERAND (foo, 0);
2889           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2890             warning_at (loc, OPT_Wextra,
2891                         "subscripting array declared %<register%>");
2892         }
2893
2894       type = TREE_TYPE (TREE_TYPE (array));
2895       rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2896       /* Array ref is const/volatile if the array elements are
2897          or if the array is..  */
2898       TREE_READONLY (rval)
2899         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2900       TREE_SIDE_EFFECTS (rval)
2901         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2902       TREE_THIS_VOLATILE (rval)
2903         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2904       ret = require_complete_type (fold_if_not_in_template (rval));
2905       protected_set_expr_location (ret, loc);
2906       return ret;
2907     }
2908
2909   {
2910     tree ar = default_conversion (array);
2911     tree ind = default_conversion (idx);
2912
2913     /* Put the integer in IND to simplify error checking.  */
2914     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2915       {
2916         tree temp = ar;
2917         ar = ind;
2918         ind = temp;
2919       }
2920
2921     if (ar == error_mark_node)
2922       return ar;
2923
2924     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2925       {
2926         error_at (loc, "subscripted value is neither array nor pointer");
2927         return error_mark_node;
2928       }
2929     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2930       {
2931         error_at (loc, "array subscript is not an integer");
2932         return error_mark_node;
2933       }
2934
2935     warn_array_subscript_with_type_char (idx);
2936
2937     ret = cp_build_indirect_ref (cp_build_binary_op (input_location,
2938                                                      PLUS_EXPR, ar, ind,
2939                                                      tf_warning_or_error),
2940                                  RO_ARRAY_INDEXING,
2941                                  tf_warning_or_error);
2942     protected_set_expr_location (ret, loc);
2943     return ret;
2944   }
2945 }
2946 \f
2947 /* Resolve a pointer to member function.  INSTANCE is the object
2948    instance to use, if the member points to a virtual member.
2949
2950    This used to avoid checking for virtual functions if basetype
2951    has no virtual functions, according to an earlier ANSI draft.
2952    With the final ISO C++ rules, such an optimization is
2953    incorrect: A pointer to a derived member can be static_cast
2954    to pointer-to-base-member, as long as the dynamic object
2955    later has the right member.  */
2956
2957 tree
2958 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2959 {
2960   if (TREE_CODE (function) == OFFSET_REF)
2961     function = TREE_OPERAND (function, 1);
2962
2963   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2964     {
2965       tree idx, delta, e1, e2, e3, vtbl, basetype;
2966       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2967
2968       tree instance_ptr = *instance_ptrptr;
2969       tree instance_save_expr = 0;
2970       if (instance_ptr == error_mark_node)
2971         {
2972           if (TREE_CODE (function) == PTRMEM_CST)
2973             {
2974               /* Extracting the function address from a pmf is only
2975                  allowed with -Wno-pmf-conversions. It only works for
2976                  pmf constants.  */
2977               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2978               e1 = convert (fntype, e1);
2979               return e1;
2980             }
2981           else
2982             {
2983               error ("object missing in use of %qE", function);
2984               return error_mark_node;
2985             }
2986         }
2987
2988       if (TREE_SIDE_EFFECTS (instance_ptr))
2989         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2990
2991       if (TREE_SIDE_EFFECTS (function))
2992         function = save_expr (function);
2993
2994       /* Start by extracting all the information from the PMF itself.  */
2995       e3 = pfn_from_ptrmemfunc (function);
2996       delta = delta_from_ptrmemfunc (function);
2997       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2998       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2999         {
3000         case ptrmemfunc_vbit_in_pfn:
3001           e1 = cp_build_binary_op (input_location,
3002                                    BIT_AND_EXPR, idx, integer_one_node,
3003                                    tf_warning_or_error);
3004           idx = cp_build_binary_op (input_location,
3005                                     MINUS_EXPR, idx, integer_one_node,
3006                                     tf_warning_or_error);
3007           break;
3008
3009         case ptrmemfunc_vbit_in_delta:
3010           e1 = cp_build_binary_op (input_location,
3011                                    BIT_AND_EXPR, delta, integer_one_node,
3012                                    tf_warning_or_error);
3013           delta = cp_build_binary_op (input_location,
3014                                       RSHIFT_EXPR, delta, integer_one_node,
3015                                       tf_warning_or_error);
3016           break;
3017
3018         default:
3019           gcc_unreachable ();
3020         }
3021
3022       /* Convert down to the right base before using the instance.  A
3023          special case is that in a pointer to member of class C, C may
3024          be incomplete.  In that case, the function will of course be
3025          a member of C, and no conversion is required.  In fact,
3026          lookup_base will fail in that case, because incomplete
3027          classes do not have BINFOs.  */
3028       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
3029       if (!same_type_ignoring_top_level_qualifiers_p
3030           (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
3031         {
3032           basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
3033                                   basetype, ba_check, NULL);
3034           instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
3035                                           1);
3036           if (instance_ptr == error_mark_node)
3037             return error_mark_node;
3038         }
3039       /* ...and then the delta in the PMF.  */
3040       instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
3041                              instance_ptr, fold_convert (sizetype, delta));
3042
3043       /* Hand back the adjusted 'this' argument to our caller.  */
3044       *instance_ptrptr = instance_ptr;
3045
3046       /* Next extract the vtable pointer from the object.  */
3047       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
3048                      instance_ptr);
3049       vtbl = cp_build_indirect_ref (vtbl, RO_NULL, tf_warning_or_error);
3050       /* If the object is not dynamic the access invokes undefined
3051          behavior.  As it is not executed in this case silence the
3052          spurious warnings it may provoke.  */
3053       TREE_NO_WARNING (vtbl) = 1;
3054
3055       /* Finally, extract the function pointer from the vtable.  */
3056       e2 = fold_build2_loc (input_location,
3057                         POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
3058                         fold_convert (sizetype, idx));
3059       e2 = cp_build_indirect_ref (e2, RO_NULL, tf_warning_or_error);
3060       TREE_CONSTANT (e2) = 1;
3061
3062       /* When using function descriptors, the address of the
3063          vtable entry is treated as a function pointer.  */
3064       if (TARGET_VTABLE_USES_DESCRIPTORS)
3065         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
3066                      cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
3067                                      tf_warning_or_error));
3068
3069       e2 = fold_convert (TREE_TYPE (e3), e2);
3070       e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
3071
3072       /* Make sure this doesn't get evaluated first inside one of the
3073          branches of the COND_EXPR.  */
3074       if (instance_save_expr)
3075         e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
3076                      instance_save_expr, e1);
3077
3078       function = e1;
3079     }
3080   return function;
3081 }
3082
3083 /* Used by the C-common bits.  */
3084 tree
3085 build_function_call (location_t loc ATTRIBUTE_UNUSED, 
3086                      tree function, tree params)
3087 {
3088   return cp_build_function_call (function, params, tf_warning_or_error);
3089 }
3090
3091 /* Used by the C-common bits.  */
3092 tree
3093 build_function_call_vec (location_t loc ATTRIBUTE_UNUSED,
3094                          tree function, VEC(tree,gc) *params,
3095                          VEC(tree,gc) *origtypes ATTRIBUTE_UNUSED)
3096 {
3097   VEC(tree,gc) *orig_params = params;
3098   tree ret = cp_build_function_call_vec (function, &params,
3099                                          tf_warning_or_error);
3100
3101   /* cp_build_function_call_vec can reallocate PARAMS by adding
3102      default arguments.  That should never happen here.  Verify
3103      that.  */
3104   gcc_assert (params == orig_params);
3105
3106   return ret;
3107 }
3108
3109 /* Build a function call using a tree list of arguments.  */
3110
3111 tree
3112 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
3113 {
3114   VEC(tree,gc) *vec;
3115   tree ret;
3116
3117   vec = make_tree_vector ();
3118   for (; params != NULL_TREE; params = TREE_CHAIN (params))
3119     VEC_safe_push (tree, gc, vec, TREE_VALUE (params));
3120   ret = cp_build_function_call_vec (function, &vec, complain);
3121   release_tree_vector (vec);
3122   return ret;
3123 }
3124
3125 /* Build a function call using a vector of arguments.  PARAMS may be
3126    NULL if there are no parameters.  This changes the contents of
3127    PARAMS.  */
3128
3129 tree
3130 cp_build_function_call_vec (tree function, VEC(tree,gc) **params,
3131                             tsubst_flags_t complain)
3132 {
3133   tree fntype, fndecl;
3134   int is_method;
3135   tree original = function;
3136   int nargs;
3137   tree *argarray;
3138   tree parm_types;
3139   VEC(tree,gc) *allocated = NULL;
3140   tree ret;
3141
3142   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3143      expressions, like those used for ObjC messenger dispatches.  */
3144   if (params != NULL && !VEC_empty (tree, *params))
3145     function = objc_rewrite_function_call (function,
3146                                            VEC_index (tree, *params, 0));
3147
3148   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3149      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
3150   if (TREE_CODE (function) == NOP_EXPR
3151       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
3152     function = TREE_OPERAND (function, 0);
3153
3154   if (TREE_CODE (function) == FUNCTION_DECL)
3155     {
3156       mark_used (function);
3157       fndecl = function;
3158
3159       /* Convert anything with function type to a pointer-to-function.  */
3160       if (DECL_MAIN_P (function) && (complain & tf_error))
3161         pedwarn (input_location, OPT_pedantic, 
3162                  "ISO C++ forbids calling %<::main%> from within program");
3163
3164       function = build_addr_func (function);
3165     }
3166   else
3167     {
3168       fndecl = NULL_TREE;
3169
3170       function = build_addr_func (function);
3171     }
3172
3173   if (function == error_mark_node)
3174     return error_mark_node;
3175
3176   fntype = TREE_TYPE (function);
3177
3178   if (TYPE_PTRMEMFUNC_P (fntype))
3179     {
3180       if (complain & tf_error)
3181         error ("must use %<.*%> or %<->*%> to call pointer-to-member "
3182                "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
3183                original, original);
3184       return error_mark_node;
3185     }
3186
3187   is_method = (TREE_CODE (fntype) == POINTER_TYPE
3188                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
3189
3190   if (!((TREE_CODE (fntype) == POINTER_TYPE
3191          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
3192         || is_method
3193         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
3194     {
3195       if (complain & tf_error)
3196         error ("%qE cannot be used as a function", original);
3197       return error_mark_node;
3198     }
3199
3200   /* fntype now gets the type of function pointed to.  */
3201   fntype = TREE_TYPE (fntype);
3202   parm_types = TYPE_ARG_TYPES (fntype);
3203
3204   if (params == NULL)
3205     {
3206       allocated = make_tree_vector ();
3207       params = &allocated;
3208     }
3209
3210   nargs = convert_arguments (parm_types, params, fndecl, LOOKUP_NORMAL,
3211                              complain);
3212   if (nargs < 0)
3213     return error_mark_node;
3214
3215   argarray = VEC_address (tree, *params);
3216
3217   /* Check for errors in format strings and inappropriately
3218      null parameters.  */
3219   check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
3220                             parm_types);
3221
3222   ret = build_cxx_call (function, nargs, argarray);
3223
3224   if (allocated != NULL)
3225     release_tree_vector (allocated);
3226
3227   return ret;
3228 }
3229 \f
3230 /* Convert the actual parameter expressions in the list VALUES to the
3231    types in the list TYPELIST.  The converted expressions are stored
3232    back in the VALUES vector.
3233    If parmdecls is exhausted, or when an element has NULL as its type,
3234    perform the default conversions.
3235
3236    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
3237
3238    This is also where warnings about wrong number of args are generated.
3239
3240    Returns the actual number of arguments processed (which might be less
3241    than the length of the vector), or -1 on error.
3242
3243    In C++, unspecified trailing parameters can be filled in with their
3244    default arguments, if such were specified.  Do so here.  */
3245
3246 static int
3247 convert_arguments (tree typelist, VEC(tree,gc) **values, tree fndecl,
3248                    int flags, tsubst_flags_t complain)
3249 {
3250   tree typetail;
3251   const char *called_thing = 0;
3252   unsigned int i;
3253
3254   /* Argument passing is always copy-initialization.  */
3255   flags |= LOOKUP_ONLYCONVERTING;
3256
3257   if (fndecl)
3258     {
3259       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
3260         {
3261           if (DECL_NAME (fndecl) == NULL_TREE
3262               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
3263             called_thing = "constructor";
3264           else
3265             called_thing = "member function";
3266         }
3267       else
3268         called_thing = "function";
3269     }
3270
3271   for (i = 0, typetail = typelist;
3272        i < VEC_length (tree, *values);
3273        i++)
3274     {
3275       tree type = typetail ? TREE_VALUE (typetail) : 0;
3276       tree val = VEC_index (tree, *values, i);
3277
3278       if (val == error_mark_node || type == error_mark_node)
3279         return -1;
3280
3281       if (type == void_type_node)
3282         {
3283           if (complain & tf_error)
3284             {
3285               if (fndecl)
3286                 {
3287                   error ("too many arguments to %s %q+#D", 
3288                          called_thing, fndecl);
3289                   error ("at this point in file");
3290                 }
3291               else
3292                 error ("too many arguments to function");
3293               return i;
3294             }
3295           else
3296             return -1;
3297         }
3298
3299       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3300          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
3301       if (TREE_CODE (val) == NOP_EXPR
3302           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3303           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3304         val = TREE_OPERAND (val, 0);
3305
3306       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3307         {
3308           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3309               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3310               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3311             val = decay_conversion (val);
3312         }
3313
3314       if (val == error_mark_node)
3315         return -1;
3316
3317       if (type != 0)
3318         {
3319           /* Formal parm type is specified by a function prototype.  */
3320           tree parmval;
3321
3322           if (!COMPLETE_TYPE_P (complete_type (type)))
3323             {
3324               if (complain & tf_error)
3325                 {
3326                   if (fndecl)
3327                     error ("parameter %P of %qD has incomplete type %qT",
3328                            i, fndecl, type);
3329                   else
3330                     error ("parameter %P has incomplete type %qT", i, type);
3331                 }
3332               parmval = error_mark_node;
3333             }
3334           else
3335             {
3336               parmval = convert_for_initialization
3337                 (NULL_TREE, type, val, flags,
3338                  "argument passing", fndecl, i, complain);
3339               parmval = convert_for_arg_passing (type, parmval);
3340             }
3341
3342           if (parmval == error_mark_node)
3343             return -1;
3344
3345           VEC_replace (tree, *values, i, parmval);
3346         }
3347       else
3348         {
3349           if (fndecl && DECL_BUILT_IN (fndecl)
3350               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3351             /* Don't do ellipsis conversion for __built_in_constant_p
3352                as this will result in spurious errors for non-trivial
3353                types.  */
3354             val = require_complete_type (val);
3355           else
3356             val = convert_arg_to_ellipsis (val);
3357
3358           VEC_replace (tree, *values, i, val);
3359         }
3360
3361       if (typetail)
3362         typetail = TREE_CHAIN (typetail);
3363     }
3364
3365   if (typetail != 0 && typetail != void_list_node)
3366     {
3367       /* See if there are default arguments that can be used.  Because
3368          we hold default arguments in the FUNCTION_TYPE (which is so
3369          wrong), we can see default parameters here from deduced
3370          contexts (and via typeof) for indirect function calls.
3371          Fortunately we know whether we have a function decl to
3372          provide default arguments in a language conformant
3373          manner.  */
3374       if (fndecl && TREE_PURPOSE (typetail)
3375           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3376         {
3377           for (; typetail != void_list_node; ++i)
3378             {
3379               tree parmval
3380                 = convert_default_arg (TREE_VALUE (typetail),
3381                                        TREE_PURPOSE (typetail),
3382                                        fndecl, i);
3383
3384               if (parmval == error_mark_node)
3385                 return -1;
3386
3387               VEC_safe_push (tree, gc, *values, parmval);
3388               typetail = TREE_CHAIN (typetail);
3389               /* ends with `...'.  */
3390               if (typetail == NULL_TREE)
3391                 break;
3392             }
3393         }
3394       else
3395         {
3396           if (complain & tf_error)
3397             {
3398               if (fndecl)
3399                 {
3400                   error ("too few arguments to %s %q+#D", 
3401                          called_thing, fndecl);
3402                   error ("at this point in file");
3403                 }
3404               else
3405                 error ("too few arguments to function");
3406             }
3407           return -1;
3408         }
3409     }
3410
3411   return (int) i;
3412 }
3413 \f
3414 /* Build a binary-operation expression, after performing default
3415    conversions on the operands.  CODE is the kind of expression to
3416    build.  ARG1 and ARG2 are the arguments.  ARG1_CODE and ARG2_CODE
3417    are the tree codes which correspond to ARG1 and ARG2 when issuing
3418    warnings about possibly misplaced parentheses.  They may differ
3419    from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3420    folding (e.g., if the parser sees "a | 1 + 1", it may call this
3421    routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3422    To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3423    ARG2_CODE as ERROR_MARK.  */
3424
3425 tree
3426 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3427                    tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3428                    tsubst_flags_t complain)
3429 {
3430   tree orig_arg1;
3431   tree orig_arg2;
3432   tree expr;
3433
3434   orig_arg1 = arg1;
3435   orig_arg2 = arg2;
3436
3437   if (processing_template_decl)
3438     {
3439       if (type_dependent_expression_p (arg1)
3440           || type_dependent_expression_p (arg2))
3441         return build_min_nt (code, arg1, arg2);
3442       arg1 = build_non_dependent_expr (arg1);
3443       arg2 = build_non_dependent_expr (arg2);
3444     }
3445
3446   if (code == DOTSTAR_EXPR)
3447     expr = build_m_component_ref (arg1, arg2);
3448   else
3449     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3450                          overloaded_p, complain);
3451
3452   /* Check for cases such as x+y<<z which users are likely to
3453      misinterpret.  But don't warn about obj << x + y, since that is a
3454      common idiom for I/O.  */
3455   if (warn_parentheses
3456       && (complain & tf_warning)
3457       && !processing_template_decl
3458       && !error_operand_p (arg1)
3459       && !error_operand_p (arg2)
3460       && (code != LSHIFT_EXPR
3461           || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3462     warn_about_parentheses (code, arg1_code, orig_arg1, arg2_code, orig_arg2);
3463
3464   if (processing_template_decl && expr != error_mark_node)
3465     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3466
3467   return expr;
3468 }
3469
3470 /* Build and return an ARRAY_REF expression.  */
3471
3472 tree
3473 build_x_array_ref (tree arg1, tree arg2, tsubst_flags_t complain)
3474 {
3475   tree orig_arg1 = arg1;
3476   tree orig_arg2 = arg2;
3477   tree expr;
3478
3479   if (processing_template_decl)
3480     {
3481       if (type_dependent_expression_p (arg1)
3482           || type_dependent_expression_p (arg2))
3483         return build_min_nt (ARRAY_REF, arg1, arg2,
3484                              NULL_TREE, NULL_TREE);
3485       arg1 = build_non_dependent_expr (arg1);
3486       arg2 = build_non_dependent_expr (arg2);
3487     }
3488
3489   expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3490                        /*overloaded_p=*/NULL, complain);
3491
3492   if (processing_template_decl && expr != error_mark_node)
3493     return build_min_non_dep (ARRAY_REF, expr, orig_arg1, orig_arg2,
3494                               NULL_TREE, NULL_TREE);
3495   return expr;
3496 }
3497
3498 /* For the c-common bits.  */
3499 tree
3500 build_binary_op (location_t location, enum tree_code code, tree op0, tree op1,
3501                  int convert_p ATTRIBUTE_UNUSED)
3502 {
3503   return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error);
3504 }
3505
3506
3507 /* Build a binary-operation expression without default conversions.
3508    CODE is the kind of expression to build.
3509    LOCATION is the location_t of the operator in the source code.
3510    This function differs from `build' in several ways:
3511    the data type of the result is computed and recorded in it,
3512    warnings are generated if arg data types are invalid,
3513    special handling for addition and subtraction of pointers is known,
3514    and some optimization is done (operations on narrow ints
3515    are done in the narrower type when that gives the same result).
3516    Constant folding is also done before the result is returned.
3517
3518    Note that the operands will never have enumeral types
3519    because either they have just had the default conversions performed
3520    or they have both just been converted to some other type in which
3521    the arithmetic is to be done.
3522
3523    C++: must do special pointer arithmetic when implementing
3524    multiple inheritance, and deal with pointer to member functions.  */
3525
3526 tree
3527 cp_build_binary_op (location_t location,
3528                     enum tree_code code, tree orig_op0, tree orig_op1,
3529                     tsubst_flags_t complain)
3530 {
3531   tree op0, op1;
3532   enum tree_code code0, code1;
3533   tree type0, type1;
3534   const char *invalid_op_diag;
3535
3536   /* Expression code to give to the expression when it is built.
3537      Normally this is CODE, which is what the caller asked for,
3538      but in some special cases we change it.  */
3539   enum tree_code resultcode = code;
3540
3541   /* Data type in which the computation is to be performed.
3542      In the simplest cases this is the common type of the arguments.  */
3543   tree result_type = NULL;
3544
3545   /* Nonzero means operands have already been type-converted
3546      in whatever way is necessary.
3547      Zero means they need to be converted to RESULT_TYPE.  */
3548   int converted = 0;
3549
3550   /* Nonzero means create the expression with this type, rather than
3551      RESULT_TYPE.  */
3552   tree build_type = 0;
3553
3554   /* Nonzero means after finally constructing the expression
3555      convert it to this type.  */
3556   tree final_type = 0;
3557
3558   tree result;
3559
3560   /* Nonzero if this is an operation like MIN or MAX which can
3561      safely be computed in short if both args are promoted shorts.
3562      Also implies COMMON.
3563      -1 indicates a bitwise operation; this makes a difference
3564      in the exact conditions for when it is safe to do the operation
3565      in a narrower mode.  */
3566   int shorten = 0;
3567
3568   /* Nonzero if this is a comparison operation;
3569      if both args are promoted shorts, compare the original shorts.
3570      Also implies COMMON.  */
3571   int short_compare = 0;
3572
3573   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
3574   int common = 0;
3575
3576   /* True if both operands have arithmetic type.  */
3577   bool arithmetic_types_p;
3578
3579   /* Apply default conversions.  */
3580   op0 = orig_op0;
3581   op1 = orig_op1;
3582
3583   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3584       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3585       || code == TRUTH_XOR_EXPR)
3586     {
3587       if (!really_overloaded_fn (op0))
3588         op0 = decay_conversion (op0);
3589       if (!really_overloaded_fn (op1))
3590         op1 = decay_conversion (op1);
3591     }
3592   else
3593     {
3594       if (!really_overloaded_fn (op0))
3595         op0 = default_conversion (op0);
3596       if (!really_overloaded_fn (op1))
3597         op1 = default_conversion (op1);
3598     }
3599
3600   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3601   STRIP_TYPE_NOPS (op0);
3602   STRIP_TYPE_NOPS (op1);
3603
3604   /* DTRT if one side is an overloaded function, but complain about it.  */
3605   if (type_unknown_p (op0))
3606     {
3607       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3608       if (t != error_mark_node)
3609         {
3610           if (complain & tf_error)
3611             permerror (input_location, "assuming cast to type %qT from overloaded function",
3612                        TREE_TYPE (t));
3613           op0 = t;
3614         }
3615     }
3616   if (type_unknown_p (op1))
3617     {
3618       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3619       if (t != error_mark_node)
3620         {
3621           if (complain & tf_error)
3622             permerror (input_location, "assuming cast to type %qT from overloaded function",
3623                        TREE_TYPE (t));
3624           op1 = t;
3625         }
3626     }
3627
3628   type0 = TREE_TYPE (op0);
3629   type1 = TREE_TYPE (op1);
3630
3631   /* The expression codes of the data types of the arguments tell us
3632      whether the arguments are integers, floating, pointers, etc.  */
3633   code0 = TREE_CODE (type0);
3634   code1 = TREE_CODE (type1);
3635
3636   /* If an error was already reported for one of the arguments,
3637      avoid reporting another error.  */
3638   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3639     return error_mark_node;
3640
3641   if ((invalid_op_diag
3642        = targetm.invalid_binary_op (code, type0, type1)))
3643     {
3644       error (invalid_op_diag);
3645       return error_mark_node;
3646     }
3647
3648   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3649   if ((orig_op0 == null_node || orig_op1 == null_node)
3650       /* It's reasonable to use pointer values as operands of &&
3651          and ||, so NULL is no exception.  */
3652       && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR 
3653       && ( /* Both are NULL (or 0) and the operation was not a
3654               comparison or a pointer subtraction.  */
3655           (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1) 
3656            && code != EQ_EXPR && code != NE_EXPR && code != MINUS_EXPR) 
3657           /* Or if one of OP0 or OP1 is neither a pointer nor NULL.  */
3658           || (!null_ptr_cst_p (orig_op0)
3659               && !TYPE_PTR_P (type0) && !TYPE_PTR_TO_MEMBER_P (type0))
3660           || (!null_ptr_cst_p (orig_op1) 
3661               && !TYPE_PTR_P (type1) && !TYPE_PTR_TO_MEMBER_P (type1)))
3662       && (complain & tf_warning))
3663     /* Some sort of arithmetic operation involving NULL was
3664        performed.  */
3665     warning (OPT_Wpointer_arith, "NULL used in arithmetic");
3666
3667   switch (code)
3668     {
3669     case MINUS_EXPR:
3670       /* Subtraction of two similar pointers.
3671          We must subtract them as integers, then divide by object size.  */
3672       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3673           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3674                                                         TREE_TYPE (type1)))
3675         return pointer_diff (op0, op1, common_pointer_type (type0, type1));
3676       /* In all other cases except pointer - int, the usual arithmetic
3677          rules apply.  */
3678       else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3679         {
3680           common = 1;
3681           break;
3682         }
3683       /* The pointer - int case is just like pointer + int; fall
3684          through.  */
3685     case PLUS_EXPR:
3686       if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3687           && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3688         {
3689           tree ptr_operand;
3690           tree int_operand;
3691           ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3692           int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3693           if (processing_template_decl)
3694             {
3695               result_type = TREE_TYPE (ptr_operand);
3696               break;
3697             }
3698           return cp_pointer_int_sum (code,
3699                                      ptr_operand, 
3700                                      int_operand);
3701         }
3702       common = 1;
3703       break;
3704
3705     case MULT_EXPR:
3706       common = 1;
3707       break;
3708
3709     case TRUNC_DIV_EXPR:
3710     case CEIL_DIV_EXPR:
3711     case FLOOR_DIV_EXPR:
3712     case ROUND_DIV_EXPR:
3713     case EXACT_DIV_EXPR:
3714       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3715            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3716           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3717               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3718         {
3719           enum tree_code tcode0 = code0, tcode1 = code1;
3720
3721           warn_for_div_by_zero (location, op1);
3722
3723           if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3724             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3725           if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3726             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3727
3728           if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3729             resultcode = RDIV_EXPR;
3730           else
3731             /* When dividing two signed integers, we have to promote to int.
3732                unless we divide by a constant != -1.  Note that default
3733                conversion will have been performed on the operands at this
3734                point, so we have to dig out the original type to find out if
3735                it was unsigned.  */
3736             shorten = ((TREE_CODE (op0) == NOP_EXPR
3737                         && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3738                        || (TREE_CODE (op1) == INTEGER_CST
3739                            && ! integer_all_onesp (op1)));
3740
3741           common = 1;
3742         }
3743       break;
3744
3745     case BIT_AND_EXPR:
3746     case BIT_IOR_EXPR:
3747     case BIT_XOR_EXPR:
3748       if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3749           || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3750               && !VECTOR_FLOAT_TYPE_P (type0)
3751               && !VECTOR_FLOAT_TYPE_P (type1)))
3752         shorten = -1;
3753       break;
3754
3755     case TRUNC_MOD_EXPR:
3756     case FLOOR_MOD_EXPR:
3757       warn_for_div_by_zero (location, op1);
3758
3759       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3760           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
3761           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
3762         common = 1;
3763       else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3764         {
3765           /* Although it would be tempting to shorten always here, that loses
3766              on some targets, since the modulo instruction is undefined if the
3767              quotient can't be represented in the computation mode.  We shorten
3768              only if unsigned or if dividing by something we know != -1.  */
3769           shorten = ((TREE_CODE (op0) == NOP_EXPR
3770                       && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3771                      || (TREE_CODE (op1) == INTEGER_CST
3772                          && ! integer_all_onesp (op1)));
3773           common = 1;
3774         }
3775       break;
3776
3777     case TRUTH_ANDIF_EXPR:
3778     case TRUTH_ORIF_EXPR:
3779     case TRUTH_AND_EXPR:
3780     case TRUTH_OR_EXPR:
3781       result_type = boolean_type_node;
3782       break;
3783
3784       /* Shift operations: result has same type as first operand;
3785          always convert second operand to int.
3786          Also set SHORT_SHIFT if shifting rightward.  */
3787
3788     case RSHIFT_EXPR:
3789       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3790         {
3791           result_type = type0;
3792           if (TREE_CODE (op1) == INTEGER_CST)
3793             {
3794               if (tree_int_cst_lt (op1, integer_zero_node))
3795                 {
3796                   if ((complain & tf_warning)
3797                       && c_inhibit_evaluation_warnings == 0)
3798                     warning (0, "right shift count is negative");
3799                 }
3800               else
3801                 {
3802                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3803                       && (complain & tf_warning)
3804                       && c_inhibit_evaluation_warnings == 0)
3805                     warning (0, "right shift count >= width of type");
3806                 }
3807             }
3808           /* Convert the shift-count to an integer, regardless of
3809              size of value being shifted.  */
3810           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3811             op1 = cp_convert (integer_type_node, op1);
3812           /* Avoid converting op1 to result_type later.  */
3813           converted = 1;
3814         }
3815       break;
3816
3817     case LSHIFT_EXPR:
3818       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3819         {
3820           result_type = type0;
3821           if (TREE_CODE (op1) == INTEGER_CST)
3822             {
3823               if (tree_int_cst_lt (op1, integer_zero_node))
3824                 {
3825                   if ((complain & tf_warning)
3826                       && c_inhibit_evaluation_warnings == 0)
3827                     warning (0, "left shift count is negative");
3828                 }
3829               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3830                 {
3831                   if ((complain & tf_warning)
3832                       && c_inhibit_evaluation_warnings == 0)
3833                     warning (0, "left shift count >= width of type");
3834                 }
3835             }
3836           /* Convert the shift-count to an integer, regardless of
3837              size of value being shifted.  */
3838           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3839             op1 = cp_convert (integer_type_node, op1);
3840           /* Avoid converting op1 to result_type later.  */
3841           converted = 1;
3842         }
3843       break;
3844
3845     case RROTATE_EXPR:
3846     case LROTATE_EXPR:
3847       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3848         {
3849           result_type = type0;
3850           if (TREE_CODE (op1) == INTEGER_CST)
3851             {
3852               if (tree_int_cst_lt (op1, integer_zero_node))
3853                 {
3854                   if (complain & tf_warning)
3855                     warning (0, (code == LROTATE_EXPR)
3856                                   ? G_("left rotate count is negative")
3857                                   : G_("right rotate count is negative"));
3858                 }
3859               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3860                 {
3861                   if (complain & tf_warning)
3862                     warning (0, (code == LROTATE_EXPR) 
3863                                   ? G_("left rotate count >= width of type")
3864                                   : G_("right rotate count >= width of type"));
3865                 }
3866             }
3867           /* Convert the shift-count to an integer, regardless of
3868              size of value being shifted.  */
3869           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3870             op1 = cp_convert (integer_type_node, op1);
3871         }
3872       break;
3873
3874     case EQ_EXPR:
3875     case NE_EXPR:
3876       if ((complain & tf_warning)
3877           && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3878         warning (OPT_Wfloat_equal,
3879                  "comparing floating point with == or != is unsafe");
3880       if ((complain & tf_warning)
3881           && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3882               || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3883         warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3884
3885       build_type = boolean_type_node;
3886       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3887            || code0 == COMPLEX_TYPE || code0 == ENUMERAL_TYPE)
3888           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3889               || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE))
3890         short_compare = 1;
3891       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3892                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3893         result_type = composite_pointer_type (type0, type1, op0, op1,
3894                                               CPO_COMPARISON, complain);
3895       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3896                && null_ptr_cst_p (op1))
3897         {
3898           if (TREE_CODE (op0) == ADDR_EXPR
3899               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3900             {
3901               if (complain & tf_warning)
3902                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3903                          TREE_OPERAND (op0, 0));
3904             }
3905           result_type = type0;
3906         }
3907       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3908                && null_ptr_cst_p (op0))
3909         {
3910           if (TREE_CODE (op1) == ADDR_EXPR 
3911               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3912             {
3913               if (complain & tf_warning)
3914                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3915                          TREE_OPERAND (op1, 0));
3916             }
3917           result_type = type1;
3918         }
3919       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3920         {
3921           result_type = type0;
3922           if (complain & tf_error) 
3923             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3924           else
3925             return error_mark_node;
3926         }
3927       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3928         {
3929           result_type = type1;
3930           if (complain & tf_error)
3931             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3932           else
3933             return error_mark_node;
3934         }
3935       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3936         {
3937           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3938               == ptrmemfunc_vbit_in_delta)
3939             {
3940               tree pfn0 = pfn_from_ptrmemfunc (op0);
3941               tree delta0 = delta_from_ptrmemfunc (op0);
3942               tree e1 = cp_build_binary_op (location,
3943                                             EQ_EXPR,
3944                                             pfn0,       
3945                                             fold_convert (TREE_TYPE (pfn0),
3946                                                           integer_zero_node),
3947                                             complain);
3948               tree e2 = cp_build_binary_op (location,
3949                                             BIT_AND_EXPR, 
3950                                             delta0,
3951                                             integer_one_node,
3952                                             complain);
3953               e2 = cp_build_binary_op (location,
3954                                        EQ_EXPR, e2, integer_zero_node,
3955                                        complain);
3956               op0 = cp_build_binary_op (location,
3957                                         TRUTH_ANDIF_EXPR, e1, e2,
3958                                         complain);
3959               op1 = cp_convert (TREE_TYPE (op0), integer_one_node); 
3960             }
3961           else 
3962             {
3963               op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3964               op1 = cp_convert (TREE_TYPE (op0), integer_zero_node); 
3965             }
3966           result_type = TREE_TYPE (op0);
3967         }
3968       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3969         return cp_build_binary_op (location, code, op1, op0, complain);
3970       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3971         {
3972           tree type;
3973           /* E will be the final comparison.  */
3974           tree e;
3975           /* E1 and E2 are for scratch.  */
3976           tree e1;
3977           tree e2;
3978           tree pfn0;
3979           tree pfn1;
3980           tree delta0;
3981           tree delta1;
3982
3983           type = composite_pointer_type (type0, type1, op0, op1, 
3984                                          CPO_COMPARISON, complain);
3985
3986           if (!same_type_p (TREE_TYPE (op0), type))
3987             op0 = cp_convert_and_check (type, op0);
3988           if (!same_type_p (TREE_TYPE (op1), type))
3989             op1 = cp_convert_and_check (type, op1);
3990
3991           if (op0 == error_mark_node || op1 == error_mark_node)
3992             return error_mark_node;
3993
3994           if (TREE_SIDE_EFFECTS (op0))
3995             op0 = save_expr (op0);
3996           if (TREE_SIDE_EFFECTS (op1))
3997             op1 = save_expr (op1);
3998
3999           pfn0 = pfn_from_ptrmemfunc (op0);
4000           pfn1 = pfn_from_ptrmemfunc (op1);
4001           delta0 = delta_from_ptrmemfunc (op0);
4002           delta1 = delta_from_ptrmemfunc (op1);
4003           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
4004               == ptrmemfunc_vbit_in_delta)
4005             {
4006               /* We generate:
4007
4008                  (op0.pfn == op1.pfn
4009                   && ((op0.delta == op1.delta)
4010                        || (!op0.pfn && op0.delta & 1 == 0 
4011                            && op1.delta & 1 == 0))
4012
4013                  The reason for the `!op0.pfn' bit is that a NULL
4014                  pointer-to-member is any member with a zero PFN and
4015                  LSB of the DELTA field is 0.  */
4016
4017               e1&nbs