Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / 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 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
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    There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
30    and to process initializations in declarations (since they work
31    like a strange sort of assignment).  */
32
33 #include "config.h"
34 #include "system.h"
35 #include "coretypes.h"
36 #include "tm.h"
37 #include "tree.h"
38 #include "rtl.h"
39 #include "expr.h"
40 #include "cp-tree.h"
41 #include "tm_p.h"
42 #include "flags.h"
43 #include "output.h"
44 #include "toplev.h"
45 #include "diagnostic.h"
46 #include "target.h"
47 #include "convert.h"
48
49 static tree convert_for_assignment (tree, tree, const char *, tree, int);
50 static tree cp_pointer_int_sum (enum tree_code, tree, tree);
51 static tree rationalize_conditional_expr (enum tree_code, tree);
52 static int comp_ptr_ttypes_real (tree, tree, int);
53 static int comp_ptr_ttypes_const (tree, tree);
54 static bool comp_except_types (tree, tree, bool);
55 static bool comp_array_types (tree, tree, bool);
56 static tree common_base_type (tree, tree);
57 static tree pointer_diff (tree, tree, tree);
58 static tree get_delta_difference (tree, tree, int);
59 static void casts_away_constness_r (tree *, tree *);
60 static bool casts_away_constness (tree, tree);
61 static void maybe_warn_about_returning_address_of_local (tree);
62 static tree lookup_destructor (tree, tree, tree);
63
64 /* Return the target type of TYPE, which means return T for:
65    T*, T&, T[], T (...), and otherwise, just T.  */
66
67 tree
68 target_type (tree type)
69 {
70   type = non_reference (type);
71   while (TREE_CODE (type) == POINTER_TYPE
72          || TREE_CODE (type) == ARRAY_TYPE
73          || TREE_CODE (type) == FUNCTION_TYPE
74          || TREE_CODE (type) == METHOD_TYPE
75          || TYPE_PTRMEM_P (type))
76     type = TREE_TYPE (type);
77   return type;
78 }
79
80 /* Do `exp = require_complete_type (exp);' to make sure exp
81    does not have an incomplete type.  (That includes void types.)
82    Returns the error_mark_node if the VALUE does not have
83    complete type when this function returns.  */
84
85 tree
86 require_complete_type (tree value)
87 {
88   tree type;
89
90   if (processing_template_decl || value == error_mark_node)
91     return value;
92
93   if (TREE_CODE (value) == OVERLOAD)
94     type = unknown_type_node;
95   else
96     type = TREE_TYPE (value);
97
98   if (type == error_mark_node)
99     return error_mark_node;
100
101   /* First, detect a valid value with a complete type.  */
102   if (COMPLETE_TYPE_P (type))
103     return value;
104
105   if (complete_type_or_else (type, value))
106     return value;
107   else
108     return error_mark_node;
109 }
110
111 /* Try to complete TYPE, if it is incomplete.  For example, if TYPE is
112    a template instantiation, do the instantiation.  Returns TYPE,
113    whether or not it could be completed, unless something goes
114    horribly wrong, in which case the error_mark_node is returned.  */
115
116 tree
117 complete_type (tree type)
118 {
119   if (type == NULL_TREE)
120     /* Rather than crash, we return something sure to cause an error
121        at some point.  */
122     return error_mark_node;
123
124   if (type == error_mark_node || COMPLETE_TYPE_P (type))
125     ;
126   else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
127     {
128       tree t = complete_type (TREE_TYPE (type));
129       if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
130         layout_type (type);
131       TYPE_NEEDS_CONSTRUCTING (type)
132         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
133       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
134         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
135     }
136   else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
137     instantiate_class_template (TYPE_MAIN_VARIANT (type));
138
139   return type;
140 }
141
142 /* Like complete_type, but issue an error if the TYPE cannot be completed.
143    VALUE is used for informative diagnostics.  DIAG_TYPE indicates the type
144    of diagnostic: 0 for an error, 1 for a warning, 2 for a pedwarn.
145    Returns NULL_TREE if the type cannot be made complete.  */
146
147 tree
148 complete_type_or_diagnostic (tree type, tree value, int diag_type)
149 {
150   type = complete_type (type);
151   if (type == error_mark_node)
152     /* We already issued an error.  */
153     return NULL_TREE;
154   else if (!COMPLETE_TYPE_P (type))
155     {
156       cxx_incomplete_type_diagnostic (value, type, diag_type);
157       return NULL_TREE;
158     }
159   else
160     return type;
161 }
162
163 /* Return truthvalue of whether type of EXP is instantiated.  */
164
165 int
166 type_unknown_p (tree exp)
167 {
168   return (TREE_CODE (exp) == TREE_LIST
169           || TREE_TYPE (exp) == unknown_type_node);
170 }
171
172 \f
173 /* Return the common type of two parameter lists.
174    We assume that comptypes has already been done and returned 1;
175    if that isn't so, this may crash.
176
177    As an optimization, free the space we allocate if the parameter
178    lists are already common.  */
179
180 tree
181 commonparms (tree p1, tree p2)
182 {
183   tree oldargs = p1, newargs, n;
184   int i, len;
185   int any_change = 0;
186
187   len = list_length (p1);
188   newargs = tree_last (p1);
189
190   if (newargs == void_list_node)
191     i = 1;
192   else
193     {
194       i = 0;
195       newargs = 0;
196     }
197
198   for (; i < len; i++)
199     newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
200
201   n = newargs;
202
203   for (i = 0; p1;
204        p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
205     {
206       if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
207         {
208           TREE_PURPOSE (n) = TREE_PURPOSE (p1);
209           any_change = 1;
210         }
211       else if (! TREE_PURPOSE (p1))
212         {
213           if (TREE_PURPOSE (p2))
214             {
215               TREE_PURPOSE (n) = TREE_PURPOSE (p2);
216               any_change = 1;
217             }
218         }
219       else
220         {
221           if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
222             any_change = 1;
223           TREE_PURPOSE (n) = TREE_PURPOSE (p2);
224         }
225       if (TREE_VALUE (p1) != TREE_VALUE (p2))
226         {
227           any_change = 1;
228           TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
229         }
230       else
231         TREE_VALUE (n) = TREE_VALUE (p1);
232     }
233   if (! any_change)
234     return oldargs;
235
236   return newargs;
237 }
238
239 /* Given a type, perhaps copied for a typedef,
240    find the "original" version of it.  */
241 tree
242 original_type (tree t)
243 {
244   while (TYPE_NAME (t) != NULL_TREE)
245     {
246       tree x = TYPE_NAME (t);
247       if (TREE_CODE (x) != TYPE_DECL)
248         break;
249       x = DECL_ORIGINAL_TYPE (x);
250       if (x == NULL_TREE)
251         break;
252       t = x;
253     }
254   return t;
255 }
256
257 /* T1 and T2 are arithmetic or enumeration types.  Return the type
258    that will result from the "usual arithmetic conversions" on T1 and
259    T2 as described in [expr].  */
260
261 tree
262 type_after_usual_arithmetic_conversions (tree t1, tree t2)
263 {
264   enum tree_code code1 = TREE_CODE (t1);
265   enum tree_code code2 = TREE_CODE (t2);
266   tree attributes;
267
268   /* FIXME: Attributes.  */
269   my_friendly_assert (ARITHMETIC_TYPE_P (t1) 
270                       || TREE_CODE (t1) == COMPLEX_TYPE
271                       || TREE_CODE (t1) == VECTOR_TYPE
272                       || TREE_CODE (t1) == ENUMERAL_TYPE,
273                       19990725);
274   my_friendly_assert (ARITHMETIC_TYPE_P (t2) 
275                       || TREE_CODE (t2) == COMPLEX_TYPE
276                       || TREE_CODE (t2) == VECTOR_TYPE
277                       || TREE_CODE (t2) == ENUMERAL_TYPE,
278                       19990725);
279
280   /* In what follows, we slightly generalize the rules given in [expr] so
281      as to deal with `long long' and `complex'.  First, merge the
282      attributes.  */
283   attributes = (*targetm.merge_type_attributes) (t1, t2);
284
285   /* If one type is complex, form the common type of the non-complex
286      components, then make that complex.  Use T1 or T2 if it is the
287      required type.  */
288   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
289     {
290       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
291       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
292       tree subtype
293         = type_after_usual_arithmetic_conversions (subtype1, subtype2);
294
295       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
296         return build_type_attribute_variant (t1, attributes);
297       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
298         return build_type_attribute_variant (t2, attributes);
299       else
300         return build_type_attribute_variant (build_complex_type (subtype),
301                                              attributes);
302     }
303
304   if (code1 == VECTOR_TYPE)
305     {
306       /* When we get here we should have two vectors of the same size.
307          Just prefer the unsigned one if present.  */
308       if (TREE_UNSIGNED (t1))
309         return build_type_attribute_variant (t1, attributes);
310       else
311         return build_type_attribute_variant (t2, attributes);
312     }
313
314   /* If only one is real, use it as the result.  */
315   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
316     return build_type_attribute_variant (t1, attributes);
317   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
318     return build_type_attribute_variant (t2, attributes);
319
320   /* Perform the integral promotions.  */
321   if (code1 != REAL_TYPE)
322     {
323       t1 = type_promotes_to (t1);
324       t2 = type_promotes_to (t2);
325     }
326
327   /* Both real or both integers; use the one with greater precision.  */
328   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
329     return build_type_attribute_variant (t1, attributes);
330   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
331     return build_type_attribute_variant (t2, attributes);
332
333   /* The types are the same; no need to do anything fancy.  */
334   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
335     return build_type_attribute_variant (t1, attributes);
336
337   if (code1 != REAL_TYPE)
338     {
339       /* If one is a sizetype, use it so size_binop doesn't blow up.  */
340       if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
341         return build_type_attribute_variant (t1, attributes);
342       if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
343         return build_type_attribute_variant (t2, attributes);
344
345       /* If one is unsigned long long, then convert the other to unsigned
346          long long.  */
347       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
348           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
349         return build_type_attribute_variant (long_long_unsigned_type_node,
350                                              attributes);
351       /* If one is a long long, and the other is an unsigned long, and
352          long long can represent all the values of an unsigned long, then
353          convert to a long long.  Otherwise, convert to an unsigned long
354          long.  Otherwise, if either operand is long long, convert the
355          other to long long.
356          
357          Since we're here, we know the TYPE_PRECISION is the same;
358          therefore converting to long long cannot represent all the values
359          of an unsigned long, so we choose unsigned long long in that
360          case.  */
361       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
362           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
363         {
364           tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
365                     ? long_long_unsigned_type_node 
366                     : long_long_integer_type_node);
367           return build_type_attribute_variant (t, attributes);
368         }
369       
370       /* Go through the same procedure, but for longs.  */
371       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
372           || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
373         return build_type_attribute_variant (long_unsigned_type_node,
374                                              attributes);
375       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
376           || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
377         {
378           tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
379                     ? long_unsigned_type_node : long_integer_type_node);
380           return build_type_attribute_variant (t, attributes);
381         }
382       /* Otherwise prefer the unsigned one.  */
383       if (TREE_UNSIGNED (t1))
384         return build_type_attribute_variant (t1, attributes);
385       else
386         return build_type_attribute_variant (t2, attributes);
387     }
388   else
389     {
390       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
391           || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
392         return build_type_attribute_variant (long_double_type_node,
393                                              attributes);
394       if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
395           || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
396         return build_type_attribute_variant (double_type_node,
397                                              attributes);
398       if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
399           || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
400         return build_type_attribute_variant (float_type_node,
401                                              attributes);
402       
403       /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
404          the standard C++ floating-point types.  Logic earlier in this
405          function has already eliminated the possibility that
406          TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
407          compelling reason to choose one or the other.  */
408       return build_type_attribute_variant (t1, attributes);
409     }
410 }
411
412 /* Subroutine of composite_pointer_type to implement the recursive
413    case.  See that function for documentation fo the parameters.  */
414
415 static tree
416 composite_pointer_type_r (tree t1, tree t2, const char* location)
417 {
418   tree pointee1;
419   tree pointee2;
420   tree result_type;
421   tree attributes;
422
423   /* Determine the types pointed to by T1 and T2.  */
424   if (TREE_CODE (t1) == POINTER_TYPE)
425     {
426       pointee1 = TREE_TYPE (t1);
427       pointee2 = TREE_TYPE (t2);
428     }
429   else
430     {
431       pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
432       pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
433     }
434
435   /* [expr.rel]
436
437      Otherwise, the composite pointer type is a pointer type
438      similar (_conv.qual_) to the type of one of the operands,
439      with a cv-qualification signature (_conv.qual_) that is the
440      union of the cv-qualification signatures of the operand
441      types.  */
442   if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2))
443     result_type = pointee1;
444   else if ((TREE_CODE (pointee1) == POINTER_TYPE
445             && TREE_CODE (pointee2) == POINTER_TYPE)
446            || (TYPE_PTR_TO_MEMBER_P (pointee1)
447                && TYPE_PTR_TO_MEMBER_P (pointee2)))
448     result_type = composite_pointer_type_r (pointee1, pointee2, location);
449   else
450     {
451       pedwarn ("%s between distinct pointer types `%T' and `%T' "
452                "lacks a cast",
453                location, t1, t2);
454       result_type = void_type_node;
455     }
456   result_type = cp_build_qualified_type (result_type,
457                                          (cp_type_quals (pointee1)
458                                           | cp_type_quals (pointee2)));
459   /* If the original types were pointers to members, so is the
460      result.  */
461   if (TYPE_PTR_TO_MEMBER_P (t1))
462     {
463       if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
464                         TYPE_PTRMEM_CLASS_TYPE (t2)))
465         pedwarn ("%s between distinct pointer types `%T' and `%T' "
466                  "lacks a cast",
467                  location, t1, t2);
468       result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
469                                        result_type);
470     }
471   else
472     result_type = build_pointer_type (result_type);
473
474   /* Merge the attributes.  */
475   attributes = (*targetm.merge_type_attributes) (t1, t2);
476   return build_type_attribute_variant (result_type, attributes);
477 }
478
479 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
480    ARG1 and ARG2 are the values with those types.  The LOCATION is a
481    string describing the current location, in case an error occurs. 
482
483    This routine also implements the computation of a common type for
484    pointers-to-members as per [expr.eq].  */
485
486 tree 
487 composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
488                         const char* location)
489 {
490   tree class1;
491   tree class2;
492
493   /* [expr.rel]
494
495      If one operand is a null pointer constant, the composite pointer
496      type is the type of the other operand.  */
497   if (null_ptr_cst_p (arg1))
498     return t2;
499   if (null_ptr_cst_p (arg2))
500     return t1;
501  
502   /* We have:
503
504        [expr.rel]
505
506        If one of the operands has type "pointer to cv1 void*", then
507        the other has type "pointer to cv2T", and the composite pointer
508        type is "pointer to cv12 void", where cv12 is the union of cv1
509        and cv2.
510
511     If either type is a pointer to void, make sure it is T1.  */
512   if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2)))
513     {
514       tree t;
515       t = t1;
516       t1 = t2;
517       t2 = t;
518     }
519
520   /* Now, if T1 is a pointer to void, merge the qualifiers.  */
521   if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1)))
522     {
523       tree attributes;
524       tree result_type;
525
526       if (pedantic && TYPE_PTRFN_P (t2))
527         pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location);
528       result_type 
529         = cp_build_qualified_type (void_type_node,
530                                    (cp_type_quals (TREE_TYPE (t1))
531                                     | cp_type_quals (TREE_TYPE (t2))));
532       result_type = build_pointer_type (result_type);
533       /* Merge the attributes.  */
534       attributes = (*targetm.merge_type_attributes) (t1, t2);
535       return build_type_attribute_variant (result_type, attributes);
536     }
537
538   /* [expr.eq] permits the application of a pointer conversion to
539      bring the pointers to a common type.  */
540   if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE
541       && CLASS_TYPE_P (TREE_TYPE (t1))
542       && CLASS_TYPE_P (TREE_TYPE (t2))
543       && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1),
544                                                      TREE_TYPE (t2)))
545     {
546       class1 = TREE_TYPE (t1);
547       class2 = TREE_TYPE (t2);
548
549       if (DERIVED_FROM_P (class1, class2))
550         t2 = (build_pointer_type 
551               (cp_build_qualified_type (class1, TYPE_QUALS (class2))));
552       else if (DERIVED_FROM_P (class2, class1))
553         t1 = (build_pointer_type 
554               (cp_build_qualified_type (class2, TYPE_QUALS (class1))));
555       else
556         {
557           error ("%s between distinct pointer types `%T' and `%T' "
558                  "lacks a cast", location, t1, t2);
559           return error_mark_node;
560         }
561     }
562   /* [expr.eq] permits the application of a pointer-to-member
563      conversion to change the class type of one of the types.  */
564   else if (TYPE_PTR_TO_MEMBER_P (t1)
565            && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1),
566                             TYPE_PTRMEM_CLASS_TYPE (t2)))
567     {
568       class1 = TYPE_PTRMEM_CLASS_TYPE (t1);
569       class2 = TYPE_PTRMEM_CLASS_TYPE (t2);
570
571       if (DERIVED_FROM_P (class1, class2))
572         t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1));
573       else if (DERIVED_FROM_P (class2, class1))
574         t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2));
575       else
576         {
577           error ("%s between distinct pointer-to-member types `%T' and `%T' "
578                  "lacks a cast", location, t1, t2);
579           return error_mark_node;
580         }
581     }
582
583   return composite_pointer_type_r (t1, t2, location);
584 }
585
586 /* Return the merged type of two types.
587    We assume that comptypes has already been done and returned 1;
588    if that isn't so, this may crash.
589
590    This just combines attributes and default arguments; any other
591    differences would cause the two types to compare unalike.  */
592
593 tree
594 merge_types (tree t1, tree t2)
595 {
596   enum tree_code code1;
597   enum tree_code code2;
598   tree attributes;
599
600   /* Save time if the two types are the same.  */
601   if (t1 == t2)
602     return t1;
603   if (original_type (t1) == original_type (t2))
604     return t1;
605
606   /* If one type is nonsense, use the other.  */
607   if (t1 == error_mark_node)
608     return t2;
609   if (t2 == error_mark_node)
610     return t1;
611
612   /* Merge the attributes.  */
613   attributes = (*targetm.merge_type_attributes) (t1, t2);
614
615   if (TYPE_PTRMEMFUNC_P (t1))
616     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
617   if (TYPE_PTRMEMFUNC_P (t2))
618     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
619
620   code1 = TREE_CODE (t1);
621   code2 = TREE_CODE (t2);
622
623   switch (code1)
624     {
625     case POINTER_TYPE:
626     case REFERENCE_TYPE:
627       /* For two pointers, do this recursively on the target type.  */
628       {
629         tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
630         int quals = cp_type_quals (t1);
631
632         if (code1 == POINTER_TYPE)
633           t1 = build_pointer_type (target);
634         else
635           t1 = build_reference_type (target);
636         t1 = build_type_attribute_variant (t1, attributes);
637         t1 = cp_build_qualified_type (t1, quals);
638
639         if (TREE_CODE (target) == METHOD_TYPE)
640           t1 = build_ptrmemfunc_type (t1);
641
642         return t1;
643       }
644
645     case OFFSET_TYPE:
646       {
647         int quals;
648         tree pointee;
649         quals = cp_type_quals (t1);
650         pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1),
651                                TYPE_PTRMEM_POINTED_TO_TYPE (t2));
652         t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1),
653                                 pointee);
654         t1 = cp_build_qualified_type (t1, quals);
655         break;
656       }
657
658     case ARRAY_TYPE:
659       {
660         tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
661         /* Save space: see if the result is identical to one of the args.  */
662         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
663           return build_type_attribute_variant (t1, attributes);
664         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
665           return build_type_attribute_variant (t2, attributes);
666         /* Merge the element types, and have a size if either arg has one.  */
667         t1 = build_cplus_array_type
668           (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
669         break;
670       }
671
672     case FUNCTION_TYPE:
673       /* Function types: prefer the one that specified arg types.
674          If both do, merge the arg types.  Also merge the return types.  */
675       {
676         tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
677         tree p1 = TYPE_ARG_TYPES (t1);
678         tree p2 = TYPE_ARG_TYPES (t2);
679         tree rval, raises;
680
681         /* Save space: see if the result is identical to one of the args.  */
682         if (valtype == TREE_TYPE (t1) && ! p2)
683           return cp_build_type_attribute_variant (t1, attributes);
684         if (valtype == TREE_TYPE (t2) && ! p1)
685           return cp_build_type_attribute_variant (t2, attributes);
686
687         /* Simple way if one arg fails to specify argument types.  */
688         if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
689           {
690             rval = build_function_type (valtype, p2);
691             if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
692               rval = build_exception_variant (rval, raises);
693             return cp_build_type_attribute_variant (rval, attributes);
694           }
695         raises = TYPE_RAISES_EXCEPTIONS (t1);
696         if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
697           {
698             rval = build_function_type (valtype, p1);
699             if (raises)
700               rval = build_exception_variant (rval, raises);
701             return cp_build_type_attribute_variant (rval, attributes);
702           }
703
704         rval = build_function_type (valtype, commonparms (p1, p2));
705         t1 = build_exception_variant (rval, raises);
706         break;
707       }
708
709     case METHOD_TYPE:
710       {
711         /* Get this value the long way, since TYPE_METHOD_BASETYPE
712            is just the main variant of this.  */
713         tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
714         tree raises = TYPE_RAISES_EXCEPTIONS (t1);
715         tree t3;
716
717         /* If this was a member function type, get back to the
718            original type of type member function (i.e., without
719            the class instance variable up front.  */
720         t1 = build_function_type (TREE_TYPE (t1),
721                                   TREE_CHAIN (TYPE_ARG_TYPES (t1)));
722         t2 = build_function_type (TREE_TYPE (t2),
723                                   TREE_CHAIN (TYPE_ARG_TYPES (t2)));
724         t3 = merge_types (t1, t2);
725         t3 = build_method_type_directly (basetype, TREE_TYPE (t3),
726                                          TYPE_ARG_TYPES (t3));
727         t1 = build_exception_variant (t3, raises);
728         break;
729       }
730
731     case TYPENAME_TYPE:
732       /* There is no need to merge attributes into a TYPENAME_TYPE.
733          When the type is instantiated it will have whatever
734          attributes result from the instantiation.  */
735       return t1;
736
737     default:;
738     }
739   return cp_build_type_attribute_variant (t1, attributes);
740 }
741
742 /* Return the common type of two types.
743    We assume that comptypes has already been done and returned 1;
744    if that isn't so, this may crash.
745
746    This is the type for the result of most arithmetic operations
747    if the operands have the given two types.  */
748
749 tree
750 common_type (tree t1, tree t2)
751 {
752   enum tree_code code1;
753   enum tree_code code2;
754
755   /* If one type is nonsense, bail.  */
756   if (t1 == error_mark_node || t2 == error_mark_node)
757     return error_mark_node;
758
759   code1 = TREE_CODE (t1);
760   code2 = TREE_CODE (t2);
761
762   if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
763        || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
764       && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
765           || code2 == COMPLEX_TYPE || code2 == VECTOR_TYPE))
766     return type_after_usual_arithmetic_conversions (t1, t2);
767
768   else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
769            || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
770            || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
771     return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
772                                    "conversion");
773   else
774     abort ();
775 }
776 \f
777 /* Compare two exception specifier types for exactness or subsetness, if
778    allowed. Returns false for mismatch, true for match (same, or
779    derived and !exact).
780  
781    [except.spec] "If a class X ... objects of class X or any class publicly
782    and unambiguously derived from X. Similarly, if a pointer type Y * ...
783    exceptions of type Y * or that are pointers to any type publicly and
784    unambiguously derived from Y. Otherwise a function only allows exceptions
785    that have the same type ..."
786    This does not mention cv qualifiers and is different to what throw
787    [except.throw] and catch [except.catch] will do. They will ignore the
788    top level cv qualifiers, and allow qualifiers in the pointer to class
789    example.
790    
791    We implement the letter of the standard.  */
792
793 static bool
794 comp_except_types (tree a, tree b, bool exact)
795 {
796   if (same_type_p (a, b))
797     return true;
798   else if (!exact)
799     {
800       if (cp_type_quals (a) || cp_type_quals (b))
801         return false;
802       
803       if (TREE_CODE (a) == POINTER_TYPE
804           && TREE_CODE (b) == POINTER_TYPE)
805         {
806           a = TREE_TYPE (a);
807           b = TREE_TYPE (b);
808           if (cp_type_quals (a) || cp_type_quals (b))
809             return false;
810         }
811       
812       if (TREE_CODE (a) != RECORD_TYPE
813           || TREE_CODE (b) != RECORD_TYPE)
814         return false;
815       
816       if (ACCESSIBLY_UNIQUELY_DERIVED_P (a, b))
817         return true;
818     }
819   return false;
820 }
821
822 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
823    If EXACT is false, T2 can be stricter than T1 (according to 15.4/7),
824    otherwise it must be exact. Exception lists are unordered, but
825    we've already filtered out duplicates. Most lists will be in order,
826    we should try to make use of that.  */
827
828 bool
829 comp_except_specs (tree t1, tree t2, bool exact)
830 {
831   tree probe;
832   tree base;
833   int  length = 0;
834
835   if (t1 == t2)
836     return true;
837   
838   if (t1 == NULL_TREE)              /* T1 is ...  */
839     return t2 == NULL_TREE || !exact;
840   if (!TREE_VALUE (t1)) /* t1 is EMPTY */
841     return t2 != NULL_TREE && !TREE_VALUE (t2);
842   if (t2 == NULL_TREE)              /* T2 is ...  */
843     return false;
844   if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
845     return !exact;
846   
847   /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
848      Count how many we find, to determine exactness. For exact matching and
849      ordered T1, T2, this is an O(n) operation, otherwise its worst case is
850      O(nm).  */
851   for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
852     {
853       for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
854         {
855           tree a = TREE_VALUE (probe);
856           tree b = TREE_VALUE (t2);
857           
858           if (comp_except_types (a, b, exact))
859             {
860               if (probe == base && exact)
861                 base = TREE_CHAIN (probe);
862               length++;
863               break;
864             }
865         }
866       if (probe == NULL_TREE)
867         return false;
868     }
869   return !exact || base == NULL_TREE || length == list_length (t1);
870 }
871
872 /* Compare the array types T1 and T2.  ALLOW_REDECLARATION is true if
873    [] can match [size].  */
874
875 static bool
876 comp_array_types (tree t1, tree t2, bool allow_redeclaration)
877 {
878   tree d1;
879   tree d2;
880   tree max1, max2;
881
882   if (t1 == t2)
883     return true;
884
885   /* The type of the array elements must be the same.  */
886   if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
887     return false;
888
889   d1 = TYPE_DOMAIN (t1);
890   d2 = TYPE_DOMAIN (t2);
891
892   if (d1 == d2)
893     return true;
894
895   /* If one of the arrays is dimensionless, and the other has a
896      dimension, they are of different types.  However, it is valid to
897      write:
898
899        extern int a[];
900        int a[3];
901
902      by [basic.link]: 
903
904        declarations for an array object can specify
905        array types that differ by the presence or absence of a major
906        array bound (_dcl.array_).  */
907   if (!d1 || !d2)
908     return allow_redeclaration;
909
910   /* Check that the dimensions are the same.  */
911
912   if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)))
913     return false;
914   max1 = TYPE_MAX_VALUE (d1);
915   max2 = TYPE_MAX_VALUE (d2);
916   if (processing_template_decl && !abi_version_at_least (2)
917       && !value_dependent_expression_p (max1)
918       && !value_dependent_expression_p (max2))
919     {
920       /* With abi-1 we do not fold non-dependent array bounds, (and
921          consequently mangle them incorrectly).  We must therefore
922          fold them here, to verify the domains have the same
923          value.  */
924       max1 = fold (max1);
925       max2 = fold (max2);
926     }
927
928   if (!cp_tree_equal (max1, max2))
929     return false;
930
931   return true;
932 }
933
934 /* Return true if T1 and T2 are related as allowed by STRICT.  STRICT
935    is a bitwise-or of the COMPARE_* flags.  */
936
937 bool
938 comptypes (tree t1, tree t2, int strict)
939 {
940   if (t1 == t2)
941     return true;
942
943   /* Suppress errors caused by previously reported errors.  */
944   if (t1 == error_mark_node || t2 == error_mark_node)
945     return false;
946   
947   my_friendly_assert (TYPE_P (t1) && TYPE_P (t2), 20030623);
948   
949   /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
950      current instantiation.  */
951   if (TREE_CODE (t1) == TYPENAME_TYPE)
952     {
953       tree resolved = resolve_typename_type (t1, /*only_current_p=*/true);
954
955       if (resolved != error_mark_node)
956         t1 = resolved;
957     }
958   
959   if (TREE_CODE (t2) == TYPENAME_TYPE)
960     {
961       tree resolved = resolve_typename_type (t2, /*only_current_p=*/true);
962
963       if (resolved != error_mark_node)
964         t2 = resolved;
965     }
966
967   /* If either type is the internal version of sizetype, use the
968      language version.  */
969   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
970       && TYPE_DOMAIN (t1))
971     t1 = TYPE_DOMAIN (t1);
972
973   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
974       && TYPE_DOMAIN (t2))
975     t2 = TYPE_DOMAIN (t2);
976
977   if (TYPE_PTRMEMFUNC_P (t1))
978     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
979   if (TYPE_PTRMEMFUNC_P (t2))
980     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
981
982   /* Different classes of types can't be compatible.  */
983   if (TREE_CODE (t1) != TREE_CODE (t2))
984     return false;
985
986   /* Qualifiers must match.  For array types, we will check when we
987      recur on the array element types.  */
988   if (TREE_CODE (t1) != ARRAY_TYPE
989       && TYPE_QUALS (t1) != TYPE_QUALS (t2))
990     return false;
991   if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
992     return false;
993
994   /* Allow for two different type nodes which have essentially the same
995      definition.  Note that we already checked for equality of the type
996      qualifiers (just above).  */
997
998   if (TREE_CODE (t1) != ARRAY_TYPE
999       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1000     return true;
1001
1002   if (!(*targetm.comp_type_attributes) (t1, t2))
1003     return false;
1004
1005   switch (TREE_CODE (t1))
1006     {
1007     case TEMPLATE_TEMPLATE_PARM:
1008     case BOUND_TEMPLATE_TEMPLATE_PARM:
1009       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
1010           || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
1011         return false;
1012       if (!comp_template_parms
1013           (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
1014            DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
1015         return false;
1016       if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
1017         return true;
1018       /* Don't check inheritance.  */
1019       strict = COMPARE_STRICT;
1020       /* Fall through.  */
1021
1022     case RECORD_TYPE:
1023     case UNION_TYPE:
1024       if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1025           && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1026               || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM)
1027           && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2)))
1028         return true;
1029       
1030       if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1031         return true;
1032       else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1))
1033         return true;
1034       
1035       return false;
1036
1037     case OFFSET_TYPE:
1038       if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2),
1039                       strict & ~COMPARE_REDECLARATION))
1040         return false;
1041       /* Fall through. */
1042
1043     case POINTER_TYPE:
1044     case REFERENCE_TYPE:
1045       return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1046
1047     case METHOD_TYPE:
1048     case FUNCTION_TYPE:
1049       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1050         return false;
1051       return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
1052
1053     case ARRAY_TYPE:
1054       /* Target types must match incl. qualifiers.  */
1055       return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION));
1056
1057     case TEMPLATE_TYPE_PARM:
1058       return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
1059               && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2));
1060
1061     case TYPENAME_TYPE:
1062       if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1063                           TYPENAME_TYPE_FULLNAME (t2)))
1064         return false;
1065       return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1066
1067     case UNBOUND_CLASS_TEMPLATE:
1068       if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2)))
1069         return false;
1070       return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1071
1072     case COMPLEX_TYPE:
1073       return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1074
1075     default:
1076       break;
1077     }
1078   return false;
1079 }
1080
1081 /* Returns 1 if TYPE1 is at least as qualified as TYPE2.  */
1082
1083 bool
1084 at_least_as_qualified_p (tree type1, tree type2)
1085 {
1086   int q1 = cp_type_quals (type1);
1087   int q2 = cp_type_quals (type2);
1088   
1089   /* All qualifiers for TYPE2 must also appear in TYPE1.  */
1090   return (q1 & q2) == q2;
1091 }
1092
1093 /* Returns 1 if TYPE1 is more qualified than TYPE2.  */
1094
1095 bool
1096 more_qualified_p (tree type1, tree type2)
1097 {
1098   int q1 = cp_type_quals (type1);
1099   int q2 = cp_type_quals (type2);
1100
1101   return q1 != q2 && (q1 & q2) == q2;
1102 }
1103
1104 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1105    more cv-qualified that TYPE1, and 0 otherwise.  */
1106
1107 int
1108 comp_cv_qualification (tree type1, tree type2)
1109 {
1110   int q1 = cp_type_quals (type1);
1111   int q2 = cp_type_quals (type2);
1112
1113   if (q1 == q2)
1114     return 0;
1115
1116   if ((q1 & q2) == q2)
1117     return 1;
1118   else if ((q1 & q2) == q1)
1119     return -1;
1120
1121   return 0;
1122 }
1123
1124 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1125    subset of the cv-qualification signature of TYPE2, and the types
1126    are similar.  Returns -1 if the other way 'round, and 0 otherwise.  */
1127
1128 int
1129 comp_cv_qual_signature (tree type1, tree type2)
1130 {
1131   if (comp_ptr_ttypes_real (type2, type1, -1))
1132     return 1;
1133   else if (comp_ptr_ttypes_real (type1, type2, -1))
1134     return -1;
1135   else
1136     return 0;
1137 }
1138
1139 /* If two types share a common base type, return that basetype.
1140    If there is not a unique most-derived base type, this function
1141    returns ERROR_MARK_NODE.  */
1142
1143 static tree
1144 common_base_type (tree tt1, tree tt2)
1145 {
1146   tree best = NULL_TREE;
1147   int i;
1148
1149   /* If one is a baseclass of another, that's good enough.  */
1150   if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1151     return tt1;
1152   if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1153     return tt2;
1154
1155   /* Otherwise, try to find a unique baseclass of TT1
1156      that is shared by TT2, and follow that down.  */
1157   for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
1158     {
1159       tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
1160       tree trial = common_base_type (basetype, tt2);
1161       if (trial)
1162         {
1163           if (trial == error_mark_node)
1164             return trial;
1165           if (best == NULL_TREE)
1166             best = trial;
1167           else if (best != trial)
1168             return error_mark_node;
1169         }
1170     }
1171
1172   /* Same for TT2.  */
1173   for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
1174     {
1175       tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
1176       tree trial = common_base_type (tt1, basetype);
1177       if (trial)
1178         {
1179           if (trial == error_mark_node)
1180             return trial;
1181           if (best == NULL_TREE)
1182             best = trial;
1183           else if (best != trial)
1184             return error_mark_node;
1185         }
1186     }
1187   return best;
1188 }
1189 \f
1190 /* Subroutines of `comptypes'.  */
1191
1192 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1193    equivalent in the sense that functions with those parameter types
1194    can have equivalent types.  The two lists must be equivalent,
1195    element by element.  */
1196
1197 bool
1198 compparms (tree parms1, tree parms2)
1199 {
1200   tree t1, t2;
1201
1202   /* An unspecified parmlist matches any specified parmlist
1203      whose argument types don't need default promotions.  */
1204
1205   for (t1 = parms1, t2 = parms2;
1206        t1 || t2;
1207        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1208     {
1209       /* If one parmlist is shorter than the other,
1210          they fail to match.  */
1211       if (!t1 || !t2)
1212         return false;
1213       if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1214         return false;
1215     }
1216   return true;
1217 }
1218
1219 \f
1220 /* Process a sizeof or alignof expression where the operand is a
1221    type.  */
1222
1223 tree
1224 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
1225 {
1226   enum tree_code type_code;
1227   tree value;
1228   const char *op_name;
1229
1230   my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
1231   if (type == error_mark_node)
1232     return error_mark_node;
1233   
1234   if (dependent_type_p (type))
1235     {
1236       value = build_min (op, size_type_node, type);
1237       TREE_READONLY (value) = 1;
1238       return value;
1239     }
1240   
1241   op_name = operator_name_info[(int) op].name;
1242
1243   type = non_reference (type);
1244   type_code = TREE_CODE (type);
1245
1246   if (type_code == METHOD_TYPE)
1247     {
1248       if (complain && (pedantic || warn_pointer_arith))
1249         pedwarn ("invalid application of `%s' to a member function", op_name);
1250       value = size_one_node;
1251     }
1252   else
1253     value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
1254
1255   return value;
1256 }
1257
1258 /* Process a sizeof or alignof expression where the operand is an
1259    expression.  */
1260
1261 tree
1262 cxx_sizeof_or_alignof_expr (tree e, enum tree_code op)
1263 {
1264   const char *op_name = operator_name_info[(int) op].name;
1265   
1266   if (e == error_mark_node)
1267     return error_mark_node;
1268   
1269   if (processing_template_decl)
1270     {
1271       e = build_min (op, size_type_node, e);
1272       TREE_SIDE_EFFECTS (e) = 0;
1273       TREE_READONLY (e) = 1;
1274       
1275       return e;
1276     }
1277   
1278   if (TREE_CODE (e) == COMPONENT_REF
1279       && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL
1280       && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1281     {
1282       error ("invalid application of `%s' to a bit-field", op_name);
1283       e = char_type_node;
1284     }
1285   else if (is_overloaded_fn (e))
1286     {
1287       pedwarn ("ISO C++ forbids applying `%s' to an expression of function type", op_name);
1288       e = char_type_node;
1289     }
1290   else if (type_unknown_p (e))
1291     {
1292       cxx_incomplete_type_error (e, TREE_TYPE (e));
1293       e = char_type_node;
1294     }
1295   else
1296     e = TREE_TYPE (e);
1297   
1298   return cxx_sizeof_or_alignof_type (e, op, true);
1299 }
1300   
1301 \f
1302 /* EXPR is being used in a context that is not a function call.
1303    Enforce:
1304
1305      [expr.ref] 
1306
1307      The expression can be used only as the left-hand operand of a
1308      member function call.  
1309
1310      [expr.mptr.operator]
1311
1312      If the result of .* or ->* is a function, then that result can be
1313      used only as the operand for the function call operator ().  
1314
1315    by issuing an error message if appropriate.  Returns true iff EXPR
1316    violates these rules.  */
1317
1318 bool
1319 invalid_nonstatic_memfn_p (tree expr)
1320 {
1321   if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
1322     {
1323       error ("invalid use of non-static member function");
1324       return true;
1325     }
1326   return false;
1327 }
1328
1329 /* Perform the conversions in [expr] that apply when an lvalue appears
1330    in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
1331    function-to-pointer conversions.
1332
1333    In addition manifest constants are replaced by their values.  */
1334
1335 tree
1336 decay_conversion (tree exp)
1337 {
1338   tree type;
1339   enum tree_code code;
1340
1341   type = TREE_TYPE (exp);
1342   code = TREE_CODE (type);
1343
1344   if (code == REFERENCE_TYPE)
1345     {
1346       exp = convert_from_reference (exp);
1347       type = TREE_TYPE (exp);
1348       code = TREE_CODE (type);
1349     }
1350
1351   if (type == error_mark_node)
1352     return error_mark_node;
1353
1354   if (type_unknown_p (exp))
1355     {
1356       cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1357       return error_mark_node;
1358     }
1359   
1360   /* Constants can be used directly unless they're not loadable.  */
1361   if (TREE_CODE (exp) == CONST_DECL)
1362     exp = DECL_INITIAL (exp);
1363   /* Replace a nonvolatile const static variable with its value.  We
1364      don't do this for arrays, though; we want the address of the
1365      first element of the array, not the address of the first element
1366      of its initializing constant.  */
1367   else if (code != ARRAY_TYPE)
1368     {
1369       exp = decl_constant_value (exp);
1370       type = TREE_TYPE (exp);
1371     }
1372
1373   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1374      Leave such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
1375
1376   if (code == VOID_TYPE)
1377     {
1378       error ("void value not ignored as it ought to be");
1379       return error_mark_node;
1380     }
1381   if (invalid_nonstatic_memfn_p (exp))
1382     return error_mark_node;
1383   if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1384     return build_unary_op (ADDR_EXPR, exp, 0);
1385   if (code == ARRAY_TYPE)
1386     {
1387       tree adr;
1388       tree ptrtype;
1389
1390       if (TREE_CODE (exp) == INDIRECT_REF)
1391         return build_nop (build_pointer_type (TREE_TYPE (type)), 
1392                           TREE_OPERAND (exp, 0));
1393
1394       if (TREE_CODE (exp) == COMPOUND_EXPR)
1395         {
1396           tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1397           return build (COMPOUND_EXPR, TREE_TYPE (op1),
1398                         TREE_OPERAND (exp, 0), op1);
1399         }
1400
1401       if (!lvalue_p (exp)
1402           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1403         {
1404           error ("invalid use of non-lvalue array");
1405           return error_mark_node;
1406         }
1407
1408       ptrtype = build_pointer_type (TREE_TYPE (type));
1409
1410       if (TREE_CODE (exp) == VAR_DECL)
1411         {
1412           if (!cxx_mark_addressable (exp))
1413             return error_mark_node;
1414           adr = build_nop (ptrtype, build_address (exp));
1415           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1416           return adr;
1417         }
1418       /* This way is better for a COMPONENT_REF since it can
1419          simplify the offset for a component.  */
1420       adr = build_unary_op (ADDR_EXPR, exp, 1);
1421       return cp_convert (ptrtype, adr);
1422     }
1423
1424   /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1425      rvalues always have cv-unqualified types.  */
1426   if (! CLASS_TYPE_P (type))
1427     exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1428
1429   return exp;
1430 }
1431
1432 tree
1433 default_conversion (tree exp)
1434 {
1435   exp = decay_conversion (exp);
1436
1437   if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp)))
1438     exp = perform_integral_promotions (exp);
1439
1440   return exp;
1441 }
1442
1443 /* EXPR is an expression with an integral or enumeration type.
1444    Perform the integral promotions in [conv.prom], and return the
1445    converted value.  */
1446
1447 tree
1448 perform_integral_promotions (tree expr)
1449 {
1450   tree type;
1451   tree promoted_type;
1452
1453   type = TREE_TYPE (expr);
1454   my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type), 20030703);
1455   promoted_type = type_promotes_to (type);
1456   if (type != promoted_type)
1457     expr = cp_convert (promoted_type, expr);
1458   return expr;
1459 }
1460
1461 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1462    or TREE_USED.  */
1463
1464 tree
1465 inline_conversion (tree exp)
1466 {
1467   if (TREE_CODE (exp) == FUNCTION_DECL)
1468     exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1469
1470   return exp;
1471 }
1472
1473 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1474    decay_conversion to one.  */
1475
1476 int
1477 string_conv_p (tree totype, tree exp, int warn)
1478 {
1479   tree t;
1480
1481   if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1482     return 0;
1483
1484   t = TREE_TYPE (totype);
1485   if (!same_type_p (t, char_type_node)
1486       && !same_type_p (t, wchar_type_node))
1487     return 0;
1488
1489   if (TREE_CODE (exp) == STRING_CST)
1490     {
1491       /* Make sure that we don't try to convert between char and wchar_t.  */
1492       if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1493         return 0;
1494     }
1495   else
1496     {
1497       /* Is this a string constant which has decayed to 'const char *'?  */
1498       t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1499       if (!same_type_p (TREE_TYPE (exp), t))
1500         return 0;
1501       STRIP_NOPS (exp);
1502       if (TREE_CODE (exp) != ADDR_EXPR
1503           || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1504         return 0;
1505     }
1506
1507   /* This warning is not very useful, as it complains about printf.  */
1508   if (warn && warn_write_strings)
1509     warning ("deprecated conversion from string constant to `%T'", totype);
1510
1511   return 1;
1512 }
1513
1514 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1515    can, for example, use as an lvalue.  This code used to be in
1516    unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1517    expressions, where we're dealing with aggregates.  But now it's again only
1518    called from unary_complex_lvalue.  The case (in particular) that led to
1519    this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1520    get it there.  */
1521
1522 static tree
1523 rationalize_conditional_expr (enum tree_code code, tree t)
1524 {
1525   /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1526      the first operand is always the one to be used if both operands
1527      are equal, so we know what conditional expression this used to be.  */
1528   if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1529     {
1530       return
1531         build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1532                                                     ? LE_EXPR : GE_EXPR),
1533                                                    TREE_OPERAND (t, 0),
1534                                                    TREE_OPERAND (t, 1),
1535                                                    /*overloaded_p=*/NULL),
1536                             build_unary_op (code, TREE_OPERAND (t, 0), 0),
1537                             build_unary_op (code, TREE_OPERAND (t, 1), 0));
1538     }
1539
1540   return
1541     build_conditional_expr (TREE_OPERAND (t, 0),
1542                             build_unary_op (code, TREE_OPERAND (t, 1), 0),
1543                             build_unary_op (code, TREE_OPERAND (t, 2), 0));
1544 }
1545
1546 /* Given the TYPE of an anonymous union field inside T, return the
1547    FIELD_DECL for the field.  If not found return NULL_TREE.  Because
1548    anonymous unions can nest, we must also search all anonymous unions
1549    that are directly reachable.  */
1550
1551 tree
1552 lookup_anon_field (tree t, tree type)
1553 {
1554   tree field;
1555
1556   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1557     {
1558       if (TREE_STATIC (field))
1559         continue;
1560       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1561         continue;
1562
1563       /* If we find it directly, return the field.  */
1564       if (DECL_NAME (field) == NULL_TREE
1565           && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1566         {
1567           return field;
1568         }
1569
1570       /* Otherwise, it could be nested, search harder.  */
1571       if (DECL_NAME (field) == NULL_TREE
1572           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1573         {
1574           tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1575           if (subfield)
1576             return subfield;
1577         }
1578     }
1579   return NULL_TREE;
1580 }
1581
1582 /* Build an expression representing OBJECT.MEMBER.  OBJECT is an
1583    expression; MEMBER is a DECL or baselink.  If ACCESS_PATH is
1584    non-NULL, it indicates the path to the base used to name MEMBER.
1585    If PRESERVE_REFERENCE is true, the expression returned will have
1586    REFERENCE_TYPE if the MEMBER does.  Otherwise, the expression
1587    returned will have the type referred to by the reference. 
1588
1589    This function does not perform access control; that is either done
1590    earlier by the parser when the name of MEMBER is resolved to MEMBER
1591    itself, or later when overload resolution selects one of the
1592    functions indicated by MEMBER.  */
1593
1594 tree
1595 build_class_member_access_expr (tree object, tree member, 
1596                                 tree access_path, bool preserve_reference)
1597 {
1598   tree object_type;
1599   tree member_scope;
1600   tree result = NULL_TREE;
1601
1602   if (object == error_mark_node || member == error_mark_node)
1603     return error_mark_node;
1604
1605   if (TREE_CODE (member) == PSEUDO_DTOR_EXPR)
1606     return member;
1607
1608   my_friendly_assert (DECL_P (member) || BASELINK_P (member),
1609                       20020801);
1610
1611   /* [expr.ref]
1612
1613      The type of the first expression shall be "class object" (of a
1614      complete type).  */
1615   object_type = TREE_TYPE (object);
1616   if (!currently_open_class (object_type) 
1617       && !complete_type_or_else (object_type, object))
1618     return error_mark_node;
1619   if (!CLASS_TYPE_P (object_type))
1620     {
1621       error ("request for member `%D' in `%E', which is of non-class type `%T'", 
1622              member, object, object_type);
1623       return error_mark_node;
1624     }
1625
1626   /* The standard does not seem to actually say that MEMBER must be a
1627      member of OBJECT_TYPE.  However, that is clearly what is
1628      intended.  */
1629   if (DECL_P (member))
1630     {
1631       member_scope = DECL_CLASS_CONTEXT (member);
1632       mark_used (member);
1633       if (TREE_DEPRECATED (member))
1634         warn_deprecated_use (member);
1635     }
1636   else
1637     member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1638   /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1639      presently be the anonymous union.  Go outwards until we find a
1640      type related to OBJECT_TYPE.  */
1641   while (ANON_AGGR_TYPE_P (member_scope)
1642          && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1643                                                         object_type))
1644     member_scope = TYPE_CONTEXT (member_scope);
1645   if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1646     {
1647       if (TREE_CODE (member) == FIELD_DECL)
1648         error ("invalid use of nonstatic data member '%E'", member);
1649       else
1650         error ("`%D' is not a member of `%T'", member, object_type);
1651       return error_mark_node;
1652     }
1653
1654   /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1655      `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only an lvalue
1656      in the frontend; only _DECLs and _REFs are lvalues in the backend.  */
1657   {
1658     tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1659     if (temp)
1660       object = build_indirect_ref (temp, NULL);
1661   }
1662
1663   /* In [expr.ref], there is an explicit list of the valid choices for
1664      MEMBER.  We check for each of those cases here.  */
1665   if (TREE_CODE (member) == VAR_DECL)
1666     {
1667       /* A static data member.  */
1668       result = member;
1669       /* If OBJECT has side-effects, they are supposed to occur.  */
1670       if (TREE_SIDE_EFFECTS (object))
1671         result = build (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1672     }
1673   else if (TREE_CODE (member) == FIELD_DECL)
1674     {
1675       /* A non-static data member.  */
1676       bool null_object_p;
1677       int type_quals;
1678       tree member_type;
1679
1680       null_object_p = (TREE_CODE (object) == INDIRECT_REF
1681                        && integer_zerop (TREE_OPERAND (object, 0)));
1682
1683       /* Convert OBJECT to the type of MEMBER.  */
1684       if (!same_type_p (TYPE_MAIN_VARIANT (object_type),
1685                         TYPE_MAIN_VARIANT (member_scope)))
1686         {
1687           tree binfo;
1688           base_kind kind;
1689
1690           binfo = lookup_base (access_path ? access_path : object_type,
1691                                member_scope, ba_ignore,  &kind);
1692           if (binfo == error_mark_node)
1693             return error_mark_node;
1694
1695           /* It is invalid to try to get to a virtual base of a
1696              NULL object.  The most common cause is invalid use of
1697              offsetof macro.  */
1698           if (null_object_p && kind == bk_via_virtual)
1699             {
1700               error ("invalid access to non-static data member `%D' of NULL object",
1701                      member);
1702               error ("(perhaps the `offsetof' macro was used incorrectly)");
1703               return error_mark_node;
1704             }
1705
1706           /* Convert to the base.  */
1707           object = build_base_path (PLUS_EXPR, object, binfo, 
1708                                     /*nonnull=*/1);
1709           /* If we found the base successfully then we should be able
1710              to convert to it successfully.  */
1711           my_friendly_assert (object != error_mark_node,
1712                               20020801);
1713         }
1714
1715       /* Complain about other invalid uses of offsetof, even though they will
1716          give the right answer.  Note that we complain whether or not they
1717          actually used the offsetof macro, since there's no way to know at this
1718          point.  So we just give a warning, instead of a pedwarn.  */
1719       if (null_object_p && warn_invalid_offsetof
1720           && CLASSTYPE_NON_POD_P (object_type))
1721         {
1722           warning ("invalid access to non-static data member `%D' of NULL object", 
1723                    member);
1724           warning  ("(perhaps the `offsetof' macro was used incorrectly)");
1725         }
1726
1727       /* If MEMBER is from an anonymous aggregate, we have converted
1728          OBJECT so that it refers to the class containing the
1729          anonymous union.  Generate a reference to the anonymous union
1730          itself, and recur to find MEMBER.  */
1731       if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1732           /* When this code is called from build_field_call, the
1733              object already has the type of the anonymous union.
1734              That is because the COMPONENT_REF was already
1735              constructed, and was then disassembled before calling
1736              build_field_call.  After the function-call code is
1737              cleaned up, this waste can be eliminated.  */
1738           && (!same_type_ignoring_top_level_qualifiers_p 
1739               (TREE_TYPE (object), DECL_CONTEXT (member))))
1740         {
1741           tree anonymous_union;
1742
1743           anonymous_union = lookup_anon_field (TREE_TYPE (object),
1744                                                DECL_CONTEXT (member));
1745           object = build_class_member_access_expr (object,
1746                                                    anonymous_union,
1747                                                    /*access_path=*/NULL_TREE,
1748                                                    preserve_reference);
1749         }
1750
1751       /* Compute the type of the field, as described in [expr.ref].  */
1752       type_quals = TYPE_UNQUALIFIED;
1753       member_type = TREE_TYPE (member);
1754       if (TREE_CODE (member_type) != REFERENCE_TYPE)
1755         {
1756           type_quals = (cp_type_quals (member_type)  
1757                         | cp_type_quals (object_type));
1758           
1759           /* A field is const (volatile) if the enclosing object, or the
1760              field itself, is const (volatile).  But, a mutable field is
1761              not const, even within a const object.  */
1762           if (DECL_MUTABLE_P (member))
1763             type_quals &= ~TYPE_QUAL_CONST;
1764           member_type = cp_build_qualified_type (member_type, type_quals);
1765         }
1766
1767       result = fold (build (COMPONENT_REF, member_type, object, member));
1768
1769       /* Mark the expression const or volatile, as appropriate.  Even
1770          though we've dealt with the type above, we still have to mark the
1771          expression itself.  */
1772       if (type_quals & TYPE_QUAL_CONST)
1773         TREE_READONLY (result) = 1;
1774       else if (type_quals & TYPE_QUAL_VOLATILE)
1775         TREE_THIS_VOLATILE (result) = 1;
1776     }
1777   else if (BASELINK_P (member))
1778     {
1779       /* The member is a (possibly overloaded) member function.  */
1780       tree functions;
1781       tree type;
1782
1783       /* If the MEMBER is exactly one static member function, then we
1784          know the type of the expression.  Otherwise, we must wait
1785          until overload resolution has been performed.  */
1786       functions = BASELINK_FUNCTIONS (member);
1787       if (TREE_CODE (functions) == FUNCTION_DECL
1788           && DECL_STATIC_FUNCTION_P (functions))
1789         type = TREE_TYPE (functions);
1790       else
1791         type = unknown_type_node;
1792       /* Note that we do not convert OBJECT to the BASELINK_BINFO
1793          base.  That will happen when the function is called.  */
1794       result = build (COMPONENT_REF, type, object, member);
1795     }
1796   else if (TREE_CODE (member) == CONST_DECL)
1797     {
1798       /* The member is an enumerator.  */
1799       result = member;
1800       /* If OBJECT has side-effects, they are supposed to occur.  */
1801       if (TREE_SIDE_EFFECTS (object))
1802         result = build (COMPOUND_EXPR, TREE_TYPE (result),
1803                         object, result);
1804     }
1805   else
1806     {
1807       error ("invalid use of `%D'", member);
1808       return error_mark_node;
1809     }
1810
1811   if (!preserve_reference)
1812     /* [expr.ref]
1813        
1814        If E2 is declared to have type "reference to T", then ... the
1815        type of E1.E2 is T.  */
1816     result = convert_from_reference (result);
1817
1818   return result;
1819 }
1820
1821 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
1822    SCOPE is NULL, by OBJECT.~DTOR_NAME.  */
1823
1824 static tree
1825 lookup_destructor (tree object, tree scope, tree dtor_name)
1826 {
1827   tree object_type = TREE_TYPE (object);
1828   tree dtor_type = TREE_OPERAND (dtor_name, 0);
1829   tree expr;
1830
1831   if (scope && !check_dtor_name (scope, dtor_name))
1832     {
1833       error ("qualified type `%T' does not match destructor name `~%T'",
1834              scope, dtor_type);
1835       return error_mark_node;
1836     }
1837   if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
1838     {
1839       error ("the type being destroyed is `%T', but the destructor refers to `%T'",
1840              TYPE_MAIN_VARIANT (object_type), dtor_type);
1841       return error_mark_node;
1842     }
1843   if (!TYPE_HAS_DESTRUCTOR (dtor_type))
1844     return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope,
1845                   dtor_type);
1846   expr = lookup_member (dtor_type, complete_dtor_identifier,
1847                         /*protect=*/1, /*want_type=*/false);
1848   expr = (adjust_result_of_qualified_name_lookup
1849           (expr, dtor_type, object_type));
1850   return expr;
1851 }
1852
1853 /* This function is called by the parser to process a class member
1854    access expression of the form OBJECT.NAME.  NAME is a node used by
1855    the parser to represent a name; it is not yet a DECL.  It may,
1856    however, be a BASELINK where the BASELINK_FUNCTIONS is a
1857    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
1858    there is no reason to do the lookup twice, so the parser keeps the
1859    BASELINK.  */
1860
1861 tree
1862 finish_class_member_access_expr (tree object, tree name)
1863 {
1864   tree expr;
1865   tree object_type;
1866   tree member;
1867   tree access_path = NULL_TREE;
1868   tree orig_object = object;
1869   tree orig_name = name;
1870
1871   if (object == error_mark_node || name == error_mark_node)
1872     return error_mark_node;
1873
1874   object_type = TREE_TYPE (object);
1875
1876   if (processing_template_decl)
1877     {
1878       if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME.  */
1879           dependent_type_p (object_type)
1880           /* If NAME is just an IDENTIFIER_NODE, then the expression
1881              is dependent.  */
1882           || TREE_CODE (object) == IDENTIFIER_NODE
1883           /* If NAME is "f<args>", where either 'f' or 'args' is
1884              dependent, then the expression is dependent.  */
1885           || (TREE_CODE (name) == TEMPLATE_ID_EXPR
1886               && dependent_template_id_p (TREE_OPERAND (name, 0),
1887                                           TREE_OPERAND (name, 1)))
1888           /* If NAME is "T::X" where "T" is dependent, then the
1889              expression is dependent.  */
1890           || (TREE_CODE (name) == SCOPE_REF
1891               && TYPE_P (TREE_OPERAND (name, 0))
1892               && dependent_type_p (TREE_OPERAND (name, 0))))
1893         return build_min_nt (COMPONENT_REF, object, name);
1894       object = build_non_dependent_expr (object);
1895     }
1896   
1897   if (TREE_CODE (object_type) == REFERENCE_TYPE)
1898     {
1899       object = convert_from_reference (object);
1900       object_type = TREE_TYPE (object);
1901     }
1902
1903   /* [expr.ref]
1904
1905      The type of the first expression shall be "class object" (of a
1906      complete type).  */
1907   if (!currently_open_class (object_type) 
1908       && !complete_type_or_else (object_type, object))
1909     return error_mark_node;
1910   if (!CLASS_TYPE_P (object_type))
1911     {
1912       error ("request for member `%D' in `%E', which is of non-class type `%T'", 
1913              name, object, object_type);
1914       return error_mark_node;
1915     }
1916
1917   if (BASELINK_P (name))
1918     {
1919       /* A member function that has already been looked up.  */
1920       my_friendly_assert ((TREE_CODE (BASELINK_FUNCTIONS (name)) 
1921                            == TEMPLATE_ID_EXPR), 
1922                           20020805);
1923       member = name;
1924     }
1925   else
1926     {
1927       bool is_template_id = false;
1928       tree template_args = NULL_TREE;
1929       tree scope;
1930
1931       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1932         {
1933           is_template_id = true;
1934           template_args = TREE_OPERAND (name, 1);
1935           name = TREE_OPERAND (name, 0);
1936
1937           if (TREE_CODE (name) == OVERLOAD)
1938             name = DECL_NAME (get_first_fn (name));
1939           else if (DECL_P (name))
1940             name = DECL_NAME (name);
1941         }
1942
1943       if (TREE_CODE (name) == SCOPE_REF)
1944         {
1945           /* A qualified name.  The qualifying class or namespace `S' has
1946              already been looked up; it is either a TYPE or a
1947              NAMESPACE_DECL.  The member name is either an IDENTIFIER_NODE
1948              or a BIT_NOT_EXPR.  */
1949           scope = TREE_OPERAND (name, 0);
1950           name = TREE_OPERAND (name, 1);
1951           my_friendly_assert ((CLASS_TYPE_P (scope) 
1952                                || TREE_CODE (scope) == NAMESPACE_DECL),
1953                               20020804);
1954           my_friendly_assert ((TREE_CODE (name) == IDENTIFIER_NODE
1955                                || TREE_CODE (name) == BIT_NOT_EXPR),
1956                               20020804);
1957
1958           /* If SCOPE is a namespace, then the qualified name does not
1959              name a member of OBJECT_TYPE.  */
1960           if (TREE_CODE (scope) == NAMESPACE_DECL)
1961             {
1962               error ("`%D::%D' is not a member of `%T'", 
1963                      scope, name, object_type);
1964               return error_mark_node;
1965             }
1966
1967           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
1968           access_path = lookup_base (object_type, scope, ba_check, NULL);
1969           if (access_path == error_mark_node)
1970             return error_mark_node;
1971           if (!access_path)
1972             {
1973               error ("`%T' is not a base of `%T'", scope, object_type);
1974               return error_mark_node;
1975             }
1976         }
1977       else
1978         {
1979           scope = NULL_TREE;
1980           access_path = object_type;
1981         }
1982
1983       if (TREE_CODE (name) == BIT_NOT_EXPR)
1984         member = lookup_destructor (object, scope, name);
1985       else
1986         {
1987           /* Look up the member.  */
1988           member = lookup_member (access_path, name, /*protect=*/1, 
1989                                   /*want_type=*/false);
1990           if (member == NULL_TREE)
1991             {
1992               error ("'%D' has no member named '%E'", object_type, name);
1993               return error_mark_node;
1994             }
1995           if (member == error_mark_node)
1996             return error_mark_node;
1997         }
1998       
1999       if (is_template_id)
2000         {
2001           tree template = member;
2002           
2003           if (BASELINK_P (template))
2004             template = lookup_template_function (template, template_args);
2005           else
2006             {
2007               error ("`%D' is not a member template function", name);
2008               return error_mark_node;
2009             }
2010         }
2011     }
2012
2013   if (TREE_DEPRECATED (member))
2014     warn_deprecated_use (member);
2015
2016   expr = build_class_member_access_expr (object, member, access_path,
2017                                          /*preserve_reference=*/false);
2018   if (processing_template_decl && expr != error_mark_node)
2019     return build_min_non_dep (COMPONENT_REF, expr,
2020                               orig_object, orig_name);
2021   return expr;
2022 }
2023
2024 /* Return an expression for the MEMBER_NAME field in the internal
2025    representation of PTRMEM, a pointer-to-member function.  (Each
2026    pointer-to-member function type gets its own RECORD_TYPE so it is
2027    more convenient to access the fields by name than by FIELD_DECL.)
2028    This routine converts the NAME to a FIELD_DECL and then creates the
2029    node for the complete expression.  */
2030
2031 tree
2032 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2033 {
2034   tree ptrmem_type;
2035   tree member;
2036   tree member_type;
2037
2038   /* This code is a stripped down version of
2039      build_class_member_access_expr.  It does not work to use that
2040      routine directly because it expects the object to be of class
2041      type.  */
2042   ptrmem_type = TREE_TYPE (ptrmem);
2043   my_friendly_assert (TYPE_PTRMEMFUNC_P (ptrmem_type), 20020804);
2044   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2045                           /*want_type=*/false);
2046   member_type = cp_build_qualified_type (TREE_TYPE (member),
2047                                          cp_type_quals (ptrmem_type));
2048   return fold (build (COMPONENT_REF, member_type, ptrmem, member));
2049 }
2050
2051 /* Given an expression PTR for a pointer, return an expression
2052    for the value pointed to.
2053    ERRORSTRING is the name of the operator to appear in error messages.
2054
2055    This function may need to overload OPERATOR_FNNAME.
2056    Must also handle REFERENCE_TYPEs for C++.  */
2057
2058 tree
2059 build_x_indirect_ref (tree expr, const char *errorstring)
2060 {
2061   tree orig_expr = expr;
2062   tree rval;
2063
2064   if (processing_template_decl)
2065     {
2066       if (type_dependent_expression_p (expr))
2067         return build_min_nt (INDIRECT_REF, expr);
2068       expr = build_non_dependent_expr (expr);
2069     }
2070
2071   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2072                        NULL_TREE, /*overloaded_p=*/NULL);
2073   if (!rval)
2074     rval = build_indirect_ref (expr, errorstring);
2075
2076   if (processing_template_decl && rval != error_mark_node)
2077     return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2078   else
2079     return rval;
2080 }
2081
2082 tree
2083 build_indirect_ref (tree ptr, const char *errorstring)
2084 {
2085   tree pointer, type;
2086
2087   if (ptr == error_mark_node)
2088     return error_mark_node;
2089
2090   if (ptr == current_class_ptr)
2091     return current_class_ref;
2092
2093   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2094              ? ptr : decay_conversion (ptr));
2095   type = TREE_TYPE (pointer);
2096
2097   if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
2098     {
2099       /* [expr.unary.op]
2100          
2101          If the type of the expression is "pointer to T," the type
2102          of  the  result  is  "T."   
2103
2104          We must use the canonical variant because certain parts of
2105          the back end, like fold, do pointer comparisons between
2106          types.  */
2107       tree t = canonical_type_variant (TREE_TYPE (type));
2108
2109       if (VOID_TYPE_P (t))
2110         {
2111           /* A pointer to incomplete type (other than cv void) can be
2112              dereferenced [expr.unary.op]/1  */
2113           error ("`%T' is not a pointer-to-object type", type);
2114           return error_mark_node;
2115         }
2116       else if (TREE_CODE (pointer) == ADDR_EXPR
2117                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2118         /* The POINTER was something like `&x'.  We simplify `*&x' to
2119            `x'.  */
2120         return TREE_OPERAND (pointer, 0);
2121       else
2122         {
2123           tree ref = build1 (INDIRECT_REF, t, pointer);
2124
2125           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2126              so that we get the proper error message if the result is used
2127              to assign to.  Also, &* is supposed to be a no-op.  */
2128           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2129           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2130           TREE_SIDE_EFFECTS (ref)
2131             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2132           return ref;
2133         }
2134     }
2135   /* `pointer' won't be an error_mark_node if we were given a
2136      pointer to member, so it's cool to check for this here.  */
2137   else if (TYPE_PTR_TO_MEMBER_P (type))
2138     error ("invalid use of `%s' on pointer to member", errorstring);
2139   else if (pointer != error_mark_node)
2140     {
2141       if (errorstring)
2142         error ("invalid type argument of `%s'", errorstring);
2143       else
2144         error ("invalid type argument");
2145     }
2146   return error_mark_node;
2147 }
2148
2149 /* This handles expressions of the form "a[i]", which denotes
2150    an array reference.
2151
2152    This is logically equivalent in C to *(a+i), but we may do it differently.
2153    If A is a variable or a member, we generate a primitive ARRAY_REF.
2154    This avoids forcing the array out of registers, and can work on
2155    arrays that are not lvalues (for example, members of structures returned
2156    by functions).
2157
2158    If INDEX is of some user-defined type, it must be converted to
2159    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2160    will inherit the type of the array, which will be some pointer type.  */
2161
2162 tree
2163 build_array_ref (tree array, tree idx)
2164 {
2165   if (idx == 0)
2166     {
2167       error ("subscript missing in array reference");
2168       return error_mark_node;
2169     }
2170
2171   if (TREE_TYPE (array) == error_mark_node
2172       || TREE_TYPE (idx) == error_mark_node)
2173     return error_mark_node;
2174
2175   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2176      inside it.  */
2177   switch (TREE_CODE (array))
2178     {
2179     case COMPOUND_EXPR:
2180       {
2181         tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2182         return build (COMPOUND_EXPR, TREE_TYPE (value),
2183                       TREE_OPERAND (array, 0), value);
2184       }
2185
2186     case COND_EXPR:
2187       return build_conditional_expr
2188         (TREE_OPERAND (array, 0),
2189          build_array_ref (TREE_OPERAND (array, 1), idx),
2190          build_array_ref (TREE_OPERAND (array, 2), idx));
2191
2192     default:
2193       break;
2194     }
2195
2196   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
2197       && TREE_CODE (array) != INDIRECT_REF)
2198     {
2199       tree rval, type;
2200
2201       /* Subscripting with type char is likely to lose
2202          on a machine where chars are signed.
2203          So warn on any machine, but optionally.
2204          Don't warn for unsigned char since that type is safe.
2205          Don't warn for signed char because anyone who uses that
2206          must have done so deliberately.  */
2207       if (warn_char_subscripts
2208           && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2209         warning ("array subscript has type `char'");
2210
2211       if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2212         {
2213           error ("array subscript is not an integer");
2214           return error_mark_node;
2215         }
2216
2217       /* Apply integral promotions *after* noticing character types.
2218          (It is unclear why we do these promotions -- the standard
2219          does not say that we should.  In fact, the natual thing would
2220          seem to be to convert IDX to ptrdiff_t; we're performing
2221          pointer arithmetic.)  */
2222       idx = perform_integral_promotions (idx);
2223
2224       /* An array that is indexed by a non-constant
2225          cannot be stored in a register; we must be able to do
2226          address arithmetic on its address.
2227          Likewise an array of elements of variable size.  */
2228       if (TREE_CODE (idx) != INTEGER_CST
2229           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2230               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2231                   != INTEGER_CST)))
2232         {
2233           if (!cxx_mark_addressable (array))
2234             return error_mark_node;
2235         }
2236
2237       /* An array that is indexed by a constant value which is not within
2238          the array bounds cannot be stored in a register either; because we
2239          would get a crash in store_bit_field/extract_bit_field when trying
2240          to access a non-existent part of the register.  */
2241       if (TREE_CODE (idx) == INTEGER_CST
2242           && TYPE_VALUES (TREE_TYPE (array))
2243           && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
2244         {
2245           if (!cxx_mark_addressable (array))
2246             return error_mark_node;
2247         }
2248
2249       if (pedantic && !lvalue_p (array))
2250         pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2251
2252       /* Note in C++ it is valid to subscript a `register' array, since
2253          it is valid to take the address of something with that
2254          storage specification.  */
2255       if (extra_warnings)
2256         {
2257           tree foo = array;
2258           while (TREE_CODE (foo) == COMPONENT_REF)
2259             foo = TREE_OPERAND (foo, 0);
2260           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2261             warning ("subscripting array declared `register'");
2262         }
2263
2264       type = TREE_TYPE (TREE_TYPE (array));
2265       rval = build (ARRAY_REF, type, array, idx);
2266       /* Array ref is const/volatile if the array elements are
2267          or if the array is..  */
2268       TREE_READONLY (rval)
2269         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2270       TREE_SIDE_EFFECTS (rval)
2271         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2272       TREE_THIS_VOLATILE (rval)
2273         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2274       return require_complete_type (fold (rval));
2275     }
2276
2277   {
2278     tree ar = default_conversion (array);
2279     tree ind = default_conversion (idx);
2280
2281     /* Put the integer in IND to simplify error checking.  */
2282     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2283       {
2284         tree temp = ar;
2285         ar = ind;
2286         ind = temp;
2287       }
2288
2289     if (ar == error_mark_node)
2290       return ar;
2291
2292     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2293       {
2294         error ("subscripted value is neither array nor pointer");
2295         return error_mark_node;
2296       }
2297     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2298       {
2299         error ("array subscript is not an integer");
2300         return error_mark_node;
2301       }
2302
2303     return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2304                                "array indexing");
2305   }
2306 }
2307 \f
2308 /* Resolve a pointer to member function.  INSTANCE is the object
2309    instance to use, if the member points to a virtual member.
2310
2311    This used to avoid checking for virtual functions if basetype
2312    has no virtual functions, according to an earlier ANSI draft.
2313    With the final ISO C++ rules, such an optimization is
2314    incorrect: A pointer to a derived member can be static_cast
2315    to pointer-to-base-member, as long as the dynamic object
2316    later has the right member.  */
2317
2318 tree
2319 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2320 {
2321   if (TREE_CODE (function) == OFFSET_REF)
2322     function = TREE_OPERAND (function, 1);
2323
2324   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2325     {
2326       tree idx, delta, e1, e2, e3, vtbl, basetype;
2327       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2328
2329       tree instance_ptr = *instance_ptrptr;
2330       tree instance_save_expr = 0;
2331       if (instance_ptr == error_mark_node)
2332         {
2333           if (TREE_CODE (function) == PTRMEM_CST)
2334             {
2335               /* Extracting the function address from a pmf is only
2336                  allowed with -Wno-pmf-conversions. It only works for
2337                  pmf constants.  */
2338               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2339               e1 = convert (fntype, e1);
2340               return e1;
2341             }
2342           else
2343             {
2344               error ("object missing in use of `%E'", function);
2345               return error_mark_node;
2346             }
2347         }
2348
2349       if (TREE_SIDE_EFFECTS (instance_ptr))
2350         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2351
2352       if (TREE_SIDE_EFFECTS (function))
2353         function = save_expr (function);
2354
2355       /* Start by extracting all the information from the PMF itself.  */
2356       e3 = PFN_FROM_PTRMEMFUNC (function);
2357       delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2358       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2359       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2360         {
2361         case ptrmemfunc_vbit_in_pfn:
2362           e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2363           idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2364           break;
2365
2366         case ptrmemfunc_vbit_in_delta:
2367           e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2368           delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2369           break;
2370
2371         default:
2372           abort ();
2373         }
2374
2375       /* Convert down to the right base before using the instance.  First
2376          use the type...  */
2377       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2378       basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2379                               basetype, ba_check, NULL);
2380       instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2381       if (instance_ptr == error_mark_node)
2382         return error_mark_node;
2383       /* ...and then the delta in the PMF.  */
2384       instance_ptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
2385                             instance_ptr, delta);
2386
2387       /* Hand back the adjusted 'this' argument to our caller.  */
2388       *instance_ptrptr = instance_ptr;
2389
2390       /* Next extract the vtable pointer from the object.  */
2391       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2392                      instance_ptr);
2393       vtbl = build_indirect_ref (vtbl, NULL);
2394
2395       /* Finally, extract the function pointer from the vtable.  */
2396       e2 = fold (build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
2397       e2 = build_indirect_ref (e2, NULL);
2398       TREE_CONSTANT (e2) = 1;
2399
2400       /* When using function descriptors, the address of the
2401          vtable entry is treated as a function pointer.  */
2402       if (TARGET_VTABLE_USES_DESCRIPTORS)
2403         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2404                      build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2405
2406       TREE_TYPE (e2) = TREE_TYPE (e3);
2407       e1 = build_conditional_expr (e1, e2, e3);
2408       
2409       /* Make sure this doesn't get evaluated first inside one of the
2410          branches of the COND_EXPR.  */
2411       if (instance_save_expr)
2412         e1 = build (COMPOUND_EXPR, TREE_TYPE (e1),
2413                     instance_save_expr, e1);
2414
2415       function = e1;
2416     }
2417   return function;
2418 }
2419
2420 tree
2421 build_function_call (tree function, tree params)
2422 {
2423   tree fntype, fndecl;
2424   tree coerced_params;
2425   tree result;
2426   tree name = NULL_TREE, assembler_name = NULL_TREE;
2427   int is_method;
2428   tree original = function;
2429
2430   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2431      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2432   if (TREE_CODE (function) == NOP_EXPR
2433       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2434     function = TREE_OPERAND (function, 0);
2435
2436   if (TREE_CODE (function) == FUNCTION_DECL)
2437     {
2438       name = DECL_NAME (function);
2439       assembler_name = DECL_ASSEMBLER_NAME (function);
2440
2441       mark_used (function);
2442       fndecl = function;
2443
2444       /* Convert anything with function type to a pointer-to-function.  */
2445       if (pedantic && DECL_MAIN_P (function))
2446         pedwarn ("ISO C++ forbids calling `::main' from within program");
2447
2448       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2449          (because calling an inline function does not mean the function
2450          needs to be separately compiled).  */
2451       
2452       if (DECL_INLINE (function))
2453         function = inline_conversion (function);
2454       else
2455         function = build_addr_func (function);
2456     }
2457   else
2458     {
2459       fndecl = NULL_TREE;
2460
2461       function = build_addr_func (function);
2462     }
2463
2464   if (function == error_mark_node)
2465     return error_mark_node;
2466
2467   fntype = TREE_TYPE (function);
2468
2469   if (TYPE_PTRMEMFUNC_P (fntype))
2470     {
2471       error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2472                 original);
2473       return error_mark_node;
2474     }
2475
2476   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2477                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2478
2479   if (!((TREE_CODE (fntype) == POINTER_TYPE
2480          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2481         || is_method
2482         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2483     {
2484       error ("`%E' cannot be used as a function", original);
2485       return error_mark_node;
2486     }
2487
2488   /* fntype now gets the type of function pointed to.  */
2489   fntype = TREE_TYPE (fntype);
2490
2491   /* Convert the parameters to the types declared in the
2492      function prototype, or apply default promotions.  */
2493
2494   coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2495                                       params, fndecl, LOOKUP_NORMAL);
2496   if (coerced_params == error_mark_node)
2497     return error_mark_node;
2498
2499   /* Check for errors in format strings.  */
2500
2501   if (warn_format)
2502     check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
2503
2504   /* Recognize certain built-in functions so we can make tree-codes
2505      other than CALL_EXPR.  We do this when it enables fold-const.c
2506      to do something useful.  */
2507
2508   if (TREE_CODE (function) == ADDR_EXPR
2509       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2510       && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2511     {
2512       result = expand_tree_builtin (TREE_OPERAND (function, 0),
2513                                     params, coerced_params);
2514       if (result)
2515         return result;
2516     }
2517
2518   return build_cxx_call (function, params, coerced_params);
2519 }
2520 \f
2521 /* Convert the actual parameter expressions in the list VALUES
2522    to the types in the list TYPELIST.
2523    If parmdecls is exhausted, or when an element has NULL as its type,
2524    perform the default conversions.
2525
2526    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2527
2528    This is also where warnings about wrong number of args are generated.
2529    
2530    Return a list of expressions for the parameters as converted.
2531
2532    Both VALUES and the returned value are chains of TREE_LIST nodes
2533    with the elements of the list in the TREE_VALUE slots of those nodes.
2534
2535    In C++, unspecified trailing parameters can be filled in with their
2536    default arguments, if such were specified.  Do so here.  */
2537
2538 tree
2539 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2540 {
2541   tree typetail, valtail;
2542   tree result = NULL_TREE;
2543   const char *called_thing = 0;
2544   int i = 0;
2545
2546   /* Argument passing is always copy-initialization.  */
2547   flags |= LOOKUP_ONLYCONVERTING;
2548
2549   if (fndecl)
2550     {
2551       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2552         {
2553           if (DECL_NAME (fndecl) == NULL_TREE
2554               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2555             called_thing = "constructor";
2556           else
2557             called_thing = "member function";
2558         }
2559       else
2560         called_thing = "function";
2561     }
2562
2563   for (valtail = values, typetail = typelist;
2564        valtail;
2565        valtail = TREE_CHAIN (valtail), i++)
2566     {
2567       tree type = typetail ? TREE_VALUE (typetail) : 0;
2568       tree val = TREE_VALUE (valtail);
2569
2570       if (val == error_mark_node)
2571         return error_mark_node;
2572
2573       if (type == void_type_node)
2574         {
2575           if (fndecl)
2576             {
2577               cp_error_at ("too many arguments to %s `%+#D'", called_thing,
2578                            fndecl);
2579               error ("at this point in file");
2580             }
2581           else
2582             error ("too many arguments to function");
2583           /* In case anybody wants to know if this argument
2584              list is valid.  */
2585           if (result)
2586             TREE_TYPE (tree_last (result)) = error_mark_node;
2587           break;
2588         }
2589
2590       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2591          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
2592       if (TREE_CODE (val) == NOP_EXPR
2593           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2594           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2595         val = TREE_OPERAND (val, 0);
2596
2597       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2598         {
2599           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2600               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2601               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2602             val = decay_conversion (val);
2603         }
2604
2605       if (val == error_mark_node)
2606         return error_mark_node;
2607
2608       if (type != 0)
2609         {
2610           /* Formal parm type is specified by a function prototype.  */
2611           tree parmval;
2612
2613           if (!COMPLETE_TYPE_P (complete_type (type)))
2614             {
2615               if (fndecl)
2616                 error ("parameter %P of `%D' has incomplete type `%T'",
2617                        i, fndecl, type);
2618               else
2619                 error ("parameter %P has incomplete type `%T'", i, type);
2620               parmval = error_mark_node;
2621             }
2622           else
2623             {
2624               parmval = convert_for_initialization
2625                 (NULL_TREE, type, val, flags,
2626                  "argument passing", fndecl, i);
2627               parmval = convert_for_arg_passing (type, parmval);
2628             }
2629
2630           if (parmval == error_mark_node)
2631             return error_mark_node;
2632
2633           result = tree_cons (NULL_TREE, parmval, result);
2634         }
2635       else
2636         {
2637           if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
2638             val = convert_from_reference (val);
2639
2640           if (fndecl && DECL_BUILT_IN (fndecl)
2641               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2642             /* Don't do ellipsis conversion for __built_in_constant_p
2643                as this will result in spurious warnings for non-POD
2644                types.  */
2645             val = require_complete_type (val);
2646           else
2647             val = convert_arg_to_ellipsis (val);
2648
2649           result = tree_cons (NULL_TREE, val, result);
2650         }
2651
2652       if (typetail)
2653         typetail = TREE_CHAIN (typetail);
2654     }
2655
2656   if (typetail != 0 && typetail != void_list_node)
2657     {
2658       /* See if there are default arguments that can be used.  */
2659       if (TREE_PURPOSE (typetail) 
2660           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2661         {
2662           for (; typetail != void_list_node; ++i)
2663             {
2664               tree parmval 
2665                 = convert_default_arg (TREE_VALUE (typetail), 
2666                                        TREE_PURPOSE (typetail), 
2667                                        fndecl, i);
2668
2669               if (parmval == error_mark_node)
2670                 return error_mark_node;
2671
2672               result = tree_cons (0, parmval, result);
2673               typetail = TREE_CHAIN (typetail);
2674               /* ends with `...'.  */
2675               if (typetail == NULL_TREE)
2676                 break;
2677             }
2678         }
2679       else
2680         {
2681           if (fndecl)
2682             {
2683               cp_error_at ("too few arguments to %s `%+#D'",
2684                            called_thing, fndecl);
2685               error ("at this point in file");
2686             }
2687           else
2688             error ("too few arguments to function");
2689           return error_mark_list;
2690         }
2691     }
2692
2693   return nreverse (result);
2694 }
2695 \f
2696 /* Build a binary-operation expression, after performing default
2697    conversions on the operands.  CODE is the kind of expression to build.  */
2698
2699 tree
2700 build_x_binary_op (enum tree_code code, tree arg1, tree arg2, 
2701                    bool *overloaded_p)
2702 {
2703   tree orig_arg1;
2704   tree orig_arg2;
2705   tree expr;
2706
2707   orig_arg1 = arg1;
2708   orig_arg2 = arg2;
2709
2710   if (processing_template_decl)
2711     {
2712       if (type_dependent_expression_p (arg1)
2713           || type_dependent_expression_p (arg2))
2714         return build_min_nt (code, arg1, arg2);
2715       arg1 = build_non_dependent_expr (arg1);
2716       arg2 = build_non_dependent_expr (arg2);
2717     }
2718
2719   if (code == DOTSTAR_EXPR)
2720     expr = build_m_component_ref (arg1, arg2);
2721   else
2722     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE, 
2723                          overloaded_p);
2724
2725   if (processing_template_decl && expr != error_mark_node)
2726     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
2727   
2728   return expr;
2729 }
2730
2731 /* Build a binary-operation expression without default conversions.
2732    CODE is the kind of expression to build.
2733    This function differs from `build' in several ways:
2734    the data type of the result is computed and recorded in it,
2735    warnings are generated if arg data types are invalid,
2736    special handling for addition and subtraction of pointers is known,
2737    and some optimization is done (operations on narrow ints
2738    are done in the narrower type when that gives the same result).
2739    Constant folding is also done before the result is returned.
2740
2741    Note that the operands will never have enumeral types
2742    because either they have just had the default conversions performed
2743    or they have both just been converted to some other type in which
2744    the arithmetic is to be done.
2745
2746    C++: must do special pointer arithmetic when implementing
2747    multiple inheritance, and deal with pointer to member functions.  */
2748
2749 tree
2750 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2751                  int convert_p ATTRIBUTE_UNUSED)
2752 {
2753   tree op0, op1;
2754   enum tree_code code0, code1;
2755   tree type0, type1;
2756
2757   /* Expression code to give to the expression when it is built.
2758      Normally this is CODE, which is what the caller asked for,
2759      but in some special cases we change it.  */
2760   enum tree_code resultcode = code;
2761
2762   /* Data type in which the computation is to be performed.
2763      In the simplest cases this is the common type of the arguments.  */
2764   tree result_type = NULL;
2765
2766   /* Nonzero means operands have already been type-converted
2767      in whatever way is necessary.
2768      Zero means they need to be converted to RESULT_TYPE.  */
2769   int converted = 0;
2770
2771   /* Nonzero means create the expression with this type, rather than
2772      RESULT_TYPE.  */
2773   tree build_type = 0;
2774
2775   /* Nonzero means after finally constructing the expression
2776      convert it to this type.  */
2777   tree final_type = 0;
2778
2779   /* Nonzero if this is an operation like MIN or MAX which can
2780      safely be computed in short if both args are promoted shorts.
2781      Also implies COMMON.
2782      -1 indicates a bitwise operation; this makes a difference
2783      in the exact conditions for when it is safe to do the operation
2784      in a narrower mode.  */
2785   int shorten = 0;
2786
2787   /* Nonzero if this is a comparison operation;
2788      if both args are promoted shorts, compare the original shorts.
2789      Also implies COMMON.  */
2790   int short_compare = 0;
2791
2792   /* Nonzero if this is a right-shift operation, which can be computed on the
2793      original short and then promoted if the operand is a promoted short.  */
2794   int short_shift = 0;
2795
2796   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
2797   int common = 0;
2798
2799   /* Apply default conversions.  */
2800   op0 = orig_op0;
2801   op1 = orig_op1;
2802   
2803   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2804       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2805       || code == TRUTH_XOR_EXPR)
2806     {
2807       if (!really_overloaded_fn (op0))
2808         op0 = decay_conversion (op0);
2809       if (!really_overloaded_fn (op1))
2810         op1 = decay_conversion (op1);
2811     }
2812   else
2813     {
2814       if (!really_overloaded_fn (op0))
2815         op0 = default_conversion (op0);
2816       if (!really_overloaded_fn (op1))
2817         op1 = default_conversion (op1);
2818     }
2819
2820   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
2821   STRIP_TYPE_NOPS (op0);
2822   STRIP_TYPE_NOPS (op1);
2823
2824   /* DTRT if one side is an overloaded function, but complain about it.  */
2825   if (type_unknown_p (op0))
2826     {
2827       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2828       if (t != error_mark_node)
2829         {
2830           pedwarn ("assuming cast to type `%T' from overloaded function",
2831                       TREE_TYPE (t));
2832           op0 = t;
2833         }
2834     }
2835   if (type_unknown_p (op1))
2836     {
2837       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2838       if (t != error_mark_node)
2839         {
2840           pedwarn ("assuming cast to type `%T' from overloaded function",
2841                       TREE_TYPE (t));
2842           op1 = t;
2843         }
2844     }
2845
2846   type0 = TREE_TYPE (op0);
2847   type1 = TREE_TYPE (op1);
2848
2849   /* The expression codes of the data types of the arguments tell us
2850      whether the arguments are integers, floating, pointers, etc.  */
2851   code0 = TREE_CODE (type0);
2852   code1 = TREE_CODE (type1);
2853
2854   /* If an error was already reported for one of the arguments,
2855      avoid reporting another error.  */
2856
2857   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2858     return error_mark_node;
2859
2860   switch (code)
2861     {
2862     case PLUS_EXPR:
2863       /* Handle the pointer + int case.  */
2864       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2865         return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
2866       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2867         return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
2868       else
2869         common = 1;
2870       break;
2871
2872     case MINUS_EXPR:
2873       /* Subtraction of two similar pointers.
2874          We must subtract them as integers, then divide by object size.  */
2875       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2876           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
2877                                                         TREE_TYPE (type1)))
2878         return pointer_diff (op0, op1, common_type (type0, type1));
2879       /* Handle pointer minus int.  Just like pointer plus int.  */
2880       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2881         return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
2882       else
2883         common = 1;
2884       break;
2885
2886     case MULT_EXPR:
2887       common = 1;
2888       break;
2889
2890     case TRUNC_DIV_EXPR:
2891     case CEIL_DIV_EXPR:
2892     case FLOOR_DIV_EXPR:
2893     case ROUND_DIV_EXPR:
2894     case EXACT_DIV_EXPR:
2895       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2896            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2897           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2898               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
2899         {
2900           if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
2901             warning ("division by zero in `%E / 0'", op0);
2902           else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
2903             warning ("division by zero in `%E / 0.'", op0);
2904               
2905           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2906             resultcode = RDIV_EXPR;
2907           else
2908             /* When dividing two signed integers, we have to promote to int.
2909                unless we divide by a constant != -1.  Note that default
2910                conversion will have been performed on the operands at this
2911                point, so we have to dig out the original type to find out if
2912                it was unsigned.  */
2913             shorten = ((TREE_CODE (op0) == NOP_EXPR
2914                         && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2915                        || (TREE_CODE (op1) == INTEGER_CST
2916                            && ! integer_all_onesp (op1)));
2917
2918           common = 1;
2919         }
2920       break;
2921
2922     case BIT_AND_EXPR:
2923     case BIT_IOR_EXPR:
2924     case BIT_XOR_EXPR:
2925       if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2926           || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
2927         shorten = -1;
2928       break;
2929
2930     case TRUNC_MOD_EXPR:
2931     case FLOOR_MOD_EXPR:
2932       if (code1 == INTEGER_TYPE && integer_zerop (op1))
2933         warning ("division by zero in `%E %% 0'", op0);
2934       else if (code1 == REAL_TYPE && real_zerop (op1))
2935         warning ("division by zero in `%E %% 0.'", op0);
2936       
2937       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2938         {
2939           /* Although it would be tempting to shorten always here, that loses
2940              on some targets, since the modulo instruction is undefined if the
2941              quotient can't be represented in the computation mode.  We shorten
2942              only if unsigned or if dividing by something we know != -1.  */
2943           shorten = ((TREE_CODE (op0) == NOP_EXPR
2944                       && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2945                      || (TREE_CODE (op1) == INTEGER_CST
2946                          && ! integer_all_onesp (op1)));
2947           common = 1;
2948         }
2949       break;
2950
2951     case TRUTH_ANDIF_EXPR:
2952     case TRUTH_ORIF_EXPR:
2953     case TRUTH_AND_EXPR:
2954     case TRUTH_OR_EXPR:
2955       result_type = boolean_type_node;
2956       break;
2957
2958       /* Shift operations: result has same type as first operand;
2959          always convert second operand to int.
2960          Also set SHORT_SHIFT if shifting rightward.  */
2961
2962     case RSHIFT_EXPR:
2963       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2964         {
2965           result_type = type0;
2966           if (TREE_CODE (op1) == INTEGER_CST)
2967             {
2968               if (tree_int_cst_lt (op1, integer_zero_node))
2969                 warning ("right shift count is negative");
2970               else
2971                 {
2972                   if (! integer_zerop (op1))
2973                     short_shift = 1;
2974                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2975                     warning ("right shift count >= width of type");
2976                 }
2977             }
2978           /* Convert the shift-count to an integer, regardless of
2979              size of value being shifted.  */
2980           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2981             op1 = cp_convert (integer_type_node, op1);
2982           /* Avoid converting op1 to result_type later.  */
2983           converted = 1;
2984         }
2985       break;
2986
2987     case LSHIFT_EXPR:
2988       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2989         {
2990           result_type = type0;
2991           if (TREE_CODE (op1) == INTEGER_CST)
2992             {
2993               if (tree_int_cst_lt (op1, integer_zero_node))
2994                 warning ("left shift count is negative");
2995               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2996                 warning ("left shift count >= width of type");
2997             }
2998           /* Convert the shift-count to an integer, regardless of
2999              size of value being shifted.  */
3000           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3001             op1 = cp_convert (integer_type_node, op1);
3002           /* Avoid converting op1 to result_type later.  */
3003           converted = 1;
3004         }
3005       break;
3006
3007     case RROTATE_EXPR:
3008     case LROTATE_EXPR:
3009       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3010         {
3011           result_type = type0;
3012           if (TREE_CODE (op1) == INTEGER_CST)
3013             {
3014               if (tree_int_cst_lt (op1, integer_zero_node))
3015                 warning ("%s rotate count is negative",
3016                          (code == LROTATE_EXPR) ? "left" : "right");
3017               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3018                 warning ("%s rotate count >= width of type",
3019                          (code == LROTATE_EXPR) ? "left" : "right");
3020             }
3021           /* Convert the shift-count to an integer, regardless of
3022              size of value being shifted.  */
3023           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3024             op1 = cp_convert (integer_type_node, op1);
3025         }
3026       break;
3027
3028     case EQ_EXPR:
3029     case NE_EXPR:
3030       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3031         warning ("comparing floating point with == or != is unsafe");
3032
3033       build_type = boolean_type_node; 
3034       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3035            || code0 == COMPLEX_TYPE)
3036           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3037               || code1 == COMPLEX_TYPE))
3038         short_compare = 1;
3039       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3040                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3041         result_type = composite_pointer_type (type0, type1, op0, op1,
3042                                               "comparison");
3043       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3044                && null_ptr_cst_p (op1))
3045         result_type = type0;
3046       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3047                && null_ptr_cst_p (op0))
3048         result_type = type1;
3049       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3050         {
3051           result_type = type0;
3052           error ("ISO C++ forbids comparison between pointer and integer");
3053         }
3054       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3055         {
3056           result_type = type1;
3057           error ("ISO C++ forbids comparison between pointer and integer");
3058         }
3059       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3060         {
3061           op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3062           op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3063           result_type = TREE_TYPE (op0);
3064         }
3065       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3066         return cp_build_binary_op (code, op1, op0);
3067       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3068                && same_type_p (type0, type1))
3069         {
3070           /* E will be the final comparison.  */
3071           tree e;
3072           /* E1 and E2 are for scratch.  */
3073           tree e1;
3074           tree e2;
3075           tree pfn0;
3076           tree pfn1;
3077           tree delta0;
3078           tree delta1;
3079
3080           if (TREE_SIDE_EFFECTS (op0))
3081             op0 = save_expr (op0);
3082           if (TREE_SIDE_EFFECTS (op1))
3083             op1 = save_expr (op1);
3084
3085           /* We generate:
3086
3087              (op0.pfn == op1.pfn 
3088               && (!op0.pfn || op0.delta == op1.delta))
3089              
3090              The reason for the `!op0.pfn' bit is that a NULL
3091              pointer-to-member is any member with a zero PFN; the
3092              DELTA field is unspecified.  */
3093           pfn0 = pfn_from_ptrmemfunc (op0);
3094           pfn1 = pfn_from_ptrmemfunc (op1);
3095           delta0 = build_ptrmemfunc_access_expr (op0,
3096                                                  delta_identifier);
3097           delta1 = build_ptrmemfunc_access_expr (op1,
3098                                                  delta_identifier);
3099           e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3100           e2 = cp_build_binary_op (EQ_EXPR, 
3101                                    pfn0,
3102                                    cp_convert (TREE_TYPE (pfn0),
3103                                                integer_zero_node));
3104           e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3105           e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3106           e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3107           if (code == EQ_EXPR)
3108             return e;
3109           return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3110         }
3111       else if ((TYPE_PTRMEMFUNC_P (type0)
3112                 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
3113                || (TYPE_PTRMEMFUNC_P (type1)
3114                    && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
3115         abort ();
3116       break;
3117
3118     case MAX_EXPR:
3119     case MIN_EXPR:
3120       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3121            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3122         shorten = 1;
3123       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3124         result_type = composite_pointer_type (type0, type1, op0, op1,
3125                                               "comparison");
3126       break;
3127
3128     case LE_EXPR:
3129     case GE_EXPR:
3130     case LT_EXPR:
3131     case GT_EXPR:
3132       build_type = boolean_type_node;
3133       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3134            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3135         short_compare = 1;
3136       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3137         result_type = composite_pointer_type (type0, type1, op0, op1,
3138                                               "comparison");
3139       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3140                && integer_zerop (op1))
3141         result_type = type0;
3142       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3143                && integer_zerop (op0))
3144         result_type = type1;
3145       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3146         {
3147           result_type = type0;
3148           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3149         }
3150       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3151         {
3152           result_type = type1;
3153           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3154         }
3155       break;
3156
3157     case UNORDERED_EXPR:
3158     case ORDERED_EXPR:
3159     case UNLT_EXPR:
3160     case UNLE_EXPR:
3161     case UNGT_EXPR:
3162     case UNGE_EXPR:
3163     case UNEQ_EXPR:
3164       build_type = integer_type_node;
3165       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3166         {
3167           error ("unordered comparison on non-floating point argument");
3168           return error_mark_node;
3169         }
3170       common = 1;
3171       break;
3172
3173     default:
3174       break;
3175     }
3176
3177   if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3178        &&
3179        (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
3180       || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
3181     {
3182       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3183
3184       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3185           && !tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)))
3186         error ("can't convert between vector values of different size");
3187
3188       if (shorten || common || short_compare)
3189         result_type = common_type (type0, type1);
3190
3191       /* For certain operations (which identify themselves by shorten != 0)
3192          if both args were extended from the same smaller type,
3193          do the arithmetic in that type and then extend.
3194
3195          shorten !=0 and !=1 indicates a bitwise operation.
3196          For them, this optimization is safe only if
3197          both args are zero-extended or both are sign-extended.
3198          Otherwise, we might change the result.
3199          Eg, (short)-1 | (unsigned short)-1 is (int)-1
3200          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3201
3202       if (shorten && none_complex)
3203         {
3204           int unsigned0, unsigned1;
3205           tree arg0 = get_narrower (op0, &unsigned0);
3206           tree arg1 = get_narrower (op1, &unsigned1);
3207           /* UNS is 1 if the operation to be done is an unsigned one.  */
3208           int uns = TREE_UNSIGNED (result_type);
3209           tree type;
3210
3211           final_type = result_type;
3212
3213           /* Handle the case that OP0 does not *contain* a conversion
3214              but it *requires* conversion to FINAL_TYPE.  */
3215
3216           if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3217             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3218           if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3219             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3220
3221           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
3222
3223           /* For bitwise operations, signedness of nominal type
3224              does not matter.  Consider only how operands were extended.  */
3225           if (shorten == -1)
3226             uns = unsigned0;
3227
3228           /* Note that in all three cases below we refrain from optimizing
3229              an unsigned operation on sign-extended args.
3230              That would not be valid.  */
3231
3232           /* Both args variable: if both extended in same way
3233              from same width, do it in that width.
3234              Do it unsigned if args were zero-extended.  */
3235           if ((TYPE_PRECISION (TREE_TYPE (arg0))
3236                < TYPE_PRECISION (result_type))
3237               && (TYPE_PRECISION (TREE_TYPE (arg1))
3238                   == TYPE_PRECISION (TREE_TYPE (arg0)))
3239               && unsigned0 == unsigned1
3240               && (unsigned0 || !uns))
3241             result_type = c_common_signed_or_unsigned_type
3242               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3243           else if (TREE_CODE (arg0) == INTEGER_CST
3244                    && (unsigned1 || !uns)
3245                    && (TYPE_PRECISION (TREE_TYPE (arg1))
3246                        < TYPE_PRECISION (result_type))
3247                    && (type = c_common_signed_or_unsigned_type
3248                        (unsigned1, TREE_TYPE (arg1)),
3249                        int_fits_type_p (arg0, type)))
3250             result_type = type;
3251           else if (TREE_CODE (arg1) == INTEGER_CST
3252                    && (unsigned0 || !uns)
3253                    && (TYPE_PRECISION (TREE_TYPE (arg0))
3254                        < TYPE_PRECISION (result_type))
3255                    && (type = c_common_signed_or_unsigned_type
3256                        (unsigned0, TREE_TYPE (arg0)),
3257                        int_fits_type_p (arg1, type)))
3258             result_type = type;
3259         }
3260
3261       /* Shifts can be shortened if shifting right.  */
3262
3263       if (short_shift)
3264         {
3265           int unsigned_arg;
3266           tree arg0 = get_narrower (op0, &unsigned_arg);
3267
3268           final_type = result_type;
3269
3270           if (arg0 == op0 && final_type == TREE_TYPE (op0))
3271             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3272
3273           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3274               /* We can shorten only if the shift count is less than the
3275                  number of bits in the smaller type size.  */
3276               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3277               /* If arg is sign-extended and then unsigned-shifted,
3278                  we can simulate this with a signed shift in arg's type
3279                  only if the extended result is at least twice as wide
3280                  as the arg.  Otherwise, the shift could use up all the
3281                  ones made by sign-extension and bring in zeros.
3282                  We can't optimize that case at all, but in most machines
3283                  it never happens because available widths are 2**N.  */
3284               && (!TREE_UNSIGNED (final_type)
3285                   || unsigned_arg
3286                   || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3287                       <= TYPE_PRECISION (result_type))))
3288             {
3289               /* Do an unsigned shift if the operand was zero-extended.  */
3290               result_type
3291                 = c_common_signed_or_unsigned_type (unsigned_arg,
3292                                                     TREE_TYPE (arg0));
3293               /* Convert value-to-be-shifted to that type.  */
3294               if (TREE_TYPE (op0) != result_type)
3295                 op0 = cp_convert (result_type, op0);
3296               converted = 1;
3297             }
3298         }
3299
3300       /* Comparison operations are shortened too but differently.
3301          They identify themselves by setting short_compare = 1.  */
3302
3303       if (short_compare)
3304         {
3305           /* Don't write &op0, etc., because that would prevent op0
3306              from being kept in a register.
3307              Instead, make copies of the our local variables and
3308              pass the copies by reference, then copy them back afterward.  */
3309           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3310           enum tree_code xresultcode = resultcode;
3311           tree val 
3312             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3313           if (val != 0)
3314             return cp_convert (boolean_type_node, val);
3315           op0 = xop0, op1 = xop1;
3316           converted = 1;
3317           resultcode = xresultcode;
3318         }
3319
3320       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3321           && warn_sign_compare
3322           /* Do not warn until the template is instantiated; we cannot
3323              bound the ranges of the arguments until that point.  */
3324           && !processing_template_decl)
3325         {
3326           int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
3327           int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
3328
3329           int unsignedp0, unsignedp1;
3330           tree primop0 = get_narrower (op0, &unsignedp0);
3331           tree primop1 = get_narrower (op1, &unsignedp1);
3332
3333           /* Check for comparison of different enum types.  */
3334           if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE 
3335               && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE 
3336               && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3337                  != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3338             {
3339               warning ("comparison between types `%#T' and `%#T'", 
3340                           TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3341             }
3342
3343           /* Give warnings for comparisons between signed and unsigned
3344              quantities that may fail.  */
3345           /* Do the checking based on the original operand trees, so that
3346              casts will be considered, but default promotions won't be.  */
3347
3348           /* Do not warn if the comparison is being done in a signed type,
3349              since the signed type will only be chosen if it can represent
3350              all the values of the unsigned type.  */
3351           if (! TREE_UNSIGNED (result_type))
3352             /* OK */;
3353           /* Do not warn if both operands are unsigned.  */
3354           else if (op0_signed == op1_signed)
3355             /* OK */;
3356           /* Do not warn if the signed quantity is an unsuffixed
3357              integer literal (or some static constant expression
3358              involving such literals or a conditional expression
3359              involving such literals) and it is non-negative.  */
3360           else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3361                    || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3362             /* OK */;
3363           /* Do not warn if the comparison is an equality operation,
3364              the unsigned quantity is an integral constant and it does
3365              not use the most significant bit of result_type.  */
3366           else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3367                    && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3368                         && int_fits_type_p (orig_op1, c_common_signed_type
3369                                             (result_type)))
3370                         || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3371                             && int_fits_type_p (orig_op0, c_common_signed_type
3372                                                 (result_type)))))
3373             /* OK */;
3374           else
3375             warning ("comparison between signed and unsigned integer expressions");
3376
3377           /* Warn if two unsigned values are being compared in a size
3378              larger than their original size, and one (and only one) is the
3379              result of a `~' operator.  This comparison will always fail.
3380
3381              Also warn if one operand is a constant, and the constant does not
3382              have all bits set that are set in the ~ operand when it is
3383              extended.  */
3384
3385           if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3386               ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3387             {
3388               if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3389                 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3390               if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3391                 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3392               
3393               if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3394                 {
3395                   tree primop;
3396                   HOST_WIDE_INT constant, mask;
3397                   int unsignedp;
3398                   unsigned int bits;
3399
3400                   if (host_integerp (primop0, 0))
3401                     {
3402                       primop = primop1;
3403                       unsignedp = unsignedp1;
3404                       constant = tree_low_cst (primop0, 0);
3405                     }
3406                   else
3407                     {
3408                       primop = primop0;
3409                       unsignedp = unsignedp0;
3410                       constant = tree_low_cst (primop1, 0);
3411                     }
3412
3413                   bits = TYPE_PRECISION (TREE_TYPE (primop));
3414                   if (bits < TYPE_PRECISION (result_type)
3415                       && bits < HOST_BITS_PER_LONG && unsignedp)
3416                     {
3417                       mask = (~ (HOST_WIDE_INT) 0) << bits;
3418                       if ((mask & constant) != mask)
3419                         warning ("comparison of promoted ~unsigned with constant");
3420                     }
3421                 }
3422               else if (unsignedp0 && unsignedp1
3423                        && (TYPE_PRECISION (TREE_TYPE (primop0))
3424                            < TYPE_PRECISION (result_type))
3425                        && (TYPE_PRECISION (TREE_TYPE (primop1))
3426                            < TYPE_PRECISION (result_type)))
3427                 warning ("comparison of promoted ~unsigned with unsigned");
3428             }
3429         }
3430     }
3431
3432   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3433      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3434      Then the expression will be built.
3435      It will be given type FINAL_TYPE if that is nonzero;
3436      otherwise, it will be given type RESULT_TYPE.  */
3437
3438   if (!result_type)
3439     {
3440       error ("invalid operands of types `%T' and `%T' to binary `%O'",
3441                 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3442       return error_mark_node;
3443     }
3444
3445   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3446   if (/* It's reasonable to use pointer values as operands of &&
3447          and ||, so NULL is no exception.  */
3448       !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3449       && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
3450           (orig_op0 == null_node
3451            && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3452           /* Or vice versa.  */
3453           || (orig_op1 == null_node
3454               && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3455           /* Or, both are NULL and the operation was not a comparison.  */
3456           || (orig_op0 == null_node && orig_op1 == null_node 
3457               && code != EQ_EXPR && code != NE_EXPR)))
3458     /* Some sort of arithmetic operation involving NULL was
3459        performed.  Note that pointer-difference and pointer-addition
3460        have already been handled above, and so we don't end up here in
3461        that case.  */
3462     warning ("NULL used in arithmetic");
3463
3464   if (! converted)
3465     {
3466       if (TREE_TYPE (op0) != result_type)
3467         op0 = cp_convert (result_type, op0); 
3468       if (TREE_TYPE (op1) != result_type)
3469         op1 = cp_convert (result_type, op1); 
3470
3471       if (op0 == error_mark_node || op1 == error_mark_node)
3472         return error_mark_node;
3473     }
3474
3475   if (build_type == NULL_TREE)
3476     build_type = result_type;
3477
3478   {
3479     tree result = build (resultcode, build_type, op0, op1);
3480     tree folded;
3481
3482     folded = fold_if_not_in_template (result);
3483     if (folded == result)
3484       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3485     if (final_type != 0)
3486       return cp_convert (final_type, folded);
3487     return folded;
3488   }
3489 }
3490 \f
3491 /* Return a tree for the sum or difference (RESULTCODE says which)
3492    of pointer PTROP and integer INTOP.  */
3493
3494 static tree
3495 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3496 {
3497   tree res_type = TREE_TYPE (ptrop);
3498
3499   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3500      in certain circumstance (when it's valid to do so).  So we need
3501      to make sure it's complete.  We don't need to check here, if we
3502      can actually complete it at all, as those checks will be done in
3503      pointer_int_sum() anyway.  */
3504   complete_type (TREE_TYPE (res_type));
3505
3506   return pointer_int_sum (resultcode, ptrop, fold (intop));
3507 }
3508
3509 /* Return a tree for the difference of pointers OP0 and OP1.
3510    The resulting tree has type int.  */
3511
3512 static tree
3513 pointer_diff (tree op0, tree op1, tree ptrtype)
3514 {
3515   tree result, folded;
3516   tree restype = ptrdiff_type_node;
3517   tree target_type = TREE_TYPE (ptrtype);
3518
3519   if (!complete_type_or_else (target_type, NULL_TREE))
3520     return error_mark_node;
3521
3522   if (pedantic || warn_pointer_arith)
3523     {
3524       if (TREE_CODE (target_type) == VOID_TYPE)
3525         pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
3526       if (TREE_CODE (target_type) == FUNCTION_TYPE)
3527         pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3528       if (TREE_CODE (target_type) == METHOD_TYPE)
3529         pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3530     }
3531
3532   /* First do the subtraction as integers;
3533      then drop through to build the divide operator.  */
3534
3535   op0 = cp_build_binary_op (MINUS_EXPR, 
3536                             cp_convert (restype, op0),
3537                             cp_convert (restype, op1));
3538
3539   /* This generates an error if op1 is a pointer to an incomplete type.  */
3540   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3541     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3542
3543   op1 = (TYPE_PTROB_P (ptrtype) 
3544          ? size_in_bytes (target_type)
3545          : integer_one_node);
3546
3547   /* Do the division.  */
3548
3549   result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3550
3551   folded = fold (result);
3552   if (folded == result)
3553     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3554   return folded;
3555 }
3556 \f
3557 /* Construct and perhaps optimize a tree representation
3558    for a unary operation.  CODE, a tree_code, specifies the operation
3559    and XARG is the operand.  */
3560
3561 tree
3562 build_x_unary_op (enum tree_code code, tree xarg)
3563 {
3564   tree orig_expr = xarg;
3565   tree exp;
3566   int ptrmem = 0;
3567   
3568   if (processing_template_decl)
3569     {
3570       if (type_dependent_expression_p (xarg))
3571         return build_min_nt (code, xarg, NULL_TREE);
3572
3573       xarg = build_non_dependent_expr (xarg);
3574     }
3575
3576   exp = NULL_TREE;
3577
3578   /* [expr.unary.op] says:
3579
3580        The address of an object of incomplete type can be taken.
3581
3582      (And is just the ordinary address operator, not an overloaded
3583      "operator &".)  However, if the type is a template
3584      specialization, we must complete the type at this point so that
3585      an overloaded "operator &" will be available if required.  */
3586   if (code == ADDR_EXPR
3587       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3588       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3589            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3590           || (TREE_CODE (xarg) == OFFSET_REF)))
3591     /* Don't look for a function.  */;
3592   else
3593     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3594                         /*overloaded_p=*/NULL);
3595   if (!exp && code == ADDR_EXPR)
3596     {
3597       /*  A pointer to member-function can be formed only by saying
3598           &X::mf.  */
3599       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3600           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3601         {
3602           if (TREE_CODE (xarg) != OFFSET_REF)
3603             {
3604               error ("invalid use of '%E' to form a pointer-to-member-function.  Use a qualified-id.",
3605                      xarg);
3606               return error_mark_node;
3607             }
3608           else
3609             {
3610               error ("parenthesis around '%E' cannot be used to form a pointer-to-member-function",
3611                      xarg);
3612               PTRMEM_OK_P (xarg) = 1;
3613             }
3614         }
3615       
3616       if (TREE_CODE (xarg) == OFFSET_REF)
3617         {
3618           ptrmem = PTRMEM_OK_P (xarg);
3619           
3620           if (!ptrmem && !flag_ms_extensions
3621               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3622             {
3623               /* A single non-static member, make sure we don't allow a
3624                  pointer-to-member.  */
3625               xarg = build (OFFSET_REF, TREE_TYPE (xarg),
3626                             TREE_OPERAND (xarg, 0),
3627                             ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3628               PTRMEM_OK_P (xarg) = ptrmem;
3629             }         
3630         }
3631       else if (TREE_CODE (xarg) == TARGET_EXPR)
3632         warning ("taking address of temporary");
3633       exp = build_unary_op (ADDR_EXPR, xarg, 0);
3634     }
3635
3636   if (processing_template_decl && exp != error_mark_node)
3637     exp = build_min_non_dep (code, exp, orig_expr,
3638                              /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3639   if (TREE_CODE (exp) == ADDR_EXPR)
3640     PTRMEM_OK_P (exp) = ptrmem;
3641   return exp;
3642 }
3643
3644 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3645    constants, where a null value is represented by an INTEGER_CST of
3646    -1.  */
3647
3648 tree
3649 cp_truthvalue_conversion (tree expr)
3650 {
3651   tree type = TREE_TYPE (expr);
3652   if (TYPE_PTRMEM_P (type))
3653     return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3654   else
3655     return c_common_truthvalue_conversion (expr);
3656 }
3657
3658 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
3659    
3660 tree
3661 condition_conversion (tree expr)
3662 {
3663   tree t;
3664   if (processing_template_decl)
3665     return expr;
3666   t = perform_implicit_conversion (boolean_type_node, expr);
3667   t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
3668   return t;
3669 }
3670                 
3671 /* Return an ADDR_EXPR giving the address of T.  This function
3672    attempts no optimizations or simplifications; it is a low-level
3673    primitive.  */
3674
3675 tree
3676 build_address (tree t)
3677 {
3678   tree addr;
3679
3680   if (error_operand_p (t) || !cxx_mark_addressable (t))
3681     return error_mark_node;
3682
3683   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3684   if (staticp (t))
3685     TREE_CONSTANT (addr) = 1;
3686
3687   return addr;
3688 }
3689
3690 /* Return a NOP_EXPR converting EXPR to TYPE.  */
3691
3692 tree
3693 build_nop (tree type, tree expr)
3694 {
3695   tree nop;
3696
3697   if (type == error_mark_node || error_operand_p (expr))
3698     return expr;
3699     
3700   nop = build1 (NOP_EXPR, type, expr);
3701   if (TREE_CONSTANT (expr))
3702     TREE_CONSTANT (nop) = 1;
3703   
3704   return nop;
3705 }
3706
3707 /* C++: Must handle pointers to members.
3708
3709    Perhaps type instantiation should be extended to handle conversion
3710    from aggregates to types we don't yet know we want?  (Or are those
3711    cases typically errors which should be reported?)
3712
3713    NOCONVERT nonzero suppresses the default promotions
3714    (such as from short to int).  */
3715
3716 tree
3717 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3718 {
3719   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3720   tree arg = xarg;
3721   tree argtype = 0;
3722   const char *errstring = NULL;
3723   tree val;
3724
3725   if (arg == error_mark_node)
3726     return error_mark_node;
3727
3728   switch (code)
3729     {
3730     case CONVERT_EXPR:
3731       /* This is used for unary plus, because a CONVERT_EXPR
3732          is enough to prevent anybody from looking inside for
3733          associativity, but won't generate any code.  */
3734       if (!(arg = build_expr_type_conversion
3735             (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, true)))
3736         errstring = "wrong type argument to unary plus";
3737       else
3738         {
3739           if (!noconvert)
3740            arg = default_conversion (arg);
3741           arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3742           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3743         }
3744       break;
3745
3746     case NEGATE_EXPR:
3747       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3748         errstring = "wrong type argument to unary minus";
3749       else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3750         arg = perform_integral_promotions (arg);
3751       break;
3752
3753     case BIT_NOT_EXPR:
3754       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3755         {
3756           code = CONJ_EXPR;
3757           if (!noconvert)
3758             arg = default_conversion (arg);
3759         }
3760       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3761                                                    arg, true)))
3762         errstring = "wrong type argument to bit-complement";
3763       else if (!noconvert)
3764         arg = perform_integral_promotions (arg);
3765       break;
3766
3767     case ABS_EXPR:
3768       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3769         errstring = "wrong type argument to abs";
3770       else if (!noconvert)
3771         arg = default_conversion (arg);
3772       break;
3773
3774     case CONJ_EXPR:
3775       /* Conjugating a real value is a no-op, but allow it anyway.  */
3776       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3777         errstring = "wrong type argument to conjugation";
3778       else if (!noconvert)
3779         arg = default_conversion (arg);
3780       break;
3781
3782     case TRUTH_NOT_EXPR:
3783       arg = perform_implicit_conversion (boolean_type_node, arg);
3784       val = invert_truthvalue (arg);
3785       if (arg != error_mark_node)
3786         return val;
3787       errstring = "in argument to unary !";
3788       break;
3789
3790     case NOP_EXPR:
3791       break;
3792       
3793     case REALPART_EXPR:
3794       if (TREE_CODE (arg) == COMPLEX_CST)
3795         return TREE_REALPART (arg);
3796       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3797         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3798       else
3799         return arg;
3800
3801     case IMAGPART_EXPR:
3802       if (TREE_CODE (arg) == COMPLEX_CST)
3803         return TREE_IMAGPART (arg);
3804       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3805         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3806       else
3807         return cp_convert (TREE_TYPE (arg), integer_zero_node);
3808       
3809     case PREINCREMENT_EXPR:
3810     case POSTINCREMENT_EXPR:
3811     case PREDECREMENT_EXPR:
3812     case POSTDECREMENT_EXPR:
3813       /* Handle complex lvalues (when permitted)
3814          by reduction to simpler cases.  */
3815
3816       val = unary_complex_lvalue (code, arg);
3817       if (val != 0)
3818         return val;
3819
3820       /* Increment or decrement the real part of the value,
3821          and don't change the imaginary part.  */
3822       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3823         {
3824           tree real, imag;
3825
3826           arg = stabilize_reference (arg);
3827           real = build_unary_op (REALPART_EXPR, arg, 1);
3828           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3829           return build (COMPLEX_EXPR, TREE_TYPE (arg),
3830                         build_unary_op (code, real, 1), imag);
3831         }
3832
3833       /* Report invalid types.  */
3834
3835       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3836                                               arg, true)))
3837         {
3838           if (code == PREINCREMENT_EXPR)
3839             errstring ="no pre-increment operator for type";
3840           else if (code == POSTINCREMENT_EXPR)
3841             errstring ="no post-increment operator for type";
3842           else if (code == PREDECREMENT_EXPR)
3843             errstring ="no pre-decrement operator for type";
3844           else
3845             errstring ="no post-decrement operator for type";
3846           break;
3847         }
3848
3849       /* Report something read-only.  */
3850
3851       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3852           || TREE_READONLY (arg))
3853         readonly_error (arg, ((code == PREINCREMENT_EXPR
3854                                || code == POSTINCREMENT_EXPR)
3855                               ? "increment" : "decrement"),
3856                         0);
3857
3858       {
3859         tree inc;
3860         tree result_type = TREE_TYPE (arg);
3861
3862         arg = get_unwidened (arg, 0);
3863         argtype = TREE_TYPE (arg);
3864
3865         /* ARM $5.2.5 last annotation says this should be forbidden.  */
3866         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3867           pedwarn ("ISO C++ forbids %sing an enum",
3868                    (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3869                    ? "increment" : "decrement");
3870             
3871         /* Compute the increment.  */
3872
3873         if (TREE_CODE (argtype) == POINTER_TYPE)
3874           {
3875             tree type = complete_type (TREE_TYPE (argtype));
3876             
3877             if (!COMPLETE_OR_VOID_TYPE_P (type))
3878               error ("cannot %s a pointer to incomplete type `%T'",
3879                         ((code == PREINCREMENT_EXPR
3880                           || code == POSTINCREMENT_EXPR)
3881                          ? "increment" : "decrement"), TREE_TYPE (argtype));
3882             else if ((pedantic || warn_pointer_arith)
3883                      && !TYPE_PTROB_P (argtype))
3884               pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
3885                           ((code == PREINCREMENT_EXPR
3886                             || code == POSTINCREMENT_EXPR)
3887                            ? "increment" : "decrement"), argtype);
3888             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3889           }
3890         else
3891           inc = integer_one_node;
3892
3893         inc = cp_convert (argtype, inc);
3894
3895         /* Handle incrementing a cast-expression.  */
3896
3897         switch (TREE_CODE (arg))
3898           {
3899           case NOP_EXPR:
3900           case CONVERT_EXPR:
3901           case FLOAT_EXPR:
3902           case FIX_TRUNC_EXPR:
3903           case FIX_FLOOR_EXPR:
3904           case FIX_ROUND_EXPR:
3905           case FIX_CEIL_EXPR:
3906             {
3907               tree incremented, modify, value, compound;
3908               if (! lvalue_p (arg) && pedantic)
3909                 pedwarn ("cast to non-reference type used as lvalue");
3910               arg = stabilize_reference (arg);
3911               if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3912                 value = arg;
3913               else
3914                 value = save_expr (arg);
3915               incremented = build (((code == PREINCREMENT_EXPR
3916                                      || code == POSTINCREMENT_EXPR)
3917                                     ? PLUS_EXPR : MINUS_EXPR),
3918                                    argtype, value, inc);
3919
3920               modify = build_modify_expr (arg, NOP_EXPR, incremented);
3921               compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3922
3923               /* Eliminate warning about unused result of + or -.  */
3924               TREE_NO_UNUSED_WARNING (compound) = 1;
3925               return compound;
3926             }
3927
3928           default:
3929             break;
3930           }
3931
3932         /* Complain about anything else that is not a true lvalue.  */
3933         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3934                                     || code == POSTINCREMENT_EXPR)
3935                                    ? "increment" : "decrement")))
3936           return error_mark_node;
3937
3938         /* Forbid using -- on `bool'.  */
3939         if (TREE_TYPE (arg) == boolean_type_node)
3940           {
3941             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
3942               {
3943                 error ("invalid use of `--' on bool variable `%D'", arg);
3944                 return error_mark_node;
3945               }
3946             val = boolean_increment (code, arg);
3947           }
3948         else
3949           val = build (code, TREE_TYPE (arg), arg, inc);
3950
3951         TREE_SIDE_EFFECTS (val) = 1;
3952         return cp_convert (result_type, val);
3953       }
3954
3955     case ADDR_EXPR:
3956       /* Note that this operation never does default_conversion
3957          regardless of NOCONVERT.  */
3958
3959       argtype = lvalue_type (arg);
3960
3961       if (TREE_CODE (arg) == OFFSET_REF)
3962         goto offset_ref;
3963
3964       if (TREE_CODE (argtype) == REFERENCE_TYPE)
3965         {
3966           arg = build1
3967             (CONVERT_EXPR,
3968              build_pointer_type (TREE_TYPE (argtype)), arg);
3969           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3970           return arg;
3971         }
3972       else if (pedantic && DECL_MAIN_P (arg))
3973         /* ARM $3.4 */
3974         pedwarn ("ISO C++ forbids taking address of function `::main'");
3975
3976       /* Let &* cancel out to simplify resulting code.  */
3977       if (TREE_CODE (arg) == INDIRECT_REF)
3978         {
3979           /* We don't need to have `current_class_ptr' wrapped in a
3980              NON_LVALUE_EXPR node.  */
3981           if (arg == current_class_ref)
3982             return current_class_ptr;
3983
3984           arg = TREE_OPERAND (arg, 0);
3985           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3986             {
3987               arg = build1
3988                 (CONVERT_EXPR,
3989                  build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
3990               TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3991             }
3992           else if (lvalue_p (arg))
3993             /* Don't let this be an lvalue.  */
3994             return non_lvalue (arg);
3995           return arg;
3996         }
3997
3998       /* For &x[y], return x+y.  But, in a template, ARG may be an
3999          ARRAY_REF representing a non-dependent expression.  In that
4000          case, there may be an overloaded "operator []" that will be
4001          chosen at instantiation time; we must not try to optimize
4002          here.  */
4003       if (TREE_CODE (arg) == ARRAY_REF && !processing_template_decl)
4004         {
4005           if (!cxx_mark_addressable (TREE_OPERAND (arg, 0)))
4006             return error_mark_node;
4007           return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4008                                      TREE_OPERAND (arg, 1));
4009         }
4010
4011       /* Uninstantiated types are all functions.  Taking the
4012          address of a function is a no-op, so just return the
4013          argument.  */
4014
4015       if (TREE_CODE (arg) == IDENTIFIER_NODE
4016           && IDENTIFIER_OPNAME_P (arg))
4017         {
4018           abort ();
4019           /* We don't know the type yet, so just work around the problem.
4020              We know that this will resolve to an lvalue.  */
4021           return build1 (ADDR_EXPR, unknown_type_node, arg);
4022         }
4023
4024       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4025           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4026         {
4027           /* They're trying to take the address of a unique non-static
4028              member function.  This is ill-formed (except in MS-land),
4029              but let's try to DTRT.
4030              Note: We only handle unique functions here because we don't
4031              want to complain if there's a static overload; non-unique
4032              cases will be handled by instantiate_type.  But we need to
4033              handle this case here to allow casts on the resulting PMF.
4034              We could defer this in non-MS mode, but it's easier to give
4035              a useful error here.  */
4036
4037           /* Inside constant member functions, the `this' pointer
4038              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4039              is used here to remove this const from the diagnostics
4040              and the created OFFSET_REF.  */
4041           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4042           tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4043
4044           if (! flag_ms_extensions)
4045             {
4046               if (current_class_type
4047                   && TREE_OPERAND (arg, 0) == current_class_ref)
4048                 /* An expression like &memfn.  */
4049                 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4050     &nbs