Upgrade GCC from 4.4.6-RELEASE to 4.4.7 snapshot 2011-10-25
[dragonfly.git] / contrib / gcc-4.4 / gcc / cp / call.c
CommitLineData
c251ad9e
SS
1/* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) and
6 modified by Brendan Kehoe (brendan@cygnus.com).
7
8This file is part of GCC.
9
10GCC is free software; you can redistribute it and/or modify
11it under the terms of the GNU General Public License as published by
12the Free Software Foundation; either version 3, or (at your option)
13any later version.
14
15GCC is distributed in the hope that it will be useful,
16but WITHOUT ANY WARRANTY; without even the implied warranty of
17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18GNU General Public License for more details.
19
20You should have received a copy of the GNU General Public License
21along with GCC; see the file COPYING3. If not see
22<http://www.gnu.org/licenses/>. */
23
24
25/* High-level class interface. */
26
27#include "config.h"
28#include "system.h"
29#include "coretypes.h"
30#include "tm.h"
31#include "tree.h"
32#include "cp-tree.h"
33#include "output.h"
34#include "flags.h"
35#include "rtl.h"
36#include "toplev.h"
37#include "expr.h"
38#include "diagnostic.h"
39#include "intl.h"
40#include "target.h"
41#include "convert.h"
42#include "langhooks.h"
43
44/* The various kinds of conversion. */
45
46typedef enum conversion_kind {
47 ck_identity,
48 ck_lvalue,
49 ck_qual,
50 ck_std,
51 ck_ptr,
52 ck_pmem,
53 ck_base,
54 ck_ref_bind,
55 ck_user,
56 ck_ambig,
57 ck_list,
58 ck_aggr,
59 ck_rvalue
60} conversion_kind;
61
62/* The rank of the conversion. Order of the enumerals matters; better
63 conversions should come earlier in the list. */
64
65typedef enum conversion_rank {
66 cr_identity,
67 cr_exact,
68 cr_promotion,
69 cr_std,
70 cr_pbool,
71 cr_user,
72 cr_ellipsis,
73 cr_bad
74} conversion_rank;
75
76/* An implicit conversion sequence, in the sense of [over.best.ics].
77 The first conversion to be performed is at the end of the chain.
78 That conversion is always a cr_identity conversion. */
79
80typedef struct conversion conversion;
81struct conversion {
82 /* The kind of conversion represented by this step. */
83 conversion_kind kind;
84 /* The rank of this conversion. */
85 conversion_rank rank;
86 BOOL_BITFIELD user_conv_p : 1;
87 BOOL_BITFIELD ellipsis_p : 1;
88 BOOL_BITFIELD this_p : 1;
89 BOOL_BITFIELD bad_p : 1;
90 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
91 temporary should be created to hold the result of the
92 conversion. */
93 BOOL_BITFIELD need_temporary_p : 1;
94 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
95 from a pointer-to-derived to pointer-to-base is being performed. */
96 BOOL_BITFIELD base_p : 1;
97 /* If KIND is ck_ref_bind, true when either an lvalue reference is
98 being bound to an lvalue expression or an rvalue reference is
99 being bound to an rvalue expression. */
100 BOOL_BITFIELD rvaluedness_matches_p: 1;
101 BOOL_BITFIELD check_narrowing: 1;
102 /* The type of the expression resulting from the conversion. */
103 tree type;
104 union {
105 /* The next conversion in the chain. Since the conversions are
106 arranged from outermost to innermost, the NEXT conversion will
107 actually be performed before this conversion. This variant is
108 used only when KIND is neither ck_identity nor ck_ambig. */
109 conversion *next;
110 /* The expression at the beginning of the conversion chain. This
111 variant is used only if KIND is ck_identity or ck_ambig. */
112 tree expr;
113 /* The array of conversions for an initializer_list. */
114 conversion **list;
115 } u;
116 /* The function candidate corresponding to this conversion
117 sequence. This field is only used if KIND is ck_user. */
118 struct z_candidate *cand;
119};
120
121#define CONVERSION_RANK(NODE) \
122 ((NODE)->bad_p ? cr_bad \
123 : (NODE)->ellipsis_p ? cr_ellipsis \
124 : (NODE)->user_conv_p ? cr_user \
125 : (NODE)->rank)
126
127static struct obstack conversion_obstack;
128static bool conversion_obstack_initialized;
129
130static struct z_candidate * tourney (struct z_candidate *);
131static int equal_functions (tree, tree);
132static int joust (struct z_candidate *, struct z_candidate *, bool);
133static int compare_ics (conversion *, conversion *);
134static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
135static tree build_java_interface_fn_ref (tree, tree);
136#define convert_like(CONV, EXPR, COMPLAIN) \
137 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
138 /*issue_conversion_warnings=*/true, \
139 /*c_cast_p=*/false, (COMPLAIN))
140#define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
141 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
142 /*issue_conversion_warnings=*/true, \
143 /*c_cast_p=*/false, (COMPLAIN))
144static tree convert_like_real (conversion *, tree, tree, int, int, bool,
145 bool, tsubst_flags_t);
146static void op_error (enum tree_code, enum tree_code, tree, tree,
147 tree, const char *);
c251ad9e
SS
148static tree resolve_args (tree);
149static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
150static void print_z_candidate (const char *, struct z_candidate *);
151static void print_z_candidates (struct z_candidate *);
152static tree build_this (tree);
153static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
154static bool any_strictly_viable (struct z_candidate *);
155static struct z_candidate *add_template_candidate
156 (struct z_candidate **, tree, tree, tree, tree, tree,
157 tree, tree, int, unification_kind_t);
158static struct z_candidate *add_template_candidate_real
159 (struct z_candidate **, tree, tree, tree, tree, tree,
160 tree, tree, int, tree, unification_kind_t);
161static struct z_candidate *add_template_conv_candidate
162 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
163static void add_builtin_candidates
164 (struct z_candidate **, enum tree_code, enum tree_code,
165 tree, tree *, int);
166static void add_builtin_candidate
167 (struct z_candidate **, enum tree_code, enum tree_code,
168 tree, tree, tree, tree *, tree *, int);
169static bool is_complete (tree);
170static void build_builtin_candidate
171 (struct z_candidate **, tree, tree, tree, tree *, tree *,
172 int);
173static struct z_candidate *add_conv_candidate
174 (struct z_candidate **, tree, tree, tree, tree, tree);
175static struct z_candidate *add_function_candidate
176 (struct z_candidate **, tree, tree, tree, tree, tree, int);
177static conversion *implicit_conversion (tree, tree, tree, bool, int);
178static conversion *standard_conversion (tree, tree, tree, bool, int);
179static conversion *reference_binding (tree, tree, tree, bool, int);
180static conversion *build_conv (conversion_kind, tree, conversion *);
181static conversion *build_list_conv (tree, tree, int);
182static bool is_subseq (conversion *, conversion *);
183static conversion *maybe_handle_ref_bind (conversion **);
184static void maybe_handle_implicit_object (conversion **);
185static struct z_candidate *add_candidate
186 (struct z_candidate **, tree, tree, size_t,
187 conversion **, tree, tree, int);
188static tree source_type (conversion *);
189static void add_warning (struct z_candidate *, struct z_candidate *);
190static bool reference_related_p (tree, tree);
191static bool reference_compatible_p (tree, tree);
192static conversion *convert_class_to_reference (tree, tree, tree);
193static conversion *direct_reference_binding (tree, conversion *);
194static bool promoted_arithmetic_type_p (tree);
195static conversion *conditional_conversion (tree, tree);
196static char *name_as_c_string (tree, tree, bool *);
197static tree call_builtin_trap (void);
198static tree prep_operand (tree);
199static void add_candidates (tree, tree, tree, bool, tree, tree,
200 int, struct z_candidate **);
201static conversion *merge_conversion_sequences (conversion *, conversion *);
202static bool magic_varargs_p (tree);
203static tree build_temp (tree, tree, int, diagnostic_t *);
204
205/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
206 NAME can take many forms... */
207
208bool
209check_dtor_name (tree basetype, tree name)
210{
211 /* Just accept something we've already complained about. */
212 if (name == error_mark_node)
213 return true;
214
215 if (TREE_CODE (name) == TYPE_DECL)
216 name = TREE_TYPE (name);
217 else if (TYPE_P (name))
218 /* OK */;
219 else if (TREE_CODE (name) == IDENTIFIER_NODE)
220 {
221 if ((MAYBE_CLASS_TYPE_P (basetype)
222 && name == constructor_name (basetype))
223 || (TREE_CODE (basetype) == ENUMERAL_TYPE
224 && name == TYPE_IDENTIFIER (basetype)))
225 return true;
226 else
227 name = get_type_value (name);
228 }
229 else
230 {
231 /* In the case of:
232
233 template <class T> struct S { ~S(); };
234 int i;
235 i.~S();
236
237 NAME will be a class template. */
238 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
239 return false;
240 }
241
242 if (!name || name == error_mark_node)
243 return false;
244 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
245}
246
247/* We want the address of a function or method. We avoid creating a
248 pointer-to-member function. */
249
250tree
251build_addr_func (tree function)
252{
253 tree type = TREE_TYPE (function);
254
255 /* We have to do these by hand to avoid real pointer to member
256 functions. */
257 if (TREE_CODE (type) == METHOD_TYPE)
258 {
259 if (TREE_CODE (function) == OFFSET_REF)
260 {
261 tree object = build_address (TREE_OPERAND (function, 0));
262 return get_member_function_from_ptrfunc (&object,
263 TREE_OPERAND (function, 1));
264 }
265 function = build_address (function);
266 }
267 else
268 function = decay_conversion (function);
269
270 return function;
271}
272
273/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
274 POINTER_TYPE to those. Note, pointer to member function types
275 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
276 two variants. build_call_a is the primitive taking an array of
277 arguments, while build_call_n is a wrapper that handles varargs. */
278
279tree
280build_call_n (tree function, int n, ...)
281{
282 if (n == 0)
283 return build_call_a (function, 0, NULL);
284 else
285 {
286 tree *argarray = (tree *) alloca (n * sizeof (tree));
287 va_list ap;
288 int i;
289
290 va_start (ap, n);
291 for (i = 0; i < n; i++)
292 argarray[i] = va_arg (ap, tree);
293 va_end (ap);
294 return build_call_a (function, n, argarray);
295 }
296}
297
298tree
299build_call_a (tree function, int n, tree *argarray)
300{
301 int is_constructor = 0;
302 int nothrow;
303 tree decl;
304 tree result_type;
305 tree fntype;
306 int i;
307
308 function = build_addr_func (function);
309
310 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
311 fntype = TREE_TYPE (TREE_TYPE (function));
312 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
313 || TREE_CODE (fntype) == METHOD_TYPE);
314 result_type = TREE_TYPE (fntype);
315
316 if (TREE_CODE (function) == ADDR_EXPR
317 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
318 {
319 decl = TREE_OPERAND (function, 0);
320 if (!TREE_USED (decl))
321 {
322 /* We invoke build_call directly for several library
323 functions. These may have been declared normally if
324 we're building libgcc, so we can't just check
325 DECL_ARTIFICIAL. */
326 gcc_assert (DECL_ARTIFICIAL (decl)
327 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
328 "__", 2));
329 mark_used (decl);
330 }
331 }
332 else
333 decl = NULL_TREE;
334
335 /* We check both the decl and the type; a function may be known not to
336 throw without being declared throw(). */
337 nothrow = ((decl && TREE_NOTHROW (decl))
338 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
339
340 if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
341 current_function_returns_abnormally = 1;
342
343 if (decl && TREE_DEPRECATED (decl))
344 warn_deprecated_use (decl);
345 require_complete_eh_spec_types (fntype, decl);
346
347 if (decl && DECL_CONSTRUCTOR_P (decl))
348 is_constructor = 1;
349
350 /* Don't pass empty class objects by value. This is useful
351 for tags in STL, which are used to control overload resolution.
352 We don't need to handle other cases of copying empty classes. */
353 if (! decl || ! DECL_BUILT_IN (decl))
354 for (i = 0; i < n; i++)
355 if (is_empty_class (TREE_TYPE (argarray[i]))
356 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
357 {
358 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
359 argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
360 argarray[i], t);
361 }
362
363 function = build_call_array (result_type, function, n, argarray);
364 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
365 TREE_NOTHROW (function) = nothrow;
366
367 return function;
368}
369
370/* Build something of the form ptr->method (args)
371 or object.method (args). This can also build
372 calls to constructors, and find friends.
373
374 Member functions always take their class variable
375 as a pointer.
376
377 INSTANCE is a class instance.
378
379 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
380
381 PARMS help to figure out what that NAME really refers to.
382
383 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
384 down to the real instance type to use for access checking. We need this
385 information to get protected accesses correct.
386
387 FLAGS is the logical disjunction of zero or more LOOKUP_
388 flags. See cp-tree.h for more info.
389
390 If this is all OK, calls build_function_call with the resolved
391 member function.
392
393 This function must also handle being called to perform
394 initialization, promotion/coercion of arguments, and
395 instantiation of default parameters.
396
397 Note that NAME may refer to an instance variable name. If
398 `operator()()' is defined for the type of that field, then we return
399 that result. */
400
401/* New overloading code. */
402
403typedef struct z_candidate z_candidate;
404
405typedef struct candidate_warning candidate_warning;
406struct candidate_warning {
407 z_candidate *loser;
408 candidate_warning *next;
409};
410
411struct z_candidate {
412 /* The FUNCTION_DECL that will be called if this candidate is
413 selected by overload resolution. */
414 tree fn;
415 /* The arguments to use when calling this function. */
416 tree args;
417 /* The implicit conversion sequences for each of the arguments to
418 FN. */
419 conversion **convs;
420 /* The number of implicit conversion sequences. */
421 size_t num_convs;
422 /* If FN is a user-defined conversion, the standard conversion
423 sequence from the type returned by FN to the desired destination
424 type. */
425 conversion *second_conv;
426 int viable;
427 /* If FN is a member function, the binfo indicating the path used to
428 qualify the name of FN at the call site. This path is used to
429 determine whether or not FN is accessible if it is selected by
430 overload resolution. The DECL_CONTEXT of FN will always be a
431 (possibly improper) base of this binfo. */
432 tree access_path;
433 /* If FN is a non-static member function, the binfo indicating the
434 subobject to which the `this' pointer should be converted if FN
435 is selected by overload resolution. The type pointed to the by
436 the `this' pointer must correspond to the most derived class
437 indicated by the CONVERSION_PATH. */
438 tree conversion_path;
439 tree template_decl;
440 candidate_warning *warnings;
441 z_candidate *next;
442};
443
444/* Returns true iff T is a null pointer constant in the sense of
445 [conv.ptr]. */
446
447bool
448null_ptr_cst_p (tree t)
449{
450 /* [conv.ptr]
451
452 A null pointer constant is an integral constant expression
453 (_expr.const_) rvalue of integer type that evaluates to zero. */
454 t = integral_constant_value (t);
455 if (t == null_node)
456 return true;
457 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
458 {
459 STRIP_NOPS (t);
460 if (!TREE_OVERFLOW (t))
461 return true;
462 }
463 return false;
464}
465
466/* Returns nonzero if PARMLIST consists of only default parms and/or
467 ellipsis. */
468
469bool
470sufficient_parms_p (const_tree parmlist)
471{
472 for (; parmlist && parmlist != void_list_node;
473 parmlist = TREE_CHAIN (parmlist))
474 if (!TREE_PURPOSE (parmlist))
475 return false;
476 return true;
477}
478
479/* Allocate N bytes of memory from the conversion obstack. The memory
480 is zeroed before being returned. */
481
482static void *
483conversion_obstack_alloc (size_t n)
484{
485 void *p;
486 if (!conversion_obstack_initialized)
487 {
488 gcc_obstack_init (&conversion_obstack);
489 conversion_obstack_initialized = true;
490 }
491 p = obstack_alloc (&conversion_obstack, n);
492 memset (p, 0, n);
493 return p;
494}
495
496/* Dynamically allocate a conversion. */
497
498static conversion *
499alloc_conversion (conversion_kind kind)
500{
501 conversion *c;
502 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
503 c->kind = kind;
504 return c;
505}
506
507#ifdef ENABLE_CHECKING
508
509/* Make sure that all memory on the conversion obstack has been
510 freed. */
511
512void
513validate_conversion_obstack (void)
514{
515 if (conversion_obstack_initialized)
516 gcc_assert ((obstack_next_free (&conversion_obstack)
517 == obstack_base (&conversion_obstack)));
518}
519
520#endif /* ENABLE_CHECKING */
521
522/* Dynamically allocate an array of N conversions. */
523
524static conversion **
525alloc_conversions (size_t n)
526{
527 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
528}
529
530static conversion *
531build_conv (conversion_kind code, tree type, conversion *from)
532{
533 conversion *t;
534 conversion_rank rank = CONVERSION_RANK (from);
535
536 /* Note that the caller is responsible for filling in t->cand for
537 user-defined conversions. */
538 t = alloc_conversion (code);
539 t->type = type;
540 t->u.next = from;
541
542 switch (code)
543 {
544 case ck_ptr:
545 case ck_pmem:
546 case ck_base:
547 case ck_std:
548 if (rank < cr_std)
549 rank = cr_std;
550 break;
551
552 case ck_qual:
553 if (rank < cr_exact)
554 rank = cr_exact;
555 break;
556
557 default:
558 break;
559 }
560 t->rank = rank;
561 t->user_conv_p = (code == ck_user || from->user_conv_p);
562 t->bad_p = from->bad_p;
563 t->base_p = false;
564 return t;
565}
566
567/* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
568 specialization of std::initializer_list<T>, if such a conversion is
569 possible. */
570
571static conversion *
572build_list_conv (tree type, tree ctor, int flags)
573{
574 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
575 unsigned len = CONSTRUCTOR_NELTS (ctor);
576 conversion **subconvs = alloc_conversions (len);
577 conversion *t;
578 unsigned i;
579 tree val;
580
581 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
582 {
583 conversion *sub
584 = implicit_conversion (elttype, TREE_TYPE (val), val,
585 false, flags);
586 if (sub == NULL)
587 return NULL;
588
589 subconvs[i] = sub;
590 }
591
592 t = alloc_conversion (ck_list);
593 t->type = type;
594 t->u.list = subconvs;
595 t->rank = cr_exact;
596
597 for (i = 0; i < len; ++i)
598 {
599 conversion *sub = subconvs[i];
600 if (sub->rank > t->rank)
601 t->rank = sub->rank;
602 if (sub->user_conv_p)
603 t->user_conv_p = true;
604 if (sub->bad_p)
605 t->bad_p = true;
606 }
607
608 return t;
609}
610
611/* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
612 aggregate class, if such a conversion is possible. */
613
614static conversion *
615build_aggr_conv (tree type, tree ctor, int flags)
616{
617 unsigned HOST_WIDE_INT i = 0;
618 conversion *c;
619 tree field = TYPE_FIELDS (type);
620
621 for (; field; field = TREE_CHAIN (field), ++i)
622 {
623 if (TREE_CODE (field) != FIELD_DECL)
624 continue;
625 if (i < CONSTRUCTOR_NELTS (ctor))
626 {
627 constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);
628 if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),
629 ce->value, flags))
630 return NULL;
631 }
632 else if (build_value_init (TREE_TYPE (field)) == error_mark_node)
633 return NULL;
634 }
635
636 c = alloc_conversion (ck_aggr);
637 c->type = type;
638 c->rank = cr_exact;
639 c->user_conv_p = true;
640 c->u.next = NULL;
641 return c;
642}
643
644/* Build a representation of the identity conversion from EXPR to
645 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
646
647static conversion *
648build_identity_conv (tree type, tree expr)
649{
650 conversion *c;
651
652 c = alloc_conversion (ck_identity);
653 c->type = type;
654 c->u.expr = expr;
655
656 return c;
657}
658
659/* Converting from EXPR to TYPE was ambiguous in the sense that there
660 were multiple user-defined conversions to accomplish the job.
661 Build a conversion that indicates that ambiguity. */
662
663static conversion *
664build_ambiguous_conv (tree type, tree expr)
665{
666 conversion *c;
667
668 c = alloc_conversion (ck_ambig);
669 c->type = type;
670 c->u.expr = expr;
671
672 return c;
673}
674
675tree
676strip_top_quals (tree t)
677{
678 if (TREE_CODE (t) == ARRAY_TYPE)
679 return t;
680 return cp_build_qualified_type (t, 0);
681}
682
683/* Returns the standard conversion path (see [conv]) from type FROM to type
684 TO, if any. For proper handling of null pointer constants, you must
685 also pass the expression EXPR to convert from. If C_CAST_P is true,
686 this conversion is coming from a C-style cast. */
687
688static conversion *
689standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
690 int flags)
691{
692 enum tree_code fcode, tcode;
693 conversion *conv;
694 bool fromref = false;
695
696 to = non_reference (to);
697 if (TREE_CODE (from) == REFERENCE_TYPE)
698 {
699 fromref = true;
700 from = TREE_TYPE (from);
701 }
702 to = strip_top_quals (to);
703 from = strip_top_quals (from);
704
705 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
706 && expr && type_unknown_p (expr))
707 {
708 tsubst_flags_t tflags = tf_conv;
709 if (!(flags & LOOKUP_PROTECT))
710 tflags |= tf_no_access_control;
711 expr = instantiate_type (to, expr, tflags);
712 if (expr == error_mark_node)
713 return NULL;
714 from = TREE_TYPE (expr);
715 }
716
717 fcode = TREE_CODE (from);
718 tcode = TREE_CODE (to);
719
720 conv = build_identity_conv (from, expr);
721 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
722 {
723 from = type_decays_to (from);
724 fcode = TREE_CODE (from);
725 conv = build_conv (ck_lvalue, from, conv);
726 }
727 else if (fromref || (expr && lvalue_p (expr)))
728 {
729 if (expr)
730 {
731 tree bitfield_type;
732 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
733 if (bitfield_type)
734 {
735 from = strip_top_quals (bitfield_type);
736 fcode = TREE_CODE (from);
737 }
738 }
739 conv = build_conv (ck_rvalue, from, conv);
740 }
741
742 /* Allow conversion between `__complex__' data types. */
743 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
744 {
745 /* The standard conversion sequence to convert FROM to TO is
746 the standard conversion sequence to perform componentwise
747 conversion. */
748 conversion *part_conv = standard_conversion
749 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
750
751 if (part_conv)
752 {
753 conv = build_conv (part_conv->kind, to, conv);
754 conv->rank = part_conv->rank;
755 }
756 else
757 conv = NULL;
758
759 return conv;
760 }
761
762 if (same_type_p (from, to))
763 return conv;
764
765 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
766 && expr && null_ptr_cst_p (expr))
767 conv = build_conv (ck_std, to, conv);
768 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
769 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
770 {
771 /* For backwards brain damage compatibility, allow interconversion of
772 pointers and integers with a pedwarn. */
773 conv = build_conv (ck_std, to, conv);
774 conv->bad_p = true;
775 }
776 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
777 {
778 /* For backwards brain damage compatibility, allow interconversion of
779 enums and integers with a pedwarn. */
780 conv = build_conv (ck_std, to, conv);
781 conv->bad_p = true;
782 }
783 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
784 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
785 {
786 tree to_pointee;
787 tree from_pointee;
788
789 if (tcode == POINTER_TYPE
790 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
791 TREE_TYPE (to)))
792 ;
793 else if (VOID_TYPE_P (TREE_TYPE (to))
794 && !TYPE_PTRMEM_P (from)
795 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
796 {
797 from = build_pointer_type
798 (cp_build_qualified_type (void_type_node,
799 cp_type_quals (TREE_TYPE (from))));
800 conv = build_conv (ck_ptr, from, conv);
801 }
802 else if (TYPE_PTRMEM_P (from))
803 {
804 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
805 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
806
807 if (DERIVED_FROM_P (fbase, tbase)
808 && (same_type_ignoring_top_level_qualifiers_p
809 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
810 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
811 {
812 from = build_ptrmem_type (tbase,
813 TYPE_PTRMEM_POINTED_TO_TYPE (from));
814 conv = build_conv (ck_pmem, from, conv);
815 }
816 else if (!same_type_p (fbase, tbase))
817 return NULL;
818 }
819 else if (CLASS_TYPE_P (TREE_TYPE (from))
820 && CLASS_TYPE_P (TREE_TYPE (to))
821 /* [conv.ptr]
822
823 An rvalue of type "pointer to cv D," where D is a
824 class type, can be converted to an rvalue of type
825 "pointer to cv B," where B is a base class (clause
826 _class.derived_) of D. If B is an inaccessible
827 (clause _class.access_) or ambiguous
828 (_class.member.lookup_) base class of D, a program
829 that necessitates this conversion is ill-formed.
830 Therefore, we use DERIVED_FROM_P, and do not check
831 access or uniqueness. */
832 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
833 {
834 from =
835 cp_build_qualified_type (TREE_TYPE (to),
836 cp_type_quals (TREE_TYPE (from)));
837 from = build_pointer_type (from);
838 conv = build_conv (ck_ptr, from, conv);
839 conv->base_p = true;
840 }
841
842 if (tcode == POINTER_TYPE)
843 {
844 to_pointee = TREE_TYPE (to);
845 from_pointee = TREE_TYPE (from);
846 }
847 else
848 {
849 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
850 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
851 }
852
853 if (same_type_p (from, to))
854 /* OK */;
855 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
856 /* In a C-style cast, we ignore CV-qualification because we
857 are allowed to perform a static_cast followed by a
858 const_cast. */
859 conv = build_conv (ck_qual, to, conv);
860 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
861 conv = build_conv (ck_qual, to, conv);
862 else if (expr && string_conv_p (to, expr, 0))
863 /* converting from string constant to char *. */
864 conv = build_conv (ck_qual, to, conv);
865 else if (ptr_reasonably_similar (to_pointee, from_pointee))
866 {
867 conv = build_conv (ck_ptr, to, conv);
868 conv->bad_p = true;
869 }
870 else
871 return NULL;
872
873 from = to;
874 }
875 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
876 {
877 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
878 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
879 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
880 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
881
882 if (!DERIVED_FROM_P (fbase, tbase)
883 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
884 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
885 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
886 || cp_type_quals (fbase) != cp_type_quals (tbase))
887 return NULL;
888
4b1e227d 889 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
c251ad9e
SS
890 from = build_ptrmemfunc_type (build_pointer_type (from));
891 conv = build_conv (ck_pmem, from, conv);
892 conv->base_p = true;
893 }
894 else if (tcode == BOOLEAN_TYPE)
895 {
896 /* [conv.bool]
897
898 An rvalue of arithmetic, unscoped enumeration, pointer, or
899 pointer to member type can be converted to an rvalue of type
900 bool. */
901 if (ARITHMETIC_TYPE_P (from)
902 || UNSCOPED_ENUM_P (from)
903 || fcode == POINTER_TYPE
904 || TYPE_PTR_TO_MEMBER_P (from))
905 {
906 conv = build_conv (ck_std, to, conv);
907 if (fcode == POINTER_TYPE
908 || TYPE_PTRMEM_P (from)
909 || (TYPE_PTRMEMFUNC_P (from)
910 && conv->rank < cr_pbool))
911 conv->rank = cr_pbool;
912 return conv;
913 }
914
915 return NULL;
916 }
917 /* We don't check for ENUMERAL_TYPE here because there are no standard
918 conversions to enum type. */
919 /* As an extension, allow conversion to complex type. */
920 else if (ARITHMETIC_TYPE_P (to))
921 {
922 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
923 || SCOPED_ENUM_P (from))
924 return NULL;
925 conv = build_conv (ck_std, to, conv);
926
927 /* Give this a better rank if it's a promotion. */
928 if (same_type_p (to, type_promotes_to (from))
929 && conv->u.next->rank <= cr_promotion)
930 conv->rank = cr_promotion;
931 }
932 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
933 && vector_types_convertible_p (from, to, false))
934 return build_conv (ck_std, to, conv);
935 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
936 && is_properly_derived_from (from, to))
937 {
938 if (conv->kind == ck_rvalue)
939 conv = conv->u.next;
940 conv = build_conv (ck_base, to, conv);
941 /* The derived-to-base conversion indicates the initialization
942 of a parameter with base type from an object of a derived
943 type. A temporary object is created to hold the result of
944 the conversion unless we're binding directly to a reference. */
945 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
946 }
947 else
948 return NULL;
949
950 if (flags & LOOKUP_NO_NARROWING)
951 conv->check_narrowing = true;
952
953 return conv;
954}
955
956/* Returns nonzero if T1 is reference-related to T2. */
957
958static bool
959reference_related_p (tree t1, tree t2)
960{
961 t1 = TYPE_MAIN_VARIANT (t1);
962 t2 = TYPE_MAIN_VARIANT (t2);
963
964 /* [dcl.init.ref]
965
966 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
967 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
968 of T2. */
969 return (same_type_p (t1, t2)
970 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
971 && DERIVED_FROM_P (t1, t2)));
972}
973
974/* Returns nonzero if T1 is reference-compatible with T2. */
975
976static bool
977reference_compatible_p (tree t1, tree t2)
978{
979 /* [dcl.init.ref]
980
981 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
982 reference-related to T2 and cv1 is the same cv-qualification as,
983 or greater cv-qualification than, cv2. */
984 return (reference_related_p (t1, t2)
985 && at_least_as_qualified_p (t1, t2));
986}
987
988/* Determine whether or not the EXPR (of class type S) can be
989 converted to T as in [over.match.ref]. */
990
991static conversion *
992convert_class_to_reference (tree reference_type, tree s, tree expr)
993{
994 tree conversions;
995 tree arglist;
996 conversion *conv;
997 tree t;
998 struct z_candidate *candidates;
999 struct z_candidate *cand;
1000 bool any_viable_p;
1001
1002 conversions = lookup_conversions (s);
1003 if (!conversions)
1004 return NULL;
1005
1006 /* [over.match.ref]
1007
1008 Assuming that "cv1 T" is the underlying type of the reference
1009 being initialized, and "cv S" is the type of the initializer
1010 expression, with S a class type, the candidate functions are
1011 selected as follows:
1012
1013 --The conversion functions of S and its base classes are
1014 considered. Those that are not hidden within S and yield type
1015 "reference to cv2 T2", where "cv1 T" is reference-compatible
1016 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1017
1018 The argument list has one argument, which is the initializer
1019 expression. */
1020
1021 candidates = 0;
1022
1023 /* Conceptually, we should take the address of EXPR and put it in
1024 the argument list. Unfortunately, however, that can result in
1025 error messages, which we should not issue now because we are just
1026 trying to find a conversion operator. Therefore, we use NULL,
1027 cast to the appropriate type. */
1028 arglist = build_int_cst (build_pointer_type (s), 0);
1029 arglist = build_tree_list (NULL_TREE, arglist);
1030
1031 t = TREE_TYPE (reference_type);
1032
1033 while (conversions)
1034 {
1035 tree fns = TREE_VALUE (conversions);
1036
1037 for (; fns; fns = OVL_NEXT (fns))
1038 {
1039 tree f = OVL_CURRENT (fns);
1040 tree t2 = TREE_TYPE (TREE_TYPE (f));
1041
1042 cand = NULL;
1043
1044 /* If this is a template function, try to get an exact
1045 match. */
1046 if (TREE_CODE (f) == TEMPLATE_DECL)
1047 {
1048 cand = add_template_candidate (&candidates,
1049 f, s,
1050 NULL_TREE,
1051 arglist,
1052 reference_type,
1053 TYPE_BINFO (s),
1054 TREE_PURPOSE (conversions),
1055 LOOKUP_NORMAL,
1056 DEDUCE_CONV);
1057
1058 if (cand)
1059 {
1060 /* Now, see if the conversion function really returns
1061 an lvalue of the appropriate type. From the
1062 point of view of unification, simply returning an
1063 rvalue of the right type is good enough. */
1064 f = cand->fn;
1065 t2 = TREE_TYPE (TREE_TYPE (f));
1066 if (TREE_CODE (t2) != REFERENCE_TYPE
1067 || !reference_compatible_p (t, TREE_TYPE (t2)))
1068 {
1069 candidates = candidates->next;
1070 cand = NULL;
1071 }
1072 }
1073 }
1074 else if (TREE_CODE (t2) == REFERENCE_TYPE
1075 && reference_compatible_p (t, TREE_TYPE (t2)))
1076 cand = add_function_candidate (&candidates, f, s, arglist,
1077 TYPE_BINFO (s),
1078 TREE_PURPOSE (conversions),
1079 LOOKUP_NORMAL);
1080
1081 if (cand)
1082 {
1083 conversion *identity_conv;
1084 /* Build a standard conversion sequence indicating the
1085 binding from the reference type returned by the
1086 function to the desired REFERENCE_TYPE. */
1087 identity_conv
1088 = build_identity_conv (TREE_TYPE (TREE_TYPE
1089 (TREE_TYPE (cand->fn))),
1090 NULL_TREE);
1091 cand->second_conv
1092 = (direct_reference_binding
1093 (reference_type, identity_conv));
1094 cand->second_conv->rvaluedness_matches_p
1095 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1096 == TYPE_REF_IS_RVALUE (reference_type);
1097 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1098 }
1099 }
1100 conversions = TREE_CHAIN (conversions);
1101 }
1102
1103 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1104 /* If none of the conversion functions worked out, let our caller
1105 know. */
1106 if (!any_viable_p)
1107 return NULL;
1108
1109 cand = tourney (candidates);
1110 if (!cand)
1111 return NULL;
1112
1113 /* Now that we know that this is the function we're going to use fix
1114 the dummy first argument. */
1115 cand->args = tree_cons (NULL_TREE,
1116 build_this (expr),
1117 TREE_CHAIN (cand->args));
1118
1119 /* Build a user-defined conversion sequence representing the
1120 conversion. */
1121 conv = build_conv (ck_user,
1122 TREE_TYPE (TREE_TYPE (cand->fn)),
1123 build_identity_conv (TREE_TYPE (expr), expr));
1124 conv->cand = cand;
1125
1126 /* Merge it with the standard conversion sequence from the
1127 conversion function's return type to the desired type. */
1128 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1129
1130 if (cand->viable == -1)
1131 conv->bad_p = true;
1132
1133 return cand->second_conv;
1134}
1135
1136/* A reference of the indicated TYPE is being bound directly to the
1137 expression represented by the implicit conversion sequence CONV.
1138 Return a conversion sequence for this binding. */
1139
1140static conversion *
1141direct_reference_binding (tree type, conversion *conv)
1142{
1143 tree t;
1144
1145 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1146 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1147
1148 t = TREE_TYPE (type);
1149
1150 /* [over.ics.rank]
1151
1152 When a parameter of reference type binds directly
1153 (_dcl.init.ref_) to an argument expression, the implicit
1154 conversion sequence is the identity conversion, unless the
1155 argument expression has a type that is a derived class of the
1156 parameter type, in which case the implicit conversion sequence is
1157 a derived-to-base Conversion.
1158
1159 If the parameter binds directly to the result of applying a
1160 conversion function to the argument expression, the implicit
1161 conversion sequence is a user-defined conversion sequence
1162 (_over.ics.user_), with the second standard conversion sequence
1163 either an identity conversion or, if the conversion function
1164 returns an entity of a type that is a derived class of the
1165 parameter type, a derived-to-base conversion. */
1166 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1167 {
1168 /* Represent the derived-to-base conversion. */
1169 conv = build_conv (ck_base, t, conv);
1170 /* We will actually be binding to the base-class subobject in
1171 the derived class, so we mark this conversion appropriately.
1172 That way, convert_like knows not to generate a temporary. */
1173 conv->need_temporary_p = false;
1174 }
1175 return build_conv (ck_ref_bind, type, conv);
1176}
1177
1178/* Returns the conversion path from type FROM to reference type TO for
1179 purposes of reference binding. For lvalue binding, either pass a
1180 reference type to FROM or an lvalue expression to EXPR. If the
1181 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1182 the conversion returned. If C_CAST_P is true, this
1183 conversion is coming from a C-style cast. */
1184
1185static conversion *
1186reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1187{
1188 conversion *conv = NULL;
1189 tree to = TREE_TYPE (rto);
1190 tree from = rfrom;
1191 tree tfrom;
1192 bool related_p;
1193 bool compatible_p;
1194 cp_lvalue_kind lvalue_p = clk_none;
1195
1196 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1197 {
1198 expr = instantiate_type (to, expr, tf_none);
1199 if (expr == error_mark_node)
1200 return NULL;
1201 from = TREE_TYPE (expr);
1202 }
1203
1204 if (TREE_CODE (from) == REFERENCE_TYPE)
1205 {
1206 /* Anything with reference type is an lvalue. */
1207 lvalue_p = clk_ordinary;
1208 from = TREE_TYPE (from);
1209 }
dff90b41
SS
1210
1211 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1212 {
1213 maybe_warn_cpp0x ("extended initializer lists");
1214 conv = implicit_conversion (to, from, expr, c_cast_p,
1215 flags);
1216 if (!CLASS_TYPE_P (to)
1217 && CONSTRUCTOR_NELTS (expr) == 1)
1218 {
1219 expr = CONSTRUCTOR_ELT (expr, 0)->value;
4b1e227d
SW
1220 if (error_operand_p (expr))
1221 return NULL;
dff90b41
SS
1222 from = TREE_TYPE (expr);
1223 }
1224 }
1225
1226 if (lvalue_p == clk_none && expr)
c251ad9e
SS
1227 lvalue_p = real_lvalue_p (expr);
1228
1229 tfrom = from;
1230 if ((lvalue_p & clk_bitfield) != 0)
1231 tfrom = unlowered_expr_type (expr);
1232
1233 /* Figure out whether or not the types are reference-related and
1234 reference compatible. We have do do this after stripping
1235 references from FROM. */
1236 related_p = reference_related_p (to, tfrom);
1237 /* If this is a C cast, first convert to an appropriately qualified
1238 type, so that we can later do a const_cast to the desired type. */
1239 if (related_p && c_cast_p
1240 && !at_least_as_qualified_p (to, tfrom))
1241 to = build_qualified_type (to, cp_type_quals (tfrom));
1242 compatible_p = reference_compatible_p (to, tfrom);
1243
1244 /* Directly bind reference when target expression's type is compatible with
1245 the reference and expression is an lvalue. In DR391, the wording in
1246 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1247 const and rvalue references to rvalues of compatible class type. */
1248 if (compatible_p
1249 && (lvalue_p
1250 || (!(flags & LOOKUP_NO_TEMP_BIND)
1251 && (CP_TYPE_CONST_NON_VOLATILE_P(to) || TYPE_REF_IS_RVALUE (rto))
1252 && CLASS_TYPE_P (from))))
1253 {
1254 /* [dcl.init.ref]
1255
1256 If the initializer expression
1257
1258 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1259 is reference-compatible with "cv2 T2,"
1260
1261 the reference is bound directly to the initializer expression
1262 lvalue.
1263
1264 [...]
1265 If the initializer expression is an rvalue, with T2 a class type,
1266 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1267 is bound to the object represented by the rvalue or to a sub-object
1268 within that object. */
1269
1270 conv = build_identity_conv (tfrom, expr);
1271 conv = direct_reference_binding (rto, conv);
1272
1273 if (flags & LOOKUP_PREFER_RVALUE)
1274 /* The top-level caller requested that we pretend that the lvalue
1275 be treated as an rvalue. */
1276 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1277 else
1278 conv->rvaluedness_matches_p
1279 = (TYPE_REF_IS_RVALUE (rto) == !lvalue_p);
1280
1281 if ((lvalue_p & clk_bitfield) != 0
1282 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1283 /* For the purposes of overload resolution, we ignore the fact
1284 this expression is a bitfield or packed field. (In particular,
1285 [over.ics.ref] says specifically that a function with a
1286 non-const reference parameter is viable even if the
1287 argument is a bitfield.)
1288
1289 However, when we actually call the function we must create
1290 a temporary to which to bind the reference. If the
1291 reference is volatile, or isn't const, then we cannot make
1292 a temporary, so we just issue an error when the conversion
1293 actually occurs. */
1294 conv->need_temporary_p = true;
1295
1296 return conv;
1297 }
1298 /* [class.conv.fct] A conversion function is never used to convert a
1299 (possibly cv-qualified) object to the (possibly cv-qualified) same
1300 object type (or a reference to it), to a (possibly cv-qualified) base
1301 class of that type (or a reference to it).... */
1302 else if (CLASS_TYPE_P (from) && !related_p
1303 && !(flags & LOOKUP_NO_CONVERSION))
1304 {
1305 /* [dcl.init.ref]
1306
1307 If the initializer expression
1308
1309 -- has a class type (i.e., T2 is a class type) can be
1310 implicitly converted to an lvalue of type "cv3 T3," where
1311 "cv1 T1" is reference-compatible with "cv3 T3". (this
1312 conversion is selected by enumerating the applicable
1313 conversion functions (_over.match.ref_) and choosing the
1314 best one through overload resolution. (_over.match_).
1315
1316 the reference is bound to the lvalue result of the conversion
1317 in the second case. */
1318 conv = convert_class_to_reference (rto, from, expr);
1319 if (conv)
1320 return conv;
1321 }
1322
1323 /* From this point on, we conceptually need temporaries, even if we
1324 elide them. Only the cases above are "direct bindings". */
1325 if (flags & LOOKUP_NO_TEMP_BIND)
1326 return NULL;
1327
1328 /* [over.ics.rank]
1329
1330 When a parameter of reference type is not bound directly to an
1331 argument expression, the conversion sequence is the one required
1332 to convert the argument expression to the underlying type of the
1333 reference according to _over.best.ics_. Conceptually, this
1334 conversion sequence corresponds to copy-initializing a temporary
1335 of the underlying type with the argument expression. Any
1336 difference in top-level cv-qualification is subsumed by the
1337 initialization itself and does not constitute a conversion. */
1338
1339 /* [dcl.init.ref]
1340
1341 Otherwise, the reference shall be to a non-volatile const type.
1342
1343 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1344 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1345 return NULL;
1346
1347 /* [dcl.init.ref]
1348
1349 Otherwise, a temporary of type "cv1 T1" is created and
1350 initialized from the initializer expression using the rules for a
1351 non-reference copy initialization. If T1 is reference-related to
1352 T2, cv1 must be the same cv-qualification as, or greater
1353 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1354 if (related_p && !at_least_as_qualified_p (to, from))
1355 return NULL;
1356
1357 /* We're generating a temporary now, but don't bind any more in the
1358 conversion (specifically, don't slice the temporary returned by a
1359 conversion operator). */
1360 flags |= LOOKUP_NO_TEMP_BIND;
1361
dff90b41
SS
1362 if (!conv)
1363 conv = implicit_conversion (to, from, expr, c_cast_p,
1364 flags);
c251ad9e
SS
1365 if (!conv)
1366 return NULL;
1367
1368 conv = build_conv (ck_ref_bind, rto, conv);
1369 /* This reference binding, unlike those above, requires the
1370 creation of a temporary. */
1371 conv->need_temporary_p = true;
1372 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1373
1374 return conv;
1375}
1376
1377/* Returns the implicit conversion sequence (see [over.ics]) from type
1378 FROM to type TO. The optional expression EXPR may affect the
1379 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1380 true, this conversion is coming from a C-style cast. */
1381
1382static conversion *
1383implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1384 int flags)
1385{
1386 conversion *conv;
1387
1388 if (from == error_mark_node || to == error_mark_node
1389 || expr == error_mark_node)
1390 return NULL;
1391
1392 if (TREE_CODE (to) == REFERENCE_TYPE)
1393 conv = reference_binding (to, from, expr, c_cast_p, flags);
1394 else
1395 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1396
1397 if (conv)
1398 return conv;
1399
1400 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1401 {
1402 if (is_std_init_list (to))
1403 return build_list_conv (to, expr, flags);
1404
1405 /* Allow conversion from an initializer-list with one element to a
1406 scalar type. */
1407 if (SCALAR_TYPE_P (to))
1408 {
1409 int nelts = CONSTRUCTOR_NELTS (expr);
1410 tree elt;
1411
1412 if (nelts == 0)
1413 elt = integer_zero_node;
1414 else if (nelts == 1)
1415 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1416 else
1417 elt = error_mark_node;
1418
1419 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1420 c_cast_p, flags);
1421 if (conv)
1422 {
1423 conv->check_narrowing = true;
1424 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1425 /* Too many levels of braces, i.e. '{{1}}'. */
1426 conv->bad_p = true;
1427 return conv;
1428 }
1429 }
1430 }
1431
1432 if (expr != NULL_TREE
1433 && (MAYBE_CLASS_TYPE_P (from)
1434 || MAYBE_CLASS_TYPE_P (to))
1435 && (flags & LOOKUP_NO_CONVERSION) == 0)
1436 {
1437 struct z_candidate *cand;
1438 int convflags = ((flags & LOOKUP_NO_TEMP_BIND)
1439 |LOOKUP_ONLYCONVERTING);
1440
1441 if (CLASS_TYPE_P (to)
1442 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1443 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1444 return build_aggr_conv (to, expr, flags);
1445
1446 cand = build_user_type_conversion_1 (to, expr, convflags);
1447 if (cand)
1448 conv = cand->second_conv;
1449
1450 /* We used to try to bind a reference to a temporary here, but that
1451 is now handled after the recursive call to this function at the end
1452 of reference_binding. */
1453 return conv;
1454 }
1455
1456 return NULL;
1457}
1458
1459/* Add a new entry to the list of candidates. Used by the add_*_candidate
1460 functions. */
1461
1462static struct z_candidate *
1463add_candidate (struct z_candidate **candidates,
1464 tree fn, tree args,
1465 size_t num_convs, conversion **convs,
1466 tree access_path, tree conversion_path,
1467 int viable)
1468{
1469 struct z_candidate *cand = (struct z_candidate *)
1470 conversion_obstack_alloc (sizeof (struct z_candidate));
1471
1472 cand->fn = fn;
1473 cand->args = args;
1474 cand->convs = convs;
1475 cand->num_convs = num_convs;
1476 cand->access_path = access_path;
1477 cand->conversion_path = conversion_path;
1478 cand->viable = viable;
1479 cand->next = *candidates;
1480 *candidates = cand;
1481
1482 return cand;
1483}
1484
1485/* Create an overload candidate for the function or method FN called with
1486 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1487 to implicit_conversion.
1488
1489 CTYPE, if non-NULL, is the type we want to pretend this function
1490 comes from for purposes of overload resolution. */
1491
1492static struct z_candidate *
1493add_function_candidate (struct z_candidate **candidates,
1494 tree fn, tree ctype, tree arglist,
1495 tree access_path, tree conversion_path,
1496 int flags)
1497{
1498 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1499 int i, len;
1500 conversion **convs;
1501 tree parmnode, argnode;
1502 tree orig_arglist;
1503 int viable = 1;
1504
1505 /* At this point we should not see any functions which haven't been
1506 explicitly declared, except for friend functions which will have
1507 been found using argument dependent lookup. */
1508 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1509
1510 /* The `this', `in_chrg' and VTT arguments to constructors are not
1511 considered in overload resolution. */
1512 if (DECL_CONSTRUCTOR_P (fn))
1513 {
1514 parmlist = skip_artificial_parms_for (fn, parmlist);
1515 orig_arglist = arglist;
1516 arglist = skip_artificial_parms_for (fn, arglist);
1517 }
1518 else
1519 orig_arglist = arglist;
1520
1521 len = list_length (arglist);
1522 convs = alloc_conversions (len);
1523
1524 /* 13.3.2 - Viable functions [over.match.viable]
1525 First, to be a viable function, a candidate function shall have enough
1526 parameters to agree in number with the arguments in the list.
1527
1528 We need to check this first; otherwise, checking the ICSes might cause
1529 us to produce an ill-formed template instantiation. */
1530
1531 parmnode = parmlist;
1532 for (i = 0; i < len; ++i)
1533 {
1534 if (parmnode == NULL_TREE || parmnode == void_list_node)
1535 break;
1536 parmnode = TREE_CHAIN (parmnode);
1537 }
1538
1539 if (i < len && parmnode)
1540 viable = 0;
1541
1542 /* Make sure there are default args for the rest of the parms. */
1543 else if (!sufficient_parms_p (parmnode))
1544 viable = 0;
1545
1546 if (! viable)
1547 goto out;
1548
1549 /* Second, for F to be a viable function, there shall exist for each
1550 argument an implicit conversion sequence that converts that argument
1551 to the corresponding parameter of F. */
1552
1553 parmnode = parmlist;
1554 argnode = arglist;
1555
1556 for (i = 0; i < len; ++i)
1557 {
1558 tree arg = TREE_VALUE (argnode);
1559 tree argtype = lvalue_type (arg);
1560 conversion *t;
1561 int is_this;
1562
1563 if (parmnode == void_list_node)
1564 break;
1565
1566 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1567 && ! DECL_CONSTRUCTOR_P (fn));
1568
1569 if (parmnode)
1570 {
1571 tree parmtype = TREE_VALUE (parmnode);
1572 int lflags = flags;
1573
1574 /* The type of the implicit object parameter ('this') for
1575 overload resolution is not always the same as for the
1576 function itself; conversion functions are considered to
1577 be members of the class being converted, and functions
1578 introduced by a using-declaration are considered to be
1579 members of the class that uses them.
1580
1581 Since build_over_call ignores the ICS for the `this'
1582 parameter, we can just change the parm type. */
1583 if (ctype && is_this)
1584 {
1585 parmtype
1586 = build_qualified_type (ctype,
1587 TYPE_QUALS (TREE_TYPE (parmtype)));
1588 parmtype = build_pointer_type (parmtype);
1589 }
1590
1591 if ((flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1592 && ctype && i == 0 && DECL_COPY_CONSTRUCTOR_P (fn))
1593 lflags |= LOOKUP_NO_CONVERSION;
1594
1595 t = implicit_conversion (parmtype, argtype, arg,
1596 /*c_cast_p=*/false, lflags);
1597 }
1598 else
1599 {
1600 t = build_identity_conv (argtype, arg);
1601 t->ellipsis_p = true;
1602 }
1603
1604 if (t && is_this)
1605 t->this_p = true;
1606
1607 convs[i] = t;
1608 if (! t)
1609 {
1610 viable = 0;
1611 break;
1612 }
1613
1614 if (t->bad_p)
1615 viable = -1;
1616
1617 if (parmnode)
1618 parmnode = TREE_CHAIN (parmnode);
1619 argnode = TREE_CHAIN (argnode);
1620 }
1621
1622 out:
1623 return add_candidate (candidates, fn, orig_arglist, len, convs,
1624 access_path, conversion_path, viable);
1625}
1626
1627/* Create an overload candidate for the conversion function FN which will
1628 be invoked for expression OBJ, producing a pointer-to-function which
1629 will in turn be called with the argument list ARGLIST, and add it to
1630 CANDIDATES. FLAGS is passed on to implicit_conversion.
1631
1632 Actually, we don't really care about FN; we care about the type it
1633 converts to. There may be multiple conversion functions that will
1634 convert to that type, and we rely on build_user_type_conversion_1 to
1635 choose the best one; so when we create our candidate, we record the type
1636 instead of the function. */
1637
1638static struct z_candidate *
1639add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1640 tree arglist, tree access_path, tree conversion_path)
1641{
1642 tree totype = TREE_TYPE (TREE_TYPE (fn));
1643 int i, len, viable, flags;
1644 tree parmlist, parmnode, argnode;
1645 conversion **convs;
1646
1647 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1648 parmlist = TREE_TYPE (parmlist);
1649 parmlist = TYPE_ARG_TYPES (parmlist);
1650
1651 len = list_length (arglist) + 1;
1652 convs = alloc_conversions (len);
1653 parmnode = parmlist;
1654 argnode = arglist;
1655 viable = 1;
1656 flags = LOOKUP_NORMAL;
1657
1658 /* Don't bother looking up the same type twice. */
1659 if (*candidates && (*candidates)->fn == totype)
1660 return NULL;
1661
1662 for (i = 0; i < len; ++i)
1663 {
1664 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1665 tree argtype = lvalue_type (arg);
1666 conversion *t;
1667
1668 if (i == 0)
1669 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1670 flags);
1671 else if (parmnode == void_list_node)
1672 break;
1673 else if (parmnode)
1674 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1675 /*c_cast_p=*/false, flags);
1676 else
1677 {
1678 t = build_identity_conv (argtype, arg);
1679 t->ellipsis_p = true;
1680 }
1681
1682 convs[i] = t;
1683 if (! t)
1684 break;
1685
1686 if (t->bad_p)
1687 viable = -1;
1688
1689 if (i == 0)
1690 continue;
1691
1692 if (parmnode)
1693 parmnode = TREE_CHAIN (parmnode);
1694 argnode = TREE_CHAIN (argnode);
1695 }
1696
1697 if (i < len)
1698 viable = 0;
1699
1700 if (!sufficient_parms_p (parmnode))
1701 viable = 0;
1702
1703 return add_candidate (candidates, totype, arglist, len, convs,
1704 access_path, conversion_path, viable);
1705}
1706
1707static void
1708build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1709 tree type1, tree type2, tree *args, tree *argtypes,
1710 int flags)
1711{
1712 conversion *t;
1713 conversion **convs;
1714 size_t num_convs;
1715 int viable = 1, i;
1716 tree types[2];
1717
1718 types[0] = type1;
1719 types[1] = type2;
1720
1721 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1722 convs = alloc_conversions (num_convs);
1723
1724 for (i = 0; i < 2; ++i)
1725 {
1726 if (! args[i])
1727 break;
1728
1729 t = implicit_conversion (types[i], argtypes[i], args[i],
1730 /*c_cast_p=*/false, flags);
1731 if (! t)
1732 {
1733 viable = 0;
1734 /* We need something for printing the candidate. */
1735 t = build_identity_conv (types[i], NULL_TREE);
1736 }
1737 else if (t->bad_p)
1738 viable = 0;
1739 convs[i] = t;
1740 }
1741
1742 /* For COND_EXPR we rearranged the arguments; undo that now. */
1743 if (args[2])
1744 {
1745 convs[2] = convs[1];
1746 convs[1] = convs[0];
1747 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1748 /*c_cast_p=*/false, flags);
1749 if (t)
1750 convs[0] = t;
1751 else
1752 viable = 0;
1753 }
1754
1755 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1756 num_convs, convs,
1757 /*access_path=*/NULL_TREE,
1758 /*conversion_path=*/NULL_TREE,
1759 viable);
1760}
1761
1762static bool
1763is_complete (tree t)
1764{
1765 return COMPLETE_TYPE_P (complete_type (t));
1766}
1767
1768/* Returns nonzero if TYPE is a promoted arithmetic type. */
1769
1770static bool
1771promoted_arithmetic_type_p (tree type)
1772{
1773 /* [over.built]
1774
1775 In this section, the term promoted integral type is used to refer
1776 to those integral types which are preserved by integral promotion
1777 (including e.g. int and long but excluding e.g. char).
1778 Similarly, the term promoted arithmetic type refers to promoted
1779 integral types plus floating types. */
1780 return ((INTEGRAL_TYPE_P (type)
1781 && same_type_p (type_promotes_to (type), type))
1782 || TREE_CODE (type) == REAL_TYPE);
1783}
1784
1785/* Create any builtin operator overload candidates for the operator in
1786 question given the converted operand types TYPE1 and TYPE2. The other
1787 args are passed through from add_builtin_candidates to
1788 build_builtin_candidate.
1789
1790 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1791 If CODE is requires candidates operands of the same type of the kind
1792 of which TYPE1 and TYPE2 are, we add both candidates
1793 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1794
1795static void
1796add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1797 enum tree_code code2, tree fnname, tree type1,
1798 tree type2, tree *args, tree *argtypes, int flags)
1799{
1800 switch (code)
1801 {
1802 case POSTINCREMENT_EXPR:
1803 case POSTDECREMENT_EXPR:
1804 args[1] = integer_zero_node;
1805 type2 = integer_type_node;
1806 break;
1807 default:
1808 break;
1809 }
1810
1811 switch (code)
1812 {
1813
1814/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1815 and VQ is either volatile or empty, there exist candidate operator
1816 functions of the form
1817 VQ T& operator++(VQ T&);
1818 T operator++(VQ T&, int);
1819 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1820 type other than bool, and VQ is either volatile or empty, there exist
1821 candidate operator functions of the form
1822 VQ T& operator--(VQ T&);
1823 T operator--(VQ T&, int);
1824 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1825 complete object type, and VQ is either volatile or empty, there exist
1826 candidate operator functions of the form
1827 T*VQ& operator++(T*VQ&);
1828 T*VQ& operator--(T*VQ&);
1829 T* operator++(T*VQ&, int);
1830 T* operator--(T*VQ&, int); */
1831
1832 case POSTDECREMENT_EXPR:
1833 case PREDECREMENT_EXPR:
1834 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1835 return;
1836 case POSTINCREMENT_EXPR:
1837 case PREINCREMENT_EXPR:
1838 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1839 {
1840 type1 = build_reference_type (type1);
1841 break;
1842 }
1843 return;
1844
1845/* 7 For every cv-qualified or cv-unqualified complete object type T, there
1846 exist candidate operator functions of the form
1847
1848 T& operator*(T*);
1849
1850 8 For every function type T, there exist candidate operator functions of
1851 the form
1852 T& operator*(T*); */
1853
1854 case INDIRECT_REF:
1855 if (TREE_CODE (type1) == POINTER_TYPE
1856 && (TYPE_PTROB_P (type1)
1857 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1858 break;
1859 return;
1860
1861/* 9 For every type T, there exist candidate operator functions of the form
1862 T* operator+(T*);
1863
1864 10For every promoted arithmetic type T, there exist candidate operator
1865 functions of the form
1866 T operator+(T);
1867 T operator-(T); */
1868
1869 case UNARY_PLUS_EXPR: /* unary + */
1870 if (TREE_CODE (type1) == POINTER_TYPE)
1871 break;
1872 case NEGATE_EXPR:
1873 if (ARITHMETIC_TYPE_P (type1))
1874 break;
1875 return;
1876
1877/* 11For every promoted integral type T, there exist candidate operator
1878 functions of the form
1879 T operator~(T); */
1880
1881 case BIT_NOT_EXPR:
1882 if (INTEGRAL_TYPE_P (type1))
1883 break;
1884 return;
1885
1886/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1887 is the same type as C2 or is a derived class of C2, T is a complete
1888 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1889 there exist candidate operator functions of the form
1890 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1891 where CV12 is the union of CV1 and CV2. */
1892
1893 case MEMBER_REF:
1894 if (TREE_CODE (type1) == POINTER_TYPE
1895 && TYPE_PTR_TO_MEMBER_P (type2))
1896 {
1897 tree c1 = TREE_TYPE (type1);
1898 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1899
1900 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
1901 && (TYPE_PTRMEMFUNC_P (type2)
1902 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1903 break;
1904 }
1905 return;
1906
1907/* 13For every pair of promoted arithmetic types L and R, there exist can-
1908 didate operator functions of the form
1909 LR operator*(L, R);
1910 LR operator/(L, R);
1911 LR operator+(L, R);
1912 LR operator-(L, R);
1913 bool operator<(L, R);
1914 bool operator>(L, R);
1915 bool operator<=(L, R);
1916 bool operator>=(L, R);
1917 bool operator==(L, R);
1918 bool operator!=(L, R);
1919 where LR is the result of the usual arithmetic conversions between
1920 types L and R.
1921
1922 14For every pair of types T and I, where T is a cv-qualified or cv-
1923 unqualified complete object type and I is a promoted integral type,
1924 there exist candidate operator functions of the form
1925 T* operator+(T*, I);
1926 T& operator[](T*, I);
1927 T* operator-(T*, I);
1928 T* operator+(I, T*);
1929 T& operator[](I, T*);
1930
1931 15For every T, where T is a pointer to complete object type, there exist
1932 candidate operator functions of the form112)
1933 ptrdiff_t operator-(T, T);
1934
1935 16For every pointer or enumeration type T, there exist candidate operator
1936 functions of the form
1937 bool operator<(T, T);
1938 bool operator>(T, T);
1939 bool operator<=(T, T);
1940 bool operator>=(T, T);
1941 bool operator==(T, T);
1942 bool operator!=(T, T);
1943
1944 17For every pointer to member type T, there exist candidate operator
1945 functions of the form
1946 bool operator==(T, T);
1947 bool operator!=(T, T); */
1948
1949 case MINUS_EXPR:
1950 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1951 break;
1952 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1953 {
1954 type2 = ptrdiff_type_node;
1955 break;
1956 }
1957 case MULT_EXPR:
1958 case TRUNC_DIV_EXPR:
1959 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1960 break;
1961 return;
1962
1963 case EQ_EXPR:
1964 case NE_EXPR:
1965 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1966 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1967 break;
1968 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1969 {
1970 type2 = type1;
1971 break;
1972 }
1973 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1974 {
1975 type1 = type2;
1976 break;
1977 }
1978 /* Fall through. */
1979 case LT_EXPR:
1980 case GT_EXPR:
1981 case LE_EXPR:
1982 case GE_EXPR:
1983 case MAX_EXPR:
1984 case MIN_EXPR:
1985 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1986 break;
1987 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1988 break;
1989 if (TREE_CODE (type1) == ENUMERAL_TYPE
1990 && TREE_CODE (type2) == ENUMERAL_TYPE)
1991 break;
1992 if (TYPE_PTR_P (type1)
1993 && null_ptr_cst_p (args[1])
1994 && !uses_template_parms (type1))
1995 {
1996 type2 = type1;
1997 break;
1998 }
1999 if (null_ptr_cst_p (args[0])
2000 && TYPE_PTR_P (type2)
2001 && !uses_template_parms (type2))
2002 {
2003 type1 = type2;
2004 break;
2005 }
2006 return;
2007
2008 case PLUS_EXPR:
2009 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2010 break;
2011 case ARRAY_REF:
2012 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
2013 {
2014 type1 = ptrdiff_type_node;
2015 break;
2016 }
2017 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
2018 {
2019 type2 = ptrdiff_type_node;
2020 break;
2021 }
2022 return;
2023
2024/* 18For every pair of promoted integral types L and R, there exist candi-
2025 date operator functions of the form
2026 LR operator%(L, R);
2027 LR operator&(L, R);
2028 LR operator^(L, R);
2029 LR operator|(L, R);
2030 L operator<<(L, R);
2031 L operator>>(L, R);
2032 where LR is the result of the usual arithmetic conversions between
2033 types L and R. */
2034
2035 case TRUNC_MOD_EXPR:
2036 case BIT_AND_EXPR:
2037 case BIT_IOR_EXPR:
2038 case BIT_XOR_EXPR:
2039 case LSHIFT_EXPR:
2040 case RSHIFT_EXPR:
2041 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
2042 break;
2043 return;
2044
2045/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2046 type, VQ is either volatile or empty, and R is a promoted arithmetic
2047 type, there exist candidate operator functions of the form
2048 VQ L& operator=(VQ L&, R);
2049 VQ L& operator*=(VQ L&, R);
2050 VQ L& operator/=(VQ L&, R);
2051 VQ L& operator+=(VQ L&, R);
2052 VQ L& operator-=(VQ L&, R);
2053
2054 20For every pair T, VQ), where T is any type and VQ is either volatile
2055 or empty, there exist candidate operator functions of the form
2056 T*VQ& operator=(T*VQ&, T*);
2057
2058 21For every pair T, VQ), where T is a pointer to member type and VQ is
2059 either volatile or empty, there exist candidate operator functions of
2060 the form
2061 VQ T& operator=(VQ T&, T);
2062
2063 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2064 unqualified complete object type, VQ is either volatile or empty, and
2065 I is a promoted integral type, there exist candidate operator func-
2066 tions of the form
2067 T*VQ& operator+=(T*VQ&, I);
2068 T*VQ& operator-=(T*VQ&, I);
2069
2070 23For every triple L, VQ, R), where L is an integral or enumeration
2071 type, VQ is either volatile or empty, and R is a promoted integral
2072 type, there exist candidate operator functions of the form
2073
2074 VQ L& operator%=(VQ L&, R);
2075 VQ L& operator<<=(VQ L&, R);
2076 VQ L& operator>>=(VQ L&, R);
2077 VQ L& operator&=(VQ L&, R);
2078 VQ L& operator^=(VQ L&, R);
2079 VQ L& operator|=(VQ L&, R); */
2080
2081 case MODIFY_EXPR:
2082 switch (code2)
2083 {
2084 case PLUS_EXPR:
2085 case MINUS_EXPR:
2086 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
2087 {
2088 type2 = ptrdiff_type_node;
2089 break;
2090 }
2091 case MULT_EXPR:
2092 case TRUNC_DIV_EXPR:
2093 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2094 break;
2095 return;
2096
2097 case TRUNC_MOD_EXPR:
2098 case BIT_AND_EXPR:
2099 case BIT_IOR_EXPR:
2100 case BIT_XOR_EXPR:
2101 case LSHIFT_EXPR:
2102 case RSHIFT_EXPR:
2103 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
2104 break;
2105 return;
2106
2107 case NOP_EXPR:
2108 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2109 break;
2110 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2111 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2112 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2113 || ((TYPE_PTRMEMFUNC_P (type1)
2114 || TREE_CODE (type1) == POINTER_TYPE)
2115 && null_ptr_cst_p (args[1])))
2116 {
2117 type2 = type1;
2118 break;
2119 }
2120 return;
2121
2122 default:
2123 gcc_unreachable ();
2124 }
2125 type1 = build_reference_type (type1);
2126 break;
2127
2128 case COND_EXPR:
2129 /* [over.built]
2130
2131 For every pair of promoted arithmetic types L and R, there
2132 exist candidate operator functions of the form
2133
2134 LR operator?(bool, L, R);
2135
2136 where LR is the result of the usual arithmetic conversions
2137 between types L and R.
2138
2139 For every type T, where T is a pointer or pointer-to-member
2140 type, there exist candidate operator functions of the form T
2141 operator?(bool, T, T); */
2142
2143 if (promoted_arithmetic_type_p (type1)
2144 && promoted_arithmetic_type_p (type2))
2145 /* That's OK. */
2146 break;
2147
2148 /* Otherwise, the types should be pointers. */
2149 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2150 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2151 return;
2152
2153 /* We don't check that the two types are the same; the logic
2154 below will actually create two candidates; one in which both
2155 parameter types are TYPE1, and one in which both parameter
2156 types are TYPE2. */
2157 break;
2158
2159 default:
2160 gcc_unreachable ();
2161 }
2162
2163 /* If we're dealing with two pointer types or two enumeral types,
2164 we need candidates for both of them. */
2165 if (type2 && !same_type_p (type1, type2)
2166 && TREE_CODE (type1) == TREE_CODE (type2)
2167 && (TREE_CODE (type1) == REFERENCE_TYPE
2168 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2169 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2170 || TYPE_PTRMEMFUNC_P (type1)
2171 || MAYBE_CLASS_TYPE_P (type1)
2172 || TREE_CODE (type1) == ENUMERAL_TYPE))
2173 {
2174 build_builtin_candidate
2175 (candidates, fnname, type1, type1, args, argtypes, flags);
2176 build_builtin_candidate
2177 (candidates, fnname, type2, type2, args, argtypes, flags);
2178 return;
2179 }
2180
2181 build_builtin_candidate
2182 (candidates, fnname, type1, type2, args, argtypes, flags);
2183}
2184
2185tree
2186type_decays_to (tree type)
2187{
2188 if (TREE_CODE (type) == ARRAY_TYPE)
2189 return build_pointer_type (TREE_TYPE (type));
2190 if (TREE_CODE (type) == FUNCTION_TYPE)
2191 return build_pointer_type (type);
2192 return type;
2193}
2194
2195/* There are three conditions of builtin candidates:
2196
2197 1) bool-taking candidates. These are the same regardless of the input.
2198 2) pointer-pair taking candidates. These are generated for each type
2199 one of the input types converts to.
2200 3) arithmetic candidates. According to the standard, we should generate
2201 all of these, but I'm trying not to...
2202
2203 Here we generate a superset of the possible candidates for this particular
2204 case. That is a subset of the full set the standard defines, plus some
2205 other cases which the standard disallows. add_builtin_candidate will
2206 filter out the invalid set. */
2207
2208static void
2209add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2210 enum tree_code code2, tree fnname, tree *args,
2211 int flags)
2212{
2213 int ref1, i;
2214 int enum_p = 0;
2215 tree type, argtypes[3];
2216 /* TYPES[i] is the set of possible builtin-operator parameter types
2217 we will consider for the Ith argument. These are represented as
2218 a TREE_LIST; the TREE_VALUE of each node is the potential
2219 parameter type. */
2220 tree types[2];
2221
2222 for (i = 0; i < 3; ++i)
2223 {
2224 if (args[i])
2225 argtypes[i] = unlowered_expr_type (args[i]);
2226 else
2227 argtypes[i] = NULL_TREE;
2228 }
2229
2230 switch (code)
2231 {
2232/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2233 and VQ is either volatile or empty, there exist candidate operator
2234 functions of the form
2235 VQ T& operator++(VQ T&); */
2236
2237 case POSTINCREMENT_EXPR:
2238 case PREINCREMENT_EXPR:
2239 case POSTDECREMENT_EXPR:
2240 case PREDECREMENT_EXPR:
2241 case MODIFY_EXPR:
2242 ref1 = 1;
2243 break;
2244
2245/* 24There also exist candidate operator functions of the form
2246 bool operator!(bool);
2247 bool operator&&(bool, bool);
2248 bool operator||(bool, bool); */
2249
2250 case TRUTH_NOT_EXPR:
2251 build_builtin_candidate
2252 (candidates, fnname, boolean_type_node,
2253 NULL_TREE, args, argtypes, flags);
2254 return;
2255
2256 case TRUTH_ORIF_EXPR:
2257 case TRUTH_ANDIF_EXPR:
2258 build_builtin_candidate
2259 (candidates, fnname, boolean_type_node,
2260 boolean_type_node, args, argtypes, flags);
2261 return;
2262
2263 case ADDR_EXPR:
2264 case COMPOUND_EXPR:
2265 case COMPONENT_REF:
2266 return;
2267
2268 case COND_EXPR:
2269 case EQ_EXPR:
2270 case NE_EXPR:
2271 case LT_EXPR:
2272 case LE_EXPR:
2273 case GT_EXPR:
2274 case GE_EXPR:
2275 enum_p = 1;
2276 /* Fall through. */
2277
2278 default:
2279 ref1 = 0;
2280 }
2281
2282 types[0] = types[1] = NULL_TREE;
2283
2284 for (i = 0; i < 2; ++i)
2285 {
2286 if (! args[i])
2287 ;
2288 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2289 {
2290 tree convs;
2291
2292 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2293 return;
2294
2295 convs = lookup_conversions (argtypes[i]);
2296
2297 if (code == COND_EXPR)
2298 {
2299 if (real_lvalue_p (args[i]))
2300 types[i] = tree_cons
2301 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2302
2303 types[i] = tree_cons
2304 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2305 }
2306
2307 else if (! convs)
2308 return;
2309
2310 for (; convs; convs = TREE_CHAIN (convs))
2311 {
2312 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2313
2314 if (i == 0 && ref1
2315 && (TREE_CODE (type) != REFERENCE_TYPE
2316 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2317 continue;
2318
2319 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2320 types[i] = tree_cons (NULL_TREE, type, types[i]);
2321
2322 type = non_reference (type);
2323 if (i != 0 || ! ref1)
2324 {
2325 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2326 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2327 types[i] = tree_cons (NULL_TREE, type, types[i]);
2328 if (INTEGRAL_TYPE_P (type))
2329 type = type_promotes_to (type);
2330 }
2331
2332 if (! value_member (type, types[i]))
2333 types[i] = tree_cons (NULL_TREE, type, types[i]);
2334 }
2335 }
2336 else
2337 {
2338 if (code == COND_EXPR && real_lvalue_p (args[i]))
2339 types[i] = tree_cons
2340 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2341 type = non_reference (argtypes[i]);
2342 if (i != 0 || ! ref1)
2343 {
2344 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2345 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2346 types[i] = tree_cons (NULL_TREE, type, types[i]);
2347 if (INTEGRAL_TYPE_P (type))
2348 type = type_promotes_to (type);
2349 }
2350 types[i] = tree_cons (NULL_TREE, type, types[i]);
2351 }
2352 }
2353
2354 /* Run through the possible parameter types of both arguments,
2355 creating candidates with those parameter types. */
2356 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2357 {
2358 if (types[1])
2359 for (type = types[1]; type; type = TREE_CHAIN (type))
2360 add_builtin_candidate
2361 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2362 TREE_VALUE (type), args, argtypes, flags);
2363 else
2364 add_builtin_candidate
2365 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2366 NULL_TREE, args, argtypes, flags);
2367 }
2368}
2369
2370
2371/* If TMPL can be successfully instantiated as indicated by
2372 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2373
2374 TMPL is the template. EXPLICIT_TARGS are any explicit template
2375 arguments. ARGLIST is the arguments provided at the call-site.
2376 The RETURN_TYPE is the desired type for conversion operators. If
2377 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2378 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2379 add_conv_candidate. */
2380
2381static struct z_candidate*
2382add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2383 tree ctype, tree explicit_targs, tree arglist,
2384 tree return_type, tree access_path,
2385 tree conversion_path, int flags, tree obj,
2386 unification_kind_t strict)
2387{
2388 int ntparms = DECL_NTPARMS (tmpl);
2389 tree targs = make_tree_vec (ntparms);
2390 tree args_without_in_chrg = arglist;
2391 struct z_candidate *cand;
2392 int i;
2393 tree fn;
2394
2395 /* We don't do deduction on the in-charge parameter, the VTT
2396 parameter or 'this'. */
2397 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2398 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2399
2400 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2401 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2402 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2403 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2404
2405 i = fn_type_unification (tmpl, explicit_targs, targs,
2406 args_without_in_chrg,
2407 return_type, strict, flags);
2408
2409 if (i != 0)
2410 return NULL;
2411
2412 fn = instantiate_template (tmpl, targs, tf_none);
2413 if (fn == error_mark_node)
2414 return NULL;
2415
2416 /* In [class.copy]:
2417
2418 A member function template is never instantiated to perform the
2419 copy of a class object to an object of its class type.
2420
2421 It's a little unclear what this means; the standard explicitly
2422 does allow a template to be used to copy a class. For example,
2423 in:
2424
2425 struct A {
2426 A(A&);
2427 template <class T> A(const T&);
2428 };
2429 const A f ();
2430 void g () { A a (f ()); }
2431
2432 the member template will be used to make the copy. The section
2433 quoted above appears in the paragraph that forbids constructors
2434 whose only parameter is (a possibly cv-qualified variant of) the
2435 class type, and a logical interpretation is that the intent was
2436 to forbid the instantiation of member templates which would then
2437 have that form. */
2438 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2439 {
2440 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2441 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2442 ctype))
2443 return NULL;
2444 }
2445
2446 if (obj != NULL_TREE)
2447 /* Aha, this is a conversion function. */
2448 cand = add_conv_candidate (candidates, fn, obj, access_path,
2449 conversion_path, arglist);
2450 else
2451 cand = add_function_candidate (candidates, fn, ctype,
2452 arglist, access_path,
2453 conversion_path, flags);
2454 if (DECL_TI_TEMPLATE (fn) != tmpl)
2455 /* This situation can occur if a member template of a template
2456 class is specialized. Then, instantiate_template might return
2457 an instantiation of the specialization, in which case the
2458 DECL_TI_TEMPLATE field will point at the original
2459 specialization. For example:
2460
2461 template <class T> struct S { template <class U> void f(U);
2462 template <> void f(int) {}; };
2463 S<double> sd;
2464 sd.f(3);
2465
2466 Here, TMPL will be template <class U> S<double>::f(U).
2467 And, instantiate template will give us the specialization
2468 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2469 for this will point at template <class T> template <> S<T>::f(int),
2470 so that we can find the definition. For the purposes of
2471 overload resolution, however, we want the original TMPL. */
2472 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2473 else
2474 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2475
2476 return cand;
2477}
2478
2479
2480static struct z_candidate *
2481add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2482 tree explicit_targs, tree arglist, tree return_type,
2483 tree access_path, tree conversion_path, int flags,
2484 unification_kind_t strict)
2485{
2486 return
2487 add_template_candidate_real (candidates, tmpl, ctype,
2488 explicit_targs, arglist, return_type,
2489 access_path, conversion_path,
2490 flags, NULL_TREE, strict);
2491}
2492
2493
2494static struct z_candidate *
2495add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2496 tree obj, tree arglist, tree return_type,
2497 tree access_path, tree conversion_path)
2498{
2499 return
2500 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2501 arglist, return_type, access_path,
2502 conversion_path, 0, obj, DEDUCE_CONV);
2503}
2504
2505/* The CANDS are the set of candidates that were considered for
2506 overload resolution. Return the set of viable candidates. If none
2507 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2508 is true if a candidate should be considered viable only if it is
2509 strictly viable. */
2510
2511static struct z_candidate*
2512splice_viable (struct z_candidate *cands,
2513 bool strict_p,
2514 bool *any_viable_p)
2515{
2516 struct z_candidate *viable;
2517 struct z_candidate **last_viable;
2518 struct z_candidate **cand;
2519
2520 viable = NULL;
2521 last_viable = &viable;
2522 *any_viable_p = false;
2523
2524 cand = &cands;
2525 while (*cand)
2526 {
2527 struct z_candidate *c = *cand;
2528 if (strict_p ? c->viable == 1 : c->viable)
2529 {
2530 *last_viable = c;
2531 *cand = c->next;
2532 c->next = NULL;
2533 last_viable = &c->next;
2534 *any_viable_p = true;
2535 }
2536 else
2537 cand = &c->next;
2538 }
2539
2540 return viable ? viable : cands;
2541}
2542
2543static bool
2544any_strictly_viable (struct z_candidate *cands)
2545{
2546 for (; cands; cands = cands->next)
2547 if (cands->viable == 1)
2548 return true;
2549 return false;
2550}
2551
2552/* OBJ is being used in an expression like "OBJ.f (...)". In other
2553 words, it is about to become the "this" pointer for a member
2554 function call. Take the address of the object. */
2555
2556static tree
2557build_this (tree obj)
2558{
2559 /* In a template, we are only concerned about the type of the
2560 expression, so we can take a shortcut. */
2561 if (processing_template_decl)
2562 return build_address (obj);
2563
2564 return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2565}
2566
2567/* Returns true iff functions are equivalent. Equivalent functions are
2568 not '==' only if one is a function-local extern function or if
2569 both are extern "C". */
2570
2571static inline int
2572equal_functions (tree fn1, tree fn2)
2573{
2574 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2575 || DECL_EXTERN_C_FUNCTION_P (fn1))
2576 return decls_match (fn1, fn2);
2577 return fn1 == fn2;
2578}
2579
2580/* Print information about one overload candidate CANDIDATE. MSGSTR
2581 is the text to print before the candidate itself.
2582
2583 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2584 to have been run through gettext by the caller. This wart makes
2585 life simpler in print_z_candidates and for the translators. */
2586
2587static void
2588print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2589{
2590 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2591 {
2592 if (candidate->num_convs == 3)
2593 inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2594 candidate->convs[0]->type,
2595 candidate->convs[1]->type,
2596 candidate->convs[2]->type);
2597 else if (candidate->num_convs == 2)
2598 inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2599 candidate->convs[0]->type,
2600 candidate->convs[1]->type);
2601 else
2602 inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2603 candidate->convs[0]->type);
2604 }
2605 else if (TYPE_P (candidate->fn))
2606 inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2607 else if (candidate->viable == -1)
2608 inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2609 else
2610 inform (input_location, "%s %+#D", msgstr, candidate->fn);
2611}
2612
2613static void
2614print_z_candidates (struct z_candidate *candidates)
2615{
2616 const char *str;
2617 struct z_candidate *cand1;
2618 struct z_candidate **cand2;
2619
2620 /* There may be duplicates in the set of candidates. We put off
2621 checking this condition as long as possible, since we have no way
2622 to eliminate duplicates from a set of functions in less than n^2
2623 time. Now we are about to emit an error message, so it is more
2624 permissible to go slowly. */
2625 for (cand1 = candidates; cand1; cand1 = cand1->next)
2626 {
2627 tree fn = cand1->fn;
2628 /* Skip builtin candidates and conversion functions. */
2629 if (TREE_CODE (fn) != FUNCTION_DECL)
2630 continue;
2631 cand2 = &cand1->next;
2632 while (*cand2)
2633 {
2634 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2635 && equal_functions (fn, (*cand2)->fn))
2636 *cand2 = (*cand2)->next;
2637 else
2638 cand2 = &(*cand2)->next;
2639 }
2640 }
2641
2642 if (!candidates)
2643 return;
2644
2645 str = _("candidates are:");
2646 print_z_candidate (str, candidates);
2647 if (candidates->next)
2648 {
2649 /* Indent successive candidates by the width of the translation
2650 of the above string. */
2651 size_t len = gcc_gettext_width (str) + 1;
2652 char *spaces = (char *) alloca (len);
2653 memset (spaces, ' ', len-1);
2654 spaces[len - 1] = '\0';
2655
2656 candidates = candidates->next;
2657 do
2658 {
2659 print_z_candidate (spaces, candidates);
2660 candidates = candidates->next;
2661 }
2662 while (candidates);
2663 }
2664}
2665
2666/* USER_SEQ is a user-defined conversion sequence, beginning with a
2667 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2668 the result of the conversion function to convert it to the final
2669 desired type. Merge the two sequences into a single sequence,
2670 and return the merged sequence. */
2671
2672static conversion *
2673merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2674{
2675 conversion **t;
2676
2677 gcc_assert (user_seq->kind == ck_user);
2678
2679 /* Find the end of the second conversion sequence. */
2680 t = &(std_seq);
2681 while ((*t)->kind != ck_identity)
2682 t = &((*t)->u.next);
2683
2684 /* Replace the identity conversion with the user conversion
2685 sequence. */
2686 *t = user_seq;
2687
2688 /* The entire sequence is a user-conversion sequence. */
2689 std_seq->user_conv_p = true;
2690
2691 return std_seq;
2692}
2693
2694/* Returns the best overload candidate to perform the requested
2695 conversion. This function is used for three the overloading situations
2696 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2697 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2698 per [dcl.init.ref], so we ignore temporary bindings. */
2699
2700static struct z_candidate *
2701build_user_type_conversion_1 (tree totype, tree expr, int flags)
2702{
2703 struct z_candidate *candidates, *cand;
2704 tree fromtype = TREE_TYPE (expr);
2705 tree ctors = NULL_TREE;
2706 tree conv_fns = NULL_TREE;
2707 conversion *conv = NULL;
2708 tree args = NULL_TREE;
2709 bool any_viable_p;
2710 int convflags;
2711
2712 /* We represent conversion within a hierarchy using RVALUE_CONV and
2713 BASE_CONV, as specified by [over.best.ics]; these become plain
2714 constructor calls, as specified in [dcl.init]. */
2715 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2716 || !DERIVED_FROM_P (totype, fromtype));
2717
2718 if (MAYBE_CLASS_TYPE_P (totype))
2719 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2720
2721 if (MAYBE_CLASS_TYPE_P (fromtype))
2722 {
2723 tree to_nonref = non_reference (totype);
2724 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2725 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2726 && DERIVED_FROM_P (to_nonref, fromtype)))
2727 {
2728 /* [class.conv.fct] A conversion function is never used to
2729 convert a (possibly cv-qualified) object to the (possibly
2730 cv-qualified) same object type (or a reference to it), to a
2731 (possibly cv-qualified) base class of that type (or a
2732 reference to it)... */
2733 }
2734 else
2735 conv_fns = lookup_conversions (fromtype);
2736 }
2737
2738 candidates = 0;
2739 flags |= LOOKUP_NO_CONVERSION;
2740
2741 /* It's OK to bind a temporary for converting constructor arguments, but
2742 not in converting the return value of a conversion operator. */
2743 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2744 flags &= ~LOOKUP_NO_TEMP_BIND;
2745
2746 if (ctors)
2747 {
2748 tree t;
2749
2750 ctors = BASELINK_FUNCTIONS (ctors);
2751
2752 t = build_int_cst (build_pointer_type (totype), 0);
2753 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
2754 && !TYPE_HAS_LIST_CTOR (totype))
2755 {
2756 args = ctor_to_list (expr);
2757 /* We still allow more conversions within an init-list. */
2758 flags = ((flags & ~LOOKUP_NO_CONVERSION)
2759 /* But not for the copy ctor. */
2760 |LOOKUP_NO_COPY_CTOR_CONVERSION
2761 |LOOKUP_NO_NARROWING);
2762 }
2763 else
2764 args = build_tree_list (NULL_TREE, expr);
2765 /* We should never try to call the abstract or base constructor
2766 from here. */
2767 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2768 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2769 args = tree_cons (NULL_TREE, t, args);
2770 }
2771 for (; ctors; ctors = OVL_NEXT (ctors))
2772 {
2773 tree ctor = OVL_CURRENT (ctors);
2774 if (DECL_NONCONVERTING_P (ctor)
2775 && !BRACE_ENCLOSED_INITIALIZER_P (expr))
2776 continue;
2777
2778 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2779 cand = add_template_candidate (&candidates, ctor, totype,
2780 NULL_TREE, args, NULL_TREE,
2781 TYPE_BINFO (totype),
2782 TYPE_BINFO (totype),
2783 flags,
2784 DEDUCE_CALL);
2785 else
2786 cand = add_function_candidate (&candidates, ctor, totype,
2787 args, TYPE_BINFO (totype),
2788 TYPE_BINFO (totype),
2789 flags);
2790
2791 if (cand)
2792 {
2793 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2794
2795 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2796 set, then this is copy-initialization. In that case, "The
2797 result of the call is then used to direct-initialize the
2798 object that is the destination of the copy-initialization."
2799 [dcl.init]
2800
2801 We represent this in the conversion sequence with an
2802 rvalue conversion, which means a constructor call. */
2803 if (TREE_CODE (totype) != REFERENCE_TYPE
2804 && !(convflags & LOOKUP_NO_TEMP_BIND))
2805 cand->second_conv
2806 = build_conv (ck_rvalue, totype, cand->second_conv);
2807 }
2808 }
2809
2810 if (conv_fns)
2811 args = build_tree_list (NULL_TREE, build_this (expr));
2812
2813 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2814 {
2815 tree fns;
2816 tree conversion_path = TREE_PURPOSE (conv_fns);
2817
2818 /* If we are called to convert to a reference type, we are trying to
2819 find an lvalue binding, so don't even consider temporaries. If
2820 we don't find an lvalue binding, the caller will try again to
2821 look for a temporary binding. */
2822 if (TREE_CODE (totype) == REFERENCE_TYPE)
2823 convflags |= LOOKUP_NO_TEMP_BIND;
2824
2825 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2826 {
2827 tree fn = OVL_CURRENT (fns);
2828
2829 /* [over.match.funcs] For conversion functions, the function
2830 is considered to be a member of the class of the implicit
2831 object argument for the purpose of defining the type of
2832 the implicit object parameter.
2833
2834 So we pass fromtype as CTYPE to add_*_candidate. */
2835
2836 if (TREE_CODE (fn) == TEMPLATE_DECL)
2837 cand = add_template_candidate (&candidates, fn, fromtype,
2838 NULL_TREE,
2839 args, totype,
2840 TYPE_BINFO (fromtype),
2841 conversion_path,
2842 flags,
2843 DEDUCE_CONV);
2844 else
2845 cand = add_function_candidate (&candidates, fn, fromtype,
2846 args,
2847 TYPE_BINFO (fromtype),
2848 conversion_path,
2849 flags);
2850
2851 if (cand)
2852 {
2853 conversion *ics
2854 = implicit_conversion (totype,
2855 TREE_TYPE (TREE_TYPE (cand->fn)),
2856 0,
2857 /*c_cast_p=*/false, convflags);
2858
2859 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
2860 copy-initialization. In that case, "The result of the
2861 call is then used to direct-initialize the object that is
2862 the destination of the copy-initialization." [dcl.init]
2863
2864 We represent this in the conversion sequence with an
2865 rvalue conversion, which means a constructor call. But
2866 don't add a second rvalue conversion if there's already
2867 one there. Which there really shouldn't be, but it's
2868 harmless since we'd add it here anyway. */
2869 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
2870 && !(convflags & LOOKUP_NO_TEMP_BIND))
2871 ics = build_conv (ck_rvalue, totype, ics);
2872
2873 cand->second_conv = ics;
2874
2875 if (!ics)
2876 cand->viable = 0;
2877 else if (candidates->viable == 1 && ics->bad_p)
2878 cand->viable = -1;
2879 }
2880 }
2881 }
2882
2883 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2884 if (!any_viable_p)
2885 return NULL;
2886
2887 cand = tourney (candidates);
2888 if (cand == 0)
2889 {
2890 if (flags & LOOKUP_COMPLAIN)
2891 {
2892 error ("conversion from %qT to %qT is ambiguous",
2893 fromtype, totype);
2894 print_z_candidates (candidates);
2895 }
2896
2897 cand = candidates; /* any one will do */
2898 cand->second_conv = build_ambiguous_conv (totype, expr);
2899 cand->second_conv->user_conv_p = true;
2900 if (!any_strictly_viable (candidates))
2901 cand->second_conv->bad_p = true;
2902 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2903 ambiguous conversion is no worse than another user-defined
2904 conversion. */
2905
2906 return cand;
2907 }
2908
2909 /* Build the user conversion sequence. */
2910 conv = build_conv
2911 (ck_user,
2912 (DECL_CONSTRUCTOR_P (cand->fn)
2913 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2914 build_identity_conv (TREE_TYPE (expr), expr));
2915 conv->cand = cand;
2916
2917 /* Remember that this was a list-initialization. */
2918 if (flags & LOOKUP_NO_NARROWING)
2919 conv->check_narrowing = true;
2920
2921 /* Combine it with the second conversion sequence. */
2922 cand->second_conv = merge_conversion_sequences (conv,
2923 cand->second_conv);
2924
2925 if (cand->viable == -1)
2926 cand->second_conv->bad_p = true;
2927
2928 return cand;
2929}
2930
2931tree
2932build_user_type_conversion (tree totype, tree expr, int flags)
2933{
2934 struct z_candidate *cand
2935 = build_user_type_conversion_1 (totype, expr, flags);
2936
2937 if (cand)
2938 {
2939 if (cand->second_conv->kind == ck_ambig)
2940 return error_mark_node;
2941 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
2942 return convert_from_reference (expr);
2943 }
2944 return NULL_TREE;
2945}
2946
2947/* Do any initial processing on the arguments to a function call. */
2948
2949static tree
2950resolve_args (tree args)
2951{
2952 tree t;
2953 for (t = args; t; t = TREE_CHAIN (t))
2954 {
2955 tree arg = TREE_VALUE (t);
2956
2957 if (error_operand_p (arg))
2958 return error_mark_node;
2959 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2960 {
2961 error ("invalid use of void expression");
2962 return error_mark_node;
2963 }
2964 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
2965 return error_mark_node;
2966 }
2967 return args;
2968}
2969
2970/* Perform overload resolution on FN, which is called with the ARGS.
2971
2972 Return the candidate function selected by overload resolution, or
2973 NULL if the event that overload resolution failed. In the case
2974 that overload resolution fails, *CANDIDATES will be the set of
2975 candidates considered, and ANY_VIABLE_P will be set to true or
2976 false to indicate whether or not any of the candidates were
2977 viable.
2978
2979 The ARGS should already have gone through RESOLVE_ARGS before this
2980 function is called. */
2981
2982static struct z_candidate *
2983perform_overload_resolution (tree fn,
2984 tree args,
2985 struct z_candidate **candidates,
2986 bool *any_viable_p)
2987{
2988 struct z_candidate *cand;
2989 tree explicit_targs = NULL_TREE;
2990 int template_only = 0;
2991
2992 *candidates = NULL;
2993 *any_viable_p = true;
2994
2995 /* Check FN and ARGS. */
2996 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2997 || TREE_CODE (fn) == TEMPLATE_DECL
2998 || TREE_CODE (fn) == OVERLOAD
2999 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3000 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
3001
3002 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3003 {
3004 explicit_targs = TREE_OPERAND (fn, 1);
3005 fn = TREE_OPERAND (fn, 0);
3006 template_only = 1;
3007 }
3008
3009 /* Add the various candidate functions. */
3010 add_candidates (fn, args, explicit_targs, template_only,
3011 /*conversion_path=*/NULL_TREE,
3012 /*access_path=*/NULL_TREE,
3013 LOOKUP_NORMAL,
3014 candidates);
3015
3016 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3017 if (!*any_viable_p)
3018 return NULL;
3019
3020 cand = tourney (*candidates);
3021 return cand;
3022}
3023
3024/* Return an expression for a call to FN (a namespace-scope function,
3025 or a static member function) with the ARGS. */
3026
3027tree
3028build_new_function_call (tree fn, tree args, bool koenig_p,
3029 tsubst_flags_t complain)
3030{
3031 struct z_candidate *candidates, *cand;
3032 bool any_viable_p;
3033 void *p;
3034 tree result;
3035
3036 args = resolve_args (args);
3037 if (args == error_mark_node)
3038 return error_mark_node;
3039
3040 /* If this function was found without using argument dependent
3041 lookup, then we want to ignore any undeclared friend
3042 functions. */
3043 if (!koenig_p)
3044 {
3045 tree orig_fn = fn;
3046
3047 fn = remove_hidden_names (fn);
3048 if (!fn)
3049 {
3050 if (complain & tf_error)
3051 error ("no matching function for call to %<%D(%A)%>",
3052 DECL_NAME (OVL_CURRENT (orig_fn)), args);
3053 return error_mark_node;
3054 }
3055 }
3056
3057 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3058 p = conversion_obstack_alloc (0);
3059
3060 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
3061
3062 if (!cand)
3063 {
3064 if (complain & tf_error)
3065 {
3066 if (!any_viable_p && candidates && ! candidates->next)
3067 return cp_build_function_call (candidates->fn, args, complain);
3068 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3069 fn = TREE_OPERAND (fn, 0);
3070 if (!any_viable_p)
3071 error ("no matching function for call to %<%D(%A)%>",
3072 DECL_NAME (OVL_CURRENT (fn)), args);
3073 else
3074 error ("call of overloaded %<%D(%A)%> is ambiguous",
3075 DECL_NAME (OVL_CURRENT (fn)), args);
3076 if (candidates)
3077 print_z_candidates (candidates);
3078 }
3079 result = error_mark_node;
3080 }
3081 else
3082 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3083
3084 /* Free all the conversions we allocated. */
3085 obstack_free (&conversion_obstack, p);
3086
3087 return result;
3088}
3089
3090/* Build a call to a global operator new. FNNAME is the name of the
3091 operator (either "operator new" or "operator new[]") and ARGS are
3092 the arguments provided. *SIZE points to the total number of bytes
3093 required by the allocation, and is updated if that is changed here.
3094 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
3095 function determines that no cookie should be used, after all,
3096 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
3097 set, upon return, to the allocation function called. */
3098
3099tree
3100build_operator_new_call (tree fnname, tree args,
3101 tree *size, tree *cookie_size,
3102 tree *fn)
3103{
3104 tree fns;
3105 struct z_candidate *candidates;
3106 struct z_candidate *cand;
3107 bool any_viable_p;
3108
3109 if (fn)
3110 *fn = NULL_TREE;
3111 args = tree_cons (NULL_TREE, *size, args);
3112 args = resolve_args (args);
3113 if (args == error_mark_node)
3114 return args;
3115
3116 /* Based on:
3117
3118 [expr.new]
3119
3120 If this lookup fails to find the name, or if the allocated type
3121 is not a class type, the allocation function's name is looked
3122 up in the global scope.
3123
3124 we disregard block-scope declarations of "operator new". */
3125 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
3126
3127 /* Figure out what function is being called. */
3128 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
3129
3130 /* If no suitable function could be found, issue an error message
3131 and give up. */
3132 if (!cand)
3133 {
3134 if (!any_viable_p)
3135 error ("no matching function for call to %<%D(%A)%>",
3136 DECL_NAME (OVL_CURRENT (fns)), args);
3137 else
3138 error ("call of overloaded %<%D(%A)%> is ambiguous",
3139 DECL_NAME (OVL_CURRENT (fns)), args);
3140 if (candidates)
3141 print_z_candidates (candidates);
3142 return error_mark_node;
3143 }
3144
3145 /* If a cookie is required, add some extra space. Whether
3146 or not a cookie is required cannot be determined until
3147 after we know which function was called. */
3148 if (*cookie_size)
3149 {
3150 bool use_cookie = true;
3151 if (!abi_version_at_least (2))
3152 {
3153 tree placement = TREE_CHAIN (args);
3154 /* In G++ 3.2, the check was implemented incorrectly; it
3155 looked at the placement expression, rather than the
3156 type of the function. */
3157 if (placement && !TREE_CHAIN (placement)
3158 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
3159 ptr_type_node))
3160 use_cookie = false;
3161 }
3162 else
3163 {
3164 tree arg_types;
3165
3166 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3167 /* Skip the size_t parameter. */
3168 arg_types = TREE_CHAIN (arg_types);
3169 /* Check the remaining parameters (if any). */
3170 if (arg_types
3171 && TREE_CHAIN (arg_types) == void_list_node
3172 && same_type_p (TREE_VALUE (arg_types),
3173 ptr_type_node))
3174 use_cookie = false;
3175 }
3176 /* If we need a cookie, adjust the number of bytes allocated. */
3177 if (use_cookie)
3178 {
3179 /* Update the total size. */
3180 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3181 /* Update the argument list to reflect the adjusted size. */
3182 TREE_VALUE (args) = *size;
3183 }
3184 else
3185 *cookie_size = NULL_TREE;
3186 }
3187
3188 /* Tell our caller which function we decided to call. */
3189 if (fn)
3190 *fn = cand->fn;
3191
3192 /* Build the CALL_EXPR. */
3193 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3194}
3195
d8f1d01e 3196tree
c251ad9e
SS
3197build_object_call (tree obj, tree args, tsubst_flags_t complain)
3198{
3199 struct z_candidate *candidates = 0, *cand;
3200 tree fns, convs, mem_args = NULL_TREE;
3201 tree type = TREE_TYPE (obj);
3202 bool any_viable_p;
3203 tree result = NULL_TREE;
3204 void *p;
3205
3206 if (TYPE_PTRMEMFUNC_P (type))
3207 {
3208 if (complain & tf_error)
3209 /* It's no good looking for an overloaded operator() on a
3210 pointer-to-member-function. */
3211 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3212 return error_mark_node;
3213 }
3214
3215 if (TYPE_BINFO (type))
3216 {
3217 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3218 if (fns == error_mark_node)
3219 return error_mark_node;
3220 }
3221 else
3222 fns = NULL_TREE;
3223
3224 args = resolve_args (args);
3225
3226 if (args == error_mark_node)
3227 return error_mark_node;
3228
3229 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3230 p = conversion_obstack_alloc (0);
3231
3232 if (fns)
3233 {
3234 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3235 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
3236
3237 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3238 {
3239 tree fn = OVL_CURRENT (fns);
3240 if (TREE_CODE (fn) == TEMPLATE_DECL)
3241 add_template_candidate (&candidates, fn, base, NULL_TREE,
3242 mem_args, NULL_TREE,
3243 TYPE_BINFO (type),
3244 TYPE_BINFO (type),
3245 LOOKUP_NORMAL, DEDUCE_CALL);
3246 else
3247 add_function_candidate
3248 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3249 TYPE_BINFO (type), LOOKUP_NORMAL);
3250 }
3251 }
3252
3253 convs = lookup_conversions (type);
3254
3255 for (; convs; convs = TREE_CHAIN (convs))
3256 {
3257 tree fns = TREE_VALUE (convs);
3258 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3259
3260 if ((TREE_CODE (totype) == POINTER_TYPE
3261 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3262 || (TREE_CODE (totype) == REFERENCE_TYPE
3263 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3264 || (TREE_CODE (totype) == REFERENCE_TYPE
3265 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3266 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3267 for (; fns; fns = OVL_NEXT (fns))
3268 {
3269 tree fn = OVL_CURRENT (fns);
3270 if (TREE_CODE (fn) == TEMPLATE_DECL)
3271 add_template_conv_candidate
3272 (&candidates, fn, obj, args, totype,
3273 /*access_path=*/NULL_TREE,
3274 /*conversion_path=*/NULL_TREE);
3275 else
3276 add_conv_candidate (&candidates, fn, obj, args,
3277 /*conversion_path=*/NULL_TREE,
3278 /*access_path=*/NULL_TREE);
3279 }
3280 }
3281
3282 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3283 if (!any_viable_p)
3284 {
3285 if (complain & tf_error)
3286 {
3287 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3288 print_z_candidates (candidates);
3289 }
3290 result = error_mark_node;
3291 }
3292 else
3293 {
3294 cand = tourney (candidates);
3295 if (cand == 0)
3296 {
3297 if (complain & tf_error)
3298 {
3299 error ("call of %<(%T) (%A)%> is ambiguous",
3300 TREE_TYPE (obj), args);
3301 print_z_candidates (candidates);
3302 }
3303 result = error_mark_node;
3304 }
3305 /* Since cand->fn will be a type, not a function, for a conversion
3306 function, we must be careful not to unconditionally look at
3307 DECL_NAME here. */
3308 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3309 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3310 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3311 else
3312 {
3313 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3314 complain);
3315 obj = convert_from_reference (obj);
3316 result = cp_build_function_call (obj, args, complain);
3317 }
3318 }
3319
3320 /* Free all the conversions we allocated. */
3321 obstack_free (&conversion_obstack, p);
3322
3323 return result;
3324}
3325
3326static void
3327op_error (enum tree_code code, enum tree_code code2,
3328 tree arg1, tree arg2, tree arg3, const char *problem)
3329{
3330 const char *opname;
3331
3332 if (code == MODIFY_EXPR)
3333 opname = assignment_operator_name_info[code2].name;
3334 else
3335 opname = operator_name_info[code].name;
3336
3337 switch (code)
3338 {
3339 case COND_EXPR:
3340 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3341 problem, arg1, arg2, arg3);
3342 break;
3343
3344 case POSTINCREMENT_EXPR:
3345 case POSTDECREMENT_EXPR:
3346 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3347 break;
3348
3349 case ARRAY_REF:
3350 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3351 break;
3352
3353 case REALPART_EXPR:
3354 case IMAGPART_EXPR:
3355 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3356 break;
3357
3358 default:
3359 if (arg2)
3360 error ("%s for %<operator%s%> in %<%E %s %E%>",
3361 problem, opname, arg1, opname, arg2);
3362 else
3363 error ("%s for %<operator%s%> in %<%s%E%>",
3364 problem, opname, opname, arg1);
3365 break;
3366 }
3367}
3368
3369/* Return the implicit conversion sequence that could be used to
3370 convert E1 to E2 in [expr.cond]. */
3371
3372static conversion *
3373conditional_conversion (tree e1, tree e2)
3374{
3375 tree t1 = non_reference (TREE_TYPE (e1));
3376 tree t2 = non_reference (TREE_TYPE (e2));
3377 conversion *conv;
3378 bool good_base;
3379
3380 /* [expr.cond]
3381
3382 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3383 implicitly converted (clause _conv_) to the type "reference to
3384 T2", subject to the constraint that in the conversion the
3385 reference must bind directly (_dcl.init.ref_) to E1. */
3386 if (real_lvalue_p (e2))
3387 {
3388 conv = implicit_conversion (build_reference_type (t2),
3389 t1,
3390 e1,
3391 /*c_cast_p=*/false,
3392 LOOKUP_NO_TEMP_BIND);
3393 if (conv)
3394 return conv;
3395 }
3396
3397 /* [expr.cond]
3398
3399 If E1 and E2 have class type, and the underlying class types are
3400 the same or one is a base class of the other: E1 can be converted
3401 to match E2 if the class of T2 is the same type as, or a base
3402 class of, the class of T1, and the cv-qualification of T2 is the
3403 same cv-qualification as, or a greater cv-qualification than, the
3404 cv-qualification of T1. If the conversion is applied, E1 is
3405 changed to an rvalue of type T2 that still refers to the original
3406 source class object (or the appropriate subobject thereof). */
3407 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3408 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3409 {
3410 if (good_base && at_least_as_qualified_p (t2, t1))
3411 {
3412 conv = build_identity_conv (t1, e1);
3413 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3414 TYPE_MAIN_VARIANT (t2)))
3415 conv = build_conv (ck_base, t2, conv);
3416 else
3417 conv = build_conv (ck_rvalue, t2, conv);
3418 return conv;
3419 }
3420 else
3421 return NULL;
3422 }
3423 else
3424 /* [expr.cond]
3425
3426 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3427 converted to the type that expression E2 would have if E2 were
3428 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3429 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3430 LOOKUP_NORMAL);
3431}
3432
3433/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3434 arguments to the conditional expression. */
3435
3436tree
3437build_conditional_expr (tree arg1, tree arg2, tree arg3,
3438 tsubst_flags_t complain)
3439{
3440 tree arg2_type;
3441 tree arg3_type;
3442 tree result = NULL_TREE;
3443 tree result_type = NULL_TREE;
3444 bool lvalue_p = true;
3445 struct z_candidate *candidates = 0;
3446 struct z_candidate *cand;
3447 void *p;
3448
3449 /* As a G++ extension, the second argument to the conditional can be
3450 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3451 c'.) If the second operand is omitted, make sure it is
3452 calculated only once. */
3453 if (!arg2)
3454 {
3455 if (complain & tf_error)
3456 pedwarn (input_location, OPT_pedantic,
3457 "ISO C++ forbids omitting the middle term of a ?: expression");
3458
3459 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3460 if (real_lvalue_p (arg1))
3461 arg2 = arg1 = stabilize_reference (arg1);
3462 else
3463 arg2 = arg1 = save_expr (arg1);
3464 }
3465
3466 /* [expr.cond]
3467
3468 The first expression is implicitly converted to bool (clause
3469 _conv_). */
3470 arg1 = perform_implicit_conversion (boolean_type_node, arg1, complain);
3471
3472 /* If something has already gone wrong, just pass that fact up the
3473 tree. */
3474 if (error_operand_p (arg1)
3475 || error_operand_p (arg2)
3476 || error_operand_p (arg3))
3477 return error_mark_node;
3478
3479 /* [expr.cond]
3480
3481 If either the second or the third operand has type (possibly
3482 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3483 array-to-pointer (_conv.array_), and function-to-pointer
3484 (_conv.func_) standard conversions are performed on the second
3485 and third operands. */
3486 arg2_type = unlowered_expr_type (arg2);
3487 arg3_type = unlowered_expr_type (arg3);
3488 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3489 {
3490 /* Do the conversions. We don't these for `void' type arguments
3491 since it can't have any effect and since decay_conversion
3492 does not handle that case gracefully. */
3493 if (!VOID_TYPE_P (arg2_type))
3494 arg2 = decay_conversion (arg2);
3495 if (!VOID_TYPE_P (arg3_type))
3496 arg3 = decay_conversion (arg3);
3497 arg2_type = TREE_TYPE (arg2);
3498 arg3_type = TREE_TYPE (arg3);
3499
3500 /* [expr.cond]
3501
3502 One of the following shall hold:
3503
3504 --The second or the third operand (but not both) is a
3505 throw-expression (_except.throw_); the result is of the
3506 type of the other and is an rvalue.
3507
3508 --Both the second and the third operands have type void; the
3509 result is of type void and is an rvalue.
3510
3511 We must avoid calling force_rvalue for expressions of type
3512 "void" because it will complain that their value is being
3513 used. */
3514 if (TREE_CODE (arg2) == THROW_EXPR
3515 && TREE_CODE (arg3) != THROW_EXPR)
3516 {
3517 if (!VOID_TYPE_P (arg3_type))
3518 arg3 = force_rvalue (arg3);
3519 arg3_type = TREE_TYPE (arg3);
3520 result_type = arg3_type;
3521 }
3522 else if (TREE_CODE (arg2) != THROW_EXPR
3523 && TREE_CODE (arg3) == THROW_EXPR)
3524 {
3525 if (!VOID_TYPE_P (arg2_type))
3526 arg2 = force_rvalue (arg2);
3527 arg2_type = TREE_TYPE (arg2);
3528 result_type = arg2_type;
3529 }
3530 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3531 result_type = void_type_node;
3532 else
3533 {
3534 if (complain & tf_error)
3535 {
3536 if (VOID_TYPE_P (arg2_type))
3537 error ("second operand to the conditional operator "
3538 "is of type %<void%>, "
3539 "but the third operand is neither a throw-expression "
3540 "nor of type %<void%>");
3541 else
3542 error ("third operand to the conditional operator "
3543 "is of type %<void%>, "
3544 "but the second operand is neither a throw-expression "
3545 "nor of type %<void%>");
3546 }
3547 return error_mark_node;
3548 }
3549
3550 lvalue_p = false;
3551 goto valid_operands;
3552 }
3553 /* [expr.cond]
3554
3555 Otherwise, if the second and third operand have different types,
3556 and either has (possibly cv-qualified) class type, an attempt is
3557 made to convert each of those operands to the type of the other. */
3558 else if (!same_type_p (arg2_type, arg3_type)
3559 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3560 {
3561 conversion *conv2;
3562 conversion *conv3;
3563
3564 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3565 p = conversion_obstack_alloc (0);
3566
3567 conv2 = conditional_conversion (arg2, arg3);
3568 conv3 = conditional_conversion (arg3, arg2);
3569
3570 /* [expr.cond]
3571
3572 If both can be converted, or one can be converted but the
3573 conversion is ambiguous, the program is ill-formed. If
3574 neither can be converted, the operands are left unchanged and
3575 further checking is performed as described below. If exactly
3576 one conversion is possible, that conversion is applied to the
3577 chosen operand and the converted operand is used in place of
3578 the original operand for the remainder of this section. */
3579 if ((conv2 && !conv2->bad_p
3580 && conv3 && !conv3->bad_p)
3581 || (conv2 && conv2->kind == ck_ambig)
3582 || (conv3 && conv3->kind == ck_ambig))
3583 {
3584 error ("operands to ?: have different types %qT and %qT",
3585 arg2_type, arg3_type);
3586 result = error_mark_node;
3587 }
3588 else if (conv2 && (!conv2->bad_p || !conv3))
3589 {
3590 arg2 = convert_like (conv2, arg2, complain);
3591 arg2 = convert_from_reference (arg2);
3592 arg2_type = TREE_TYPE (arg2);
3593 /* Even if CONV2 is a valid conversion, the result of the
3594 conversion may be invalid. For example, if ARG3 has type
3595 "volatile X", and X does not have a copy constructor
3596 accepting a "volatile X&", then even if ARG2 can be
3597 converted to X, the conversion will fail. */
3598 if (error_operand_p (arg2))
3599 result = error_mark_node;
3600 }
3601 else if (conv3 && (!conv3->bad_p || !conv2))
3602 {
3603 arg3 = convert_like (conv3, arg3, complain);
3604 arg3 = convert_from_reference (arg3);
3605 arg3_type = TREE_TYPE (arg3);
3606 if (error_operand_p (arg3))
3607 result = error_mark_node;
3608 }
3609
3610 /* Free all the conversions we allocated. */
3611 obstack_free (&conversion_obstack, p);
3612
3613 if (result)
3614 return result;
3615
3616 /* If, after the conversion, both operands have class type,
3617 treat the cv-qualification of both operands as if it were the
3618 union of the cv-qualification of the operands.
3619
3620 The standard is not clear about what to do in this
3621 circumstance. For example, if the first operand has type
3622 "const X" and the second operand has a user-defined
3623 conversion to "volatile X", what is the type of the second
3624 operand after this step? Making it be "const X" (matching
3625 the first operand) seems wrong, as that discards the
3626 qualification without actually performing a copy. Leaving it
3627 as "volatile X" seems wrong as that will result in the
3628 conditional expression failing altogether, even though,
3629 according to this step, the one operand could be converted to
3630 the type of the other. */
3631 if ((conv2 || conv3)
3632 && CLASS_TYPE_P (arg2_type)
3633 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3634 arg2_type = arg3_type =
3635 cp_build_qualified_type (arg2_type,
3636 TYPE_QUALS (arg2_type)
3637 | TYPE_QUALS (arg3_type));
3638 }
3639
3640 /* [expr.cond]
3641
3642 If the second and third operands are lvalues and have the same
3643 type, the result is of that type and is an lvalue. */
3644 if (real_lvalue_p (arg2)
3645 && real_lvalue_p (arg3)
3646 && same_type_p (arg2_type, arg3_type))
3647 {
3648 result_type = arg2_type;
3649 goto valid_operands;
3650 }
3651
3652 /* [expr.cond]
3653
3654 Otherwise, the result is an rvalue. If the second and third
3655 operand do not have the same type, and either has (possibly
3656 cv-qualified) class type, overload resolution is used to
3657 determine the conversions (if any) to be applied to the operands
3658 (_over.match.oper_, _over.built_). */
3659 lvalue_p = false;
3660 if (!same_type_p (arg2_type, arg3_type)
3661 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3662 {
3663 tree args[3];
3664 conversion *conv;
3665 bool any_viable_p;
3666
3667 /* Rearrange the arguments so that add_builtin_candidate only has
3668 to know about two args. In build_builtin_candidates, the
3669 arguments are unscrambled. */
3670 args[0] = arg2;
3671 args[1] = arg3;
3672 args[2] = arg1;
3673 add_builtin_candidates (&candidates,
3674 COND_EXPR,
3675 NOP_EXPR,
3676 ansi_opname (COND_EXPR),
3677 args,
3678 LOOKUP_NORMAL);
3679
3680 /* [expr.cond]
3681
3682 If the overload resolution fails, the program is
3683 ill-formed. */
3684 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3685 if (!any_viable_p)
3686 {
3687 if (complain & tf_error)
3688 {
3689 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3690 print_z_candidates (candidates);
3691 }
3692 return error_mark_node;
3693 }
3694 cand = tourney (candidates);
3695 if (!cand)
3696 {
3697 if (complain & tf_error)
3698 {
3699 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3700 print_z_candidates (candidates);
3701 }
3702 return error_mark_node;
3703 }
3704
3705 /* [expr.cond]
3706
3707 Otherwise, the conversions thus determined are applied, and
3708 the converted operands are used in place of the original
3709 operands for the remainder of this section. */
3710 conv = cand->convs[0];
3711 arg1 = convert_like (conv, arg1, complain);
3712 conv = cand->convs[1];
3713 arg2 = convert_like (conv, arg2, complain);
3714 conv = cand->convs[2];
3715 arg3 = convert_like (conv, arg3, complain);
3716 }
3717
3718 /* [expr.cond]
3719
3720 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3721 and function-to-pointer (_conv.func_) standard conversions are
3722 performed on the second and third operands.
3723
3724 We need to force the lvalue-to-rvalue conversion here for class types,
3725 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3726 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3727 regions. */
3728
3729 arg2 = force_rvalue (arg2);
3730 if (!CLASS_TYPE_P (arg2_type))
3731 arg2_type = TREE_TYPE (arg2);
3732
3733 arg3 = force_rvalue (arg3);
3734 if (!CLASS_TYPE_P (arg2_type))
3735 arg3_type = TREE_TYPE (arg3);
3736
3737 if (arg2 == error_mark_node || arg3 == error_mark_node)
3738 return error_mark_node;
3739
3740 /* [expr.cond]
3741
3742 After those conversions, one of the following shall hold:
3743
3744 --The second and third operands have the same type; the result is of
3745 that type. */
3746 if (same_type_p (arg2_type, arg3_type))
3747 result_type = arg2_type;
3748 /* [expr.cond]
3749
3750 --The second and third operands have arithmetic or enumeration
3751 type; the usual arithmetic conversions are performed to bring
3752 them to a common type, and the result is of that type. */
3753 else if ((ARITHMETIC_TYPE_P (arg2_type)
3754 || UNSCOPED_ENUM_P (arg2_type))
3755 && (ARITHMETIC_TYPE_P (arg3_type)
3756 || UNSCOPED_ENUM_P (arg3_type)))
3757 {
3758 /* In this case, there is always a common type. */
3759 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3760 arg3_type);
3761
3762 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3763 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3764 {
3765 if (complain & tf_warning)
3766 warning (0,
3767 "enumeral mismatch in conditional expression: %qT vs %qT",
3768 arg2_type, arg3_type);
3769 }
3770 else if (extra_warnings
3771 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3772 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3773 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3774 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3775 {
3776 if (complain & tf_warning)
3777 warning (0,
3778 "enumeral and non-enumeral type in conditional expression");
3779 }
3780
3781 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3782 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3783 }
3784 /* [expr.cond]
3785
3786 --The second and third operands have pointer type, or one has
3787 pointer type and the other is a null pointer constant; pointer
3788 conversions (_conv.ptr_) and qualification conversions
3789 (_conv.qual_) are performed to bring them to their composite
3790 pointer type (_expr.rel_). The result is of the composite
3791 pointer type.
3792
3793 --The second and third operands have pointer to member type, or
3794 one has pointer to member type and the other is a null pointer
3795 constant; pointer to member conversions (_conv.mem_) and
3796 qualification conversions (_conv.qual_) are performed to bring
3797 them to a common type, whose cv-qualification shall match the
3798 cv-qualification of either the second or the third operand.
3799 The result is of the common type. */
3800 else if ((null_ptr_cst_p (arg2)
3801 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3802 || (null_ptr_cst_p (arg3)
3803 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3804 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3805 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3806 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3807 {
3808 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3809 arg3, "conditional expression",
3810 complain);
3811 if (result_type == error_mark_node)
3812 return error_mark_node;
3813 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3814 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3815 }
3816
3817 if (!result_type)
3818 {
3819 if (complain & tf_error)
3820 error ("operands to ?: have different types %qT and %qT",
3821 arg2_type, arg3_type);
3822 return error_mark_node;
3823 }
3824
3825 valid_operands:
3826 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3827 arg2, arg3));
3828 /* We can't use result_type below, as fold might have returned a
3829 throw_expr. */
3830
3831 if (!lvalue_p)
3832 {
3833 /* Expand both sides into the same slot, hopefully the target of
3834 the ?: expression. We used to check for TARGET_EXPRs here,
3835 but now we sometimes wrap them in NOP_EXPRs so the test would
3836 fail. */
3837 if (CLASS_TYPE_P (TREE_TYPE (result)))
3838 result = get_target_expr (result);
3839 /* If this expression is an rvalue, but might be mistaken for an
3840 lvalue, we must add a NON_LVALUE_EXPR. */
3841 result = rvalue (result);
3842 }
3843
3844 return result;
3845}
3846
3847/* OPERAND is an operand to an expression. Perform necessary steps
3848 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3849 returned. */
3850
3851static tree
3852prep_operand (tree operand)
3853{
3854 if (operand)
3855 {
3856 if (CLASS_TYPE_P (TREE_TYPE (operand))
3857 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3858 /* Make sure the template type is instantiated now. */
3859 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3860 }
3861
3862 return operand;
3863}
3864
3865/* Add each of the viable functions in FNS (a FUNCTION_DECL or
3866 OVERLOAD) to the CANDIDATES, returning an updated list of
3867 CANDIDATES. The ARGS are the arguments provided to the call,
3868 without any implicit object parameter. The EXPLICIT_TARGS are
3869 explicit template arguments provided. TEMPLATE_ONLY is true if
3870 only template functions should be considered. CONVERSION_PATH,
3871 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3872
3873static void
3874add_candidates (tree fns, tree args,
3875 tree explicit_targs, bool template_only,
3876 tree conversion_path, tree access_path,
3877 int flags,
3878 struct z_candidate **candidates)
3879{
3880 tree ctype;
3881 tree non_static_args;
3882
3883 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3884 /* Delay creating the implicit this parameter until it is needed. */
3885 non_static_args = NULL_TREE;
3886
3887 while (fns)
3888 {
3889 tree fn;
3890 tree fn_args;
3891
3892 fn = OVL_CURRENT (fns);
3893 /* Figure out which set of arguments to use. */
3894 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3895 {
3896 /* If this function is a non-static member, prepend the implicit
3897 object parameter. */
3898 if (!non_static_args)
3899 non_static_args = tree_cons (NULL_TREE,
3900 build_this (TREE_VALUE (args)),
3901 TREE_CHAIN (args));
3902 fn_args = non_static_args;
3903 }
3904 else
3905 /* Otherwise, just use the list of arguments provided. */
3906 fn_args = args;
3907
3908 if (TREE_CODE (fn) == TEMPLATE_DECL)
3909 add_template_candidate (candidates,
3910 fn,
3911 ctype,
3912 explicit_targs,
3913 fn_args,
3914 NULL_TREE,
3915 access_path,
3916 conversion_path,
3917 flags,
3918 DEDUCE_CALL);
3919 else if (!template_only)
3920 add_function_candidate (candidates,
3921 fn,
3922 ctype,
3923 fn_args,
3924 access_path,
3925 conversion_path,
3926 flags);
3927 fns = OVL_NEXT (fns);
3928 }
3929}
3930
3931tree
3932build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3933 bool *overloaded_p, tsubst_flags_t complain)
3934{