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