OSDN Git Service

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