OSDN Git Service

Fix PR c++/43800
[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 /* Return the ARRAY_TYPE type without its domain.  */
882
883 tree
884 strip_array_domain (tree type)
885 {
886   tree t2;
887   gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
888   if (TYPE_DOMAIN (type) == NULL_TREE)
889     return type;
890   t2 = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
891   return cp_build_type_attribute_variant (t2, TYPE_ATTRIBUTES (type));
892 }
893
894 /* Wrapper around cp_common_type that is used by c-common.c and other
895    front end optimizations that remove promotions.  
896
897    Return the common type for two arithmetic types T1 and T2 under the
898    usual arithmetic conversions.  The default conversions have already
899    been applied, and enumerated types converted to their compatible
900    integer types.  */
901
902 tree
903 common_type (tree t1, tree t2)
904 {
905   /* If one type is nonsense, use the other  */
906   if (t1 == error_mark_node)
907     return t2;
908   if (t2 == error_mark_node)
909     return t1;
910
911   return cp_common_type (t1, t2);
912 }
913
914 /* Return the common type of two pointer types T1 and T2.  This is the
915    type for the result of most arithmetic operations if the operands
916    have the given two types.
917  
918    We assume that comp_target_types has already been done and returned
919    nonzero; if that isn't so, this may crash.  */
920
921 tree
922 common_pointer_type (tree t1, tree t2)
923 {
924   gcc_assert ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
925               || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
926               || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)));
927
928   return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
929                                  CPO_CONVERSION, tf_warning_or_error);
930 }
931 \f
932 /* Compare two exception specifier types for exactness or subsetness, if
933    allowed. Returns false for mismatch, true for match (same, or
934    derived and !exact).
935
936    [except.spec] "If a class X ... objects of class X or any class publicly
937    and unambiguously derived from X. Similarly, if a pointer type Y * ...
938    exceptions of type Y * or that are pointers to any type publicly and
939    unambiguously derived from Y. Otherwise a function only allows exceptions
940    that have the same type ..."
941    This does not mention cv qualifiers and is different to what throw
942    [except.throw] and catch [except.catch] will do. They will ignore the
943    top level cv qualifiers, and allow qualifiers in the pointer to class
944    example.
945
946    We implement the letter of the standard.  */
947
948 static bool
949 comp_except_types (tree a, tree b, bool exact)
950 {
951   if (same_type_p (a, b))
952     return true;
953   else if (!exact)
954     {
955       if (cp_type_quals (a) || cp_type_quals (b))
956         return false;
957
958       if (TREE_CODE (a) == POINTER_TYPE
959           && TREE_CODE (b) == POINTER_TYPE)
960         {
961           a = TREE_TYPE (a);
962           b = TREE_TYPE (b);
963           if (cp_type_quals (a) || cp_type_quals (b))
964             return false;
965         }
966
967       if (TREE_CODE (a) != RECORD_TYPE
968           || TREE_CODE (b) != RECORD_TYPE)
969         return false;
970
971       if (PUBLICLY_UNIQUELY_DERIVED_P (a, b))
972         return true;
973     }
974   return false;
975 }
976
977 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
978    If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
979    otherwise it must be exact. Exception lists are unordered, but
980    we've already filtered out duplicates. Most lists will be in order,
981    we should try to make use of that.  */
982
983 bool
984 comp_except_specs (const_tree t1, const_tree t2, bool exact)
985 {
986   const_tree probe;
987   const_tree base;
988   int  length = 0;
989
990   if (t1 == t2)
991     return true;
992
993   if (t1 == NULL_TREE)                     /* T1 is ...  */
994     return t2 == NULL_TREE || !exact;
995   if (!TREE_VALUE (t1))                    /* t1 is EMPTY */
996     return t2 != NULL_TREE && !TREE_VALUE (t2);
997   if (t2 == NULL_TREE)                     /* T2 is ...  */
998     return false;
999   if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
1000     return !exact;
1001
1002   /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
1003      Count how many we find, to determine exactness. For exact matching and
1004      ordered T1, T2, this is an O(n) operation, otherwise its worst case is
1005      O(nm).  */
1006   for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
1007     {
1008       for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
1009         {
1010           tree a = TREE_VALUE (probe);
1011           tree b = TREE_VALUE (t2);
1012
1013           if (comp_except_types (a, b, exact))
1014             {
1015               if (probe == base && exact)
1016                 base = TREE_CHAIN (probe);
1017               length++;
1018               break;
1019             }
1020         }
1021       if (probe == NULL_TREE)
1022         return false;
1023     }
1024   return !exact || base == NULL_TREE || length == list_length (t1);
1025 }
1026
1027 /* Compare the array types T1 and T2.  ALLOW_REDECLARATION is true if
1028    [] can match [size].  */
1029
1030 static bool
1031 comp_array_types (const_tree t1, const_tree t2, bool allow_redeclaration)
1032 {
1033   tree d1;
1034   tree d2;
1035   tree max1, max2;
1036
1037   if (t1 == t2)
1038     return true;
1039
1040   /* The type of the array elements must be the same.  */
1041   if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1042     return false;
1043
1044   d1 = TYPE_DOMAIN (t1);
1045   d2 = TYPE_DOMAIN (t2);
1046
1047   if (d1 == d2)
1048     return true;
1049
1050   /* If one of the arrays is dimensionless, and the other has a
1051      dimension, they are of different types.  However, it is valid to
1052      write:
1053
1054        extern int a[];
1055        int a[3];
1056
1057      by [basic.link]:
1058
1059        declarations for an array object can specify
1060        array types that differ by the presence or absence of a major
1061        array bound (_dcl.array_).  */
1062   if (!d1 || !d2)
1063     return allow_redeclaration;
1064
1065   /* Check that the dimensions are the same.  */
1066
1067   if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
1068     return false;
1069   max1 = TYPE_MAX_VALUE (d1);
1070   max2 = TYPE_MAX_VALUE (d2);
1071   if (processing_template_decl && !abi_version_at_least (2)
1072       && !value_dependent_expression_p (max1)
1073       && !value_dependent_expression_p (max2))
1074     {
1075       /* With abi-1 we do not fold non-dependent array bounds, (and
1076          consequently mangle them incorrectly).  We must therefore
1077          fold them here, to verify the domains have the same
1078          value.  */
1079       max1 = fold (max1);
1080       max2 = fold (max2);
1081     }
1082
1083   if (!cp_tree_equal (max1, max2))
1084     return false;
1085
1086   return true;
1087 }
1088
1089 /* Compare the relative position of T1 and T2 into their respective
1090    template parameter list.
1091    T1 and T2 must be template parameter types.
1092    Return TRUE if T1 and T2 have the same position, FALSE otherwise.  */
1093
1094 static bool
1095 comp_template_parms_position (tree t1, tree t2)
1096 {
1097   gcc_assert (t1 && t2
1098               && TREE_CODE (t1) == TREE_CODE (t2)
1099               && (TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM
1100                   || TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM
1101                   || TREE_CODE (t1) == TEMPLATE_TYPE_PARM));
1102
1103       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1104           || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
1105           || (TEMPLATE_TYPE_PARAMETER_PACK (t1) 
1106               != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
1107         return false;
1108
1109       return true;
1110 }
1111
1112 /* Subroutine of incompatible_dependent_types_p.
1113    Return the template parameter of the dependent type T.
1114    If T is a typedef, return the template parameters of
1115    the _decl_ of the typedef. T must be a dependent type.  */
1116
1117 static tree
1118 get_template_parms_of_dependent_type (tree t)
1119 {
1120   tree tinfo = NULL_TREE, tparms = NULL_TREE;
1121
1122   /* First, try the obvious case of getting the
1123      template info from T itself.  */
1124   if ((tinfo = get_template_info (t)))
1125     ;
1126   else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
1127     return TEMPLATE_TYPE_PARM_SIBLING_PARMS (t);
1128   else if (typedef_variant_p (t)
1129            && !NAMESPACE_SCOPE_P (TYPE_NAME (t)))
1130     tinfo = get_template_info (DECL_CONTEXT (TYPE_NAME (t)));
1131   /* If T is a TYPENAME_TYPE which context is a template type
1132      parameter, get the template parameters from that context.  */
1133   else if (TYPE_CONTEXT (t)
1134            && TREE_CODE (TYPE_CONTEXT (t)) == TEMPLATE_TYPE_PARM)
1135    return TEMPLATE_TYPE_PARM_SIBLING_PARMS (TYPE_CONTEXT (t));
1136   else if (TYPE_CONTEXT (t)
1137            && !NAMESPACE_SCOPE_P (t))
1138     tinfo = get_template_info (TYPE_CONTEXT (t));
1139
1140   if (tinfo)
1141     tparms = DECL_TEMPLATE_PARMS (TI_TEMPLATE (tinfo));
1142
1143   return tparms;
1144 }
1145
1146 /* Subroutine of structural_comptypes.
1147    Compare the dependent types T1 and T2.
1148    Return TRUE if we are sure they can't be equal, FALSE otherwise.
1149    The whole point of this function is to support cases where either T1 or
1150    T2 is a typedef. In those cases, we need to compare the template parameters
1151    of the _decl_ of the typedef. If those don't match then we know T1
1152    and T2 cannot be equal.  */
1153
1154 static bool
1155 incompatible_dependent_types_p (tree t1, tree t2)
1156 {
1157   tree tparms1 = NULL_TREE, tparms2 = NULL_TREE;
1158   bool t1_typedef_variant_p, t2_typedef_variant_p;
1159
1160   if (!uses_template_parms (t1) || !uses_template_parms (t2))
1161     return false;
1162
1163   if (TREE_CODE (t1) == TEMPLATE_TYPE_PARM)
1164     {
1165       /* If T1 and T2 don't have the same relative position in their
1166          template parameters set, they can't be equal.  */
1167       if (!comp_template_parms_position (t1, t2))
1168         return true;
1169     }
1170
1171   t1_typedef_variant_p = typedef_variant_p (t1);
1172   t2_typedef_variant_p = typedef_variant_p (t2);
1173
1174   /* Either T1 or T2 must be a typedef.  */
1175   if (!t1_typedef_variant_p && !t2_typedef_variant_p)
1176     return false;
1177
1178   if (!t1_typedef_variant_p || !t2_typedef_variant_p)
1179     /* Either T1 or T2 is not a typedef so we cannot compare the
1180        the template parms of the typedefs of T1 and T2.
1181        At this point, if the main variant type of T1 and T2 are equal
1182        it means the two types can't be incompatible, from the perspective
1183        of this function.  */
1184     if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1185       return false;
1186
1187   /* So if we reach this point, it means either T1 or T2 is a typedef variant.
1188      Let's compare their template parameters.  */
1189
1190   tparms1 = get_template_parms_of_dependent_type (t1);
1191   tparms2 = get_template_parms_of_dependent_type (t2);
1192
1193   /* If T2 is a template type parm and if we could not get the template
1194      parms it belongs to, that means we have not finished parsing the
1195      full set of template parameters of the template declaration it
1196      belongs to yet. If we could get the template parms T1 belongs to,
1197      that mostly means T1 and T2 belongs to templates that are
1198      different and incompatible.  */
1199   if (TREE_CODE (t1) == TEMPLATE_TYPE_PARM
1200       && (tparms1 == NULL_TREE || tparms2 == NULL_TREE)
1201       && tparms1 != tparms2)
1202     return true;
1203
1204   if (tparms1 == NULL_TREE
1205       || tparms2 == NULL_TREE
1206       || tparms1 == tparms2)
1207     return false;
1208
1209   /* And now compare the mighty template parms!  */
1210   return !comp_template_parms (tparms1, tparms2);
1211 }
1212
1213 /* Subroutine in comptypes.  */
1214
1215 static bool
1216 structural_comptypes (tree t1, tree t2, int strict)
1217 {
1218   if (t1 == t2)
1219     return true;
1220
1221   /* Suppress errors caused by previously reported errors.  */
1222   if (t1 == error_mark_node || t2 == error_mark_node)
1223     return false;
1224
1225   gcc_assert (TYPE_P (t1) && TYPE_P (t2));
1226
1227   /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1228      current instantiation.  */
1229   if (TREE_CODE (t1) == TYPENAME_TYPE)
1230     t1 = resolve_typename_type (t1, /*only_current_p=*/true);
1231
1232   if (TREE_CODE (t2) == TYPENAME_TYPE)
1233     t2 = resolve_typename_type (t2, /*only_current_p=*/true);
1234
1235   if (TYPE_PTRMEMFUNC_P (t1))
1236     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
1237   if (TYPE_PTRMEMFUNC_P (t2))
1238     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
1239
1240   /* Different classes of types can't be compatible.  */
1241   if (TREE_CODE (t1) != TREE_CODE (t2))
1242     return false;
1243
1244   /* Qualifiers must match.  For array types, we will check when we
1245      recur on the array element types.  */
1246   if (TREE_CODE (t1) != ARRAY_TYPE
1247       && TYPE_QUALS (t1) != TYPE_QUALS (t2))
1248     return false;
1249   if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
1250     return false;
1251
1252   /* If T1 and T2 are dependent typedefs then check upfront that
1253      the template parameters of their typedef DECLs match before
1254      going down checking their subtypes.  */
1255   if (incompatible_dependent_types_p (t1, t2))
1256     return false;
1257
1258   /* Allow for two different type nodes which have essentially the same
1259      definition.  Note that we already checked for equality of the type
1260      qualifiers (just above).  */
1261
1262   if (TREE_CODE (t1) != ARRAY_TYPE
1263       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1264     return true;
1265
1266
1267   /* Compare the types.  Break out if they could be the same.  */
1268   switch (TREE_CODE (t1))
1269     {
1270     case VOID_TYPE:
1271     case BOOLEAN_TYPE:
1272       /* All void and bool types are the same.  */
1273       break;
1274
1275     case INTEGER_TYPE:
1276     case FIXED_POINT_TYPE:
1277     case REAL_TYPE:
1278       /* With these nodes, we can't determine type equivalence by
1279          looking at what is stored in the nodes themselves, because
1280          two nodes might have different TYPE_MAIN_VARIANTs but still
1281          represent the same type.  For example, wchar_t and int could
1282          have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1283          TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1284          and are distinct types. On the other hand, int and the
1285          following typedef
1286
1287            typedef int INT __attribute((may_alias));
1288
1289          have identical properties, different TYPE_MAIN_VARIANTs, but
1290          represent the same type.  The canonical type system keeps
1291          track of equivalence in this case, so we fall back on it.  */
1292       return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1293
1294     case TEMPLATE_TEMPLATE_PARM:
1295     case BOUND_TEMPLATE_TEMPLATE_PARM:
1296       if (!comp_template_parms_position (t1, t2))
1297         return false;
1298       if (!comp_template_parms
1299           (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1300            DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1301         return false;
1302       if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1303         break;
1304       /* Don't check inheritance.  */
1305       strict = COMPARE_STRICT;
1306       /* Fall through.  */
1307
1308     case RECORD_TYPE:
1309     case UNION_TYPE:
1310       if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1311           && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1312               || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1313           && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1314         break;
1315
1316       if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1317         break;
1318       else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1319         break;
1320
1321       return false;
1322
1323     case OFFSET_TYPE:
1324       if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1325                       strict & ~COMPARE_REDECLARATION))
1326         return false;
1327       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1328         return false;
1329       break;
1330
1331     case REFERENCE_TYPE:
1332       if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
1333         return false;
1334       /* fall through to checks for pointer types */
1335
1336     case POINTER_TYPE:
1337       if (TYPE_MODE (t1) != TYPE_MODE (t2)
1338           || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
1339           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1340         return false;
1341       break;
1342
1343     case METHOD_TYPE:
1344     case FUNCTION_TYPE:
1345       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1346         return false;
1347       if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)))
1348         return false;
1349       break;
1350
1351     case ARRAY_TYPE:
1352       /* Target types must match incl. qualifiers.  */
1353       if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)))
1354         return false;
1355       break;
1356
1357     case TEMPLATE_TYPE_PARM:
1358       /* If incompatible_dependent_types_p called earlier didn't decide
1359          T1 and T2 were different, they might be equal.  */
1360       break;
1361
1362     case TYPENAME_TYPE:
1363       if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1364                           TYPENAME_TYPE_FULLNAME (t2)))
1365         return false;
1366       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1367         return false;
1368       break;
1369
1370     case UNBOUND_CLASS_TEMPLATE:
1371       if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1372         return false;
1373       if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)))
1374         return false;
1375       break;
1376
1377     case COMPLEX_TYPE:
1378       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1379         return false;
1380       break;
1381
1382     case VECTOR_TYPE:
1383       if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2)
1384           || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1385         return false;
1386       break;
1387
1388     case TYPE_PACK_EXPANSION:
1389       return same_type_p (PACK_EXPANSION_PATTERN (t1), 
1390                           PACK_EXPANSION_PATTERN (t2));
1391
1392     case DECLTYPE_TYPE:
1393       if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1)
1394           != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2)
1395           || (DECLTYPE_FOR_LAMBDA_CAPTURE (t1)
1396               != DECLTYPE_FOR_LAMBDA_CAPTURE (t2))
1397           || (DECLTYPE_FOR_LAMBDA_RETURN (t1)
1398               != DECLTYPE_FOR_LAMBDA_RETURN (t2))
1399           || !cp_tree_equal (DECLTYPE_TYPE_EXPR (t1), 
1400                              DECLTYPE_TYPE_EXPR (t2)))
1401         return false;
1402       break;
1403
1404     default:
1405       return false;
1406     }
1407
1408   /* If we get here, we know that from a target independent POV the
1409      types are the same.  Make sure the target attributes are also
1410      the same.  */
1411   return targetm.comp_type_attributes (t1, t2);
1412 }
1413
1414 /* Return true if T1 and T2 are related as allowed by STRICT.  STRICT
1415    is a bitwise-or of the COMPARE_* flags.  */
1416
1417 bool
1418 comptypes (tree t1, tree t2, int strict)
1419 {
1420   if (strict == COMPARE_STRICT)
1421     {
1422       if (t1 == t2)
1423         return true;
1424
1425       if (t1 == error_mark_node || t2 == error_mark_node)
1426         return false;
1427
1428       if (TYPE_STRUCTURAL_EQUALITY_P (t1) || TYPE_STRUCTURAL_EQUALITY_P (t2))
1429         /* At least one of the types requires structural equality, so
1430            perform a deep check. */
1431         return structural_comptypes (t1, t2, strict);
1432
1433 #ifdef ENABLE_CHECKING
1434       if (USE_CANONICAL_TYPES)
1435         {
1436           bool result = structural_comptypes (t1, t2, strict);
1437           
1438           if (result && TYPE_CANONICAL (t1) != TYPE_CANONICAL (t2))
1439             /* The two types are structurally equivalent, but their
1440                canonical types were different. This is a failure of the
1441                canonical type propagation code.*/
1442             internal_error 
1443               ("canonical types differ for identical types %T and %T", 
1444                t1, t2);
1445           else if (!result && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
1446             /* Two types are structurally different, but the canonical
1447                types are the same. This means we were over-eager in
1448                assigning canonical types. */
1449             internal_error 
1450               ("same canonical type node for different types %T and %T",
1451                t1, t2);
1452           
1453           return result;
1454         }
1455 #else
1456       if (USE_CANONICAL_TYPES)
1457         return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1458 #endif
1459       else
1460         return structural_comptypes (t1, t2, strict);
1461     }
1462   else if (strict == COMPARE_STRUCTURAL)
1463     return structural_comptypes (t1, t2, COMPARE_STRICT);
1464   else
1465     return structural_comptypes (t1, t2, strict);
1466 }
1467
1468 /* Returns 1 if TYPE1 is at least as qualified as TYPE2.  */
1469
1470 bool
1471 at_least_as_qualified_p (const_tree type1, const_tree type2)
1472 {
1473   int q1 = cp_type_quals (type1);
1474   int q2 = cp_type_quals (type2);
1475
1476   /* All qualifiers for TYPE2 must also appear in TYPE1.  */
1477   return (q1 & q2) == q2;
1478 }
1479
1480 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1481    more cv-qualified that TYPE1, and 0 otherwise.  */
1482
1483 int
1484 comp_cv_qualification (const_tree type1, const_tree type2)
1485 {
1486   int q1 = cp_type_quals (type1);
1487   int q2 = cp_type_quals (type2);
1488
1489   if (q1 == q2)
1490     return 0;
1491
1492   if ((q1 & q2) == q2)
1493     return 1;
1494   else if ((q1 & q2) == q1)
1495     return -1;
1496
1497   return 0;
1498 }
1499
1500 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1501    subset of the cv-qualification signature of TYPE2, and the types
1502    are similar.  Returns -1 if the other way 'round, and 0 otherwise.  */
1503
1504 int
1505 comp_cv_qual_signature (tree type1, tree type2)
1506 {
1507   if (comp_ptr_ttypes_real (type2, type1, -1))
1508     return 1;
1509   else if (comp_ptr_ttypes_real (type1, type2, -1))
1510     return -1;
1511   else
1512     return 0;
1513 }
1514 \f
1515 /* Subroutines of `comptypes'.  */
1516
1517 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1518    equivalent in the sense that functions with those parameter types
1519    can have equivalent types.  The two lists must be equivalent,
1520    element by element.  */
1521
1522 bool
1523 compparms (const_tree parms1, const_tree parms2)
1524 {
1525   const_tree t1, t2;
1526
1527   /* An unspecified parmlist matches any specified parmlist
1528      whose argument types don't need default promotions.  */
1529
1530   for (t1 = parms1, t2 = parms2;
1531        t1 || t2;
1532        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1533     {
1534       /* If one parmlist is shorter than the other,
1535          they fail to match.  */
1536       if (!t1 || !t2)
1537         return false;
1538       if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1539         return false;
1540     }
1541   return true;
1542 }
1543
1544 \f
1545 /* Process a sizeof or alignof expression where the operand is a
1546    type.  */
1547
1548 tree
1549 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1550 {
1551   tree value;
1552   bool dependent_p;
1553
1554   gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
1555   if (type == error_mark_node)
1556     return error_mark_node;
1557
1558   type = non_reference (type);
1559   if (TREE_CODE (type) == METHOD_TYPE)
1560     {
1561       if (complain)
1562         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
1563                  "invalid application of %qs to a member function", 
1564                  operator_name_info[(int) op].name);
1565       value = size_one_node;
1566     }
1567
1568   dependent_p = dependent_type_p (type);
1569   if (!dependent_p)
1570     complete_type (type);
1571   if (dependent_p
1572       /* VLA types will have a non-constant size.  In the body of an
1573          uninstantiated template, we don't need to try to compute the
1574          value, because the sizeof expression is not an integral
1575          constant expression in that case.  And, if we do try to
1576          compute the value, we'll likely end up with SAVE_EXPRs, which
1577          the template substitution machinery does not expect to see.  */
1578       || (processing_template_decl 
1579           && COMPLETE_TYPE_P (type)
1580           && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
1581     {
1582       value = build_min (op, size_type_node, type);
1583       TREE_READONLY (value) = 1;
1584       return value;
1585     }
1586
1587   return c_sizeof_or_alignof_type (input_location, complete_type (type),
1588                                    op == SIZEOF_EXPR,
1589                                    complain);
1590 }
1591
1592 /* Return the size of the type, without producing any warnings for
1593    types whose size cannot be taken.  This routine should be used only
1594    in some other routine that has already produced a diagnostic about
1595    using the size of such a type.  */
1596 tree 
1597 cxx_sizeof_nowarn (tree type)
1598 {
1599   if (TREE_CODE (type) == FUNCTION_TYPE
1600       || TREE_CODE (type) == VOID_TYPE
1601       || TREE_CODE (type) == ERROR_MARK)
1602     return size_one_node;
1603   else if (!COMPLETE_TYPE_P (type))
1604     return size_zero_node;
1605   else
1606     return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false);
1607 }
1608
1609 /* Process a sizeof expression where the operand is an expression.  */
1610
1611 static tree
1612 cxx_sizeof_expr (tree e, tsubst_flags_t complain)
1613 {
1614   if (e == error_mark_node)
1615     return error_mark_node;
1616
1617   if (processing_template_decl)
1618     {
1619       e = build_min (SIZEOF_EXPR, size_type_node, e);
1620       TREE_SIDE_EFFECTS (e) = 0;
1621       TREE_READONLY (e) = 1;
1622
1623       return e;
1624     }
1625
1626   /* To get the size of a static data member declared as an array of
1627      unknown bound, we need to instantiate it.  */
1628   if (TREE_CODE (e) == VAR_DECL
1629       && VAR_HAD_UNKNOWN_BOUND (e)
1630       && DECL_TEMPLATE_INSTANTIATION (e))
1631     instantiate_decl (e, /*defer_ok*/true, /*expl_inst_mem*/false);
1632
1633   if (TREE_CODE (e) == COMPONENT_REF
1634       && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1635       && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1636     {
1637       if (complain & tf_error)
1638         error ("invalid application of %<sizeof%> to a bit-field");
1639       else
1640         return error_mark_node;
1641       e = char_type_node;
1642     }
1643   else if (is_overloaded_fn (e))
1644     {
1645       if (complain & tf_error)
1646         permerror (input_location, "ISO C++ forbids applying %<sizeof%> to an expression of "
1647                    "function type");
1648       else
1649         return error_mark_node;
1650       e = char_type_node;
1651     }
1652   else if (type_unknown_p (e))
1653     {
1654       if (complain & tf_error)
1655         cxx_incomplete_type_error (e, TREE_TYPE (e));
1656       else
1657         return error_mark_node;
1658       e = char_type_node;
1659     }
1660   else
1661     e = TREE_TYPE (e);
1662
1663   return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error);
1664 }
1665
1666 /* Implement the __alignof keyword: Return the minimum required
1667    alignment of E, measured in bytes.  For VAR_DECL's and
1668    FIELD_DECL's return DECL_ALIGN (which can be set from an
1669    "aligned" __attribute__ specification).  */
1670
1671 static tree
1672 cxx_alignof_expr (tree e, tsubst_flags_t complain)
1673 {
1674   tree t;
1675
1676   if (e == error_mark_node)
1677     return error_mark_node;
1678
1679   if (processing_template_decl)
1680     {
1681       e = build_min (ALIGNOF_EXPR, size_type_node, e);
1682       TREE_SIDE_EFFECTS (e) = 0;
1683       TREE_READONLY (e) = 1;
1684
1685       return e;
1686     }
1687
1688   if (TREE_CODE (e) == VAR_DECL)
1689     t = size_int (DECL_ALIGN_UNIT (e));
1690   else if (TREE_CODE (e) == COMPONENT_REF
1691            && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1692            && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1693     {
1694       if (complain & tf_error)
1695         error ("invalid application of %<__alignof%> to a bit-field");
1696       else
1697         return error_mark_node;
1698       t = size_one_node;
1699     }
1700   else if (TREE_CODE (e) == COMPONENT_REF
1701            && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL)
1702     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1)));
1703   else if (is_overloaded_fn (e))
1704     {
1705       if (complain & tf_error)
1706         permerror (input_location, "ISO C++ forbids applying %<__alignof%> to an expression of "
1707                    "function type");
1708       else
1709         return error_mark_node;
1710       if (TREE_CODE (e) == FUNCTION_DECL)
1711         t = size_int (DECL_ALIGN_UNIT (e));
1712       else
1713         t = size_one_node;
1714     }
1715   else if (type_unknown_p (e))
1716     {
1717       if (complain & tf_error)
1718         cxx_incomplete_type_error (e, TREE_TYPE (e));
1719       else
1720         return error_mark_node;
1721       t = size_one_node;
1722     }
1723   else
1724     return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR, 
1725                                        complain & tf_error);
1726
1727   return fold_convert (size_type_node, t);
1728 }
1729
1730 /* Process a sizeof or alignof expression E with code OP where the operand
1731    is an expression.  */
1732
1733 tree
1734 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain)
1735 {
1736   if (op == SIZEOF_EXPR)
1737     return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none);
1738   else
1739     return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none);
1740 }
1741 \f
1742 /* EXPR is being used in a context that is not a function call.
1743    Enforce:
1744
1745      [expr.ref]
1746
1747      The expression can be used only as the left-hand operand of a
1748      member function call.
1749
1750      [expr.mptr.operator]
1751
1752      If the result of .* or ->* is a function, then that result can be
1753      used only as the operand for the function call operator ().
1754
1755    by issuing an error message if appropriate.  Returns true iff EXPR
1756    violates these rules.  */
1757
1758 bool
1759 invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
1760 {
1761   if (expr && DECL_NONSTATIC_MEMBER_FUNCTION_P (expr))
1762     {
1763       if (complain & tf_error)
1764         error ("invalid use of non-static member function");
1765       return true;
1766     }
1767   return false;
1768 }
1769
1770 /* If EXP is a reference to a bitfield, and the type of EXP does not
1771    match the declared type of the bitfield, return the declared type
1772    of the bitfield.  Otherwise, return NULL_TREE.  */
1773
1774 tree
1775 is_bitfield_expr_with_lowered_type (const_tree exp)
1776 {
1777   switch (TREE_CODE (exp))
1778     {
1779     case COND_EXPR:
1780       if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)
1781                                                ? TREE_OPERAND (exp, 1)
1782                                                : TREE_OPERAND (exp, 0)))
1783         return NULL_TREE;
1784       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2));
1785
1786     case COMPOUND_EXPR:
1787       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1));
1788
1789     case MODIFY_EXPR:
1790     case SAVE_EXPR:
1791       return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1792
1793     case COMPONENT_REF:
1794       {
1795         tree field;
1796         
1797         field = TREE_OPERAND (exp, 1);
1798         if (TREE_CODE (field) != FIELD_DECL || !DECL_BIT_FIELD_TYPE (field))
1799           return NULL_TREE;
1800         if (same_type_ignoring_top_level_qualifiers_p
1801             (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field)))
1802           return NULL_TREE;
1803         return DECL_BIT_FIELD_TYPE (field);
1804       }
1805
1806     CASE_CONVERT:
1807       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp, 0)))
1808           == TYPE_MAIN_VARIANT (TREE_TYPE (exp)))
1809         return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0));
1810       /* Fallthrough.  */
1811
1812     default:
1813       return NULL_TREE;
1814     }
1815 }
1816
1817 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
1818    bitfield with a lowered type, the type of EXP is returned, rather
1819    than NULL_TREE.  */
1820
1821 tree
1822 unlowered_expr_type (const_tree exp)
1823 {
1824   tree type;
1825
1826   type = is_bitfield_expr_with_lowered_type (exp);
1827   if (!type)
1828     type = TREE_TYPE (exp);
1829
1830   return type;
1831 }
1832
1833 /* Perform the conversions in [expr] that apply when an lvalue appears
1834    in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1835    function-to-pointer conversions.  In addition, manifest constants
1836    are replaced by their values, and bitfield references are converted
1837    to their declared types.
1838
1839    Although the returned value is being used as an rvalue, this
1840    function does not wrap the returned expression in a
1841    NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
1842    that the return value is no longer an lvalue.  */
1843
1844 tree
1845 decay_conversion (tree exp)
1846 {
1847   tree type;
1848   enum tree_code code;
1849
1850   type = TREE_TYPE (exp);
1851   if (type == error_mark_node)
1852     return error_mark_node;
1853
1854   exp = resolve_nondeduced_context (exp);
1855   if (type_unknown_p (exp))
1856     {
1857       cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1858       return error_mark_node;
1859     }
1860
1861   exp = decl_constant_value (exp);
1862   if (error_operand_p (exp))
1863     return error_mark_node;
1864
1865   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1866      Leave such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
1867   code = TREE_CODE (type);
1868   if (code == VOID_TYPE)
1869     {
1870       error ("void value not ignored as it ought to be");
1871       return error_mark_node;
1872     }
1873   if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error))
1874     return error_mark_node;
1875   if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1876     return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error);
1877   if (code == ARRAY_TYPE)
1878     {
1879       tree adr;
1880       tree ptrtype;
1881
1882       if (TREE_CODE (exp) == INDIRECT_REF)
1883         return build_nop (build_pointer_type (TREE_TYPE (type)),
1884                           TREE_OPERAND (exp, 0));
1885
1886       if (TREE_CODE (exp) == COMPOUND_EXPR)
1887         {
1888           tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1889           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1890                          TREE_OPERAND (exp, 0), op1);
1891         }
1892
1893       if (!lvalue_p (exp)
1894           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1895         {
1896           error ("invalid use of non-lvalue array");
1897           return error_mark_node;
1898         }
1899
1900       ptrtype = build_pointer_type (TREE_TYPE (type));
1901
1902       if (TREE_CODE (exp) == VAR_DECL)
1903         {
1904           if (!cxx_mark_addressable (exp))
1905             return error_mark_node;
1906           adr = build_nop (ptrtype, build_address (exp));
1907           return adr;
1908         }
1909       /* This way is better for a COMPONENT_REF since it can
1910          simplify the offset for a component.  */
1911       adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
1912       return cp_convert (ptrtype, adr);
1913     }
1914
1915   /* If a bitfield is used in a context where integral promotion
1916      applies, then the caller is expected to have used
1917      default_conversion.  That function promotes bitfields correctly
1918      before calling this function.  At this point, if we have a
1919      bitfield referenced, we may assume that is not subject to
1920      promotion, and that, therefore, the type of the resulting rvalue
1921      is the declared type of the bitfield.  */
1922   exp = convert_bitfield_to_declared_type (exp);
1923
1924   /* We do not call rvalue() here because we do not want to wrap EXP
1925      in a NON_LVALUE_EXPR.  */
1926
1927   /* [basic.lval]
1928
1929      Non-class rvalues always have cv-unqualified types.  */
1930   type = TREE_TYPE (exp);
1931   if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
1932     exp = build_nop (cv_unqualified (type), exp);
1933
1934   return exp;
1935 }
1936
1937 /* Perform preparatory conversions, as part of the "usual arithmetic
1938    conversions".  In particular, as per [expr]:
1939
1940      Whenever an lvalue expression appears as an operand of an
1941      operator that expects the rvalue for that operand, the
1942      lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1943      standard conversions are applied to convert the expression to an
1944      rvalue.
1945
1946    In addition, we perform integral promotions here, as those are
1947    applied to both operands to a binary operator before determining
1948    what additional conversions should apply.  */
1949
1950 tree
1951 default_conversion (tree exp)
1952 {
1953   /* Check for target-specific promotions.  */
1954   tree promoted_type = targetm.promoted_type (TREE_TYPE (exp));
1955   if (promoted_type)
1956     exp = cp_convert (promoted_type, exp);
1957   /* Perform the integral promotions first so that bitfield
1958      expressions (which may promote to "int", even if the bitfield is
1959      declared "unsigned") are promoted correctly.  */
1960   else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1961     exp = perform_integral_promotions (exp);
1962   /* Perform the other conversions.  */
1963   exp = decay_conversion (exp);
1964
1965   return exp;
1966 }
1967
1968 /* EXPR is an expression with an integral or enumeration type.
1969    Perform the integral promotions in [conv.prom], and return the
1970    converted value.  */
1971
1972 tree
1973 perform_integral_promotions (tree expr)
1974 {
1975   tree type;
1976   tree promoted_type;
1977
1978   /* [conv.prom]
1979
1980      If the bitfield has an enumerated type, it is treated as any
1981      other value of that type for promotion purposes.  */
1982   type = is_bitfield_expr_with_lowered_type (expr);
1983   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
1984     type = TREE_TYPE (expr);
1985   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
1986   promoted_type = type_promotes_to (type);
1987   if (type != promoted_type)
1988     expr = cp_convert (promoted_type, expr);
1989   return expr;
1990 }
1991
1992 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1993    decay_conversion to one.  */
1994
1995 int
1996 string_conv_p (const_tree totype, const_tree exp, int warn)
1997 {
1998   tree t;
1999
2000   if (TREE_CODE (totype) != POINTER_TYPE)
2001     return 0;
2002
2003   t = TREE_TYPE (totype);
2004   if (!same_type_p (t, char_type_node)
2005       && !same_type_p (t, char16_type_node)
2006       && !same_type_p (t, char32_type_node)
2007       && !same_type_p (t, wchar_type_node))
2008     return 0;
2009
2010   if (TREE_CODE (exp) == STRING_CST)
2011     {
2012       /* Make sure that we don't try to convert between char and wide chars.  */
2013       if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
2014         return 0;
2015     }
2016   else
2017     {
2018       /* Is this a string constant which has decayed to 'const char *'?  */
2019       t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
2020       if (!same_type_p (TREE_TYPE (exp), t))
2021         return 0;
2022       STRIP_NOPS (exp);
2023       if (TREE_CODE (exp) != ADDR_EXPR
2024           || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
2025         return 0;
2026     }
2027
2028   /* This warning is not very useful, as it complains about printf.  */
2029   if (warn)
2030     warning (OPT_Wwrite_strings,
2031              "deprecated conversion from string constant to %qT",
2032              totype);
2033
2034   return 1;
2035 }
2036
2037 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
2038    can, for example, use as an lvalue.  This code used to be in
2039    unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
2040    expressions, where we're dealing with aggregates.  But now it's again only
2041    called from unary_complex_lvalue.  The case (in particular) that led to
2042    this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
2043    get it there.  */
2044
2045 static tree
2046 rationalize_conditional_expr (enum tree_code code, tree t,
2047                               tsubst_flags_t complain)
2048 {
2049   /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
2050      the first operand is always the one to be used if both operands
2051      are equal, so we know what conditional expression this used to be.  */
2052   if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
2053     {
2054       tree op0 = TREE_OPERAND (t, 0);
2055       tree op1 = TREE_OPERAND (t, 1);
2056
2057       /* The following code is incorrect if either operand side-effects.  */
2058       gcc_assert (!TREE_SIDE_EFFECTS (op0)
2059                   && !TREE_SIDE_EFFECTS (op1));
2060       return
2061         build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
2062                                                     ? LE_EXPR : GE_EXPR),
2063                                                    op0, TREE_CODE (op0),
2064                                                    op1, TREE_CODE (op1),
2065                                                    /*overloaded_p=*/NULL,
2066                                                    complain),
2067                                 cp_build_unary_op (code, op0, 0, complain),
2068                                 cp_build_unary_op (code, op1, 0, complain),
2069                                 complain);
2070     }
2071
2072   return
2073     build_conditional_expr (TREE_OPERAND (t, 0),
2074                             cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
2075                                                complain),
2076                             cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
2077                                                complain),
2078                             complain);
2079 }
2080
2081 /* Given the TYPE of an anonymous union field inside T, return the
2082    FIELD_DECL for the field.  If not found return NULL_TREE.  Because
2083    anonymous unions can nest, we must also search all anonymous unions
2084    that are directly reachable.  */
2085
2086 tree
2087 lookup_anon_field (tree t, tree type)
2088 {
2089   tree field;
2090
2091   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2092     {
2093       if (TREE_STATIC (field))
2094         continue;
2095       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
2096         continue;
2097
2098       /* If we find it directly, return the field.  */
2099       if (DECL_NAME (field) == NULL_TREE
2100           && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
2101         {
2102           return field;
2103         }
2104
2105       /* Otherwise, it could be nested, search harder.  */
2106       if (DECL_NAME (field) == NULL_TREE
2107           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2108         {
2109           tree subfield = lookup_anon_field (TREE_TYPE (field), type);
2110           if (subfield)
2111             return subfield;
2112         }
2113     }
2114   return NULL_TREE;
2115 }
2116
2117 /* Build an expression representing OBJECT.MEMBER.  OBJECT is an
2118    expression; MEMBER is a DECL or baselink.  If ACCESS_PATH is
2119    non-NULL, it indicates the path to the base used to name MEMBER.
2120    If PRESERVE_REFERENCE is true, the expression returned will have
2121    REFERENCE_TYPE if the MEMBER does.  Otherwise, the expression
2122    returned will have the type referred to by the reference.
2123
2124    This function does not perform access control; that is either done
2125    earlier by the parser when the name of MEMBER is resolved to MEMBER
2126    itself, or later when overload resolution selects one of the
2127    functions indicated by MEMBER.  */
2128
2129 tree
2130 build_class_member_access_expr (tree object, tree member,
2131                                 tree access_path, bool preserve_reference,
2132                                 tsubst_flags_t complain)
2133 {
2134   tree object_type;
2135   tree member_scope;
2136   tree result = NULL_TREE;
2137
2138   if (error_operand_p (object) || error_operand_p (member))
2139     return error_mark_node;
2140
2141   gcc_assert (DECL_P (member) || BASELINK_P (member));
2142
2143   /* [expr.ref]
2144
2145      The type of the first expression shall be "class object" (of a
2146      complete type).  */
2147   object_type = TREE_TYPE (object);
2148   if (!currently_open_class (object_type)
2149       && !complete_type_or_else (object_type, object))
2150     return error_mark_node;
2151   if (!CLASS_TYPE_P (object_type))
2152     {
2153       if (complain & tf_error)
2154         error ("request for member %qD in %qE, which is of non-class type %qT",
2155                member, object, object_type);
2156       return error_mark_node;
2157     }
2158
2159   /* The standard does not seem to actually say that MEMBER must be a
2160      member of OBJECT_TYPE.  However, that is clearly what is
2161      intended.  */
2162   if (DECL_P (member))
2163     {
2164       member_scope = DECL_CLASS_CONTEXT (member);
2165       mark_used (member);
2166       if (TREE_DEPRECATED (member))
2167         warn_deprecated_use (member, NULL_TREE);
2168     }
2169   else
2170     member_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (member));
2171   /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2172      presently be the anonymous union.  Go outwards until we find a
2173      type related to OBJECT_TYPE.  */
2174   while (ANON_AGGR_TYPE_P (member_scope)
2175          && !same_type_ignoring_top_level_qualifiers_p (member_scope,
2176                                                         object_type))
2177     member_scope = TYPE_CONTEXT (member_scope);
2178   if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
2179     {
2180       if (complain & tf_error)
2181         {
2182           if (TREE_CODE (member) == FIELD_DECL)
2183             error ("invalid use of nonstatic data member %qE", member);
2184           else
2185             error ("%qD is not a member of %qT", member, object_type);
2186         }
2187       return error_mark_node;
2188     }
2189
2190   /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2191      `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only an lvalue
2192      in the front end; only _DECLs and _REFs are lvalues in the back end.  */
2193   {
2194     tree temp = unary_complex_lvalue (ADDR_EXPR, object);
2195     if (temp)
2196       object = cp_build_indirect_ref (temp, RO_NULL, complain);
2197   }
2198
2199   /* In [expr.ref], there is an explicit list of the valid choices for
2200      MEMBER.  We check for each of those cases here.  */
2201   if (TREE_CODE (member) == VAR_DECL)
2202     {
2203       /* A static data member.  */
2204       result = member;
2205       /* If OBJECT has side-effects, they are supposed to occur.  */
2206       if (TREE_SIDE_EFFECTS (object))
2207         result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result);
2208     }
2209   else if (TREE_CODE (member) == FIELD_DECL)
2210     {
2211       /* A non-static data member.  */
2212       bool null_object_p;
2213       int type_quals;
2214       tree member_type;
2215
2216       null_object_p = (TREE_CODE (object) == INDIRECT_REF
2217                        && integer_zerop (TREE_OPERAND (object, 0)));
2218
2219       /* Convert OBJECT to the type of MEMBER.  */
2220       if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
2221                         TYPE_MAIN_VARIANT (member_scope)))
2222         {
2223           tree binfo;
2224           base_kind kind;
2225
2226           binfo = lookup_base (access_path ? access_path : object_type,
2227                                member_scope, ba_unique,  &kind);
2228           if (binfo == error_mark_node)
2229             return error_mark_node;
2230
2231           /* It is invalid to try to get to a virtual base of a
2232              NULL object.  The most common cause is invalid use of
2233              offsetof macro.  */
2234           if (null_object_p && kind == bk_via_virtual)
2235             {
2236               if (complain & tf_error)
2237                 {
2238                   error ("invalid access to non-static data member %qD of "
2239                          "NULL object",
2240                          member);
2241                   error ("(perhaps the %<offsetof%> macro was used incorrectly)");
2242                 }
2243               return error_mark_node;
2244             }
2245
2246           /* Convert to the base.  */
2247           object = build_base_path (PLUS_EXPR, object, binfo,
2248                                     /*nonnull=*/1);
2249           /* If we found the base successfully then we should be able
2250              to convert to it successfully.  */
2251           gcc_assert (object != error_mark_node);
2252         }
2253
2254       /* Complain about other invalid uses of offsetof, even though they will
2255          give the right answer.  Note that we complain whether or not they
2256          actually used the offsetof macro, since there's no way to know at this
2257          point.  So we just give a warning, instead of a pedwarn.  */
2258       /* Do not produce this warning for base class field references, because
2259          we know for a fact that didn't come from offsetof.  This does occur
2260          in various testsuite cases where a null object is passed where a
2261          vtable access is required.  */
2262       if (null_object_p && warn_invalid_offsetof
2263           && CLASSTYPE_NON_STD_LAYOUT (object_type)
2264           && !DECL_FIELD_IS_BASE (member)
2265           && cp_unevaluated_operand == 0
2266           && (complain & tf_warning))
2267         {
2268           warning (OPT_Winvalid_offsetof, 
2269                    "invalid access to non-static data member %qD "
2270                    " of NULL object", member);
2271           warning (OPT_Winvalid_offsetof, 
2272                    "(perhaps the %<offsetof%> macro was used incorrectly)");
2273         }
2274
2275       /* If MEMBER is from an anonymous aggregate, we have converted
2276          OBJECT so that it refers to the class containing the
2277          anonymous union.  Generate a reference to the anonymous union
2278          itself, and recur to find MEMBER.  */
2279       if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
2280           /* When this code is called from build_field_call, the
2281              object already has the type of the anonymous union.
2282              That is because the COMPONENT_REF was already
2283              constructed, and was then disassembled before calling
2284              build_field_call.  After the function-call code is
2285              cleaned up, this waste can be eliminated.  */
2286           && (!same_type_ignoring_top_level_qualifiers_p
2287               (TREE_TYPE (object), DECL_CONTEXT (member))))
2288         {
2289           tree anonymous_union;
2290
2291           anonymous_union = lookup_anon_field (TREE_TYPE (object),
2292                                                DECL_CONTEXT (member));
2293           object = build_class_member_access_expr (object,
2294                                                    anonymous_union,
2295                                                    /*access_path=*/NULL_TREE,
2296                                                    preserve_reference,
2297                                                    complain);
2298         }
2299
2300       /* Compute the type of the field, as described in [expr.ref].  */
2301       type_quals = TYPE_UNQUALIFIED;
2302       member_type = TREE_TYPE (member);
2303       if (TREE_CODE (member_type) != REFERENCE_TYPE)
2304         {
2305           type_quals = (cp_type_quals (member_type)
2306                         | cp_type_quals (object_type));
2307
2308           /* A field is const (volatile) if the enclosing object, or the
2309              field itself, is const (volatile).  But, a mutable field is
2310              not const, even within a const object.  */
2311           if (DECL_MUTABLE_P (member))
2312             type_quals &= ~TYPE_QUAL_CONST;
2313           member_type = cp_build_qualified_type (member_type, type_quals);
2314         }
2315
2316       result = build3 (COMPONENT_REF, member_type, object, member,
2317                        NULL_TREE);
2318       result = fold_if_not_in_template (result);
2319
2320       /* Mark the expression const or volatile, as appropriate.  Even
2321          though we've dealt with the type above, we still have to mark the
2322          expression itself.  */
2323       if (type_quals & TYPE_QUAL_CONST)
2324         TREE_READONLY (result) = 1;
2325       if (type_quals & TYPE_QUAL_VOLATILE)
2326         TREE_THIS_VOLATILE (result) = 1;
2327     }
2328   else if (BASELINK_P (member))
2329     {
2330       /* The member is a (possibly overloaded) member function.  */
2331       tree functions;
2332       tree type;
2333
2334       /* If the MEMBER is exactly one static member function, then we
2335          know the type of the expression.  Otherwise, we must wait
2336          until overload resolution has been performed.  */
2337       functions = BASELINK_FUNCTIONS (member);
2338       if (TREE_CODE (functions) == FUNCTION_DECL
2339           && DECL_STATIC_FUNCTION_P (functions))
2340         type = TREE_TYPE (functions);
2341       else
2342         type = unknown_type_node;
2343       /* Note that we do not convert OBJECT to the BASELINK_BINFO
2344          base.  That will happen when the function is called.  */
2345       result = build3 (COMPONENT_REF, type, object, member, NULL_TREE);
2346     }
2347   else if (TREE_CODE (member) == CONST_DECL)
2348     {
2349       /* The member is an enumerator.  */
2350       result = member;
2351       /* If OBJECT has side-effects, they are supposed to occur.  */
2352       if (TREE_SIDE_EFFECTS (object))
2353         result = build2 (COMPOUND_EXPR, TREE_TYPE (result),
2354                          object, result);
2355     }
2356   else
2357     {
2358       if (complain & tf_error)
2359         error ("invalid use of %qD", member);
2360       return error_mark_node;
2361     }
2362
2363   if (!preserve_reference)
2364     /* [expr.ref]
2365
2366        If E2 is declared to have type "reference to T", then ... the
2367        type of E1.E2 is T.  */
2368     result = convert_from_reference (result);
2369
2370   return result;
2371 }
2372
2373 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2374    SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type.  */
2375
2376 static tree
2377 lookup_destructor (tree object, tree scope, tree dtor_name)
2378 {
2379   tree object_type = TREE_TYPE (object);
2380   tree dtor_type = TREE_OPERAND (dtor_name, 0);
2381   tree expr;
2382
2383   if (scope && !check_dtor_name (scope, dtor_type))
2384     {
2385       error ("qualified type %qT does not match destructor name ~%qT",
2386              scope, dtor_type);
2387       return error_mark_node;
2388     }
2389   if (TREE_CODE (dtor_type) == IDENTIFIER_NODE)
2390     {
2391       /* In a template, names we can't find a match for are still accepted
2392          destructor names, and we check them here.  */
2393       if (check_dtor_name (object_type, dtor_type))
2394         dtor_type = object_type;
2395       else
2396         {
2397           error ("object type %qT does not match destructor name ~%qT",
2398                  object_type, dtor_type);
2399           return error_mark_node;
2400         }
2401       
2402     }
2403   else if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2404     {
2405       error ("the type being destroyed is %qT, but the destructor refers to %qT",
2406              TYPE_MAIN_VARIANT (object_type), dtor_type);
2407       return error_mark_node;
2408     }
2409   expr = lookup_member (dtor_type, complete_dtor_identifier,
2410                         /*protect=*/1, /*want_type=*/false);
2411   expr = (adjust_result_of_qualified_name_lookup
2412           (expr, dtor_type, object_type));
2413   return expr;
2414 }
2415
2416 /* An expression of the form "A::template B" has been resolved to
2417    DECL.  Issue a diagnostic if B is not a template or template
2418    specialization.  */
2419
2420 void
2421 check_template_keyword (tree decl)
2422 {
2423   /* The standard says:
2424
2425       [temp.names]
2426
2427       If a name prefixed by the keyword template is not a member
2428       template, the program is ill-formed.
2429
2430      DR 228 removed the restriction that the template be a member
2431      template.
2432
2433      DR 96, if accepted would add the further restriction that explicit
2434      template arguments must be provided if the template keyword is
2435      used, but, as of 2005-10-16, that DR is still in "drafting".  If
2436      this DR is accepted, then the semantic checks here can be
2437      simplified, as the entity named must in fact be a template
2438      specialization, rather than, as at present, a set of overloaded
2439      functions containing at least one template function.  */
2440   if (TREE_CODE (decl) != TEMPLATE_DECL
2441       && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2442     {
2443       if (!is_overloaded_fn (decl))
2444         permerror (input_location, "%qD is not a template", decl);
2445       else
2446         {
2447           tree fns;
2448           fns = decl;
2449           if (BASELINK_P (fns))
2450             fns = BASELINK_FUNCTIONS (fns);
2451           while (fns)
2452             {
2453               tree fn = OVL_CURRENT (fns);
2454               if (TREE_CODE (fn) == TEMPLATE_DECL
2455                   || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2456                 break;
2457               if (TREE_CODE (fn) == FUNCTION_DECL
2458                   && DECL_USE_TEMPLATE (fn)
2459                   && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2460                 break;
2461               fns = OVL_NEXT (fns);
2462             }
2463           if (!fns)
2464             permerror (input_location, "%qD is not a template", decl);
2465         }
2466     }
2467 }
2468
2469 /* This function is called by the parser to process a class member
2470    access expression of the form OBJECT.NAME.  NAME is a node used by
2471    the parser to represent a name; it is not yet a DECL.  It may,
2472    however, be a BASELINK where the BASELINK_FUNCTIONS is a
2473    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
2474    there is no reason to do the lookup twice, so the parser keeps the
2475    BASELINK.  TEMPLATE_P is true iff NAME was explicitly declared to
2476    be a template via the use of the "A::template B" syntax.  */
2477
2478 tree
2479 finish_class_member_access_expr (tree object, tree name, bool template_p,
2480                                  tsubst_flags_t complain)
2481 {
2482   tree expr;
2483   tree object_type;
2484   tree member;
2485   tree access_path = NULL_TREE;
2486   tree orig_object = object;
2487   tree orig_name = name;
2488
2489   if (object == error_mark_node || name == error_mark_node)
2490     return error_mark_node;
2491
2492   /* If OBJECT is an ObjC class instance, we must obey ObjC access rules.  */
2493   if (!objc_is_public (object, name))
2494     return error_mark_node;
2495
2496   object_type = TREE_TYPE (object);
2497
2498   if (processing_template_decl)
2499     {
2500       if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME.  */
2501           dependent_type_p (object_type)
2502           /* If NAME is just an IDENTIFIER_NODE, then the expression
2503              is dependent.  */
2504           || TREE_CODE (object) == IDENTIFIER_NODE
2505           /* If NAME is "f<args>", where either 'f' or 'args' is
2506              dependent, then the expression is dependent.  */
2507           || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2508               && dependent_template_id_p (TREE_OPERAND (name, 0),
2509                                           TREE_OPERAND (name, 1)))
2510           /* If NAME is "T::X" where "T" is dependent, then the
2511              expression is dependent.  */
2512           || (TREE_CODE (name) == SCOPE_REF
2513               && TYPE_P (TREE_OPERAND (name, 0))
2514               && dependent_type_p (TREE_OPERAND (name, 0))))
2515         return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2516       object = build_non_dependent_expr (object);
2517     }
2518
2519   /* [expr.ref]
2520
2521      The type of the first expression shall be "class object" (of a
2522      complete type).  */
2523   if (!currently_open_class (object_type)
2524       && !complete_type_or_else (object_type, object))
2525     return error_mark_node;
2526   if (!CLASS_TYPE_P (object_type))
2527     {
2528       if (complain & tf_error)
2529         error ("request for member %qD in %qE, which is of non-class type %qT",
2530                name, object, object_type);
2531       return error_mark_node;
2532     }
2533
2534   if (BASELINK_P (name))
2535     /* A member function that has already been looked up.  */
2536     member = name;
2537   else
2538     {
2539       bool is_template_id = false;
2540       tree template_args = NULL_TREE;
2541       tree scope;
2542
2543       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2544         {
2545           is_template_id = true;
2546           template_args = TREE_OPERAND (name, 1);
2547           name = TREE_OPERAND (name, 0);
2548
2549           if (TREE_CODE (name) == OVERLOAD)
2550             name = DECL_NAME (get_first_fn (name));
2551           else if (DECL_P (name))
2552             name = DECL_NAME (name);
2553         }
2554
2555       if (TREE_CODE (name) == SCOPE_REF)
2556         {
2557           /* A qualified name.  The qualifying class or namespace `S'
2558              has already been looked up; it is either a TYPE or a
2559              NAMESPACE_DECL.  */
2560           scope = TREE_OPERAND (name, 0);
2561           name = TREE_OPERAND (name, 1);
2562
2563           /* If SCOPE is a namespace, then the qualified name does not
2564              name a member of OBJECT_TYPE.  */
2565           if (TREE_CODE (scope) == NAMESPACE_DECL)
2566             {
2567               if (complain & tf_error)
2568                 error ("%<%D::%D%> is not a member of %qT",
2569                        scope, name, object_type);
2570               return error_mark_node;
2571             }
2572
2573           gcc_assert (CLASS_TYPE_P (scope));
2574           gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2575                       || TREE_CODE (name) == BIT_NOT_EXPR);
2576
2577           if (constructor_name_p (name, scope))
2578             {
2579               if (complain & tf_error)
2580                 error ("cannot call constructor %<%T::%D%> directly",
2581                        scope, name);
2582               return error_mark_node;
2583             }
2584
2585           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
2586           access_path = lookup_base (object_type, scope, ba_check, NULL);
2587           if (access_path == error_mark_node)
2588             return error_mark_node;
2589           if (!access_path)
2590             {
2591               if (complain & tf_error)
2592                 error ("%qT is not a base of %qT", scope, object_type);
2593               return error_mark_node;
2594             }
2595         }
2596       else
2597         {
2598           scope = NULL_TREE;
2599           access_path = object_type;
2600         }
2601
2602       if (TREE_CODE (name) == BIT_NOT_EXPR)
2603         member = lookup_destructor (object, scope, name);
2604       else
2605         {
2606           /* Look up the member.  */
2607           member = lookup_member (access_path, name, /*protect=*/1,
2608                                   /*want_type=*/false);
2609           if (member == NULL_TREE)
2610             {
2611               if (complain & tf_error)
2612                 error ("%qD has no member named %qE", object_type, name);
2613               return error_mark_node;
2614             }
2615           if (member == error_mark_node)
2616             return error_mark_node;
2617         }
2618
2619       if (is_template_id)
2620         {
2621           tree templ = member;
2622
2623           if (BASELINK_P (templ))
2624             templ = lookup_template_function (templ, template_args);
2625           else
2626             {
2627               if (complain & tf_error)
2628                 error ("%qD is not a member template function", name);
2629               return error_mark_node;
2630             }
2631         }
2632     }
2633
2634   if (TREE_DEPRECATED (member))
2635     warn_deprecated_use (member, NULL_TREE);
2636
2637   if (template_p)
2638     check_template_keyword (member);
2639
2640   expr = build_class_member_access_expr (object, member, access_path,
2641                                          /*preserve_reference=*/false,
2642                                          complain);
2643   if (processing_template_decl && expr != error_mark_node)
2644     {
2645       if (BASELINK_P (member))
2646         {
2647           if (TREE_CODE (orig_name) == SCOPE_REF)
2648             BASELINK_QUALIFIED_P (member) = 1;
2649           orig_name = member;
2650         }
2651       return build_min_non_dep (COMPONENT_REF, expr,
2652                                 orig_object, orig_name,
2653                                 NULL_TREE);
2654     }
2655
2656   return expr;
2657 }
2658
2659 /* Return an expression for the MEMBER_NAME field in the internal
2660    representation of PTRMEM, a pointer-to-member function.  (Each
2661    pointer-to-member function type gets its own RECORD_TYPE so it is
2662    more convenient to access the fields by name than by FIELD_DECL.)
2663    This routine converts the NAME to a FIELD_DECL and then creates the
2664    node for the complete expression.  */
2665
2666 tree
2667 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2668 {
2669   tree ptrmem_type;
2670   tree member;
2671   tree member_type;
2672
2673   /* This code is a stripped down version of
2674      build_class_member_access_expr.  It does not work to use that
2675      routine directly because it expects the object to be of class
2676      type.  */
2677   ptrmem_type = TREE_TYPE (ptrmem);
2678   gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2679   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2680                           /*want_type=*/false);
2681   member_type = cp_build_qualified_type (TREE_TYPE (member),
2682                                          cp_type_quals (ptrmem_type));
2683   return fold_build3_loc (input_location,
2684                       COMPONENT_REF, member_type,
2685                       ptrmem, member, NULL_TREE);
2686 }
2687
2688 /* Given an expression PTR for a pointer, return an expression
2689    for the value pointed to.
2690    ERRORSTRING is the name of the operator to appear in error messages.
2691
2692    This function may need to overload OPERATOR_FNNAME.
2693    Must also handle REFERENCE_TYPEs for C++.  */
2694
2695 tree
2696 build_x_indirect_ref (tree expr, ref_operator errorstring, 
2697                       tsubst_flags_t complain)
2698 {
2699   tree orig_expr = expr;
2700   tree rval;
2701
2702   if (processing_template_decl)
2703     {
2704       /* Retain the type if we know the operand is a pointer so that
2705          describable_type doesn't make auto deduction break.  */
2706       if (TREE_TYPE (expr) && POINTER_TYPE_P (TREE_TYPE (expr)))
2707         return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
2708       if (type_dependent_expression_p (expr))
2709         return build_min_nt (INDIRECT_REF, expr);
2710       expr = build_non_dependent_expr (expr);
2711     }
2712
2713   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2714                        NULL_TREE, /*overloaded_p=*/NULL, complain);
2715   if (!rval)
2716     rval = cp_build_indirect_ref (expr, errorstring, complain);
2717
2718   if (processing_template_decl && rval != error_mark_node)
2719     return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2720   else
2721     return rval;
2722 }
2723
2724 /* Helper function called from c-common.  */
2725 tree
2726 build_indirect_ref (location_t loc __attribute__ ((__unused__)),
2727                     tree ptr, ref_operator errorstring)
2728 {
2729   return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2730 }
2731
2732 tree
2733 cp_build_indirect_ref (tree ptr, ref_operator errorstring, 
2734                        tsubst_flags_t complain)
2735 {
2736   tree pointer, type;
2737
2738   if (ptr == error_mark_node)
2739     return error_mark_node;
2740
2741   if (ptr == current_class_ptr)
2742     return current_class_ref;
2743
2744   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2745              ? ptr : decay_conversion (ptr));
2746   type = TREE_TYPE (pointer);
2747
2748   if (POINTER_TYPE_P (type))
2749     {
2750       /* [expr.unary.op]
2751
2752          If the type of the expression is "pointer to T," the type
2753          of  the  result  is  "T."  */
2754       tree t = TREE_TYPE (type);
2755
2756       if (CONVERT_EXPR_P (ptr)
2757           || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2758         {
2759           /* If a warning is issued, mark it to avoid duplicates from
2760              the backend.  This only needs to be done at
2761              warn_strict_aliasing > 2.  */
2762           if (warn_strict_aliasing > 2)
2763             if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2764                                          type, TREE_OPERAND (ptr, 0)))
2765               TREE_NO_WARNING (ptr) = 1;
2766         }
2767
2768       if (VOID_TYPE_P (t))
2769         {
2770           /* A pointer to incomplete type (other than cv void) can be
2771              dereferenced [expr.unary.op]/1  */
2772           if (complain & tf_error)
2773             error ("%qT is not a pointer-to-object type", type);
2774           return error_mark_node;
2775         }
2776       else if (TREE_CODE (pointer) == ADDR_EXPR
2777                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2778         /* The POINTER was something like `&x'.  We simplify `*&x' to
2779            `x'.  */
2780         return TREE_OPERAND (pointer, 0);
2781       else
2782         {
2783           tree ref = build1 (INDIRECT_REF, t, pointer);
2784
2785           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2786              so that we get the proper error message if the result is used
2787              to assign to.  Also, &* is supposed to be a no-op.  */
2788           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2789           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2790           TREE_SIDE_EFFECTS (ref)
2791             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2792           return ref;
2793         }
2794     }
2795   else if (!(complain & tf_error))
2796     /* Don't emit any errors; we'll just return ERROR_MARK_NODE later.  */
2797     ;
2798   /* `pointer' won't be an error_mark_node if we were given a
2799      pointer to member, so it's cool to check for this here.  */
2800   else if (TYPE_PTR_TO_MEMBER_P (type))
2801     switch (errorstring)
2802       {
2803          case RO_ARRAY_INDEXING:
2804            error ("invalid use of array indexing on pointer to member");
2805            break;
2806          case RO_UNARY_STAR:
2807            error ("invalid use of unary %<*%> on pointer to member");
2808            break;
2809          case RO_IMPLICIT_CONVERSION:
2810            error ("invalid use of implicit conversion on pointer to member");
2811            break;
2812          default:
2813            gcc_unreachable ();
2814       }
2815   else if (pointer != error_mark_node)
2816     switch (errorstring)
2817       {
2818          case RO_NULL:
2819            error ("invalid type argument");
2820            break;
2821          case RO_ARRAY_INDEXING:
2822            error ("invalid type argument of array indexing");
2823            break;
2824          case RO_UNARY_STAR:
2825            error ("invalid type argument of unary %<*%>");
2826            break;
2827          case RO_IMPLICIT_CONVERSION:
2828            error ("invalid type argument of implicit conversion");
2829            break;
2830          default:
2831            gcc_unreachable ();
2832       }
2833   return error_mark_node;
2834 }
2835
2836 /* This handles expressions of the form "a[i]", which denotes
2837    an array reference.
2838
2839    This is logically equivalent in C to *(a+i), but we may do it differently.
2840    If A is a variable or a member, we generate a primitive ARRAY_REF.
2841    This avoids forcing the array out of registers, and can work on
2842    arrays that are not lvalues (for example, members of structures returned
2843    by functions).
2844
2845    If INDEX is of some user-defined type, it must be converted to
2846    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2847    will inherit the type of the array, which will be some pointer type.
2848    
2849    LOC is the location to use in building the array reference.  */
2850
2851 tree
2852 build_array_ref (location_t loc, tree array, tree idx)
2853 {
2854   tree ret;
2855
2856   if (idx == 0)
2857     {
2858       error_at (loc, "subscript missing in array reference");
2859       return error_mark_node;
2860     }
2861
2862   if (TREE_TYPE (array) == error_mark_node
2863       || TREE_TYPE (idx) == error_mark_node)
2864     return error_mark_node;
2865
2866   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2867      inside it.  */
2868   switch (TREE_CODE (array))
2869     {
2870     case COMPOUND_EXPR:
2871       {
2872         tree value = build_array_ref (loc, TREE_OPERAND (array, 1), idx);
2873         ret = build2 (COMPOUND_EXPR, TREE_TYPE (value),
2874                       TREE_OPERAND (array, 0), value);
2875         SET_EXPR_LOCATION (ret, loc);
2876         return ret;
2877       }
2878
2879     case COND_EXPR:
2880       ret = build_conditional_expr
2881               (TREE_OPERAND (array, 0),
2882                build_array_ref (loc, TREE_OPERAND (array, 1), idx),
2883                build_array_ref (loc, TREE_OPERAND (array, 2), idx),
2884                tf_warning_or_error);
2885       protected_set_expr_location (ret, loc);
2886       return ret;
2887
2888     default:
2889       break;
2890     }
2891
2892   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2893     {
2894       tree rval, type;
2895
2896       warn_array_subscript_with_type_char (idx);
2897
2898       if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2899         {
2900           error_at (loc, "array subscript is not an integer");
2901           return error_mark_node;
2902         }
2903
2904       /* Apply integral promotions *after* noticing character types.
2905          (It is unclear why we do these promotions -- the standard
2906          does not say that we should.  In fact, the natural thing would
2907          seem to be to convert IDX to ptrdiff_t; we're performing
2908          pointer arithmetic.)  */
2909       idx = perform_integral_promotions (idx);
2910
2911       /* An array that is indexed by a non-constant
2912          cannot be stored in a register; we must be able to do
2913          address arithmetic on its address.
2914          Likewise an array of elements of variable size.  */
2915       if (TREE_CODE (idx) != INTEGER_CST
2916           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2917               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2918                   != INTEGER_CST)))
2919         {
2920           if (!cxx_mark_addressable (array))
2921             return error_mark_node;
2922         }
2923
2924       /* An array that is indexed by a constant value which is not within
2925          the array bounds cannot be stored in a register either; because we
2926          would get a crash in store_bit_field/extract_bit_field when trying
2927          to access a non-existent part of the register.  */
2928       if (TREE_CODE (idx) == INTEGER_CST
2929           && TYPE_DOMAIN (TREE_TYPE (array))
2930           && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2931         {
2932           if (!cxx_mark_addressable (array))
2933             return error_mark_node;
2934         }
2935
2936       if (!lvalue_p (array))
2937         pedwarn (loc, OPT_pedantic, 
2938                  "ISO C++ forbids subscripting non-lvalue array");
2939
2940       /* Note in C++ it is valid to subscript a `register' array, since
2941          it is valid to take the address of something with that
2942          storage specification.  */
2943       if (extra_warnings)
2944         {
2945           tree foo = array;
2946           while (TREE_CODE (foo) == COMPONENT_REF)
2947             foo = TREE_OPERAND (foo, 0);
2948           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2949             warning_at (loc, OPT_Wextra,
2950                         "subscripting array declared %<register%>");
2951         }
2952
2953       type = TREE_TYPE (TREE_TYPE (array));
2954       rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2955       /* Array ref is const/volatile if the array elements are
2956          or if the array is..  */
2957       TREE_READONLY (rval)
2958         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2959       TREE_SIDE_EFFECTS (rval)
2960         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2961       TREE_THIS_VOLATILE (rval)
2962         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2963       ret = require_complete_type (fold_if_not_in_template (rval));
2964       protected_set_expr_location (ret, loc);
2965       return ret;
2966     }
2967
2968   {
2969     tree ar = default_conversion (array);
2970     tree ind = default_conversion (idx);
2971
2972     /* Put the integer in IND to simplify error checking.  */
2973     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2974       {
2975         tree temp = ar;
2976         ar = ind;
2977         ind = temp;
2978       }
2979
2980     if (ar == error_mark_node)
2981       return ar;
2982
2983     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2984       {
2985         error_at (loc, "subscripted value is neither array nor pointer");
2986         return error_mark_node;
2987       }
2988     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2989       {
2990         error_at (loc, "array subscript is not an integer");
2991         return error_mark_node;
2992       }
2993
2994     warn_array_subscript_with_type_char (idx);
2995
2996     ret = cp_build_indirect_ref (cp_build_binary_op (input_location,
2997                                                      PLUS_EXPR, ar, ind,
2998                                                      tf_warning_or_error),
2999                                  RO_ARRAY_INDEXING,
3000                                  tf_warning_or_error);
3001     protected_set_expr_location (ret, loc);
3002     return ret;
3003   }
3004 }
3005 \f
3006 /* Resolve a pointer to member function.  INSTANCE is the object
3007    instance to use, if the member points to a virtual member.
3008
3009    This used to avoid checking for virtual functions if basetype
3010    has no virtual functions, according to an earlier ANSI draft.
3011    With the final ISO C++ rules, such an optimization is
3012    incorrect: A pointer to a derived member can be static_cast
3013    to pointer-to-base-member, as long as the dynamic object
3014    later has the right member.  */
3015
3016 tree
3017 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
3018 {
3019   if (TREE_CODE (function) == OFFSET_REF)
3020     function = TREE_OPERAND (function, 1);
3021
3022   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
3023     {
3024       tree idx, delta, e1, e2, e3, vtbl, basetype;
3025       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
3026
3027       tree instance_ptr = *instance_ptrptr;
3028       tree instance_save_expr = 0;
3029       if (instance_ptr == error_mark_node)
3030         {
3031           if (TREE_CODE (function) == PTRMEM_CST)
3032             {
3033               /* Extracting the function address from a pmf is only
3034                  allowed with -Wno-pmf-conversions. It only works for
3035                  pmf constants.  */
3036               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
3037               e1 = convert (fntype, e1);
3038               return e1;
3039             }
3040           else
3041             {
3042               error ("object missing in use of %qE", function);
3043               return error_mark_node;
3044             }
3045         }
3046
3047       if (TREE_SIDE_EFFECTS (instance_ptr))
3048         instance_ptr = instance_save_expr = save_expr (instance_ptr);
3049
3050       if (TREE_SIDE_EFFECTS (function))
3051         function = save_expr (function);
3052
3053       /* Start by extracting all the information from the PMF itself.  */
3054       e3 = pfn_from_ptrmemfunc (function);
3055       delta = delta_from_ptrmemfunc (function);
3056       idx = build1 (NOP_EXPR, vtable_index_type, e3);
3057       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
3058         {
3059         case ptrmemfunc_vbit_in_pfn:
3060           e1 = cp_build_binary_op (input_location,
3061                                    BIT_AND_EXPR, idx, integer_one_node,
3062                                    tf_warning_or_error);
3063           idx = cp_build_binary_op (input_location,
3064                                     MINUS_EXPR, idx, integer_one_node,
3065                                     tf_warning_or_error);
3066           break;
3067
3068         case ptrmemfunc_vbit_in_delta:
3069           e1 = cp_build_binary_op (input_location,
3070                                    BIT_AND_EXPR, delta, integer_one_node,
3071                                    tf_warning_or_error);
3072           delta = cp_build_binary_op (input_location,
3073                                       RSHIFT_EXPR, delta, integer_one_node,
3074                                       tf_warning_or_error);
3075           break;
3076
3077         default:
3078           gcc_unreachable ();
3079         }
3080
3081       /* Convert down to the right base before using the instance.  A
3082          special case is that in a pointer to member of class C, C may
3083          be incomplete.  In that case, the function will of course be
3084          a member of C, and no conversion is required.  In fact,
3085          lookup_base will fail in that case, because incomplete
3086          classes do not have BINFOs.  */
3087       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
3088       if (!same_type_ignoring_top_level_qualifiers_p
3089           (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
3090         {
3091           basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
3092                                   basetype, ba_check, NULL);
3093           instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
3094                                           1);
3095           if (instance_ptr == error_mark_node)
3096             return error_mark_node;
3097         }
3098       /* ...and then the delta in the PMF.  */
3099       instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
3100                              instance_ptr, fold_convert (sizetype, delta));
3101
3102       /* Hand back the adjusted 'this' argument to our caller.  */
3103       *instance_ptrptr = instance_ptr;
3104
3105       /* Next extract the vtable pointer from the object.  */
3106       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
3107                      instance_ptr);
3108       vtbl = cp_build_indirect_ref (vtbl, RO_NULL, tf_warning_or_error);
3109       /* If the object is not dynamic the access invokes undefined
3110          behavior.  As it is not executed in this case silence the
3111          spurious warnings it may provoke.  */
3112       TREE_NO_WARNING (vtbl) = 1;
3113
3114       /* Finally, extract the function pointer from the vtable.  */
3115       e2 = fold_build2_loc (input_location,
3116                         POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
3117                         fold_convert (sizetype, idx));
3118       e2 = cp_build_indirect_ref (e2, RO_NULL, tf_warning_or_error);
3119       TREE_CONSTANT (e2) = 1;
3120
3121       /* When using function descriptors, the address of the
3122          vtable entry is treated as a function pointer.  */
3123       if (TARGET_VTABLE_USES_DESCRIPTORS)
3124         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
3125                      cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
3126                                      tf_warning_or_error));
3127
3128       e2 = fold_convert (TREE_TYPE (e3), e2);
3129       e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
3130
3131       /* Make sure this doesn't get evaluated first inside one of the
3132          branches of the COND_EXPR.  */
3133       if (instance_save_expr)
3134         e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
3135                      instance_save_expr, e1);
3136
3137       function = e1;
3138     }
3139   return function;
3140 }
3141
3142 /* Used by the C-common bits.  */
3143 tree
3144 build_function_call (location_t loc ATTRIBUTE_UNUSED, 
3145                      tree function, tree params)
3146 {
3147   return cp_build_function_call (function, params, tf_warning_or_error);
3148 }
3149
3150 /* Used by the C-common bits.  */
3151 tree
3152 build_function_call_vec (location_t loc ATTRIBUTE_UNUSED,
3153                          tree function, VEC(tree,gc) *params,
3154                          VEC(tree,gc) *origtypes ATTRIBUTE_UNUSED)
3155 {
3156   VEC(tree,gc) *orig_params = params;
3157   tree ret = cp_build_function_call_vec (function, &params,
3158                                          tf_warning_or_error);
3159
3160   /* cp_build_function_call_vec can reallocate PARAMS by adding
3161      default arguments.  That should never happen here.  Verify
3162      that.  */
3163   gcc_assert (params == orig_params);
3164
3165   return ret;
3166 }
3167
3168 /* Build a function call using a tree list of arguments.  */
3169
3170 tree
3171 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
3172 {
3173   VEC(tree,gc) *vec;
3174   tree ret;
3175
3176   vec = make_tree_vector ();
3177   for (; params != NULL_TREE; params = TREE_CHAIN (params))
3178     VEC_safe_push (tree, gc, vec, TREE_VALUE (params));
3179   ret = cp_build_function_call_vec (function, &vec, complain);
3180   release_tree_vector (vec);
3181   return ret;
3182 }
3183
3184 /* Build a function call using a vector of arguments.  PARAMS may be
3185    NULL if there are no parameters.  This changes the contents of
3186    PARAMS.  */
3187
3188 tree
3189 cp_build_function_call_vec (tree function, VEC(tree,gc) **params,
3190                             tsubst_flags_t complain)
3191 {
3192   tree fntype, fndecl;
3193   int is_method;
3194   tree original = function;
3195   int nargs;
3196   tree *argarray;
3197   tree parm_types;
3198   VEC(tree,gc) *allocated = NULL;
3199   tree ret;
3200
3201   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3202      expressions, like those used for ObjC messenger dispatches.  */
3203   if (params != NULL && !VEC_empty (tree, *params))
3204     function = objc_rewrite_function_call (function,
3205                                            VEC_index (tree, *params, 0));
3206
3207   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3208      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
3209   if (TREE_CODE (function) == NOP_EXPR
3210       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
3211     function = TREE_OPERAND (function, 0);
3212
3213   if (TREE_CODE (function) == FUNCTION_DECL)
3214     {
3215       mark_used (function);
3216       fndecl = function;
3217
3218       /* Convert anything with function type to a pointer-to-function.  */
3219       if (DECL_MAIN_P (function) && (complain & tf_error))
3220         pedwarn (input_location, OPT_pedantic, 
3221                  "ISO C++ forbids calling %<::main%> from within program");
3222
3223       function = build_addr_func (function);
3224     }
3225   else
3226     {
3227       fndecl = NULL_TREE;
3228
3229       function = build_addr_func (function);
3230     }
3231
3232   if (function == error_mark_node)
3233     return error_mark_node;
3234
3235   fntype = TREE_TYPE (function);
3236
3237   if (TYPE_PTRMEMFUNC_P (fntype))
3238     {
3239       if (complain & tf_error)
3240         error ("must use %<.*%> or %<->*%> to call pointer-to-member "
3241                "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
3242                original, original);
3243       return error_mark_node;
3244     }
3245
3246   is_method = (TREE_CODE (fntype) == POINTER_TYPE
3247                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
3248
3249   if (!((TREE_CODE (fntype) == POINTER_TYPE
3250          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
3251         || is_method
3252         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
3253     {
3254       if (complain & tf_error)
3255         error ("%qE cannot be used as a function", original);
3256       return error_mark_node;
3257     }
3258
3259   /* fntype now gets the type of function pointed to.  */
3260   fntype = TREE_TYPE (fntype);
3261   parm_types = TYPE_ARG_TYPES (fntype);
3262
3263   if (params == NULL)
3264     {
3265       allocated = make_tree_vector ();
3266       params = &allocated;
3267     }
3268
3269   nargs = convert_arguments (parm_types, params, fndecl, LOOKUP_NORMAL,
3270                              complain);
3271   if (nargs < 0)
3272     return error_mark_node;
3273
3274   argarray = VEC_address (tree, *params);
3275
3276   /* Check for errors in format strings and inappropriately
3277      null parameters.  */
3278   check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
3279                             parm_types);
3280
3281   ret = build_cxx_call (function, nargs, argarray);
3282
3283   if (allocated != NULL)
3284     release_tree_vector (allocated);
3285
3286   return ret;
3287 }
3288 \f
3289 /* Convert the actual parameter expressions in the list VALUES to the
3290    types in the list TYPELIST.  The converted expressions are stored
3291    back in the VALUES vector.
3292    If parmdecls is exhausted, or when an element has NULL as its type,
3293    perform the default conversions.
3294
3295    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
3296
3297    This is also where warnings about wrong number of args are generated.
3298
3299    Returns the actual number of arguments processed (which might be less
3300    than the length of the vector), or -1 on error.
3301
3302    In C++, unspecified trailing parameters can be filled in with their
3303    default arguments, if such were specified.  Do so here.  */
3304
3305 static int
3306 convert_arguments (tree typelist, VEC(tree,gc) **values, tree fndecl,
3307                    int flags, tsubst_flags_t complain)
3308 {
3309   tree typetail;
3310   const char *called_thing = 0;
3311   unsigned int i;
3312
3313   /* Argument passing is always copy-initialization.  */
3314   flags |= LOOKUP_ONLYCONVERTING;
3315
3316   if (fndecl)
3317     {
3318       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
3319         {
3320           if (DECL_NAME (fndecl) == NULL_TREE
3321               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
3322             called_thing = "constructor";
3323           else
3324             called_thing = "member function";
3325         }
3326       else
3327         called_thing = "function";
3328     }
3329
3330   for (i = 0, typetail = typelist;
3331        i < VEC_length (tree, *values);
3332        i++)
3333     {
3334       tree type = typetail ? TREE_VALUE (typetail) : 0;
3335       tree val = VEC_index (tree, *values, i);
3336
3337       if (val == error_mark_node || type == error_mark_node)
3338         return -1;
3339
3340       if (type == void_type_node)
3341         {
3342           if (complain & tf_error)
3343             {
3344               if (fndecl)
3345                 {
3346                   error_at (input_location, "too many arguments to %s %q#D", 
3347                             called_thing, fndecl);
3348                   inform (DECL_SOURCE_LOCATION (fndecl),
3349                           "declared here");
3350                 }
3351               else
3352                 error ("too many arguments to function");
3353               return i;
3354             }
3355           else
3356             return -1;
3357         }
3358
3359       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3360          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
3361       if (TREE_CODE (val) == NOP_EXPR
3362           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3363           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3364         val = TREE_OPERAND (val, 0);
3365
3366       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3367         {
3368           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3369               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3370               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3371             val = decay_conversion (val);
3372         }
3373
3374       if (val == error_mark_node)
3375         return -1;
3376
3377       if (type != 0)
3378         {
3379           /* Formal parm type is specified by a function prototype.  */
3380           tree parmval;
3381
3382           if (!COMPLETE_TYPE_P (complete_type (type)))
3383             {
3384               if (complain & tf_error)
3385                 {
3386                   if (fndecl)
3387                     error ("parameter %P of %qD has incomplete type %qT",
3388                            i, fndecl, type);
3389                   else
3390                     error ("parameter %P has incomplete type %qT", i, type);
3391                 }
3392               parmval = error_mark_node;
3393             }
3394           else
3395             {
3396               parmval = convert_for_initialization
3397                 (NULL_TREE, type, val, flags,
3398                  "argument passing", fndecl, i, complain);
3399               parmval = convert_for_arg_passing (type, parmval);
3400             }
3401
3402           if (parmval == error_mark_node)
3403             return -1;
3404
3405           VEC_replace (tree, *values, i, parmval);
3406         }
3407       else
3408         {
3409           if (fndecl && DECL_BUILT_IN (fndecl)
3410               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3411             /* Don't do ellipsis conversion for __built_in_constant_p
3412                as this will result in spurious errors for non-trivial
3413                types.  */
3414             val = require_complete_type (val);
3415           else
3416             val = convert_arg_to_ellipsis (val);
3417
3418           VEC_replace (tree, *values, i, val);
3419         }
3420
3421       if (typetail)
3422         typetail = TREE_CHAIN (typetail);
3423     }
3424
3425   if (typetail != 0 && typetail != void_list_node)
3426     {
3427       /* See if there are default arguments that can be used.  Because
3428          we hold default arguments in the FUNCTION_TYPE (which is so
3429          wrong), we can see default parameters here from deduced
3430          contexts (and via typeof) for indirect function calls.
3431          Fortunately we know whether we have a function decl to
3432          provide default arguments in a language conformant
3433          manner.  */
3434       if (fndecl && TREE_PURPOSE (typetail)
3435           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3436         {
3437           for (; typetail != void_list_node; ++i)
3438             {
3439               tree parmval
3440                 = convert_default_arg (TREE_VALUE (typetail),
3441                                        TREE_PURPOSE (typetail),
3442                                        fndecl, i);
3443
3444               if (parmval == error_mark_node)
3445                 return -1;
3446
3447               VEC_safe_push (tree, gc, *values, parmval);
3448               typetail = TREE_CHAIN (typetail);
3449               /* ends with `...'.  */
3450               if (typetail == NULL_TREE)
3451                 break;
3452             }
3453         }
3454       else
3455         {
3456           if (complain & tf_error)
3457             {
3458               if (fndecl)
3459                 {
3460                   error_at (input_location, "too few arguments to %s %q#D", 
3461                             called_thing, fndecl);
3462                   inform (DECL_SOURCE_LOCATION (fndecl),
3463                           "declared here");
3464                 }
3465               else
3466                 error ("too few arguments to function");