OSDN Git Service

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