OSDN Git Service

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