OSDN Git Service

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