OSDN Git Service

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