OSDN Git Service

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