OSDN Git Service

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