OSDN Git Service

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