OSDN Git Service

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