OSDN Git Service

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