OSDN Git Service

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